=wgУddlmZddlmZddlmZddlmZmZmZGddeZ GddeZ Gd d e Z Gd d e Z Gd de Z Gdde ZGdde ZGdde ZGddeZGddeZGdde ZGdde ZGdde ZGdd e ZGd!d"e ZGd#d$eZGd%d&eZGd'd(eZGd)d*eZGd+d,eZGd-d.eZd1d0Zy/)2)array) defaultdict) string_type) iteritemsizipxrangec(eZdZdZdZdZddZdZy) FacetTypezABase class for "facets", aspects that can be sorted/faceted. Nct)zReturns a :class:`Categorizer` corresponding to this facet. :param global_searcher: A parent searcher. You can use this searcher if you need global document ID references. NotImplementedErrorselfglobal_searchers E/var/www/horilla/myenv/lib/python3.12/site-packages/whoosh/sorting.py categorizerzFacetType.categorizer+ "!cn|j}||}| tSt|tur|S|SN)maptype OrderedListtype)rdefaultts rmapz FacetType.map4s9 LL 9A 9= !W_3JHrcy)Nfacetrs r default_namezFacetType.default_name@srr)__name__ __module__ __qualname____doc__rrrr!rrrr r %sG" rr c0eZdZdZdZdZdZdZdZdZ y) CategorizeraBase class for categorizer objects which compute a key value for a document based on certain criteria, for use in sorting/faceting. Categorizers are created by FacetType objects through the :meth:`FacetType.categorizer` method. The :class:`whoosh.searching.Searcher` object passed to the ``categorizer`` method may be a composite searcher (that is, wrapping a multi-reader), but categorizers are always run **per-segment**, with segment-relative document numbers. The collector will call a categorizer's ``set_searcher`` method as it searches each segment to let the cateogorizer set up whatever segment- specific data it needs. ``Collector.allow_overlap`` should be ``True`` if the caller can use the ``keys_for`` method instead of ``key_for`` to group documents into potentially overlapping groups. The default is ``False``. If a categorizer subclass can categorize the document using only the document number, it should set ``Collector.needs_current`` to ``False`` (this is the default) and NOT USE the given matcher in the ``key_for`` or ``keys_for`` methods, since in that case ``segment_docnum`` is not guaranteed to be consistent with the given matcher. If a categorizer subclass needs to access information on the matcher, it should set ``needs_current`` to ``True``. This will prevent the caller from using optimizations that might leave the matcher in an inconsistent state. Fcy)a[Called by the collector when the collector moves to a new segment. The ``segment_searcher`` will be atomic. The ``docoffset`` is the offset of the segment's document numbers relative to the entire index. You can use the offset to get absolute index docnums by adding the offset to segment-relative docnums. Nrrsegment_searcher docoffsets r set_searcherzCategorizer.set_searcherds rct|dr|j|St|dr|j|St|j)aReturns a key for the current match. :param matcher: a :class:`whoosh.matching.Matcher` object. If ``self.needs_current`` is ``False``, DO NOT use this object, since it may be inconsistent. Use the given ``segment_docnum`` instead. :param segment_docnum: the segment-relative document number of the current match. key_for_idkey_for_matcher)hasattrr.r/r __class__rmatchersegment_docnums rkey_forzCategorizer.key_fornsH 4 &??>2 2 T, -''0 0!$..11rcft|dr|j|St|j)aYields a series of keys for the current match. This method will be called instead of ``key_for`` if ``self.allow_overlap`` is ``True``. :param matcher: a :class:`whoosh.matching.Matcher` object. If ``self.needs_current`` is ``False``, DO NOT use this object, since it may be inconsistent. Use the given ``segment_docnum`` instead. :param segment_docnum: the segment-relative document number of the current match. keys_for_id)r0r7r r1r2s rkeys_forzCategorizer.keys_fors. 4 '##N3 3!$..11rc|S)aReturns a representation of the key to be used as a dictionary key in faceting. For example, the sorting key for date fields is a large integer; this method translates it into a ``datetime`` object to make the groupings clearer. rrkeys r key_to_namezCategorizer.key_to_names  rN) r"r#r$r% allow_overlap needs_currentr,r5r8r<rrrr'r'Ds'8MM 2&2(rr'c(eZdZdZ ddZdZdZy) FieldFacetaSorts/facets by the contents of a field. For example, to sort by the contents of the "path" field in reverse order, and facet by the contents of the "tag" field:: paths = FieldFacet("path", reverse=True) tags = FieldFacet("tag") results = searcher.search(myquery, sortedby=paths, groupedby=tags) This facet returns different categorizers based on the field type. Nc<||_||_||_||_y)aG :param fieldname: the name of the field to sort/facet on. :param reverse: if True, when sorting, reverse the sort order of this facet. :param allow_overlap: if True, when grouping, allow documents to appear in multiple groups when they have multiple terms in the field. N) fieldnamereverser=r)rrBrCr=rs r__init__zFieldFacet.__init__s!# * rc|jSrrBr s rr!zFieldFacet.default_name ~~rcn|j}|j|}|jr t||S|j j |rK|j }|js |jst|||j}|St||}|St|||j}|Sr) rBschemar=OverlappingCategorizerreader has_column column_type reversiblerCColumnCategorizerReversedColumnCategorizerPostingCategorizer)rrrBfieldobjcoltypecs rrzFieldFacet.categorizersNN ")))4   )/9E E  ! ! # . .y 9**G!!%oy$,,O  .oyI#?I#'<<1Ar)FFN)r"r#r$r%rDr!rrrrr@r@s  @E rr@c,eZdZddZdZdZdZdZy)rOc||_|j|j|_|jj|_||_d|_yr) _fieldnamerI _fieldobjrM _column_type_reverse_creader)rrrBrCs rrDzColumnCategorizer.__init__sA#(//@ NN66  rc|jjd|jd|jd|jdS)N(, z , reverse=))r1r"rXrWrZr s r__repr__zColumnCategorizer.__repr__s-+/>>+B+B+/>>4??+/==: :rc~|j}|j|j|jd|_y)NF)rC translate)rK column_readerrWrZr[)rr*r+rs rr,zColumnCategorizer.set_searchers5  # # %04 27(9 rc8|jj|Sr)r[sort_keyr2s rr5zColumnCategorizer.key_fors}}%%n55rc8|jj|Sr)rXfrom_column_valuer:s rr<zColumnCategorizer.key_to_names~~//44rNF)r"r#r$rDr`r,r5r<rrrrOrOs: 9 65rrOc"eZdZdZdZdZdZy)rPz^Categorizer that reverses column values for columns that aren't naturally reversible. ctj||||j}|j|_|j |d}t t||_yNF)rb) rOrDrK doc_count_all _doccountrcsortedset_values)rrrBrKglobal_creaders rrDz"ReversedColumnCategorizer.__init__sX""4)D '')--/--i5-Ic.12 rc`|j|}|jj|}d|z SNr)r[rqindex)rr3r4valueorders rr5z!ReversedColumnCategorizer.key_fors. n- ""5)5yrcR|jd|z }tj||Srt)rqrOr<r:s rr<z%ReversedColumnCategorizer.key_to_name s'll1s7# ,,T377rN)r"r#r$r%rDr5r<rrrrPrPs3 8rrPc(eZdZdZdZdZdZdZy)rJTc:||_|j||_|j|}|j}t |j |_|j|xr|jj|_ d|_ d|_ d|_ yr)rWrIrXrKboolvector _use_vectorsrLrM stores_lists _use_column_segment_searcherr[_lists)rrrBfieldrKs rrDzOverlappingCategorizer.__init__s#(// :&&y1 '') ."--i8A % 1 1 > > @ "&  rc|j}||_|j}|jry|jr|j |d|_y|j}|j|}|j}t|Dcgc]}gc}|_ |j||D]O} || } |j|| } | jD] } |j| j| "Qycc}wrl)rWrrKr}rrcr[rmrI from_bytesrrsortable_termspostingsall_idsappend) rr*r+rBrKdcrr_btexttextrdocids rr,z#OverlappingCategorizer.set_searcher!sOO !1!((*       "00e0LDM"//1B$++I6E))J'-bz2!22DK--fi@ 4!%(!??9e<%--/4EKK&--d34 43s Dc|jr@ |jj||j}t |j S|jr|j|S|j|xsdgS#t $rgcYSwxYwr) r}rr|rWlistrKeyErrorrr[r)rr3rvs rr8zOverlappingCategorizer.keys_for8s    **11%IAIIK((  ==' ';;u%/$ /    s>A<< B  B c"|jr7 |jj||j}|j S|j r|jj|S|j|}|r|dSy#t $rYywxYwrt) r}rr|rWidrrr[rfr)rr3rrlss rr5zOverlappingCategorizer.key_forDs    **11%Ittv   ==))%0 0U#B!u   s5B B BN)r"r#r$r=rDr,r8r5rrrrJrJsM 4. 0rrJc(eZdZdZdZdZdZdZy)rQaa Categorizer for fields that don't store column values. This is very inefficient. Instead of relying on this categorizer you should plan for which fields you'll want to sort on and set ``sortable=True`` in their field type. This object builds an array caching the order of all documents according to the field, then uses the cached order as a numeric key. This is useful when a field cache is not available, and also for reversed fields (since field cache keys for non- numeric fields are arbitrary data, it's not possible to "negate" them to reverse the sort order). c||_||jvr|j|\|_|_y|j }|j }|j ||_|jj}g|_td|dzg|z|_|jj||}t|D]\\}} |jj|| |j|| } | jD]} ||j| <^|j|jf|j|<y)Ni)rC _field_cachesvaluesrrKrmrIrXrr enumeraterrr) rrrBrCrKrrbtextsrrrrs rrDzPostingCategorizer.__init__cs( 55 5&5&C&CI&N #DK%++-F%%'B,33I>DN22JDKsR!VHrM2DJ^^2269EF%f- *5 "":e#45!??9e<%--/*E()DJJu%*  *9= TZZ7PO ) )) 4rc ||_||_yr) _searcherr+r)s rr,zPostingCategorizer.set_searcher}s)"rc|j|z}|j|}|jrt|j|z }|Sr)r+rrClenr)rr3r4 global_docnumrs rr5zPostingCategorizer.key_fors=7 JJ} % <<DKK 1$Arc|t|jk\ry|jrt|j|z }|j|Sr)rrrC)rrs rr<zPostingCategorizer.key_to_names> DKK  <<DKK 1$A{{1~rN)r"r#r$r%rDr,r5r<rrrrQrQUs Q4#rrQc8eZdZdZ ddZdZGddeZy) QueryFacetz>Sorts/facets based on the results of a series of queries. Nc<||_||_||_||_y)z :param querydict: a dictionary mapping keys to :class:`whoosh.query.Query` objects. :param other: the key to use for documents that don't match any of the queries. N) querydictotherrr=)rrrr=rs rrDzQueryFacet.__init__s!#  *rcd|j|j|j|jSr)QueryCategorizerrrr=rs rrzQueryFacet.categorizers%$$T^^TZZASASTTrc&eZdZddZdZdZdZy)QueryFacet.QueryCategorizerc.||_||_||_yr)rrr=rrrr=s rrDz$QueryFacet.QueryCategorizer.__init__s&DNDJ!.D rci|_|jjD]1\}}t|j |}|s#||j|<3||_yr)docsetsritemsrpdocsoffset)rr*rqnameqdocsets rr,z(QueryFacet.QueryCategorizer.set_searchersWDL NN002 1qQVV$456*0DLL' 1!DKrcf|jD]}||j|vs|cS|jSr)rr)rr3rrs rr5z#QueryFacet.QueryCategorizer.key_fors7 !DLL// L !:: rc#pKd}|jD]}||j|vs|d}|sdyyw)NFT)r)rr3rfoundrs rr8z$QueryFacet.QueryCategorizer.keys_forsHE !DLL//K E ! s#66Nri)r"r#r$rDr,r5r8rrrrrs /  !   rr)NFN)r"r#r$r%rDrr'rrrrrrs'=B +U;rrc:eZdZdZ d dZdZdZdZdZdZ y) RangeFacetazSorts/facets based on numeric ranges. For textual ranges, use :class:`QueryFacet`. For example, to facet the "price" field into $100 buckets, up to $1000:: prices = RangeFacet("price", 0, 1000, 100) results = searcher.search(myquery, groupedby=prices) The ranges/buckets are always **inclusive** at the start and **exclusive** at the end. Ncx||_||_||_||_||_||_|j y)a :param fieldname: the numeric field to sort/facet on. :param start: the start of the entire range. :param end: the end of the entire range. :param gap: the size of each "bucket" in the range. This can be a sequence of sizes. For example, ``gap=[1,5,10]`` will use 1 as the size of the first bucket, 5 as the size of the second bucket, and 10 as the size of all subsequent buckets. :param hardend: if True, the end of the last bucket is clamped to the value of ``end``. If False (the default), the last bucket is always ``gap`` sized, even if that means the end of the last bucket is after ``end``. N)rBstartendgaphardendr_queries)rrBrrrrrs rrDzRangeFacet.__init__s7 #    rc|jSrrFr s rr!zRangeFacet.default_namerGrc&ddlm}|jSNr)query)whooshr NumericRangerrs r _rangetypezRangeFacet._rangetypes !!!rc ||fSrr)rstartvalendvals r _range_namezRangeFacet._range_names &!!rcL|jstd|jzt|jttfr|j}d}n|jg}d}|j }i|_|j}||jkr||}|dk\r|dz }|t|k(rd}||z}|jrt|j|}|j||}||j||d}||j |<|}||jkryy)NzNo gap secified (%r)rrT)endexcl)r Exception isinstancertuplerrrrrrminrrB) rgapsgapindex rangetypecstartthisgapcend rangenamers rrzRangeFacet._queriessxx2TXX=> > dhhu .88DHHH:DHOO% txx8nG1}A s4y(!HG#D||488T*((6I$..&$EA()DNN9 %FtxxrcJt|jj|Sr)rrrrs rrzRangeFacet.categorizers$..)55oFFr)FN) r"r#r$r%rDr!rrrrrrrrrs/ rDr,r5rrrrr@s  %  5 rrN)r"r#r$r%rr'rrrrrr3s6;rrc4eZdZdZddZdZGddeZy) FunctionFacetaThis facet type is low-level. In most cases you should use :class:`TranslateFacet` instead. This facet type ets you pass an arbitrary function that will compute the key. This may be easier than subclassing FacetType and Categorizer to set up the desired behavior. The function is called with the arguments ``(searcher, docid)``, where the ``searcher`` may be a composite searcher, and the ``docid`` is an absolute index document number (not segment-relative). For example, to use the number of words in the document's "content" field as the sorting/faceting key:: fn = lambda s, docid: s.doc_field_length(docid, "content") lengths = FunctionFacet(fn) Nc ||_||_yr)fnr)rrrs rrDzFunctionFacet.__init__gs rc:|j||jSr)FunctionCategorizerrrs rrzFunctionFacet.categorizerks''AArceZdZdZdZdZy)!FunctionFacet.FunctionCategorizerc ||_||_yr)rr)rrrs rrDz*FunctionFacet.FunctionCategorizer.__init__os#2D DGrc||_yr)rr)s rr,z.FunctionFacet.FunctionCategorizer.set_searcherss #DKrcT|j|j||jzSr)rrrrr3rs rr5z)FunctionFacet.FunctionCategorizer.key_forvs"774//1DE ErNr"r#r$rDr,r5rrrrrns  $ Frrr)r"r#r$r%rDrr'rrrrrrTs $B Fk Frrc2eZdZdZdZdZGddeZy)TranslateFacetaLets you specify a function to compute the key based on a key generated by a wrapped facet. This is useful if you want to use a custom ordering of a sortable field. For example, if you want to use an implementation of the Unicode Collation Algorithm (UCA) to sort a field using the rules from a particular language:: from pyuca import Collator # The Collator object has a sort_key() method which takes a unicode # string and returns a sort key c = Collator("allkeys.txt") # Make a facet object for the field you want to sort on facet = sorting.FieldFacet("name") # Wrap the facet in a TranslateFacet with the translation function # (the Collator object's sort_key method) facet = sorting.TranslateFacet(c.sort_key, facet) # Use the facet to sort the search results results = searcher.search(myquery, sortedby=facet) You can pass multiple facets to the c.||_||_d|_y)a :param fn: The function to apply. For each matching document, this function will be called with the values of the given facets as arguments. :param facets: One or more :class:`FacetType` objects. These facets are used to compute facet value(s) for a matching document, and then the value(s) is/are passed to the function. N)rfacetsr)rrrs rrDzTranslateFacet.__init__s  rc|jDcgc]}|j|}}|j|j|Scc}wr)rrTranslateCategorizerr)rrrcatterss rrzTranslateFacet.categorizersACG;;O%5$$_5OO(('::PsAceZdZdZdZdZy)#TranslateFacet.TranslateCategorizerc ||_||_yr)rr)rrrs rrDz,TranslateFacet.TranslateCategorizer.__init__sDG"DLrcJ|jD]}|j||yrrr,rr*r+catters rr,z0TranslateFacet.TranslateCategorizer.set_searcher(,, A##$4i@ Arc||jDcgc]}|j||}}|j|Scc}wr)rr5r)rr3r4r keyss rr5z+TranslateFacet.TranslateCategorizer.key_forsC"&,,0NN7N;0D0477D> !0s9Nrrrrrrs # A "rrN)r"r#r$r%rDrr'rrrrrrzs2 ; "{ "rrc>eZdZdZ ddZdZdZGddeZy) StoredFieldFacetaLets you sort/group using the value in an unindexed, stored field (e.g. :class:`whoosh.fields.STORED`). This is usually slower than using an indexed field. For fields where the stored value is a space-separated list of keywords, (e.g. ``"tag1 tag2 tag3"``), you can use the ``allow_overlap`` keyword argument to allow overlapped faceting on the result of calling the ``split()`` method on the field value (or calling a custom split function if one is supplied). Nc<||_||_||_||_y)af :param fieldname: the name of the stored field. :param allow_overlap: if True, when grouping, allow documents to appear in multiple groups when they have multiple terms in the field. The categorizer uses ``string.split()`` or the custom ``split_fn`` to convert the stored value into a list of facet values. :param split_fn: a custom function to split a stored field value into multiple facet values when ``allow_overlap`` is True. If not supplied, the categorizer simply calls the value's ``split()`` method. N)rBr=split_fnr)rrBr=rrs rrDzStoredFieldFacet.__init__s!#*   rc|jSrrFr s rr!zStoredFieldFacet.default_namerGrcd|j|j|j|jSr)StoredFieldCategorizerrBr=rrs rrzStoredFieldFacet.categorizers***4>>4;M;M+/==: :rc$eZdZdZdZdZdZy)'StoredFieldFacet.StoredFieldCategorizerc.||_||_||_yr)rBr=r)rrBr=rs rrDz0StoredFieldFacet.StoredFieldCategorizer.__init__s&DN!.D $DMrc||_yrrr)s rr,z4StoredFieldFacet.StoredFieldCategorizer.set_searcherrrc|jj|}|j|j}|jr|j |S|j Sr)r* stored_fieldsgetrBrsplit)rr3rdrvs rr8z0StoredFieldFacet.StoredFieldCategorizer.keys_forsL%%33E:AEE$..)E}}}}U++{{}$rcn|jj|}|j|jSr)r*rrrB)rr3rrs rr5z/StoredFieldFacet.StoredFieldCategorizer.key_fors+%%33E:A55( (rN)r"r#r$rDr,r8r5rrrrrs %  5 % )rr)FNN) r"r#r$r%rDr!rr'rrrrrrs, AE&:))rrcleZdZdZddZdZedZdZddZ ddZ d Z d Z d Z Gd d eZy) MultiFacetaFSorts/facets by the combination of multiple "sub-facets". For example, to sort by the value of the "tag" field, and then (for documents where the tag is the same) by the value of the "path" field:: facet = MultiFacet(FieldFacet("tag"), FieldFacet("path") results = searcher.search(myquery, sortedby=facet) As a shortcut, you can use strings to refer to field names, and they will be assumed to be field names and turned into FieldFacet objects:: facet = MultiFacet("tag", "path") You can also use the ``add_*`` methods to add criteria to the multifacet:: facet = MultiFacet() facet.add_field("tag") facet.add_field("path", reverse=True) facet.add_query({"a-m": TermRange("name", "a", "m"), "n-z": TermRange("name", "n", "z")}) NcTg|_|r|D]}|j|||_yr)r_addr)rrritems rrDzMultiFacet.__init__s-   $  rch|jjd|jd|jdS)Nr]r^r_)r1r"rrr s rr`zMultiFacet.__repr__s'#~~66#{{#||- -rc|}t|tr|j||St|ttfs t |dr|D]}|j||S|j||S)N__iter__)rrr"rrr0)clssortedbymultir#s r from_sortedbyzMultiFacet.from_sortedbysu h , JJx  D%=1:.  ! 4  !  JJx  rct|tr|j|yt|tr|j |yt d|)Nz!Don't know what to do with facet )rr add_facetr add_fieldr)rr#s rr"zMultiFacet._add s< dI & NN4 k * NN4 TKL LrcR|jjt|||S)N)rC)rrr@)rrBrCs rr-zMultiFacet.add_field(s  :iAB rcT|jjt||||S)N)rr=)rrrrs r add_queryzMultiFacet.add_query,s) :iu4AC D rcL|jjt|Sr)rrrr s r add_scorezMultiFacet.add_score1s :<( rcxt|tst|d|jj ||S)Nz5 is not a facet object, perhaps you meant add_field())rr TypeErrorrr)rrs rr,zMultiFacet.add_facet5s8%+-256 6 5! rc|js tdt|jdk(r |jdj|}|S|j |jDcgc]}|j|c}}|Scc}w)Nz No facetsrr)rrrrMultiCategorizer)rrr rs rrzMultiFacet.categorizer<s{{K( (   "[[^//@F **9=,F05-2,=,=o,N,FGF ,Fs)B c4eZdZdZedZdZdZdZy)MultiFacet.MultiCategorizerc||_yr)r)rrs rrDz$MultiFacet.MultiCategorizer.__init__Gs "DLrc:td|jDS)Nc34K|]}|jywr)r>).0rTs r z.Ls=1q=s)anyrr s rr>z)MultiFacet.MultiCategorizer.needs_currentJs= == =rcJ|jD]}|j||yrrr s rr,z(MultiFacet.MultiCategorizer.set_searcherNr rcDtfd|jDS)Nc3BK|]}|jywr)r5)r<r rr3s rr=z6MultiFacet.MultiCategorizer.key_for..Ss$5# 75s)rrrs ``rr5z#MultiFacet.MultiCategorizer.key_forRs!5'+||55 5rcNtdt|j|DS)Nc3DK|]\}}|j|ywr)r<)r<r keyparts rr=z:MultiFacet.MultiCategorizer.key_to_name..Ws'5,VW ++G45s )rrrr:s rr<z'MultiFacet.MultiCategorizer.key_to_nameVs'5 s355 5rN) r"r#r$rDpropertyr>r,r5r<rrrr6r8Fs+ #  >  > A 5 5rr6)NNri)NF)r"r#r$r%rDr` classmethodr*r"r-r0r2r,rr'r6rrrr r sP,-   M 5;5rr cNeZdZdZd dZedZdZdZdZ dZ d Z d d Z y) FacetsaMaps facet names to :class:`FacetType` objects, for creating multiple groupings of documents. For example, to group by tag, and **also** group by price range:: facets = Facets() facets.add_field("tag") facets.add_facet("price", RangeFacet("price", 0, 1000, 100)) results = searcher.search(myquery, groupedby=facets) tag_groups = results.groups("tag") price_groups = results.groups("price") (To group by the combination of multiple facets, use :class:`MultiFacet`.) Nc:i|_|r|j|yyr)r add_facets)rxs rrDzFacets.__init__ms OOA  rc|}t||tfr|j||St|tr|j ||St|t r"|j |j||St|ttfr)|D]"}|j|j|$|Std|z)Nz'Don't know what to do with groupedby=%r) rdictrJrr-r r,r!rrfrom_groupedbyr)r' groupedbyrr#s rrNzFacets.from_groupedbyrs i#t -   i (  ; /   Y '  9 -   Y335y A  D%= 1! <!!#"4"4T":; <  E'() )rc,t|jS)z?Returns an iterator of the facet names in this object. )iterrr s rnamesz Facets.namessDKK  rc6|jjS)zaReturns a list of (facetname, facetobject) tuples for the facets in this object. )rrr s rrz Facets.itemss {{  ""rc 8t|fi||j|<|S)z~Adds a :class:`FieldFacet` for the given field name (the field name is automatically used as the facet name). )r@r)rrBkwargss rr-zFacets.add_fields! ",I!@!@ I rc 8t|fi||j|<|S)zAdds a :class:`QueryFacet` under the given ``name``. :param name: a name for the facet. :param querydict: a dictionary mapping keys to :class:`whoosh.query.Query` objects. )rr)rnamerrUs rr0zFacets.add_querys!'y;F; D rcft|tst|d|d||j|<|S)zCAdds a :class:`FacetType` object under the given ``name``. :z is not a facet)rr rr)rrWrs rr,zFacets.add_facets1%+dEBC C! D rct|ttfstd|z|j D]%\}}|s||j vs||j |<'|S)z]Adds the contents of the given ``Facets`` or ``dict`` object to this object. z!%r is not a Facets object or dict)rrMrHrrr)rrreplacerWrs rrJzFacets.add_facetss_ &4.1?&HI I!<<> *KD%$dkk1$) D! * rr)T) r"r#r$r%rDrFrNrRrr-r0r,rJrrrrHrH\s>  "! #  rrHceZdZdZdZdZy)FacetMapaKBase class for objects holding the results of grouping search results by a Facet. Use an object's ``as_dict()`` method to access the results. You can pass a subclass of this to the ``maptype`` keyword argument when creating a ``FacetType`` object to specify what information the facet should record about the group. For example:: # Record each document in each group in its sorted order myfacet = FieldFacet("size", maptype=OrderedList) # Record only the count of documents in each group myfacet = FieldFacet("size", maptype=Count) ct)a*Adds a document to the facet results. :param groupname: the name of the group to add this document to. :param docid: the document number of the document to add. :param sortkey: a value representing the sort position of the document in the full results. r r groupnamersortkeys raddz FacetMap.adds "!rct)zReturns a dictionary object mapping group names to implementation-specific values. For example, the value might be a list of document numbers, or a integer representing the number of documents in the group. r r s ras_dictzFacetMap.as_dictrrN)r"r#r$r%rbrdrrrr]r]s  ""rr]c(eZdZdZdZdZdZdZy)rzStores a list of document numbers for each group, in the same order as they appear in the search results. The ``as_dict`` method returns a dictionary mapping group names to lists of document numbers. c,tt|_yrrrrMr s rrDzOrderedList.__init__% rcPd|jjd|jdSN< >r1r"rMr s rr`zOrderedList.__repr__ NN33TYY??rcD|j|j||fyrrMrr_s rrbzOrderedList.adds )##We$45rci}t|jD]&\}}t|Dcgc]\}}| c}}||<(|Scc}}wr)rrMro)rrr;rrdocnums rrdzOrderedList.as_dictsI #DII. =JC.4Um<Ff>> from whoosh import index, sorting >>> ix = index.open_dir("indexdir") >>> with ix.writer() as w: ... facet = sorting.FieldFacet("price") ... sorting.add_sortable(w, "price", facet) ... :param writer: a :class:`whoosh.writing.IndexWriter` object. :param fieldname: the name of the field to add the per-document sortable values to. If this field doesn't exist in the writer's schema, the function will add a :class:`whoosh.fields.COLUMN` field to the schema, and you must specify the column object to using the ``column`` keyword argument. :param facet: a :class:`FacetType` object to use to generate the per-document values. :param column: a :class:`whosh.columns.ColumnType` object to use to store the per-document values. If you don't specify a column object, the function will use the default column type for the given field. Nz%r field is already sortabler)COLUMNzField %r does not existz%r field already has a column)storagerIrMr whoosh.fieldsrrbdefault_columnsearcherrleaf_searchersr,rKrLcodecsegmentcolumn_filename create_filewriter all_doc_idsr<r5to_column_valuefinishrmclose)rrBrcolumnrrIrrrr  subsearcherr+rKrrcolnamecolfile colwriterrsrcvs r add_sortabler=s0nnG ]]F EFy!   :YFG G F " ,6NE JJy% (  ))+F5 AB B H   x (F"*"9"9"; YK3##%   Y ';iGH H .."'';%%g.  g.I ,,. *&&v~~dF'CD**1- fb) *   V113 4 MMO),E MMOs B G))G;r)r collectionsr whoosh.compatrrrrobjectr r'r@rOrPrJrQrrrrrrrr rHr]rrvr~rrrrrrs48#%11 >X&Xz44n5 5:8 184C[CL88z00fOGOGdZ8B#FI#FL7"Y7"t9)y9)xi5i5X[V[@!"v!"H(0H.H(84Dr