=wgYddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z Gdd e Z dd Z dd ZGd d eZGddeZeZeZGddeZGddeZeZGddeZy))divisionN)array)matchingu) TermNotFound) methodcallerceZdZdZy) QueryErrorz-Error encountered while running a query. N)__name__ __module__ __qualname____doc__I/var/www/horilla/myenv/lib/python3.12/site-packages/whoosh/query/qcore.pyr r (s rr c,| t}||_|S)zReturns the query in the second argument (or a :class:`NullQuery` if the second argument is not given) with its ``error`` attribute set to ``msg``. ) _NullQueryerror)msgqs r error_queryr0s  y LAG Hrc|jr.ddlm}|s t||st |j Syg}|j D]6}t||}t|dk(r|d}|s&|j|8|S)zcReturns the terms in the query tree, with the query hierarchy represented as nested lists. r)PhrasephrasesN) is_leaf whoosh.queryr isinstancelisttokenschildren token_listslenappend)rrrlsqqts rr$r$<s  yy{' *Q/ # #0**, BB0A1v{aD !    rc:eZdZdZdZdZdZdZdZdZ dZ y ) LowestzSA value that is always compares lower than any other object except itself. c*|jturyy)Nr) __class__r+selfothers r__cmp__zLowest.__cmp__Ws ??f $rc0|jt|uSNr.typer/s r__eq__z Lowest.__eq__\~~e,,rc0t||juSr4r6r.r/s r__lt__z Lowest.__lt___sE{$..00rc&|j| Sr4r7r/s r__ne__z Lowest.__ne__b;;u%%%rcL|j|xs|j| Sr4r;r7r/s r__gt__z Lowest.__gt__e"KK&<$++e*<==rcJ|j|xs|j|Sr4r7r;r/s r__le__z Lowest.__le__h{{5!7T[[%77rcJ|j|xs|j|Sr4r7rBr/s r__ge__z Lowest.__ge__krGrN r r rrr2r7r;r>rBrFrJrrrr+r+Rs* -1&>88rr+c:eZdZdZdZdZdZdZdZdZ dZ y ) HighestzTA value that is always compares higher than any other object except itself. c*|jturyy)Nrr)r.rMr/s rr2zHighest.__cmp__ts ??g %rc0|jt|uSr4r5r/s rr7zHighest.__eq__yr8rc0t||juSr4r:r/s rr;zHighest.__lt__|sE{dnn,,rc&|j| Sr4r=r/s rr>zHighest.__ne__r?rcL|j|xs|j| Sr4rAr/s rrBzHighest.__gt__rCrcJ|j|xs|j|Sr4rEr/s rrFzHighest.__le__rGrcJ|j|xs|j|Sr4rIr/s rrJzHighest.__ge__rGrNrKrrrrMrMos* --&>88rrMceZdZdZdxZZdZdZdZdZ dZ dZ dZ d Z d Zd Zd Zd ZdZdZdZdZdZd%dZd&dZd%dZd'dZdZd%dZd(dZd)dZdZdZ dZ!dZ"dZ#d*d Z$d!Z%d"Z&d#Z'd$Z(y)+QueryaAbstract base class for all queries. Note that this base class implements __or__, __and__, and __sub__ to allow slightly more convenient composition of query objects:: >>> Term("content", u"a") | Term("content", u"b") Or([Term("content", u"a"), Term("content", u"b")]) >>> Term("content", u"a") & Term("content", u"b") And([Term("content", u"a"), Term("content", u"b")]) >>> Term("content", u"a") - Term("content", u"b") And([Term("content", u"a"), Not(Term("content", u"b"))]) Nc@t|jjr4)NotImplementedErrorr.r r0s r __unicode__zQuery.__unicode__s!$.."9"9::rctr4rX)r0items r __getitem__zQuery.__getitem__!!rc>ddlm}|||gjS)zWAllows you to use | between query objects to wrap them in an Or query. r)Or)rra normalize)r0queryras r__or__z Query.__or__s $4- **,,rc>ddlm}|||gjS)zXAllows you to use & between query objects to wrap them in an And query. r)And)rrfrb)r0rcrfs r__and__z Query.__and__s %D%=!++--rcNddlm}m}||||gjS)zhAllows you to use - between query objects to add the right-hand query as a "NOT" query. r)rfNot)rrfrirb)r0rcrfris r__sub__z Query.__sub__s$ *D#e*%&0022rctr4r\rYs r__hash__zQuery.__hash__r_rc&|j| Sr4r=r/s rr>z Query.__ne__r?rcy)zoReturns True if this is a leaf node in the query tree, or False if this query has sub-queries. TrrYs rrz Query.is_leafs rctgS)z>Returns an iterator of the subqueries of this object. iterrYs rr#zQuery.childrens Bxrcy)zHReturns True if this object searches for values within a range. FrrYs ris_rangezQuery.is_rangesrcy)aReturns True if this specific object represents a search for a specific term (as opposed to a pattern, as in Wildcard and Prefix) or terms (i.e., whether the ``replace()`` method does something meaningful on this instance). FrrYs r has_termszQuery.has_termssrcR|jD]}|jsyy)NTF)r# needs_spans)r0childs rrwzQuery.needs_spanss+]]_ E  " rc|S)aIf this query has children, calls the given function on each child and returns a new copy of this node with the new children returned by the function. If this is a leaf node, simply returns this object. This is useful for writing functions that transform a query tree. For example, this function changes all Term objects in a query tree into Variations objects:: def term2var(q): if isinstance(q, Term): return Variations(q.fieldname, q.text) else: return q.apply(term2var) q = And([Term("f", "alfa"), Or([Term("f", "bravo"), Not(Term("f", "charlie"))])]) q = term2var(q) Note that this method does not automatically create copies of nodes. To avoid modifying the original tree, your function should call the :meth:`Query.copy` method on nodes before changing their attributes. r)r0fns rapplyz Query.applys 2 rc"fd|S)aApplies the given function to this query's subqueries (if any) and then to this query itself:: def boost_phrases(q): if isintance(q, Phrase): q.boost *= 2.0 return q myquery = myquery.accept(boost_phrases) This method automatically creates copies of the nodes in the original tree before passing them to your function, so your function can change attributes on nodes without altering the original tree. This method is less flexible than using :meth:`Query.apply` (in fact it's implemented using that method) but is often more straightforward. c6|j}|Sr4)r{)rrz fn_wrappers rr~z Query.accept..fn_wrappers #Aa5Lrr)r0rzr~s `@racceptz Query.accept s& $rc|jrtj|S|jtd|||S)zReturns a copy of this query with oldtext replaced by newtext (if oldtext was anywhere in this query). Note that this returns a *new* query with the given text replaced. It *does not* modify the original query "in place". replace)rcopyr{r )r0 fieldnameoldtextnewtexts rrz Query.replace#s< <<>99T? "::l9i+245 5rc,tj|S)z0Deprecated, just use ``copy.deepcopy``. )rdeepcopyrYs rrz Query.copy3s}}T""rc8t|j|S)zReturns a set of all terms in this query tree. This method exists for backwards-compatibility. Use iter_all_terms() instead. :param phrases: Whether to add words found in Phrase queries. :rtype: set r)setiter_all_termsr0rs r all_termszQuery.all_terms9s4&&w&788rctdS)a Yields zero or more (fieldname, text) pairs queried by this object. You can check whether a query object targets specific terms before you call this method using :meth:`Query.has_terms`. To get all terms in a query tree, use :meth:`Query.iter_all_terms`. rrprs rtermsz Query.termsEs Bxrc&|j|S)Nr)r)r0ixreaderrs rexpanded_termszQuery.expanded_termsOszz'z**rc|j}t}|jD]}|r||jk7r|r|j ||}n|j |}|D]B\}} || f|vr ||vs||} | j | } || f|vs0|j|| fD|S#t$rYTwxYw)ayReturns a set of all byteterms in this query tree that exist in the given ixreader. :param ixreader: A :class:`whoosh.reading.IndexReader` object. :param phrases: Whether to add words found in Phrase queries. :param expand: If True, queries that match multiple terms will return all matching expansions. :rtype: set r) schemarleavesfieldrrto_bytes ValueErroradd) r0rrexpandrrtermsetrrtextrbtexts rexisting_termszQuery.existing_termsRs% 8AY!'')3((7(C0#( 8 4t$/&"9-E! %t 4"5)X5 Y$67 8 8. &! !sB33 B?>B?c#K|jr|y|jD]}|jD]}|yw)zaReturns an iterator of all the leaf queries in this query tree as a flat series. N)rr#r)r0rr(s rrz Query.leavesysE <<>J]]_ ((*BH sAAc#K|jD].}|js|j|D]}|0yw)asReturns an iterator of (fieldname, text) pairs for all terms in this query tree. >>> qp = qparser.QueryParser("text", myindex.schema) >>> q = myparser.parse("alfa bravo title:charlie") >>> # List the terms in a query >>> list(q.iter_all_terms()) [("text", "alfa"), ("text", "bravo"), ("title", "charlie")] >>> # Get a set of all terms in the query that don't exist in the index >>> r = myindex.reader() >>> missing = set(t for t in q.iter_all_terms() if t not in r) set([("text", "alfa"), ("title", "charlie")]) >>> # All terms in the query that occur in fewer than 5 documents in >>> # the index >>> [t for t in q.iter_all_terms() if r.doc_frequency(t[0], t[1]) < 5] [("title", "charlie")] :param phrases: Whether to add words found in Phrase queries. rN)rrur)r0rrr)s rrzQuery.iter_all_termssE* A{{}1AG s $AAc#K|jr|j|D]}|y|t|dr |jndz}|j D]}|j |D]}|yw)aReturns an iterator of :class:`analysis.Token` objects corresponding to all terms in this query tree. The Token objects will have the ``fieldname``, ``text``, and ``boost`` attributes set. If the query was built by the query parser, they Token objects will also have ``startchar`` and ``endchar`` attributes indexing into the original user query. boost?N)rr"hasattrrr# all_tokens)r0rtokenrxs rrzQuery.all_tokenss} <<>U+    74#9TZZs BE "--e4 EK  sA9A;ctdS)aYields zero or more :class:`analysis.Token` objects corresponding to the terms searched for by this query object. You can check whether a query object targets specific terms before you call this method using :meth:`Query.has_terms`. The Token objects will have the ``fieldname``, ``text``, and ``boost`` attributes set. If the query was built by the query parser, they Token objects will also have ``startchar`` and ``endchar`` attributes indexing into the original user query. To get all tokens for a query tree, use :meth:`Query.all_tokens`. :param exreader: a reader to use to expand multiterm queries such as prefixes and wildcards. The default is None meaning do not expand. rrp)r0rexreaders rr"z Query.tokenss "Bxrct|gS)a6Returns a set of queries that are *known* to be required to match for the entire query to match. Note that other queries might also turn out to be required but not be determinable by examining the static query. >>> a = Term("f", u"a") >>> b = Term("f", u"b") >>> And([a, b]).requires() set([Term("f", u"a"), Term("f", u"b")]) >>> Or([a, b]).requires() set([]) >>> AndMaybe(a, b).requires() set([Term("f", u"a")]) >>> a.requires() set([Term("f", u"a")]) )rrYs rrequireszQuery.requiress(D6{rc|jS)zqReturns the field this query matches in, or None if this query does not match in a single field. )rrYs rrz Query.fields ~~rc4|j}||_|S)zReturns a COPY of this query with the boost set to the given value. If a query type does not accept a boost itself, it will try to pass the boost on to its children, if any. )rr)r0rrs r with_boostzQuery.with_boosts IIKrct)a Returns an estimate of how many documents this query could potentially match (for example, the estimated size of a simple term query is the document frequency of the term). It is permissible to overestimate, but not to underestimate. r\r0rs r estimate_sizezQuery.estimate_sizes "!rc$|j|S)zkReturns an estimate of the minimum number of documents this query could potentially match. )rrs restimate_min_sizezQuery.estimate_min_sizes !!(++rct)zReturns a :class:`~whoosh.matching.Matcher` object you can use to retrieve documents and scores matching this query. :rtype: :class:`whoosh.matching.Matcher` r\r0searchercontexts rmatcherz Query.matchers "!rc |j}|j||jS#t$rt gcYSwxYw)zReturns an iterator of docnums matching this query. >>> with my_index.searcher() as searcher: ... list(my_query.docs(searcher)) [10, 34, 78, 103] :param searcher: A :class:`whoosh.searching.Searcher` object. )boolean_contextrall_idsrrqrs rdocsz Query.docssG ..0G<<'2::< < 8O s/2A A c$|j|S)aReturns an iterator of docnums matching this query for the purpose of deletion. The :meth:`~whoosh.writing.IndexWriter.delete_by_query` method will use this method when deciding what documents to delete, allowing special queries (e.g. nested queries) to override what documents are deleted. The default implementation just forwards to :meth:`Query.docs`. )rr0rs r deletion_docszQuery.deletion_docssyy""rc|S)aReturns a recursively "normalized" form of this query. The normalized form removes redundancy and empty queries. This is called automatically on query trees created by the query parser, but you may want to call it yourself if you're writing your own parser or building your own queries. >>> q = And([And([Term("f", u"a"), ... Term("f", u"b")]), ... Term("f", u"c"), Or([])]) >>> q.normalize() And([Term("f", u"a"), Term("f", u"b"), Term("f", u"c")]) Note that this returns a *new, normalized* query. It *does not* modify the original query "in place". rrYs rrbzQuery.normalizes  rc|S)zReturns a recursively simplified form of this query, where "second-order" queries (such as Prefix and Variations) are re-written into lower-level queries (such as Term and Or). rrs rsimplifyzQuery.simplify1s  rT)F)TFN)r)rNr4))r r rr startcharendcharrrZr^rdrgrjrlr>rr#rsrurwr{rrrrrrrrrrr"rrrrrrrrrbrrrrrVrVs "I E;"-.3"&   6 25 # 9+%N 4 $&, "," #$rrVcpeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZddZy)rz-Represents a query that won't match anything.rcd|_yr4)rrYs r__init__z_NullQuery.__init__@s  rctdS)Nz <_NullQuery>rrYs rrZz_NullQuery.__unicode__Cs   rc|Sr4rrYs r__call__z_NullQuery.__call__F rc4d|jjzS)Nz<%s>)r.r rYs r__repr__z_NullQuery.__repr__Is0011rc"t|tSr4)r rr/s rr7z_NullQuery.__eq__Ls%,,rc&|j| Sr4r=r/s rr>z_NullQuery.__ne__Or?rct|Sr4)idrYs rrlz_NullQuery.__hash__Rs $xrc|Sr4rrYs r__copy__z_NullQuery.__copy__Urrc|Sr4r)r0memos r __deepcopy__z_NullQuery.__deepcopy__Xrrcyr4rrYs rrz_NullQuery.field[srcy)Nrrrs rrz_NullQuery.estimate_size^src|Sr4rrYs rrbz_NullQuery.normalizearrc|Sr4rrs rrz_NullQuery.simplifydrrcgSr4rrs rrz_NullQuery.docsgs rNc*tjSr4)r NullMatcherrs rrz_NullQuery.matcherjs##%%rr4)r r rrrrrZrrr7r>rlrrrrrbrrrrrrrr;sU3 E!2-&&rrcBeZdZdZd dZdZdZdZeZdZ dZ d d Z y) EveryaA query that matches every document containing any term in a given field. If you don't specify a field, the query matches every document. >>> # Match any documents with something in the "path" field >>> q = Every("path") >>> # Matcher every document >>> q = Every() The unfielded form (matching every document) is efficient. The fielded is more efficient than a prefix query with an empty prefix or a '*' wildcard, but it can still be very slow on large indexes. It requires the searcher to read the full posting list of every term in the given field. Instead of using this query it is much more efficient when you create the index to include a single term that appears in all documents that have the field you want to match. For example, instead of this:: # Match all documents that have something in the "path" field q = Every("path") Do this when indexing:: # Add an extra field that indicates whether a document has a path schema = fields.Schema(path=fields.ID, has_path=fields.ID) # When indexing, set the "has_path" field based on whether the document # has anything in the "path" field writer.add_document(text=text_value1) writer.add_document(text=text_value2, path=path_value2, has_path="t") Then to find all documents with a path:: q = Term("has_path", "t") Nc2|r|dk(rd}||_||_y)z| :param fieldname: the name of the field to match, or ``None`` or ``*`` to match all documents. *N)rr)r0rrs rrzEvery.__init__s! I,I" rch|jjd|jd|jdS)N(z, boost=))r.r rrrYs rrzEvery.__repr__s&%)^^%<%>))rc,t|jSr4)hashrrYs rrlzEvery.__hash__sDNN##rc"|jSr4) doc_countrs rrzEvery.estimate_sizes!!##rcr|j}|j}|dvrtd|j}n\t }|j |D]3}|j ||}|j|j5t|}tj||jS)N)NrI) all_weights) rreaderr all_doc_idsrlexiconpostingsupdatersortedr ListMatcherr)r0rrrrdoclistrprs rrz Every.matchersNN "  'C!3!3!56G eG ((3 -&&y$7rzz|, -WoG##GDDr)Nrr4) r r rrrrr7rZ__str__rlrrrrrrrss3%N 1/ *G$$Errr4r) __future__rrrwhooshr whoosh.compatrwhoosh.readingrr Exceptionr rr$objectr+rMrVr NullQueryrrrrrs8 '&     ,8V8:8f8:  ) dFdR 0&0&f L XEEXEr