U
|
¸ý°d¹ð ã @ s¬ d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d d lm
|
Z
|
d d
|
lm Z d d lm Z d d lm Z d d lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z dd l m Z dd l m Z dd l m!Z! dd l m"Z# dd l$m%Z% er¢dd!lm&Z& dd"lm'Z' dd#lm(Z( dd$lm)Z) dd%lm*Z* dd&lm+Z+ dd'lm,Z, dd(lm-Z- dd)l.m/Z/ dd*l.m0Z0 dd+l1m2Z2 dd,l3m4Z4 dd-l3m5Z5 dd.l3m6Z6 dd/l7m8Z8 dd0l9m:Z: dd1l;m<Z< dd2l;m=Z= dd3l;m>Z> dd4l;m?Z? dd5l;m@Z@ dd6lAmBZB dd7lCmDZD dd8lEmFZF dd9lGmHZH dd:lGmIZI ed; ZJed<ed=ZKe Ld>d?i¡ZMe Ld@d?i¡ZNG dAdB dBZOe jPe dCdDdEdFgdGdHdIdJdKdLdMdNdOdPdQg dRdSdTdUdVdWdXdYgdZG d[d\ d\ee ZQed]d\d=ZRG d^d_ d_eeR ZSG d`da daeeR ZTG dbdc dcee! edc ZUdddedfdgdhZVdidedjdkdlZWeWe#_XdS )mé )Ú annotationsN)ÚAny)Ú Awaitable)ÚCallable)ÚDict)ÚGeneric)ÚIterable)ÚIterator)ÚNoReturn)ÚOptional)Úoverload)ÚSequence)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Úengine)ÚReversibleProxy)ÚStartableContext)Ú_ensure_sync_result)Ú AsyncResult)ÚAsyncScalarResulté )Úutil)Úobject_session)ÚSession)ÚSessionTransaction)Ústate)Úgreenlet_spawn)ÚAsyncConnection)Ú AsyncEngine)Ú
|
Connection)ÚEngine)ÚResult)ÚRow)Ú
|
RowMapping)Ú ScalarResult)Ú_CoreAnyExecuteParams)Ú_CoreSingleExecuteParams)Ú
|
dispatcher)Ú_IdentityKeyType)Ú_O)ÚOrmExecuteOptionsParameter)Ú IdentityMap)Ú ORMOption)Ú_BindArguments)Ú_EntityBindKey)Ú_PKIdentityArgument)Ú _SessionBind)Ú_SessionBindKey)Ú _InfoType)Ú
|
Executable)Ú ClauseElement)ÚForUpdateParameter)ÚTypedReturnsRows)r" r! Ú_T)ÚboundZprebuffer_rowsTZstream_resultsc @ s0 e Zd ZdZG dd dZeddddZdS ) Ú
|
AsyncAttrsa( Mixin 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 ``.async_attrs``
|
# interface, so that it may be awaited
|
for b1 in await a1.async_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 @ s. e Zd ZdZddddZdddd d
|
Zd S ) ú AsyncAttrs._AsyncAttrGetitemÚ _instancer ©r? c C s
|
|| _ d S ©Nr@ )Úselfr? © rC úUd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/asyncio/session.pyÚ__init__ s z%AsyncAttrs._AsyncAttrGetitem.__init__ÚstrzAwaitable[Any])ÚnameÚreturnc C s t t| j|S rA )r Úgetattrr? )rB rG rC rC rD Ú __getattr__ s z(AsyncAttrs._AsyncAttrGetitem.__getattr__N)Ú__name__Ú
|
__module__Ú __qualname__Ú __slots__rE rJ rC rC rC rD Ú_AsyncAttrGetitem s rO r> ©rH c C s
|
t | ¡S )aN 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.async_attrs.some_deferred_attribute
|
some_collection = await a1.async_attrs.some_collection
|
|
)r= rO ©rB rC rC rD Úawaitable_attrs s zAsyncAttrs.awaitable_attrsN)rK rL rM Ú__doc__rO ÚpropertyrR rC rC rC rD r= M s A r= z:class:`_orm.Session`z :class:`_asyncio.AsyncSession`r Ú identity_keyÚ __contains__Ú__iter__ÚaddÚadd_allÚexpireÚ
|
expire_allÚexpungeÚ expunge_allÚ is_modifiedÚin_transactionÚin_nested_transactionÚdirtyÚdeletedÚnewÚ identity_mapÚ is_activeÚ autoflushÚ no_autoflushÚinfo)Z classmethodsÚmethodsÚ
|
attributesc @ sÎ e Zd ZU dZdZded< dÄdddddd d
|
d d d ZeZded< ded< e ddddZ
|
dÅddddddd Z d d
|
d
|
d
|
d d d Z e dÆejdddd!d"d#d$d%d&d&d'd(d)d*Ze dÇejdddd!d+d#d$d%d&d&d,d(d-d*ZdÈejdd.d+d#d$d%d
|
d,d/d0d*Ze dÉejdd.d1d2d$d%d
|
d3d/d4d5Ze dÊejdd.d+d2d$d%d
|
d
|
d/d6d5ZdËejdd.d+d2d$d%d
|
d
|
d/d7d5Ze dÌejdd.d1d2d$d%d
|
d8d/d9d:Ze dÍejdd.d+d2d$d%d
|
d;d/d<d:ZdÎejdd.d+d2d$d%d
|
d;d/d=d:Zdd>ddejd?d@dAdBdCdd&d$dDdEdFdGZe dÏejdd.d"d#d$d%d
|
dHd/dIdJZe dÐejdd.d+d#d$d%d
|
dKd/dLdJZdÑejdd.d+d#d$d%d
|
dKd/dMdJZe dÒejdd.d1d2d$d%d
|
dNd/dOdPZe dÓejdd.d+d2d$d%d
|
dQd/dRdPZdÔejdd.d+d2d$d%d
|
dQd/dSdPZdddTdUdVZdddWdXdCdBdXdYdZd[ZdÕd\dd]d^d_Zd`ddadbZd`ddcddZdÖdedfdgd
|
dhdidjdkZd
|
dldmdndoZ dpddqdrZ dpddsdtZ dddudvZ dddwdxZ dddydzZ!ddd{d|Z"e ddd}d~Z#dddddZ$d
|
d
|
d
|
dddd
Z%dddddZ&ddCdTddZ'ddddZ(d×ddCddddZ)dddddZ*dØddddddZ+ddddZ,dddTddZ-ddddZ.dÙddCdCddd Z/dCdd¡d¢Z0dCdd£d¤Z1e2d
|
dd¥d¦Z3e2d
|
dd§d¨Z4e2d
|
dd©dªZ5e2d«dd¬dZ6e6j7d«dd®d¯dZ6e2d
|
dd°d±Z8e2dCdd²d³Z9e9j7dCdd®d´d³Z9e2d
|
ddµd¶Z:e2d
|
dd·d¸Z;e dd¹dTdºd»Z<e dÚdddd¼d½d¾d&d¿d&dÀdÁdÂdÃZ=dS )ÛÚ AsyncSessionae Asyncio version of :class:`_orm.Session`.
|
|
The :class:`_asyncio.AsyncSession` is a proxy for a traditional
|
:class:`_orm.Session` instance.
|
|
.. 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)ÚbindsÚsync_session_classúOptional[_AsyncSessionBind]z2Optional[Dict[_SessionBindKey, _AsyncSessionBind]]zOptional[Type[Session]]r )Úbindrm rn Úkwc K sj d }}|r || _ t |¡}|r8|| _dd | ¡ D }|rB|| _| | jf ||d|¡ | _| _dS )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
|
|
Nc S s i | ]\}}|t |¡qS rC )r Ú _get_sync_engine_or_connection)Ú.0ÚkeyÚbrC rC rD Ú
|
<dictcomp>ü s ÿ z)AsyncSession.__init__.<locals>.<dictcomp>)rp rm ) rp r rr rm Úitemsrn Ú_assign_proxiedÚ sync_sessionÚ_proxied)rB rp rm rn rq Z sync_bindZ
|
sync_bindsrC rC rD rE Ú s
|
þÿzAsyncSession.__init__z Type[Session]rn r ry r
|
rP c C s t dd S )Nztasynchronous events are not implemented at this time. Apply synchronous listeners to the AsyncSession.sync_session.)ÚNotImplementedError)ÚclsrC rC rD Ú_no_async_engine_events% s ÿz$AsyncSession._no_async_engine_eventsÚobjectzOptional[Iterable[str]]r9 ÚNone)ÚinstanceÚattribute_namesÚwith_for_updaterH c à s t | jj|||dI dH dS )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
|
|
)r r N)r ry Úrefresh)rB r r r rC rC rD r , s üzAsyncSession.refreshzCallable[..., Any])ÚfnÚargrq rH c Ï s t || jf||I dH S )a¤ Invoke 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`
|
N)r ry )rB r r
rq rC rC rD Úrun_syncG s 7zAsyncSession.run_sync)Úexecution_optionsÚbind_argumentsÚ_parent_execute_stateÚ
|
_add_eventzTypedReturnsRows[_T]z Optional[_CoreAnyExecuteParams]r. zOptional[_BindArguments]z Optional[Any]z
|
Result[_T])Ú statementÚparamsr r r r rH c à s d S rA rC ©rB r r r r r r rC rC rD Úexecute s zAsyncSession.executer7 z Result[Any]c à s d S rA rC r rC rC rD r s )r r )r r r r rq rH c Ë sP |rt |¡ t¡}nt}t| jj|f|||d|I dH }t|| jI dH S )z¼Execute a statement and return a buffered
|
:class:`_engine.Result` object.
|
|
.. seealso::
|
|
:meth:`_orm.Session.execute` - main documentation for execute
|
|
©r r r N)r Ú immutabledictÚunionÚ_EXECUTE_OPTIONSr ry r r ©rB r r r r rq ÚresultrC rC rD r s
|
ÿþûú zTypedReturnsRows[Tuple[_T]]z"Optional[_CoreSingleExecuteParams]z Optional[_T]c Ë s d S rA rC ©rB r r r r rq rC rC rD Úscalar½ s
|
zAsyncSession.scalarc Ë s d S rA rC r rC rC rD r É s
|
c Ë sB |rt |¡ t¡}nt}t| jj|f|||d|I dH }|S )zExecute a statement and return a scalar result.
|
|
.. seealso::
|
|
:meth:`_orm.Session.scalar` - main documentation for scalar
|
|
r N)r r r r r ry r r rC rC rD r Õ s
|
ÿþûú zScalarResult[_T]c Ë s d S rA rC r rC rC rD Úscalars÷ s
|
zAsyncSession.scalarszScalarResult[Any]c Ë s d S rA rC r rC rC rD r s
|
c Ë s( | j |f|||d|I dH }| ¡ S )aÏ Execute 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
|
|
r N)r r r rC rC rD r s ÿüû F)ÚoptionsÚpopulate_existingr Úidentity_tokenr z_EntityBindKey[_O]r3 z Optional[Sequence[ORMOption]]Úboolz Optional[_O])ÚentityÚidentr r r r r rH c à s$ t | jj||||||dI dH }|S )zÃReturn an instance based on the given primary key identifier,
|
or ``None`` if not found.
|
|
.. seealso::
|
|
:meth:`_orm.Session.get` - main documentation for get
|
|
|
)r r r r N)r ry Úget) rB r r r r r r r Z
|
result_objrC rC rD r 2 s ù zAsyncSession.getzAsyncResult[_T]c Ë s d S rA rC r rC rC rD ÚstreamS s
|
zAsyncSession.streamzAsyncResult[Any]c Ë s d S rA rC r rC rC rD r _ s
|
c Ë sF |rt |¡ t¡}nt}t| jj|f|||d|I dH }t|S )zbExecute a statement and return a streaming
|
:class:`_asyncio.AsyncResult` object.
|
|
r N)r r r Ú_STREAM_OPTIONSr ry r r r rC rC rD r k s
|
ÿþûú zAsyncScalarResult[_T]c Ë s d S rA rC r rC rC rD Ústream_scalars s
|
zAsyncSession.stream_scalarszAsyncScalarResult[Any]c Ë s d S rA rC r rC rC rD r¡ s
|
c Ë s( | j |f|||d|I dH }| ¡ S )aR 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
|
|
r N)r r r rC rC rD r¡ £ s ÿüû ©r rH c à s t | jj|I dH dS )aT 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 ry Údelete©rB r rC rC rD r£ à s zAsyncSession.delete©Úloadr r- )r r¦ r rH c à s t | jj|||dI dH S )zÛCopy the state of a given instance into a corresponding instance
|
within this :class:`_asyncio.AsyncSession`.
|
|
.. seealso::
|
|
:meth:`_orm.Session.merge` - main documentation for merge
|
|
r¥ N)r ry Úmerge)rB r r¦ r rC rC rD r§ Ò s ÿzAsyncSession.mergezOptional[Sequence[Any]])ÚobjectsrH c à s t | jj|dI dH dS )zFlush all the object changes to the database.
|
|
.. seealso::
|
|
:meth:`_orm.Session.flush` - main documentation for flush
|
|
)r¨ N)r ry Úflush)rB r¨ rC rC rD r© å s zAsyncSession.flushz!Optional[AsyncSessionTransaction]c C s$ | j ¡ }|dk r t |¡S dS dS )zÁReturn the current root transaction in progress, if any.
|
|
:return: an :class:`_asyncio.AsyncSessionTransaction` object, or
|
``None``.
|
|
.. versionadded:: 1.4.18
|
|
N)ry Úget_transactionÚAsyncSessionTransactionÚ_retrieve_proxy_for_target©rB ÚtransrC rC rD rª ï s
|
|
z AsyncSession.get_transactionc C s$ | j ¡ }|dk r t |¡S dS dS )zÃReturn the current nested transaction in progress, if any.
|
|
:return: an :class:`_asyncio.AsyncSessionTransaction` object, or
|
``None``.
|
|
.. versionadded:: 1.4.18
|
|
N)ry Úget_nested_transactionr« r¬ r rC rC rD r¯ þ s
|
|
|
z#AsyncSession.get_nested_transactionz Optional[_EntityBindKey[_O]]zOptional[ClauseElement]zOptional[_SessionBind]zUnion[Engine, Connection])ÚmapperÚclauserp rq rH c K s | j jf |||d|S )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.
|
|
)r° r± rp )ry Úget_bind)rB r° r± rp rq rC rC rD r² s P ÿÿzAsyncSession.get_bindr! )rq rH c Ë s" t | jjf|I dH }tj |¡S )a Return 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"
|
|
N)r ry Ú
|
connectionr r! r¬ )rB rq Zsync_connectionrC rC rD r³ b s ÿÿ
|
ÿzAsyncSession.connectionr« c C s t | S )aæ Return 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`.
|
|
©r« rQ rC rC rD Úbeginz s zAsyncSession.beginc C s 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)Únestedr´ rQ rC rC rD Ú begin_nested s zAsyncSession.begin_nestedc à s t | jjI dH dS )z-Rollback the current transaction in progress.N)r ry ÚrollbackrQ rC rC rD r¸ s zAsyncSession.rollbackc à s t | jjI dH dS )z+Commit the current transaction in progress.N)r ry ÚcommitrQ rC rC rD r¹ ¢ s zAsyncSession.commitc à s t | jjI dH dS )aP Close 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 ry ÚcloserQ rC rC rD rº ¦ s zAsyncSession.closec à s t | jjI dH dS )z
Close this Session, using connection invalidation.
|
|
For a complete description, see :meth:`_orm.Session.invalidate`.
|
N)r ry Ú
|
invalidaterQ rC rC rD r» Ä s zAsyncSession.invalidatec à s t | jjI dH dS )z2Close all :class:`_asyncio.AsyncSession` sessions.N)r ry Ú close_allrQ rC rC rD r¼ Ë s zAsyncSession.close_allÚ_AS)rB rH c à s | S rA rC rQ rC rC rD Ú
|
__aenter__Ð s zAsyncSession.__aenter__©Útype_ÚvalueÚ tracebackrH c à s" t | ¡ ¡}t |¡I d H d S rA )ÚasyncioÚ create_taskrº Úshield)rB rÀ rÁ r ÚtaskrC rC rD Ú __aexit__Ó s zAsyncSession.__aexit__ú _AsyncSessionContextManager[_AS]c C s t | S rA )Ú_AsyncSessionContextManagerrQ rC rC rD Ú_maker_context_manager× s z#AsyncSession._maker_context_managerc C s | j |¡S )aK Return 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.
|
|
|
)rz rV r¤ rC rC rD rV ß s zAsyncSession.__contains__zIterator[object]c C s
|
| j ¡ S )zøIterate 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.
|
|
|
)rz rW rQ rC rC rD rW ï s zAsyncSession.__iter__)r Ú_warnrH c C s | j j||dS )a: Place 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`
|
|
|
)rË )rz rX )rB r rË rC rC rD rX ý s zAsyncSession.addzIterable[object])Ú instancesrH c C s | j |¡S )aÓ Add 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`
|
|
|
)rz rY )rB rÌ rC rC rD rY s zAsyncSession.add_all)r r rH c C s | j j||dS )aa Expire 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 )rz rZ )rB r r rC rC rD rZ 5 s .zAsyncSession.expirec C s
|
| j ¡ S )ak Expires 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`
|
|
|
)rz r[ rQ rC rC rD r[ e s 'zAsyncSession.expire_allc C s | j |¡S )ad Remove 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.
|
|
|
)rz r\ r¤ rC rC rD r\ s zAsyncSession.expungec C s
|
| j ¡ S )aA Remove 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``.
|
|
|
)rz r] rQ rC rC rD r] s zAsyncSession.expunge_all)r Úinclude_collectionsrH c C s | j j||dS )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 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.
|
|
|
)rÍ )rz r^ )rB r rÍ rC rC rD r^ ® s < ÿzAsyncSession.is_modifiedc C s
|
| j ¡ S )aO Return 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`
|
|
|
|
)rz r_ rQ rC rC rD r_ î s zAsyncSession.in_transactionc C s
|
| j ¡ S )a+ Return 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
|
|
|
)rz r` rQ rC rC rD r` s z"AsyncSession.in_nested_transactionc C s | j jS )aû The 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.
|
|
|
)rz ra rQ rC rC rD ra s zAsyncSession.dirtyc C s | j jS )zîThe 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.
|
|
)rz rb rQ rC rC rD rb 3 s zAsyncSession.deletedc C s | j jS )zëThe 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.
|
|
)rz rc rQ rC rC rD rc @ s zAsyncSession.newr/ c C s | j jS )zProxy for the :attr:`_orm.Session.identity_map` attribute
|
on behalf of the :class:`_asyncio.AsyncSession` class.
|
|
©rz rd rQ rC rC rD rd M s zAsyncSession.identity_map)ÚattrrH c C s || j _d S rA rÎ ©rB rÏ rC rC rD rd V s c C s | j jS )aÕ True 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`
|
|
|
)rz re rQ rC rC rD re Z s #zAsyncSession.is_activec C s | j jS )zProxy for the :attr:`_orm.Session.autoflush` attribute
|
on behalf of the :class:`_asyncio.AsyncSession` class.
|
|
©rz rf rQ rC rC rD rf s zAsyncSession.autoflushc C s || j _d S rA rÑ rÐ rC rC rD rf s c C s | j jS )a Return 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.
|
|
|
)rz rg rQ rC rC rD rg s zAsyncSession.no_autoflushc C s | j jS )a+ A 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.
|
|
|
)rz rh rQ rC rC rD rh © s zAsyncSession.infozOptional[Session]c C s
|
t |¡S )a Return 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 )r| r rC rC rD r ½ s zAsyncSession.object_session)r Úrowr zOptional[Type[Any]]zUnion[Any, Tuple[Any, ...]]z%Optional[Union[Row[Any], RowMapping]]z_IdentityKeyType[Any])Úclass_r r rÒ r rH c C s t j|||||dS )zûReturn 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`.
|
|
|
)rÓ r r rÒ r )r rU )r| rÓ r r rÒ r rC rC rD rU Í s ûzAsyncSession.identity_key)N)NN)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)NNN)T)N)T)NN)>rK rL rM rS Z _is_asyncioÚ__annotations__rE r rn Ú classmethodr} r r r r Ú
|
EMPTY_DICTr r r r r r¡ r£ r§ r© rª r¯ r² r³ rµ r· r¸ r¹ rº r» r¼ r¾ rÇ rÊ rV rW rX rY rZ r[ r\ r] r^ r_ r` rT ra rb rc rd Úsetterre rf rg rh r rU rC rC rC rD rk ª sb
|
þû. ü9 ýø ýø ýú # ýú ýú ýú " ýú ýú ýú (÷ ! ýú ýú ýú ýú ýú ýú û
|
üT " ÿ0) ÿ@ $ ýùrk r½ c
|
@ sÌ e Zd ZU dZded< ed#dddddddddd d
|
d d Zed$ddddd ddddd ddd Zd%edddddddddd d
|
dd ZddddZd ddddZ d d d d d Z
|
d dd!d"Z dS )&Úasync_sessionmakeraë A 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`.
|
|
z Type[_AS]rÓ .)rf Úexpire_on_commitrh ro r zOptional[_InfoType]r )rp rÓ rf rÙ rh rq c K s d S rA rC ©rB rp rÓ rf rÙ rh rq rC rC rD rE * s zasync_sessionmaker.__init__z"'async_sessionmaker[AsyncSession]'©rB rp rf rÙ rh rq c K s d S rA rC rÛ rC rC rD rE 7 s
|
NT)rÓ rf rÙ rh c K s8 ||d< ||d< ||d< |dk r(||d< || _ || _dS )a Construct 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.
|
|
|
rp rf rÙ Nrh )rq rÓ rÚ rC rC rD rE C s rÈ rP c C s | }| ¡ S )a Produce 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
|
|
|
)rÊ )rB ÚsessionrC rC rD rµ ^ s zasync_sessionmaker.beginr½ )Úlocal_kwrH c K s\ | j ¡ D ]D\}}|dkrBd|krB| ¡ }| |d ¡ ||d< q
|
| ||¡ q
|
| jf |S )a¤ Produce 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__()
|
|
rh )rq rw ÚcopyÚupdateÚ
|
setdefaultrÓ )rB rÝ ÚkÚvÚdrC rC rD Ú__call__s s
|
zasync_sessionmaker.__call__r )Únew_kwrH c K s | j |¡ dS )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)rq rß )rB rå rC rC rD Ú configure s
|
z async_sessionmaker.configurerF c C s, d| j j| jjd dd | j ¡ D ¡f S )Nz%s(class_=%r, %s)z, c s s | ]\}}d ||f V qdS )z%s=%rNrC )rs rá râ rC rC rD Ú <genexpr> s z.async_sessionmaker.__repr__.<locals>.<genexpr>)Ú __class__rK rÓ Újoinrq rw rQ rC rC rD Ú__repr__ s
|
ýzasync_sessionmaker.__repr__).).)N) rK rL rM rS rÔ r rE rk rµ rä ræ rê rC rC rC rD rØ ñ s6
|
6 þù þú þù rØ c @ sR e Zd ZU dZded< ded< ddddZdd d
|
d Zd d d d dddZdS )rÉ )Ú async_sessionr® r½ rë r« r® ©rë c C s
|
|| _ d S rA rì )rB rë rC rC rD rE ¡ s z$_AsyncSessionContextManager.__init__rP c à s" | j ¡ | _| j ¡ I d H | j S rA )rë rµ r® r¾ rQ rC rC rD r¾ ¤ s z&_AsyncSessionContextManager.__aenter__r r r¿ c s8 dd fdd }t | ¡}t |¡I d H d S )Nr rP c s0 j ¡I d H j ¡I d H d S rA )r® rÇ rë rC ©rB r rÀ rÁ rC rD Úgoª s z1_AsyncSessionContextManager.__aexit__.<locals>.go)rà rÄ rÅ )rB rÀ rÁ r rî rÆ rC rí rD rÇ © s z%_AsyncSessionContextManager.__aexit__N)rK rL rM rN rÔ rE r¾ rÇ rC rC rC rD rÉ s
|
rÉ c @ s e Zd ZU dZdZded< ded< d ddd d
|
d Zedd d dZdd ddZ dd ddZ
|
dd ddZ d dd dddZ dddddd d Z d S )!r« a² A 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
|
|
)rÜ Úsync_transactionr¶ rk rÜ z Optional[SessionTransaction]rï Fr )rÜ r¶ c C s || _ || _d | _d S rA )rÜ r¶ rï )rB rÜ r¶ rC rC rD rE Ê s z AsyncSessionTransaction.__init__rP c C s | ¡ d k o| ¡ jS rA )Ú_sync_transactionre rQ rC rC rD re Ï s þz!AsyncSessionTransaction.is_activer c C s | j s| ¡ | j S rA )rï Z_raise_for_not_startedrQ rC rC rD rð Ö s z)AsyncSessionTransaction._sync_transactionr c à s t | ¡ jI dH dS )z2Roll back this :class:`_asyncio.AsyncTransaction`.N)r rð r¸ rQ rC rC rD r¸ Û s z AsyncSessionTransaction.rollbackc à s t | ¡ jI dH dS )z/Commit this :class:`_asyncio.AsyncTransaction`.N)r rð r¹ rQ rC rC rD r¹ ß s z AsyncSessionTransaction.commit)Ú is_ctxmanagerrH c à s> | t| jr| jjjn| jjjI d H ¡| _|r:| j ¡ | S rA ) rx r r¶ rÜ ry r· rµ rï Ú __enter__)rB rñ rC rC rD Ústartä s ÿ ýÿ
|
z AsyncSessionTransaction.startr r¿ c à s t | ¡ j|||I d H d S rA )r rð Ú__exit__)rB rÀ rÁ r rC rC rD rÇ ò s ÿz!AsyncSessionTransaction.__aexit__N)F)F)rK rL rM rS rN rÔ rE rT re rð r¸ r¹ ró rÇ rC rC rC rD r« ² s
|
ÿr« r~ zOptional[AsyncSession]r¢ c C s t | }|dk rt|S dS dS )a« Return 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ë )r rÜ rC rC rD Úasync_object_sessionø s rõ r )rÜ rH c C s t j| ddS )a Return 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)Z
|
regenerate)rk r¬ )rÜ rC rC rD rë s
|
rë )YÚ
|
__future__r rà Útypingr r r r r r r r
|
r r r r r r r r Ú r Úbaser r r r r r r Zormr r r r Z_instance_stateZutil.concurrencyr r! r" r# r$ r% r& r' r( Zengine.interfacesr) r* Úeventr+ Z orm._typingr, r- r. Z orm.identityr/ Zorm.interfacesr0 Z orm.sessionr1 r2 r3 r4 r5 Z sql._typingr6 Zsql.baser7 Z sql.elementsr8 Zsql.selectabler9 r: Z_AsyncSessionBindr; r r r r= Zcreate_proxy_methodsrk r½ rØ rÉ r« rõ rë Z_async_providerrC rC rC rD Ú<module> sÜ ]õøî 1 +
|
þF
|
