=wgqdZddlmZmZmZddlmZmZmZm Z m Z ddl m Z Gdde ZdZGdd ej ZGd d eZGd d eZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGd d!eZy")#as This module contains Query objects that deal with "spans". Span queries allow for positional constraints on matching documents. For example, the :class:`whoosh.spans.SpanNear` query matches documents where one term occurs near another. Because you can nest span queries, and wrap them around almost any non-span query, you can create very complex constraints. For example, to find documents containing "whoosh" at most 5 positions before "library" in the "text" field:: from whoosh import query, spans t1 = query.Term("text", "whoosh") t2 = query.Term("text", "library") q = spans.SpanNear(t1, t2, slop=5) )mcorewrappersbinary)QueryAndAndMaybeOrTerm)make_binary_treeceZdZdZ ddZdZdZdZdZdZ d Z e d Z d Z d Zd ZdZdZdZdZdZy)Spanstartend startcharendcharboostNc`||}||ksJ||_||_||_||_||_yNr)selfrrrrrs I/var/www/horilla/myenv/lib/python3.12/site-packages/whoosh/query/spans.py__init__z Span.__init__8s; ;C|| "  c|j |j1d|j|j|j|jfzSd|j|jfzS)Nz <%d-%d %d:%d>z<%d-%d>)rrrrrs r__repr__z Span.__repr__CsZ >> %)A"djj$((DNN&*ll&44 4 DHH55 5rc|j|jk(xrO|j|jk(xr4|j|jk(xr|j|jk(Sr)rrrrrspans r__eq__z Span.__eq__JsX djj(1HH(1NNdnn41LLDLL0 2rcj|j|jk7xs|j|jk7Srrrrs r__ne__z Span.__ne__Ps'zzTZZ'?488txx+??rc4|j|jkSrrrs r__lt__z Span.__lt__SzzDJJ&&rc4|j|jkDSrr%rs r__gt__z Span.__gt__Vr'rcDt|j|jfSr)hashrrrs r__hash__z Span.__hash__YsTZZ*++rcnd}|t|dz kr||}|dz}|t|krr||}|j|jdzkDrnP|j|s|j |r|j |}|||<||=n|dz }|t|krr|dz }|t|dz kr|S)zMerges overlapping and touches spans in the given list of spans. Note that this modifies the original list. >>> spans = [Span(1,2), Span(3)] >>> Span.merge(spans) >>> spans [<1-3>] r)lenrrtouchesoverlapsto)clsspansiherejtheres rmergez Span.merge\s #e*q. 8DAAc%j.a;;A-<<&$--*>775>D#E!HaFAc%j. FA#e*q.  rc|j |j}n9|j |j}n t|j|j}|j |j}n9|j |j}n t|j|j}t|j|j}t|j |j }|j ||||Sr)rminrmaxrr __class__)rrmincharmaxcharminposmaxposs rr2zSpan.toys >> !nnG ^^ #nnG$..$..9G << llG \\ !llG$,, 5GTZZ,TXXtxx(~~ffgw??rc|j|jk\xr|j|jkxs|j|jk\xr|j|jkxsj|j|jk\xr|j|jkxs4|j|jk\xr|j|jkSrr"rs rr1z Span.overlapsstzz)DdjjDHH.DEHH *Ctxx488/CEJJ$**,Gtxx1GEHH *Ctxx488/C Frcj|j|jkxr|j|jkDSrr"rs r surroundszSpan.surroundss'zzDJJ&>488dhh+>>rcj|j|jk\xr|j|jkSrr"rs r is_withinzSpan.is_withins'zzTZZ'@DHH,@@rc4|j|jkSr)rrrs r is_beforezSpan.is_beforesxx$**$$rc4|j|jkDSrr"rs ris_afterz Span.is_afterszzDHH$$rcv|j|jdzk(xs|j|jdz k(SNr.r"rs rr0z Span.touchess/zzTXX\)GTXXa-GGrc|j|ry|j|r|j|jz S|j|jz S)Nr)r1rHrrrs r distance_tozSpan.distance_tosC ==  ^^D !::( (::( (r)NNNg?)__name__ __module__ __qualname__ __slots__rrr r#r&r)r, classmethodr9r2r1rDrFrHrJr0rNrrr r 5sqAI@D 62 @'',8@$F ?A%%H)rr czd}t|}||kr(||zdz}||j|kr|dz}n|}||kr(|S)Nrr.)r/r)r4rlohimids r bisect_spansrZsT B UB r'Bw1n :  e #qBB r' IrcLeZdZdZfdZdZdZdZdZdZ dZ d Z xZ S) SpanWrappingMatcheracAn abstract matcher class that wraps a "regular" matcher. This matcher uses the sub-matcher's matching logic, but only matches documents that have matching spans, i.e. where ``_get_spans()`` returns a non-empty list. Subclasses must implement the ``_get_spans()`` method, which returns a list of valid spans for the current document. c|tt| |d|_|j r|j yyr)superr\r_spans is_active _find_next)rchildr=s rrzSpanWrappingMatcher.__init__s3 !41%8 >>  OO  rcz|j|jj}|j|_|Sr)r=rbcopyr_rms rrdzSpanWrappingMatcher.copys+ NN4::??, -;;rc$|j|Srr=rnewchilds r _replacementz SpanWrappingMatcher._replacements~~h''rc&|jsy|j}d}|j}|jrJ|sH|jxs|}|jsy|j}|jr|sH||_|SNFT)r`rb _get_spansnextr_)rrbrr4s rrazSpanWrappingMatcher._find_nextsz~~   !oo !A??$OO%E oo  rc|jSr)r_rs rr4zSpanWrappingMatcher.spanss {{rcX|jj|jyr)rbrorars rrozSpanWrappingMatcher.nexts  rcZ|jj||jyr)rbskip_tora)rids rrtzSpanWrappingMatcher.skip_tos 2 rc#K|jrD|jr|j|j|jrCyywr)r`r4rurors rall_idszSpanWrappingMatcher.all_idss9nnzz|ggi IIKnns AAA) rOrPrQ__doc__rrdrkrar4rortrw __classcell__rhs@rr\r\s0  ("rr\c eZdZdZdZddZy) SpanBiMatcherc|j|jj|jjSr)r=ardbrs rrdzSpanBiMatcher.copys'~~dffkkmTVV[[];;rcdt|jj|jjzSrL)r<r}depthr~rs rrzSpanBiMatcher.depths(3tvv||~tvv||~666rcN|jstjS|Srr`r NullMatcherr minqualitys rreplacezSpanBiMatcher.replaces ~~$$& & rNr)rOrPrQrdrrrTrrr{r{s<7rr{c6eZdZdZd dZdZdZdZdZdZ y) SpanQueryaAbstract base class for span-based queries. Each span query type wraps a "regular" query that implements the basic document-matching functionality (for example, SpanNear wraps an And query, because SpanNear requires that the two sub-queries occur in the same documents. The wrapped query is stored in the ``q`` attribute. Subclasses usually only need to implement the initializer to set the wrapped query, and ``matcher()`` to return a span-aware matcher object. Nc:|jj||Sr)qmatcher)rscontexts r_submzSpanQuery._subm svv~~a))rcN|jjd|jdS)N())r=rOrrs rrzSpanQuery.__repr__s>>22DFF;;rcp|xr3|j|juxr|j|jk(Sr)r=rrothers rr zSpanQuery.__eq__s3&$..EOO;&FFegg% 'rclt|jjt|jz Sr)r+r=rOrrs rr,zSpanQuery.__hash__s$DNN++,tDFF|;;rcyrrTrs rfieldzSpanQuery.fieldrcy)NTrTrs r needs_spanszSpanQuery.needs_spansrrr) rOrPrQrxrrr r,rrrTrrrrs%*<'<rrceZdZdZdZdZy) WrappingSpancyNFrTrs ris_leafzWrappingSpan.is_leaf!rc\|j||j|jSN)limitr=rrrfns rapplyzWrappingSpan.apply$s!~~bj ~;;rc6|jjSr)rrrs rrzWrappingSpan.field'svv||~rN)rOrPrQrrrrTrrrr s<rrcBeZdZdZd dZdZdZd dZGddeZ y) SpanFirstzMatches spans that end within the first N positions. This lets you for example only match terms near the beginning of the document. c ||_||_y)z :param q: the query to match. :param limit: the query must match within this position at the start of a document. The default is ``0``, which means the query must match at the first position. N)rr)rrrs rrzSpanFirst.__init__0s rc|xrN|j|juxr4|j|jk(xr|j|jk(Srrrs rr zSpanFirst.__eq__;sLD$..EOO;DFFegg%D*.** *C ErcXt|jt|jz Sr)r+rrrs rr,zSpanFirst.__hash__?sDFF|d4::...rNch|j||}tj||jSr)rrSpanFirstMatcherr)rsearcherrrfs rrzSpanFirst.matcherBs, JJx )))!4::)>>rc2eZdZdfd ZdZdZdZxZS)SpanFirst.SpanFirstMatchercN||_ttj||yr)rr^rrr)rrbrr=s rrz#SpanFirst.SpanFirstMatcher.__init__GsDJ ),,d >$**//"34::>F Frc<|j||jSr)r=rris rrkz'SpanFirst.SpanFirstMatcher._replacementNs>>($**>= =rc|jjDcgc]}|j|jkr|c}Scc}wr)rbr4rrrs rrnz%SpanFirst.SpanFirstMatcher._get_spansQs>%)ZZ%5%5%7/Txx4::-/ //s"Ar)rOrPrQrrdrkrnryrhs@rrrFs D G > /rrrr) rOrPrQrxrr r,rr\rrTrrrr+s) E/? /. /rrcfeZdZdZd dZdZdZdZdZdZ dd Z e dd Z Gd d e Zy)SpanNearap Note: for new code, use :class:`SpanNear2` instead of this class. SpanNear2 takes a list of sub-queries instead of requiring you to create a binary tree of query objects. Matches queries that occur near each other. By default, only matches queries that occur right next to each other (slop=1) and in order (ordered=True). For example, to find documents where "whoosh" occurs next to "library" in the "text" field:: from whoosh import query, spans t1 = query.Term("text", "whoosh") t2 = query.Term("text", "library") q = spans.SpanNear(t1, t2) To find documents where "whoosh" occurs at most 5 positions before "library":: q = spans.SpanNear(t1, t2, slop=5) To find documents where "whoosh" occurs at most 5 positions before or after "library":: q = spans.SpanNear(t1, t2, slop=5, ordered=False) You can use the ``phrase()`` class method to create a tree of SpanNear queries to match a list of terms:: q = spans.SpanNear.phrase("text", ["whoosh", "search", "library"], slop=2) cnt||g|_||_||_||_||_||_y)a :param a: the first query to match. :param b: the second query that must occur within "slop" positions of the first query. :param slop: the number of positions within which the queries must occur. Default is 1, meaning the queries must occur right next to each other. :param ordered: whether a must occur before b. Default is True. :pram mindist: the minimum distance allowed between the queries. N)rrr}r~sloporderedmindist)rr}r~rrrs rrzSpanNear.__init__ys6aV   rcd|jj|j|j|j|j fzSNz'%s(%r, slop=%d, ordered=%s, mindist=%d))r=rOrrrrrs rrzSpanNear.__repr__s:9>>**DFFDIIt||<<!! "rc|xr|j|jk(xrj|j|jk(xrO|j|jk(xr4|j|jk(xr|j|jk(Sr)r=rrrrrs rr zSpanNear.__eq__st2$..EOO;2FFegg%2*.))uzz*A2LLEMM12LLEMM1 3rct|jt|jz t|jz t|jz t|j z Sr)r+r}r~rrrrs rr,zSpanNear.__hash__sNTVV tDFF|+d499o=t||$%'+DLL'9: ;rcyrrTrs rrzSpanNear.is_leafrrc|j||j||j|j|j|j SN)rrr)r=r}r~rrrrs rrzSpanNear.applysA~~bj"TVV*499&*llDLLJ JrNc|jj||}|jj||}tj |||j |j |jSr)r}rr~rSpanNearMatcherrrrrrrmambs rrzSpanNear.matchersZ VV^^Hg . VV^^Hg .''BTYY04 04 (> >rc\|Dcgc]}t||}}t||||Scc}w)aReturns a tree of SpanNear queries to match a list of terms. This class method is a convenience for constructing a phrase query using a binary tree of SpanNear queries:: SpanNear.phrase("content", ["alfa", "bravo", "charlie", "delta"]) :param fieldname: the name of the field to search in. :param words: a sequence of texts to search for. :param slop: the number of positions within which the terms must occur. Default is 1, meaning the terms must occur right next to each other. :param ordered: whether the terms must occur in order. Default is True. )rr)r r )r3 fieldnamewordsrrwordtermss rphrasezSpanNear.phrases4"4994i&99UwGG:s)c4eZdZdfd ZdZddZdZxZS)SpanNear.SpanNearMatcherc||_||_||_||_||_t j ||}ttj|+|yr) r}r~rrrrIntersectionMatcherr^rrr)rr}r~rrrisectr=s rrz!SpanNear.SpanNearMatcher.__init__sMDFDFDI"DL"DL..q!4E (**D :5 Arc|j|jj|jj|j|j |j Sr)r=r}rdr~rrrrs rrdzSpanNear.SpanNearMatcher.copysE>>$&&++-TYY*.,, "N NrcN|jstjS|Srrrs rrz SpanNear.SpanNearMatcher.replace >>#((**Krc |j}|j}|j}t}|jj }|j j D]}|D]}|j|j|z ks|r|j|jkDr;|j|j|zkDr^|j|}||cxkr|ksvny|j|j|t|Sr) rrrsetr~r4r}rrrNaddr2sorted) rrrrr4bspansaspanbspandists rrnz#SpanNear.SpanNearMatcher._get_spanss99DllGllGEEVV\\^F 3#3E EKK$$66# ekk(A!{{UYY%55!,,U3D$.$. %((5/23 3$%= rr.Tr.rrOrPrQrrdrrnryrhs@rrrs B N   !rrrr)r.T)rOrPrQrxrrr r,rrrrSrr\rrTrrrrVsO D&" 3 ;J>HH&-!--!rrcleZdZdZddZdZdZdZdZdZ dZ d Z d Z d Z dd ZGddeZy ) SpanNear2a Matches queries that occur near each other. By default, only matches queries that occur right next to each other (slop=1) and in order (ordered=True). New code should use this query type instead of :class:`SpanNear`. (Unlike :class:`SpanNear`, this query takes a list of subqueries instead of requiring you to build a binary tree of query objects. This query should also be slightly faster due to less overhead.) For example, to find documents where "whoosh" occurs next to "library" in the "text" field:: from whoosh import query, spans t1 = query.Term("text", "whoosh") t2 = query.Term("text", "library") q = spans.SpanNear2([t1, t2]) To find documents where "whoosh" occurs at most 5 positions before "library":: q = spans.SpanNear2([t1, t2], slop=5) To find documents where "whoosh" occurs at most 5 positions before or after "library":: q = spans.SpanNear2(t1, t2, slop=5, ordered=False) c<||_||_||_||_y)a :param qs: a sequence of sub-queries to match. :param slop: the number of positions within which the queries must occur. Default is 1, meaning the queries must occur right next to each other. :param ordered: whether a must occur before b. Default is True. :pram mindist: the minimum distance allowed between the queries. N)qsrrr)rrrrrs rrzSpanNear2.__init__ s    rcd|jj|j|j|j|j fzSr)r=rOrrrrrs rrzSpanNear2.__repr__s:9>>**DGGTYY <<!! "rc|xr|j|jk(xrj|j|jk(xrO|j|jk(xr4|j|jk(xr|j|jk(Srr=rrrrrs rr zSpanNear2.__eq__ st2$..EOO;2GGuxx'2,0II,C2LLEMM12LLEMM1 3rct|jt|jz t|jz }|jD]}|t|z}|Sr)r+rrrr)rhrs rr,zSpanNear2.__hash__&sP Od4<<0 04 3E E A aLA rc@tj|jSr)rrrrs r _and_queryzSpanNear2._and_query,suuTWW~rc@|jj|Sr)r estimate_sizerixreaders rrzSpanNear2.estimate_size/s ..x88rc@|jj|Sr)restimate_min_sizers rrzSpanNear2.estimate_min_size2s 228<>TWW"=1668"=DII*.,, "N N"=sAcN|jstjS|Srrrs rrz"SpanNear2.SpanNear2Matcher.replaceQrrc@|j}|j}|j}|j}|dj }d}|t |kr9|r6||j }t }|D]} |r | j} ntd| j|z } t|| } | t |ksF|| } | dz } | j| j|z ks|r| j| jkDrQ| j| j|zkDr| j| } || cxkr|kr#nn |j| j| | t |krt|}|dz }|t |kr|r6|t |k(r|SgS)Nrr.)rrrrr4r/rrr<rZrrNrr2r)rrrrraspansr5rr4rrr7rrs rrnz%SpanNear2.SpanNear2Matcher._get_spansWsz99DllGllGBU[[]FAc"g+&A#7E %  #Au{{T'9 :$VU3Ac&k/ &q Q!II d(:: 'EKK%++,E% ;;T)99" %007"d2d2!IIehhuo6%c&k/78 QAc"g+&DCG|  rrrrrhs@rrrDs D N  - rrrr)rOrPrQrxrrr r,rrrrrrrr\rrTrrrrsN< " 3  9=J; @.@rrc@eZdZdZdZdZdZd dZGddeZ y) SpanOrzMatches documents that match any of a list of sub-queries. Unlike query.Or, this class merges together matching spans from the different sub-queries when they overlap. c2t||_||_y)z; :param subqs: a list of queries to match. N)r rsubqs)rrs rrzSpanOr.__init__s E rcyrrTrs rrzSpanOr.is_leafrrcj|j|jDcgc] }|| c}Scc}wr)r=r)rrsqs rrz SpanOr.applys'~~ ;"r"v;<<;s0Nc|jDcgc]}|j||}}ttj|Scc}wr)rrr r SpanOrMatcher)rrrrmatcherss rrzSpanOr.matchers=:>**EQAIIh0EE 4 4h??FsAc$eZdZfdZdZxZS)SpanOr.SpanOrMatcherc||_||_tj||}tt j ||yr)r}r~r UnionMatcherr^rr r)rr}r~umr=s rrzSpanOr.SpanOrMatcher.__init__s8DFDF$$Q*B &&& 6r :rc|jj}|jj}|r|jj}|r|jj}||k(rQt t |jj t |jj z}np||kr|jj }nP|jj }n5|jj }n|jj }tj||Sr) r}r`r~rurrr4r r9)ra_activeb_activea_idb_idr4s rrnzSpanOr.SpanOrMatcher._get_spanssvv'')Hvv'')Hvvyy{6699;Dt| &s466<<>':),TVV\\^)<(=!> $  $  FFLLNE  JJu LrrOrPrQrrnryrhs@rr r s  ;  rr r) rOrPrQrxrrrrr{r rTrrrrs( =@ rrc eZdZdZdZddZy) SpanBiQuerycyrrTrs rrzSpanBiQuery.is_leafrrcf|j||j||jSr)r=r}r~rs rrzSpanBiQuery.applys#~~bj"TVV*55rNc|jj||}|jj||}|j||Sr)r}rr~_Matcherrs rrzSpanBiQuery.matchers; VV^^Hg . VV^^Hg .}}R$$rr)rOrPrQrrrrTrrrrs6%rrc,eZdZdZdZGddeZy)SpanNota)Matches spans from the first query only if they don't overlap with spans from the second query. If there are no non-overlapping spans, the document does not match. For example, to match documents that contain "bear" at most 2 places after "apple" in the "text" field but don't have "cute" between them:: from whoosh import query, spans t1 = query.Term("text", "apple") t2 = query.Term("text", "bear") near = spans.SpanNear(t1, t2, slop=2) q = spans.SpanNot(near, query.Term("text", "cute")) cBt|||_||_||_y)z :param a: the query to match. :param b: do not match any spans that overlap with spans from this query. N)rrr}r~rr}r~s rrzSpanNot.__init__s!Qrc$eZdZfdZdZxZS)SpanNot._Matcherc||_||_tj||}tt j ||yr)r}r~rAndMaybeMatcherr^rrr)rr}r~ammr=s rrzSpanNot._Matcher.__init__s8DFDF((A.C '""D 23 7rc~|jj|jjk(rog}|jj}|jjD]4}d}|D]}|j |sd}n|r$|j |6|S|jjSrm)r}rur~r4r1append)rr4rr overlappedrs rrnzSpanNot._Matcher._get_spanssvvyy{dffiik)!VV\\^,E!&J!'" >>%0)-J!"& U+, vv||~%rrrhs@rrr!s  8  &rrNrOrPrQrxrr{rrTrrrrs  &=&rrc,eZdZdZdZGddeZy) SpanContainsaMatches documents where the spans of the first query contain any spans of the second query. For example, to match documents where "apple" occurs at most 10 places before "bear" in the "text" field and "cute" is between them:: from whoosh import query, spans t1 = query.Term("text", "apple") t2 = query.Term("text", "bear") near = spans.SpanNear(t1, t2, slop=10) q = spans.SpanContains(near, query.Term("text", "cute")) cDt||g|_||_||_y)z :param a: the query to match. :param b: the query whose spans must occur within the matching spans of the first query. N)rrr}r~rs rrzSpanContains.__init__ s!aVrc$eZdZfdZdZxZS)SpanContains._Matcherc||_||_tj||}tt j ||yr)r}r~rrr^r*rrrr}r~imr=s rrzSpanContains._Matcher.__init__s8DFDF++Aq1B ,'' 7 ;rc<g}|jj}|jjD]b}|D][}|j|jkDr|j|jkr=|j |sJ|j |bd|Sr)r~r4r}rrrFr&)rr4rrrs rrnz SpanContains._Matcher._get_spanssEVV\\^F #E{{UYY. yy5;;.u- U+ Lrrrhs@rrr-s  < rrNr(rTrrr*r*s  =rr*c,eZdZdZdZGddeZy) SpanBeforea_Matches documents where the spans of the first query occur before any spans of the second query. For example, to match documents where "apple" occurs anywhere before "bear":: from whoosh import query, spans t1 = query.Term("text", "apple") t2 = query.Term("text", "bear") q = spans.SpanBefore(t1, t2) cD||_||_t||g|_y)z :param a: the query that must occur before the second. :param b: the query that must occur after the first. Nr}r~rrrs rrzSpanBefore.__init__<s! aVrc$eZdZfdZdZxZS)SpanBefore._Matcherc||_||_tj||}tt j ||yr)r}r~rrr^r3rrr/s rrzSpanBefore._Matcher.__init__Gs8DFDF++Aq1B *%%t 5b 9rctd|jjD}|jjDcgc]}|j|ks|c}Scc}w)Nc34K|]}|jywrr%).0rs r z1SpanBefore._Matcher._get_spans..NsDEEKKDs)r;r~r4r}r)r bminstartrs rrnzSpanBefore._Matcher._get_spansMsEDTVV\\^DDI'+vv||~OeY9NEO OOs A#A#rrhs@rrr7Fs :  PrrNr(rTrrr3r3/s  P= Prr3c,eZdZdZdZGddeZy) SpanConditionaMatches documents that satisfy both subqueries, but only uses the spans from the first subquery. This is useful when you want to place conditions on matches but not have those conditions affect the spans returned. For example, to get spans for the term ``alfa`` in documents that also must contain the term ``bravo``:: SpanCondition(Term("text", u"alfa"), Term("text", u"bravo")) cD||_||_t||g|_yrr5rs rrzSpanCondition.__init__`saVrc$eZdZfdZdZxZS)SpanCondition._Matchercz||_tj||}ttj ||yr)r}rrr^r?rrr/s rrzSpanCondition._Matcher.__init__fs1DF++Aq1B -(($ 8 !rrrhs@rrrBes  =  "rrNr(rTrrr?r?Rs  "="rr?N)rxwhoosh.matchingrrr whoosh.queryrrrr r whoosh.utilr objectr rZWrappingMatcherr\r{rrrrrrrrr*r3r?rTrrrJs8$4377( q)6q)h 7(227t '  >9(/ (/VT!yT!nW Wt4Y4n %) %/&k/&d-;-` P PF"K"r