HEX

File: //usr/local/lib/python3.10/dist-packages/sqlalchemy/ext/asyncio/__pycache__/engine.cpython-310.pyc
o

���gF��@s�ddlmZddlZddlZddlmZddlmZddlmZddlmZddlm	Z	ddlm
Z
dd	lmZdd
lmZddlm
Z
ddlmZdd
lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl m"Z#ddl m$Z%ddl m&Z&dd l'm(Z(dd!l'm)Z)dd"lm*Z*dd#l+m,Z,dd$l-m.Z.dd%l-m/Z/e�rCdd&l0m1Z1dd'l2m3Z3dd(l2m4Z4dd)l2m5Z5dd*l2m6Z6dd+l2m7Z7dd,l2m8Z8dd-l2m9Z9dd.l2m:Z:dd/l2m;Z;dd0l<m=Z=dd1l>m?Z?dd2l@mAZAdd3l@mBZBdd4lCmDZDdd5lEmFZFdd6lGmHZHe/d7�ZIed8ed9�ZJdkd@dA�ZK	BdldmdHdI�ZLdndKdL�ZMGdMdN�dN�ZNejOe!dOdPgggdQ�dR�GdSdT�dTee!edTeN��ZPejOe&dUdVggdW�gdX�dR�GdYd?�d?ee&eN��ZQGdZd[�d[ee)ed[�ZRedod^d_��ZSedpdad_��ZSdqddd_�ZSe�TeP�drdgdh��ZUe�TeQ�dsdidj��ZVdS)t�)�annotationsN)�Any)�
AsyncIterator)�Callable)�Dict)�	Generator)�NoReturn)�Optional)�overload)�Tuple)�Type)�
TYPE_CHECKING)�TypeVar)�Union�)�exc)�asyncstartablecontext)�GeneratorStartableContext)�ProxyComparable)�StartableContext)�_ensure_sync_result)�AsyncResult)�AsyncScalarResult�)�
inspection)�util)�
Connection)�
create_engine)�create_pool_from_url)�Engine)�NestedTransaction)�Transaction)�
ArgumentError)�greenlet_spawn)�Concatenate)�	ParamSpec)�CursorResult)�_CoreAnyExecuteParams)�_CoreSingleExecuteParams)�_DBAPIAnyExecuteParams)�_ExecuteOptions)�CompiledCacheType)�CoreExecuteOptionsParameter)�Dialect)�IsolationLevel)�SchemaTranslateMapType)�ScalarResult)�URL)�Pool)�PoolProxiedConnection)�	_InfoType)�
Executable)�TypedReturnsRows�_P�_T)�bound�url�Union[str, URL]�kwr�return�AsyncEnginecsr|�dd�rt�d��d|d<|�dd���r-|�dd�r!td	��d��fdd
�}||d<t|fi|���t��S)aCreate a new async engine instance.

    Arguments passed to :func:`_asyncio.create_async_engine` are mostly
    identical to those passed to the :func:`_sa.create_engine` function.
    The specified dialect must be an asyncio-compatible dialect
    such as :ref:`dialect-postgresql-asyncpg`.

    .. versionadded:: 1.4

    :param async_creator: an async callable which returns a driver-level
        asyncio connection. If given, the function should take no arguments,
        and return a new asyncio connection from the underlying asyncio
        database driver; the connection will be wrapped in the appropriate
        structures to be used with the :class:`.AsyncEngine`.   Note that the
        parameters specified in the URL are not applied here, and the creator
        function should use its own connection parameters.

        This parameter is the asyncio equivalent of the
        :paramref:`_sa.create_engine.creator` parameter of the
        :func:`_sa.create_engine` function.

        .. versionadded:: 2.0.16

    �server_side_cursorsFz}Can't set server_side_cursors for async engine globally; use the connection.stream() method for an async streaming result setT�	_is_async�
async_creatorN�creatorz?Can only specify one of 'async_creator' or 'creator', not both.r=rcs�jjj�d�S)N)�async_creator_fn)�dialect�dbapi�connect��rA�sync_enginerG�H/usr/local/lib/python3.10/dist-packages/sqlalchemy/ext/asyncio/engine.pyrBos�z$create_async_engine.<locals>.creator�r=r)�get�	async_exc�AsyncMethodRequired�popr"�_create_enginer>)r:r<rBrGrHrJ�create_async_engineFs��rQ�sqlalchemy.�
configuration�Dict[str, Any]�prefix�str�kwargscsB�fdd�|��D�}d|d<|�|�|�d�}t|fi|��S)a�Create a new AsyncEngine instance using a configuration dictionary.

    This function is analogous to the :func:`_sa.engine_from_config` function
    in SQLAlchemy Core, except that the requested dialect must be an
    asyncio-compatible dialect such as :ref:`dialect-postgresql-asyncpg`.
    The argument signature of the function is identical to that
    of :func:`_sa.engine_from_config`.

    .. versionadded:: 1.4.29

    cs,i|]\}}|���r|t��d�|�qS�N)�
startswith�len)�.0�key�value�rUrGrJ�
<dictcomp>�s��z,async_engine_from_config.<locals>.<dictcomp>T�_coerce_configr:)�items�updaterOrQ)rSrUrW�optionsr:rGr^rJ�async_engine_from_config|s
�

rdr2cKsd|d<t|fi|��S)aVCreate a new async engine instance.

    Arguments passed to :func:`_asyncio.create_async_pool_from_url` are mostly
    identical to those passed to the :func:`_sa.create_pool_from_url` function.
    The specified dialect must be an asyncio-compatible dialect
    such as :ref:`dialect-postgresql-asyncpg`.

    .. versionadded:: 2.0.10

    Tr@)�_create_pool_from_url)r:rWrGrGrJ�create_async_pool_from_url�srfc@seZdZdZeddd��ZdS)�AsyncConnectable)�_slots_dispatch�__weakref__r=rcCstd��)Nz�asynchronous events are not implemented at this time.  Apply synchronous listeners to the AsyncEngine.sync_engine or AsyncConnection.sync_connection attributes.)�NotImplementedError)�clsrGrGrJ�_no_async_engine_events�s�z(AsyncConnectable._no_async_engine_eventsN�r=r)�__name__�
__module__�__qualname__�	__slots__�classmethodrlrGrGrGrJrg�srgz:class:`_engine.Connection`z!:class:`_asyncio.AsyncConnection`)�closed�invalidatedrD�default_isolation_level)�classmethods�methods�
attributesc@seZdZUdZdZ	d�d�dd	�Zded<	d
ed<	ed�dd��Z	d�d�dd�Z	e
d�dd��Zd�dd�Ze
jd�dd��Ze
jd�dd ��Zd�d"d#�Zd�d$d%�Z	d�d�d)d*�Zd�d,d-�Zd�d.d/�Zd�d0d1�Zd�d3d4�Zd�d5d6�Zed7d7d7ddd7d7d7d7dd8�
d�dIdJ��Zed�dKdJ��Zd�dLdJ�Zd�dMdN�Zd�dOdP�Zd�dQdR�Zd�dSdT�Z		d�d�d[d\�Ze	d�dd]�d�dadb��Z e	d�dd]�d�dedb��Z e!	d�dd]�d�dgdb��Z e	d�dd]�d�didj��Z"e	d�dd]�d�dkdj��Z"	d�dd]�d�dldj�Z"e	d�dd]�d�dpdq��Z#e	d�dd]�d�drdq��Z#	d�dd]�d�dsdq�Z#e	d�dd]�d�dudv��Z$e	d�dd]�d�dxdv��Z$	d�dd]�d�dydv�Z$e	d�dd]�d�d{d|��Z%e	d�dd]�d�d~d|��Z%e!	d�dd]�d�d�d|��Z%d�d�d��Z&d�d�d��Z'd�d�d��Z(e
d�d�d���Z)e
d�d�d���Z*e
d�d�d���Z+e+j,d�d�d���Z+e
d�d�d���Z-dS)��AsyncConnectiona�An asyncio proxy for a :class:`_engine.Connection`.

    :class:`_asyncio.AsyncConnection` is acquired using the
    :meth:`_asyncio.AsyncEngine.connect`
    method of :class:`_asyncio.AsyncEngine`::

        from sqlalchemy.ext.asyncio import create_async_engine

        engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname")

        async with engine.connect() as conn:
            result = await conn.execute(select(table))

    .. versionadded:: 1.4

    )�enginerI�sync_connectionN�async_enginer>r{�Optional[Connection]cCs||_|j|_|�|�|_dSrX)rzrI�_assign_proxiedr{)�selfr|r{rGrGrJ�__init__�szAsyncConnection.__init__rrI�targetrr=cCstt�|j�|�SrX)ryr>�_retrieve_proxy_for_targetrz�rkr�rGrGrJ�_regenerate_proxy_for_targets�z,AsyncConnection._regenerate_proxy_for_targetF�
is_ctxmanager�boolc�s0�|jr	t�d��|�t|jj�IdH�|_|S)zzStart this :class:`_asyncio.AsyncConnection` object's context
        outside of using a Python ``with:`` block.

        zconnection is already startedN)r{r�InvalidRequestErrorr~r#rIrF�rr�rGrGrJ�starts�
�zAsyncConnection.startrcCs
t�d��)zeNot implemented for async; call
        :meth:`_asyncio.AsyncConnection.get_raw_connection`.
        z�AsyncConnection.connection accessor is not implemented as the attribute may need to reconnect on an invalidated connection.  Use the get_raw_connection() method.)rr��rrGrGrJ�
connections�zAsyncConnection.connectionr3c�s�tt|jd�IdHS)aReturn the pooled DBAPI-level connection in use by this
        :class:`_asyncio.AsyncConnection`.

        This is a SQLAlchemy connection-pool proxied connection
        which then has the attribute
        :attr:`_pool._ConnectionFairy.driver_connection` that refers to the
        actual driver connection. Its
        :attr:`_pool._ConnectionFairy.dbapi_connection` refers instead
        to an :class:`_engine.AdaptedConnection` instance that
        adapts the driver connection to the DBAPI protocol.

        r�N)r#�getattr�_proxiedr�rGrGrJ�get_raw_connection!s�z"AsyncConnection.get_raw_connectionr4cC�|jjS)aReturn the :attr:`_engine.Connection.info` dictionary of the
        underlying :class:`_engine.Connection`.

        This dictionary is freely writable for user-defined state to be
        associated with the database connection.

        This attribute is only available if the :class:`.AsyncConnection` is
        currently connected.   If the :attr:`.AsyncConnection.closed` attribute
        is ``True``, then accessing this attribute will raise
        :class:`.ResourceClosedError`.

        .. versionadded:: 1.4.0b2

        )r��infor�rGrGrJr�1szAsyncConnection.infocC�|js|��|jSrX)r{�_raise_for_not_startedr�rGrGrJr�C�zAsyncConnection._proxied�AsyncTransactioncCs|jsJ�t|�S)z1Begin a transaction prior to autobegin occurring.�r�r�r�rGrGrJ�beginIs
zAsyncConnection.begincCs|jsJ�t|dd�S)z;Begin a nested transaction and return a transaction handle.T)�nestedr�r�rGrGrJ�begin_nestedNs
zAsyncConnection.begin_nested�	exception�Optional[BaseException]�Nonec�s�t|jj|d�IdHS)z�Invalidate the underlying DBAPI connection associated with
        this :class:`_engine.Connection`.

        See the method :meth:`_engine.Connection.invalidate` for full
        detail on this method.

        )r�N)r#r��
invalidate)rr�rGrGrJr�Ss��zAsyncConnection.invalidater.c�s�t|jj�IdHSrX)r#r��get_isolation_levelr�rGrGrJr�bs�z#AsyncConnection.get_isolation_levelcC�
|j��S)z,Return True if a transaction is in progress.)r��in_transactionr�rGrGrJr�es
zAsyncConnection.in_transactioncCr�)zYReturn True if a transaction is in progress.

        .. versionadded:: 1.4.0b2

        )r��in_nested_transactionr�rGrGrJr�js
z%AsyncConnection.in_nested_transaction�Optional[AsyncTransaction]cC� |j��}|durt�|�SdS)a�Return an :class:`.AsyncTransaction` representing the current
        transaction, if any.

        This makes use of the underlying synchronous connection's
        :meth:`_engine.Connection.get_transaction` method to get the current
        :class:`_engine.Transaction`, which is then proxied in a new
        :class:`.AsyncTransaction` object.

        .. versionadded:: 1.4.0b2

        N)r��get_transactionr�r��r�transrGrGrJr�r�


zAsyncConnection.get_transactioncCr�)a�Return an :class:`.AsyncTransaction` representing the current
        nested (savepoint) transaction, if any.

        This makes use of the underlying synchronous connection's
        :meth:`_engine.Connection.get_nested_transaction` method to get the
        current :class:`_engine.Transaction`, which is then proxied in a new
        :class:`.AsyncTransaction` object.

        .. versionadded:: 1.4.0b2

        N)r��get_nested_transactionr�r�r�rGrGrJr��r�z&AsyncConnection.get_nested_transaction.)
�compiled_cache�
logging_token�isolation_level�
no_parameters�stream_results�max_row_buffer�	yield_per�insertmanyvalues_page_size�schema_translate_map�preserve_rowcountr��Optional[CompiledCacheType]r�rVr�r�r�r��intr�r�r�� Optional[SchemaTranslateMapType]r��optrc
���dSrXrG)rr�r�r�r�r�r�r�r�r�r�r�rGrGrJ�execution_options�s�z!AsyncConnection.execution_optionsc�r�rXrG�rr�rGrGrJr��s�c�s0�|j}t|jfi|��IdH}||usJ�|S)a'Set non-SQL options for the connection which take effect
        during execution.

        This returns this :class:`_asyncio.AsyncConnection` object with
        the new options added.

        See :meth:`_engine.Connection.execution_options` for full details
        on this method.

        N)r�r#r�)rr��conn�c2rGrGrJr��s
�c���t|jj�IdHdS)a�Commit the transaction that is currently in progress.

        This method commits the current transaction if one has been started.
        If no transaction was started, the method has no effect, assuming
        the connection is in a non-invalidated state.

        A transaction is begun on a :class:`_engine.Connection` automatically
        whenever a statement is first executed, or when the
        :meth:`_engine.Connection.begin` method is called.

        N�r#r��commitr�rGrGrJr��s�zAsyncConnection.commitc�r�)a&Roll back the transaction that is currently in progress.

        This method rolls back the current transaction if one has been started.
        If no transaction was started, the method has no effect.  If a
        transaction was started and the connection is in an invalidated state,
        the transaction is cleared using this method.

        A transaction is begun on a :class:`_engine.Connection` automatically
        whenever a statement is first executed, or when the
        :meth:`_engine.Connection.begin` method is called.


        N�r#r��rollbackr�rGrGrJr��s�zAsyncConnection.rollbackc�r�)z�Close this :class:`_asyncio.AsyncConnection`.

        This has the effect of also rolling back the transaction if one
        is in place.

        N�r#r��closer�rGrGrJr��s�zAsyncConnection.closec�s�|��IdHdS)aA synonym for :meth:`_asyncio.AsyncConnection.close`.

        The :meth:`_asyncio.AsyncConnection.aclose` name is specifically
        to support the Python standard library ``@contextlib.aclosing``
        context manager function.

        .. versionadded:: 2.0.20

        N�r�r�rGrGrJ�aclose�s�
zAsyncConnection.aclose�	statement�
parameters� Optional[_DBAPIAnyExecuteParams]r��%Optional[CoreExecuteOptionsParameter]�CursorResult[Any]c��0�t|jj|||dd�IdH}t||j�IdHS)zaExecutes a driver-level SQL string and return buffered
        :class:`_engine.Result`.

        T)�_require_awaitN)r#r��exec_driver_sqlr�rr�r�r��resultrGrGrJr��s��zAsyncConnection.exec_driver_sql�r��TypedReturnsRows[_T]�Optional[_CoreAnyExecuteParams]�*GeneratorStartableContext[AsyncResult[_T]]cC�dSrXrG�rr�r�r�rGrGrJ�stream�zAsyncConnection.streamr5�+GeneratorStartableContext[AsyncResult[Any]]cCr�rXrGr�rGrGrJr�r��AsyncIterator[AsyncResult[Any]]c	Cs��|jjs
t�d��t|jj||tj�	|ddi�dd�IdH}|j
js%J�t|�}z|VWn
t
y8YdSwt�|���}t�|�IdHdS)aKExecute a statement and return an awaitable yielding a
        :class:`_asyncio.AsyncResult` object.

        E.g.::

            result = await conn.stream(stmt)
            async for row in result:
                print(f"{row}")

        The :meth:`.AsyncConnection.stream`
        method supports optional context manager use against the
        :class:`.AsyncResult` object, as in::

            async with conn.stream(stmt) as result:
                async for row in result:
                    print(f"{row}")

        In the above pattern, the :meth:`.AsyncResult.close` method is
        invoked unconditionally, even if the iterator is interrupted by an
        exception throw.   Context manager use remains optional, however,
        and the function may be called in either an ``async with fn():`` or
        ``await fn()`` style.

        .. versionadded:: 2.0.0b3 added context manager support


        :return: an awaitable object that will yield an
         :class:`_asyncio.AsyncResult` object.

        .. seealso::

            :meth:`.AsyncConnection.stream_scalars`

        zmCant use `stream` or `stream_scalars` with the current dialect since it does not support server side cursors.r�T�r�r�N)rD�supports_server_side_cursorsrr�r#r��executer�
EMPTY_DICT�
merge_with�context�_is_server_sider�
GeneratorExit�asyncio�create_taskr��shield)rr�r�r�r��ar�taskrGrGrJr�s.�*���	
��CursorResult[_T]c�r�rXrGr�rGrGrJr�Z��zAsyncConnection.executec�r�rXrGr�rGrGrJr�cr�c�r�)a�Executes a SQL statement construct and return a buffered
        :class:`_engine.Result`.

        :param object: The statement to be executed.  This is always
         an object that is in both the :class:`_expression.ClauseElement` and
         :class:`_expression.Executable` hierarchies, including:

         * :class:`_expression.Select`
         * :class:`_expression.Insert`, :class:`_expression.Update`,
           :class:`_expression.Delete`
         * :class:`_expression.TextClause` and
           :class:`_expression.TextualSelect`
         * :class:`_schema.DDL` and objects which inherit from
           :class:`_schema.ExecutableDDLElement`

        :param parameters: parameters which will be bound into the statement.
         This may be either a dictionary of parameter names to values,
         or a mutable sequence (e.g. a list) of dictionaries.  When a
         list of dictionaries is passed, the underlying statement execution
         will make use of the DBAPI ``cursor.executemany()`` method.
         When a single dictionary is passed, the DBAPI ``cursor.execute()``
         method will be used.

        :param execution_options: optional dictionary of execution options,
         which will be associated with the statement execution.  This
         dictionary can provide a subset of the options that are accepted
         by :meth:`_engine.Connection.execution_options`.

        :return: a :class:`_engine.Result` object.

        Tr�N)r#r�r�rr�rGrGrJr�ls�&��TypedReturnsRows[Tuple[_T]]�"Optional[_CoreSingleExecuteParams]�Optional[_T]c�r�rXrGr�rGrGrJ�scalar�r�zAsyncConnection.scalarc�r�rXrGr�rGrGrJr��r�c�� �|j|||d�IdH}|��S)auExecutes a SQL statement construct and returns a scalar object.

        This method is shorthand for invoking the
        :meth:`_engine.Result.scalar` method after invoking the
        :meth:`_engine.Connection.execute` method.  Parameters are equivalent.

        :return: a scalar Python value representing the first column of the
         first row returned.

        r�N)r�r�r�rGrGrJr��s
���ScalarResult[_T]c�r�rXrGr�rGrGrJ�scalars�r�zAsyncConnection.scalars�ScalarResult[Any]c�r�rXrGr�rGrGrJr��r�c�r�)aiExecutes a SQL statement construct and returns a scalar objects.

        This method is shorthand for invoking the
        :meth:`_engine.Result.scalars` method after invoking the
        :meth:`_engine.Connection.execute` method.  Parameters are equivalent.

        :return: a :class:`_engine.ScalarResult` object.

        .. versionadded:: 1.4.24

        r�N)r�r�r�rGrGrJr��s
���0GeneratorStartableContext[AsyncScalarResult[_T]]cCr�rXrGr�rGrGrJ�stream_scalars�r�zAsyncConnection.stream_scalars�1GeneratorStartableContext[AsyncScalarResult[Any]]cCr�rXrGr�rGrGrJr��r��%AsyncIterator[AsyncScalarResult[Any]]c	CsV�|j|||d�4IdH�}|��VWd�IdHdS1IdHs$wYdS)afExecute a statement and return an awaitable yielding a
        :class:`_asyncio.AsyncScalarResult` object.

        E.g.::

            result = await conn.stream_scalars(stmt)
            async for scalar in result:
                print(f"{scalar}")

        This method is shorthand for invoking the
        :meth:`_engine.AsyncResult.scalars` method after invoking the
        :meth:`_engine.Connection.stream` method.  Parameters are equivalent.

        The :meth:`.AsyncConnection.stream_scalars`
        method supports optional context manager use against the
        :class:`.AsyncScalarResult` object, as in::

            async with conn.stream_scalars(stmt) as result:
                async for scalar in result:
                    print(f"{scalar}")

        In the above pattern, the :meth:`.AsyncScalarResult.close` method is
        invoked unconditionally, even if the iterator is interrupted by an
        exception throw.  Context manager use remains optional, however,
        and the function may be called in either an ``async with fn():`` or
        ``await fn()`` style.

        .. versionadded:: 2.0.0b3 added context manager support

        :return: an awaitable object that will yield an
         :class:`_asyncio.AsyncScalarResult` object.

        .. versionadded:: 1.4.24

        .. seealso::

            :meth:`.AsyncConnection.stream`

        r�N)r�r�r�rGrGrJr��s�0�.��fn�)Callable[Concatenate[Connection, _P], _T]�arg�_P.argsr<�	_P.kwargsr8c�s&�t||jg|�Rddi|��IdHS)aa	Invoke the given synchronous (i.e. not async) callable,
        passing a synchronous-style :class:`_engine.Connection` as the first
        argument.

        This method allows traditional synchronous SQLAlchemy functions to
        run within the context of an asyncio application.

        E.g.::

            def do_something_with_core(conn: Connection, arg1: int, arg2: str) -> str:
                """A synchronous function that does not require awaiting

                :param conn: a Core SQLAlchemy Connection, used synchronously

                :return: an optional return value is supported

                """
                conn.execute(some_table.insert().values(int_col=arg1, str_col=arg2))
                return "success"


            async def do_something_async(async_engine: AsyncEngine) -> None:
                """an async function that uses awaiting"""

                async with async_engine.begin() as async_conn:
                    # run do_something_with_core() with a sync-style
                    # Connection, proxied into an awaitable
                    return_code = await async_conn.run_sync(
                        do_something_with_core, 5, "strval"
                    )
                    print(return_code)

        This method maintains the asyncio event loop all the way through
        to the database connection by running the given callable in a
        specially instrumented greenlet.

        The most rudimentary use of :meth:`.AsyncConnection.run_sync` is to
        invoke methods such as :meth:`_schema.MetaData.create_all`, given
        an :class:`.AsyncConnection` that needs to be provided to
        :meth:`_schema.MetaData.create_all` as a :class:`_engine.Connection`
        object::

            # run metadata.create_all(conn) with a sync-style Connection,
            # proxied into an awaitable
            with async_engine.begin() as conn:
                await conn.run_sync(metadata.create_all)

        .. note::

            The provided callable is invoked inline within the asyncio event
            loop, and will block on traditional IO calls.  IO within this
            callable should only call into SQLAlchemy's asyncio database
            APIs which will be properly adapted to the greenlet context.

        .. seealso::

            :meth:`.AsyncSession.run_sync`

            :ref:`session_run_sync`

        r�FN)r#r�)rr�r�r<rGrGrJ�run_sync3s�D����zAsyncConnection.run_sync�%Generator[Any, None, AsyncConnection]cCs|����SrX)r��	__await__r�rGrGrJr�{szAsyncConnection.__await__�type_r]�	tracebackc�s$�t�|���}t�|�IdHdSrX)r�r�r�r�)rr�r]r�r�rGrGrJ�	__aexit__~s�zAsyncConnection.__aexit__cCr�)z�Return True if this connection is closed.

        .. container:: class_bases

            Proxied for the :class:`_engine.Connection` class
            on behalf of the :class:`_asyncio.AsyncConnection` class.

        )r�rsr�rGrGrJrs�szAsyncConnection.closedcCr�)aTReturn True if this connection was invalidated.

        .. container:: class_bases

            Proxied for the :class:`_engine.Connection` class
            on behalf of the :class:`_asyncio.AsyncConnection` class.

        This does not indicate whether or not the connection was
        invalidated at the pool level, however


        )r�rtr�rGrGrJrt��zAsyncConnection.invalidatedr-cCr�)z�Proxy for the :attr:`_engine.Connection.dialect` attribute
        on behalf of the :class:`_asyncio.AsyncConnection` class.

        �r�rDr�rGrGrJrD��zAsyncConnection.dialect�attrcC�||j_dSrXr��rrrGrGrJrD��cCr�)a�The initial-connection time isolation level associated with the
        :class:`_engine.Dialect` in use.

        .. container:: class_bases

            Proxied for the :class:`_engine.Connection` class
            on behalf of the :class:`_asyncio.AsyncConnection` class.

        This value is independent of the
        :paramref:`.Connection.execution_options.isolation_level` and
        :paramref:`.Engine.execution_options.isolation_level` execution
        options, and is determined by the :class:`_engine.Dialect` when the
        first connection is created, by performing a SQL query against the
        database for the current isolation level before any additional commands
        have been emitted.

        Calling this accessor does not invoke any new SQL queries.

        .. seealso::

            :meth:`_engine.Connection.get_isolation_level`
            - view current actual isolation level

            :paramref:`_sa.create_engine.isolation_level`
            - set per :class:`_engine.Engine` isolation level

            :paramref:`.Connection.execution_options.isolation_level`
            - set per :class:`_engine.Connection` isolation level


        )r�rur�rGrGrJru�s"z'AsyncConnection.default_isolation_levelrX)r|r>r{r})r�rr=ry�F)r�r�r=ryrm�r=r3)r=r4)r=r)r=r�)r�r�r=r�)r=r.�r=r�)r=r�)r�r�r�rVr�r.r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr=ry)r�rr=ry�r=r�)NN)r�rVr�r�r�r�r=r�)r�r�r�r�r�r�r=r�)r�r5r�r�r�r�r=r�)r�r5r�r�r�r�r=r�)r�r�r�r�r�r�r=r�)r�r5r�r�r�r�r=r�)r�r�r�r�r�r�r=r�)r�r5r�r�r�r�r=r)r�r�r�r�r�r�r=r�)r�r5r�r�r�r�r=r�)r�r�r�r�r�r�r=r�)r�r5r�r�r�r�r=r�)r�r5r�r�r�r�r=r�)r�r�r�r�r<r�r=r8)r=r��r�rr]rr�rr=r�rK�r=r-�rr-r=r�).rnrorp�__doc__rqr��__annotations__rrr�r��propertyr�r�r�ro_non_memoized_propertyr�r�r�r�r�r�r�r�r�r�r
r�r�r�r�r�r�r�rr�r�r�r�r�r�r�rsrtrD�setterrurGrGrGrJry�s
	�	�



�




�




	�������B������/������������������
4
H
	ryz:class:`_engine.Engine`z:class:`_asyncio.AsyncEngine`)�clear_compiled_cache�update_execution_options�get_execution_options)r:�poolrDrz�name�driver�echoc@sxeZdZUdZdZeZded<ded<	dMdd�Ze	j
dNd	d
��ZedOdd
��Z
ejdPdd��ZdQdd�ZdRdd�Zedddddd�dSd%d&��ZedTd'd&��ZdTd(d&�ZdUdVd-d.�ZdWd/d0�ZdXd1d2�ZdYd4d5�ZedZd7d8��Zejd[d:d8��Zed\d<d=��Zejd]d>d=��Zed^d@dA��Zejd_dBdA��Zed`dCdD��Zed`dEdF��Zed`dGdH��Z ed`dIdJ��Z!e!jdadKdJ��Z!dLS)br>aQAn asyncio proxy for a :class:`_engine.Engine`.

    :class:`_asyncio.AsyncEngine` is acquired using the
    :func:`_asyncio.create_async_engine` function::

        from sqlalchemy.ext.asyncio import create_async_engine

        engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname")

    .. versionadded:: 1.4

    rIzType[AsyncConnection]�_connection_clsrcCs.|jjst�d|jj�d���|�|�|_dS)NzFThe asyncio extension requires an async driver to be used. The loaded z is not async.)rD�is_asyncrr�rr~rI)rrIrGrGrJr�s��zAsyncEngine.__init__r=cCs|jSrX)rIr�rGrGrJr�szAsyncEngine._proxiedr�cCst|�SrX)r>r�rGrGrJr��z(AsyncEngine._regenerate_proxy_for_target�AsyncIterator[AsyncConnection]c
Cs��|��}|4IdH�-|��4IdH�|VWd�IdHn1IdHs(wYWd�IdHdS1IdHs>wYdS)a�Return a context manager which when entered will deliver an
        :class:`_asyncio.AsyncConnection` with an
        :class:`_asyncio.AsyncTransaction` established.

        E.g.::

            async with async_engine.begin() as conn:
                await conn.execute(
                    text("insert into table (x, y, z) values (1, 2, 3)")
                )
                await conn.execute(text("my_special_procedure(5)"))

        N)rFr�)rr�rGrGrJr�s�*�.�zAsyncEngine.beginrycCs
|�|�S)aReturn an :class:`_asyncio.AsyncConnection` object.

        The :class:`_asyncio.AsyncConnection` will procure a database
        connection from the underlying connection pool when it is entered
        as an async context manager::

            async with async_engine.connect() as conn:
                result = await conn.execute(select(user_table))

        The :class:`_asyncio.AsyncConnection` may also be started outside of a
        context manager by invoking its :meth:`_asyncio.AsyncConnection.start`
        method.

        )rr�rGrGrJrF,�
zAsyncEngine.connectr3c�s�t|jj�IdHS)zReturn a "raw" DBAPI connection from the connection pool.

        .. seealso::

            :ref:`dbapi_connections`

        N)r#rI�raw_connectionr�rGrGrJr>s�zAsyncEngine.raw_connection.)r�r�r�r�r�r�r�r�rVr�r.r�r�r�r�r�rcKr�rXrG)rr�r�r�r�r�r�rGrGrJr�Hs
zAsyncEngine.execution_optionscKr�rXrGr�rGrGrJr�T�cKst|jjdi|���S)aReturn a new :class:`_asyncio.AsyncEngine` that will provide
        :class:`_asyncio.AsyncConnection` objects with the given execution
        options.

        Proxied from :meth:`_engine.Engine.execution_options`.  See that
        method for details.

        NrG)r>rIr�r�rGrGrJr�Ws
Tr�r�r�c�s�t|jj|d�IdHdS)aEDispose of the connection pool used by this
        :class:`_asyncio.AsyncEngine`.

        :param close: if left at its default of ``True``, has the
         effect of fully closing all **currently checked in**
         database connections.  Connections that are still checked out
         will **not** be closed, however they will no longer be associated
         with this :class:`_engine.Engine`,
         so when they are closed individually, eventually the
         :class:`_pool.Pool` which they are associated with will
         be garbage collected and they will be closed out fully, if
         not already closed on checkin.

         If set to ``False``, the previous connection pool is de-referenced,
         and otherwise not touched in any way.

        .. seealso::

            :meth:`_engine.Engine.dispose`

        r�N)r#rI�dispose)rr�rGrGrJrcs�zAsyncEngine.disposecCr�)a-Clear the compiled cache associated with the dialect.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class on
            behalf of the :class:`_asyncio.AsyncEngine` class.

        This applies **only** to the built-in cache that is established
        via the :paramref:`_engine.create_engine.query_cache_size` parameter.
        It will not impact any dictionary caches that were passed via the
        :paramref:`.Connection.execution_options.compiled_cache` parameter.

        .. versionadded:: 1.4


        )r�rr�rGrGrJr�s
z AsyncEngine.clear_compiled_cachecKs|jjdi|��S)a�Update the default execution_options dictionary
        of this :class:`_engine.Engine`.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class on
            behalf of the :class:`_asyncio.AsyncEngine` class.

        The given keys/values in \**opt are added to the
        default execution options that will be used for
        all connections.  The initial contents of this dictionary
        can be sent via the ``execution_options`` parameter
        to :func:`_sa.create_engine`.

        .. seealso::

            :meth:`_engine.Connection.execution_options`

            :meth:`_engine.Engine.execution_options`


        NrG)r�rr�rGrGrJr�sz$AsyncEngine.update_execution_optionsr*cCr�)aUGet the non-SQL options which will take effect during execution.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class on
            behalf of the :class:`_asyncio.AsyncEngine` class.

        .. versionadded: 1.3

        .. seealso::

            :meth:`_engine.Engine.execution_options`

        )r�rr�rGrGrJr�rz!AsyncEngine.get_execution_optionsr1cCr�)zzProxy for the :attr:`_engine.Engine.url` attribute
        on behalf of the :class:`_asyncio.AsyncEngine` class.

        �r�r:r�rGrGrJr:�rzAsyncEngine.urlrcCrrXr rrGrGrJr:�rr2cCr�)z{Proxy for the :attr:`_engine.Engine.pool` attribute
        on behalf of the :class:`_asyncio.AsyncEngine` class.

        �r�rr�rGrGrJr�rzAsyncEngine.poolcCrrXr!rrGrGrJr�rr-cCr�)z~Proxy for the :attr:`_engine.Engine.dialect` attribute
        on behalf of the :class:`_asyncio.AsyncEngine` class.

        r�r�rGrGrJrD�rzAsyncEngine.dialectcCrrXr�rrGrGrJrD�rcCr�)aIReturns this :class:`.Engine`.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class
            on behalf of the :class:`_asyncio.AsyncEngine` class.

        Used for legacy schemes that accept :class:`.Connection` /
        :class:`.Engine` objects within the same variable.


        )r�rzr�rGrGrJrz�r�zAsyncEngine.enginecCr�)aString name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
        in use by this :class:`Engine`.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class
            on behalf of the :class:`_asyncio.AsyncEngine` class.


        )r�rr�rGrGrJr��
zAsyncEngine.namecCr�)aDriver name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
        in use by this :class:`Engine`.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class
            on behalf of the :class:`_asyncio.AsyncEngine` class.


        )r�rr�rGrGrJrr"zAsyncEngine.drivercCr�)a3When ``True``, enable log output for this element.

        .. container:: class_bases

            Proxied for the :class:`_engine.Engine` class
            on behalf of the :class:`_asyncio.AsyncEngine` class.

        This has the effect of setting the Python logging level for the namespace
        of this element's class and object reference.  A value of boolean ``True``
        indicates that the loglevel ``logging.INFO`` will be set for the logger,
        whereas the string value ``debug`` will set the loglevel to
        ``logging.DEBUG``.

        �r�rr�rGrGrJrszAsyncEngine.echocCrrXr#rrGrGrJr*rN)rIr)r=r)r�rr=r>)r=r)r=ryr)r�r�r�rVr�r.r�r�r�r�r�rr=r>)r�rr=r>)T)r�r�r=r�r)r�rr=r�)r=r*)r=r1)rr1r=r�)r=r2)rr2r=r�r
rrK)rrr=r�)"rnrorprrqryrr
r�rrr�rrr��
contextlib�asynccontextmanagerr�rFrr
r�rrrrrr:rrrDrzrrrrGrGrGrJr>�sf






�



c@s�eZdZUdZdZded<ded<ded<d(d)d
d�Zed*dd��Ze	j
d+dd��Zed,dd��Z
ed,dd��Zd-dd�Zd-dd�Zd-dd�Zd(d.dd �Zd/d%d&�Zd'S)0r�z4An asyncio proxy for a :class:`_engine.Transaction`.�r��sync_transactionr�zOptional[Transaction]r'ryr�r�r�FcCs||_d|_||_dSrXr&)rr�r�rGrGrJr�<s
zAsyncTransaction.__init__r�r!r=cCsP|j}|}t|t�}t�|�}|dusJ�|�|�}||_|�|�|_||_|SrX)	r��
isinstancer ryr��__new__r~r'r�)rkr�r{r'r��async_connection�objrGrGrJr�As
�
z-AsyncTransaction._regenerate_proxy_for_targetcCr�rX)r'r�r�rGrGrJr�Tr�zAsyncTransaction._proxiedcCr�rX)r��is_validr�rGrGrJr,ZrzAsyncTransaction.is_validcCr�rX)r��	is_activer�rGrGrJr-^rzAsyncTransaction.is_activer�c�r�)a@Close this :class:`.AsyncTransaction`.

        If this transaction is the base transaction in a begin/commit
        nesting, the transaction will rollback().  Otherwise, the
        method returns.

        This is used to cancel a Transaction without affecting the scope of
        an enclosing transaction.

        Nr�r�rGrGrJr�bs�zAsyncTransaction.closec�r�)z*Roll back this :class:`.AsyncTransaction`.Nr�r�rGrGrJr�os�zAsyncTransaction.rollbackc�r�)z'Commit this :class:`.AsyncTransaction`.Nr�r�rGrGrJr�ss�zAsyncTransaction.commitr�c�s@�|�t|jr|jjjn|jjj�IdH�|_|r|j��|S)z{Start this :class:`_asyncio.AsyncTransaction` object's context
        outside of using a Python ``with:`` block.

        N)	r~r#r�r�r�r�r�r'�	__enter__r�rGrGrJr�xs����
zAsyncTransaction.startr�rr]r�c�s�t|jj|||�IdHdSrX)r#r��__exit__)rr�r]r�rGrGrJr��s�zAsyncTransaction.__aexit__Nr)r�ryr�r�)r�r!r=r�)r=r!rr)r�r�r=r�r	)rnrorprrqr
r�rrr�rrr�rr,r-r�r�r�r�r�rGrGrGrJr�1s(



r�r|rcCr�rXrG�r|rGrGrJ�_get_sync_engine_or_connection�rr1rcCr�rXrGr0rGrGrJr1�s�#Union[AsyncEngine, AsyncConnection]�Union[Engine, Connection]c
CsBt|t�r|jSz|jWSty }zt�d|�|�d}~ww)NzAsyncEngine expected, got %r)r(ryr�rI�AttributeErrorrr")r|�erGrGrJr1�s
�����subjectrcC�tjddd��)Nz�Inspection on an AsyncConnection is currently not supported. Please use ``run_sync`` to pass a callable where it's possible to call ``inspect`` on the passed connection.�xd3s��code�r�NoInspectionAvailable�r6rGrGrJ�_no_insp_for_async_conn_yet�s�r>cCr7)Nz�Inspection on an AsyncEngine is currently not supported. Please obtain a connection then use ``conn.run_sync`` to pass a callable where it's possible to call ``inspect`` on the passed connection.r8r9r;r=rGrGrJ�_no_insp_for_async_engine_xyet�s�r?)r:r;r<rr=r>)rR)rSrTrUrVrWrr=r>)r:r;rWrr=r2)r|r>r=r)r|ryr=r)r|r2r=r3)r6ryr=r)r6r>r=r)W�
__future__rr�r$�typingrrrrrrr	r
rrr
rr�rrM�baserrrrr�rrrrrrzrrrPrrer�engine.baser r!r"�util.concurrencyr#�util.typingr$r%�
engine.cursorr&�engine.interfacesr'r(r)r*r+r,r-r.r/�
engine.resultr0�
engine.urlr1rr2r3�sql._typingr4�sql.baser5�sql.selectabler6r7r8rQrdrfrg�create_proxy_methodsryr>r�r1�	_inspectsr>r?rGrGrGrJ�<module>s�
7�
�

�"�
N�\