
    =wgJ                     "   d Z ddlZddlmZ ddlmZmZmZ ddlmZm	Z	m
Z
mZmZ ddlmZ  edg d      Z G d	 d
e      Z G d de      Z G d de      Z G d de      Z G d de      Z G d de      ZdZ G d de      Z G d de      Zy)zL
An implementation of an object that acts like a collection of on/off bits.
    N)array)bisect_leftbisect_rightinsort)integer_typesizipizip_longestnextxrange)bytes_for_bitsB(   r      r      r   r   r      r   r   r   r   r   r   r      r   r   r   r   r   r   r   r   r   r   r   r   r   r   r      r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r      r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r      r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r      c                       e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zy)DocIdSeta  Base class for a set of positive integers, implementing a subset of the
    built-in ``set`` type's interface with extra docid-related methods.

    This is a superclass for alternative set implementations to the built-in
    ``set`` which are more memory-efficient and specialized toward storing
    sorted lists of positive integers, though they will inevitably be slower
    than ``set`` for most operations since they're pure Python.
    c                 :    t        | |      D ]  \  }}||k7  s y yNFT)r   )selfotherabs       D/var/www/horilla/myenv/lib/python3.12/site-packages/whoosh/idsets.py__eq__zDocIdSet.__eq__%   s+    u% 	DAqAv	     c                 &    | j                  |       S N)r   r   r   s     r   __neq__zDocIdSet.__neq__+   s    ;;u%%%r    c                     t         r"   NotImplementedErrorr   s    r   __len__zDocIdSet.__len__.       !!r    c                     t         r"   r&   r(   s    r   __iter__zDocIdSet.__iter__1   r*   r    c                     t         r"   r&   r   is     r   __contains__zDocIdSet.__contains__4   r*   r    c                 $    | j                  |      S r"   )unionr#   s     r   __or__zDocIdSet.__or__7   s    zz%  r    c                 $    | j                  |      S r"   )intersectionr#   s     r   __and__zDocIdSet.__and__:   s      ''r    c                 $    | j                  |      S r"   )
differencer#   s     r   __sub__zDocIdSet.__sub__=   s    u%%r    c                     t         r"   r&   r(   s    r   copyzDocIdSet.copy@   r*   r    c                     t         r"   r&   r   ns     r   addzDocIdSet.addC   r*   r    c                     t         r"   r&   r=   s     r   discardzDocIdSet.discardF   r*   r    c                 :    | j                   }|D ]
  } ||        y r"   )r?   )r   r   r?   r/   s       r   updatezDocIdSet.updateI   s!    hh 	AF	r    c                 >    | D ]  }||vs| j                  |        y r"   rA   r   r   r>   s      r   intersection_updatezDocIdSet.intersection_updateN   s#     	 A~Q	 r    c                 4    |D ]  }| j                  |        y r"   rE   rF   s      r   difference_updatezDocIdSet.difference_updateS   s     	ALLO	r    c                 r    t        |      D ])  }|| v r| j                  |       | j                  |       + y)z}Updates the set in-place to contain numbers in the range
        ``[0 - size)`` except numbers that are in this set.
        N)r   rA   r?   )r   sizer/   s      r   invert_updatezDocIdSet.invert_updateW   s4    
  	ADyQ		r    c                 H    | j                         }|j                  |       |S r"   )r;   rG   r   r   cs      r   r5   zDocIdSet.intersectionb   s     IIK	e$r    c                 H    | j                         }|j                  |       |S r"   )r;   rC   rN   s      r   r2   zDocIdSet.uniong   s    IIK	r    c                 H    | j                         }|j                  |       |S r"   )r;   rI   rN   s      r   r8   zDocIdSet.differencel   s     IIK	E"r    c                 H    | j                         }|j                  |       |S r"   )r;   rL   )r   rK   rO   s      r   invertzDocIdSet.invertq   s    IIK	r    c                 \    | }|}t        |      t        |       k  r|| }}|D ]  }||v s y yr   len)r   r   r   r   nums        r   
isdisjointzDocIdSet.isdisjointv   sC    u:D	!$qA 	Cax	 r    c                     t         )zGReturns the previous integer in the set before ``i``, or None.
        r&   r.   s     r   beforezDocIdSet.before   
     "!r    c                     t         )zBReturns the next integer in the set after ``i``, or None.
        r&   r.   s     r   afterzDocIdSet.after   r[   r    c                     t         )z7Returns the first (lowest) integer in the set.
        r&   r(   s    r   firstzDocIdSet.first   r[   r    c                     t         )z7Returns the last (highest) integer in the set.
        r&   r(   s    r   lastzDocIdSet.last   r[   r    N)__name__
__module____qualname____doc__r   r$   r)   r,   r0   r3   r6   r9   r;   r?   rA   rC   rG   rI   rL   r5   r2   r8   rS   rX   rZ   r]   r_   ra    r    r   r   r      s    &"""!(&"""
 
	



"
"
"
"r    r   c                   R    e Zd Zd Zd Zd Zd Zd Zd ZeZ	d Z
d Zd	 Zd
 Zd Zy)
BaseBitSetc                     t         r"   r&   r(   s    r   
byte_countzBaseBitSet.byte_count   r*   r    c                     t         r"   r&   r.   s     r   	_get_bytezBaseBitSet._get_byte   r*   r    c                     t         r"   r&   r(   s    r   _iter_byteszBaseBitSet._iter_bytes   r*   r    c                 B    t        d | j                         D              S )Nc              3   .   K   | ]  }t         |     y wr"   )
_1SPERBYTE).0r   s     r   	<genexpr>z%BaseBitSet.__len__.<locals>.<genexpr>   s     =Q:a==s   )sumrn   r(   s    r   r)   zBaseBitSet.__len__   s    =$*:*:*<===r    c              #      K   d}| j                         D ]'  }t        d      D ]  }|d|z  z  s||z     |dz  }) y w)Nr   r   r   )rn   r   )r   basebyter/   s       r   r,   zBaseBitSet.__iter__   sU     $$& 	DAY #16?(N# AID		s
   ,A A c                 B    t        d | j                         D              S )Nc              3       K   | ]  }|  y wr"   rf   )rr   r>   s     r   rs   z)BaseBitSet.__nonzero__.<locals>.<genexpr>   s     111   )anyrn   r(   s    r   __nonzero__zBaseBitSet.__nonzero__   s    1d..0111r    c                 z    |dz  }|| j                         k\  ryt        | j                  |      d|dz  z  z        S )Nr   Fr   r   )rj   boolrl   r   r/   buckets      r   r0   zBaseBitSet.__contains__   s>    aT__&&DNN6*aAEl;<<r    c                 $    | j                  d      S N)r]   r(   s    r   r_   zBaseBitSet.first   s    zz"~r    c                 L    | j                  | j                         dz  dz         S )Nr   r   )rZ   rj   r(   s    r   ra   zBaseBitSet.last   s"    {{4??,q01455r    c                     | j                   }| j                         dz  }|dk  ry ||k\  r|dz
  }n|dz  }|dz  }|dk\  r= ||      }|s|dz  }|dz  dz   }|d|dz  z  z  r|S |dz  dk(  r|dz  }|dz  }|dk\  r=y Nr   r   r   r   rl   rj   r   r/   rl   rK   r   rw   s         r   rZ   zBaseBitSet.before   s    NN	 1$6$YqAFAa1fV$D!QJNqQU|$1uz!FA 1f r    c                     | j                   }| j                         dz  }||k\  ry |dk  rd}n|dz  }|dz  }||k  r: ||      }|s|dz  }|dz  }|d|dz  z  z  r|S |dz  }|dz  dk(  r|dz  }||k  r:y r   r   r   s         r   r]   zBaseBitSet.after   s    NN	 1$9UAFAa$hV$D!QJqQU|$FA1uz! $h r    N)rb   rc   rd   rj   rl   rn   r)   r,   r|   __bool__r0   r_   ra   rZ   r]   rf   r    r   rh   rh      s@    """
>2 H=64r    rh   c                   .    e Zd ZdZd Zd Zd Zd Zd Zy)OnDiskBitSetaV  A DocIdSet backed by an array of bits on disk.

    >>> st = RamStorage()
    >>> f = st.create_file("test.bin")
    >>> bs = BitSet([1, 10, 15, 7, 2])
    >>> bytecount = bs.to_disk(f)
    >>> f.close()
    >>> # ...
    >>> f = st.open_file("test.bin")
    >>> odbs = OnDiskBitSet(f, bytecount)
    >>> list(odbs)
    [1, 2, 7, 10, 15]
    c                 .    || _         || _        || _        y)a  
        :param dbfile: a :class:`~whoosh.filedb.structfile.StructFile` object
            to read from.
        :param basepos: the base position of the bytes in the given file.
        :param bytecount: the number of bytes to use for the bit array.
        N)_dbfile_basepos
_bytecount)r   dbfilebasepos	bytecounts       r   __init__zOnDiskBitSet.__init__  s     #r    c                 x    d| j                   j                  | j                  | j                  | j                  fz  S )Nz%s(%s, %d, %d))	__class__rb   r   r   r   r(   s    r   __repr__zOnDiskBitSet.__repr__  s6    4>>#:#:DKK#'==$..#B B 	Br    c                     | j                   S r"   )r   r(   s    r   rj   zOnDiskBitSet.byte_count  s    r    c                 R    | j                   j                  | j                  |z         S r"   )r   get_byter   r=   s     r   rl   zOnDiskBitSet._get_byte  s     ||$$T]]Q%677r    c              #      K   | j                   }|j                  | j                         t        | j                        D ]  }|j                           y wr"   )r   seekr   r   r   	read_byte)r   r   _s      r   rn   zOnDiskBitSet._iter_bytes  sF     DMM"( 	%A""$$	%s   AAN)	rb   rc   rd   re   r   r   rj   rl   rn   rf   r    r   r   r      s!    
$B8%r    r   c                       e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd Zd Zed        Zed        Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zy)BitSetzA DocIdSet backed by an array of bits. This can also be useful as a bit
    array (e.g. for a Bloom filter). It is much more memory efficient than a
    large built-in set of integers, but wastes memory for sparse sets.
    Nc                     |s+t        |t        t        t        t        f      rt        |      }t        |      }t        dd t        |      D              | _	        |r| j                  }|D ]
  } ||        yy)a$  
        :param maxsize: the maximum size of the bit array.
        :param source: an iterable of positive integers to add to this set.
        :param bits: an array of unsigned bytes ("B") to use as the underlying
            bit array. This is used by some of the object's methods.
        r   c              3       K   | ]  }d   yw)r   Nrf   )rr   r   s     r   rs   z"BitSet.__init__.<locals>.<genexpr>2  s     =a=rz   N)
isinstancelisttupleset	frozensetmaxr   r   r   bitsr?   )r   sourcerK   r   r?   rW   s         r   r   zBitSet.__init__&  sl     
6D%i+HIv;D"4(	#=6)+<=>	((C C r    c                 L    | j                   j                  dt        |       dS N())r   rb   r   r(   s    r   r   zBitSet.__repr__9  s    >>22DJ??r    c                 ,    t        | j                        S r"   )rV   r   r(   s    r   rj   zBitSet.byte_count<      499~r    c                      | j                   |   S r"   r   r=   s     r   rl   zBitSet._get_byte?      yy|r    c                 ,    t        | j                        S r"   )iterr   r(   s    r   rn   zBitSet._iter_bytesB      DIIr    c                     | j                   }t        | j                         dz
  }|dk\  r||   s|dz  }|dk\  r||   s| j                   |dz   d = y )Nr   r   r   rV   )r   r   ra   s      r   _trimzBitSet._trimE  sT    yy499~!aiT
AID aiT
IIdQhi r    c                     t        | j                        }t        |      }||kD  r"| j                  j                  d||z
  z         y ||k  r| j                  |dz   d = y y )N)r   r   )rV   r   r   extend)r   tosize	curlength	newlengths       r   _resizezBitSet._resizeL  s\    		N	"6*	y IITY%:;<"		)a-.) #r    c                 p    | j                   }|t        |      dz
  dz  z
  }|rd|z  dz
  }|d   |z  |d<   y y )Nr   r   r   r   r   )r   rK   r   spillmasks        r   _zero_extra_bitszBitSet._zero_extra_bitsT  sH    yyTQ!+,:>DBx$DH r    c                     |j                   }t        t        ||j                   d            D ]9  \  }\  }} |||      dz  }|t        |      k\  r|j	                  |       5|||<   ; |j                          |S )Nr   )	fillvalue   )r   	enumerater	   rV   appendr   )	r   objopr   objbitsr/   byte1byte2values	            r   _logiczBitSet._logic[  s~    ((!*<BC,E "F 	#A~uue$t+ECL u%"
	# 			
r    c                 b    |j                  | j                         t        | j                        S r"   )write_arrayr   rV   )r   r   s     r   to_diskzBitSet.to_diskh  s"    499%499~r    c                 6     |        }t        d|      |_        |S Nr   )r   r   )clsbsr   s      r   
from_byteszBitSet.from_bytesl  s    EsBr    c                 D    | j                  |j                  d|            S r   )r   
read_array)r   r   r   s      r   	from_diskzBitSet.from_diskr  s    ~~f//Y?@@r    c                 n    | j                         }t        dt        | j                              |_        |S r   )r   r   r   r   )r   r   s     r   r;   zBitSet.copyv  s)    NNsDO,r    c                 h    t        t        | j                              D ]  }d| j                  |<    y Nr   )r   rV   r   r.   s     r   clearzBitSet.clear{  s+    DII' 	ADIIaL	r    c                     |dz	  }|t        | j                        k\  r| j                  |dz          | j                  |xx   d|dz  z  z  cc<   y Nr   r   r   )rV   r   r   r   s      r   r?   z
BitSet.add  sG    aS^#LLQ		&Q1q5\)r    c                 J    |dz	  }| j                   |xx   d|dz  z   z  cc<   y r   r   r   s      r   rA   zBitSet.discard  s)    a		&qQU|_,r    c                     t        |t        t        t        t        f      r9t        |      }|dz  t        | j                        kD  r| j                  |       y y y )Nr   )	r   r   r   r   r   r   rV   r   r   )r   r   maxbits      r   _resize_to_otherzBitSet._resize_to_other  sH    edE3	:;ZF{S^+V$ , <r    c                 R    | j                  |       t        j                  | |       y r"   )r   r   rC   )r   iterables     r   rC   zBitSet.update  s    h'h'r    c                     t        |t              r!| j                  | t        j                  |      S | j
                  }| D ]  }||vs ||        y r"   )r   r   r   operatorr6   rA   r   r   rA   r>   s       r   rG   zBitSet.intersection_update  sK    eV$;;tX%5%5u==,, 	A~
	r    c                     t        |t              r| j                  | d |      S | j                  }|D ]
  } ||        y )Nc                     | | z  S r"   rf   xys     r   <lambda>z*BitSet.difference_update.<locals>.<lambda>  s    !qb& r    )r   r   r   rA   r   s       r   rI   zBitSet.difference_update  s?    eV$;;t%8%@@,, 	AAJ	r    c                     | j                   }t        t        |            D ]  }||    dz  ||<    | j                  |       y )Nr   )r   r   rV   r   )r   rK   r   r/   s       r   rL   zBitSet.invert_update  sD    yyD	" 	&AAwhoDG	&d#r    c                     t        |t              r/| j                  | j                         t        j
                  |      S | j                         }|j                  |       |S r"   )r   r   r   r;   r   r3   rC   )r   r   r   s      r   r2   zBitSet.union  sD    eV$;;tyy{HOOUCCIIK	r    c                     t        t              r/| j                  | j                         t        j
                        S t        fd| D              S )Nc              3   ,   K   | ]  }|v s|  y wr"   rf   rr   r>   r   s     r   rs   z&BitSet.intersection.<locals>.<genexpr>  s     <Aea<   	r   )r   r   r   r;   r   r6   r#   s    `r   r5   zBitSet.intersection  s=    eV$;;tyy{H,<,<eDD<<==r    c                     t        t              r"| j                  | j                         d       S t        fd| D              S )Nc                     | | z  S r"   rf   r   s     r   r   z#BitSet.difference.<locals>.<lambda>  s    aR r    c              3   ,   K   | ]  }|vs|  y wr"   rf   r   s     r   rs   z$BitSet.difference.<locals>.<genexpr>  s     @A%a@r   r   )r   r   r   r;   r#   s    `r   r8   zBitSet.difference  s8    eV$;;tyy{,?GG@@AAr    r   )rb   rc   rd   re   r   r   rj   rl   rn   r   r   r   r   r   classmethodr   r   r;   r   r?   rA   r   rC   rG   rI   rL   r2   r5   r8   rf   r    r   r   r      s    
&@!*'  
 A A
*-%($>
Br    r   c                       e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
e
Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zy)SortedIntSetz5A DocIdSet backed by a sorted array of integers.
    Nc                 z    |r"t        |t        |            | _        || _        y t        |      | _        || _        y r"   )r   sorteddatatypecode)r   r   r   s      r   r   zSortedIntSet.__init__  s4    hv7DI ! hDI r    c                 d    t               }t        | j                  | j                        |_        |S r"   )r   r   r   r   )r   siss     r   r;   zSortedIntSet.copy  s$    n		2
r    c                 Z    t        | j                        | j                  j                  z  S r"   )rV   r   itemsizer(   s    r   rK   zSortedIntSet.size  s    499~		 2 222r    c                 N    | j                   j                  d| j                  dS r   )r   rb   r   r(   s    r   r   zSortedIntSet.__repr__  s    >>22DII>>r    c                 ,    t        | j                        S r"   )rV   r   r(   s    r   r)   zSortedIntSet.__len__  r   r    c                 ,    t        | j                        S r"   )r   r   r(   s    r   r,   zSortedIntSet.__iter__  r   r    c                 ,    t        | j                        S r"   )r~   r   r(   s    r   r|   zSortedIntSet.__nonzero__  r   r    c                     | j                   }|r||d   k  s||d   kD  ryt        ||      }|t        |      k(  ry||   |k(  S )Nr   r   F)r   r   rV   r   r/   r   poss       r   r0   zSortedIntSet.__contains__  sN    yyq47{a$r(l$"#d)CyA~r    c                 *   | j                   }|r||d   kD  r|j                  |       y |d   }|d   }||k(  s||k(  ry ||kD  r|j                  |       y ||k  r|j                  d|       y t        ||      }||   |k7  r|j                  ||       y y Nr   r   )r   r   insertr   )r   r/   r   mnmxr  s         r   r?   zSortedIntSet.add  s    yyq48|KKNaBbBBw!r'RARAq!!$*9>KKQ' "r    c                 h    | j                   }t        ||      }||   |k(  r|j                  |       y y r"   )r   r   popr
  s       r   rA   zSortedIntSet.discard  s2    yy$"9>HHSM r    c                 8    t        | j                        | _        y r"   r   r   r   r(   s    r   r   zSortedIntSet.clear  s    $--(	r    c                 N    t        | j                  fd| D              | _        y )Nc              3   ,   K   | ]  }|v s|  y wr"   rf   rr   rW   r   s     r   rs   z3SortedIntSet.intersection_update.<locals>.<genexpr>  s     )N##)Nr   r  r#   s    `r   rG   z SortedIntSet.intersection_update   s    $--)N)NO	r    c                 N    t        | j                  fd| D              | _        y )Nc              3   ,   K   | ]  }|vs|  y wr"   rf   r  s     r   rs   z1SortedIntSet.difference_update.<locals>.<genexpr>  s     C3#U2B3Cr   r  r#   s    `r   rI   zSortedIntSet.difference_update  s    $--C$CE	r    c                 ,    t        fd| D              S )Nc              3   ,   K   | ]  }|v s|  y wr"   rf   r  s     r   rs   z,SortedIntSet.intersection.<locals>.<genexpr>  s     ASC5LSAr   r   r#   s    `r   r5   zSortedIntSet.intersection  s    ADABBr    c                 ,    t        fd| D              S )Nc              3   ,   K   | ]  }|vs|  y wr"   rf   r  s     r   rs   z*SortedIntSet.difference.<locals>.<genexpr>  s     ESCu4DSEr   r  r#   s    `r   r8   zSortedIntSet.difference
  s    EDEFFr    c                      | j                   d   S r   r   r(   s    r   r_   zSortedIntSet.first  r   r    c                      | j                   d   S r   r   r(   s    r   ra   zSortedIntSet.last  s    yy}r    c                 N    | j                   }t        ||      }|dk  ry ||dz
     S Nr   )r   r   r
  s       r   rZ   zSortedIntSet.before  s/    yy$"7a= r    c                 l    | j                   }|r||d   k\  ry ||d   k  r|d   S t        ||      }||   S r  )r   r   r
  s       r   r]   zSortedIntSet.after  sE    yyqDH}a[7N4#Cyr    )NI)rb   rc   rd   re   r   r;   rK   r   r)   r,   r|   r   r0   r?   rA   r   rG   rI   r5   r8   r_   ra   rZ   r]   rf   r    r   r   r     sq    !
3? H($)PECG!r    r   c                   @    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zy
)ReverseIdSetz
    Wraps a DocIdSet object and reverses its semantics, so docs in the wrapped
    set are not in this set, and vice-versa.
    c                      || _         || _        y)zt
        :param idset: the DocIdSet object to wrap.
        :param limit: the highest possible ID plus one.
        N)idsetlimit)r   r)  r*  s      r   r   zReverseIdSet.__init__,  s     

r    c                 F    | j                   t        | j                        z
  S r"   )r*  rV   r)  r(   s    r   r)   zReverseIdSet.__len__5  s    zzC

O++r    c                     || j                   vS r"   )r)  r.   s     r   r0   zReverseIdSet.__contains__8  s    

""r    c              #      K   t        | j                        }	 t        |      }t	        | j
                        D ]  }||k(  r	 t        |      }|  y # t        $ r d}Y >w xY w# t        $ r d}Y :w xY wwr   )r   r)  r
   StopIterationr   r*  )r   idsnxr/   s       r   r,   zReverseIdSet.__iter__;  s     4::	cB 

# 	ABwcB 	  	B	 % BsK   A7A A7A&A7A# A7"A##A7&A41A73A44A7c                 :    | j                   j                  |       y r"   )r)  rA   r=   s     r   r?   zReverseIdSet.addK  s    

1r    c                 :    | j                   j                  |       y r"   )r)  r?   r=   s     r   rA   zReverseIdSet.discardN  s    

qr    c                     | D ]  }|c S  y r"   rf   r.   s     r   r_   zReverseIdSet.firstQ  s     	AH	r    c                     | j                   }| j                  dz
  }|j                         |dz
  k  r|S t        |dd      D ]
  }||vs|c S  y )Nr   r   )r)  r*  ra   r   )r   r)  maxidr/   s       r   ra   zReverseIdSet.lastU  sS    



Q::<%!)#Lr2& 	A~	r    N)rb   rc   rd   re   r   r)   r0   r,   r?   rA   r_   ra   rf   r    r   r'  r'  &  s/    
,# r    r'     c                   @    e Zd ZdZdZddZd Zd Zd Zd Z	d	 Z
d
 Zy)RoaringIdSetz
    Separates IDs into ranges of 2^16 bits, and stores each range in the most
    efficient type of doc set, either a BitSet (if the range has >= 2^12 IDs)
    or a sorted ID set of 16-bit shorts.
    r6  Nc                 :    g | _         |r| j                  |       y y r"   )idsetsrC   )r   r   s     r   r   zRoaringIdSet.__init__k  s    KK r    c                 T    | j                   syt        d | j                   D              S )Nr   c              3   2   K   | ]  }t        |        y wr"   rU   rr   r)  s     r   rs   z'RoaringIdSet.__len__.<locals>.<genexpr>t       7%3u:7   )r:  rt   r(   s    r   r)   zRoaringIdSet.__len__p  s!    {{74;;777r    c                 l    |dz	  }|t        | j                        k\  ry||dz  z
  | j                  |   v S )N   F)rV   r:  )r   r>   r   s      r   r0   zRoaringIdSet.__contains__v  s<    bS%%Vr\"t{{6':::r    c              #   Z   K   | j                   D ]  \  }}|dz  }|D ]	  }||z      y w)NrA  )r:  )r   r/   r)  floorr>   s        r   r,   zRoaringIdSet.__iter__|  s>      	 HAuGE  ai 	 s   )+c                    |dz	  }|dz  }|t        | j                        k\  rQ| j                  j                  t        t        | j                        |dz         D cg c]  }t	                c}       | j                  |   }|||fS c c}w )NrA  r   )rV   r:  r   r   r   )r   r>   r   rC  r   r)  s         r   _findzRoaringIdSet._find  s    bRS%%KK#)#dkk*:FQJ#G I1  I JF#ue## Is   Bc                     | j                  |      \  }}}t        |      }|j                  ||z
         |t        cxk  rt        |      k  rn y t	        |      | j
                  |<   y y r"   )rE  rV   r?   ROARING_CUTOFFr   r:  r   r>   r   rC  r)  oldlens         r   r?   zRoaringIdSet.add  sW    #zz!}uU		!e)^0c%j0"(-DKK 1r    c                     | j                  |      \  }}}t        |      }|j                  ||z
         |t        cxkD  rt        |      k\  rn y t	        |      | j
                  |<   y y r"   )rE  rV   rA   rG  r   r:  rH  s         r   rA   zRoaringIdSet.discard  sX    #zz!}uUa%i N0c%j0".u"5DKK 1r    r"   )rb   rc   rd   re   cutoffr   r)   r0   r,   rE  r?   rA   rf   r    r   r8  r8  b  s1     F 
8; $06r    r8  c                   4    e Zd ZdZd Zd Zd Zd Zd Zd Z	y)	
MultiIdSetzfWraps multiple SERIAL sub-DocIdSet objects and presents them as an
    aggregated, read-only set.
    c                 R    t        |      t        |      k(  sJ || _        || _        y)z
        :param idsets: a list of DocIdSet objects.
        :param offsets: a list of offsets corresponding to the DocIdSet objects
            in ``idsets``.
        N)rV   r:  offsets)r   r:  rO  s      r   r   zMultiIdSet.__init__  s(     6{c'l***r    c                 r    | j                   }t        t        ||      t        | j                         dz
        S r#  )rO  r   r   rV   )r   r>   rO  s      r   _document_setzMultiIdSet._document_set  s-    ,,;w*C,=,ABBr    c                 j    | j                  |      }| j                  |   }| j                  |   ||z
  fS r"   )rQ  rO  r:  )r   r>   setnumoffsets       r   _set_and_docnumzMultiIdSet._set_and_docnum  s8    ##A&f%{{6"AJ..r    c                 :    t        d | j                  D              S )Nc              3   2   K   | ]  }t        |        y wr"   rU   r=  s     r   rs   z%MultiIdSet.__len__.<locals>.<genexpr>  r>  r?  )rt   r:  r(   s    r   r)   zMultiIdSet.__len__  s    74;;777r    c              #   x   K   t        | j                  | j                        D ]  \  }}|D ]	  }||z      y wr"   )r   r:  rO  )r   r)  rT  docnums       r   r,   zMultiIdSet.__iter__  sA     !$++t||< 	&ME6 &vo%&	&s   8:c                 2    | j                  |      \  }}||v S r"   )rU  )r   itemr)  r>   s       r   r0   zMultiIdSet.__contains__  s     ''-qEzr    N)
rb   rc   rd   re   r   rQ  rU  r)   r,   r0   rf   r    r   rM  rM    s&    	C/
8&
r    rM  )re   r   r   bisectr   r   r   whoosh.compatr   r   r	   r
   r   whoosh.util.numericr   rq   objectr   rh   r   r   r   r'  rG  r8  rM  rf   r    r   <module>r`     s      4 4 I I . 3 
 

w"v w"t\ \~)%: )%XWBZ WBti8 iX78 7r 568 56p# #r    