9hKSrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK rSSK J r SSK J r SSKJr SSKJrJr SSKJrJr SSKJr SS KJr SS KJr SS KJr S S KJr S SKJr S SK!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+ S SK,J-r- Sr.SSK/r/Sr1Sr2Sr3"SS5r4"SS\45r5"SS\55r6"SS5r7"SS\45r8"S S!\55r9"S"S#\55r:"S$S%\45r;"S&S'\;5r<"S(S)\<5r="S*S+\;5r>"S,S-\>5r?"S.S/5r@"S0S1\>5rA"S2S3\45rB"S4S5\45rCg!\0a Sr/Sr.Nf=f)6zEFramework-agnostic core of Motor, an asynchronous driver for MongoDB.N) ChangeStream) ClientSession) Collection) CommandCursorRawBatchCommandCursor)CursorRawBatchCursor)_QUERY_OPTIONS)Database) DriverInfo)ClientEncryption) docstrings)version) AsyncCommand AsyncRead AsyncWriteDelegateMethodMotorCursorChainingMethodReadOnlyPropertycoroutine_annotationcreate_class_with_frameworkunwrap_args_sessionunwrap_kwargs_session)callback_type_errorTFxc@[R"5U- [:$)z/Are we within the with_transaction retry limit?)time monotonic"_WITH_TRANSACTION_RETRY_TIME_LIMIT) start_times OC:\Suresh\moveshuttle\MDcreated\moveengine\venv\Lib\site-packages\motor/core.py_within_time_limitr#Bs >> j (+M MMcv[U[RR5=(a URS:H$)z/Return true if exc is a MaxTimeMSExpired error.2) isinstancepymongoerrorsOperationFailurecode)excs r"_max_time_expired_errorr-Gs& c7>>:: ; NBNr$c&\rSrSrSrSrSrSrg) AgnosticBaseLc[XR5(a;[US5(a*[US5(aURUR:H$[$)Ndelegate)r' __class__hasattrr2NotImplemented)selfothers r"__eq__AgnosticBase.__eq__MsD unn - -j))z**==ENN2 2r$cXlgNr2)r6r2s r"__init__AgnosticBase.__init__Vs r$cPURRSUR<S3$)N())r3__name__r2r6s r"__repr__AgnosticBase.__repr__Ys%..))*!DMM+>r$r<N)rB __module__ __qualname____firstlineno__r8r=rD__static_attributes__r$r"r/r/Ls!?r$r/ch\rSrSr\S\S\4Sj5r\"5r \"5r \"5r \"5r Sr g)AgnosticBaseProperties]keyreturncU$r;rJclsrNs r"__class_getitem__(AgnosticBaseProperties.__class_getitem___ r$rJN)rBrFrGrH classmethodstrobjectrSr codec_optionsread_preference read_concern write_concernrIrJr$r"rLrL]sDCF%&M&(O#%L$&Mr$rLc^\rSrSrSr\R Rr\ "5r \ "5r \ "5r \ "5r\"5r\"5R%S5r\ "5r\ "\R,S9R/\5r\ "\R4S9R/\5r\ "5r\ "5r\ "5r\"5R/\5r \"5r!\ "5r"\ "5r#\ "5r$\ "5r%\ "5r&\"5r'\ "5r(\"\RRS9R/\*5r+\"5r,U4Sjr-\.S5r/Sr0S Sjr1S r2S r3S rS r4U=r5$)AgnosticClienti MotorClient MotorDatabasedocc>SU;a-URS5nURRU5 OSnX0lUR SS5 [ S[ URR55nURS5(aURS5n[U[ 5(d[S[U5S35eUR(aS UR3OS nUR(aS UR3OS n[ URS UR3URU3URU35nXBS'UR"U0UD6n[ T U]EU5 g) a Create a new connection to a single MongoDB instance at *host:port*. Takes the same constructor arguments as :class:`~pymongo.mongo_client.MongoClient`, as well as: :Parameters: - `io_loop` (optional): Special event loop instance to use instead of default. io_loopNconnectFMotordriverzIncorrect type for `driver` z7; expected value of type pymongo.driver_info.DriverInfo|)pop _frameworkcheck_event_loop_io_loop setdefaultr motor_version platform_infogetr' TypeErrortyperplatformname__delegate_class__superr=) r6argskwargsre driver_info provided_info added_versionadded_platformr2r3s r"r=AgnosticClient.__init__sk  jj+G OO , ,W 5G )U+ -9V9V9XY ::h  "JJx0MmZ8824 3F2GHMM= 4.0. - `session` (optional): a :class:`~pymongo.client_session.ClientSession`. - `start_after` (optional): The same as `resume_after` except that `start_after` can resume notifications after an invalidate event. This option and `resume_after` are mutually exclusive. - `comment` (optional): A user-provided comment to attach to this command. - `full_document_before_change`: Allowed values: `whenAvailable` and `required`. Change events may now result in a `fullDocumentBeforeChange` response field. - `show_expanded_events` (optional): Include expanded events such as DDL events like `dropIndexes`. :Returns: A :class:`~MotorChangeStream`. .. versionchanged:: 3.2 Added ``show_expanded_events`` parameter. .. versionchanged:: 3.1 Added ``full_document_before_change`` parameter. .. versionchanged:: 3.0 Added ``comment`` parameter. .. versionchanged:: 2.1 Added the ``start_after`` parameter. .. versionadded:: 2.0 .. mongodoc:: changeStreams rAgnosticChangeStreamrlrFr6pipeline full_document resume_aftermax_await_time_ms batch_size collationstart_at_operation_timesession start_aftercommentfull_document_before_changeshow_expanded_events cursor_classs r"watchAgnosticClient.watchT`3 $//4??         #    '   r$c URS5(a,[URRSU<SUSUS35eX$)N_ has no attribute . To access the z database, use client['']. startswithAttributeErrorr3rBr6rvs r" __getattr__AgnosticClient.__getattr__sV ??3   >>**++=dXEUVZU[)$s4  zr$c\[[URUR5nU"X5$r;)rAgnosticDatabaserlrF)r6rvdb_classs r" __getitem__AgnosticClient.__getitem__%s'./?RVRaRab##r$cUR[:Xa6[[URUR 5nU"XR US9$UR[:Xa-[[URUR 5nU"X5$UR[:Xa-[[URUR 5nU"X5$gN _delegate) r3r rrrlrFrvrAgnosticCommandCursorrAgnosticClientSession)r6objrcommand_cursor_class session_classs r"wrapAgnosticClient.wrap*s ==H $2 $//4??HD((c: : ]]m +#>%t$ (2 2 ]]m +7%tM!+ + ,r$rn NNNNNNNNNNNN)6rBrFrGrH__motor_class_name__r( mongo_client MongoClientrwraddressarbitersrclose__hash__r bulk_writerunwrap drop_databaseoptionsrget_database_docrr get_databaseget_default_database_docget_default_databaseHOST is_mongos is_primaryrlist_databaseslist_database_namesnodesPORTprimaryr[ secondaries server_infotopology_descriptionstart_session_docr start_session_connectr=propertyrerrrrrI __classcell__r3s@r"r^r^is( --99 G!H  EHJ N))/:M G!j&A&ABGGQL)j.Q.QRWWX`a  D "I!#J[%%m4N#+  E  D G#%L"$K+K+- Z%A%ABGG VM{H'#R   $$(!c J$ ,,r$r^c*\rSrSrSrSrSrSrSrg)_MotorTransactionContexti?z;Internal transaction context manager for start_transaction.cXlgr;_session)r6rs r"r=!_MotorTransactionContext.__init__Bs r$c# U$7fr;rJrCs r" __aenter__#_MotorTransactionContext.__aenter__E  c# URR(aIUc#URR5IShvN gURR5IShvN ggN)N7fr;)rin_transactioncommit_transactionabort_transactionr6exc_typeexc_valexc_tbs r" __aexit__"_MotorTransactionContext.__aexit__HsN == ' 'mm66888mm55777 (87s!URS5(a([U5(aSnASSS5IShvN GM eSnAff=fN!,IShvN (df  N=fN![RRannURS5(a'[U5(a[U5(dSnAGM=URS5(a[U5(aSnAO eSnAff=fGM7f)az Executes an awaitable in a transaction. This method starts a transaction on this session, awaits ``coro`` once, and then commits the transaction. For example:: async def coro(session): orders = session.client.db.orders inventory = session.client.db.inventory inserted_id = await orders.insert_one( {"sku": "abc123", "qty": 100}, session=session) await inventory.update_one( {"sku": "abc123", "qty": {"$gte": 100}}, {"$inc": {"qty": -100}}, session=session) return inserted_id async with await client.start_session() as session: inserted_id = await session.with_transaction(coro) To pass arbitrary arguments to the ``coro``, wrap it with a ``lambda`` like this:: async def coro(session, custom_arg, custom_kwarg=None): # Transaction operations... async with await client.start_session() as session: await session.with_transaction( lambda s: coro(s, "custom_arg", custom_kwarg=1)) In the event of an exception, ``with_transaction`` may retry the commit or the entire transaction, therefore ``coro`` may be awaited multiple times by a single call to ``with_transaction``. Developers should be mindful of this possibility when writing a ``coro`` that modifies application state or has any other side-effects. Note that even when the ``coro`` is invoked multiple times, ``with_transaction`` ensures that the transaction will be committed at-most-once on the server. The ``coro`` should not attempt to start new transactions, but should simply run operations meant to be contained within a transaction. The ``coro`` should also not commit the transaction; this is handled automatically by ``with_transaction``. If the ``coro`` does commit or abort the transaction without error, however, ``with_transaction`` will return without taking further action. When ``coro`` raises an exception, ``with_transaction`` automatically aborts the current transaction. When ``coro`` or :meth:`~ClientSession.commit_transaction` raises an exception that includes the ``"TransientTransactionError"`` error label, ``with_transaction`` starts a new transaction and re-executes the ``coro``. When :meth:`~ClientSession.commit_transaction` raises an exception with the ``"UnknownTransactionCommitResult"`` error label, ``with_transaction`` retries the commit until the result of the transaction is known. This method will cease retrying after 120 seconds has elapsed. This timeout is not configurable and any exception raised by the ``coro`` or by :meth:`ClientSession.commit_transaction` after the timeout is reached will be re-raised. Applications that desire a different timeout duration should not use this method. :Parameters: - `coro`: The coroutine to run inside a transaction. The coroutine must accept a single argument, this session. Note, under certain error conditions the coroutine may be run multiple times. - `read_concern` (optional): The :class:`~pymongo.read_concern.ReadConcern` to use for this transaction. - `write_concern` (optional): The :class:`~pymongo.write_concern.WriteConcern` to use for this transaction. - `read_preference` (optional): The read preference to use for this transaction. If ``None`` (the default) the :attr:`read_preference` of this :class:`Database` is used. See :mod:`~pymongo.read_preferences` for options. :Returns: The return value of the ``coro``. .. versionadded:: 2.1 NTransientTransactionErrorUnknownTransactionCommitResult)rrstart_transaction Exceptionrrr'r(r) PyMongoErrorhas_error_labelr#rr-) r6coror[r\rZmax_commit_time_msr!retr,s r"with_transaction&AgnosticClientSession.with_transactionxsv^^% --_  $T *C "&& 11333$ S+ **"44666"3(C(CDD//0KLL.z::!  .4~~22++,LMM.z:: 7 < <!**+FGGL^"MM3s-GBGD. BBB GD,G*E =E>E GB D)$D$6B97AD$ D. GDG#D$$D))D.,G.E4D7 5 EGE G(6GG%&G GGGGcPURRUUUUS9 [U5$)aStart a multi-statement transaction. Takes the same arguments as :class:`~pymongo.client_session.TransactionOptions`. Best used in a context manager block: .. code-block:: python3 # Use "await" for start_session, but not for start_transaction. async with await client.start_session() as s: async with s.start_transaction(): await collection.delete_one({"x": 1}, session=s) await collection.insert_one({"x": 2}, session=s) )r[r\rZr)r2rr)r6r[r\rZrs r"r'AgnosticClientSession.start_transactions4& ''%'+1 ( (--r$cUR$)z8The :class:`~MotorClient` this session was created from.rrCs r"clientAgnosticClientSession.client||r$c# U$7fr;rJrCs r"r AgnosticClientSession.__aenter__ rrcD# URRXU5 g7fr;)r2__exit__rs r"rAgnosticClientSession.__aexit__#s x&9s c[S5e)NzMUse Motor sessions like 'async with await client.start_session()', not 'with')rrCs r" __enter__AgnosticClientSession.__enter__&s [  r$cgr;rJrs r"rAgnosticClientSession.__exit__+ r$r )NNNN)!rBrFrGrHrrrrwrrr end_sessionr cluster_time has_endedrroperation_time session_idradvance_cluster_timeadvance_operation_timer=rrrrr rrrrrIrJr$r"rrPs"0&%$.K#%L "I%'N G%'N!#J)++-$*  FR_c.6:  r$rc(^\rSrSrSr\r\"5r\"5r \ "\ RS9r \ "5R\5r\"5r\ "5R'S5r\"5R\5r\"\ R,S9r\"5R\5r\"5r\"5R'S5r\"5R\5r\"SS9rU4SjrSr SS jr!SS jr"\#S 5r$S r%S r&Sr'SrSr(Sr)U=r*$)ri/rarbMotorCollection aggregate attr_namec >XlURS5nUbUO[URU40UD6n[TU]U5 g)Nr)rrrr r2rxr=)r6r rvrzrr2r3s r"r=AgnosticDatabase.__init__BsA JJ{+ ) 598FOOUY;d]c;d "r$c[[URUR5nU"USURU/[ U5Q70[ U5D6$)aExecute an aggregation pipeline on this database. Introduced in MongoDB 3.6. The aggregation can be run on a secondary if the client is connected to a replica set and its ``read_preference`` is not :attr:`PRIMARY`. The :meth:`aggregate` method obeys the :attr:`read_preference` of this :class:`MotorDatabase`, except when ``$out`` or ``$merge`` are used, in which case :attr:`PRIMARY` is used. All optional `aggregate command`_ parameters should be passed as keyword arguments to this method. Valid options include, but are not limited to: - `allowDiskUse` (bool): Enables writing to temporary files. When set to True, aggregation stages can write data to the _tmp subdirectory of the --dbpath directory. The default is False. - `maxTimeMS` (int): The maximum amount of time to allow the operation to run in milliseconds. - `batchSize` (int): The maximum number of documents to return per batch. Ignored if the connected mongod or mongos does not support returning aggregate results using a cursor. - `collation` (optional): An instance of :class:`~pymongo.collation.Collation`. - `let` (dict): A dict of parameter names and values. Values must be constant or closed expressions that do not reference document fields. Parameters can then be accessed as variables in an aggregate expression context (e.g. ``"$$var"``). This option is only supported on MongoDB >= 5.0. Returns a :class:`MotorCommandCursor` that can be iterated like a cursor from :meth:`find`:: async def f(): # Lists all operations currently running on the server. pipeline = [{"$currentOp": {}}] async for operation in client.admin.aggregate(pipeline): print(operation) .. note:: This method does not support the 'explain' option. Please use :meth:`MotorDatabase.command` instead. .. note:: The :attr:`MotorDatabase.write_concern` of this database is automatically applied to this operation. .. versionadded:: 2.1 .. _aggregate command: https://www.mongodb.com/docs/manual/reference/command/aggregate/ z$cmd.aggregaterAgnosticLatentCommandCursorrlrF_async_aggregaterrr6rryrzrs r"r"AgnosticDatabase.aggregateIs`f3 '$//  ! "  ! !  ! &  $F+   r$c t[[URUR5n U "UUUUUUUUUU U U U 5 $)a Watch changes on this database. Returns a :class:`~MotorChangeStream` cursor which iterates over changes on this database. Introduced in MongoDB 4.0. See the documentation for :meth:`MotorCollection.watch` for more details and examples. :Parameters: - `pipeline` (optional): A list of aggregation pipeline stages to append to an initial ``$changeStream`` stage. Not all pipeline stages are valid after a ``$changeStream`` stage, see the MongoDB documentation on change streams for the supported stages. - `full_document` (optional): The fullDocument option to pass to the ``$changeStream`` stage. Allowed values: 'updateLookup'. When set to 'updateLookup', the change notification for partial updates will include both a delta describing the changes to the document, as well as a copy of the entire document that was changed from some time after the change occurred. - `resume_after` (optional): A resume token. If provided, the change stream will start returning changes that occur directly after the operation specified in the resume token. A resume token is the _id value of a change document. - `max_await_time_ms` (optional): The maximum time in milliseconds for the server to wait for changes before responding to a getMore operation. - `batch_size` (optional): The maximum number of documents to return per batch. - `collation` (optional): The :class:`~pymongo.collation.Collation` to use for the aggregation. - `start_at_operation_time` (optional): If provided, the resulting change stream will only return changes that occurred at or after the specified :class:`~bson.timestamp.Timestamp`. Requires MongoDB >= 4.0. - `session` (optional): a :class:`~pymongo.client_session.ClientSession`. - `start_after` (optional): The same as `resume_after` except that `start_after` can resume notifications after an invalidate event. This option and `resume_after` are mutually exclusive. - `comment` (optional): A user-provided comment to attach to this command. - `full_document_before_change`: Allowed values: `whenAvailable` and `required`. Change events may now result in a `fullDocumentBeforeChange` response field. - `show_expanded_events` (optional): Include expanded events such as DDL events like `dropIndexes`. :Returns: A :class:`~MotorChangeStream`. .. versionchanged:: 3.2 Added ``show_expanded_events`` parameter. .. versionchanged:: 3.1 Added ``full_document_before_change`` parameter. .. versionchanged:: 3.0 Added ``comment`` parameter. .. versionchanged:: 2.1 Added the ``start_after`` parameter. .. versionadded:: 2.0 .. mongodoc:: changeStreams rrs r"rAgnosticDatabase.watchrr$c(^^^ # U4m UTS'UTS'UTS'UTS'UTS'UTS'U UU4Sjn TR5n TRRX5IShvN n [[TRTR 5n U "U T5$N27f) aIssue a MongoDB command and parse the response as a cursor. If the response from the server does not include a cursor field, an error will be thrown. Otherwise, behaves identically to issuing a normal MongoDB command. :Parameters: - `command`: document representing the command to be issued, or the name of the command (for simple commands only). .. note:: the order of keys in the `command` document is significant (the "verb" must come first), so commands which require multiple keys (e.g. `findandmodify`) should use an instance of :class:`~bson.son.SON` or a string and kwargs instead of a Python `dict`. - `value` (optional): value to use for the command verb when `command` is passed as a string - `read_preference` (optional): The read preference for this operation. See :mod:`~pymongo.read_preferences` for options. If the provided `session` is in a transaction, defaults to the read preference configured for the transaction. Otherwise, defaults to :attr:`~pymongo.read_preferences.ReadPreference.PRIMARY`. - `codec_options`: A :class:`~bson.codec_options.CodecOptions` instance. - `session` (optional): A :class:`MotorClientSession`. - `comment` (optional): A user-provided comment to attach to future getMores for this command. - `max_await_time_ms` (optional): The number of ms to wait for more data on future getMores for this command. - `**kwargs` (optional): additional keyword arguments will be added to the command document before it is sent .. note:: :meth:`command` does **not** obey this Database's :attr:`read_preference` or :attr:`codec_options`. You must use the ``read_preference`` and ``codec_options`` parameters instead. .. note:: :meth:`command` does **not** apply any custom TypeDecoders when decoding the command response. .. note:: If this client has been configured to use MongoDB Stable API (see :ref:`versioned-api-ref`), then :meth:`command` will automatically add API versioning options to the given command. Explicitly adding API versioning options in the command and declaring an API version on the client is not supported. .. seealso:: The MongoDB documentation on `commands `_. valuerZrYrrrc`>TRR"[T50[T5D6$r;)r2cursor_commandrr)ryrzr6sr"inner.AgnosticDatabase.cursor_command..inner3s/==//$T*.CF.K r$N)rrlrun_on_executorrrrF)r6commandr0rZrYrrrrzr3loopcursorrrys` ` @r"r2AgnosticDatabase.cursor_commandszzw$3 !"/#y#y&7"#  !66tCC2 !4??DOO FD)) DsABB3BcUR$)z*This MotorDatabase's :class:`MotorClient`.r rCs r"r AgnosticDatabase.clientAr r$cURS5(a)[URRSU<SUS35eX$)Nrrrz$ collection, use database['{name}'].rrs r"rAgnosticDatabase.__getattr__FsP ??3   >>**++=dXEUVZU[67  zr$c\[[URUR5nU"X5$r;)rAgnosticCollectionrlrFr6rvcollection_classs r"rAgnosticDatabase.__getitem__Os)6   ++r$cURRnURRRnUS:Xa[ US35e[ SUSUS35e)N open_synczA.open_sync() is unnecessary Motor 0.2, see changelog for details.z@MotorDatabase object is not callable. If you meant to call the 'z' method on a z4 object it is failing because no such method exists.)r2rvrr3rBrs)r6ryrz database_nameclient_class_names r"__call__AgnosticDatabase.__call__Vsx **  LL22;; K '$%&--   &~6G5HI5 5  r$cUR[La6[[URUR 5nU"XR US9$UR[La%URURUR US9$UR[La-[[URUR 5nU"X5$U$r) r3rrr?rlrFrvr rrr)r6rklassrs r"rAgnosticDatabase.wrapes ==J &/"DOOT__Exx37 7 ]]h &>>$,,C>H H ]]m +#>%t$ (2 2Jr$c6URR5$r;rrCs r"rAgnosticDatabase.get_io_loopwrr$r r)rNNNNN)+rBrFrGrHrr rwrr__bool__rrcmd_docr6rrcreate_collectionr dereferencerdrop_collectionget_collectionlist_collection_names_doclist_collection_namesrlist_collectionsrrvvalidate_collection with_optionsr*r=r"rr2rr rrrGrrIrrs@r"rr/sR*!HHz112G$++J7+K"n++,=>O#%**:6N%**N*NO {'' 6  D#+,,->?!#((2L ;7#> D $$(!c PQ*f,  $**r$rc^\rSrSrSr\r\"5r\"5r \ "\ RS9r \"5r\ "\ R S9r\ "\ R$S9r\ "5r\ "5r\ "\ R,S9r\ "\ R0S9r\"5r\ "\ R6S9r\ "5r\ "5r\ "5r\ "5r \"\ RBS9r"\ "\ RFS9r$\ "\ RJS9r&\ "\ RNS9r(\)"5r*\"\ RVS9r,\-"\ R\S9r/\ "\ R`S9r1\)"5r2\"5r3\ "5r4\ "\ RjS9r6\ "\ RnS9r8\ "\ RrS9r:\ "5r;\"5Ry\5r=\"SS9r>\"SS9r?\"SS9r@\"SS9rASU4S jjrBS rCS rDS rES rFSrGSrHSrISSjrJSSjrKSrLSr[[URUR5n[ X5(d[ SU-5eUbUO[ URUUUUUS9n [T U]%U 5 Xl g)Nz?First argument to MotorCollection must be MotorDatabase, not %r)rYrZr\r[) rrrlrFr'rsrr2rxr=database) r6r^rvrYrZr\r[rrr2r3s r"r=AgnosticCollection.__init__s//?RVRaRab(--QT\\  $ !!+ /+)   " r$c URS5(a=URSU3n[URRSU<SUSUS35eX$)Nr.rrz collection, use database['r)rrvrr3rB)r6rv full_names r"rAgnosticCollection.__getattr__sj ??3  99+Qtf-I >>**++=dXEUV_U`-i[=  zr$c[[URUR5nU"URUR S-U-UR US9$)Nrar)rr?rlrFr^rvr2r@s r"rAgnosticCollection.__getitem__sL6   MM499s?T1T]]4=P  r$cF[SURR-5e)NzMotorCollection object is not callable. If you meant to call the '%s' method on a MotorCollection object it is failing because no such method exists.)rsr2rvr6ryrzs r"rGAgnosticCollection.__call__s' 57;}}7I7I J  r$cURR"[U50[U5D6n[ [ UR UR5nU"X05$)akCreate a :class:`MotorCursor`. Same parameters as for PyMongo's :meth:`~pymongo.collection.Collection.find`. Note that ``find`` does not require an ``await`` expression, because ``find`` merely creates a :class:`MotorCursor` without performing any operations on the server. ``MotorCursor`` methods such as :meth:`~MotorCursor.to_list` perform actual operations. )r2findrrrAgnosticCursorrlrFr6ryrzr8rs r"rjAgnosticCollection.findsN##%8%>`BWX^B_`2>4??TXTcTcd F))r$cURR"[U50[U5D6n[ [ UR UR5nU"X05$)aNQuery the database and retrieve batches of raw BSON. Similar to the :meth:`find` method but returns each batch as bytes. This example demonstrates how to work with raw batches, but in practice raw batches should be passed to an external library that can decode BSON into another data type, rather than used with PyMongo's :mod:`bson` module. .. code-block:: python3 async def get_raw(): cursor = db.test.find_raw_batches() async for batch in cursor: print(bson.decode_all(batch)) Note that ``find_raw_batches`` does not support sessions. .. versionadded:: 2.0 )r2find_raw_batchesrrrAgnosticRawBatchCursorrlrFrls r"ro#AgnosticCollection.find_raw_batchessU*//  & *?*G 3 "DOOT__ F))r$c[[URUR5nU"UURU/[ U5Q70[ U5D6$)a Execute an aggregation pipeline on this collection. The aggregation can be run on a secondary if the client is connected to a replica set and its ``read_preference`` is not :attr:`PRIMARY`. :Parameters: - `pipeline`: a single command or list of aggregation commands - `session` (optional): a :class:`~pymongo.client_session.ClientSession`, created with :meth:`~MotorClient.start_session`. - `**kwargs`: send arbitrary parameters to the aggregate command All optional `aggregate command`_ parameters should be passed as keyword arguments to this method. Valid options include, but are not limited to: - `allowDiskUse` (bool): Enables writing to temporary files. When set to True, aggregation stages can write data to the _tmp subdirectory of the --dbpath directory. The default is False. - `maxTimeMS` (int): The maximum amount of time to allow the operation to run in milliseconds. - `batchSize` (int): The maximum number of documents to return per batch. Ignored if the connected mongod or mongos does not support returning aggregate results using a cursor. - `collation` (optional): An instance of :class:`~pymongo.collation.Collation`. - `let` (dict): A dict of parameter names and values. Values must be constant or closed expressions that do not reference document fields. Parameters can then be accessed as variables in an aggregate expression context (e.g. ``"$$var"``). This option is only supported on MongoDB >= 5.0. Returns a :class:`MotorCommandCursor` that can be iterated like a cursor from :meth:`find`:: async def f(): pipeline = [{'$project': {'name': {'$toUpper': '$name'}}}] async for doc in collection.aggregate(pipeline): print(doc) Note that this method returns a :class:`MotorCommandCursor` which lazily runs the aggregate command when first iterated. In order to run an aggregation with ``$out`` or ``$merge`` the application needs to iterate the cursor, for example:: cursor = motor_coll.aggregate([{'$out': 'out'}]) # Iterate the cursor to run the $out (or $merge) operation. await cursor.to_list(length=None) # Or more succinctly: await motor_coll.aggregate([{'$out': 'out'}]).to_list(length=None) # Or: async for _ in motor_coll.aggregate([{'$out': 'out'}]): pass :class:`MotorCommandCursor` does not allow the ``explain`` option. To explain MongoDB's query plan for the aggregation, use :meth:`MotorDatabase.command`:: async def f(): plan = await db.command( 'aggregate', 'COLLECTION-NAME', pipeline=[{'$project': {'x': 1}}], explain=True) print(plan) .. versionchanged:: 2.1 This collection's read concern is now applied to pipelines containing the `$out` stage when connected to MongoDB >= 4.2. .. versionchanged:: 1.0 :meth:`aggregate` now **always** returns a cursor. .. versionchanged:: 0.5 :meth:`aggregate` now returns a cursor by default, and the cursor is returned immediately without an ``await``. See :ref:`aggregation changes in Motor 0.5 `. .. versionchanged:: 0.2 Added cursor support. .. _aggregate command: https://mongodb.com/docs/manual/applications/aggregation r(r+s r"r"AgnosticCollection.aggregatesZl3 '$//    ! !  ! &  $F+   r$c [[URUR5nU"XRU40[ U5D6$)aaPerform an aggregation and retrieve batches of raw BSON. Similar to the :meth:`aggregate` method but returns each batch as bytes. This example demonstrates how to work with raw batches, but in practice raw batches should be passed to an external library that can decode BSON into another data type, rather than used with PyMongo's :mod:`bson` module. .. code-block:: python3 async def get_raw(): cursor = db.test.aggregate_raw_batches() async for batch in cursor: print(bson.decode_all(batch)) Note that ``aggregate_raw_batches`` does not support sessions. .. versionadded:: 2.0 )rr)rlrF_async_aggregate_raw_batchesr)r6rrzrs r"rZ(AgnosticCollection.aggregate_raw_batchesqsE*3 '$//  33X AVW]A^  r$c t[[URUR5n U "UUUUUUUUUU U U U 5 $)aWatch changes on this collection. Performs an aggregation with an implicit initial ``$changeStream`` stage and returns a :class:`~MotorChangeStream` cursor which iterates over changes on this collection. Introduced in MongoDB 3.6. A change stream continues waiting indefinitely for matching change events. Code like the following allows a program to cancel the change stream and exit. .. code-block:: python3 change_stream = None async def watch_collection(): global change_stream # Using the change stream in an "async with" block # ensures it is canceled promptly if your code breaks # from the loop or throws an exception. async with db.collection.watch() as change_stream: async for change in change_stream: print(change) # Tornado from tornado.ioloop import IOLoop def main(): loop = IOLoop.current() # Start watching collection for changes. try: loop.run_sync(watch_collection) except KeyboardInterrupt: if change_stream: loop.run_sync(change_stream.close) # asyncio try: asyncio.run(watch_collection()) except KeyboardInterrupt: pass The :class:`~MotorChangeStream` async iterable blocks until the next change document is returned or an error is raised. If the :meth:`~MotorChangeStream.next` method encounters a network error when retrieving a batch from the server, it will automatically attempt to recreate the cursor such that no change events are missed. Any error encountered during the resume attempt indicates there may be an outage and will be raised. .. code-block:: python3 try: pipeline = [{"$match": {"operationType": "insert"}}] async with db.collection.watch(pipeline) as stream: async for change in stream: print(change) except pymongo.errors.PyMongoError: # The ChangeStream encountered an unrecoverable error or the # resume attempt failed to recreate the cursor. logging.error("...") For a precise description of the resume process see the `change streams specification`_. :Parameters: - `pipeline` (optional): A list of aggregation pipeline stages to append to an initial ``$changeStream`` stage. Not all pipeline stages are valid after a ``$changeStream`` stage, see the MongoDB documentation on change streams for the supported stages. - `full_document` (optional): The fullDocument option to pass to the ``$changeStream`` stage. Allowed values: 'updateLookup'. When set to 'updateLookup', the change notification for partial updates will include both a delta describing the changes to the document, as well as a copy of the entire document that was changed from some time after the change occurred. - `resume_after` (optional): A resume token. If provided, the change stream will start returning changes that occur directly after the operation specified in the resume token. A resume token is the _id value of a change document. - `max_await_time_ms` (optional): The maximum time in milliseconds for the server to wait for changes before responding to a getMore operation. - `batch_size` (optional): The maximum number of documents to return per batch. - `collation` (optional): The :class:`~pymongo.collation.Collation` to use for the aggregation. - `session` (optional): a :class:`~pymongo.client_session.ClientSession`. - `start_after` (optional): The same as `resume_after` except that `start_after` can resume notifications after an invalidate event. This option and `resume_after` are mutually exclusive. - `comment` (optional): A user-provided comment to attach to this command. - `full_document_before_change`: Allowed values: `whenAvailable` and `required`. Change events may now result in a `fullDocumentBeforeChange` response field. - `show_expanded_events` (optional): Include expanded events such as DDL events like `dropIndexes`. :Returns: A :class:`~MotorChangeStream`. See the :ref:`tornado_change_stream_example`. .. versionchanged:: 3.2 Added ``show_expanded_events`` parameter. .. versionchanged:: 3.1 Added ``full_document_before_change`` parameter. .. versionchanged:: 3.0 Added ``comment`` parameter. .. versionchanged:: 2.1 Added the ``start_after`` parameter. .. versionadded:: 1.2 .. mongodoc:: changeStreams .. _change streams specification: https://github.com/mongodb/specifications/blob/master/source/change-streams/change-streams.rst rrs r"rAgnosticCollection.watchsT`3 $//4??         #    '   r$c v[[URUR5nU"XR4SU0UD6$)a.Get a cursor over the index documents for this collection. :: async def print_indexes(): async for index in db.test.list_indexes(): print(index) If the only index is the default index on ``_id``, this might print:: SON([('v', 1), ('key', SON([('_id', 1)])), ('name', '_id_')]) r)rr)rlrF_async_list_indexes)r6rrzrs r"r[AgnosticCollection.list_indexes4s:3 '$// D":":VGVvVVr$cx[[URUR5nU"XR/UQ70UD6$)z?Return a cursor over search indexes for the current collection.)rr)rlrF_async_list_search_indexes)r6ryrzrs r"r\&AgnosticCollection.list_search_indexesFs82 '$// D"A"ASDSFSSr$cUR[La%URURURUS9$UR[La [ X5$UR[ La-[[URUR5nU"X5$UR[La-[[URUR5nU"X5$U$r) r3rr^rvrrkrrrrlrFrr)r6rrchange_stream_classs r"rAgnosticCollection.wrapOs ==J &>>$--S>I I ]]f $!#, , ]]m +#>%t$ (2 2 ]]l *"=$doot# 's1 1Jr$c6URR5$r;)r^rrCs r"rAgnosticCollection.get_io_loopds}}((**r$)r^)NNNNNrr;)PrBrFrGrHrrrwrrrNrrbulk_write_docrrcount_documentscreate_index_doc create_indexcreate_indexes_doccreate_indexescreate_search_indexcreate_search_indexesdelete_many_doc delete_manydelete_one_doc delete_onedistinctdrop_docdrop drop_indexdrop_search_index drop_indexesestimated_document_count find_one_docfind_onefind_one_and_delete_docfind_one_and_deletefind_one_and_replace_docfind_one_and_replacefind_one_and_update_docfind_one_and_updaterrbindex_information_docindex_informationrinsert_many_doc insert_manyinsert_one_doc insert_onervrrenamereplace_one_doc replace_oneupdate_many_doc update_manyupdate_one_doc update_oneupdate_search_indexrrXr*rurzr}r=rrrGrjror"rZrr[r\rrIrrs@r"r?r?{sK,#HH*";";K*";";L+~Z445H&:+M+MN'J,O,OP&:+M+MN "I!j&F&FG!;!;K:#=#=>K*";";[TU]US9 X lSUlSUlg)aDon't construct a cursor yourself, but acquire one from methods like :meth:`MotorCollection.find` or :meth:`MotorCollection.aggregate`. .. note:: There is no need to manually close cursors; they are closed by the server after being fully iterated with :meth:`to_list`, :meth:`each`, or `async for`, or automatically closed by the client when the :class:`MotorCursor` is cleaned up by the garbage collector. r<FN)rxr= collectionstartedclosed)r6r8rr3s r"r=AgnosticBaseCursor.__init__ws( &)$  r$cU$r;rJrCs r" __aiter__AgnosticBaseCursor.__aiter__ r$c# UR(aGUR5(dUR5IShvN (a[UR5$[ eN$7f)z+Advance the cursor. .. versionadded:: 2.2 N)alive _buffer_size _get_morenextr2StopAsyncIterationrCs r"rAgnosticBaseCursor.nextsF ::4,,..8H2H2H & &  3Is:A#A!%A#c# U$7fr;rJrCs r"rAgnosticBaseCursor.__aenter__rrcd# UR(aUR5IShvN ggN7fr;r2rrs r"rAgnosticBaseCursor.__aexit__# ==**,     %0.0cUR(d[RRS5eSUlUR 5$)z+Initial query or getMore. Returns a Future.zICan't call get_more() on a MotorCursor that has been exhausted or killed.T)rr(r)InvalidOperationr_refreshrCs r"rAgnosticBaseCursor._get_mores8zz..11[  }}r$c[R"S[SS9 UR5(d!UR(aUR 5$UR5(a<UR RUR55nURS5 U$UR RUR55nURS5 U$)a7**DEPRECATED** - A Future used with `gen.coroutine`_ to asynchronously retrieve the next document in the result set, fetching a batch of documents from the server if necessary. Resolves to ``False`` if there are no more documents, otherwise :meth:`next_object` is guaranteed to return a document: .. doctest:: fetch_next :hide: >>> _ = MongoClient().test.test_collection.delete_many({}) >>> collection = MotorClient().test.test_collection .. attention:: The :attr:`fetch_next` property is deprecated and will be removed in Motor 3.0. Use `async for` to iterate elegantly and efficiently over :class:`MotorCursor` objects instead.: .. doctest:: fetch_next >>> async def f(): ... await collection.drop() ... await collection.insert_many([{"_id": i} for i in range(5)]) ... async for doc in collection.find(): ... sys.stdout.write(str(doc["_id"]) + ", ") ... print("done") ... >>> IOLoop.current().run_sync(f) 0, 1, 2, 3, 4, done While it appears that fetch_next retrieves each document from the server individually, the cursor actually fetches documents efficiently in `large batches`_. Example usage: .. doctest:: fetch_next >>> async def f(): ... await collection.drop() ... await collection.insert_many([{"_id": i} for i in range(5)]) ... cursor = collection.find().sort([("_id", 1)]) ... while await cursor.fetch_next: ... doc = cursor.next_object() ... sys.stdout.write(str(doc["_id"]) + ", ") ... print("done") ... >>> IOLoop.current().run_sync(f) 0, 1, 2, 3, 4, done .. versionchanged:: 2.2 Deprecated. .. _`large batches`: https://www.mongodb.com/docs/manual/tutorial/iterate-a-cursor/#cursor-batches .. _`gen.coroutine`: http://tornadoweb.org/en/stable/gen.html zThe fetch_next property is deprecated and may be removed in a future major release. Use `async for` to iterate over Cursor objects instead. stacklevelTF) warningswarnDeprecationWarningrrrrl get_futurer set_result)r6futures r" fetch_nextAgnosticBaseCursor.fetch_nextsn   +     ""tzz>># #    __//0@0@0BCF   d #M__//0@0@0BCF   e $Mr$c[R"S[SS9 UR5(dg[ UR 5$)a?**DEPRECATED** - Get a document from the most recently fetched batch, or ``None``. See :attr:`fetch_next`. The :meth:`next_object` method is deprecated and may be removed in a future major release. Use `async for` to elegantly iterate over :class:`MotorCursor` objects instead. .. versionchanged:: 2.2 Deprecated. zThe next_object method is deprecated and may be removed in a future major release. Use `async for` to iterate over Cursor objects instead.rrN)rrrrrr2rCs r" next_objectAgnosticBaseCursor.next_objects@   +     ""DMM""r$cT[U5(d[eURUS5 g)aIterates over all the documents for this cursor. :meth:`each` returns immediately, and `callback` is executed asynchronously for each document. `callback` is passed ``(None, None)`` when iteration is complete. Cancel iteration early by returning ``False`` from the callback. (Only ``False`` cancels iteration: returning ``None`` or 0 does not.) .. testsetup:: each from tornado.ioloop import IOLoop MongoClient().test.test_collection.delete_many({}) MongoClient().test.test_collection.insert_many([{"_id": i} for i in range(5)]) collection = MotorClient().test.test_collection .. doctest:: each >>> def each(result, error): ... if error: ... raise error ... elif result: ... sys.stdout.write(str(result["_id"]) + ", ") ... else: ... # Iteration complete ... IOLoop.current().stop() ... print("done") ... >>> cursor = collection.find().sort([("_id", 1)]) >>> cursor.each(callback=each) >>> IOLoop.current().start() 0, 1, 2, 3, 4, done .. note:: Unlike other Motor methods, ``each`` requires a callback and does not return a Future, so it cannot be used in a coroutine. ``async for`` and :meth:`to_list` are much easier to use. :Parameters: - `callback`: function taking (document, error) N)callabler_each_got_more)r6callbacks r"eachAgnosticBaseCursor.each s&V!!% % Hd+r$cU(aUR5 UR5S:aJ[UR5nU"US5SLagUR (agUR5S:aMJUR (agUR(dUR(dEURRUR5UR5URU5 gURRUR5[R "USS55 g![anU"SU5 SnAgSnAff=f)NrF)resultrrrr2rr cursor_idrrl add_futurerrr call_soon functoolspartial)r6rrerrorrcs r"r!AgnosticBaseCursor._each_got_more;s    !A%t}}%CT"e+{{!A% ::4>> OO & &  "DNN$4d6I6I8  OO % %d&6&6&8):K:KHVZ\`:a b- u% sD00 E : EE cUb4[U[5(d[SU-5eUS:a [S5eUR 5[ S-(a[ RRS5eURRUR55nUR(dUR/5 U$/nURRUR5UR5UR UUU5 U$)a!Get a list of documents. .. testsetup:: to_list MongoClient().test.test_collection.delete_many({}) MongoClient().test.test_collection.insert_many([{"_id": i} for i in range(4)]) from tornado import ioloop .. doctest:: to_list >>> from motor.motor_tornado import MotorClient >>> collection = MotorClient().test.test_collection >>> >>> async def f(): ... cursor = collection.find().sort([("_id", 1)]) ... docs = await cursor.to_list(length=2) ... while docs: ... print(docs) ... docs = await cursor.to_list(length=2) ... print("done") ... >>> ioloop.IOLoop.current().run_sync(f) [{'_id': 0}, {'_id': 1}] [{'_id': 2}, {'_id': 3}] done :Parameters: - `length`: maximum number of documents to return for this call, or None Returns a Future. .. versionchanged:: 2.0 No longer accepts a callback argument. .. versionchanged:: 0.2 `callback` must be passed as a keyword argument, like ``to_list(10, callback=callback)``, and the `length` parameter is no longer optional. zlength must be an int, not %rrzlength must be non-negativetailable_cursorz%Can't call to_list on tailable cursor)r'intrs ValueError _query_flagsr r(r)rrlrrrrrr_to_list)r6lengthrthe_lists r"to_listAgnosticBaseCursor.to_listWsV  fc** ?& HII! !>??    0A!B B..112YZ Z++D,<,<,>?zz   b ! H OO & &  "     r$cUR5nUR5(agUcUnO[U[U5- U5n[ U5H0nUR UR 5R55 M2 USL=(a [U5U:nU(dUR(dURU5 gURRUR5UR5URXU5 g![a5n UR5(dUR!U 5 Sn A gSn A gSn A ff=fr;)rdoneminlenrangeappend_datapopleftrrrlrrrrr set_exception) r6rrrget_more_resultrnrreached_lengthr,s r"rAgnosticBaseCursor._to_lists *$++-F{{}}~X.71X 4 4 67$4/KCMV4KNTZZ!!(+**$$&(8$--[a *;;==$$S))! *s$%DBDAD E &EE c6URR5$r;)rrrCs r"rAgnosticBaseCursor.get_io_loops**,,r$cr# UR(d SUlUR5IShvN ggN7f)zSExplicitly kill this cursor on the server. Call like:: await cursor.close() TN)r _async_closerCs r"rAgnosticBaseCursor.closes/{{DK##% % % %s ,757c<URRU5 U$r;)r2rr6rs r"rAgnosticBaseCursor.batch_sizes   , r$c4[UR55$r;)rrrCs r"rAgnosticBaseCursor._buffer_sizes4::<  r$c[er;NotImplementedErrorrCs r"rAgnosticBaseCursor._query_flags!!r$c[er;r rCs r"rAgnosticBaseCursor._datarr$c[er;r rCs r"_killedAgnosticBaseCursor._killedrr$)rrrr;))rBrFrGrHrrVrWrXrSrrrrrrrrr=rr __anext__rrrrrrrrrrrrrrrrrrrIrrs@r"rrhsACFw/L{H G "I  E G$!IHHT#..,`c8BBH*8- &!""""r$rcf\rSrSrSr\r\"5r\ "5r \ "5r \ "5r \ "5r\ "5r\ "5r\ "5r\ "5r\ "\R(S9r\ "5r\ "\R.S9r\ "5r\ "5r\ "5r\ "5r\ "5r\ "5rSrSr Sr!Sr"Sr#S r$S r%S r&g ) rki MotorCursorrbcHURR5 SUlU$)z,Rewind this cursor to its unevaluated state.F)r2rewindrrCs r"rAgnosticCursor.rewinds   r$cjURURR5UR5$)zGet a clone of this cursor.)r3r2clonerrCs r"rAgnosticCursor.clones$~~dmm113T__EEr$cjURURR5UR5$r;)r3r2__copy__rrCs r"rAgnosticCursor.__copy__s$~~dmm446HHr$clURURRU5UR5$r;)r3r2 __deepcopy__r)r6memos r"r"AgnosticCursor.__deepcopy__s&~~dmm88>PPr$c.URR$r;)r2rrCs r"rAgnosticCursor._query_flagss}})))r$c.URR$r;r2rrCs r"rAgnosticCursor._data}}"""r$c.URR$r;r2rrCs r"rAgnosticCursor._killed}}$$$r$)rN)'rBrFrGrHrrrwrrrrrrexplain add_option remove_optionlimitskipmax_scanrcursor_sort_docsorthint where_docwherer max_time_msrmaxrallow_disk_userrrr"rrrrIrJr$r"rkrks( G)+I{HkG*,J-/M % 'E $ &D(*H $)C)C DD $ &D %**>*> ?E13+-K # %C # %C')G.0N FIQ*#%r$rkc\rSrSrSr\rSrg)rpi MotorRawBatchCursorrJN)rBrFrGrHrr rwrIrJr$r"rprp s0'r$rpc4\rSrSrSr\rSrSrSr Sr Sr g) riMotorCommandCursorc^# U4SjnTR5nTRRX!5IShvN $N7f)aAdvance the cursor without blocking indefinitely. This method returns the next document without waiting indefinitely for data. If no document is cached locally then this method runs a single getMore command. If the getMore yields any documents, the next document is returned, otherwise, if the getMore returns no documents (because there is no additional data) then ``None`` is returned. :Returns: The next document or ``None`` when no document is available after running a single getMore or when the cursor is closed. c8>TRR5$r;)r2try_nextrCsr"r3-AgnosticCommandCursor.try_next..inner"s==))+ +r$N)rrlr5)r6r3r7s` r"rCAgnosticCommandCursor.try_nexts6  ,!__44TAAAAs 5?=?cg)NrrJrCs r"r"AgnosticCommandCursor._query_flags(sr$c.URR$r;r(rCs r"rAgnosticCommandCursor._data+r*r$c.URR$r;r,rCs r"rAgnosticCommandCursor._killed.r.r$rJN) rBrFrGrHrrrwrCrrrrIrJr$r"rrs#/&B,#%r$rc\rSrSrSr\rSrg)AgnosticRawBatchCommandCursori2MotorRawBatchCommandCursorrJN)rBrFrGrHrrrwrIrJr$r"rMrM2s7.r$rMcV\rSrSrSrSr/rSrSrSr Sr Sr Sr Sr SrSrS rS rS rg) _LatentCursori7zCTake the place of a PyMongo CommandCursor until aggregate() begins.TNFc&URUlgr;)r2 _collection)r6rs r"r=_LatentCursor.__init__Cs%..r$cgr;rJrgs r" _end_session_LatentCursor._end_sessionFrr$cgr;rJrgs r" _die_lock_LatentCursor._die_lockIrr$c,[UR5$r;)rPrRrCs r"r_LatentCursor.cloneLsT--..r$cgr;rJrCs r"r_LatentCursor.rewindOrr$)rR)rBrFrGrHrrr_idr _sock_mgrr_explicit_sessionrr=rUrXrrrIrJr$r"rPrP7sGM E E CGIHI/  / r$rPcJ^\rSrSrSrU4SjrSrU4SjrU4SjrSr U=r $)r)iSMotorLatentCommandCursorc\>[TU][U5U5 X lX0lX@lgr;)rxr=rPstartryrz)r6rrdryrzr3s r"r=$AgnosticLatentCommandCursor.__init__Vs( z2J?   r$c"XRS'U$)N batchSize)rzrs r"r&AgnosticLatentCommandCursor.batch_sizeds#- K  r$c>UR(dSUlURRUR55nUR"UR 0UR D6nS=Ul=UlUlURRUR5X RU5 U$[TU])5$)NT) rrlrrrdryrzr _on_startedrxr)r6original_futurerr3s r"r%AgnosticLatentCommandCursor._get_morehs||DL"oo889I9I9KLOZZ:dkk:F37 7DJ 7T[ OO & &  "F,<,UR5nX0lUR5(agURR(dURR(d/UR [ URR55 g[TU]!5nURRX!5 g![a5nUR5(dURU5 SnAgSnAgSnAff=fr;) rr2rrrrrrxrrl chain_futurerr)r6rkrpymongo_cursorr,r3s r"rj'AgnosticLatentCommandCursor._on_startedxs F$]]_N*M ##%%}}""$--*=*=**3t}}/B/B+CD*,,,VE 3"''))--c22* 3sB>> C=&C88C=)ryr2rzrdr) rBrFrGrHrr=rrrjrIrrs@r"r)r)Ss$5 # FFr$r)c^\rSrSrSr\rSr\"SS9r \ "5r \ S\ S\4Sj5rU4S jrS rS r\S 5rS rSrSrSr\rSrSrSrSrSrSrU=r $)rizA change stream cursor. Should not be called directly by application developers. See :meth:`~MotorCollection.watch` for example usage. .. versionadded: 1.2 .. mongodoc:: changeStreams MotorChangeStreamrr#rNrOcU$r;rJrQs r"rS&AgnosticChangeStream.__class_getitem__rUr$c T>[TU]SS9 XlUUUUUUUU U U U U S. Ulg)Nr<) rrrrrrrrrrrr)rxr=_target_kwargs)r6targetrrrrrrrrrrrrr3s r"r=AgnosticChangeStream.__init__sG $'  *(!2$"'>&+F$8   r$cUR(d?URRR"S0[UR5D6Ulgg)NrJ)r2rvrrrwrCs r" _lazy_initAgnosticChangeStream._lazy_inits:}} LL1177^:OPTP\P\:]^DMr$cVUR5 URR5$r;)r{r2rCrCs r" _try_nextAgnosticChangeStream._try_nexts }}%%''r$cRUR(dgURR$)zDoes this cursor have the potential to return more data? .. note:: Even if :attr:`alive` is ``True``, :meth:`next` can raise :exc:`StopAsyncIteration` and :meth:`try_next` can return ``None``. T)r2rrCs r"rAgnosticChangeStream.alives}}}}"""r$c# UR(a0UR5IShvN nUbU$UR(aM0[5eN&7f)apAdvance the cursor. This method blocks until the next change document is returned or an unrecoverable error is raised. This method is used when iterating over all changes in the cursor. For example:: async def watch_collection(): resume_token = None pipeline = [{'$match': {'operationType': 'insert'}}] try: async with db.collection.watch(pipeline) as stream: async for insert_change in stream: print(insert_change) resume_token = stream.resume_token except pymongo.errors.PyMongoError: # The ChangeStream encountered an unrecoverable error or the # resume attempt failed to recreate the cursor. if resume_token is None: # There is no usable resume token because there was a # failure during ChangeStream initialization. logging.error('...') else: # Use the interrupted ChangeStream's resume token to # create a new ChangeStream. The new stream will # continue from the last seen insert change without # missing any events. async with db.collection.watch( pipeline, resume_after=resume_token) as stream: async for insert_change in stream: print(insert_change) Raises :exc:`StopAsyncIteration` if this change stream is closed. In addition to using an "async for" loop as shown in the code example above, you can also iterate the change stream by calling ``await change_stream.next()`` repeatedly. N)rrCr)r6rcs r"rAgnosticChangeStream.nextsBLjj 'C jjj !"" (s%AAA Ac# UR5nURRXR5IShvN $N7f)aAdvance the cursor without blocking indefinitely. This method returns the next change document without waiting indefinitely for the next change. If no changes are available, it returns None. For example: .. code-block:: python3 while change_stream.alive: change = await change_stream.try_next() # Note that the ChangeStream's resume token may be updated # even when no changes are returned. print("Current resume token: %r" % (change_stream.resume_token,)) if change is not None: print("Change document: %r" % (change,)) continue # We end up here when there are no recent changes. # Sleep for a while before trying again to avoid flooding # the server with getMore requests when no changes are # available. await asyncio.sleep(10) If no change document is cached locally then this method runs a single getMore command. If the getMore yields any documents, the next document is returned, otherwise, if the getMore returns no documents (because there have been no changes) then ``None`` is returned. :Returns: The next change document or ``None`` when no document is available after running a single getMore or when the cursor is closed. .. versionadded:: 2.1 N)rrlr5r~r6r7s r"rCAgnosticChangeStream.try_next s5D!__44T>>JJJJs9AAAcd# UR(aUR5IShvN ggN7f)zQClose this change stream. Stops any "async for" loops using this change stream. N)r2_closerCs r"rAgnosticChangeStream.close/s% ==++-    rcU$r;rJrCs r"rAgnosticChangeStream.__aiter__7rr$c# UR(d=UR5nURRXR5IShvN U$N7fr;)r2rrlr5r{rs r"rAgnosticChangeStream.__aenter__<sA}}##%D//11$H H H  IsA A A Acd# UR(aUR5IShvN ggN7fr;rrs r"rAgnosticChangeStream.__aexit__Brrc6URR5$r;)rvrrCs r"r AgnosticChangeStream.get_io_loopFrr$c[S5e)Nz/Use a change stream in "async with", not "with") RuntimeErrorrCs r"rAgnosticChangeStream.__enter__IsLMMr$cgr;rJrs r"rAgnosticChangeStream.__exit__Lrr$)rwrvr2)!rBrFrGrHrrrwrrrr resume_tokenrVrWrXrSr=r{r~rrrrCrrrrrrrrrIrrs@r"rrs&. G ,F#%LCF  D_(  # #+#Z#KJ I *N  r$rcX^\rSrSrSrSr\r\"\ RS9r \"5r \"5r \"5r\"\ RS9r\"5r\"5r\"5r\"5r\"5r\"5r\S\S\4Sj5rSU4Sjjr\S 5rS rS rS r S r!Sr"Sr#SSjr$Sr%U=r&$)AgnosticClientEncryptioniPz,Explicit client-side field level encryption.MotorClientEncryptionrbrNrOcU$r;rJrQs r"rS*AgnosticClientEncryption.__class_getitem__erUr$c>U(aURRU5 OSnURnURXXtU5n[T U]U5 XPlg)zExplicit client-side field level encryption. Takes the same constructor arguments as :class:`pymongo.encryption.ClientEncryption`, as well as: :Parameters: - `io_loop` (optional): Special event loop instance to use instead of default. N)rlrmr2rwrxr=rn) r6 kms_providerskey_vault_namespacekey_vault_clientrYrekms_tls_options sync_clientr2r3s r"r=!AgnosticClientEncryption.__init__isU$  OO , ,W 5G&// **  O  " r$crURcURR5UlUR$r;rrCs r"re AgnosticClientEncryption.io_looprr$cUR$r;rrCs r"r$AgnosticClientEncryption.get_io_looprr$c# U$7fr;rJrCs r"r#AgnosticClientEncryption.__aenter__rrcd# UR(aUR5IShvN ggN7fr;rrs r"r"AgnosticClientEncryption.__aexit__rrcH[SURRS35e)NzUse z in "async with", not "with")rr3rBrCs r"r"AgnosticClientEncryption.__enter__s"T$.."9"9!::VWXXr$cgr;rJrs r"r!AgnosticClientEncryption.__exit__rr$c# [[URUR5nU"URR 5U5$7fr;)rrkrlrFr2get_keys)r6rs r"r!AgnosticClientEncryption.get_keyss82>4??TXTcTcd DMM224d;;sAA c 6# [[URUR5nUR 5nURR "UUR R4UR UUUUS.UD6IShvN upU"XRU S9U 4$N7f)a}Create a collection with encryptedFields. .. warning:: This function does not update the encryptedFieldsMap in the client's AutoEncryptionOpts, thus the user must create a new client after calling this function with the encryptedFields returned. Normally collection creation is automatic. This method should only be used to specify options on creation. :class:`~pymongo.errors.EncryptionError` will be raised if the collection already exists. :Parameters: - `database`: the database in which to create a collection - `name`: the name of the collection to create - `encrypted_fields` (dict): Document that describes the encrypted fields for Queryable Encryption. For example:: { "escCollection": "enxcol_.encryptedCollection.esc", "ecocCollection": "enxcol_.encryptedCollection.ecoc", "fields": [ { "path": "firstName", "keyId": Binary.from_uuid(UUID('00000000-0000-0000-0000-000000000000')), "bsonType": "string", "queries": {"queryType": "equality"} }, { "path": "ssn", "keyId": Binary.from_uuid(UUID('04104104-1041-0410-4104-104104104104')), "bsonType": "string" } ] } The "keyId" may be set to ``None`` to auto-generate the data keys. - `kms_provider` (optional): the KMS provider to be used - `master_key` (optional): Identifies a KMS-specific key used to encrypt the new data key. If the kmsProvider is "local" the `master_key` is not applicable and may be omitted. - `**kwargs` (optional): additional keyword arguments are the same as "create_collection". All optional `create collection command`_ parameters should be passed as keyword arguments to this method. See the documentation for :meth:`~pymongo.database.Database.create_collection` for all valid options. :Raises: - :class:`~pymongo.errors.EncryptedCollectionError`: When either data-key creation or creating the collection fails. .. versionadded:: 3.2 .. _create collection command: https://mongodb.com/docs/manual/reference/command/create )r^rvencrypted_fields kms_provider master_keyNr) rr?rlrFrr5r2create_encrypted_collectionrv) r6r^rvrrrrzrAr7collefs r"r4AgnosticClientEncryption.create_encrypted_collectionsF7  !88  MM 5 5  &&-%!      ))tDbHH  sA;B=B>Br)NN)'rBrFrGrHrrr rwrrcreate_data_key_doccreate_data_keyencryptencrypt_expressiondecrypt close_docrrewrap_many_data_key delete_keyget_keyadd_key_alt_nameget_key_by_alt_nameremove_key_alt_namerVrWrXrSr=rrerrrrrrrrIrrs@r"rrPs62)"z'E'EFOnG%nG Z11 2E(>JnG#~&.&.CF : Y < QIQIr$r)Drrrrr( pymongo.authpymongo.commonpymongo.databasepymongo.errorspymongo.mongo_clientpymongo.change_streamrpymongo.client_sessionrpymongo.collectionrpymongo.command_cursorrrpymongo.cursorrr pymongo.cursor_sharedr r pymongo.driver_infor pymongo.encryptionr rjrrrpmetaprogrammingrrrrrrrrrr motor_commonrHAS_SSLssl ImportErrorr r#r-r/rLr^rrrr?rrkrprrMrPr)rrrJr$r"rsuL .0)G10%*/&   . &)"N O ??" '\ 'S,+S,l88"\ L\ ~I*-I*X j+/j+Zn"n"b -%'-%`(^( !%.!%H/$9/   89F"79Fx~ <~ BaI|aIs@ CGsE EE