,h pSSKJr SSKrSSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SS KJ r SS KJ r SS KJ r SS KJ r SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r! SSKJ"r" SSKJ#r# SS KJ$r$ SS!KJ%r& SS"K'J(r( SS#K)J*r* SS$K)J+r+ \(aSS%KJ,r, SS&KJ-r- SS'KJ.r. SS(KJ/r/ SS)KJ0r0 SS*KJ1r1 SS+KJ2r2 SS,KJ3r3 SS-KJ4r4 SS.K5J6r6 SS/K5J7r7 SS0K8J9r9 SS1K:J;r; SS2K:JJ?r? SS5K@JArA SS6KBJCrC SS7KBJDrD SS8KBJErE SS9KBJFrF SS:KBJGrG SS;KHJIrI SSKNJOrO SS?KPJQrQ SS@KPJRrR \SArS\+"SB5rT\"SC\SD9rU\R"SESF05rW\R"SGSF05rX"SHSI5rY\R"\#SJSKSLSM//SNQ/SOQSP9"SQSR\\#55r[\"SSSRSD9r\"STSU\ \\5r]"SVSW\ \\5r^"SXSY\\$\SY5r_S]SZjr`S^S[jraS_S\jr \a\&lbg)`) annotationsN)Any) Awaitable)Callable)cast)Dict)Generic)Iterable)Iterator)NoReturn)Optional)overload)Sequence)Tuple)Type) TYPE_CHECKING)TypeVar)Union)engine)ReversibleProxy)StartableContext)_ensure_sync_result) AsyncResult)AsyncScalarResult)utilclose_all_sessions)object_session)Session)SessionTransaction)state)greenlet_spawn) Concatenate) ParamSpec)AsyncConnection) AsyncEngine) Connection) CursorResult)Engine)Result)Row) RowMapping) ScalarResult)_CoreAnyExecuteParams)CoreExecuteOptionsParameter) dispatcher)_IdentityKeyType)_O)OrmExecuteOptionsParameter) IdentityMap) ORMOption)_BindArguments)_EntityBindKey)_PKIdentityArgument) _SessionBind)_SessionBindKey) _InfoType) Executable) UpdateBase) ClauseElement)ForUpdateParameter)TypedReturnsRows)r(r'_P_T)boundprebuffer_rowsTstream_resultsc@\rSrSrSr"SS5r\SSj5rSrg) AsyncAttrsUaMixin class which provides an awaitable accessor for all attributes. E.g.:: from __future__ import annotations from typing import List from sqlalchemy import ForeignKey from sqlalchemy import func from sqlalchemy.ext.asyncio import AsyncAttrs from sqlalchemy.orm import DeclarativeBase from sqlalchemy.orm import Mapped from sqlalchemy.orm import mapped_column from sqlalchemy.orm import relationship class Base(AsyncAttrs, DeclarativeBase): pass class A(Base): __tablename__ = "a" id: Mapped[int] = mapped_column(primary_key=True) data: Mapped[str] bs: Mapped[List[B]] = relationship() class B(Base): __tablename__ = "b" id: Mapped[int] = mapped_column(primary_key=True) a_id: Mapped[int] = mapped_column(ForeignKey("a.id")) data: Mapped[str] In the above example, the :class:`_asyncio.AsyncAttrs` mixin is applied to the declarative ``Base`` class where it takes effect for all subclasses. This mixin adds a single new attribute :attr:`_asyncio.AsyncAttrs.awaitable_attrs` to all classes, which will yield the value of any attribute as an awaitable. This allows attributes which may be subject to lazy loading or deferred / unexpiry loading to be accessed such that IO can still be emitted:: a1 = (await async_session.scalars(select(A).where(A.id == 5))).one() # use the lazy loader on ``a1.bs`` via the ``.awaitable_attrs`` # interface, so that it may be awaited for b1 in await a1.awaitable_attrs.bs: print(b1) The :attr:`_asyncio.AsyncAttrs.awaitable_attrs` performs a call against the attribute that is approximately equivalent to using the :meth:`_asyncio.AsyncSession.run_sync` method, e.g.:: for b1 in await async_session.run_sync(lambda sess: a1.bs): print(b1) .. versionadded:: 2.0.13 .. seealso:: :ref:`asyncio_orm_avoid_lazyloads` c,\rSrSrSrSSjrSSjrSrg) AsyncAttrs._AsyncAttrGetitem _instancecXlgNrN)selfrNs V/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/ext/asyncio/session.py__init__%AsyncAttrs._AsyncAttrGetitem.__init__s&Nc8[[URU5$rP)r$getattrrN)rRnames rS __getattr__(AsyncAttrs._AsyncAttrGetitem.__getattr__s!'4>>4@ @rVrQN)rNr)rYstrreturnzAwaitable[Any])__name__ __module__ __qualname____firstlineno__ __slots__rTrZ__static_attributes__rVrS_AsyncAttrGetitemrLs  ' ArVrec,[RU5$)a&provide a namespace of all attributes on this object wrapped as awaitables. e.g.:: a1 = (await async_session.scalars(select(A).where(A.id == 5))).one() some_attribute = await a1.awaitable_attrs.some_deferred_attribute some_collection = await a1.awaitable_attrs.some_collection )rIrerRs rSawaitable_attrsAsyncAttrs.awaitable_attrss++D11rVrdN)r]rL) r^r_r`ra__doc__repropertyrhrcrdrVrSrIrIUs(?BAA22rVrIz:class:`_orm.Session`z:class:`_asyncio.AsyncSession`r identity_key) __contains____iter__addadd_allexpire expire_allexpunge expunge_all is_modifiedin_transactionin_nested_transaction)dirtydeletednew identity_map is_active autoflush no_autoflushinfo) classmethodsmethods attributesc. \rSrSr%SrSrS\S'SUSSS.SVS jjjr\r S \S'S \S '\ SWS j5r SXSYSjjr SZSjr \SU\R SSSS.S[Sjjj5r\SU\R SSSS.S\Sjjj5r\SU\R SSSS.S]Sjjj5rSU\R SS.S^Sjjjr\SU\R SS.S_Sjjj5r\SU\R SS.S`Sjjj5rSU\R SS.S`Sjjjr\SU\R SS.SaSjjj5r\SU\R SS.SbSjjj5rSU\R SS.SbSjjjrSSSS\R S.ScSjjrSSSS\R S.SdSjjr\SU\R SS.SeS jjj5r\SU\R SS.SfS!jjj5rSU\R SS.SfS"jjjr\SU\R SS.SgS#jjj5r\SU\R SS.ShS$jjj5rSU\R SS.ShS%jjjrSiS&jrSSS'.SjS(jjrSUSkS)jjrSlS*jrSlS+jrSmSnS,jjrSXSoS-jjrSpS.jrSpS/jr SqS0jr!SqS1jr"SqS2jr#SqS3jr$SqS4jr%SqS5jr&\ \RN"S6S75SqS8j55r(SrS9jr)SsS:jr*StS;jr+SuS<jr,SvS=jr-SwSxS>jjr.SyS?jr/SUSzS@jjr0SqSAjr1SiSBjr2SqSCjr3SwS{SDjjr4S|SEjr5S|SFjr6\7S}SGj5r8\7S}SHj5r9\7S}SIj5r:\7S~SJj5r;\;RxSSKj5r;\7S}SLj5r=\7S|SMj5r>\>RxSSNj5r>\7S}SOj5r?\7S}SPj5r@\ SSQj5rA\ SXSSSSR.SSSjjj5rBSTrCg) AsyncSessionaAsyncio version of :class:`_orm.Session`. The :class:`_asyncio.AsyncSession` is a proxy for a traditional :class:`_orm.Session` instance. The :class:`_asyncio.AsyncSession` is **not safe for use in concurrent tasks.**. See :ref:`session_faq_threadsafe` for background. .. versionadded:: 1.4 To use an :class:`_asyncio.AsyncSession` with custom :class:`_orm.Session` implementations, see the :paramref:`_asyncio.AsyncSession.sync_session_class` parameter. Tzdispatcher[Session]dispatchN)bindssync_session_classrc `S=pVU(aXl[R"U5nU(a?X lUR 5VVs0sHupxU[R"U5_M nnnU(aX0lUR UR "SXVS.UD65=UlUlgs snnf)a}Construct a new :class:`_asyncio.AsyncSession`. All parameters other than ``sync_session_class`` are passed to the ``sync_session_class`` callable directly to instantiate a new :class:`_orm.Session`. Refer to :meth:`_orm.Session.__init__` for parameter documentation. :param sync_session_class: A :class:`_orm.Session` subclass or other callable which will be used to construct the :class:`_orm.Session` which will be proxied. This parameter may be used to provide custom :class:`_orm.Session` subclasses. Defaults to the :attr:`_asyncio.AsyncSession.sync_session_class` class-level attribute. .. versionadded:: 1.4.24 N)bindrrd) rr_get_sync_engine_or_connectionritemsr_assign_proxied sync_session_proxied) rRrrrkw sync_bind sync_bindskeybs rSrTAsyncSession.__init__s4"&% I==dCI J$kkm+FCV::1==+  &8 #,0,@,@  # # K K K-  DMs#B*z Type[Session]r!rc[S5e)Nztasynchronous events are not implemented at this time. Apply synchronous listeners to the AsyncSession.sync_session.)NotImplementedErrorclss rS_no_async_engine_events$AsyncSession._no_async_engine_events0s! F  rVc`# [URRUUUS9IShvN gN7f)a}Expire and refresh the attributes on the given instance. A query will be issued to the database and all attributes will be refreshed with their current database value. This is the async version of the :meth:`_orm.Session.refresh` method. See that method for a complete description of all options. .. seealso:: :meth:`_orm.Session.refresh` - main documentation for refresh )attribute_nameswith_for_updateN)r$rrefresh)rRinstancerrs rSrAsyncSession.refresh7s1(    % % ++    $.,.cT# [XR/UQ7SS0UD6IShvN $N7f)aInvoke the given synchronous (i.e. not async) callable, passing a synchronous-style :class:`_orm.Session` as the first argument. This method allows traditional synchronous SQLAlchemy functions to run within the context of an asyncio application. E.g.:: def some_business_method(session: Session, param: str) -> str: """A synchronous function that does not require awaiting :param session: a SQLAlchemy Session, used synchronously :return: an optional return value is supported """ session.add(MyObject(param=param)) session.flush() return "success" async def do_something_async(async_engine: AsyncEngine) -> None: """an async function that uses awaiting""" with AsyncSession(async_engine) as async_session: # run some_business_method() with a sync-style # Session, proxied into an awaitable return_code = await async_session.run_sync( some_business_method, param="param1" ) 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. .. tip:: 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:: :class:`.AsyncAttrs` - a mixin for ORM mapped classes that provides a similar feature more succinctly on a per-attribute basis :meth:`.AsyncConnection.run_sync` :ref:`session_run_sync` _require_awaitFN)r$r)rRfnargrs rSrun_syncAsyncSession.run_syncRs@x$ !! $' 8= AC    s (&()execution_optionsbind_arguments_parent_execute_state _add_eventc # g7frPrdrR statementparamsrrrrs rSexecuteAsyncSession.executes c # g7frPrdrs rSrrs  rc # g7frPrdrs rSrrs r)rrc# U(a*[R"U5R[5nO[n[ UR R U4UUUS.UD6IShvN n[X`R 5IShvN $N!N7f)zExecute a statement and return a buffered :class:`_engine.Result` object. .. seealso:: :meth:`_orm.Session.execute` - main documentation for execute rrrN)r immutabledictunion_EXECUTE_OPTIONSr$rrrrRrrrrrresults rSrrs$  $ 2 23D E K K ! !1 %    % %  /)     )>>> ?s$A B"B#B?BBBc # g7frPrdrRrrrrrs rSscalarAsyncSession.scalars rc # g7frPrdrs rSrrs rc# U(a*[R"U5R[5nO[n[ UR R U4UUUS.UD6IShvN $N7f)zExecute a statement and return a scalar result. .. seealso:: :meth:`_orm.Session.scalar` - main documentation for scalar rN)rrrrr$rrrs rSrrsu"  $ 2 23D E K K ! !1 #    $ $  /)       sA A)"A'#A)c # g7frPrdrs rSscalarsAsyncSession.scalars rc # g7frPrdrs rSrrs  rcl# UR"U4UUUS.UD6IShvN nUR5$N7f)aExecute a statement and return scalar results. :return: a :class:`_result.ScalarResult` object .. versionadded:: 1.4.24 Added :meth:`_asyncio.AsyncSession.scalars` .. versionadded:: 1.4.26 Added :meth:`_asyncio.async_scoped_session.scalars` .. seealso:: :meth:`_orm.Session.scalars` - main documentation for scalars :meth:`_asyncio.AsyncSession.stream_scalars` - streaming version rN)rrrs rSrr&sI4||  /)     ~~ 424Foptionspopulate_existingridentity_tokenrc z# [[SURR5UUUUUUUS9IShvN $N7f)zReturn an instance based on the given primary key identifier, or ``None`` if not found. .. seealso:: :meth:`_orm.Session.get` - main documentation for get Callable[..., _O]rN)r$rrgetrRentityidentrrrrrs rSrAsyncSession.getIsJ*$ $d&7&7&;&; <  /+)/    2;9;c z# [[SURR5UUUUUUUS9IShvN $N7f)aReturn an instance based on the given primary key identifier, or raise an exception if not found. Raises :class:`_exc.NoResultFound` if the query selects no rows. ..versionadded: 2.0.22 .. seealso:: :meth:`_orm.Session.get_one` - main documentation for get_one rrN)r$rrget_oners rSrAsyncSession.get_oneisJ0$ $d&7&7&?&? @  /+)/    rc # g7frPrdrs rSstreamAsyncSession.streams rc # g7frPrdrs rSrrrrc# U(a*[R"U5R[5nO[n[ UR R U4UUUS.UD6IShvN n[U5$N7f)zRExecute a statement and return a streaming :class:`_asyncio.AsyncResult` object. rN)rrr_STREAM_OPTIONSr$rrrrs rSrrs  $ 2 23D E K K! !0 %    % %  /)     6"" sA A4"A2#A4c # g7frPrdrs rSstream_scalarsAsyncSession.stream_scalarss !$rc # g7frPrdrs rSrrs "%rcl# UR"U4UUUS.UD6IShvN nUR5$N7f)a"Execute a statement and return a stream of scalar results. :return: an :class:`_asyncio.AsyncScalarResult` object .. versionadded:: 1.4.24 .. seealso:: :meth:`_orm.Session.scalars` - main documentation for scalars :meth:`_asyncio.AsyncSession.scalars` - non streaming version rN)rrrs rSrrsI.{{  /)     ~~ rc`# [URRU5IShvN gN7f)a$Mark an instance as deleted. The database delete operation occurs upon ``flush()``. As this operation may need to cascade along unloaded relationships, it is awaitable to allow for those queries to take place. .. seealso:: :meth:`_orm.Session.delete` - main documentation for delete N)r$rdeleterRrs rSrAsyncSession.deletes#T..55x@@@rloadrc\# [URRXUS9IShvN $N7f)zCopy the state of a given instance into a corresponding instance within this :class:`_asyncio.AsyncSession`. .. seealso:: :meth:`_orm.Session.merge` - main documentation for merge rN)r$rmerge)rRrrrs rSrAsyncSession.merges1$    # #X'    s #,*,c\# [URRUS9IShvN gN7f)z|Flush all the object changes to the database. .. seealso:: :meth:`_orm.Session.flush` - main documentation for flush )objectsN)r$rflush)rRrs rSrAsyncSession.flushs#T..44gFFFs ",*,cdURR5nUb[RXS9$g)zReturn the current root transaction in progress, if any. :return: an :class:`_asyncio.AsyncSessionTransaction` object, or ``None``. .. versionadded:: 1.4.18 N async_session)rget_transactionAsyncSessionTransaction_retrieve_proxy_for_targetrRtranss rSrAsyncSession.get_transaction#s?!!113  *EEF rVcdURR5nUb[RXS9$g)zReturn the current nested transaction in progress, if any. :return: an :class:`_asyncio.AsyncSessionTransaction` object, or ``None``. .. versionadded:: 1.4.18 Nr)rget_nested_transactionrrrs rSr#AsyncSession.get_nested_transaction4s?!!88:  *EEF rVc @URR"SXUS.UD6$)a Return a "bind" to which the synchronous proxied :class:`_orm.Session` is bound. Unlike the :meth:`_orm.Session.get_bind` method, this method is currently **not** used by this :class:`.AsyncSession` in any way in order to resolve engines for requests. .. note:: This method proxies directly to the :meth:`_orm.Session.get_bind` method, however is currently **not** useful as an override target, in contrast to that of the :meth:`_orm.Session.get_bind` method. The example below illustrates how to implement custom :meth:`_orm.Session.get_bind` schemes that work with :class:`.AsyncSession` and :class:`.AsyncEngine`. The pattern introduced at :ref:`session_custom_partitioning` illustrates how to apply a custom bind-lookup scheme to a :class:`_orm.Session` given a set of :class:`_engine.Engine` objects. To apply a corresponding :meth:`_orm.Session.get_bind` implementation for use with a :class:`.AsyncSession` and :class:`.AsyncEngine` objects, continue to subclass :class:`_orm.Session` and apply it to :class:`.AsyncSession` using :paramref:`.AsyncSession.sync_session_class`. The inner method must continue to return :class:`_engine.Engine` instances, which can be acquired from a :class:`_asyncio.AsyncEngine` using the :attr:`_asyncio.AsyncEngine.sync_engine` attribute:: # using example from "Custom Vertical Partitioning" import random from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.ext.asyncio import create_async_engine from sqlalchemy.ext.asyncio import async_sessionmaker from sqlalchemy.orm import Session # construct async engines w/ async drivers engines = { "leader": create_async_engine("sqlite+aiosqlite:///leader.db"), "other": create_async_engine("sqlite+aiosqlite:///other.db"), "follower1": create_async_engine("sqlite+aiosqlite:///follower1.db"), "follower2": create_async_engine("sqlite+aiosqlite:///follower2.db"), } class RoutingSession(Session): def get_bind(self, mapper=None, clause=None, **kw): # within get_bind(), return sync engines if mapper and issubclass(mapper.class_, MyOtherClass): return engines["other"].sync_engine elif self._flushing or isinstance(clause, (Update, Delete)): return engines["leader"].sync_engine else: return engines[ random.choice(["follower1", "follower2"]) ].sync_engine # apply to AsyncSession using sync_session_class AsyncSessionMaker = async_sessionmaker(sync_session_class=RoutingSession) The :meth:`_orm.Session.get_bind` method is called in a non-asyncio, implicitly non-blocking context in the same manner as ORM event hooks and functions that are invoked via :meth:`.AsyncSession.run_sync`, so routines that wish to run SQL commands inside of :meth:`_orm.Session.get_bind` can continue to do so using blocking-style code, which will be translated to implicitly async calls at the point of invoking IO on the database drivers. )mapperclauserrd)rget_bind)rRrrrrs rSrAsyncSession.get_bindFs0`  )) t 79  rVc# [URR4UUS.UD6IShvN n[RR U5$N#7f)aReturn a :class:`_asyncio.AsyncConnection` object corresponding to this :class:`.Session` object's transactional state. This method may also be used to establish execution options for the database connection used by the current transaction. .. versionadded:: 1.4.24 Added \**kw arguments which are passed through to the underlying :meth:`_orm.Session.connection` method. .. seealso:: :meth:`_orm.Session.connection` - main documentation for "connection" )rrN)r$r connectionrr'r)rRrrrsync_connections rSrAsyncSession.connections],!/    ( (! )/!  !   %%@@    s'AA $Ac[U5$)aReturn an :class:`_asyncio.AsyncSessionTransaction` object. The underlying :class:`_orm.Session` will perform the "begin" action when the :class:`_asyncio.AsyncSessionTransaction` object is entered:: async with async_session.begin(): ... # ORM transaction is begun Note that database IO will not normally occur when the session-level transaction is begun, as database transactions begin on an on-demand basis. However, the begin block is async to accommodate for a :meth:`_orm.SessionEvents.after_transaction_create` event hook that may perform IO. For a general description of ORM begin, see :meth:`_orm.Session.begin`. rrgs rSbeginAsyncSession.begins*'t,,rVc[USS9$)aReturn an :class:`_asyncio.AsyncSessionTransaction` object which will begin a "nested" transaction, e.g. SAVEPOINT. Behavior is the same as that of :meth:`_asyncio.AsyncSession.begin`. For a general description of ORM begin nested, see :meth:`_orm.Session.begin_nested`. .. seealso:: :ref:`aiosqlite_serializable` - special workarounds required with the SQLite asyncio driver in order for SAVEPOINT to work correctly. T)nestedrrgs rS begin_nestedAsyncSession.begin_nesteds"'tD99rVc^# [URR5IShvN gN7f)zRollback the current transaction in progress. .. seealso:: :meth:`_orm.Session.rollback` - main documentation for "rollback" N)r$rrollbackrgs rSrAsyncSession.rollbacks!T..77888 #-+-c^# [URR5IShvN gN7f)zCommit the current transaction in progress. .. seealso:: :meth:`_orm.Session.commit` - main documentation for "commit" N)r$rcommitrgs rSrAsyncSession.commits!T..55666rc^# [URR5IShvN gN7f)aEClose out the transactional resources and ORM objects used by this :class:`_asyncio.AsyncSession`. .. seealso:: :meth:`_orm.Session.close` - main documentation for "close" :ref:`session_closing` - detail on the semantics of :meth:`_asyncio.AsyncSession.close` and :meth:`_asyncio.AsyncSession.reset`. N)r$rclosergs rSrAsyncSession.closes!T..44555rc^# [URR5IShvN gN7f)aClose out the transactional resources and ORM objects used by this :class:`_orm.Session`, resetting the session to its initial state. .. versionadded:: 2.0.22 .. seealso:: :meth:`_orm.Session.reset` - main documentation for "reset" :ref:`session_closing` - detail on the semantics of :meth:`_asyncio.AsyncSession.close` and :meth:`_asyncio.AsyncSession.reset`. N)r$rresetrgs rSrAsyncSession.resets! T..44555rc@# UR5IShvN gN7f)zA synonym for :meth:`_asyncio.AsyncSession.close`. The :meth:`_asyncio.AsyncSession.aclose` name is specifically to support the Python standard library ``@contextlib.aclosing`` context manager function. .. versionadded:: 2.0.20 N)rrgs rSacloseAsyncSession.aclosesjjls c^# [URR5IShvN gN7f)zuClose this Session, using connection invalidation. For a complete description, see :meth:`_orm.Session.invalidate`. N)r$r invalidatergs rSrAsyncSession.invalidate&s! T..99:::rz2.0zThe :meth:`.AsyncSession.close_all` method is deprecated and will be removed in a future release. Please refer to :func:`_asyncio.close_all_sessions`.c4# [5IShvN gN7f)z2Close all :class:`_asyncio.AsyncSession` sessions.Nrrs rS close_allAsyncSession.close_all-s!"""s c# U$7frPrdrgs rS __aenter__AsyncSession.__aenter__8s  sc# [R"UR55n[R"U5IShvN gN7frP)asyncio create_taskrshield)rRtype_value tracebacktasks rS __aexit__AsyncSession.__aexit__;s-""4::<0nnT"""s>AAAc[U5$rP)_AsyncSessionContextManagerrgs rS_maker_context_manager#AsyncSession._maker_context_manager?s *400rVc8URRU5$)aReturn True if the instance is associated with this session. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. The instance may be pending or persistent within the Session for a result of True. )rrmrs rSrmAsyncSession.__contains__Gs}}))(33rVc6URR5$)zIterate over all pending or persistent instances within this Session. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. )rrnrgs rSrnAsyncSession.__iter__Ws}}%%''rVc4URRXS9$)aPlace an object into this :class:`_orm.Session`. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. Objects that are in the :term:`transient` state when passed to the :meth:`_orm.Session.add` method will move to the :term:`pending` state, until the next flush, at which point they will move to the :term:`persistent` state. Objects that are in the :term:`detached` state when passed to the :meth:`_orm.Session.add` method will move to the :term:`persistent` state directly. If the transaction used by the :class:`_orm.Session` is rolled back, objects which were transient when they were passed to :meth:`_orm.Session.add` will be moved back to the :term:`transient` state, and will no longer be present within this :class:`_orm.Session`. .. seealso:: :meth:`_orm.Session.add_all` :ref:`session_adding` - at :ref:`session_basics` )_warn)rro)rRrr:s rSroAsyncSession.addes@}}   77rVc8URRU5$)aAdd the given collection of instances to this :class:`_orm.Session`. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. See the documentation for :meth:`_orm.Session.add` for a general behavioral description. .. seealso:: :meth:`_orm.Session.add` :ref:`session_adding` - at :ref:`session_basics` )rrp)rR instancess rSrpAsyncSession.add_alls(}}$$Y//rVc4URRXS9$)aExpire the attributes on an instance. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. Marks the attributes of an instance as out of date. When an expired attribute is next accessed, a query will be issued to the :class:`.Session` object's current transactional context in order to load all expired attributes for the given instance. Note that a highly isolated transaction will return the same values as were previously read in that same transaction, regardless of changes in database state outside of that transaction. To expire all objects in the :class:`.Session` simultaneously, use :meth:`Session.expire_all`. The :class:`.Session` object's default behavior is to expire all state whenever the :meth:`Session.rollback` or :meth:`Session.commit` methods are called, so that new state can be loaded for the new transaction. For this reason, calling :meth:`Session.expire` only makes sense for the specific case that a non-ORM SQL statement was emitted in the current transaction. :param instance: The instance to be refreshed. :param attribute_names: optional list of string attribute names indicating a subset of attributes to be expired. .. seealso:: :ref:`session_expire` - introductory material :meth:`.Session.expire` :meth:`.Session.refresh` :meth:`_orm.Query.populate_existing` )r)rrq)rRrrs rSrqAsyncSession.expires\}}##H#NNrVc6URR5$)aExpires all persistent instances within this Session. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. When any attributes on a persistent instance is next accessed, a query will be issued using the :class:`.Session` object's current transactional context in order to load all expired attributes for the given instance. Note that a highly isolated transaction will return the same values as were previously read in that same transaction, regardless of changes in database state outside of that transaction. To expire individual objects and individual attributes on those objects, use :meth:`Session.expire`. The :class:`.Session` object's default behavior is to expire all state whenever the :meth:`Session.rollback` or :meth:`Session.commit` methods are called, so that new state can be loaded for the new transaction. For this reason, calling :meth:`Session.expire_all` is not usually needed, assuming the transaction is isolated. .. seealso:: :ref:`session_expire` - introductory material :meth:`.Session.expire` :meth:`.Session.refresh` :meth:`_orm.Query.populate_existing` )rrrrgs rSrrAsyncSession.expire_allsN}}''))rVc8URRU5$)a4Remove the `instance` from this ``Session``. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. This will free all internal references to the instance. Cascading will be applied according to the *expunge* cascade rule. )rrsrs rSrsAsyncSession.expunges}}$$X..rVc6URR5$)aRemove all object instances from this ``Session``. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. This is equivalent to calling ``expunge(obj)`` on all objects in this ``Session``. )rrtrgs rSrtAsyncSession.expunge_alls}}((**rVc4URRXS9$)a Return ``True`` if the given instance has locally modified attributes. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. This method retrieves the history for each instrumented attribute on the instance and performs a comparison of the current value to its previously flushed or committed value, if any. It is in effect a more expensive and accurate version of checking for the given instance in the :attr:`.Session.dirty` collection; a full test for each attribute's net "dirty" status is performed. E.g.:: return session.is_modified(someobject) A few caveats to this method apply: * Instances present in the :attr:`.Session.dirty` collection may report ``False`` when tested with this method. This is because the object may have received change events via attribute mutation, thus placing it in :attr:`.Session.dirty`, but ultimately the state is the same as that loaded from the database, resulting in no net change here. * Scalar attributes may not have recorded the previously set value when a new value was applied, if the attribute was not loaded, or was expired, at the time the new value was received - in these cases, the attribute is assumed to have a change, even if there is ultimately no net change against its database value. SQLAlchemy in most cases does not need the "old" value when a set event occurs, so it skips the expense of a SQL call if the old value isn't present, based on the assumption that an UPDATE of the scalar value is usually needed, and in those few cases where it isn't, is less expensive on average than issuing a defensive SELECT. The "old" value is fetched unconditionally upon set only if the attribute container has the ``active_history`` flag set to ``True``. This flag is set typically for primary key attributes and scalar object references that are not a simple many-to-one. To set this flag for any arbitrary mapped column, use the ``active_history`` argument with :func:`.column_property`. :param instance: mapped instance to be tested for pending changes. :param include_collections: Indicates if multivalued collections should be included in the operation. Setting this to ``False`` is a way to detect only local-column based properties (i.e. scalar columns or many-to-one foreign keys) that would result in an UPDATE for this instance upon flush. )include_collections)rru)rRrrHs rSruAsyncSession.is_modifieds$x}}(( )  rVc6URR5$)aReturn True if this :class:`_orm.Session` has begun a transaction. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. .. versionadded:: 1.4 .. seealso:: :attr:`_orm.Session.is_active` )rrvrgs rSrvAsyncSession.in_transactionVs$}}++--rVc6URR5$)zReturn True if this :class:`_orm.Session` has begun a nested transaction, e.g. SAVEPOINT. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. .. versionadded:: 1.4 )rrwrgs rSrw"AsyncSession.in_nested_transactionjs}}2244rVc.URR$)akThe set of all persistent instances considered dirty. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. E.g.:: some_mapped_object in session.dirty Instances are considered dirty when they were modified but not deleted. Note that this 'dirty' calculation is 'optimistic'; most attribute-setting or collection modification operations will mark an instance as 'dirty' and place it in this set, even if there is no net change to the attribute's value. At flush time, the value of each attribute is compared to its previously saved value, and if there's no net change, no SQL operation will occur (this is a more expensive operation so it's only done at flush time). To check if an instance has actionable net changes to its attributes, use the :meth:`.Session.is_modified` method. )rrxrgs rSrxAsyncSession.dirtyzs>}}"""rVc.URR$)zThe set of all instances marked as 'deleted' within this ``Session`` .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. )rryrgs rSryAsyncSession.deleteds}}$$$rVc.URR$)zThe set of all instances marked as 'new' within this ``Session``. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. )rrzrgs rSrzAsyncSession.news}}   rVc.URR$)zrProxy for the :attr:`_orm.Session.identity_map` attribute on behalf of the :class:`_asyncio.AsyncSession` class. rr{rgs rSr{AsyncSession.identity_maps}})))rVc$XRlgrPrUrRattrs rSr{rVs %) "rVc.URR$)a5True if this :class:`.Session` not in "partial rollback" state. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. .. versionchanged:: 1.4 The :class:`_orm.Session` no longer begins a new transaction immediately, so this attribute will be False when the :class:`_orm.Session` is first instantiated. "partial rollback" state typically indicates that the flush process of the :class:`_orm.Session` has failed, and that the :meth:`_orm.Session.rollback` method must be emitted in order to fully roll back the transaction. If this :class:`_orm.Session` is not in a transaction at all, the :class:`_orm.Session` will autobegin when it is first used, so in this case :attr:`_orm.Session.is_active` will return True. Otherwise, if this :class:`_orm.Session` is within a transaction, and that transaction has not been rolled back internally, the :attr:`_orm.Session.is_active` will also return True. .. seealso:: :ref:`faq_session_rollback` :meth:`_orm.Session.in_transaction` )rr|rgs rSr|AsyncSession.is_activesF}}&&&rVc.URR$)zoProxy for the :attr:`_orm.Session.autoflush` attribute on behalf of the :class:`_asyncio.AsyncSession` class. rr}rgs rSr}AsyncSession.autoflushs}}&&&rVc$XRlgrPr]rXs rSr}r^s "& rVc.URR$)aReturn a context manager that disables autoflush. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. e.g.:: with session.no_autoflush: some_object = SomeClass() session.add(some_object) # won't autoflush some_object.related_thing = session.query(SomeRelated).first() Operations that proceed within the ``with:`` block will not be subject to flushes occurring upon query access. This is useful when initializing a series of objects which involve existing database queries, where the uncompleted object should not yet be flushed. )rr~rgs rSr~AsyncSession.no_autoflushs6}})))rVc.URR$)aA user-modifiable dictionary. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. The initial value of this dictionary can be populated using the ``info`` argument to the :class:`.Session` constructor or :class:`.sessionmaker` constructor or factory methods. The dictionary here is always local to this :class:`.Session` and can be modified independently of all other :class:`.Session` objects. )rrrgs rSrAsyncSession.infos$}}!!!rVc.[R"U5$)zReturn the :class:`.Session` to which an object belongs. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. This is an alias of :func:`.object_session`. )r!r )rrs rSr AsyncSession.object_session%s%%h//rV)rrowrc2[R"UUUUUS9$)zReturn an identity key. .. container:: class_bases Proxied for the :class:`_orm.Session` class on behalf of the :class:`_asyncio.AsyncSession` class. This is an alias of :func:`.util.identity_key`. )class_rrrfr)r!rl)rrhrrrfrs rSrlAsyncSession.identity_key5s&,##)   rV)rrrrrrP)rOptional[_AsyncSessionBind]rz2Optional[Dict[_SessionBindKey, _AsyncSessionBind]]rzOptional[Type[Session]]rr)r]r )NN)robjectrOptional[Iterable[str]]rrAr]None)rz&Callable[Concatenate[Session, _P], _T]rz_P.argsrz _P.kwargsr]rD)rTypedReturnsRows[_T]rOptional[_CoreAnyExecuteParams]rr5rOptional[_BindArguments]r Optional[Any]rrqr]z Result[_T])rr?rrorr5rrprrqrrqr]zCursorResult[Any])rr>rrorr5rrprrqrrqr] Result[Any]) rr>rrorr5rrprrr]rr) rTypedReturnsRows[Tuple[_T]]rrorr5rrprrr]z Optional[_T]) rr>rrorr5rrprrr]r) rrsrrorr5rrprrr]zScalarResult[_T]) rr>rrorr5rrprrr]zScalarResult[Any])r_EntityBindKey[_O]rr:rOptional[Sequence[ORMOption]]rboolrrArrqrr5r]zUnion[_O, None])rrtrr:rrurrvrrArrqrr5r]r4) rrnrrorr5rrprrr]zAsyncResult[_T]) rr>rrorr5rrprrr]zAsyncResult[Any]) rrsrrorr5rrprrr]zAsyncScalarResult[_T]) rr>rrorr5rrprrr]zAsyncScalarResult[Any])rrkr]rm)rr4rrvrrur]r4)rzOptional[Sequence[Any]]r]rm)r]z!Optional[AsyncSessionTransaction])NNN) rzOptional[_EntityBindKey[_O]]rzOptional[ClauseElement]rzOptional[_SessionBind]rrr]zUnion[Engine, Connection])rrprz%Optional[CoreExecuteOptionsParameter]rrr]r')r]rr]rm)rR_ASr]rxr+rr,rr-rr]rm)rRrxr] _AsyncSessionContextManager[_AS])rrkr]rv)r]zIterator[object])T)rrkr:rvr]rm)r=zIterable[object]r]rm)rrkrrlr]rm)rrkrHrvr]rvr]rv)r]r)r]r6)rYr6r]rm)rYrvr]rm)rrkr]zOptional[Session]) rhzOptional[Type[Any]]rzUnion[Any, Tuple[Any, ...]]rrqrfz%Optional[Union[Row[Any], RowMapping]]rrqr]z_IdentityKeyType[Any])Dr^r_r`rarj _is_asyncio__annotations__rTr!r classmethodrrrrr EMPTY_DICTrrrrrrrrrrrrrrrr rrrrrr deprecatedr"r%r/r3rmrnrorprqrrrsrtrurvrwrkrxryrzr{setterr|r}r~rr rlrcrdrVrSrrs <"K!!-1, EI6: , ), B , 4 ,  , \)0 /    48.2   1 ,    6> 2> >  > > @37  9=37/3$( ' 0  6  1  - "    37  9=37/3$(    0  6  1   -  "       37  9=37/3$(  0  6  1  - "    37!? 9=37 !?!?0!? 6 !? 1 !?!? !?F37 9=37 .0 6  1  37 9=37 0 6  1  37 9=37   0 6  1     B37 9=37 .0 6  1  37 9=37   0 6  1      37! 9=37 ! ! 0! 6 ! 1 ! !  ! P26"'.2(,8< " # /    , & 6   J26"'.2(,8<! "! #! / !  ! ,! &! 6!  ! F37 9=37 '0 6  1  37 9=37 0 6  1  37# 9=37 ##0# 6 # 1 ## #>37$ 9=37 $.$0$ 6 $ 1 $$ $$37% 9=37 %%0% 6 % 1 %% %%37 9=37   0 6  1     @ A&15     /   &G"(04*.'+ R ,R (R % R  R # R l48CG 0 A     @-.:&976 6$ ; __  / # ##14 ( 8D0.LP.O.O1H.O .O`'*R/ +"=A> > 59> > @.(5 ##@ % % ! !****"'"'H''''**8""& 0 0'+-1 #'59(, # +   3  &    rVrrxc\rSrSr%SrS\S'\SSSSS.SSjjj5r\SSSSS.SSjjj5rS\S S S S .SS jjjrSS jr SSjr SSjr SSjr Sr g )async_sessionmakeriYaA configurable :class:`.AsyncSession` factory. The :class:`.async_sessionmaker` factory works in the same way as the :class:`.sessionmaker` factory, to generate new :class:`.AsyncSession` objects when called, creating them given the configurational arguments established here. e.g.:: from sqlalchemy.ext.asyncio import create_async_engine from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.ext.asyncio import async_sessionmaker async def run_some_sql( async_session: async_sessionmaker[AsyncSession], ) -> None: async with async_session() as session: session.add(SomeObject(data="object")) session.add(SomeOtherObject(name="other object")) await session.commit() async def main() -> None: # an AsyncEngine, which the AsyncSession will use for connection # resources engine = create_async_engine( "postgresql+asyncpg://scott:tiger@localhost/" ) # create a reusable factory for new AsyncSession instances async_session = async_sessionmaker(engine) await run_some_sql(async_session) await engine.dispose() The :class:`.async_sessionmaker` is useful so that different parts of a program can create new :class:`.AsyncSession` objects with a fixed configuration established up front. Note that :class:`.AsyncSession` objects may also be instantiated directly when not using :class:`.async_sessionmaker`. .. versionadded:: 2.0 :class:`.async_sessionmaker` provides a :class:`.sessionmaker` class that's dedicated to the :class:`.AsyncSession` object, including pep-484 typing support. .. seealso:: :ref:`asyncio_orm` - shows example use :class:`.sessionmaker` - general overview of the :class:`.sessionmaker` architecture :ref:`session_getting` - introductory text on creating sessions using :class:`.sessionmaker`. Type[_AS]rh.)r}expire_on_commitrc grPrdrRrrhr}rrrs rSrTasync_sessionmaker.__init__s rVc grPrd)rRrr}rrrs rSrTrs rVNT)rhr}rrc BXS'X6S'XFS'UbXVS'X`lX lg)zConstruct a new :class:`.async_sessionmaker`. All arguments here except for ``class_`` correspond to arguments accepted by :class:`.Session` directly. See the :meth:`.AsyncSession.__init__` docstring for more details on parameters. rr}rNr)rrhrs rSrTrs2&6 #;!1   vJ rVc0U"5nUR5$)aLProduce a context manager that both provides a new :class:`_orm.AsyncSession` as well as a transaction that commits. e.g.:: async def main(): Session = async_sessionmaker(some_engine) async with Session.begin() as session: session.add(some_object) # commits transaction, closes session )r3)rRsessions rSrasync_sessionmaker.begins"&--//rVc URR5HLup#US:Xa0SU;a*UR5nURUS5 XAS'M;UR X#5 MN UR "S0UD6$)atProduce a new :class:`.AsyncSession` object using the configuration established in this :class:`.async_sessionmaker`. In Python, the ``__call__`` method is invoked on an object when it is "called" in the same way as a function:: AsyncSession = async_sessionmaker(async_engine, expire_on_commit=False) session = AsyncSession() # invokes sessionmaker.__call__() rrd)rrcopyupdate setdefaultrh)rRlocal_kwkvds rS__call__async_sessionmaker.__call__snGGMMODAF{v1FFH&)*#$ ##A) ${{&X&&rVc :URRU5 g)z(Re)configure the arguments for this async_sessionmaker. e.g.:: AsyncSession = async_sessionmaker(some_engine) AsyncSession.configure(bind=create_async_engine("sqlite+aiosqlite://")) N)rr)rRnew_kws rS configureasync_sessionmaker.configures vrVc URR<SURR<SSRSURR 555<S3$)Nz(class_=z, c38# UHupU<SU<3v M g7f)=Nrd).0rrs rS .async_sessionmaker.__repr__..sC?41A&?s)) __class__r^rhjoinrrrgs rS__repr__async_sessionmaker.__repr__sB NN # # KK IIC477==?C C  rV)rhr).) rrjrhrr}rvrrvrOptional[_InfoType]rr) rRz"'async_sessionmaker[AsyncSession]'rrjr}rvrrvrrrrrP)r]rz)rrr]rx)rrr]rm)r]r\)r^r_r`rarjr}rrTrrrrrrcrdrVrSrrYs=:x  -0  !$$'  )        "      -0 !$$'  0 )     "    -1)!%$()     "60('(  rVrcL\rSrSr%SrS\S'S\S'S SjrS SjrS S jrSr g )r2i)rrrxrrrcXlgrPr)rRrs rSrT$_AsyncSessionContextManager.__init__ s*rVc# URR5UlURR5IShvN UR$N7frP)rrrr%rgs rSr%&_AsyncSessionContextManager.__aenter__sB''--/ jj##%%%!!! &s=AAAc^^^^# SUUUU4Sjjn[R"U"55n[R"U5IShvN gN7f)Nc># TRRTTT5IShvN TRRTTT5IShvN gN*N7frP)rr/r)rRr-r+r,srSgo1_AsyncSessionContextManager.__aexit__..gosI**&&ueY? ? ?$$..ueYG G G @ Gs!!AA$A A AArw)r(r)r*)rRr+r,r-rr.s```` rSr/%_AsyncSessionContextManager.__aexit__s8 H H""24(nnT"""sAAA AN)rrx)r]rxry) r^r_r`rarbr}rTr%r/rcrdrVrSr2r2s"*I ""+" #rVr2c\rSrSr%SrSrS\S'S\S'SSSjjr\SS j5r SS jr SS jr SS jr \ SS j5rSSSjjrSSjrSrg)riaA wrapper for the ORM :class:`_orm.SessionTransaction` object. This object is provided so that a transaction-holding object for the :meth:`_asyncio.AsyncSession.begin` may be returned. The object supports both explicit calls to :meth:`_asyncio.AsyncSessionTransaction.commit` and :meth:`_asyncio.AsyncSessionTransaction.rollback`, as well as use as an async context manager. .. versionadded:: 1.4 )rsync_transactionr rrzOptional[SessionTransaction]rc*XlX lSUlgrP)rr r)rRrr s rSrT AsyncSessionTransaction.__init__5s  $rVchUR5SL=(a UR5R$rP)_sync_transactionr|rgs rSr|!AsyncSessionTransaction.is_active:s1  " " $D 0 3&&(22 rVc\UR(dUR5 UR$rP)r_raise_for_not_startedrgs rSr)AsyncSessionTransaction._sync_transactionAs#$$  ' ' )$$$rVcf# [UR5R5IShvN gN7f)z2Roll back this :class:`_asyncio.AsyncTransaction`.N)r$rrrgs rSr AsyncSessionTransaction.rollbackFs"T335>>??? '1/1cf# [UR5R5IShvN gN7f)z/Commit this :class:`_asyncio.AsyncTransaction`.N)r$rrrgs rSrAsyncSessionTransaction.commitJs$T335<<===rc UnURnURU5nX&lURU5UlXVlU$rP)r __new__rrr)rtargetr additional_kwrr objs rS_regenerate_proxy_for_target4AsyncSessionTransaction._regenerate_proxy_for_targetOsD"kk## "223CD  rVc@# UR[UR(a URRR OURRR 5IShvN 5UlU(aURR5 U$N07frP) rr$r rrr rr __enter__)rR is_ctxmanagers rSstartAsyncSessionTransaction.start^sw!% 4 4 ;; ))66\\..44 !    ! ! + + -  sA)B+B,1Bcj# [UR5RXU5IShvN gN7frP)r$r__exit__)rRr+r,r-s rSr/!AsyncSessionTransaction.__aexit__ls-  " " $ - -uY   s )313)r rrN)F)rrr rvr{)r]r"rw)rr"rrrrr]r)rrvr]rry)r^r_r`rarjrbr}rTrkr|rrrr~rrr/rcrdrVrSrrs :I 22%   % @>  " $   !  %* !    rVrc6[U5nUb [U5$g)awReturn the :class:`_asyncio.AsyncSession` to which the given instance belongs. This function makes use of the sync-API function :class:`_orm.object_session` to retrieve the :class:`_orm.Session` which refers to the given instance, and from there links it to the original :class:`_asyncio.AsyncSession`. If the :class:`_asyncio.AsyncSession` has been garbage collected, the return value is ``None``. This functionality is also available from the :attr:`_orm.InstanceState.async_session` accessor. :param instance: an ORM mapped instance :return: an :class:`_asyncio.AsyncSession` object, or ``None``. .. versionadded:: 1.4.18 N)r r)rrs rSasync_object_sessionrrs",X&GW%%rVc*[RUSS9$)zReturn the :class:`_asyncio.AsyncSession` which is proxying the given :class:`_orm.Session` object, if any. :param session: a :class:`_orm.Session` instance. :return: a :class:`_asyncio.AsyncSession` instance, or ``None``. .. versionadded:: 1.4.18 F) regenerate)rr)rs rSrrs  2 27u 2 MMrVc># [[5IShvN gN7f)zClose all :class:`_asyncio.AsyncSession` sessions. .. versionadded:: 2.0.23 .. seealso:: :func:`.session.close_all_sessions` N)r$_sync_close_all_sessionsrdrVrSrrs 1 222s )rrkr]Optional[AsyncSession])rr!r]rrw)c __future__rr(typingrrrrrr r r r r rrrrrrrrbaserrrrrrrormrrr r!r"r#_instance_stateutil.concurrencyr$ util.typingr%r&r'r(r)r*r+r,r-r.r/engine.interfacesr0r1eventr2 orm._typingr3r4r5 orm.identityr6orm.interfacesr7 orm.sessionr8r9r:r;r< sql._typingr=sql.baser>sql.dmlr? sql.elementsr@sql.selectablerArB_AsyncSessionBindrCrDrrrrIcreate_proxy_methodsrrxrr2rrr_async_providerrdrVrSrs# !"'%A!%+.&$'#$&  $&:@#/!9++--2+.(&%-42:;t_ T%%'7&>?$$&6%=>Z2Z2z $"N3  %:B ?7+B ;:B N,e>*j j Z#'#,#.R &'./R j: N 3#0rV