-hh SSKrSSKJr SSKJr SSKJr SSKJr SSKJ r SSKJr SS KJ r SS KJ r SS K J r SS KJr SS KJr SSKJr SSKJr SrS%Sjr"SS5r\ R2"\SS///SQS9"SS\\\55r\ R2"\SS//SQ/SQS9"SS\\55r"S S!\\5rS"r\ R<"\5S#5r\ R<"\5S$5r g)&N)exc)ProxyComparable)StartableContext)_ensure_sync_result) AsyncResult) inspection)util) create_engine)NestedTransaction) Connection)Engine)greenlet_spawncURSS5(a[R"S5eSUS'[U0UD6n[ U5$)a-Create 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 server_side_cursorsFz}Can't set server_side_cursors for async engine globally; use the connection.stream() method for an async streaming result setTfuture)get async_excAsyncMethodRequired_create_engine AsyncEngine)argkw sync_engines rC:\Users\ROHAN GUPTA\OneDrive\Desktop\mathbuddy-assessment\venv\Lib\site-packages\sqlalchemy/ext/asyncio/engine.pycreate_async_enginersS vv#U++++ #  BxL #,,K { ##c 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_configurl)items startswithlenupdatepopr) configurationprefixkwargskeyvalueoptionsr!s rasync_engine_from_configr-/s(--//JC >>& ! "CKME!/  !%G  NN6 ++e C s .g ..s A=A=c\rSrSrSrSrg)AsyncConnectableF)_slots_dispatch __weakref__N)__name__ __module__ __qualname____firstlineno__ __slots____static_attributes__r3rrr/r/Fs0Irr/z:class:`_future.Connection`z!:class:`_asyncio.AsyncConnection`)closed invalidateddialectdefault_isolation_level) classmethodsmethods attributesc\rSrSr%SrSrS&Sjr\\S'\ \S'\ S5r S'S jr \ S 5rS r\ S 5r\ S 5rSrSrSrS&SjrSrSrSrSrSrSrSrSrSrSrS\ RB4Sjr"S\ RB4Sjr#S\ RB4Sjr$S\ RB4Sjr%S\ RB4S jr&S\ RB4S!jr'S"r(S#r)S$r*S%r+g)(AsyncConnectionJaAn asyncio proxy for a :class:`_engine.Connection`. :class:`_asyncio.AsyncConnection` is acquired using the :meth:`_asyncio.AsyncEngine.connect` method of :class:`_asyncio.AsyncEngine`:: from sqlalchemy.ext.asyncio import create_async_engine engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname") async with engine.connect() as conn: result = await conn.execute(select(table)) .. versionadded:: 1.4 )enginersync_connectionNc^XlURUlURU5UlgN)rDr_assign_proxiedrE)self async_enginerEs r__init__AsyncConnection.__init__ss(" '33#33ODrrErcT[[RUR5U5$rG)rBr_retrieve_proxy_for_targetrDclstargets r_regenerate_proxy_for_target,AsyncConnection._regenerate_proxy_for_targets#  2 26== A6  rc# UR(a[R"S5eUR[ UR R 5IShvN 5UlU$N7f)zjStart this :class:`_asyncio.AsyncConnection` object's context outside of using a Python ``with:`` block. zconnection is already startedN)rErInvalidRequestErrorrHrrconnectrI is_ctxmanagers rstartAsyncConnection.startsX   ))*IJ J#33!$"2"2":":; <   =sAA)A'A)c.[R"S5e)zUNot implemented for async; call :meth:`_asyncio.AsyncConnection.get_raw_connection`. zAsyncConnection.connection accessor is not implemented as the attribute may need to reconnect on an invalidated connection. Use the get_raw_connection() method.)rrUrIs r connectionAsyncConnection.connections %% 3  rc`# UR5n[[US5IShvN $N7f)aReturn the pooled DBAPI-level connection in use by this :class:`_asyncio.AsyncConnection`. This is a SQLAlchemy connection-pool proxied connection which then has the attribute :attr:`_pool._ConnectionFairy.driver_connection` that refers to the actual driver connection. Its :attr:`_pool._ConnectionFairy.dbapi_connection` refers instead to an :class:`_engine.AdaptedConnection` instance that adapts the driver connection to the DBAPI protocol. r]N)_sync_connectionrgetattrrIconns rget_raw_connection"AsyncConnection.get_raw_connections*$$&#GT<@@@@s %.,.cUR$rG)rEr\s r_proxiedAsyncConnection._proxieds###rc.URR$)aReturn the :attr:`_engine.Connection.info` dictionary of the underlying :class:`_engine.Connection`. This dictionary is freely writable for user-defined state to be associated with the database connection. This attribute is only available if the :class:`.AsyncConnection` is currently connected. If the :attr:`.AsyncConnection.closed` attribute is ``True``, then accessing this attribute will raise :class:`.ResourceClosedError`. .. versionadded:: 1.4.0b2 )rEinfor\s rrjAsyncConnection.infos ##(((rc\UR(dUR5 UR$rG)rE_raise_for_not_startedr\s rr` AsyncConnection._sync_connections###  ' ' )###rc8UR5 [U5$)z1Begin a transaction prior to autobegin occurring.r`AsyncTransactionr\s rbeginAsyncConnection.begins %%rc6UR5 [USS9$)z;Begin a nested transaction and return a transaction handle.T)nestedrpr\s r begin_nestedAsyncConnection.begin_nesteds T22rcf# UR5n[URUS9IShvN $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)rIryrcs rrzAsyncConnection.invalidates,$$&#DOOyIIIIs (1/1ch# UR5n[UR5IShvN $N7frGr`rget_isolation_levelrbs rr~#AsyncConnection.get_isolation_level*$$&#D$<$<==== )202ch# UR5n[UR5IShvN $N7frGr}rbs rset_isolation_level#AsyncConnection.set_isolation_levelrrcBUR5nUR5$zIReturn True if a transaction is in progress. .. versionadded:: 1.4.0b2 )r`in_transactionrbs rrAsyncConnection.in_transactions!$$&""$$rcBUR5nUR5$r)r`in_nested_transactionrbs rr%AsyncConnection.in_nested_transactions! $$&))++rctUR5nUR5nUb[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)r`get_transactionrqrNrIrctranss rrAsyncConnection.get_transaction s:$$&$$&  #>>uE ErctUR5nUR5nUb[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)r`get_nested_transactionrqrNrs rr&AsyncConnection.get_nested_transactions:$$&++-  #>>uE Ercz# UR5n[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:`_future.Connection.execution_options` for full details on this method. N)r`rexecution_options)rIoptrcc2s rr!AsyncConnection.execution_options3sB$$&!$"8"8@C@ @zz As *;9 ;cj# UR5n[UR5IShvN 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:`_future.Connection` automatically whenever a statement is first executed, or when the :meth:`_future.Connection.begin` method is called. N)r`rcommitrbs rrAsyncConnection.commitDs'$$&T[[))) )313cj# UR5n[UR5IShvN 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:`_future.Connection` automatically whenever a statement is first executed, or when the :meth:`_future.Connection.begin` method is called. N)r`rrollbackrbs rrAsyncConnection.rollbackSs'$$&T]]+++rcj# UR5n[UR5IShvN gN7f)z}Close this :class:`_asyncio.AsyncConnection`. This has the effect of also rolling back the transaction if one is in place. N)r`rcloserbs rrAsyncConnection.closeds'$$&TZZ(((rc# UR5n[URUUUSS9IShvN n[XPR5IShvN $N!N7f)zQExecutes a driver-level SQL string and return buffered :class:`_engine.Result`. T_require_awaitN)r`rexec_driver_sqlrrI statement parametersrrcresults rrAsyncConnection.exec_driver_sqlnsZ$$&%       )1E1EFFF G!+AAA A AAc # UR5n[URUU[RR USS05SS9IShvN nUR R(dS5e[U5$N17f)zPExecute a statement and return a streaming :class:`_asyncio.AsyncResult` object.stream_resultsTrNzserver side result expected) r`r _execute_20r EMPTY_DICT merge_withcontext_is_server_siderrs rstreamAsyncConnection.streams$$&%      OO & &!$4d#;    ~~-- 77 756"" sA B A?2Bc# UR5n[URUUUSS9IShvN n[XPR5IShvN $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.DDLElement` :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:`_future.Connection.execution_options`. :return: a :class:`_engine.Result` object. TrN)r`rrrexecuters rrAsyncConnection.executesXJ$$&%         )>>> ?rcb# URXU5IShvN 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:`_future.Connection.execute` method. Parameters are equivalent. :return: a scalar Python value representing the first column of the first row returned. N)rscalarrIrrrrs rrAsyncConnection.scalars- ||I;LMM}}N /-/cb# URXU5IShvN 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:`_future.Connection.execute` method. Parameters are equivalent. :return: a :class:`_engine.ScalarResult` object. .. versionadded:: 1.4.24 N)rscalarsrs rrAsyncConnection.scalarss."||I;LMM~~Nrcb# URXU5IShvN nUR5$N7f)aJExecutes a SQL statement and returns a streaming scalar result object. This method is shorthand for invoking the :meth:`_engine.AsyncResult.scalars` method after invoking the :meth:`_future.Connection.stream` method. Parameters are equivalent. :return: an :class:`_asyncio.AsyncScalarResult` object. .. versionadded:: 1.4.24 N)rrrs rstream_scalarsAsyncConnection.stream_scalarss.${{9:KLL~~Mrc\# UR5n[X/UQ70UD6IShvN $N7f)aInvoke the given sync callable passing self as the first argument. 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. E.g.:: 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:: :ref:`session_run_sync` N)r`r)rIfnrrrcs rrun_syncAsyncConnection.run_sync s00$$&#B9s9b9999 #,*,c>UR5R5$rG)rY __await__r\s rrAsyncConnection.__await__&szz|%%''rc# [R"5RUR55n[R"U5IShvN gN7frG)asyncioget_event_loop create_taskrshield)rItype_r+ tracebacktasks r __aexit__AsyncConnection.__aexit__)s6%%'33DJJLAnnT"""sA AAA)rDrErrGF),r4r5r6r7__doc__r8rKr__annotations__r classmethodrRrYpropertyr]rdrgrjr`rrrvrzr~rrrrrrrrrr rrrrrrrrrrr9r3rrrBrBJsG*I E       A"$$))"$ & 3 J>> %,((" *,")// G4// #8// .?f// ,//  .//  *:8(#rrBz:class:`_future.Engine`z:class:`_asyncio.AsyncEngine`)clear_compiled_cacheupdate_execution_optionsget_execution_options)r!poolr<rDnamedriverechoc\rSrSr%SrSr\r\\ S'"SS\ 5r Sr \ \ S'\S 5rS rS rS rS rSrSrg)ri.a8An 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 )rrg _option_clsc*\rSrSrSrSSjrSrSrg)AsyncEngine._trans_ctxiRcXlgrG)rcrbs rrKAsyncEngine._trans_ctx.__init__SsIrc# URRUS9IShvN URR5UlURR 5IShvN UR$NQN7f)N)rX)rcrYrr transaction __aenter__rWs rrYAsyncEngine._trans_ctx.startVsZ))// /> > >#yy0D ""--/ / /99  ? /s"A5A1AA5 A3!A53A5c^^^^# UUUU4Sjn[R"5RU"55n[R"U5IShvN gN7f)Nc># TRRTTT5IShvN TRR5IShvN gN'N7frG)rrrcr)rIrrr+srgo,AsyncEngine._trans_ctx.__aexit__..go^sA&&00yIIIiioo'''J's!!AA !AAAA)rrrr)rIrr+rrrs```` rr AsyncEngine._trans_ctx.__aexit__]s? ( ())+77=D..& & &sA AAA)rcrNr)r4r5r6r7rKrYrr9r3rr _trans_ctxrRs   'rrcURR(d/[R"SURR<S35eUR U5=UlUlg)NzFThe asyncio extension requires an async driver to be used. The loaded z is not async.)r<is_asyncrrUrrHrrg)rIrs rrKAsyncEngine.__init__es_""++)))1188;>K ,0+?+? +LL4=rrc[U5$rG)rrOs rrR(AsyncEngine._regenerate_proxy_for_targetxs 6""rcDUR5nURU5$)aqReturn 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)")) )rVrrbs rrrAsyncEngine.begin|s||~t$$rc$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. )_connection_clsr\s rrVAsyncEngine.connects ##D))rc\# [URR5IShvN $N7f)zgReturn a "raw" DBAPI connection from the connection pool. .. seealso:: :ref:`dbapi_connections` N)rrraw_connectionr\s rrAsyncEngine.raw_connections$$D$4$4$C$CDDDDrc L[URR"S0UD65$)zReturn a new :class:`_asyncio.AsyncEngine` that will provide :class:`_asyncio.AsyncConnection` objects with the given execution options. Proxied from :meth:`_future.Engine.execution_options`. See that method for details. r3)rrr)rIrs rrAsyncEngine.execution_optionss#4++==DDEErc^# [URR5IShvN gN7f)a5Dispose of the connection pool used by this :class:`_asyncio.AsyncEngine`. This will close all connection pool connections that are **currently checked in**. See the documentation for the underlying :meth:`_future.Engine.dispose` method for further notes. .. seealso:: :meth:`_future.Engine.dispose` N)rrdisposer\s rrAsyncEngine.disposes!T--55666s #-+-)rgrN)r4r5r6r7rr8rBrtyperrrrKrrrRrrrVrrrr9r3rrrr.sh ",I%O'%'&M##%$*$E F7rrc\rSrSrSrSrSSjr\S5rSr \ S5r \ S5r \ S 5r S rS rS rSS jrSrSrg)rqiz4An asyncio proxy for a :class:`_engine.Transaction`.r]sync_transactionruc*XlSUlX lgrGr)rIr]rus rrKAsyncTransaction.__init__s$ $ rcURnUn[U[5n[R U5nUceUR U5nXVlUR U5UlXFlU$rG) r] isinstancer rBrN__new__rHrru)rPrQrErruasync_connectionobjs rrR-AsyncTransaction._regenerate_proxy_for_targetss ++!F$56*EE   +++kk#)"223CD  rc\UR(dUR5 UR$rG)rrmr\s r_sync_transaction"AsyncTransaction._sync_transactions#$$  ' ' )$$$rcUR$rG)rr\s rrgAsyncTransaction._proxieds$$$rc6UR5R$rG)ris_validr\s rrAsyncTransaction.is_valids%%'000rc6UR5R$rG)r is_activer\s rrAsyncTransaction.is_actives%%'111rcf# [UR5R5IShvN gN7f)a Close this :class:`.Transaction`. 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. N)rrrr\s rrAsyncTransaction.closes$T335;;<<< '1/1cf# [UR5R5IShvN gN7f)z%Roll back this :class:`.Transaction`.N)rrrr\s rrAsyncTransaction.rollbacks"T335>>???rcf# [UR5R5IShvN gN7f)z"Commit this :class:`.Transaction`.N)rrrr\s rrAsyncTransaction.commits$T335<<===rcP# UR[UR(a$URR 5R O#URR 5R 5IShvN 5UlU(aURR5 U$N07f)zkStart this :class:`_asyncio.AsyncTransaction` object's context outside of using a Python ``with:`` block. N) rHrrur]r`rvrrr __enter__rWs rrYAsyncTransaction.start s} !% 4 4 ;;002??__557== !    ! ! + + -  sA1B&3B$41B&cj# [UR5RXU5IShvN gN7frG)rr__exit__)rIrr+rs rrAsyncTransaction.__aexit__s-  " " $ - -uY   r)r]rurNr)r4r5r6r7rr8rKrrRrrrgrrrrrrYrr9r3rrrqrqs~> " rrqc[U[5(a UR$UR$![an[ R "SU-5UeSnAff=f)NzAsyncEngine expected, got %r)r rBrErAttributeErrorr ArgumentError)rJes r_get_sync_engine_or_connectionr, sZ,00+++'''  *\ 9  s / AAAc,[R"SSS9e)NzInspection on an AsyncConnection is currently not supported. Please use ``run_sync`` to pass a callable where it's possible to call ``inspect`` on the passed connection.xd3scoderNoInspectionAvailablesubjects r_no_insp_for_async_conn_yetr5,s # # 8  rc,[R"SSS9e)NzInspection on an AsyncEngine is currently not supported. Please obtain a connection then use ``conn.run_sync`` to pass a callable where it's possible to call ``inspect`` on the passed connection.r.r/r1r3s r_no_insp_for_async_engine_xyetr76s # #   r)z sqlalchemy.)!rrrbaserrrrrr r rDr r engine.baser rrrutil.concurrencyrrr-r/create_proxy_methodsrBrrqr, _inspectsr5r7r3rrr>s"!"'5, .$./.11!'  T#o'79IT# T#n #  N J7/#3J7 J7ZV (8V r  o&' k"#r