=wgqbddlZddlmZddlmZddlmZmZddlmZddl m Z ddl m Z m Z ddlmZGd d eZGd d e ZGd deZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGdd eZGd!d"eZGd#d$eZGd%d&eZGd'd(eZ Gd)d*eZ!Gd+d,eZ"Gd-d.eZ#Gd/d0eZ$Gd1d2eZ%Gd3d4eZ&Gd5d6eZ'y)7N)query)u) iteritemsxrange)syntax)attach) RegexTaggerFnTagger)rcompileceZdZdZdZdZy)Pluginz#Base class for parser plugins. cy)zShould return a list of ``(Tagger, priority)`` tuples to add to the syntax the parser understands. Lower priorities run first. rselfparsers M/var/www/horilla/myenv/lib/python3.12/site-packages/whoosh/qparser/plugins.pytaggerszPlugin.taggers+s cy)zShould return a list of ``(filter_function, priority)`` tuples to add to parser. Lower priority numbers run first. Filter functions will be called with ``(parser, groupnode)`` and should return a group node. rrrs rfilterszPlugin.filters2srN)__name__ __module__ __qualname____doc__rrrrrr r 'srr c.eZdZdZdZddZdZdZdZy) TaggingPluginaA plugin that also acts as a Tagger, to avoid having an extra Tagger class for simple cases. A TaggingPlugin object should have a ``priority`` attribute and either a ``nodetype`` attribute or a ``create()`` method. If the subclass doesn't override ``create()``, the base class will call ``self.nodetype`` with the Match object's named groups as keyword arguments. rNc@t|xs |j|_yN)r exprrr s r__init__zTaggingPlugin.__init__IsT.TYY/ rc ||jfgSr)priorityrs rrzTaggingPlugin.taggersLst}}%&&rcy)Nrrrs rrzTaggingPlugin.filtersOsrcxtdt|jD}|jdi|S)Nc3<K|]\}}t||fywr)str.0kvs r z'TaggingPlugin.create..UsKdas1vqkKsr)dictr groupdictnodetype)rrmatchkwargss rcreatezTaggingPlugin.createRs4Ki8I.JKKt}}&v&&rr) rrrrr$r"rrr3rrrrr=s"H0''rrc@eZdZdZej ZdZddZdZ dZ y)WhitespacePluginaTags whitespace and removes it at priority 500. Depending on whether your plugin's filter wants to see where whitespace was in the original query, it should run with priority lower than 500 (before removal of whitespace) or higher than 500 (after removal of whitespace). dc0tj||yr)rr"r!s rr"zWhitespacePlugin.__init__cstT*rc |jdfgS)Ni)remove_whitespacers rrzWhitespacePlugin.filtersfs''-..rc|j}|D]`}t|tjr"|j |j ||?|j rP|j |b|Sr) empty_copy isinstancer GroupNodeappendr9is_wsrrgroupnewgroupnodes rr9z"WhitespacePlugin.remove_whitespaceisd##% &D$ 0 01 6 6vt DEZZ\%  & rN)z\s+) rrrrr Whitespacer0r$r"rr9rrrr5r5Ys(   HH+/rr5c,eZdZdZdZej Zy)SingleQuotePluginziAdds the ability to specify single "terms" containing spaces by enclosing them in single quotes. z*(^|(?<=\W))'(?P.*?)'(?=\s|\]|[)}]|$)N)rrrrr rWordNoder0rrrrFrFss 9DHrrFcBeZdZdZGddej ZdZeZy) PrefixPluginaAdds the ability to specify prefix queries by ending a term with an asterisk. This plugin is useful if you want the user to be able to create prefix but not wildcard queries (for performance reasons). If you are including the wildcard plugin, you should not include this plugin as well. >>> qp = qparser.QueryParser("content", myschema) >>> qp.remove_plugin_class(qparser.WildcardPlugin) >>> qp.add_plugin(qparser.PrefixPlugin()) >>> q = qp.parse("pre*") c*eZdZejZdZy)PrefixPlugin.PrefixNodec d|jzS)Nz%r*textrs rrzPrefixPlugin.PrefixNode.rs499$ $rN)rrrrPrefixqclassrPrrr PrefixNoderKs %rrSz (?P[^ *]+)[*](?= |$|\))N) rrrrrTextNoderSr r0rrrrIrI|s# %V__% 2DHrrIc`eZdZedZdezZdZdZGddejZ e Z y)WildcardPluginu?՞؟፧z(?P[*%s])c |jdfgS)N2) do_wildcardsrs rrzWildcardPlugin.filterss""B'((rcd}|t|kr ||}t||jr|t|dz krI||dzjr3|j |dz}|xj |j z c_|dkDrI||dz jr3|j |dz }|j |j z|_n7|dz }n1t|t jr|j|||dz }|t|kr tt|D]}||}t||js|j tdkDs:tfd|jDrYjdtdz k(sztjdd}|j|_|j |_|||<|S)Nrc3&K|]}|v ywrr)r*qmrNs rr-z.WildcardPlugin.do_wildcards..s,NBR4Z,Ns*)lenr< WildcardNodeis_textpoprNrr=rYranyqmarksfindrIrS startcharendchar) rrrAirCnextnodeprevnodenewnoderNs @rrYzWildcardPlugin.do_wildcardss #e*n8D$ 1 12s5zA~%%A,*>*>*@$yyQ/HII.Iq5U1q5\113$yyQ/H (  9DIFAdF$4$45%%fd3Q#e*n E # +A8D$ 1 12yyt9q=,N$++,N)Nyy~TQ6"."9"9$s)"D,0NN)*.,,#*a + rc*eZdZejZdZy)WildcardPlugin.WildcardNodec d|jzS)NzWild %rrMrOs rrPzWildcardPlugin.WildcardNode.rstyy( (rN)rrrrWildcardrRrPrrrrarns  )rraN) rrrrrer rrYrrTrar0rrrrVrVs:$ %F v %D)<)v)HrrVcBeZdZdZGddej ZdZeZy) RegexPluginaAdds the ability to specify regular expression term queries. The default syntax for a regular expression term is ``r"termexpr"``. >>> qp = qparser.QueryParser("content", myschema) >>> qp.add_plugin(qparser.RegexPlugin()) >>> q = qp.parse('foo title:r"bar+"') c*eZdZejZdZy)RegexPlugin.RegexNodec d|jzS)NzRegex %rrMrOs rrPzRegexPlugin.RegexNode.rs ) )rN)rrrrRegexrRrPrrr RegexNoderts *rrwzr"(?P[^"]*)"N) rrrrrrTrwr r0rrrrrrrs#*FOO* DHrrrcVeZdZdZdZGddej ZdZdZ dZ dZ y ) BoostPluginzAdds the ability to boost clauses of the query using the circumflex. >>> qp = qparser.QueryParser("content", myschema) >>> q = qp.parse("hello there^2") z-\^(?P[0-9]*(\.[0-9]+)?)($|(?=[ )]))ceZdZdZdZy)BoostPlugin.BoostNodec ||_||_yr)originalboost)rr}r~s rr"zBoostPlugin.BoostNode.__init__s$DMDJrc d|jzS)Nz^ %s)r~rOs rrPzBoostPlugin.BoostNode.rsDJJ& &rN)rrrr"rPrrr BoostNoder{s   'rrc|jd} t|jd}|j||}|S#t$rt j |}Y|SwxYw)Nrr~)rAfloatr ValueErrorrrG)rrr1r}r~rCs rr3zBoostPlugin.createsf;;q> 3%++g./E >>(E2D  -??8,D  -sAA#"A#c:|jdf|jdfgS)Nr) clean_boostdo_boostrs rrzBoostPlugin.filterss!!!1% s';<r@s rrzBoostPlugin.do_boost s ##% "D$ 0 01}}VT2D$..1"!7!7RL**4::6!>>$/D OOD ! "rN) rrrrr r SyntaxNoderr3rrrrrrryrys5 @D'F%%' = rryc~eZdZdZGddej ZGddej Zd dZdZ dZ d Z y ) GroupPluginz9Adds the ability to group clauses using parentheses. ceZdZdZy)GroupPlugin.OpenBracketcy)N(rrOs rrPzGroupPlugin.OpenBracket.r)rNrrrrPrrr OpenBracketr( rrceZdZdZy)GroupPlugin.CloseBracketcy)N)rrOs rrPzGroupPlugin.CloseBracket.r-rrNrrrr CloseBracketr,rrrc ||_||_yr)openexpr closeexpr)rrrs rr"zGroupPlugin.__init__0  "rct|j|jddft|j|jddfgS)NopenBrcloseB)r rrrrrs rrzGroupPlugin.taggers4sD$--)9)97CQG$..$*;*;XFJL Lrc |jdfgSNr) do_groupsrs rrzGroupPlugin.filters8s#$$rcH|j|j}}|jg}|D]}t||r |j |j/t||r4t |dkDsJ|j }|dj |o|dj ||d}t |dkDr|ddD]} |j| t |dk(r5t|dtjr|j} |d}| |_ |S)zThis filter finds open and close bracket markers in a flat group and uses them to organize the nodes into a hierarchy. r[r_rN) rrrAr<r>r`rcextendrr=r~) rrrAobcbstackrClasttoplsr~s rrzGroupPlugin.do_groups;s !!4#4#4B  'D$# V\\^,D"%u:> 99;D"I$$T*b   & 'Ah u:>ABi  2  s8q=ZA0@0@AIIEa&CCI rN)z[(]z[)]) rrrrrrrrr"rrrrrrrr"s@ f''v((#L%#rrcDeZdZdZdZdZGddejZy) EveryPluginz[*]:[*]r_c"|jSr) EveryNoderrr1s rr3zEveryPlugin.createes~~rceZdZdZdZy)EveryPlugin.EveryNodecy)Nz*:*rrOs rrPzEveryPlugin.EveryNode.risrc*tjSr)rEveryrs rrzEveryPlugin.EveryNode.queryls;;= rN)rrrrPrrrrrrhs   !rrN) rrrr r$r3rrrrrrrras# DH !F%%!rrc@eZdZdZGddeZd dZdZdZdZ y) FieldsPluginz7Adds the ability to specify the field of a clause. ceZdZdZy)FieldsPlugin.FieldnameTaggercjtj|jd|jdS)NrNr)r FieldnameNoderArs rr3z#FieldsPlugin.FieldnameTagger.createus&'' F(;U[[^L LrNrrrr3rrrFieldnameTaggerrts Mrrc ||_||_y)z :param expr: the regular expression to use for tagging fields. :param remove_unknown: if True, converts field specifications for fields that aren't in the schema into regular text. N)r removeunknown)rr remove_unknowns rr"zFieldsPlugin.__init__xs +rc>|j|jdfgSr)rr rs rrzFieldsPlugin.taggerss%%dii0!455rc |jdfgS)Nr6) do_fieldnamesrs rrzFieldsPlugin.filterss##S)**rctj}|jr|jr|j}|j }d}|D]}t ||r|j |vr|} |rQ|jr|j|jz|_ n$|jtj|d}|j||r$|jtj||}|j }t|}|dkDr|dz}||}t ||rtj|}n,t |tjr|j||}|dkDrJ|js:t ||dz |r(|j!||dz j d|dz}|j||dkDr|j#|S)zkThis filter finds FieldnameNodes in the tree and applies their fieldname to the next node. Nrr[Foverride)rrrschemar;r< fieldnamehas_textr}rNr>rr`r=rr? set_fieldnamereverse) rrrAfnclassrrBprev_field_noderCris rrzFieldsPlugin.do_fieldnamess &&   &--]]F'')H"O &dG,v1M&*O$}}$3$<$\w+|[*]):T) rrrrr rr"rrrrrrrrps)M+M,6+6rrceZdZdZeddZGddejZGddejZ d Z d Z d Z y ) FuzzyTermPluginaAdds syntax to the query parser to create "fuzzy" term queries, which match any term within a certain "edit distance" (number of inserted, deleted, or transposed characters) by appending a tilde (``~``) and an optional maximum edit distance to a term. If you don't specify an explicit maximum edit distance, the default is 1. >>> qp = qparser.QueryParser("content", myschema) >>> qp.add_plugin(qparser.FuzzyTermPlugin()) >>> q = qp.parse("Stephen~2 Colbert") For example, the following query creates a :class:`whoosh.query.FuzzyTerm` query with a maximum edit distance of 1:: bob~ The following creates a fuzzy term query with a maximum edit distance of 2:: bob~2 The maximum edit distance can only be a single digit. Note that edit distances greater than 2 can take an extremely long time and are generally not useful. You can specify a prefix length using ``~n/m``. For example, to allow a maximum edit distance of 2 and require a prefix match of 3 characters:: johannson~2/3 To specify a prefix with the default edit distance:: johannson~/3 ad (?<=\S) # Only match right after non-space ~ # Initial tilde (?P[0-9])? # Optional maxdist (/ # Optional prefix slash (?P[1-9][0-9]*) # prefix )? # (end prefix group) TverboseceZdZdZdZy)FuzzyTermPlugin.FuzzinessNodec.||_||_||_yr)maxdist prefixlengthr})rrrr}s rr"z&FuzzyTermPlugin.FuzzinessNode.__init__s"DL ,D $DMrc8d|j|jfzS)Nz<~%d/%d>)rrrOs r__repr__z&FuzzyTermPlugin.FuzzinessNode.__repr__st/@/@ AA ArNrrrr"rrrr FuzzinessNoders  %  Brrc6eZdZejZdZdZdZy)FuzzyTermPlugin.FuzzyTermNodec|j|_|j|_|j|_|j|_|j|_||_||_yr)rrNr~rgrhrr)rwordnoderrs rr"z&FuzzyTermPlugin.FuzzyTermNode.__init__sN%//DN DI!DJ%//DN#++DL"DL ,D rcNd|j|j|jfzS)Nz %r ~%d/%d)rNrrrOs rrPzFuzzyTermPlugin.FuzzyTermNode.rs"$))T\\4;L;L!MM Mrctjj||}|j|_|j|_|Sr)rrTrrr)rrqs rrz#FuzzyTermPlugin.FuzzyTermNode.querys7%%dF3A AI!..ANHrN)rrrr FuzzyTermrRr"rPrrr FuzzyTermNoders - N rrc|jd}|r t|nd}|jd}|r t|nd}|j|||jdS)Nrr[prefixr)rAintr)rrr1mdstrrpstrrs rr3zFuzzyTermPlugin.createsU I& %#e*1{{8$$(s4ya !!'<QHHrc |jdfgSr) do_fuzzytermsrs rrzFuzzyTermPlugin.filterss##Q'((rc2|j}d}|t|kr||}|t|dz krdt|tjrJ||dz}t||j r,|j ||j|j}|dz }t||j rtj|}t|tjr|j||}|j||dz }|t|kr|SNrr[) r;r`r<rrGrrrrrr=rr>rrrArBrirCrjs rrzFuzzyTermPlugin.do_fuzzytermss##% #e*n8D3u:>!jv&G Q<h(:(:;--dH4D4D.6.C.CEDFA$ 2 23~~d+$ 0 01))&$7 OOD ! FA#e*nrN)rrrrr r rrrrTrr3rrrrrrrsR D  DB))B2I)rrcleZdZdZeddZGddejZdZ dZ d Z d Z d Z y ) FunctionPluginzAdds an abitrary "function call" syntax to the query parser to allow advanced and extensible query functionality. This is unfinished and experimental. z [#](?P[A-Za-z_][A-Za-z0-9._]*) # function name ( # optional args \[ # inside square brackets (?P.*?) \] )? Trc*eZdZdZdZdZdZdZdZy)FunctionPlugin.FunctionNodeFTcX||_||_||_||_g|_d|_yr)namefnargsr2nodesr~)rrrrr2s rr"z$FunctionPlugin.FunctionNode.__init__Es,DIDGDI DKDJDJrcVd|jd|jd|jdS)N#(r)rrrrOs rrz$FunctionPlugin.FunctionNode.__repr__Ms$(IItyy$**E Erc|jDcgc]}|j|}}|j}d|vr|j|j|d<|j|g|j i|jScc}w)Nr~)rrr2r~rr)rrnqsr2s rrz!FunctionPlugin.FunctionNode.queryPsp+/::6a!''&/6B6[[Ff$)?"&**w47729 9T[[9 9 7sA>N) rrr has_fieldnamermergingr"rrrrr FunctionNoder@s!    F :rrc||_y)zf :param fns: a dictionary mapping names to functions that return a query. N)fns)rrs rr"zFunctionPlugin.__init__Xs rc|jd}||jvrO|j|}|jd}|r|j|\}}nd}i}|j||||Sy)Nrrr)rAr _parse_argsr)rrr1rr argstringrr2s rr3zFunctionPlugin.create`st{{6" 488 $B F+I#// : f$$T2tV< < rcPg}i}|jd}|D]}d|vr/|jdd\}}t|j}nd}|}|j}|jdr|j dr|dd}|r|||<y|j |||fS)N,=r['r_)splitr(strip startswithendswithr>)rr rr2partspartrvalues rrzFunctionPlugin._parse_argsls$ #Dd{"jja0 e4::<(KKME$)<a $t  E"! #$V|rc |jdfgSNiX) do_functionsrs rrzFunctionPlugin.filters""C())rc0|j}d}|t|kr||}t||jr|t|dz krxt||dztj rX||dz}t |j|||_|jdk7r|j|j|dz }n,t|tj r|j||}|j||dz }|t|kr|Sr) r;r`r<rrr=listrrr~rr>rs rrzFunctionPlugin.do_functionss##% #e*n8D4!2!23E Q&uQU|V-=-=> Q<!$"3"3FH"EF >>Q&NN8>>2QD&"2"23((6 OOD ! FA!#e*n"rN)rrrrr r rrrr"r3rrrrrrrr0sH  D:v((:0 =2*rrcneZdZdZedZGddejZGdde Z d dZ dZ y ) PhrasePluginzEAdds the ability to specify phrase queries inside double quotes. z\S+c&eZdZddZdZdZdZy)PhrasePlugin.PhraseNodec`tjj||||_||_yr)rrTr" textstartcharslop)rrNr r!s rr"z PhrasePlugin.PhraseNode.__init__s% OO $ $T4 0!.D DIrcf|jjd|jd|jS)N ~) __class__rrNr!rOs rrPzPhrasePlugin.PhraseNode.rs!!%!8!8$))TYYO Orc |j|j|jDcgc] }|| c}|j|jScc}w)N)r!r~)r%typerr!r~)rrrCs rapplyzPhrasePlugin.PhraseNode.applysE>>$))4::-N4bh-N'+yy "D D-NsA cd|j}|jxs |j}|j}|jr||jvr|j|}|jrh|j |dd}g}g}|D]J} |j | j|j || jz|| jzfLnt|j|d}dgt|z}n}g}g}tjj|D]W} |j | jd|j || j!z|| j#zfY|j$} | |||j&|j(|} t+| |S)NrT)modechars)r*)NNr)r!r~ char_ranges)rNrr ranalyzertokenizer>rgrhr process_textr`rwordexprfinditerrAstartend phraseclassr!r~r) rrrNrscfieldtokenswordsr,tr1rRrs rrzPhrasePlugin.PhraseNode.querys99D:&*:*:I ##B}}fmm!; i0>>#^^Dwd^KFE"$K#O QVV,#**B,|j|jdfgSr)r?r rs rrzPhrasePlugin.taggerss""499-q122rN)z("(?P.*?)"(~(?P[1-9][0-9]*))?) rrrrr r0rrTr:r r?r"rrrrrrs<H2#V__2#hF{F3rrc~eZdZdZd dZGddej ZGddejZ dZ dZ d Z y ) SequencePluginaAdds the ability to group arbitrary queries inside double quotes to produce a query matching the individual sub-queries in sequence. To enable this plugin, first remove the default PhrasePlugin, then add this plugin:: qp = qparser.QueryParser("field", my_schema) qp.remove_plugin_class(qparser.PhrasePlugin) qp.add_plugin(qparser.SequencePlugin()) This enables parsing "phrases" such as:: "(jon OR john OR jonathan~1) smith*" c||_y)z :param expr: a regular expression for the marker at the start and end of a phrase. The default is the double-quotes character. NrAr!s rr"zSequencePlugin.__init__s  rc$eZdZejZy)SequencePlugin.SequenceNodeN)rrrrSequencerRrrr SequenceNoderGs rrIceZdZddZy)SequencePlugin.QuoteNodeNc8|rt||_yd|_yNr[)rr!)rr!s rr"z!SequencePlugin.QuoteNode.__init__s%)D DIqDIrr)rrrr"rrr QuoteNoderKs 1rrNcJt|j|jddfgS)Nquoter)r r rNrs rrzSequencePlugin.taggers s!$))T^^W=qABBrc |jdfgS)Ni&) do_quotesrs rrzSequencePlugin.filterss%&&rc|j}d}|D]}t|tjr|j ||}t||j r6|g}J|j ||j}|j|d}{||j||j|||j||S)N)r!) r;r<rr=rRrNrIr!r>r)rrrArBseqrCsns rrRzSequencePlugin.do_quotess##%  !D$ 0 01~~fd3$/;C**3TYY*?BOOB'C% 4 ' !. ? OOC rN)z["](~(?P[1-9][0-9]*))?) rrrrr"rr=rI MarkerNoderNrrrRrrrrDrDs@  v'' 1F%%1C'%rrDcHeZdZdZeddZGddeZd dZd Z y) RangePluginz-Adds the ability to specify term ranges. a (?P\{|\[) # Open paren (?P ('[^']*?'\s+) # single-quoted | # or ([^\]}]+?(?=[Tt][Oo])) # everything until "to" )? [Tt][Oo] # "to" (?P (\s+'[^']*?') # single-quoted | # or ([^\]}]+?) # everything until "]" or "}" )? (?P}|]) # Close paren TrceZdZdZdZy)RangePlugin.RangeTaggerc.||_||_||_yrr excl_startexcl_endrr r]r^s rr"z RangePlugin.RangeTagger.__init__NsDI(DO$DMrc|jd}|jd}|r7|j}|jdr|jdr|dd}|r7|j }|jdr|jdr|dd}|jd|j k(}|jd|j k(}tj||||}|S)Nr2r3r r[r_openclose) rArstriprrlstripr]r^r RangeNode)rrr1r2r3 startexclendexclrns rr3zRangePlugin.RangeTagger.createSsKK(E++e$C ##C(U^^C-@!!BKEjjl>>#&3<<+<a)C F+t>Ikk'*dmm;G!!%iABIrN)rrrr"r3rrr RangeTaggerrZMs  %  rriNcJ|xs |j|_||_||_yrr\r_s rr"zRangePlugin.__init__is %DII $  rcn|j|j|j|j}|dfgSrM)rir r]r^)rrtaggers rrzRangePlugin.taggersns.!!$))T__dmmL }r)N{}) rrrrr r r rir"rrrrrXrX9s3  D k8! rrXcNeZdZdZGddeZ d dZdZdZdZ y) OperatorsPluginaBy default, adds the AND, OR, ANDNOT, ANDMAYBE, and NOT operators to the parser syntax. This plugin scans the token stream for subclasses of :class:`Operator` and calls their :meth:`Operator.make_group` methods to allow them to manipulate the stream. There are two levels of configuration available. The first level is to change the regular expressions of the default operators, using the ``And``, ``Or``, ``AndNot``, ``AndMaybe``, and/or ``Not`` keyword arguments. The keyword value can be a pattern string or a compiled expression, or None to remove the operator:: qp = qparser.QueryParser("content", schema) cp = qparser.OperatorsPlugin(And="&", Or="\|", AndNot="&!", AndMaybe="&~", Not=None) qp.replace_plugin(cp) You can also specify a list of ``(OpTagger, priority)`` pairs as the first argument to the initializer to use custom operators. See :ref:`custom-op` for more information on this. c:eZdZejddfdZdZdZy)OperatorsPlugin.OpTaggerTchtj||||_||_||_||_yr)r r" grouptypeoptype leftassocmemo)rr rurvrwrxs rr"z!OperatorsPlugin.OpTagger.__init__s.  t ,&DN DK&DNDIrc~d|jjd|jjd|jdS)Nrr#z (z)>)r%rr patternrxrOs rrz!OperatorsPlugin.OpTagger.__repr__s.%)^^%<%<%)YY%6%6 C Crcn|j|jd|j|jSr)rvrArurwrs rr3zOperatorsPlugin.OpTagger.creates%;;u{{1~t~~t~~N NrN)rrrr InfixOperatorr"rr3rrrOpTaggerrrs!393G3G#"  C Orr}Nc ~|r t|}ng}|s#|j} |r9|j| |tjtj ddf|r*|j| |tj ddf|r*|j| |tjddf|r*|j| |tjddf|r*|j| |tjddf|r*|j| |tjd df||_ y) Nnot)rxrandoranotamaybereq) rr}r>rNotGroupPrefixOperatorAndGroupOrGroup AndNotGroup AndMaybeGroup RequireGroupops) rrcleanAndOrAndNotAndMaybeNotRequireots rr"zOperatorsPlugin.__init__s s)CCB BsFOOV5J5J$)+,-/0 BsFOO%@!DE Br6>>=qAB Bvv'9'9$*,-/12 Bx)=)=$,./134 Bw(;(;$)+,-/0rc|jSr)rrs rrzOperatorsPlugin.taggerss xxrc |jdfgSr) do_operatorsrs rrzOperatorsPlugin.filtersrrc4|jD]\}}|j}|j}|jrYd}|t |ks;||}t ||r"|j|ur|j |||}n|dz }|t |krGt |dz }|dk\s||}t ||r|j |||}|dz}|dk\r/t|D]5\}}t |tjs!|j||||<7|S)zThis filter finds PrefixOperator, PostfixOperator, and InfixOperator nodes in the tree and calls their logic to rearrange the nodes. rr[) rrvrurwr`r< replace_selfrrr=r) rrrArl_rvgtyperir9s rrzOperatorsPlugin.do_operatorss$  IFA]]F$$E #e*naA!!V,1ENN65!<Q #e*nJN1faA!!V,NN65!<FA 1f' 4e$ 8DAq!V--.,,VQ7a 8 r)NFz(?<=\s)AND(?=\s)z(?<=\s)OR(?=\s)z(?<=\s)ANDNOT(?=\s)z(?<=\s)ANDMAYBE(?=\s)z(^|(?<=(\s|[()])))NOT(?=\s)z(^|(?<=\s))REQUIRE(?=\s)) rrrrr r}r"rrrrrrrprpssA,O;O (-(&.234 B*#rrpc~eZdZdZGddej ZGddej Zd dZdZ dZ d Z y ) PlusMinusPluginzAdds the ability to use + and - in a flat OR query to specify required and prohibited terms. This is the basis for the parser configuration returned by ``SimpleParser()``. c eZdZy)PlusMinusPlugin.PlusNrrrrrrPlusr rrc eZdZy)PlusMinusPlugin.MinusNrrrrMinusrrrrc ||_||_yr)plusexpr minusexpr)rrrs rr"zPlusMinusPlugin.__init__rrct|j|jddft|j|jddfgS)Nplusrminus)r rrrrrs rrzPlusMinusPlugin.taggerss@$--F;Q?$..$**g>BD Drc |jdfgS)Nr) do_plusminusrs rrzPlusMinusPlugin.filtersrrctj}tj}tj}t|tjrtj}|}|D]G}t||jr|}t||j r|}5|j ||}I|}|rtj||g}|rtj||g}|S)zThis filter sorts nodes in a flat group into "required", "optional", and "banned" subgroups based on the presence of plus and minus nodes. ) rrrr<rrr>rr)rrrArequiredoptionalbannednextrCs rrzPlusMinusPlugin.do_plusminuss ??$>>#! eV__ -(H D$ *D$**- D!  (((E):;E &&v7E rN)z\+-) rrrrrrVrrr"rrrrrrrrs@ v    !! #D*!rrcTeZdZdZGddej ZdZeZdZ dZ dZ y) GtLtPluginaAllows the user to use greater than/less than symbols to create range queries:: a:>100 b:<=z c:>=-1.4 d:``, ``<``, ``>=``, ``<=``, ``=>``, and ``=<`` after a field specifier. The field specifier is required. You cannot do the following:: >100 This plugin requires the FieldsPlugin and RangePlugin to work. ceZdZdZdZy)GtLtPlugin.GtLtNodec||_yrrel)rrs rr"zGtLtPlugin.GtLtNode.__init__<s DHrc d|jzS)Nz(%s)rrOs rrzGtLtPlugin.GtLtNode.__repr__?sDHH$ $rNrrrrGtLtNoder;s   %rrz(?P(<=|>=|<|>|=<|=>))c |jdfgSNc)do_gtltrs rrzGtLtPlugin.filtersEsr"##rctj}|j}d}t|dz }|t|kr||}t ||j r[||krg|d}||dz} t ||rN| j rB|j|j| |j|dz }n|j||dz }|t|kr|S)zLThis filter translate FieldnameNode/GtLtNode pairs into RangeNodes. rr[r_) rrr;r`r<rrr> make_ranger) rrrAfnamerBrilastirCrkrjs rrzGtLtPlugin.do_gtltIs$$##% E Q#e*n8D$ .u9'|H$QU|H!(E2x7H7H $(((KLQ% FA##e*n&rch|j}|dk(rtjd|dd}nc|dk(rtj|ddd}nE|dk(s|dk(rtjd|dd}n"|dk(s|dk(rtj|ddd}j|j|j S) NrFT>z<=z==z=>)rNrre set_rangergrh)rrCrrNrs rrzGtLtPlugin.make_rangefsyy #:  tUD9A CZ  tT59A D[C4K  tUE:A D[C4K  tUE:A{{4>>4<<88rN) rrrrrrrr r0rrrrrrrr(s4$%6$$% )DH$: 9rrc<eZdZdZdej fdZdZdZy)MultifieldPluginaConverts any unfielded terms into OR clauses that search for the term in a specified list of fields. >>> qp = qparser.QueryParser(None, myschema) >>> qp.add_plugin(qparser.MultifieldPlugin(["a", "b"]) >>> qp.parse("alfa c:bravo") And([Or([Term("a", "alfa"), Term("b", "alfa")]), Term("c", "bravo")]) This plugin is the basis for the ``MultifieldParser``. Nc6||_|xsi|_||_y)a :param fieldnames: a list of fields to search. :param fieldboosts: an optional dictionary mapping field names to a boost to use for that field. :param group: the group to use to relate the fielded terms to each other. N) fieldnamesboostsrA)rr fieldboostsrAs rr"zMultifieldPlugin.__init__s%!'R  rc |jdfgS)Nn) do_multifieldrs rrzMultifieldPlugin.filterss##S)**rct|D]\}}t|tjr|j ||||<6|j sC|j Pg}|jD]d}tj|}|j||j|jj|d|j|f|j|||<|S)Ng?)rr<rr=rrrrcopyrrrgetr>rA)rrrArirCnewnodesrrls rrzMultifieldPlugin.do_multifields ' 0GAt$ 0 01--fd;a##(>!__-E"iioG))%0%%dkkooeS&ABOOG, -  ::h/a 0 r) rrrrrrr"rrrrrrrss! 046>> + rrc"eZdZdZdZdZdZy)FieldAliasPlugina Adds the ability to use "aliases" of fields in the query string. This plugin is useful for allowing users of languages that can't be represented in ASCII to use field names in their own language, and translate them into the "real" field names, which must be valid Python identifiers. >>> # Allow users to use 'body' or 'text' to refer to the 'content' field >>> parser.add_plugin(FieldAliasPlugin({"content": ["body", "text"]})) >>> parser.parse("text:hello") Term("content", "hello") cr||_i|_t|D]\}}|D]}||j|<yr)fieldmaprr)rrkeyvaluesrs rr"zFieldAliasPlugin.__init__sE   $X. *KC *&) U# * *rc |jdfgS)NZ) do_aliasesrs rrzFieldAliasPlugin.filterss"%&&rc6t|D]\}}t|tjr|j ||||<6|j sC|j P|j }||jvsk|j|j|d|SNTr) rr<rr=rrrrr)rrrArirCrs rrzFieldAliasPlugin.do_aliasess ' KGAt$ 0 01??648a##(BDLL(&&t||E':T&J  K rN)rrrrr"rrrrrrrs *'rrc<eZdZdZej dfdZdZdZy)CopyFieldPlugina+Looks for basic syntax nodes (terms, prefixes, wildcards, phrases, etc.) occurring in a certain field and replaces it with a group (by default OR) containing the original token and the token copied to a new field. For example, the query:: hello name:matt could be automatically converted by ``CopyFieldPlugin({"name", "author"})`` to:: hello (name:matt OR author:matt) This is useful where one field was indexed with a differently-analyzed copy of another, and you want the query to search both fields. You can specify a different group type with the ``group`` keyword. You can also specify ``group=None``, in which case the copied node is inserted "inline" next to the original, instead of in a new group:: hello name:matt author:matt Fcz||_||_|r+|jtdt |Dyy)a :param map: a dictionary mapping names of fields to copy to the names of the destination fields. :param group: the type of group to create in place of the original token. You can specify ``group=None`` to put the copied node "inline" next to the original node instead of in a new group. :param two_way: if True, the plugin copies both ways, so if the user specifies a query in the 'toname' field, it will be copied to the 'fromname' field. c3*K|] \}}||f ywrrr)s rr-z+CopyFieldPlugin.__init__..s>tq!QF>sN)maprAupdater.r)rrrAmirrors rr"zCopyFieldPlugin.__init__s5  JJt>y~>> ? rc |jdfgS)Nm) do_copyfieldrs rrzCopyFieldPlugin.filterss""C())rc|j}|j}|D]}t|tjr|j ||}n|j r|jxs |j}||vr}tj|}|j||d|j#|j||j|n"|j|j||g|j||Sr) rr;r<rr=rrrrrrAr>)rrrArrBrCrrls rrzCopyFieldPlugin.do_copyfieldshh##% "D$ 0 01((6##:&*:*:C<"iioG))#e*t)Dzz) - 0  D'?(CD OOD ! " rN) rrrrrrr"rrrrrrrs".#)..@$*rrc"eZdZdZdZdZdZy)PseudoFieldPlugina This is an advanced plugin that lets you define "pseudo-fields" the user can use in their queries. When the parser encounters one of these fields, it runs a given function on the following node in the abstract syntax tree. Unfortunately writing the transform function(s) requires knowledge of the parser's abstract syntax tree classes. A transform function takes a :class:`whoosh.qparser.SyntaxNode` and returns a :class:`~whoosh.qparser.SyntaxNode` (or None if the node should be removed instead of transformed). Some things you can do in the transform function:: from whoosh import qparser def my_xform_fn(node): # Is this a text node? if node.has_text: # Change the node's text node.text = node.text + "foo" # Change the node into a prefix query node = qparser.PrefixPlugin.PrefixNode(node.text) # Set the field the node should search in node.set_fieldname("title") return node else: # If the pseudo-field wasn't applied to a text node (e.g. # it preceded a group, as in ``pfield:(a OR b)`` ), remove the # node. Alternatively you could just ``return node`` here to # leave the non-text node intact. return None In the following example, if the user types ``regex:foo.bar``, the function transforms the text in the pseudo-field "regex" into a regular expression query in the "content" field:: from whoosh import qparser def regex_maker(node): if node.has_text: node = qparser.RegexPlugin.RegexNode(node.text) node.set_fieldname("content") return node qp = qparser.QueryParser("content", myindex.schema) qp.add_plugin(qparser.PseudoFieldPlugin({"regex": regex_maker})) q = qp.parse("alfa regex:br.vo") The name of the "pseudo" field can be the same as an actual field. Imagine the schema has a field named ``reverse``, and you want the user to be able to type ``reverse:foo`` and transform it to ``reverse:(foo OR oof)``:: def rev_text(node): if node.has_text: # Create a word node for the reversed text revtext = node.text[::-1] # Reverse the text rnode = qparser.WordNode(revtext) # Put the original node and the reversed node in an OrGroup group = qparser.OrGroup([node, rnode]) # Need to set the fieldname here because the PseudoFieldPlugin # removes the field name syntax group.set_fieldname("reverse") return group qp = qparser.QueryParser("content", myindex.schema) qp.add_plugin(qparser.PseudoFieldPlugin({"reverse": rev_text})) q = qp.parse("alfa reverse:bravo") Note that transforming the query like this can potentially really confuse the spell checker! This plugin works as a filter, so it can only operate on the query after it has been parsed into an abstract syntax tree. For parsing control (i.e. to give a pseudo-field its own special syntax), you would need to write your own parsing plugin. c||_y)aZ :param xform_map: a dictionary mapping psuedo-field names to transform functions. The function should take a :class:`whoosh.qparser.SyntaxNode` as an argument, and return a :class:`~whoosh.qparser.SyntaxNode`. If the function returns None, the node will be removed from the query. N) xform_map)rrs rr"zPseudoFieldPlugin.__init__^s #rc |jdfgSr)do_pseudofieldrs rrzPseudoFieldPlugin.filtersis$$b)**rc|j}|j}d}|D]}t|tjr|j ||}n8t|tj r|j|vr||j}h|r5||}d}|w|j|j|j|}|j||Sr) rr;r<rr=rrrrrgrhr>)rrrArrB xform_nextrCrls rrz PseudoFieldPlugin.do_pseudofieldmsNN ##%  "D$ 0 01**648T6#7#78nn 1&t~~6 $T*! ?%%dnndllC"D OOD !# "&rN)rrrrr"rrrrrrr sPd #+rr)(rwhooshr whoosh.compatrrrwhoosh.qparserrwhoosh.qparser.commonrwhoosh.qparser.taggersr r whoosh.util.textr objectr rr5rFrIrVrrryrrrrrrrDrXrprrrrrrrrrrsV8 +!(8%V,'K'8}4 =03]3l-(A-AH<&<~ !- !N=Nblml^l]l^J36J3ZJVJZ7&7tqfql<f<~H9H9V-v-`!v!HAfAHzzr