W h(HSSKrSSKrSSKrSSKrSSKJr SSKrSSKrSSKJ r J r SSK J r SSK Jr SSKJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJrJrJrJr SS K J!r!J"r"J#r#J$r$J%r% SSK&J'r'J(r( SSK)J*r* SSK+J,r, SSK-J.r.J/r/ Sr0Sr1Sr2Sr3Sr4Sr5"SS5r6g)N)Mapping)SON json_util)Code)ReturnDocument)validate_read_preference) ReadConcern)signals) get_document) _import_class)get_db)!no_dereferencing_active_for_classset_read_write_concernset_write_concern switch_db)BulkWriteErrorInvalidQueryError LookUpErrorNotUniqueErrorOperationError)LEGACY_JSON_OPTIONScount_documents) transform)QueryFieldList)QQNode) BaseQuerySet DO_NOTHINGNULLIFYCASCADEDENYPULLc\rSrSrSrSrSTSjrSrSrSr S r S r S r S r S rSUSjrSrSrSrSVSjrSWSjrSXSjrSYSjrSZSjrS[SjrS\SjrSrSrSrSrSrSrSr S]S jr!S!r"S"r#STS#jr$STS$jr%S%r&S&r'S'r(S(r)SWS)jr*S*r+SS+.S,jr,S-r-S.r.S/r/S0r0S1r1S2r2S3r3S4r4S5r5S6r6S7r7S8r8S9r9S:r:S;r;S^S<jrr>S?r?S@r@S_SAjrASBrBSCrC\DSD5rE\DSE5rF\DSF5rGSGrH\DSH5rI\DSI5rJ\DSJ5rKSKrLSWSLjrMSWSMjrNSNrOSOrPSPrQSQrRSRrSSSrTg)`r2zA set of results returned from a query. Wraps a MongoDB cursor, providing :class:`~mongoengine.Document` objects as the results. cXlX lSUl[5Ul0UlSUl[5UlSUl SUl SUl SUl SUl SUlSUl/UlSUlSUlSUlSUlSUlSUlUR.R1S5SLar[3URR45S:Xa!SURR4S0UlOSSURR400Ul[S/S9UlSUlSUlSUlS UlSUlSUl SUl!SUl"SUl#g) NFTallow_inheritancer#_clsr$inalways_include)$ _document_collection_obj _mongo_queryr _query_obj _cls_query _where_clauser_loaded_fields _ordering _snapshot_timeout_allow_disk_use_read_preference _read_concern_iter_scalar_none _as_pymongo _search_text_search_text_score_BaseQuerySet__dereference_BaseQuerySet__auto_dereference_metagetlen _subclasses _cursor_obj_limit_skip_hint _collation _batch_size _max_time_ms_comment_empty)selfdocument collections aC:\Users\julio\Documents\inmuebles-mzt\backend\env\Lib\site-packages\mongoengine/queryset/base.py__init__BaseQuerySet.__init__7s\!) #!,. $ $!     "&""& >>  1 2d :4>>--.!3#)4>>+E+Ea+H"I#)E4>>3M3M+N"O"0"ID       Nc [S0UD6nU(a)[U[5(dSU-n[U5eX!-nUR 5nU=R U-slSUlSUlU$)aFilter the selected documents by calling the :class:`~mongoengine.queryset.QuerySet` with a query. :param q_obj: a :class:`~mongoengine.queryset.Q` object to be used in the query; the :class:`~mongoengine.queryset.QuerySet` is filtered multiple times with different :class:`~mongoengine.queryset.Q` objects, only the last one will be used. :param query: Django-style query keyword arguments. z8Not a query object: %s. Did you intend to use key=value?N)r isinstancerrcloner3r2rI)rRq_objquerymsgquerysets rU__call__BaseQuerySet.__call__isv E  eU++79>?(,, NE::<u$ $#rXcfURR5nURS5 SUS'U$)W Need for pickling queryset See https://github.com/MongoEngine/mongoengine/issues/442 r1NrI)__dict__copypoprRobj_dicts rU __getstate__BaseQuerySet.__getstate__s6==%%'  &'#'rXcfUSR5US'URRU5 g)rdr0r1N)_get_collectionreupdaterhs rU __setstate__BaseQuerySet.__setstate__s1'/{&;&K&K&M"# X&rXcUR5nSUl[U[5(aURUUlUR URsUlUl UR (a/UR(aURUR - Ul URS:XaSUlU$[U[5(aUR(a@URURRURUURS95$UR (aURU$URRURUURS9$[#S5e)aKReturn a document instance corresponding to a given index if the key is an integer. If the key is a slice, translate its bounds into a skip and a limit, and return a cloned queryset with that skip/limit applied. For example: >>> User.objects[0] >>> User.objects[1:3] [, ] FrT_auto_dereferencez#Provide a slice or an integer index)r\rQr[slice_cursorrIstartstoprKrJintr> _get_scalarr0 _from_sonrsr@ TypeError)rRkeyr`s rU __getitem__BaseQuerySet.__getitem__sE::< c5 ! !#+#3#3C#8H .1ii +HNHOyySXX"%((SYY"6!#"&OS ! !++&&00 ((-*.*@*@1##'',,%%//  %"&"8"80  =>>rXc[eN)NotImplementedErrorrRs rU__iter__BaseQuerySet.__iter__s!!rXcLUR5nUR5cS$S$)z#Return True if cursor has any data.FT)order_byfirstrRr`s rU _has_dataBaseQuerySet._has_datas$==? (0u:d:rXc"UR5$)z/Avoid to open all records in an if stmt in Py3.)rrs rU__bool__BaseQuerySet.__bool__s~~rXc"UR5$)z'Returns a copy of the current QuerySet.rars rUallBaseQuerySet.alls}}rXc&UR"U0UD6$)z;An alias of :meth:`~mongoengine.queryset.QuerySet.__call__`r)rRq_objsr^s rUfilterBaseQuerySet.filters}}f...rXcUR5nUR(a [S5e[SU05nU(aX%S'U=R[ SU0S9-slSUlSUlXlX4lU$)a Start a text search, using text indexes. Require: MongoDB server version 2.6+. :param language: The language that determines the list of stop words for the search and the rules for the stemmer and tokenizer. If not specified, the search uses the default language of the index. For supported languages, see `Text Search Languages `. :param text_score: True to have it return the text_score (available through get_text_score()), False to disable that Note that unless you order the results, leaving text_score=True may provide randomness in the returned documents z0It is not possible to use search_text two times.z$searchz $languagez$text__raw__N) r\rArrr3rr2rIrB)rRtextlanguage text_scorer` query_kwargss rU search_textBaseQuerySet.search_textsz::<   !ST TIt,- (0 %q'<)@AA $# $&0#rXcUR5nUR5RS5nUR"U0UD6n[ U5n[ U5 UR RS5e![ a5 SUR R-nUR RU5ef=f![ a Us$f=f)a Retrieve the matching object raising :class:`~mongoengine.queryset.MultipleObjectsReturned` or `DocumentName.MultipleObjectsReturned` exception if multiple results and :class:`~mongoengine.queryset.DoesNotExist` or `DocumentName.DoesNotExist` if no results are found. r$z!%s matching query does not exist.z&2 or more items returned, instead of 1) r\rlimitrnext StopIterationr0 _class_name DoesNotExistMultipleObjectsReturned)rRrr^r`resultr_s rUrFBaseQuerySet.gets::<$$&,,Q/??F4e4 7(^F   N   88 4   758J8J8V8VVC$$11#6 6 7 M s A5 B75?B47 CCc @UR"S0UD6RSS9$)z5Create new object. Returns the saved object instance.T) force_insertrZ)r0save)rRkwargss rUcreateBaseQuerySet.create"s"~~'',,$,??rXcUR5nUR(dUR(agUSnU$![a SnU$f=f)z-Retrieve the first object matching the query.Nr)r\r?rQ IndexError)rRr`rs rUrBaseQuerySet.first&sM::< :: a[F  F  s< A  A c~[S5nUc0nUnSn[Xe5(d[URU5(aSnU/nUHqn[XR5(d#S[ UR5-n [ U 5eUR(dMSUR(aMfSn [ U 5e U=(d 0n[RR"UR4SU0UD6 UVs/sHoR5PM n n[URU5n U Rn U(aU Sn U R n SSS5 W "U 5n U(a U R"/O U R$n[9Xn5H unnUUlM U(d<[R:R"UR4USS .UD6 U(aUS$U$UR=U5nUVs/sHnUR?U5PM nn[R:R"UR4USS .UD6 U(aUS$U$s snf!,(df  GN =f![&R(R*anS n[-UU-5eSnAf[&R(R.anS n[/UUR0-5eSnAf[&R(R2aJnS n[4R6"S [ U55(aS n[-UU-5e[ UU-5eSnAff=fs snf)abulk insert documents :param doc_or_docs: a document or list of documents to be inserted :param load_bulk (optional): If True returns the list of document instances :param write_concern: Extra keyword arguments are passed down to :meth:`~pymongo.collection.Collection.insert` which will be used as options for the resultant ``getLastError`` command. For example, ``insert(..., {w: 2, fsync: True})`` will wait until at least two servers have recorded the write and will force an fsync on each server being written to. :param signal_kwargs: (optional) kwargs dictionary to be passed to the signal calls. By default returns document instances, set ``load_bulk`` to False to return just ``ObjectIds`` DocumentNFTz.Some documents inserted aren't instances of %sz7Some documents have ObjectIds, use doc.update() instead documentsrzCould not save document (%s)zBulk write error: (%s)z^E1100[01] duplicate keyz(Tried to save duplicate unique keys (%s))rloaded) r r[ issubclass __class__r0strrpk_createdr pre_bulk_insertsendto_mongor _collection insert_many insert_one inserted_id inserted_idspymongoerrorsDuplicateKeyErrorrrdetailsOperationFailurerematchzippost_bulk_insertin_bulkrF)rR doc_or_docs load_bulk write_concern signal_kwargsrdocs return_onedocr_rawrT insert_funcinserted_resultidserrmessagedoc_idrobj_idresultss rUinsertBaseQuerySet.insert2s*!,  M d % %DNNH)M)MJ6DCc>>22FNNJ%S))vvvclllO$S))&+ $$T^^UtU}U)-.#||~. t// ?:$00K!f(33 @  0)#.O!,,-$11 .t>KCCF*  $ $ ) ) *.u @M (3q6 0S 0LL% 7:;sV9==(s;  %% NN &-d >K (wqz4W4_/ ? ?~~// 04G 3/ /~~,, 8/G 3;;!67 7~~.. 04Gxx2CH==E$Ws]33 3/ / 0((aUR@sSSS5 $SSS5 g!,(df  g=f)aDelete the documents matched by the query. :param write_concern: Extra keyword arguments are passed down which will be used as options for the resultant ``getLastError`` command. For example, ``save(..., write_concern={w: 2, fsync: True}, ...)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. :param _from_doc_delete: True when called from document delete therefore signals will have been triggered so don't loop. :returns number of deleted documents Nrr# delete_rulesabstract__inzCould not delete document (.z refers to it)pk__nin)r cascade_refsrz unset__%sz pull_all__%srZ)!r\r0r signals_available pre_deletehas_receivers_for post_deleterKrJdeleterErFlistitemsr!objectsrrr__name__r setraddidrrnr"r delete_manyr acknowledged deleted_count)rRr_from_doc_deleterr`rhas_delete_signalcall_document_deletecntr rule_entryrule document_cls field_namerefsrefrTrs rUrBaseQuerySet.deletes::<    M$55    0 0 5 :""44S9  NN Bhoo B1B #""  C +]+q Jyy}}^4: L..01 !- J'1 $L!!%%j11t|#++JzF/BD.IJ::a=&&(1,('00*>!-!- J'1 $L!!%%j11w(4(&>>'$((0 (#++!F*D)\J::SU;aURRUSS'OSURR0US'[URX45n U Rn U(a U Rn U "XXS9n SSS5 U(aW $W R(aU RS$gs sn f!,(df  N==f![ R"R$an['S U-5eSnAf[ R"R(a/n[+U5S :Xa S n[U5e[S U-5eSnAff=f) aPerform an atomic update on the fields matched by the query. :param upsert: insert if document doesn't exist (default ``False``) :param multi: Update multiple documents. :param write_concern: Extra keyword arguments are passed down which will be used as options for the resultant ``getLastError`` command. For example, ``save(..., write_concern={w: 2, fsync: True}, ...)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. :param read_concern: Override the read concern for the operation :param full_result: Return the associated ``pymongo.UpdateResult`` rather than just the number updated items :param array_filters: A list of filters specifying which array elements an update should apply. :param update: Django-style update keyword arguments :returns the number of updated documents (unless ``full_result`` is True) z'No update parameters, would remove dataNrrr+z$set)upsert array_filtersnUpdate failed (%s)zmulti not coded yetz'update() method requires MongoDB 1.1.3+)rr?rQr\rr[rrrnr0rrr update_one update_many raw_resultrrrrrr)rRrmultir read_concern full_resultr rnr`r^urT update_funcrrrs rUrnBaseQuerySet.updates8f !JK K  M ::::<  : 9 t$ $  **A  !3!3F 1~F* F %%h&8&8CFCF fo)1););)G)Gvv&"((*<*<*H*H!Iv ='$$m(33 ","8"8K$&  ""((--#3~~// = !5!;< <~~.. =3x00C$W-- !5!;< <  =sH-F F%6'FF%.F% F"F%%H!G!H!2*HH!c UR"SSSUUSS.UD6nURS(aUR5nU$URRR UR 5nU$)a'Overwrite or add the first document matched by the query. :param write_concern: Extra keyword arguments are passed down which will be used as options for the resultant ``getLastError`` command. For example, ``save(..., write_concern={w: 2, fsync: True}, ...)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. :param read_concern: Override the read concern for the operation :param update: Django-style update keyword arguments :returns the new or overwritten document FT)rrrrrupdatedExistingrZ)rnrrFr0rwith_id upserted_id)rRrrrn atomic_updaterSs rU upsert_oneBaseQuerySet.upsert_one_sz  '%      # #$5 6xxzH~~--55m6O6OPHrXc 2UR"SUSUUUS.UD6$)aDPerform an atomic update on the fields of the first document matched by the query. :param upsert: insert if document doesn't exist (default ``False``) :param write_concern: Extra keyword arguments are passed down which will be used as options for the resultant ``getLastError`` command. For example, ``save(..., write_concern={w: 2, fsync: True}, ...)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. :param full_result: Return the associated ``pymongo.UpdateResult`` rather than just the number updated items :param array_filters: A list of filters specifying which array elements an update should apply. :param update: Django-style update keyword arguments full_result :returns the number of updated documents (unless ``full_result`` is True) F)rrrrr rZ)rn)rRrrrr rns rUr BaseQuerySet.update_one}s32{{ '#'     rXc U(aU(a [S5eU(dU(dU(d [S5eUR(dUR(agUR5nURnU(d![ R "UR40UD6nURn U(aSn [R"U [5 U(a*URR"U4SU 0URD6n OVU(a[R n O[R"n URR$"UU4UU U US.URD6n U(a)U Sb!URR1U S5U S'U $U bURR1U 5n U $![&R(R*an [-SU -5eSn A f[&R(R.an [SU -5eSn A ff=f) aUpdate and return the updated document. Returns either the document before or after modification based on `new` parameter. If no documents match the query and `upsert` is false, returns ``None``. If upserting and `new` is false, returns ``None``. If the full_response parameter is ``True``, the return value will be the entire response object from the server, including the 'ok' and 'lastErrorObject' fields, rather than just the modified document. This is useful mainly because the 'lastErrorObject' document holds information about the command's execution. :param upsert: insert if document doesn't exist (default ``False``) :param full_response: return the entire response object from the server (default ``False``, not available for PyMongo 3+) :param remove: remove rather than updating (default ``False``) :param new: return updated rather than original document (default ``False``) :param array_filters: A list of filters specifying which array elements an update should apply. :param update: Django-style update keyword arguments z&Conflicting parameters: remove and newz2No update parameters, must either update or removeNzEWith PyMongo 3+, it is not possible anymore to get the full response.sort)rrreturn_documentr r value)rr?rQr\rrrnr0r7warningswarnDeprecationWarningrfind_one_and_delete _cursor_argsrAFTERBEFOREfind_one_and_updaterrrrrrz)rRr full_responseremovenewr rnr`r^rr_r return_docrs rUmodifyBaseQuerySet.modifys> c !IJ JfV !UV V ::::<%%h&8&8CFCF!! =] c#56!--AA $(,(9(9!/!5!5J!/!6!6J!--AA"$."/ '' g*"&..":":6'?"Kw  !11&9 ~~// = !5!;< <~~.. = !5!;< < =s,.AF)AF))H G!H 6HH cUR5nUR(a Sn[U5eURUS9R 5$)zRetrieve the object matching the id provided. Uses `object_id` only and raises InvalidQueryError if a filter has been applied. Returns `None` if no document exists with that id. :param object_id: the value for the id of the document to look up z*Cannot use a filter whilst using `with_id`)r)r\r3rrr)rR object_idr`r_s rUrBaseQuerySet.with_idsB::<   >C#C( (),2244rXc0nURR"SSU0040URD6nUR(a:UH2nUR UR R U55X$S'M4 U$UR(aUH nXBUS'M U$UH,nUR R UURS9X$S'M. U$)zRetrieve a set of documents by their ids. :param object_ids: a list or tuple of ObjectId's :rtype: dict of ObjectId's as keys and collection-specific Document subclasses as values. _idr,rr) rfindr&r>ryr0rzr@rs)rR object_idsdoc_maprrs rUrBaseQuerySet.in_bulks$$eeZ-@%AWTEVEVW <<&*&6&6t~~7O7OPS7T&UE #  &)E # &*nn&>&>&*&<&<'?'E # rXc4UR5nSUlU$)zReturns a queryset that never returns any objects and no query will be executed when accessing the results inspired by django none() https://docs.djangoproject.com/en/dev/ref/models/querysets/#none T)r\r?rs rUnoneBaseQuerySet.nones::<rXcURRRS5SLaSURR0UlU$)zaFilter for only the instances of this specific document. Do NOT return any inherited documents. r*Tr+)r0rErFrr4rs rUno_sub_classesBaseQuerySet.no_sub_classess= >>   # #$7 8D @%t~~'A'ABDO rXc[URU5nUR5nSSS5 URUR URW55$!,(df  N9=f)zThis method is for controlling which database the QuerySet will be evaluated against if you are using more than one database. :param alias: The database alias N)rr0rm _clone_intor)rRaliasclsrTs rUusingBaseQuerySet.using)sRt~~u -,,.J.t~~z JKK. -s A A)clURURURUR55$)z&Create a copy of the current queryset.)r@rr0r1rs rUr\BaseQuerySet.clone5s(t~~t?S?S TUUrXcN[U[5(d[SUR-5eSnUH.n[ X5n[ X[ R "U55 M0 URUlUR(aURR5UlU$)zCopy all the relevant properties of this queryset to a new queryset (which has to be an instance of :class:`~mongoengine.queryset.base.BaseQuerySet`). z$%s is not a subclass of BaseQuerySet)r2r4r?r3r5r6r7r8r9r:r;r<r=r>r@rJrKrQrLrMrArBrOrPrN) r[rrrgetattrsetattrrfrDrIr\)rRnew_qs copy_propspropvals rUr@BaseQuerySet._clone_into9s &,// 6H  8D$%C F$))C. 1%)$H$H!   !%!1!1!7!7!9F  rXcJUS- nUR5nURX!S9$)zHandles dereferencing of :class:`~bson.dbref.DBRef` objects or :class:`~bson.object_id.ObjectId` a maximum depth in order to cut down the number queries to mongodb. r#) max_depth)r\ _dereference)rRrPr`s rUselect_relatedBaseQuerySet.select_relatedjs, Q ::<$$X$CCrXcUR5nXlSUlUR(a%URR UR5 U$)aLimit the number of returned documents to `n`. This may also be achieved using array-slicing syntax (e.g. ``User.objects[:5]``). :param n: the maximum number of objects to return if n is greater than 0. When 0 is passed, returns all the documents in the cursor F)r\rJrQrIrrRr r`s rUrBaseQuerySet.limittsC::<     & &x 7rXcUR5nXlUR(a%URRUR5 U$)zSkip `n` documents before returning the results. This may also be achieved using array-slicing syntax (e.g. ``User.objects[5:]``). :param n: the number of objects to skip before returning results )r\rKrIrrUs rUrBaseQuerySet.skips< ::<     % %hnn 5rXcUR5nXlUR(a%URRUR5 U$)aAdded 'hint' support, telling Mongo the proper index to use for the query. Judicious use of hints can greatly improve query performance. When doing a query on multiple fields (at least one of which is indexed) pass the indexed field as a hint to the query. Hinting will not do anything if the corresponding index does not exist. The last hint applied to this cursor takes precedence over all others. )r\rLrIr)rRindexr`s rUrBaseQuerySet.hints<::<     % %hnn 5rXcUR5nXlUR(aURRU5 U$)a Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks. :param collation: `~pymongo.collation.Collation` or dict with following fields: { locale: str, caseLevel: bool, caseFirst: str, strength: int, numericOrdering: bool, alternate: str, maxVariable: str, backwards: str } Collation should be added to indexes like in test example )r\rMrIr)rRrr`s rUrBaseQuerySet.collations7$::<'     * *9 5rXcUR5nXlUR(a%URRUR5 U$)zLimit the number of documents returned in a single batch (each batch requires a round trip to the server). See https://pymongo.readthedocs.io/en/stable/api/pymongo/cursor.html#pymongo.cursor.Cursor for details. :param size: desired size of each batch. )r\rNrI batch_size)rRsizer`s rUr_BaseQuerySet.batch_sizes?::<#     + +H,@,@ ArXcUR5nURU/5R5nURR U5nUR (dU$URUSXRS9nURRRURSS5S5nSn[S5n[S5n[S5n [XX5(a [US U5n[XWU 45(a [US S5nSU;aURS5SSHhn U(a[XWU 45(aUn[XZU5n[XX5(a [US U5n[XWU 45(dM[[US S5nMj U(a)[XWU 45(aUV s/sH o"S 0U D6PM nn U$![a GNf=fs sn f) zReturn a list of distinct values for a given field. :param field: the field to select distinct values from .. note:: This is a command and won't take ordering or limit into account. r#)nameinstancerrNEmbeddedDocumentField ListFieldGenericEmbeddedDocumentFieldfield document_typerZ)r\_fields_to_dbfieldsrgrrudistinctrsrQr0_fieldsrFsplitr r[rH) rRrhr` raw_valuesrk doc_fieldrdrerfrg field_partrs rUrkBaseQuerySet.distincts::< ,,eW599;E%%..u5 %% $$Z$XNN**..u{{3/B1/EF !..E F!+. '45S'T$ i + + 7I>I i9U!V W Wy/4@H %<#kk#.qr2  7ST!!!)I#I9E i33 ' 7I FI7ST 'y/4HH3  /KL  4<<8C38H<Y   T=s G 5G GGcpUVs0sHo"[R_M nnUR"S0UD6$s snf)aLoad only a subset of this document's fields. :: post = BlogPost.objects(...).only('title', 'author.name') .. note :: `only()` is chainable and will perform a union :: So with the following it will fetch both: `title` and `author.name`:: post = BlogPost.objects.only('title').only('author.name') :func:`~mongoengine.queryset.QuerySet.all_fields` will reset any field filters. :param fields: fields to include )T)rONLYfieldsrRrtfs rUonlyBaseQuerySet.onlys8399&Q^(((&9{{*6**:3cpUVs0sHo"[R_M nnUR"S0UD6$s snf)aOpposite to .only(), exclude some document's fields. :: post = BlogPost.objects(...).exclude('comments') .. note :: `exclude()` is chainable and will perform a union :: So with the following it will exclude both: `title` and `author.name`:: post = BlogPost.objects.exclude('title').exclude('author.name') :func:`~mongoengine.queryset.QuerySet.all_fields` will reset any field filters. :param fields: fields to exclude rZ)rEXCLUDErtrus rUexcludeBaseQuerySet.exclude s86<._sort_keyXs"HA%%% rX)r|c US$)Nr#rZ)xs rU%BaseQuerySet.fields..cs!rX)r! _only_called) rrmrgjoinappendsortedr\ itertoolsgroupbyrjr6r)rRrr operatorscleaned_fieldsr|r!partsoprrtr`grouprhs rUrtBaseQuerySet.fields2s2k*  ,,.JCIIdOEQx9$YYq\r5)((5/C  ! !3, / )  6::<%--fnELE056 eF611&9F  # #~e,(  #F 7s3C9cjUR5n[URRS9UlU$)zInclude all fields. Reset all previously calls of .only() or .exclude(). :: post = BlogPost.objects.exclude('comments').all_fields() r-)r\rr6r.rs rU all_fieldsBaseQuerySet.all_fieldsls2 ::<"0#22AA# rXrc6U(aU(a [S5eUR5nURnU(aUnOURU5nUR(a1U(aURR U5 OU(aSUlXSlU$)aOrder the :class:`~mongoengine.queryset.QuerySet` by the given keys. The order may be specified by prepending each of the keys by a "+" or a "-". Ascending order is assumed if there's no prefix. If no keys are passed, existing ordering is cleared instead. :param keys: fields to order the query results by; keys may be prefixed with "+" or a "-" to determine the ordering direction. :param __raw__: a raw pymongo "sort" argument (provided as a list of (key, direction)) see 'key_or_list' in `pymongo.cursor.Cursor.sort doc `. If both keys and __raw__ are provided, an exception is raised z2Can not use both keys and __raw__ with order_by() N)rr\r7 _get_order_byrIr)rRrkeysr` old_ordering new_orderings rUrBaseQuerySet.order_byxs{ t !UV V::<)) "L#11$7L   $$)),7 '+$)rXc4UR5n0UlU$)a2Clear the default "_cls" query. By default, all queries generated for documents that allow inheritance include an extra "_cls" clause. In most cases this is desirable, but sometimes you might achieve better performance if you clear that default query. Scan the code for `_cls_query` to get more details. )r\r4rs rUclear_cls_queryBaseQuerySet.clear_cls_querys::< rXc&URSU5$)zsAdd a comment to the query. See https://www.mongodb.com/docs/manual/reference/method/cursor.comment/ for details. comment_chainable_method)rRrs rUrBaseQuerySet.comments %%i66rXc6URR5$)zVReturn an explain plan record for the :class:`~mongoengine.queryset.QuerySet` cursor. )ruexplainrs rUrBaseQuerySet.explains||##%%rXclSn[R"U[5 UR5nXlU$)zhEnable or disable snapshot mode when querying. :param enabled: whether or not snapshot mode is enabled zAsnapshot is deprecated as it has no impact when using PyMongo 3+.)r"r#r$r\r8)rRenabledr_r`s rUsnapshotBaseQuerySet.snapshots/ R c-.::<$rXc2UR5nXlU$)zEnable or disable the use of temporary files on disk while processing a blocking sort operation. (To store data exceeding the 100 megabyte system memory limit) :param enabled: whether or not temporary files on disk are used )r\r:rRrr`s rUallow_disk_useBaseQuerySet.allow_disk_uses ::<#* rXc2UR5nXlU$)zEnable or disable the default mongod timeout when querying. (no_cursor_timeout option) :param enabled: whether or not the timeout is used )r\r9rs rUtimeoutBaseQuerySet.timeouts ::<#rXcX[SU5 UR5nXlSUlU$)zwChange the read_preference when querying. :param read_preference: override ReplicaSetConnection-level preference. read_preferenceN)rr\r;rI)rRrr`s rUrBaseQuerySet.read_preferences- !!2OD::<$3!#rXcUb$[U[5(d[U<S35eUR5nUb [ S0UD6OSUlSUlU$)zqChange the read_concern when querying. :param read_concern: override ReplicaSetConnection-level preference. Nz is not a valid read concern.rZ)r[rr{r\r r<rI)rRrr`s rUrBaseQuerySet.read_concerns^  #J|W,M,M|..KLM M::<+7+CK ', '  $rXcUR5n[U5UlU(aUR"U6nU$UR 5nU$)aInstead of returning Document instances, return either a specific value or a tuple of values in order. Can be used along with :func:`~mongoengine.queryset.QuerySet.no_dereference` to turn off dereferencing. .. note:: This effects all results and can be unset by calling ``scalar`` without arguments. Calls ``only`` automatically. :param fields: One or more fields to return instead of a Document. )r\rr>rwr)rRrtr`s rUscalarBaseQuerySet.scalarsH::<< }}f-H **,HrXc UR"U6$)zAn alias for scalar)r)rRrts rU values_listBaseQuerySet.values_list s{{F##rXc4UR5nSUlU$)zInstead of returning Document instances, return raw values from pymongo. This method is particularly useful if you don't need dereferencing and care primarily about the speed of data retrieval. T)r\r@rs rU as_pymongoBaseQuerySet.as_pymongos::<#rXc&URSU5$)zWait `ms` milliseconds before killing the query on the server :param ms: the number of milliseconds before killing the query on the server max_time_msr)rRmss rUrBaseQuerySet.max_time_mss %%mR88rXcSU;a$[R"S[5 [US'[R "UR 5/UQ70UD6$)zConverts a queryset to JSON json_optionsaNo 'json_options' are specified! Falling back to LEGACY_JSON_OPTIONS with uuid_representation=PYTHON_LEGACY. For use with other MongoDB drivers specify the UUID representation to use. This will be changed to uuid_representation=UNSPECIFIED in a future release.)r"r#r$rrdumpsr)rRargsrs rUto_jsonBaseQuerySet.to_json%sM  ' MMG #  &9F> "t0B4B6BBrXc[R"U5nUVs/sHo0RRU5PM sn$s snf)z%Converts json data to unsaved objects)rloadsr0rz)rR json_datason_datadatas rU from_jsonBaseQuerySet.from_json3s5??9-;CD84((.8DDDs$Ac[U[5=(d [U5n[U[5(aU/O [U5nU(aSn[R "U[ 5 XR- n/nUR(dUR(a(URSS05 URSSS005 UR(aURSUR05 UR(a&URS[UR505 URb3URSURUR=(d S-05 URbURS UR05 Xu-nURn URc UR b.URR#URUR S 9n U R$"U4S 00UD6$) a Perform an aggregate function based on your queryset params :param pipeline: list of aggregation commands, see: https://www.mongodb.com/docs/manual/core/aggregation-pipeline/ :param suppl_pipeline: unpacked list of pipeline (added to support deprecation of the old interface) parameter will be removed shortly :param kwargs: (optional) kwargs dictionary to be passed to pymongo's aggregate call See https://pymongo.readthedocs.io/en/stable/api/pymongo/collection.html#pymongo.collection.Collection.aggregate zCalling .aggregate() with un unpacked list (*pipeline) is deprecated, it will soon change and will expect a list (similar to pymongo.Collection.aggregate interface), see documentationz$limitr#$matchz$exprFz$sortrz$skiprrcursor)r[dictboolrr"r#r$r?rQrrr7rJrKrr;r< with_options aggregate) rRpipelinesuppl_pipelinerusing_deprecated_interface user_pipeliner_initial_pipelinefinal_pipelinerTs rUrBaseQuerySet.aggregate8s&0$%?%W4CW"&04&@&@ d8n %LC MM#1 2'  ::  # #XqM 2  # #X/?$@ A ;;  # #Xt{{$; < >>  # #Wd4>>.B$C D ;; "  # #Xt{{djjoA/N$O P :: !  # #Wdjj$9 :)9%%  ,0B0B0N))66 $ 5 5DDVDV7J##NH2HHHrXc## UR5n[S5n0n [U[5(aURn [ U5n[UR U5U =(d S5n0n [U[5(aURn [ U5nUR U5n [X=(d S5nSUR0n U(aW0n [U[5(aURn [ U5nUR U5n[X=(d S5nXLS'U(aXlS'U(aX\S'US:XaUR(d SnSS 0U S 'OS n[U[ 5(aX eT " "++KJEX,,U3[5HDI h % %%^^N8}H //9  '=>HOO, ! *d++#-#3#3  _ &55jAOo/G4HJ",J  $G  $G  X h&8&8F&]GENF&#&&!'FD))!#:D"JJt,Eu&--tUm< ;))NOO!::j1= "))41A1F1F*GH$Q(D"JJt,Eu&--tUm<) "%^!4    ' ' )%//DDF"     )$D&*C00&*+002h'yyd,T,-?@EEG   99X//0DC#""H$8$8#e*c'l sF2M08BM0>D2M0cUR5nURU5nUVs/sHoTRRU5PM nnURR 5nXc=(d 0S.nUR nUR (aUR US'XS'[XS9nURR5n U RSXS9RS5$s snf)aSExecute a Javascript function on the server. A list of fields may be provided, which will be translated to their correct names and supplied as the arguments to the function. A few extra variables are added to the function's scope: ``collection``, which is the name of the collection in use; ``query``, which is an object representing the current query; and ``options``, which is an object containing any options specified as keyword arguments. As fields in MongoEngine may use different names in the database (set using the :attr:`db_field` keyword argument to a :class:`Field` constructor), a mechanism exists for replacing MongoEngine field names with the database field names in Javascript code. When accessing a field, use square-bracket notation, and prefix the MongoEngine field name with a tilde (~). :param code: a string of Javascript code to execute :param fields: fields that you will be using in your function, which will be passed in to your function as arguments :param options: options that you want available to the function (accessed in Javascript through the ``options`` object) )rToptionsz$wherer^)reval)rretval) r\rr0_translate_field_namerrr5rrrrF) rRcodertr r`rvrTrr^rs rUexec_jsBaseQuerySet.exec_jss,::<&&t,GMNv!$$::1=vN''<<> )mD  ! !&44E(OgD&    ' ' )zz&$z488BBOs$C%cTUR5nURU5nXlU$)aYFilter ``QuerySet`` results with a ``$where`` clause (a Javascript expression). Performs automatic field name substitution like :meth:`mongoengine.queryset.Queryset.exec_js`. .. note:: When using this mode of query, the database will call your function, or evaluate your predicate clause, for each object in the collection. )r\rr5)rR where_clauser`s rUwhereBaseQuerySet.wheres*::<..|< !-rXcURU/5R5nSUR0SSSSU-0S.0/n[S5nUR S5nUR R U5n[US U5(aURS S SU-05 [UR R5RU55nU(aUS S $g )zSum over the values of the specified field. :param field: the field to sum over; use dot notation to refer to embedded document fields r$groupsumz$sumrr4totalrfrr/r#$unwindrr rjrgrr rmr0 _lookup_fieldr[rtuplermrrRrhdb_fieldrrf field_partsfield_instancesrs rUrBaseQuerySet.sums ++UG488: t{{ # uh/GH I "+. kk#& ..66{C ob)9 5 5 OOA 3;7 8t~~557AA(KL !9W% %rXcURU/5R5nSUR0SSSSU-0S.0/n[S5nUR S5nUR R U5n[US U5(aURS S SU-05 [UR R5RU55nU(aUS S $g )zAverage over the values of the specified field. :param field: the field to average over; use dot notation to refer to embedded document fields rravgz$avgrrrfrr/r#rrrrrs rUaverageBaseQuerySet.average6s ++UG488: t{{ # uh/GH I "+. kk#& ..66{C ob)9 5 5 OOA 3;7 8t~~557AA(KL !9W% %rXcLU(aURXS9$URXS9$)aReturns a dictionary of all items present in a field across the whole queried set of documents, and their corresponding frequency. This is useful for generating tag clouds, or searching documents. .. note:: Can only do direct simple mappings and cannot map across :class:`~mongoengine.fields.ReferenceField` or :class:`~mongoengine.fields.GenericReferenceField` for more complex counting a manual map reduce call is required. If the field is a :class:`~mongoengine.fields.ListField`, the items within each list will be counted individually. :param field: the field to use :param normalize: normalize the results so they add to 1.0 :param map_reduce: Use map_reduce over exec_js ) normalize)_item_frequencies_map_reduce_item_frequencies_exec_js)rRrhr'rs rUitem_frequenciesBaseQuerySet.item_frequenciesPs/& 44U4P P--e-IIrXc2UR(dUR(a[e[UR5nUR (aU$UR RUURS9nUR(aURU5$U$)z;Wrap the result in a :class:`~mongoengine.Document` object.rr) r?rQrrrur@r0rzrsr>ry)rRraw_docrs rU__next__BaseQuerySet.__next__isu :: t||$   Nnn&& "44'  <<##C( ( rXcFSUlURR5 g)z+Rewind the cursor to its unevaluated state.FN)r=rurewindrs rUr1BaseQuerySet.rewind}s  rXcUR$)zvProperty that returns the collection object. This allows us to perform operations only if the collection is accessed. )r1rs rUrBaseQuerySet._collections ###rXcSnUR(aSn[R"U[5 0nUR(dSUS'UR (aSUS'UR (aUR R5X1'UR(a#X;a0X1'UR(a SS0X1S'U$) N projectionz>PC MM#1 2 }}/3K+ ,   ,0K( )   '+':':'B'B'DK $   -+- (&&;BK:P (7rXcURb UR$URc URbYURR URURS9R "UR 40URD6UlO6URR "UR 40URD6UlUR(a6URUR5nURRU5 UR(a&URRUR5 OnURcaURRS(aCURURRS5nURRU5 UR b%URR#UR 5 UR$b%URR'UR$5 UR(S:wa%URR+UR(5 UR,b%URR/UR,5 UR0b%URR3UR05 UR4b%URR7UR45 UR$)z>Return a PyMongo cursor object corresponding to this queryset.rorderingr/)rIr;r<rrr5rr&r5rrr7rr0rErrJrrKrrLrrMrrNr_rPr)rRrorders rUruBaseQuerySet._cursors4    '## #  ,0B0B0N#//<< $ 5 5DDVDV = d ;; 5"&"3"3 5D  $//44T[[VDDUDUVD    ..t/A/ABL    " "< 0 >>    ! !$.. 1 ^^ #(<(3BaseQuerySet._fields_to_dbfields..s,!F$As++A;F02Fc3h# UH(n[U[5(aUO URv M* g7frrcrds rUrfrgs,,%F",As!3!3AC%FrhT) r0rErHr rmrrrr) rRrt subclassesrdb_field_pathsrhrrfoundsubdocsubfields rUrj BaseQuerySet._fields_to_dbfieldsus6 >>   3 437>>3M3MN3Ma,q/3MNqrRJE++c*K !!^^99+F!%%e,8?O )F #&88,%+%9%9+%F,$'--h7 $&)I# sBB5-AB:: D/D* :DD* D D*D D**D/cv/nUHnU(dM US:XaURSSS045 M)[RnUSS:Xa[RnUSS;aUSS nUR S S 5nUR R U5nURX445 M U$![a N$f=f) zGiven a list of MongoEngine-style sort keys, return a list of sorting tuples that can be applied to a PyMongo cursor. For example: >>> qs._get_order_by(['-last_name', 'first_name']) [('last_name', -1), ('first_name', 1)] z $text_scorer:r8r9r-)rq+r#Nrr)rr ASCENDING DESCENDINGrr0r  Exception)rRrkey_listr| directions rUrBaseQuerySet._get_order_bysCm#+0F GH))I1v}#.. 1v#!"g++dC(C nn::3? OOS, --0   s8B++ B87B8cSnURVs/sH o2"X5PM nn[U5S:XaUS$[U5$s snf)NcPURS5nUHn[X5nM U$)Nr)rmrH)objrcchunkschunks rUlookup(BaseQuerySet._get_scalar..lookups)ZZ%Fc) JrXr#r)r>rGr)rRrr~r rs rUryBaseQuerySet._get_scalarsH  )- 5 1s 5 t9>7NT{ 6sAc|^U4SjnU4Sjn[R"SX!5n[R"SX15nU$)zWhen fields are specified with [~fieldname] syntax, where *fieldname* is the Python name of a field, *fieldname* will be substituted for the MongoDB name of the field (specified using the :attr:`name` keyword argument in a field's constructor). c>URS5RS5nTRRU5nSUSR-$)Nr#rz["%s"]r/)rrmr0rr)rrrtrRs rU field_sub.BaseQuerySet._sub_js_fields..field_subsDQ--c2J^^11*=FfRj111 1rXc>URS5RS5nTRRU5nSR UVs/sHo3R PM sn5$s snf)Nr#r)rrmr0rrr)rrrtrvrRs rUfield_path_sub3BaseQuerySet._sub_js_fields..field_path_subsRQ--c2J^^11*=F888AZZ89 98s A(z\[\s*~([A-z_][A-z_0-9.]+?)\s*\]z#\{\{\s*~([A-z_][A-z_0-9.]+?)\s*\}\})rsub)rRr rrs` rUrBaseQuerySet._sub_js_fieldss6 2 :vv8)JvvrArBrKr8r9r5r)NT)TNN)F)NFN)FTNNFN)NN)FNFN)FFFFN)r#)NNN)FT)Ur __module__ __qualname____firstlineno____doc__rVrarjror}rrrrrrrFrrrrrrnrr r.rrr:r=rCr\r@rRrrrrr_rkrwr|rtrrrrrrrrrrrrrrrrrrrrrr$r*r.r1propertyrr&rurErrQrsrQr(r)rjrryrr__static_attributes__rZrXrUrr2sP0d8" ',?\";  /: 8@ NR\5|&PY,zJ=X@  H  Pd 52 LV/bD" (4$8t+$%$8t '+%N 7&   .$ 9 CE 0IhKOxt'CR 44J2($$ 68 8 t!!"" 880d=~#J!F 2rXr)7rfrrr"collections.abcrrpymongo.errorsbsonrr bson.coderpymongo.collectionrpymongo.commonrpymongo.read_concernr mongoenginer mongoengine.baser mongoengine.commonr mongoengine.connectionr mongoengine.context_managersrrrrmongoengine.errorsrrrrrmongoengine.pymongo_supportrrmongoengine.querysetrmongoengine.queryset.field_listrmongoengine.queryset.visitorrr__all__rrr r!r"rrZrXrUrs  #-3,),) +:1 N  AArX