U Lk7g/@s>ddlZddlZddlmZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZddlmZddlmZmZddlmZmZmZdd lmZmZmZdd lmZdd lm Z m!Z!m"Z"m#Z#d Z$d dZ%Gddde&Z'Gddde e dZ(Gddde edZ)Gddde)edZ*Gddde(e dZ+GdddZ,dS)N)DBRef)ReadPreference)signals)BaseDict BaseDocumentBaseListDocumentMetaclassEmbeddedDocumentListTopLevelDocumentMetaclass get_document _import_class)DEFAULT_CONNECTION_NAMEget_db)set_write_concernswitch_collection switch_db)InvalidDocumentErrorInvalidQueryErrorSaveConditionError)list_collection_names)NotUniqueErrorOperationErrorQuerySet transform)DocumentEmbeddedDocumentDynamicDocumentDynamicEmbeddedDocumentrInvalidCollectionErrorrMapReduceDocumentcCsVd}t|rNt|dtr$|d}n*t|dttfrNt|drN|dd}|dkS)z8Helper function used for ensuring and comparing indexes.Nr_cls)len isinstancestrlisttuple)fieldsZ first_fieldr(8/tmp/pip-unpacked-wheel-n1etwkgt/mongoengine/document.py includes_cls1s  r*c@s eZdZdS)rN)__name__ __module__ __qualname__r(r(r(r)r<srcs`eZdZdZdZeZdZfddZddZ dd Z fd d Z fd d Z fddZ ZS)raA :class:`~mongoengine.Document` that isn't stored in its own collection. :class:`~mongoengine.EmbeddedDocument`\ s should be used as fields on :class:`~mongoengine.Document`\ s through the :class:`~mongoengine.EmbeddedDocumentField` field type. A :class:`~mongoengine.EmbeddedDocument` subclass may be itself subclassed, to create a specialised version of the embedded document that will be stored in the same collection. To facilitate this behaviour a `_cls` field is added to documents (hidden though the MongoEngine interface). To enable this behaviour set :attr:`allow_inheritance` to ``True`` in the :attr:`meta` dictionary. ) _instanceNcstj||d|_g|_dSN)super__init__r._changed_fields)selfargskwargs __class__r(r)r1YszEmbeddedDocument.__init__cCst||jr|j|jkSdS)NF)r#r7_datar3otherr(r(r)__eq__^s  zEmbeddedDocument.__eq__cCs || Sr/)r;r9r(r(r)__ne__cszEmbeddedDocument.__ne__cst}d|d<|SNr.)r0 __getstate__)r3datar6r(r)r>fs zEmbeddedDocument.__getstate__cst||d|_dSr=)r0 __setstate__r.)r3stater6r(r)r@ks zEmbeddedDocument.__setstate__cs,tj||}d|kr(|ddkr(|d=|S)N_id)r0to_mongor3r4r5r?r6r(r)rCoszEmbeddedDocument.to_mongo)r+r,r-__doc__ __slots__r my_metaclass__hash__r1r;r<r>r@rC __classcell__r(r(r6r)r@s    r) metaclassc speZdZdZeZdZeddZej ddZfddZ e dd Z e d d Z e d d Ze ddZe ddZfddZdFddZdGddZddZddZdd Zd!d"Zd#d$Zed%d&Zed'd(Zd)d*ZdHd+d,ZdId-d.ZdJd/d0ZdKd2d3Zd4d5Z d6d7Z!d8d9Z"e d:d;Z#e dd?Z%e d@dAZ&e dBdCZ'e dDdEZ(Z)S)Mra The base class used for defining the structure and properties of collections of documents stored in MongoDB. Inherit from this class, and add fields as class attributes to define a document's structure. Individual documents may then be created by making instances of the :class:`~mongoengine.Document` subclass. By default, the MongoDB collection used to store documents created using a :class:`~mongoengine.Document` subclass will be the name of the subclass converted to snake_case. A different collection may be specified by providing :attr:`collection` to the :attr:`meta` dictionary in the class definition. A :class:`~mongoengine.Document` subclass may be itself subclassed, to create a specialised version of the document that will be stored in the same collection. To facilitate this behaviour a `_cls` field is added to documents (hidden though the MongoEngine interface). To enable this behaviour set :attr:`allow_inheritance` to ``True`` in the :attr:`meta` dictionary. A :class:`~mongoengine.Document` may use a **Capped Collection** by specifying :attr:`max_documents` and :attr:`max_size` in the :attr:`meta` dictionary. :attr:`max_documents` is the maximum number of documents that is allowed to be stored in the collection, and :attr:`max_size` is the maximum size of the collection in bytes. :attr:`max_size` is rounded up to the next multiple of 256 by MongoDB internally and mongoengine before. Use also a multiple of 256 to avoid confusions. If :attr:`max_size` is not specified and :attr:`max_documents` is, :attr:`max_size` defaults to 10485760 bytes (10MB). Indexes may be created by specifying :attr:`indexes` in the :attr:`meta` dictionary. The value should be a list of field names or tuples of field names. Index direction may be specified by prefixing the field names with a **+** or **-** sign. Automatic index creation can be disabled by specifying :attr:`auto_create_index` in the :attr:`meta` dictionary. If this is set to False then indexes will not be created by MongoEngine. This is useful in production systems where index creation is performed as part of a deployment system. By default, _cls will be added to the start of every index (that doesn't contain a list) if allow_inheritance is True. This can be disabled by either setting cls to False on the specific index or by setting index_cls to False on the meta dictionary for the document. By default, any extra attribute existing in stored data but not declared in your model will raise a :class:`~mongoengine.FieldDoesNotExist` error. This can be disabled by setting :attr:`strict` to ``False`` in the :attr:`meta` dictionary. ) __objectscCsd|jkrdSt||jdS)zGet the primary key.id_fieldN)_metagetattrr3r(r(r)pks z Document.pkcCst||jd|S)zSet the primary key.rL)setattrrM)r3valuer(r(r)rPscs"|jdkrtt|St|jS)zReturn the hash based on the PK of this document. If it's new and doesn't have a PK yet, return the default object hash instead. N)rPr0rrHhashrOr6r(r)rHs zDocument.__hash__cCst|jdtS)zSome Model using other db_aliasdb_alias)rrMgetrclsr(r(r)_get_dbszDocument._get_dbcCs d|_dS)z?Detach the Document class from the (cached) database collectionN) _collectionrVr(r(r) _disconnectszDocument._disconnectcCst|dr|jdkr|jds,|jdr8||_n2|jdrP||_n|}|}|||_|}|jddr|jj r| |jS)aeReturn the PyMongo collection corresponding to this document. Upon first call, this method: 1. Initializes a :class:`~pymongo.collection.Collection` corresponding to this document. 2. Creates indexes defined in this document's :attr:`meta` dictionary. This happens only if `auto_create_index` is True. rYNmax_size max_documents timeseriesZauto_create_indexT) hasattrrYrMrU_get_capped_collection_get_timeseries_collectionrX_get_collection_nameclientZ is_primaryensure_indexes)rWdbcollection_namer(r(r)_get_collections     zDocument._get_collectioncCs|}|}|jdpd}|jd}|drD|ddd}|t|ddkr||}|}|d|ks|d |krtd |j|Sd|d }|r||d<|j |f|S) z:Create a new or get an existing capped PyMongo collection.r[ir\TZinclude_system_collectionsmaxsizezICannot create collection "{}" as a capped collection as it already exists)Zcappedrk) rXrarMrUroptionsrformatrYcreate_collection)rWrdrer[r\ collectionrloptsr(r(r)r_s.  zDocument._get_capped_collectioncCsf|}|}|jd}|t|ddkr@||}||Sd|ddi}|jf||d|S)z>Create a new or get an existing timeseries PyMongo collection.r]TriZexpireAfterSecondsN)namer])rXrarMrUrrlpoprn)rWrdreZtimeseries_optsrorpr(r(r)r`s" z#Document._get_timeseries_collectioncsDtj||}|ddkr@|jddkr2|d=n|jd|d<|S)NrBid)r0rCr8rUrDr6r(r)rC)s  zDocument.to_mongoNc Ks|dkr i}|jdkrtd|jd}t|tr:|n||}||krX|j||<n|||jkrntd||j |j f|j fddi|}|dkrdS|j D]}t ||||||q|j|_d|_dS)a4Perform an atomic update of the document in the database and reload the document object using updated version. Returns True if the document has been updated or False if the document in the database doesn't match the query. .. note:: All unsaved changes that have been made to the document are rejected if the method returns True. :param query: the update will be performed only if the document in the database matches the query :param update: Django-style update keyword arguments Nz)The document does not have a primary key.rLzAInvalid document modify query: it must modify only this document.newTF)rPrrMr#dictcopyZto_queryrupdate _object_key_qsmodifyZ_fields_orderedrQ_reloadr2_created)r3queryrwrLupdatedfieldr(r(r)rz6s*     zDocument.modifyFTc  KsD| pi} |jdrtdtjj|jfd|i| |rF|j|d|dkrRi}|j|jdgd} d| kpv|j pv|} tj j|jf|| d | |} |j dkr| }n|jd d r| z| r|j| ||d }n|| ||\}} |dkr|jd d p|dk }|rJ||||d} |r6| ||| d<|jf| Wntjjk r}zd}t||W5d}~XYnZtjjk r}z6d}tdt|rd}t||t||W5d}~XYnX|jd}| s||jdgkr|j||||<tjj|jf|| d | |d |_ |S)a Save the :class:`~mongoengine.Document` to the database. If the document already exists, it will be updated, otherwise it will be created. Returns the saved object instance. :param force_insert: only try to create a new document, don't allow updates of existing documents. :param validate: validates the document; set to ``False`` to skip. :param clean: call the document clean method, requires `validate` to be True. :param write_concern: Extra keyword arguments are passed down to :meth:`~pymongo.collection.Collection.save` OR :meth:`~pymongo.collection.Collection.insert` 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 cascade: Sets the flag for cascading saves. You can set a default by setting "cascade" in the document __meta__ :param cascade_kwargs: (optional) kwargs dictionary to be passed throw to cascading saves. Implies ``cascade=True``. :param _refs: A list of processed references used in cascading saves :param save_condition: only perform save if matching record in db satisfies condition(s) (e.g. version number). Raises :class:`OperationError` if the conditions are not satisfied :param signal_kwargs: (optional) kwargs dictionary to be passed to the signal calls. .. versionchanged:: 0.5 In existing documents it only saves changed fields using set / unset. Saves are cascaded and any :class:`~bson.dbref.DBRef` objects that have changes are saved as well. .. versionchanged:: 0.6 Added cascading saves .. versionchanged:: 0.8 Cascade saves are optional and default to False. If you want fine grain control then you can turn off using document meta['cascade'] = True. Also you can pass different kwargs to the cascade save using cascade_kwargs which overwrites the existing kwargs with custom values. .. versionchanged:: 0.26 save() no longer calls :meth:`~mongoengine.Document.ensure_indexes` unless ``meta['auto_create_index_on_save']`` is set to True. abstractz!Cannot save an abstract document.document)cleanNrL)r'rB)rcreatedZauto_create_index_on_saveF)doc force_insert write_concerncascade)rvalidaterr_refsz(Tried to save duplicate unique keys (%s)zCould not save document (%s)z^E1100[01] duplicate key shard_key)rMrUrrZpre_savesendr7rrCr|Zpre_save_post_validationrYrfrc _save_create _save_updaterw cascade_savepymongoerrorsZDuplicateKeyErrorrOperationFailurerematchr$r_fieldsZ to_pythonZ post_saveZ_clear_changed_fields)r3rrrrrZcascade_kwargsrsave_condition signal_kwargsr5Zdoc_idrr_ object_iderrmessagerLr(r(r)savecs;        z Document.savec Cs|}t||r}|r0||jW5QRSd|krtd|di}|||}|||}|rt|dW5QRS||j}W5QRX|S)zXSave a new document. Helper method, should only be used inside save(). rB)rfrZ insert_oneZ inserted_id_integrate_shard_keyZfind_one_and_replace) r3rrrro wc_collection select_dictZ raw_objectrr(r(r)rs    zDocument._save_createcCs,|\}}i}|r||d<|r(||d<|S)zReturn a dict containing all the $set and $unset operations that should be sent to MongoDB based on the changes made to this Document. z$setz$unset)Z_delta)r3ZupdatesZremovals update_docr(r(r)_get_update_docs zDocument._get_update_docc Cs`|jdt}|D]F}||d}dd|D}|}|D] }||}q>||d|<q|S)zIntegrates the collection's shard key to the `select_dict`, which will be used for the query. The value from the shard key is taken from the `doc` and finally the select_dict is returned. r.cSsg|] }|jqSr()Zdb_field).0pr(r(r) sz1Document._integrate_shard_key..)rMrUr&Z _lookup_fieldsplitjoin) r3rrrkpathZ actual_keyvalZakr(r(r)rs zDocument._integrate_shard_keyc Cs|}|d}d}i}|dk r0tj|jf|}||d<|||}|}|r|dk} t||} | j||| dj} W5QRX| s| ddkrt d| dk r| d} | dkrd }||fS) z`Update an existing document. Helper method, should only be used inside save(). rBFN)upsertnrz2Race condition preventing document update detectedZupdatedExistingT) rfrr}r7rrr update_oneZ raw_resultrrU) r3rrrrorrrrrrZ last_errorZupdated_existingr(r(r)r's4   zDocument._save_updatec Ks|dp g}td}td}|jD]\}}t|||fs@q(|j|}|r(t|tr\q(t|ddsjq(|jj dt |j}|r(||kr(| |||d<|j f|g|_ q(dS)zXRecursively save any references and generic references on the document. rReferenceFieldGenericReferenceFieldr2T,N)rUr ritemsr#r8rrNr7r+r$appendrr2) r3r5rrrrqrWrefZref_idr(r(r)rMs"     zDocument.cascade_savecCs0t|ds*|jdt}||j||_|jS)z;Return the default queryset corresponding to this document.rKqueryset_class)r^rMrUrr7rf_Document__objects)r3rr(r(r)ryhs z Document._qscCsZd|ji}|jjdt}|D]4}|}|d}|D]}t||}q6||d|<q |S)aReturn a query dict that can be used to fetch this document. Most of the time the dict is a simple PK lookup, but in case of a sharded collection with a compound shard key, it can contain a more complex query. Note that the dict returned by this method uses MongoEngine field names instead of PyMongo field names (e.g. "pk" instead of "_id", "some__nested__field" instead of "some.nested.field", etc.). rPrr__)rPr7rMrUr&rrNr)r3rrrrZ field_partspartr(r(r)rxps   zDocument._object_keycKsb|jdkrJ|ddrB|}d|kr,|d=|jjf|jf|Std|jjf|jjf|S)zPerforms an update on the :class:`~mongoengine.Document` A convenience wrapper to :meth:`~mongoengine.QuerySet.update`. Raises :class:`OperationError` if called on an object that has not yet been saved. NrFr!z*attempt to update a document not yet saved)rPrUrCryfilterrrrx)r3r5r}r(r(r)rws  zDocument.updatec Ks|pi}tjj|jfd|i|td}|jD] \}}t||r4t|| q4z|j j f|j j |ddWn8t jjk r}zd|j}t|W5d}~XYnXtjj|jfd|i|dS)aWDelete the :class:`~mongoengine.Document` from the database. This will only take effect if the document has been previously saved. :param signal_kwargs: (optional) kwargs dictionary to be passed to the signal calls. :param write_concern: Extra keyword arguments are passed down which will be used as options for the resultant ``getLastError`` command. For example, ``save(..., w: 2, fsync: True)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. r FileFieldT)rZ_from_doc_deletezCould not delete document (%s)N)rZ pre_deleterr7r rrr#rNdeleteryrrxrrrr4rZ post_delete)r3rrrrqrrrr(r(r)rs    zDocument.deletec snt|j|}||W5QRXfdd|_fdd|_|_|sRdn|j|_|j|_|j_|S)aT Temporarily switch the database for a document instance. Only really useful for archiving off data and calling `save()`:: user = User.objects.get(id=user_id) user.switch_db('archive-db') user.save() :param str db_alias: The database alias to use for saving the document :param bool keep_created: keep self._created value after switching db, else is reset to True .. seealso:: Use :class:`~mongoengine.context_managers.switch_collection` if you need to read from another collection csSr/r(r(ror(r)z$Document.switch_db..csSr/r(r()rdr(r)rrT) rr7rfrXrYr|ryr_collection_obj)r3rT keep_createdrWr()rordr)rszDocument.switch_dbc sXt|j|}|W5QRXfdd|_|_|s.T)rr7rfrYr|ryrr)r3rerrWr(rr)rszDocument.switch_collectionrhcCstd}||g|d|S)zHandles dereferencing of :class:`~bson.dbref.DBRef` objects to a maximum depth in order to cut down the number queries to mongodb. DeReferencerhr )r3 max_depthrr(r(r)select_relatedszDocument.select_relatedc OsTd}|r,t|dtr,|d}|dd}nd|kr<|d}|jdkrP|d|jtjjf|j j | dj |d}|r|d}n |d|j D]}|r||krzt||||||Wqttfk r"z t|||||j |Wn tk rt||YnXYqXq|rBtt|jt|n|j|_d|_|S)zReloads all attributes from the database. :param fields: (optional) args list of fields to reload :param max_depth: (optional) depth of dereferencing to follow rhrNrzDocument does not exist)rF)r#intrPZ DoesNotExistryZread_preferencerZPRIMARYrrxonlylimitrr8rQr{KeyErrorAttributeErrorrUdelattrr%setr2r|)r3r'r5robjrr(r(r)reloadsH       zDocument.reloadcst|tr.fdd|D}t|}nrt|trZfdd|D}t|}nFt|trfdd|D}t|}nt|ttfrd|_g|_|S)zoUsed by :meth:`~mongoengine.Document.reload` to ensure the correct instance is linked to self. cs g|]\}}|||fqSr(r{)rrvrOr(r)r2sz$Document._reload..csg|]}|qSr(rrrkeyr3r(r)r5scsg|]}|qSr(rrrr(r)r8sN) r#rrr rrrr.r2)r3rrRr(rr)r{-s   zDocument._reloadcCs(|jdkrd}t|t|j|jS)zVReturns an instance of :class:`~bson.dbref.DBRef` useful in `__raw__` queries.Nz+Only saved documents can have a valid dbref)rPrrr7ra)r3msgr(r(r)to_dbref?s zDocument.to_dbrefcsrfddjDg}fddjDg}|D]4}|D]*|jdpRi}|||f<||jd<q@q8dS)z[This method registers the delete rules to apply when removing this object. csg|]}|jkrt|qSr(r+r r class_namerVr(r)rLs z1Document.register_delete_rule..csg|]}|jkrt|qSr(rr) document_clsr(r)rQs delete_rulesN)Z _subclassesrMrU)rWr field_nameZruleclassesZ documentsklassrr()rWrr)register_delete_ruleGs   zDocument.register_delete_rulecCs4|}|std|d|_|}||dS)zDrops the entire collection associated with this :class:`~mongoengine.Document` type from the database. Raises :class:`OperationError` if the document has no collection set (i.g. if it is `abstract`) z8Document %s has no collection defined (is it abstract ?)N)rarrYrXdrop_collection)rWZ coll_namerdr(r(r)r]szDocument.drop_collectioncKs@||}|}|d}||d<|||j|f|S)a<Creates the given indexes if required. :param keys: a single index key or a list of index keys (to construct a multi-field index); keys may be prefixed with a **+** or a **-** to determine the index ordering :param background: Allows index creation in the background r' background)Z_build_index_specrvrrrwrf create_index)rWkeysrr5 index_specr'r(r(r)rns   zDocument.create_indexc Cs|jdd}|jdpi}|jdd}|}d}|jdr|jd}|D]X}|}|d}|ppt|}|} | |d| kr| d=|j|fd |i| qP|r|s|jd rd|kr|d=|jd d |i|d S)aChecks the document meta data and ensures all the indexes exist. Global defaults can be set in the meta - see :doc:`guide/defining-documents` By default, this will get called automatically upon first interaction with the Document collection (query, save, etc) so unless you disabled `auto_create_index`, you shouldn't have to call this manually. This also gets called upon every call to Document.save if `auto_create_index_on_save` is set to True If called multiple times, MongoDB will not re-recreate indexes if they exist already .. note:: You can disable automatic index creation by setting `auto_create_index` to False in the documents meta data Zindex_backgroundF index_opts index_clsT index_specsr'rWrallow_inheritancer!N)r!)rMrUrfrvrrr*rwr) rWrrrroZ cls_indexedrspecr'rpr(r(r)rcs(     zDocument.ensure_indexescs|jdrgSgfdd|dd}g}D]$}||D]}||krF||qFq:dg|krv|dg|jddr|jd r|d g|S) zLists all indexes that should be created for the Document collection. It includes all the indexes from super- and sub-classes. Note that it will only return the indexes' fields, not the indexes' options rcs|krt|tr||jD]P}t|tr"|tkr"|jds"|j|jkr"|kr"||q"| D]<}t|tr||j|jkr||kr|||q|dS)Nr) r#r r __bases__rrMrUrfZ full_name__subclasses__)rWZbase_clssubclassr get_classesr(r)rs8       z*Document.list_indexes..get_classescSsBg}|jdr>|jd}|D] }|}|d}||q|S)Nrr')rMrvrrr)rWindexesrrr'r(r(r)get_indexes_specs    z/Document.list_indexes..get_indexes_spec)rBrhrTrr!rh)rMrUr)rWrrrindexr(rr) list_indexess       zDocument.list_indexescs|g|}|D]Z}d|ddkrl|ddd|d}fdd|Dq |dq fddD}fd dD}d g|krd }D]}t|r||krd }qq|r|d g||d S)zCompares the indexes defined in MongoEngine with the ones existing in the database. Returns any missing/extra indexes. Z_ftsrrrhweightscsg|] }|fqSr(r()rr) index_typer(r)rsz,Document.compare_indexes..csg|]}|kr|qSr(r(rr)existingr(r)r scsg|]}|kr|qSr(r(r)requiredr(r)r srFT)missingextra) rrfZindex_informationvaluesrUrrr*remove)rWroinfoZtext_index_fieldsrrZ cls_obsoleterr()rrrr)compare_indexess(  zDocument.compare_indexes)N) FTTNNNNNN)N)T)T)rh)F)*r+r,r-rEr rGrFpropertyrPsetterrH classmethodrXrZrfr_r`rCrzrrrrrrryrxrwrrrrrr{rrrrrcrrrIr(r(r6r)rysx4       %  / &      3    7 Arcs(eZdZdZeZdZfddZZS)ra*A Dynamic Document class allowing flexible, expandable and uncontrolled schemas. As a :class:`~mongoengine.Document` subclass, acts in the same way as an ordinary document but has expanded style properties. Any data passed or set against the :class:`~mongoengine.DynamicDocument` that is not a field is automatically converted into a :class:`~mongoengine.fields.DynamicField` and data can be attributed to that field. .. note:: There is one caveat on Dynamic Documents: undeclared fields cannot start with `_` Tcs>|d}||jkr,t||dd|j|_ntj||dS)YDelete the attribute by setting to None and allowing _delta to unset it. rNF)Z_dynamic_fieldsrQnullr0 __delattr__)r3r4r5rr6r(r)r.s   zDynamicDocument.__delattr__) r+r,r-rEr rG_dynamicrrIr(r(r6r)rsrc@s eZdZdZeZdZddZdS)rzA Dynamic Embedded Document class allowing flexible, expandable and uncontrolled schemas. See :class:`~mongoengine.DynamicDocument` for more information about dynamic documents. TcOsJ|d}||jkr:|j|j}t|r,|}t|||n t||ddS)rrN)rdefaultcallablerQ)r3r4r5rrr(r(r)rEs  z#DynamicEmbeddedDocument.__delattr__N)r+r,r-rErrGrrr(r(r(r)r:src@s$eZdZdZddZeddZdS)r aA document returned from a map/reduce query. :param collection: An instance of :class:`~pymongo.Collection` :param key: Document/result key, often an instance of :class:`~bson.objectid.ObjectId`. If supplied as an ``ObjectId`` found in the given ``collection``, the object can be accessed via the ``object`` property. :param value: The result(s) for this key. cCs||_||_||_||_dSr/) _documentrYrrR)r3rrorrRr(r(r)r1^szMapReduceDocument.__init__cCs~|jd}t|}t|j|sVz||j|_Wn"tk rTtd|jYnXt|dsx|jj |j|_ |j S|j S)zmLazy-load the object referenced by ``self.key``. ``self.key`` should be the ``primary_key``. rLzCould not cast key as %s _key_object) rrMtyper#r Exceptionr+r^ZobjectsZwith_idr)r3rLZ id_field_typer(r(r)objectds  zMapReduceDocument.objectN)r+r,r-rEr1rrr(r(r(r)r Ss r )-rrZ bson.dbrefrZpymongo.read_preferencesrZ mongoenginerZmongoengine.baserrrrr r r Zmongoengine.commonr Zmongoengine.connectionrrZmongoengine.context_managersrrrZmongoengine.errorsrrrZmongoengine.pymongo_supportrZmongoengine.querysetrrrr__all__r*rrrrrrr r(r(r(r)s4   $    9)