o =a.:@sddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd l mZeje d d d dggdgddGdddeZGdddZGdddeeZddZddZee _dS))engine)result)ReversibleProxy)StartableContext)util)object_session)Session)state)greenlet_spawnz:class:`_orm.Session`z:class:`_asyncio.AsyncSession`r identity_key) __contains____iter__addadd_allexpire expire_allexpunge expunge_allget_bind is_modifiedin_transactionin_nested_transaction)dirtydeletednew identity_map is_active autoflush no_autoflushinfo) classmethodsmethods attributesc@seZdZdZdZdZd2ddZ d2ddZdd Zde j dfd d Z de j dfd d Z    d3ddZ de j dfddZddZd4ddZd5ddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zed*d+Zd,d-Zd.d/Zd0d1ZdS)6 AsyncSessionzKAsyncio version of :class:`_orm.Session`. .. versionadded:: 1.4 )bindsbind sync_session_proxied_slots_dispatchNcKs^d|d<|r||_t|}|r||_dd|D}|td||d||_|_dS)NTfuturecSsi|] \}}|t|qS)r_get_sync_engine_or_connection).0keybr+r+T/var/www/html/gps/gps/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/session.py Js z)AsyncSession.__init__..)r&r%r+) r&rr,r%items_assign_proxiedr r'r()selfr&r%kwr+r+r0__init__Bs zAsyncSession.__init__cst|jj|||dIdHS)aTExpire 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. )attribute_nameswith_for_updateN)r r'refresh)r4instancer7r8r+r+r0r9Ss  zAsyncSession.refreshcs"t||jg|Ri|IdHS)aInvoke the given sync callable passing sync 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 AsyncSession(async_engine) as session: await session.run_sync(some_business_method) .. 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')r4fnargr5r+r+r0run_syncgs zAsyncSession.run_synccs4|ddi}t|jj|f|||d|IdHS)zQExecute a statement and return a buffered :class:`_engine.Result` object.prebuffer_rowsTparamsexecution_optionsbind_argumentsN)unionr r'execute)r4 statementr@rArBr5r+r+r0rDs  zAsyncSession.executecs*|j|f|||d|IdH}|S)z/Execute a statement and return a scalar result.r?N)rDscalarr4rEr@rArBr5rr+r+r0rFs  zAsyncSession.scalarFc s"t|jj||||||dIdHS)zjReturn an instance based on the given primary key identifier, or ``None`` if not found. )optionspopulate_existingr8identity_tokenN)r r'get)r4entityidentrHrIr8rJr+r+r0rKs zAsyncSession.getcs>|ddi}t|jj|f|||d|IdH}t|S)zXExecute a statement and return a streaming :class:`_asyncio.AsyncResult` object.stream_resultsTr?N)rCr r'rD_result AsyncResultrGr+r+r0streams  zAsyncSession.streamcst|jj|IdHS)zMark 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. N)r r'delete)r4r:r+r+r0rRs zAsyncSession.deleteTcst|jj||dIdHS)z~Copy the state of a given instance into a corresponding instance within this :class:`_asyncio.AsyncSession`. )loadN)r r'merge)r4r:rSr+r+r0rTs  zAsyncSession.mergecst|jj|dIdHdS)zuFlush all the object changes to the database. .. seealso:: :meth:`_orm.Session.flush` )objectsN)r r'flush)r4rUr+r+r0rVszAsyncSession.flushcC |j}|durt|SdS)zReturn the current root transaction in progress, if any. :return: an :class:`_asyncio.AsyncSessionTransaction` object, or ``None``. .. versionadded:: 1.4.18 N)r'get_transactionAsyncSessionTransaction_retrieve_proxy_for_targetr4transr+r+r0rXs  zAsyncSession.get_transactioncCrW)zReturn the current nested transaction in progress, if any. :return: an :class:`_asyncio.AsyncSessionTransaction` object, or ``None``. .. versionadded:: 1.4.18 N)r'get_nested_transactionrYrZr[r+r+r0r]s  z#AsyncSession.get_nested_transactioncs t|jjIdH}tj|S)zReturn a :class:`_asyncio.AsyncConnection` object corresponding to this :class:`.Session` object's transactional state. N)r r' connectionrAsyncConnectionrZ)r4sync_connectionr+r+r0r^s zAsyncSession.connectioncKt|S)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`. rYr4r5r+r+r0begin#szAsyncSession.begincKs t|ddS)a:Return 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`. T)nestedrbrcr+r+r0 begin_nested:s zAsyncSession.begin_nestedct|jjIdHS)z-Rollback the current transaction in progress.N)r r'rollbackr4r+r+r0rhGzAsyncSession.rollbackcrg)z+Commit the current transaction in progress.N)r r'commitrir+r+r0rkKrjzAsyncSession.commitcrg)aPClose out the transactional resources and ORM objects used by this :class:`_asyncio.AsyncSession`. This expunges all ORM objects associated with this :class:`_asyncio.AsyncSession`, ends any transaction in progress and :term:`releases` any :class:`_asyncio.AsyncConnection` objects which this :class:`_asyncio.AsyncSession` itself has checked out from associated :class:`_asyncio.AsyncEngine` objects. The operation then leaves the :class:`_asyncio.AsyncSession` in a state which it may be used again. .. tip:: The :meth:`_asyncio.AsyncSession.close` method **does not prevent the Session from being used again**. The :class:`_asyncio.AsyncSession` itself does not actually have a distinct "closed" state; it merely means the :class:`_asyncio.AsyncSession` will release all database connections and ORM objects. .. seealso:: :ref:`session_closing` - detail on the semantics of :meth:`_asyncio.AsyncSession.close` N)r r'closerir+r+r0rlOszAsyncSession.closecrg)z2Close all :class:`_asyncio.AsyncSession` sessions.N)r r' close_allrir+r+r0rmmszAsyncSession.close_allcs|SNr+rir+r+r0 __aenter__rszAsyncSession.__aenter__cs|IdHdSrn)rlr4type_value tracebackr+r+r0 __aexit__uszAsyncSession.__aexit__cCrarn)_AsyncSessionContextManagerrir+r+r0_maker_context_managerxsz#AsyncSession._maker_context_manager)NN)NFNN)Trn)__name__ __module__ __qualname____doc__ __slots__dispatchr6r9r=r EMPTY_DICTrDrFrKrQrRrTrVrXr]r^rdrfrhrkrl classmethodrmrortrvr+r+r+r0r$sR            r$c@s$eZdZddZddZddZdS)rucCs ||_dSrn) async_session)r4rr+r+r0r6~s z$_AsyncSessionContextManager.__init__cs$|j|_|jIdH|jSrn)rrdr\rorir+r+r0ros z&_AsyncSessionContextManager.__aenter__cs2|j|||IdH|j|||IdHdSrn)r\rtrrpr+r+r0rtsz%_AsyncSessionContextManager.__aexit__N)rwrxryr6rortr+r+r+r0ru}s ruc@sTeZdZdZdZdddZeddZdd Zd d Z d d Z dddZ ddZ dS)rYaA 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 )sessionsync_transactionreFcCs||_||_d|_dSrn)rrer)r4rrer+r+r0r6s z AsyncSessionTransaction.__init__cCs|duo |jSrn)_sync_transactionrrir+r+r0rs z!AsyncSessionTransaction.is_activecCs|js||jSrn)r_raise_for_not_startedrir+r+r0rsz)AsyncSessionTransaction._sync_transactionct|jIdHdS)z2Roll back this :class:`_asyncio.AsyncTransaction`.N)r rrhrir+r+r0rhsz AsyncSessionTransaction.rollbackcr)z/Commit this :class:`_asyncio.AsyncTransaction`.N)r rrkrir+r+r0rkszAsyncSessionTransaction.commitcs@|t|jr |jjjn|jjjIdH|_|r|j|Srn) r3r rerr'rfrdr __enter__)r4 is_ctxmanagerr+r+r0starts  zAsyncSessionTransaction.startcs t|j|||IdHdSrn)r r__exit__rpr+r+r0rtsz!AsyncSessionTransaction.__aexit__N)F) rwrxryrzr{r6propertyrrrhrkrrtr+r+r+r0rYs    rYcCst|}|dur t|SdS)aReturn 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)rr)r:rr+r+r0async_object_sessionsrcCstj|ddS)aReturn 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)r$rZ)rr+r+r0rs rN)rrrObaserrrormrr r _instance_stateutil.concurrencyr create_proxy_methodsr$rurYrr_async_providerr+r+r+r0s2         O>