o 'hi@s,UdZddlmZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZddlmZddlmZddlmZdd lmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0e rddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8m9Z9dZ:GdddZ;GdddZGd$d%d%Z?Gd&d'd'Z@dEd+d,ZAdFd/d0ZBe#eCd1d2gBZDd3eEd4<d5ZFdGd8d9ZGed:ZHe rdd;lImJZJGdd?d?ZLGd@dAdAZMGdBdCdCejNZOdS)HaLogical sessions for ordering sequential operations. .. versionadded:: 3.6 Causally Consistent Reads ========================= .. code-block:: python with client.start_session(causal_consistency=True) as session: collection = client.db.collection collection.update_one({"_id": 1}, {"$set": {"x": 10}}, session=session) secondary_c = collection.with_options(read_preference=ReadPreference.SECONDARY) # A secondary read waits for replication of the write. secondary_c.find_one({"_id": 1}, session=session) If `causal_consistency` is True (the default), read operations that use the session are causally after previous read and write operations. Using a causally consistent session, an application can read its own writes and is guaranteed monotonic reads, even when reading from replica set secondaries. .. seealso:: The MongoDB documentation on `causal-consistency `_. .. _transactions-ref: Transactions ============ .. versionadded:: 3.7 MongoDB 4.0 adds support for transactions on replica set primaries. A transaction is associated with a :class:`ClientSession`. To start a transaction on a session, use :meth:`ClientSession.start_transaction` in a with-statement. Then, execute an operation within the transaction by passing the session to the operation: .. code-block:: python orders = client.db.orders inventory = client.db.inventory with client.start_session() as session: with session.start_transaction(): orders.insert_one({"sku": "abc123", "qty": 100}, session=session) inventory.update_one( {"sku": "abc123", "qty": {"$gte": 100}}, {"$inc": {"qty": -100}}, session=session, ) Upon normal completion of ``with session.start_transaction()`` block, the transaction automatically calls :meth:`ClientSession.commit_transaction`. If the block exits with an exception, the transaction automatically calls :meth:`ClientSession.abort_transaction`. In general, multi-document transactions only support read/write (CRUD) operations on existing collections. However, MongoDB 4.4 adds support for creating collections and indexes with some limitations, including an insert operation that would result in the creation of a new collection. For a complete description of all the supported and unsupported operations see the `MongoDB server's documentation for transactions `_. A session may only have a single active transaction at a time, multiple transactions on the same session can be executed in sequence. Sharded Transactions ^^^^^^^^^^^^^^^^^^^^ .. versionadded:: 3.9 PyMongo 3.9 adds support for transactions on sharded clusters running MongoDB >=4.2. Sharded transactions have the same API as replica set transactions. When running a transaction against a sharded cluster, the session is pinned to the mongos server selected for the first operation in the transaction. All subsequent operations that are part of the same transaction are routed to the same mongos server. When the transaction is completed, by running either commitTransaction or abortTransaction, the session is unpinned. .. seealso:: The MongoDB documentation on `transactions `_. .. _snapshot-reads-ref: Snapshot Reads ============== .. versionadded:: 3.12 MongoDB 5.0 adds support for snapshot reads. Snapshot reads are requested by passing the ``snapshot`` option to :meth:`~pymongo.mongo_client.MongoClient.start_session`. If ``snapshot`` is True, all read operations that use this session read data from the same snapshot timestamp. The server chooses the latest majority-committed snapshot timestamp when executing the first read operation using the session. Subsequent reads on this session read from the same snapshot timestamp. Snapshot reads are also supported when reading from replica set secondaries. .. code-block:: python # Each read using this session reads data from the same point in time. with client.start_session(snapshot=True) as session: order = orders.find_one({"sku": "abc123"}, session=session) inventory = inventory.find_one({"sku": "abc123"}, session=session) Snapshot Reads Limitations ^^^^^^^^^^^^^^^^^^^^^^^^^^ Snapshot reads sessions are incompatible with ``causal_consistency=True``. Only the following read operations are supported in a snapshot reads session: - :meth:`~pymongo.collection.Collection.find` - :meth:`~pymongo.collection.Collection.find_one` - :meth:`~pymongo.collection.Collection.aggregate` - :meth:`~pymongo.collection.Collection.count_documents` - :meth:`~pymongo.collection.Collection.distinct` (on unsharded collections) Classes ======= ) annotationsN)Mapping) TYPE_CHECKINGAnyCallableContextManagerrMutableMappingNoReturnOptionalTypeTypeVar)Binary)Int64) Timestamp)_csot)ConfigurationErrorConnectionFailureInvalidOperationOperationFailure PyMongoError WTimeoutError)_RETRYABLE_ERROR_CODES)_Op) ReadConcern)ReadPreference _ServerMode) SERVER_TYPE)_ConnectionManager) WriteConcern) TracebackType) Connection)Server) ClusterTime_AddressTc@sLeZdZdZ   ddd d ZedddZedddZedddZdS)SessionOptionsatOptions for a new :class:`ClientSession`. :param causal_consistency: If True, read operations are causally ordered within the session. Defaults to True when the ``snapshot`` option is ``False``. :param default_transaction_options: The default TransactionOptions to use for transactions started on this session. :param snapshot: If True, then all reads performed using this session will read from the same snapshot. This option is incompatible with ``causal_consistency=True``. Defaults to ``False``. .. versionchanged:: 3.12 Added the ``snapshot`` parameter. NFcausal_consistencyOptional[bool]default_transaction_optionsOptional[TransactionOptions]snapshotreturnNonecCsX|r |rtdd}n|durd}||_|dur$t|ts$td|||_||_dS)Nz5snapshot reads do not support causal_consistency=TrueFTzgdefault_transaction_options must be an instance of pymongo.client_session.TransactionOptions, not: {!r})r_causal_consistency isinstanceTransactionOptions TypeErrorformat_default_transaction_options _snapshot)selfr%r'r)r4^/var/www/html/olx_land/venv/lib/python3.10/site-packages/pymongo/synchronous/client_session.py__init__s"  zSessionOptions.__init__boolcC|jS)z)Whether causal consistency is configured.)r,r3r4r4r5r%z!SessionOptions.causal_consistencycCr8)zThe default TransactionOptions to use for transactions started on this session. .. versionadded:: 3.7 )r1r9r4r4r5r'sz*SessionOptions.default_transaction_optionscCr8)zOWhether snapshot reads are configured. .. versionadded:: 3.12 )r2r9r4r4r5r)zSessionOptions.snapshot)NNF)r%r&r'r(r)r&r*r+r*r7)r*r()r*r&) __name__ __module__ __qualname____doc__r6propertyr%r'r)r4r4r4r5r$s   r$c@s\eZdZdZ    ddd dZedddZedddZedddZedddZ dS)r.aOptions for :meth:`ClientSession.start_transaction`. :param read_concern: The :class:`~pymongo.read_concern.ReadConcern` to use for this transaction. If ``None`` (the default) the :attr:`read_preference` of the :class:`MongoClient` is used. :param write_concern: The :class:`~pymongo.write_concern.WriteConcern` to use for this transaction. If ``None`` (the default) the :attr:`read_preference` of the :class:`MongoClient` is used. :param read_preference: The read preference to use. If ``None`` (the default) the :attr:`read_preference` of this :class:`MongoClient` is used. See :mod:`~pymongo.read_preferences` for options. Transactions which read must use :attr:`~pymongo.read_preferences.ReadPreference.PRIMARY`. :param max_commit_time_ms: The maximum amount of time to allow a single commitTransaction command to run. This option is an alias for maxTimeMS option on the commitTransaction command. If ``None`` (the default) maxTimeMS is not used. .. versionchanged:: 3.9 Added the ``max_commit_time_ms`` option. .. versionadded:: 3.7 N read_concernOptional[ReadConcern] write_concernOptional[WriteConcern]read_preferenceOptional[_ServerMode]max_commit_time_ms Optional[int]r*r+cCs||_||_||_||_|durt|tstd||dur6t|ts,td||js6t d||durFt|t sFt|d|durXt|t sZtdt |dSdS)NzKread_concern must be an instance of pymongo.read_concern.ReadConcern, not: zNwrite_concern must be an instance of pymongo.write_concern.WriteConcern, not: z:transactions do not support unacknowledged write concern: zR is not valid for read_preference. See pymongo.read_preferences for valid options.z3max_commit_time_ms must be an integer or None, not ) _read_concern_write_concern_read_preference_max_commit_time_msr-rr/r acknowledgedrrinttype)r3rBrDrFrHr4r4r5r6sH     zTransactionOptions.__init__cCr8)z>This transaction's :class:`~pymongo.read_concern.ReadConcern`.)rJr9r4r4r5rB<r:zTransactionOptions.read_concerncCr8)z@This transaction's :class:`~pymongo.write_concern.WriteConcern`.)rKr9r4r4r5rDAr:z TransactionOptions.write_concerncCr8)zEThis transaction's :class:`~pymongo.read_preferences.ReadPreference`.)rLr9r4r4r5rFFr:z"TransactionOptions.read_preferencecCr8)zfThe maxTimeMS to use when running a commitTransaction command. .. versionadded:: 3.9 )rMr9r4r4r5rHKr;z%TransactionOptions.max_commit_time_msNNNN) rBrCrDrErFrGrHrIr*r+)r*rC)r*rEr*rG)r*rI) r=r>r?r@r6rArBrDrFrHr4r4r4r5r.s )   r.sessionOptional[ClientSession]rDrEr*cCs.|r|dur|js|jrdStd||S)zValidate that an explicit session is not used with an unack'ed write. Returns the session to use for the next operation. NzFExplicit sessions are incompatible with unacknowledged write concern: )rN _implicitr)rSrDr4r4r5_validate_session_write_concernTsrVc@s.eZdZdZdddZdddZdddZdS)_TransactionContextz;Internal transaction context manager for start_transaction.rS ClientSessioncCs ||_dSN)_TransactionContext__session)r3rSr4r4r5r6o z_TransactionContext.__init__r*cC|SrYr4r9r4r4r5 __enter__rz_TransactionContext.__enter__exc_typeOptional[Type[BaseException]]exc_valOptional[BaseException]exc_tbOptional[TracebackType]r+cCs0|jjr|dur|jdS|jdSdSrY)rZin_transactioncommit_transactionabort_transactionr3r_rarcr4r4r5__exit__us z_TransactionContext.__exit__N)rSrX)r*rW)r_r`rarbrcrdr*r+)r=r>r?r@r6r]rir4r4r4r5rWls   rWc@s$eZdZdZdZdZdZdZdZdS) _TxnStateN) r=r>r?NONESTARTING IN_PROGRESS COMMITTEDCOMMITTED_EMPTYABORTEDr4r4r4r5rjsrjc@sdeZdZdZdddZd d d Zd d d Zed!ddZd"ddZ d#ddZ d#ddZ d#ddZ dS)$ _TransactionzBInternal class to hold transaction information in a ClientSession.optsr(client MongoClientcCs6||_tj|_d|_d|_d|_d|_d|_||_ dSNFr) rxrjrqstateshardedpinned_addressconn_mgrrecovery_tokenattemptry)r3rxryr4r4r5r6s z_Transaction.__init__r*r7cCs|jtjtjfvSrY)r|rjrrrsr9r4r4r5activez_Transaction.activecCs |jtjkSrY)r|rjrrr9r4r4r5startings z_Transaction.startingOptional[Connection]cCs|r |jr |jjSdSrY)rrconnr9r4r4r5 pinned_connsz_Transaction.pinned_connserverr!rr r+cCs:d|_|jj|_|jjtjkr|t|d|_ dSdS)NTF) r} descriptionaddressr~ server_typer LoadBalancerpin_txnrrr3rrr4r4r5pins  z_Transaction.pincCs d|_|jr |jd|_dSrY)r~rcloser9r4r4r5unpins  z_Transaction.unpincCs&|tj|_d|_d|_d|_dSr{)rrjrqr|r}rrr9r4r4r5resets  z_Transaction.resetcCs&|jr|jdd|jd|_dSdSNr)rry_close_cursor_soonr9r4r4r5__del__s z_Transaction.__del__N)rxr(ryrzr<r*rrr!rr r*r+r*r+) r=r>r?r@r6rrrArrrrrr4r4r4r5rws      rwexcrr cCs |d)zDRe-raise an exception with the UnknownTransactionCommitResult label.UnknownTransactionCommitResult)_add_error_labelrr4r4r5_reraise_with_unknown_commits rrr7cCst|to |jdkS)z/Return true if exc is a MaxTimeMSExpired error.2)r-rcoderr4r4r5_max_time_expired_errorsr@r frozenset_UNKNOWN_COMMIT_ERROR_CODESx start_timefloatcCst|tkS)z/Are we within the with_transaction retry limit?)time monotonic"_WITH_TRANSACTION_RETRY_TIME_LIMIT)rr4r4r5_within_time_limitsr_T)rzc@seZdZdZdd d ZdddZdddZdddZdddZdddZ dddZ e dddZ e dd d!Z e dd#d$Ze dd&d'Ze dd)d*Ze dd,d-Zdd2d3Z 4 4 4 4ddd?d@Z 4 4 4 4dddBdCZddDdEZddFdGZddJdKZddNdOZddRdSZddTdUZddWdXZddZd[Zdd]d^Ze dd_d`Ze ddadbZe ddcddZ e ddfdgZ!e ddidjZ"ddmdnZ#ddodpZ$ddqdrZ%dddtduZ&ddzd{Z'dd|d}Z(dddZ)dddZ*d4S)rXaA session for ordering sequential operations. :class:`ClientSession` instances are **not thread-safe or fork-safe**. They can only be used by one thread or process at a time. A single :class:`ClientSession` cannot be used to run multiple operations concurrently. Should not be initialized directly by application developers - to create a :class:`ClientSession`, call :meth:`~pymongo.mongo_client.MongoClient.start_session`. ryrzserver_sessionroptionsr$implicitr7r*r+cCs:||_||_||_d|_d|_d|_||_td||_dSrY) _client_server_session_options _cluster_time_operation_time_snapshot_timerUrw _transaction)r3ryrrrr4r4r5r6szClientSession.__init__cCs|jdddS)zFinish this session. If a transaction has started, abort it. It is an error to use the session after the session has ended. TlockN _end_sessionr9r4r4r5 end_sessionszClientSession.end_sessionrc CsV|jdur)z|jr ||W|j|jd|_dS|j|jd|_wdSrY)rrerg_unpinr_return_server_session)r3rr4r4r5r s   zClientSession._end_sessioncCs&|jdur|j|jd|_dSdSrY)rrrr9r4r4r5_end_implicit_sessions  z#ClientSession._end_implicit_sessioncCs|jdur tddS)NzCannot use ended session)rrr9r4r4r5 _check_endeds zClientSession._check_endedcCr\rYr4r9r4r4r5r]"r^zClientSession.__enter__r_rarccCs|jdddS)NTrrrhr4r4r5ri%szClientSession.__exit__cCr8)z^The :class:`~pymongo.mongo_client.MongoClient` this session was created from. )rr9r4r4r5ry(zClientSession.clientcCr8)z:The :class:`SessionOptions` this session was created with.)rr9r4r4r5r/r:zClientSession.optionsMapping[str, Any]cCs |||jjj|jjS)z6A BSON document, the opaque server session identifier.)r _materializertopology_descriptionlogical_session_timeout_minutesr session_idr9r4r4r5r4szClientSession.session_idrcCs||jjj|jjS)z=The current transaction id for the underlying server session.)rrrrrtransaction_idr9r4r4r5_transaction_id;szClientSession._transaction_idOptional[ClusterTime]cCr8)zZThe cluster time returned by the last operation executed in this session. rr9r4r4r5 cluster_timeArzClientSession.cluster_timeOptional[Timestamp]cCr8)z\The operation time returned by the last operation executed in this session. rr9r4r4r5operation_timeHrzClientSession.operation_timenamestrvalrcCs2|r|S|jj}|ot||}|r|St|j|S)z-Return the inherited TransactionOption value.)rr'getattrry)r3rrtxn_opts parent_valr4r4r5_inherit_optionOs zClientSession._inherit_optionNcallbackCallable[[ClientSession], _T]rBrCrDrErFrGrHrIc Cst} |||||z||}Wn(ty;}z|jr"|t|tr6|dr6t |r6WYd}~qd}~ww|jsA|S z| W|Styx}z#|drdt |rdt |sdWYd}~qA|drst |rsWYd}~nd}~wwq)aExecute a callback in a transaction. This method starts a transaction on this session, executes ``callback`` once, and then commits the transaction. For example:: def callback(session): orders = session.client.db.orders inventory = session.client.db.inventory orders.insert_one({"sku": "abc123", "qty": 100}, session=session) inventory.update_one({"sku": "abc123", "qty": {"$gte": 100}}, {"$inc": {"qty": -100}}, session=session) with client.start_session() as session: session.with_transaction(callback) To pass arbitrary arguments to the ``callback``, wrap your callable with a ``lambda`` like this:: def callback(session, custom_arg, custom_kwarg=None): # Transaction operations... with client.start_session() as session: session.with_transaction( lambda s: callback(s, "custom_arg", custom_kwarg=1)) In the event of an exception, ``with_transaction`` may retry the commit or the entire transaction, therefore ``callback`` may be invoked multiple times by a single call to ``with_transaction``. Developers should be mindful of this possibility when writing a ``callback`` that modifies application state or has any other side-effects. Note that even when the ``callback`` is invoked multiple times, ``with_transaction`` ensures that the transaction will be committed at-most-once on the server. The ``callback`` should not attempt to start new transactions, but should simply run operations meant to be contained within a transaction. The ``callback`` should also not commit the transaction; this is handled automatically by ``with_transaction``. If the ``callback`` does commit or abort the transaction without error, however, ``with_transaction`` will return without taking further action. :class:`ClientSession` instances are **not thread-safe or fork-safe**. Consequently, the ``callback`` must not attempt to execute multiple operations concurrently. When ``callback`` raises an exception, ``with_transaction`` automatically aborts the current transaction. When ``callback`` or :meth:`~ClientSession.commit_transaction` raises an exception that includes the ``"TransientTransactionError"`` error label, ``with_transaction`` starts a new transaction and re-executes the ``callback``. 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 ``callback`` 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. :param callback: The callable ``callback`` to run inside a transaction. The callable must accept a single argument, this session. Note, under certain error conditions the callback may be run multiple times. :param read_concern: The :class:`~pymongo.read_concern.ReadConcern` to use for this transaction. :param write_concern: The :class:`~pymongo.write_concern.WriteConcern` to use for this transaction. :param read_preference: 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. :return: The return value of the ``callback``. .. versionadded:: 3.9 TTransientTransactionErrorNr) rrstart_transaction BaseExceptionrergr-rhas_error_labelrrfr) r3rrBrDrFrHrretrr4r4r5with_transactionYsP[       zClientSession.with_transactionrcCs||jjr td|jrtd|d|}|d|}|d|}|dur2|jj}|r2|j}t|||||j _ |j t j |j _|t|S)zStart a multi-statement transaction. Takes the same arguments as :class:`TransactionOptions`. .. versionchanged:: 3.9 Added the ``max_commit_time_ms`` option. .. versionadded:: 3.7 z3Transactions are not supported in snapshot sessionszTransaction already in progressrBrDrFN)rrr)rrerr'rHr.rrxrrjrrr|_start_retryable_writerW)r3rBrDrFrHrxr4r4r5rs&     zClientSession.start_transactionc CsZ||jj}|tjurtd|tjtjfvr tj|j_dS|tjur)td|tj ur3tj |j_zsz| dWnKt yV}z| dt|WYd}~n=d}~wtyk}z t|WYd}~n0d}~wty}z|jtvrxt|WYd}~nd}~wwWtj |j_dSWtj |j_dSWtj |j_dSWtj |j_dStj |j_w)zMCommit a multi-statement transaction. .. versionadded:: 3.7 No transaction startedNz.funcNT) retryable operation)rrTrr rr7r*r)r_retry_internalrABORT)r3rrr4rr5rOsz,ClientSession._finish_transaction_with_retryrr cCs|jjd7_|jj}|sJ|j}|di}|dkrG|jr)tdur)|j|d<|jjdkrG|s3J|j}d|d<|ddt d i|}|jj rQ|jj |d<|j j j ||||d d S) Nrkr maxTimeMSmajoritywwtimeouti' recoveryTokenT)rSrDparse_write_concern_errorr4)rrrxrDrHr get_timeoutdocument setdefaultrrradmin_command)r3rrrxwccmdwc_docr4r4r5r\s&     z!ClientSession._finish_transactionrOptional[Mapping[str, Any]]cCs@|jdur ||_dS|dur|d|jdkr||_dSdSdS)zInternal cluster time helper.N clusterTimerr3rr4r4r5_advance_cluster_timews   z#ClientSession._advance_cluster_timecCsBt|tstdt|t|dtstd||dS)zUpdate the cluster time for this session. :param cluster_time: The :data:`~pymongo.client_session.ClientSession.cluster_time` from another `ClientSession` instance. zt|jtr|j}|jj||_|jr|jdSdSdSrY)r-r_EmptyServerSessionr _topologyget_server_sessionstarted_retryable_writeinc_transaction_id)r3roldr4r4r5rs zClientSession._materializecommandMutableMapping[str, Any] is_retryablercCs|js |js tddS|||j|jjr |||t |j _ |j j |d<|r6|j j|d<dS|jr~|tjkrEtd||jjtjkrrtj|j_d|d<|jjs[J|jjjrl|jjjj}|rl||d<||||j j|d<d|d <dSdS) Nz5Sessions are not supported by this MongoDB deploymentlsid txnNumberz7read preference in a transaction must be primary, not: TstartTransaction readConcernF autocommit)supports_sessionsrUrrrrrr)_update_read_concernrrrlast_userrrerPRIMARYrrr|rjrrrsrxrBr)r3rrrFrrcr4r4r5 _apply_tos<             zClientSession._apply_tocCs||jdSrY)rrrr9r4r4r5rsz$ClientSession._start_retryable_writercCsr|jjr|jdur|j|did<|jjr5|jdkrtd|di}d|d<|jdur7|j|d<dSdSdS)Nr"afterClusterTime z+Snapshot reads require MongoDB 5.0 or laterr)levelr )rr%rrr)max_wire_versionrr)r3rrr(r4r4r5r%s   z"ClientSession._update_read_concernr cCstd)Nz>A ClientSession cannot be copied, create a new session instead)r/r9r4r4r5__copy__#szClientSession.__copy__) ryrzrrrr$rr7r*r+r)rr7r*r+)r*rX)r_rrarrcrr*r+)r*rz)r*r$)r*rr*r)r*r)r*r)rrrrr*rrQ) rrrBrCrDrErFrGrHrIr*r) rBrCrDrErFrGrHrIr*r)rrr*r)rr rrr*r)rrr*r+)rrr*r+)rrr*r+)rrr*r+)rrr*r+r<)r*rrrrRrY)rrIr*r+) rrrr7rFrrr r*r+)rrrr r*r+)r*r )+r=r>r?r@r6rrrrr]rirAryrrrrrrrrrfrgrrrrrrr r rerrrrrrrr)rr%r.r4r4r4r5rXsx                ( +                ,  rXc@s.eZdZdZd ddZd ddZd dd Zd S) rdirtyrr*r+cCsd|_d|_dS)NFr0r9r4r4r5r6*s z_EmptyServerSession.__init__cC d|_dSNTr1r9r4r4r5 mark_dirty.r[z_EmptyServerSession.mark_dirtycCr2r3)rr9r4r4r5r1r[z&_EmptyServerSession.inc_transaction_idNr)r=r>r? __slots__r6r5rr4r4r4r5r's   rc@sBeZdZdddZdddZdd d ZedddZdddZdS)_ServerSession generationrOcCs6dttjdi|_t|_d|_d|_ ||_ dS)NidrnrF) r uuiduuid4bytesrrrr&rr1r8)r3r8r4r4r5r66s   z_ServerSession.__init__r*r+cCs d|_dS)zMark this session as dirty. A server session is marked dirty when a command fails with a network error. Dirty sessions are later discarded from the server session pool. TNr4r9r4r4r5r5>rz_ServerSession.mark_dirtysession_timeout_minutesrIr7cCs*|durdSt|j}||ddkS)NFrk<)rrr&)r3r= idle_secondsr4r4r5 timed_outFsz_ServerSession.timed_outrcCs t|jS)zPositive 64-bit integer.)rrr9r4r4r5rOr z_ServerSession.transaction_idcCs|jd7_dSNrk)rr9r4r4r5rTrz!_ServerSession.inc_transaction_idN)r8rOr)r=rIr*r7r/) r=r>r?r6r5r@rArrr4r4r4r5r75s    r7csTeZdZdZdfdd Zdd d Zdd d ZdddZdddZdddZ Z S)_ServerSessionPoolzDPool of _ServerSession objects. This class is thread-safe. argsrkwargscstj|i|d|_dSr)superr6r8)r3rCrD __class__r4r5r6^s z_ServerSessionPool.__init__r*r+cCs|jd7_|dSrA)r8clearr9r4r4r5rbs z_ServerSessionPool.resetlist[_ServerSession]cCs2g} z ||jWn tyY|SwqrY)appendpopr IndexError)r3idsr4r4r5pop_allfs z_ServerSessionPool.pop_allr=rIr7cCsF|| z|}Wn tyYn w||s|Sqt|jSrY) _clear_stalepopleftrLr@r7r8r3r=sr4r4r5ros     z%_ServerSessionPool.get_server_sessionrcCs(|j|jkr|js||dSdSdSrY)r8r1 appendleft)r3rr4r4r5return_server_sessionsz(_ServerSessionPool.return_server_sessioncCs> z|}Wn tyYdSw||s||dSqrY)rKrLr@rJrQr4r4r5rOs    z_ServerSessionPool._clear_stale)rCrrDrr)r*rI)r=rIr*r7)rr7r*r+)r=rIr*r+) r=r>r?r@r6rrNrrTrO __classcell__r4r4rFr5rBXs   rB)rSrTrDrEr*rT)rrr*r )rrr*r7)rrr*r7)Pr@ __future__r collectionsrr:collections.abcrrtypingrrrrrr r r r bson.binaryr bson.int64rbson.timestamprpymongorpymongo.errorsrrrrrrpymongo.helpers_sharedrpymongo.operationsrpymongo.read_concernrpymongo.read_preferencesrrpymongo.server_typerpymongo.synchronous.cursorrpymongo.write_concernrtypesrpymongo.synchronous.poolr pymongo.synchronous.serverr!pymongo.typingsr"r#_IS_SYNCr$r.rVrWrjrwrrrr__annotations__rrr pymongo.synchronous.mongo_clientrzrXrr7dequerBr4r4r4r5sf y 0             ? \ 5   E#