,h SSKJr SSKrSSKrSSKJr SSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS KJ r SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSK J!r! SSK J"r# SSK J$r% SSK J&r& SS K'J(r( SS!K'J)r) SS"KJ*r* SS#K+J,r, SS$K-J.r. SS%K-J/r/ \(afSS&K0J1r1 SS'K2J3r3 SS(K2J4r4 SS)K2J5r5 SS*K2J6r6 SS+K2J7r7 SS,K2J8r8 SS-K2J9r9 SS.K2J:r: SS/K2J;r; SS0KJ?r? SS2K@JArA SS3K@JBrB SS4KCJDrD SS5KEJFrF SS6KGJHrH \/"S75rI\"S8\S99rJSRS;jrKSSSTS<jjrLSUS=jrM"S>S?5rN\R"\!S@SA///SBQSC9"SDSE\\!\SE\N55rP\R"\&SFSG//SHQ/SIQSC9"SJS:\\&\N55rQ"SKSL\\)\SL5rR\ SVSMj5rS\ SWSNj5rSSXSOjrS\R"\P5SYSPj5rU\R"\Q5SZSQj5rVg)[) annotationsN)Any) AsyncIterator)Callable)Dict) Generator)NoReturn)Optional)overload)Tuple)Type) TYPE_CHECKING)TypeVar)Union)exc)asyncstartablecontext)GeneratorStartableContext)ProxyComparable)StartableContext)_ensure_sync_result) AsyncResult)AsyncScalarResult) inspection)util) Connection) create_engine)create_pool_from_url)Engine)NestedTransaction) Transaction) ArgumentError)greenlet_spawn) Concatenate) ParamSpec) CursorResult)_CoreAnyExecuteParams)_CoreSingleExecuteParams)_DBAPIAnyExecuteParams)_ExecuteOptions)CompiledCacheType)CoreExecuteOptionsParameter)Dialect)IsolationLevel)SchemaTranslateMapType) ScalarResult)URL)Pool)PoolProxiedConnection) _InfoType) Executable)TypedReturnsRows_P_T)bound AsyncEnginec (^^URSS5(a[R"S5eSUS'URSS5mT(a/URSS5(a [ S 5eS UU4S jjnX!S'[ U40UD6m[ T5$) aCreate a new async engine instance. Arguments passed to :func:`_asyncio.create_async_engine` are mostly identical to those passed to the :func:`_sa.create_engine` function. The specified dialect must be an asyncio-compatible dialect such as :ref:`dialect-postgresql-asyncpg`. .. versionadded:: 1.4 :param async_creator: an async callable which returns a driver-level asyncio connection. If given, the function should take no arguments, and return a new asyncio connection from the underlying asyncio database driver; the connection will be wrapped in the appropriate structures to be used with the :class:`.AsyncEngine`. Note that the parameters specified in the URL are not applied here, and the creator function should use its own connection parameters. This parameter is the asyncio equivalent of the :paramref:`_sa.create_engine.creator` parameter of the :func:`_sa.create_engine` function. .. versionadded:: 2.0.16 server_side_cursorsFz}Can't set server_side_cursors for async engine globally; use the connection.stream() method for an async streaming result setT _is_async async_creatorNcreatorz?Can only specify one of 'async_creator' or 'creator', not both.cJ>TRRRTS9$)N)async_creator_fn)dialectdbapiconnect)r? sync_enginesU/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/ext/asyncio/engine.pyr@$create_async_engine..creatoros,&&,,44!.5 returnr)get async_excAsyncMethodRequiredpopr#_create_enginer;)urlkwr@r?rFs @@rGcreate_async_enginerSFs4 vv#U++++ #  B{OFF?D1M 66)T " "     9  ++K { ##rIc UR5VVs0sH,up4URU5(dMU[U5SU_M. nnnSUS'URU5 UR S5n[ U40UD6$s snnf)aCreate a new AsyncEngine instance using a configuration dictionary. This function is analogous to the :func:`_sa.engine_from_config` function in SQLAlchemy Core, except that the requested dialect must be an asyncio-compatible dialect such as :ref:`dialect-postgresql-asyncpg`. The argument signature of the function is identical to that of :func:`_sa.engine_from_config`. .. versionadded:: 1.4.29 NT_coerce_configrQ)items startswithlenupdaterOrS) configurationprefixkwargskeyvalueoptionsrQs rGasync_engine_from_configr`|s (--//JC >>& ! "CKME!/  !%G  NN6 ++e C s .g ..s A=A=c $SUS'[U40UD6$)a>Create a new async engine instance. Arguments passed to :func:`_asyncio.create_async_pool_from_url` are mostly identical to those passed to the :func:`_sa.create_pool_from_url` function. The specified dialect must be an asyncio-compatible dialect such as :ref:`dialect-postgresql-asyncpg`. .. versionadded:: 2.0.10 Tr>)_create_pool_from_url)rQr\s rGcreate_async_pool_from_urlrcsF;  / //rIc,\rSrSrSr\SSj5rSrg)AsyncConnectable)_slots_dispatch __weakref__c[S5e)Nzasynchronous events are not implemented at this time. Apply synchronous listeners to the AsyncEngine.sync_engine or AsyncConnection.sync_connection attributes.)NotImplementedError)clss rG_no_async_engine_events(AsyncConnectable._no_async_engine_eventss! :  rINrKr )__name__ __module__ __qualname____firstlineno__ __slots__ classmethodrl__static_attributes__rnrIrGreres0I  rIrez:class:`_engine.Connection`z!:class:`_asyncio.AsyncConnection`)closed invalidatedrCdefault_isolation_level) classmethodsmethods attributesc f\rSrSr%SrSrS<S=SjjrS\S'S\S '\S>S j5r S?S@S jjr \ SAS j5r SBSjr \RSCSj5r\RSDSj5rSESjrSESjrS<SFSjjrSGSjrSHSjrSHSjrSISjrSISjr\SSSS S SSSSS S. SJSjj5r\SKSj5rSKSjrSLSjrSLSjrSLS jrSLS!jrSMSNS"jjr \SUR(de[U5$)z1Begin a transaction prior to autobegin occurring.rAsyncTransactionrs rGbeginAsyncConnection.beginIs}}}%%rIc<UR(de[USS9$)z;Begin a nested transaction and return a transaction handle.T)nestedrrs rG begin_nestedAsyncConnection.begin_nestedNs}}}T22rIcZ# [URRUS9IShvN $N7f)zInvalidate the underlying DBAPI connection associated with this :class:`_engine.Connection`. See the method :meth:`_engine.Connection.invalidate` for full detail on this method. ) exceptionN)r$r invalidate)rrs rGrAsyncConnection.invalidateSs-$ MM $ $     s "+)+c\# [URR5IShvN $N7fr)r$rget_isolation_levelrs rGr#AsyncConnection.get_isolation_levelbs #DMM$E$EFFFF #,*,c6URR5$)z,Return True if a transaction is in progress.)rin_transactionrs rGrAsyncConnection.in_transactiones}}++--rIc6URR5$)zIReturn True if a transaction is in progress. .. versionadded:: 1.4.0b2 )rin_nested_transactionrs rGr%AsyncConnection.in_nested_transactionjs }}2244rIchURR5nUb[RU5$g)aOReturn an :class:`.AsyncTransaction` representing the current transaction, if any. This makes use of the underlying synchronous connection's :meth:`_engine.Connection.get_transaction` method to get the current :class:`_engine.Transaction`, which is then proxied in a new :class:`.AsyncTransaction` object. .. versionadded:: 1.4.0b2 N)rget_transactionrrrtranss rGrAsyncConnection.get_transactionrs0 --/  #>>uE ErIchURR5nUb[RU5$g)aiReturn an :class:`.AsyncTransaction` representing the current nested (savepoint) transaction, if any. This makes use of the underlying synchronous connection's :meth:`_engine.Connection.get_nested_transaction` method to get the current :class:`_engine.Transaction`, which is then proxied in a new :class:`.AsyncTransaction` object. .. versionadded:: 1.4.0b2 N)rget_nested_transactionrrrs rGr&AsyncConnection.get_nested_transactions0 446  #>>uE ErI.) compiled_cache logging_tokenisolation_level no_parametersstream_resultsmax_row_buffer yield_perinsertmanyvalues_page_sizeschema_translate_mappreserve_rowcountc  # g7frrn) rrrrrrrrrrropts rGexecution_options!AsyncConnection.execution_optionss c # g7frrnrrs rGrrsFIrcr# URn[UR40UD6IShvN nX2LdeU$N 7f)zSet non-SQL options for the connection which take effect during execution. This returns this :class:`_asyncio.AsyncConnection` object with the new options added. See :meth:`_engine.Connection.execution_options` for full details on this method. N)rr$r)rrconnc2s rGrrs=}}!$"8"8@C@ @zz As &75 7c^# [URR5IShvN gN7f)aCommit the transaction that is currently in progress. This method commits the current transaction if one has been started. If no transaction was started, the method has no effect, assuming the connection is in a non-invalidated state. A transaction is begun on a :class:`_engine.Connection` automatically whenever a statement is first executed, or when the :meth:`_engine.Connection.begin` method is called. Nr$rcommitrs rGrAsyncConnection.commitsT]]11222 #-+-c^# [URR5IShvN gN7f)aRoll back the transaction that is currently in progress. This method rolls back the current transaction if one has been started. If no transaction was started, the method has no effect. If a transaction was started and the connection is in an invalidated state, the transaction is cleared using this method. A transaction is begun on a :class:`_engine.Connection` automatically whenever a statement is first executed, or when the :meth:`_engine.Connection.begin` method is called. Nr$rrollbackrs rGrAsyncConnection.rollbacksT]]33444rc^# [URR5IShvN gN7f)z}Close this :class:`_asyncio.AsyncConnection`. This has the effect of also rolling back the transaction if one is in place. Nr$rclosers rGrAsyncConnection.closesT]]00111rc@# UR5IShvN gN7f)zA synonym for :meth:`_asyncio.AsyncConnection.close`. The :meth:`_asyncio.AsyncConnection.aclose` name is specifically to support the Python standard library ``@contextlib.aclosing`` context manager function. .. versionadded:: 2.0.20 Nrrs rGacloseAsyncConnection.aclosesjjls c# [URRUUUSS9IShvN n[X@R5IShvN $N!N7f)zQExecutes a driver-level SQL string and return buffered :class:`_engine.Result`. T)_require_awaitN)r$rexec_driver_sqlrr statement parametersrresults rGrAsyncConnection.exec_driver_sqlsP& MM ) )      )1E1EFFF G!%A A A A A  A rcgrrnrrrrs rGstreamAsyncConnection.streams69rIcgrrnrs rGrrs7:rIc # URR(d[R"S5e[ UR R UU[RRUSS05SS9IShvN nURR(de[U5nU7v [R"UR55n[R "U5IShvN gNuN!["a gf=f7f)aExecute a statement and return an awaitable yielding a :class:`_asyncio.AsyncResult` object. E.g.:: result = await conn.stream(stmt) async for row in result: print(f"{row}") The :meth:`.AsyncConnection.stream` method supports optional context manager use against the :class:`.AsyncResult` object, as in:: async with conn.stream(stmt) as result: async for row in result: print(f"{row}") In the above pattern, the :meth:`.AsyncResult.close` method is invoked unconditionally, even if the iterator is interrupted by an exception throw. Context manager use remains optional, however, and the function may be called in either an ``async with fn():`` or ``await fn()`` style. .. versionadded:: 2.0.0b3 added context manager support :return: an awaitable object that will yield an :class:`_asyncio.AsyncResult` object. .. seealso:: :meth:`.AsyncConnection.stream_scalars` zmCant use `stream` or `stream_scalars` with the current dialect since it does not support server side cursors.rTrrN)rCsupports_server_side_cursorsrrr$rexecuter EMPTY_DICT merge_withcontext_is_server_siderasyncio create_taskrshield GeneratorExit)rrrrrartasks rGrrsT||88))I  & MM ! !  "oo88!$4d#;   ~~----   'H&&rxxz2D..& & &# " '    sHA6D8C.9,D&C2+=D(C0)D0D2 C?<D>C??Dc # g7frrnrs rGrAsyncConnection.executeZ rc # g7frrnrs rGrr c  rc# [URRUUUSS9IShvN n[X@R5IShvN $N!N7f)aExecutes a SQL statement construct and return a buffered :class:`_engine.Result`. :param object: The statement to be executed. This is always an object that is in both the :class:`_expression.ClauseElement` and :class:`_expression.Executable` hierarchies, including: * :class:`_expression.Select` * :class:`_expression.Insert`, :class:`_expression.Update`, :class:`_expression.Delete` * :class:`_expression.TextClause` and :class:`_expression.TextualSelect` * :class:`_schema.DDL` and objects which inherit from :class:`_schema.ExecutableDDLElement` :param parameters: parameters which will be bound into the statement. This may be either a dictionary of parameter names to values, or a mutable sequence (e.g. a list) of dictionaries. When a list of dictionaries is passed, the underlying statement execution will make use of the DBAPI ``cursor.executemany()`` method. When a single dictionary is passed, the DBAPI ``cursor.execute()`` method will be used. :param execution_options: optional dictionary of execution options, which will be associated with the statement execution. This dictionary can provide a subset of the options that are accepted by :meth:`_engine.Connection.execution_options`. :return: a :class:`_engine.Result` object. TrN)r$rrrrs rGrr lsNL& MM ! !  /   )>>> ?rc # g7frrnrs rGscalarAsyncConnection.scalars rc # g7frrnrs rGrrs rc^# URXUS9IShvN nUR5$N7f)aEExecutes a SQL statement construct and returns a scalar object. This method is shorthand for invoking the :meth:`_engine.Result.scalar` method after invoking the :meth:`_engine.Connection.execute` method. Parameters are equivalent. :return: a scalar Python value representing the first column of the first row returned. rN)rrrs rGrrs8"|| 5F$  }} -+-c # g7frrnrs rGscalarsAsyncConnection.scalarsr rc # g7frrnrs rGrrr rc^# URXUS9IShvN nUR5$N7f)a9Executes a SQL statement construct and returns a scalar objects. This method is shorthand for invoking the :meth:`_engine.Result.scalars` method after invoking the :meth:`_engine.Connection.execute` method. Parameters are equivalent. :return: a :class:`_engine.ScalarResult` object. .. versionadded:: 1.4.24 rN)rrrs rGrrs9$|| 5F$  ~~ rcgrrnrs rGstream_scalarsAsyncConnection.stream_scalarss str: """A synchronous function that does not require awaiting :param conn: a Core SQLAlchemy Connection, used synchronously :return: an optional return value is supported """ conn.execute(some_table.insert().values(int_col=arg1, str_col=arg2)) return "success" async def do_something_async(async_engine: AsyncEngine) -> None: """an async function that uses awaiting""" async with async_engine.begin() as async_conn: # run do_something_with_core() with a sync-style # Connection, proxied into an awaitable return_code = await async_conn.run_sync( do_something_with_core, 5, "strval" ) print(return_code) This method maintains the asyncio event loop all the way through to the database connection by running the given callable in a specially instrumented greenlet. The most rudimentary use of :meth:`.AsyncConnection.run_sync` is to invoke methods such as :meth:`_schema.MetaData.create_all`, given an :class:`.AsyncConnection` that needs to be provided to :meth:`_schema.MetaData.create_all` as a :class:`_engine.Connection` object:: # run metadata.create_all(conn) with a sync-style Connection, # proxied into an awaitable with async_engine.begin() as conn: await conn.run_sync(metadata.create_all) .. note:: The provided callable is invoked inline within the asyncio event loop, and will block on traditional IO calls. IO within this callable should only call into SQLAlchemy's asyncio database APIs which will be properly adapted to the greenlet context. .. seealso:: :meth:`.AsyncSession.run_sync` :ref:`session_run_sync` rFN)r$r)rfnargrRs rGrun_syncAsyncConnection.run_sync3s>H$   # 49 =?    rc>UR5R5$r)r __await__rs rGr$AsyncConnection.__await__{szz|%%''rIc# [R"UR55n[R"U5IShvN gN7fr)rrrr)rtype_r^ tracebackrs rG __aexit__AsyncConnection.__aexit__~s-""4::<0nnT"""s>AAAc.URR$)zReturn True if this connection is closed. .. container:: class_bases Proxied for the :class:`_engine.Connection` class on behalf of the :class:`_asyncio.AsyncConnection` class. )rrwrs rGrwAsyncConnection.closeds}}###rIc.URR$)a$Return True if this connection was invalidated. .. container:: class_bases Proxied for the :class:`_engine.Connection` class on behalf of the :class:`_asyncio.AsyncConnection` class. This does not indicate whether or not the connection was invalidated at the pool level, however )rrxrs rGrxAsyncConnection.invalidateds}}(((rIc.URR$)zvProxy for the :attr:`_engine.Connection.dialect` attribute on behalf of the :class:`_asyncio.AsyncConnection` class. rrCrs rGrCAsyncConnection.dialect}}$$$rIc$XRlgrr0rattrs rGrCr1 $ rIc.URR$)aThe initial-connection time isolation level associated with the :class:`_engine.Dialect` in use. .. container:: class_bases Proxied for the :class:`_engine.Connection` class on behalf of the :class:`_asyncio.AsyncConnection` class. This value is independent of the :paramref:`.Connection.execution_options.isolation_level` and :paramref:`.Engine.execution_options.isolation_level` execution options, and is determined by the :class:`_engine.Dialect` when the first connection is created, by performing a SQL query against the database for the current isolation level before any additional commands have been emitted. Calling this accessor does not invoke any new SQL queries. .. seealso:: :meth:`_engine.Connection.get_isolation_level` - view current actual isolation level :paramref:`_sa.create_engine.isolation_level` - set per :class:`_engine.Engine` isolation level :paramref:`.Connection.execution_options.isolation_level` - set per :class:`_engine.Connection` isolation level )rryrs rGry'AsyncConnection.default_isolation_levelsD}}444rI)rrrFr)rr;rr)rrrrrKr~F)rboolrKr~rorKr4)rKr5)rKr)rKr)rzOptional[BaseException]rKNone)rKr/rKr:)rKzOptional[AsyncTransaction])rOptional[CompiledCacheType]rstrrr/rr:rr:rintrr@rr@r Optional[SchemaTranslateMapType]rr:rrrKr~)rrrKr~rKr<)NN)rr?rz Optional[_DBAPIAnyExecuteParams]r%Optional[CoreExecuteOptionsParameter]rKCursorResult[Any])rTypedReturnsRows[_T]rOptional[_CoreAnyExecuteParams]rrCrKz*GeneratorStartableContext[AsyncResult[_T]])rr6rrFrrCrKz+GeneratorStartableContext[AsyncResult[Any]])rr6rrFrrCrKzAsyncIterator[AsyncResult[Any]])rrErrFrrCrKzCursorResult[_T])rr6rrFrrCrKrD)rTypedReturnsRows[Tuple[_T]]r"Optional[_CoreSingleExecuteParams]rrCrKz Optional[_T])rr6rrHrrCrKr)rrGrrFrrCrKzScalarResult[_T])rr6rrFrrCrKzScalarResult[Any])rrGrrHrrCrKz0GeneratorStartableContext[AsyncScalarResult[_T]])rr6rrHrrCrKz1GeneratorStartableContext[AsyncScalarResult[Any]])rr6rrHrrCrKz%AsyncIterator[AsyncScalarResult[Any]])rz)Callable[Concatenate[Connection, _P], _T]r z_P.argsrRz _P.kwargsrKr9)rKz%Generator[Any, None, AsyncConnection]r'rr^rr(rrKr<rJrKr.r5r.rKr<)0rprqrrrs__doc__rtr__annotations__rurrpropertyrrrro_non_memoized_propertyrrrrrrrrrrr rrrrrrrrrrrrr!r$r)rwrxrCsetterryrvrnrIrGr~r~s"$,I15E!E.E*)    25   %* !     J  """#"" ""$#$ & 3 48  0    G. 5&&7: *-#$!*-AD"'4  (   %(?   II" 35 2 8 DH .7 A   :> DH 7 A  :> DH 7 A  ,7; DH .4 A   7; DH   4 A     7; DH   4 A    .:>? DH ?.?7? A ? : ??:>@ DH @@7@ A @ ; @@:>2# DH 2#2#72# A 2# / 2#2#hF 5F F  F F P(# $ $)) %% ^^%%!5!5rIr~z:class:`_engine.Engine`z:class:`_asyncio.AsyncEngine`)clear_compiled_cacheupdate_execution_optionsget_execution_options)rQpoolrCrnamedriverechocz\rSrSr%SrSr\rS\S'S\S'S#Sjr \ RS$Sj5r \ S%S j5r\R S&S j5rS'S jrS(S jr\S S S S S S.S)Sjj5r\S*Sj5rS*SjrS+S,SjjrS-SjrS.SjrS/Sjr\S0Sj5r\R8S1Sj5r\S2Sj5r\R8S3Sj5r\S4Sj5r\R8S5Sj5r\S6Sj5r\S6Sj5r \S6Sj5r!\S6Sj5r"\"R8S7S j5r"S!r#g")8r;ia9An asyncio proxy for a :class:`_engine.Engine`. :class:`_asyncio.AsyncEngine` is acquired using the :func:`_asyncio.create_async_engine` function:: from sqlalchemy.ext.asyncio import create_async_engine engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname") .. versionadded:: 1.4 rFzType[AsyncConnection]_connection_clsr cURR(d/[R"SURR<S35eUR U5Ulg)NzFThe asyncio extension requires an async driver to be used. The loaded z is not async.)rCis_asyncrrrVrrF)rrFs rGrAsyncEngine.__init__sX""++)))1188;>K  // <rIcUR$rrFrs rGrAsyncEngine._proxiedsrIc [U5$r)r;rs rGr(AsyncEngine._regenerate_proxy_for_targets6""rIc6# UR5nUIShvN UR5IShvN U7v SSS5IShvN SSS5IShvN gNCN,N!,IShvN (df  N.=fN%!,IShvN (df  g=f7f)apReturn a context manager which when entered will deliver an :class:`_asyncio.AsyncConnection` with an :class:`_asyncio.AsyncTransaction` established. E.g.:: async with async_engine.begin() as conn: await conn.execute( text("insert into table (x, y, z) values (1, 2, 3)") ) await conn.execute(text("my_special_procedure(5)")) N)rEr)rrs rGrAsyncEngine.beginsL||~4zz|| $|44#|||444sBABA?AA?A# A?A!A? BA=BA?!A?#A: )A,* A: 6A?=B?BB  BBc$URU5$)aReturn an :class:`_asyncio.AsyncConnection` object. The :class:`_asyncio.AsyncConnection` will procure a database connection from the underlying connection pool when it is entered as an async context manager:: async with async_engine.connect() as conn: result = await conn.execute(select(user_table)) The :class:`_asyncio.AsyncConnection` may also be started outside of a context manager by invoking its :meth:`_asyncio.AsyncConnection.start` method. )rYrs rGrEAsyncEngine.connect.s ##D))rIc\# [URR5IShvN $N7f)zgReturn a "raw" DBAPI connection from the connection pool. .. seealso:: :ref:`dbapi_connections` N)r$rFraw_connectionrs rGrgAsyncEngine.raw_connection@s$$D$4$4$C$CDDDDr.)rrrrrc grrn)rrrrrrrs rGrAsyncEngine.execution_optionsJsrIc grrnrs rGrrjVsrr?rr/rr@rrArrrKr;)rrrKr;)T)rr:rKr<rB)rrrKr<)rKr+)rKr2)r5r2rKr<)rKr3)r5r3rKr<rJrKrJ)r5rrKr<)$rprqrrrsrLrtr~rYrMrrrOrrur contextlibasynccontextmanagerrrErgr rrnrQrRrSrNrQrPrTrCrrUrVrWrvrnrIrGr;r;s $I-s$ $ rIc URnUn[U[5n[R U5nUceUR U5nXglUR U5UlXWlU$r) r isinstancer!r~r__new__rrr)rkrrrrrasync_connectionobjs rGr-AsyncTransaction._regenerate_proxy_for_targetCsu!++!F$56*EE   +++kk#)"223CD  rIc\UR(dUR5 UR$r)rrrs rGrAsyncTransaction._proxiedVs#$$  ' ' )$$$rIc.URR$r)ris_validrs rGrAsyncTransaction.is_valid\s}}%%%rIc.URR$r)r is_activers rGrAsyncTransaction.is_active`s}}&&&rIc^# [URR5IShvN gN7f)aClose this :class:`.AsyncTransaction`. If this transaction is the base transaction in a begin/commit nesting, the transaction will rollback(). Otherwise, the method returns. This is used to cancel a Transaction without affecting the scope of an enclosing transaction. Nrrs rGrAsyncTransaction.closedsT]]00111rc^# [URR5IShvN gN7f)z*Roll back this :class:`.AsyncTransaction`.Nrrs rGrAsyncTransaction.rollbackqsT]]33444rc^# [URR5IShvN gN7f)z'Commit this :class:`.AsyncTransaction`.Nrrs rGrAsyncTransaction.commitusT]]11222rc@# UR[UR(a URRR OURRR 5IShvN 5UlU(aURR5 U$N07f)zkStart this :class:`_asyncio.AsyncTransaction` object's context outside of using a Python ``with:`` block. N) rr$rrrrrr __enter__rs rGrAsyncTransaction.startzsw !% 4 4 ;;((55__--33 !    ! ! + + -  sA)B+B,1Bcb# [URRXU5IShvN gN7fr)r$r__exit__)rr'r^r(s rGr)AsyncTransaction.__aexit__s!T]]33U9MMMs %/-/)rrrNr9)rr~rr:)rr"rrrKr)rKr"r=rB)rr:rKrrI)rprqrrrsrLrtrMrrurrrOrrNrrrrrrr)rvrnrIrGrr3s?rs`#  '+!"'% 5C,& .&$-:=;46@,3;-!-(&2t_ T3$n2?/!/+./JM//2 0   !'  W 5J&'W 5 W 5x #  N I"/&)+;I" I"\ YNK "23E"FYNx L L !  5   o&  ' k"     # rI