SQLAlchemy 2.0.53__py3-none-any.whl → 2.1.0__py3-none-any.whl

sqlalchemy/__init__.py

@@ -47,9 +47,6 @@ from .engine import URL as URL
 from .inspection import inspect as inspect
 from .pool import AssertionPool as AssertionPool
 from .pool import AsyncAdaptedQueuePool as AsyncAdaptedQueuePool
-from .pool import (
-    FallbackAsyncAdaptedQueuePool as FallbackAsyncAdaptedQueuePool,
-)
 from .pool import NullPool as NullPool
 from .pool import Pool as Pool
 from .pool import PoolProxiedConnection as PoolProxiedConnection
@@ -60,29 +57,40 @@ from .pool import StaticPool as StaticPool
 from .schema import BaseDDLElement as BaseDDLElement
 from .schema import BLANK_SCHEMA as BLANK_SCHEMA
 from .schema import CheckConstraint as CheckConstraint
+from .schema import CheckFirst as CheckFirst
 from .schema import Column as Column
 from .schema import ColumnDefault as ColumnDefault
 from .schema import Computed as Computed
 from .schema import Constraint as Constraint
+from .schema import CreateTable as CreateTable
+from .schema import CreateTableAs as CreateTableAs
+from .schema import CreateView as CreateView
 from .schema import DDL as DDL
 from .schema import DDLElement as DDLElement
 from .schema import DefaultClause as DefaultClause
+from .schema import DropTable as DropTable
+from .schema import DropView as DropView
 from .schema import ExecutableDDLElement as ExecutableDDLElement
 from .schema import FetchedValue as FetchedValue
 from .schema import ForeignKey as ForeignKey
 from .schema import ForeignKeyConstraint as ForeignKeyConstraint
+from .schema import ForeignKeyTarget as ForeignKeyTarget
 from .schema import Identity as Identity
 from .schema import Index as Index
 from .schema import insert_sentinel as insert_sentinel
 from .schema import MetaData as MetaData
+from .schema import Named as Named
 from .schema import PrimaryKeyConstraint as PrimaryKeyConstraint
 from .schema import Sequence as Sequence
 from .schema import Table as Table
+from .schema import TypedColumns as TypedColumns
 from .schema import UniqueConstraint as UniqueConstraint
 from .sql import ColumnExpressionArgument as ColumnExpressionArgument
 from .sql import NotNullable as NotNullable
 from .sql import Nullable as Nullable
 from .sql import SelectLabelStyle as SelectLabelStyle
+from .sql.expression import aggregate_order_by as aggregate_order_by
+from .sql.expression import AggregateOrderBy as AggregateOrderBy
 from .sql.expression import Alias as Alias
 from .sql.expression import alias as alias
 from .sql.expression import AliasedReturnsRows as AliasedReturnsRows
@@ -127,6 +135,9 @@ from .sql.expression import Extract as Extract
 from .sql.expression import extract as extract
 from .sql.expression import false as false
 from .sql.expression import False_ as False_
+from .sql.expression import FrameClause as FrameClause
+from .sql.expression import FrameClauseType as FrameClauseType
+from .sql.expression import from_dml_column as from_dml_column
 from .sql.expression import FromClause as FromClause
 from .sql.expression import FromGrouping as FromGrouping
 from .sql.expression import func as func
@@ -171,6 +182,7 @@ from .sql.expression import nullsfirst as nullsfirst
 from .sql.expression import nullslast as nullslast
 from .sql.expression import Operators as Operators
 from .sql.expression import or_ as or_
+from .sql.expression import OrderByList as OrderByList
 from .sql.expression import outerjoin as outerjoin
 from .sql.expression import outparam as outparam
 from .sql.expression import Over as Over
@@ -195,6 +207,7 @@ from .sql.expression import TableClause as TableClause
 from .sql.expression import TableSample as TableSample
 from .sql.expression import tablesample as tablesample
 from .sql.expression import TableValuedAlias as TableValuedAlias
+from .sql.expression import TableValuedColumn as TableValuedColumn
 from .sql.expression import text as text
 from .sql.expression import TextAsFrom as TextAsFrom
 from .sql.expression import TextClause as TextClause
@@ -203,6 +216,8 @@ from .sql.expression import true as true
 from .sql.expression import True_ as True_
 from .sql.expression import try_cast as try_cast
 from .sql.expression import TryCast as TryCast
+from .sql.expression import TString as TString
+from .sql.expression import tstring as tstring
 from .sql.expression import Tuple as Tuple
 from .sql.expression import tuple_ as tuple_
 from .sql.expression import type_coerce as type_coerce
@@ -249,6 +264,7 @@ from .types import LargeBinary as LargeBinary
 from .types import NCHAR as NCHAR
 from .types import NUMERIC as NUMERIC
 from .types import Numeric as Numeric
+from .types import NumericCommon as NumericCommon
 from .types import NVARCHAR as NVARCHAR
 from .types import PickleType as PickleType
 from .types import REAL as REAL
@@ -269,7 +285,7 @@ from .types import Uuid as Uuid
 from .types import VARBINARY as VARBINARY
 from .types import VARCHAR as VARCHAR
 
-__version__ = "2.0.53"
+__version__ = "2.1.0"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/connectors/aioodbc.py

@@ -13,12 +13,9 @@ from typing import TYPE_CHECKING
 from .asyncio import AsyncAdapt_dbapi_connection
 from .asyncio import AsyncAdapt_dbapi_cursor
 from .asyncio import AsyncAdapt_dbapi_ss_cursor
-from .asyncio import AsyncAdaptFallback_dbapi_connection
 from .pyodbc import PyODBCConnector
-from .. import pool
-from .. import util
-from ..util.concurrency import await_fallback
-from ..util.concurrency import await_only
+from ..connectors.asyncio import AsyncAdapt_dbapi_module
+from ..util.concurrency import await_
 
 if TYPE_CHECKING:
     from ..engine.interfaces import ConnectArgsType
@@ -33,7 +30,7 @@ class AsyncAdapt_aioodbc_cursor(AsyncAdapt_dbapi_cursor):
         return self._cursor._impl.setinputsizes(*inputsizes)
 
         # how it's supposed to work
-        # return self.await_(self._cursor.setinputsizes(*inputsizes))
+        # return await_(self._cursor.setinputsizes(*inputsizes))
 
     @property
     def fast_executemany(self):
@@ -67,7 +64,7 @@ class AsyncAdapt_aioodbc_connection(AsyncAdapt_dbapi_connection):
         self._connection._conn.autocommit = value
 
     def ping(self, reconnect):
-        return self.await_(self._connection.ping(reconnect))
+        return await_(self._connection.ping(reconnect))
 
     def add_output_converter(self, *arg, **kw):
         self._connection.add_output_converter(*arg, **kw)
@@ -104,14 +101,9 @@ class AsyncAdapt_aioodbc_connection(AsyncAdapt_dbapi_connection):
             super().close()
 
 
-class AsyncAdaptFallback_aioodbc_connection(
-    AsyncAdaptFallback_dbapi_connection, AsyncAdapt_aioodbc_connection
-):
-    __slots__ = ()
-
-
-class AsyncAdapt_aioodbc_dbapi:
+class AsyncAdapt_aioodbc_dbapi(AsyncAdapt_dbapi_module):
     def __init__(self, aioodbc, pyodbc):
+        super().__init__(aioodbc, dbapi_module=pyodbc)
         self.aioodbc = aioodbc
         self.pyodbc = pyodbc
         self.paramstyle = pyodbc.paramstyle
@@ -146,19 +138,14 @@ class AsyncAdapt_aioodbc_dbapi:
             setattr(self, name, getattr(self.pyodbc, name))
 
     def connect(self, *arg, **kw):
-        async_fallback = kw.pop("async_fallback", False)
         creator_fn = kw.pop("async_creator_fn", self.aioodbc.connect)
 
-        if util.asbool(async_fallback):
-            return AsyncAdaptFallback_aioodbc_connection(
-                self,
-                await_fallback(creator_fn(*arg, **kw)),
-            )
-        else:
-            return AsyncAdapt_aioodbc_connection(
+        return await_(
+            AsyncAdapt_aioodbc_connection.create(
                 self,
-                await_only(creator_fn(*arg, **kw)),
+                creator_fn(*arg, **kw),
             )
+        )
 
 
 class aiodbcConnector(PyODBCConnector):
@@ -180,14 +167,5 @@ class aiodbcConnector(PyODBCConnector):
 
         return (), kw
 
-    @classmethod
-    def get_pool_class(cls, url):
-        async_fallback = url.query.get("async_fallback", False)
-
-        if util.asbool(async_fallback):
-            return pool.FallbackAsyncAdaptedQueuePool
-        else:
-            return pool.AsyncAdaptedQueuePool
-
     def get_driver_connection(self, connection):
         return connection._connection

sqlalchemy/connectors/asyncio.py

@@ -12,23 +12,25 @@ from __future__ import annotations
 import asyncio
 import collections
 import sys
+import types
 from typing import Any
 from typing import AsyncIterator
+from typing import Awaitable
 from typing import Deque
 from typing import Iterator
 from typing import NoReturn
 from typing import Optional
+from typing import Protocol
 from typing import Sequence
 from typing import Tuple
 from typing import Type
 from typing import TYPE_CHECKING
 
 from ..engine import AdaptedConnection
+from ..exc import EmulatedDBAPIException
 from ..util import EMPTY_DICT
-from ..util.concurrency import await_fallback
-from ..util.concurrency import await_only
+from ..util.concurrency import await_
 from ..util.concurrency import in_greenlet
-from ..util.typing import Protocol
 
 if TYPE_CHECKING:
     from ..engine.interfaces import _DBAPICursorDescription
@@ -124,13 +126,38 @@ class AsyncAdapt_dbapi_module:
 
         def __getattr__(self, key: str) -> Any: ...
 
+    def __init__(
+        self,
+        driver: types.ModuleType,
+        *,
+        dbapi_module: types.ModuleType | None = None,
+    ):
+        self.driver = driver
+        self.dbapi_module = dbapi_module
+
+    @property
+    def exceptions_module(self) -> types.ModuleType:
+        """Return the module which we think will have the exception hierarchy.
+
+        For an asyncio driver that wraps a plain DBAPI like aiomysql,
+        aioodbc, aiosqlite, etc. these exceptions will be from the
+        dbapi_module.  For a "pure" driver like asyncpg these will come
+        from the driver module.
+
+        .. versionadded:: 2.1
+
+        """
+        if self.dbapi_module is not None:
+            return self.dbapi_module
+        else:
+            return self.driver
+
 
 class AsyncAdapt_dbapi_cursor:
     server_side = False
     __slots__ = (
         "_adapt_connection",
         "_connection",
-        "await_",
         "_cursor",
         "_rows",
         "_soft_closed_memoized",
@@ -147,8 +174,6 @@ class AsyncAdapt_dbapi_cursor:
         self._adapt_connection = adapt_connection
         self._connection = adapt_connection._connection
 
-        self.await_ = adapt_connection.await_
-
         cursor = self._make_new_cursor(self._connection)
         self._cursor = self._aenter_cursor(cursor)
         self._soft_closed_memoized = EMPTY_DICT
@@ -156,7 +181,10 @@ class AsyncAdapt_dbapi_cursor:
             self._rows = collections.deque()
 
     def _aenter_cursor(self, cursor: AsyncIODBAPICursor) -> AsyncIODBAPICursor:
-        return self.await_(cursor.__aenter__())  # type: ignore[no-any-return]
+        try:
+            return await_(cursor.__aenter__())  # type: ignore[no-any-return]
+        except Exception as error:
+            self._adapt_connection._handle_exception(error)
 
     def _make_new_cursor(
         self, connection: AsyncIODBAPIConnection
@@ -217,7 +245,7 @@ class AsyncAdapt_dbapi_cursor:
         if not self._awaitable_cursor_close:
             self._cursor.close()  # type: ignore[unused-coroutine]
         elif in_greenlet():
-            self.await_(self._cursor.close())
+            await_(self._cursor.close())
 
     def execute(
         self,
@@ -225,7 +253,7 @@ class AsyncAdapt_dbapi_cursor:
         parameters: Optional[_DBAPISingleExecuteParams] = None,
     ) -> Any:
         try:
-            return self.await_(self._execute_async(operation, parameters))
+            return await_(self._execute_async(operation, parameters))
         except Exception as error:
             self._adapt_connection._handle_exception(error)
 
@@ -235,7 +263,7 @@ class AsyncAdapt_dbapi_cursor:
         seq_of_parameters: _DBAPIMultiExecuteParams,
     ) -> Any:
         try:
-            return self.await_(
+            return await_(
                 self._executemany_async(operation, seq_of_parameters)
             )
         except Exception as error:
@@ -263,18 +291,16 @@ class AsyncAdapt_dbapi_cursor:
             return await self._cursor.executemany(operation, seq_of_parameters)
 
     def nextset(self) -> None:
-        self.await_(self._cursor.nextset())
+        await_(self._cursor.nextset())
         if self._cursor.description and not self.server_side:
-            self._rows = collections.deque(
-                self.await_(self._cursor.fetchall())
-            )
+            self._rows = collections.deque(await_(self._cursor.fetchall()))
 
     def setinputsizes(self, *inputsizes: Any) -> None:
         # NOTE: this is overridden in aioodbc due to
         # see https://github.com/aio-libs/aioodbc/issues/451
         # right now
 
-        return self.await_(self._cursor.setinputsizes(*inputsizes))
+        return await_(self._cursor.setinputsizes(*inputsizes))
 
     def __enter__(self) -> Self:
         return self
@@ -310,23 +336,23 @@ class AsyncAdapt_dbapi_ss_cursor(AsyncAdapt_dbapi_cursor):
 
     def close(self) -> None:
         if self._cursor is not None:
-            self.await_(self._cursor.close())
-            self._cursor = None  # type: ignore
+            await_(self._cursor.close())
+            self._cursor = None  # type: ignore[assignment]
 
     def fetchone(self) -> Optional[Any]:
-        return self.await_(self._cursor.fetchone())
+        return await_(self._cursor.fetchone())
 
     def fetchmany(self, size: Optional[int] = None) -> Any:
-        return self.await_(self._cursor.fetchmany(size=size))
+        return await_(self._cursor.fetchmany(size=size))
 
     def fetchall(self) -> Sequence[Any]:
-        return self.await_(self._cursor.fetchall())
+        return await_(self._cursor.fetchall())
 
     def __iter__(self) -> Iterator[Any]:
         iterator = self._cursor.__aiter__()
         while True:
             try:
-                yield self.await_(iterator.__anext__())
+                yield await_(iterator.__anext__())
             except StopAsyncIteration:
                 break
 
@@ -335,12 +361,24 @@ class AsyncAdapt_dbapi_connection(AdaptedConnection):
     _cursor_cls = AsyncAdapt_dbapi_cursor
     _ss_cursor_cls = AsyncAdapt_dbapi_ss_cursor
 
-    await_ = staticmethod(await_only)
-
     __slots__ = ("dbapi", "_execute_mutex")
 
     _connection: AsyncIODBAPIConnection
 
+    @classmethod
+    async def create(
+        cls,
+        dbapi: Any,
+        connection_awaitable: Awaitable[AsyncIODBAPIConnection],
+        **kw: Any,
+    ) -> Self:
+        try:
+            connection = await connection_awaitable
+        except Exception as error:
+            cls._handle_exception_no_connection(dbapi, error)
+        else:
+            return cls(dbapi, connection, **kw)
+
     def __init__(self, dbapi: Any, connection: AsyncIODBAPIConnection):
         self.dbapi = dbapi
         self._connection = connection
@@ -362,31 +400,31 @@ class AsyncAdapt_dbapi_connection(AdaptedConnection):
         cursor.execute(operation, parameters)
         return cursor
 
-    def _handle_exception(self, error: Exception) -> NoReturn:
+    @classmethod
+    def _handle_exception_no_connection(
+        cls, dbapi: Any, error: Exception
+    ) -> NoReturn:
         exc_info = sys.exc_info()
 
         raise error.with_traceback(exc_info[2])
 
+    def _handle_exception(self, error: Exception) -> NoReturn:
+        self._handle_exception_no_connection(self.dbapi, error)
+
     def rollback(self) -> None:
         try:
-            self.await_(self._connection.rollback())
+            await_(self._connection.rollback())
         except Exception as error:
             self._handle_exception(error)
 
     def commit(self) -> None:
         try:
-            self.await_(self._connection.commit())
+            await_(self._connection.commit())
         except Exception as error:
             self._handle_exception(error)
 
     def close(self) -> None:
-        self.await_(self._connection.close())
-
-
-class AsyncAdaptFallback_dbapi_connection(AsyncAdapt_dbapi_connection):
-    __slots__ = ()
-
-    await_ = staticmethod(await_fallback)
+        await_(self._connection.close())
 
 
 class AsyncAdapt_terminate:
@@ -399,7 +437,7 @@ class AsyncAdapt_terminate:
             # in a greenlet; this is the connection was invalidated case.
             try:
                 # try to gracefully close; see #10717
-                self.await_(asyncio.shield(self._terminate_graceful_close()))  # type: ignore[attr-defined] # noqa: E501
+                await_(asyncio.shield(self._terminate_graceful_close()))
             except self._terminate_handled_exceptions() as e:
                 # in the case where we are recycling an old connection
                 # that may have already been disconnected, close() will
@@ -427,3 +465,12 @@ class AsyncAdapt_terminate:
     def _terminate_force_close(self) -> None:
         """Terminate the connection"""
         raise NotImplementedError
+
+
+class AsyncAdapt_Error(EmulatedDBAPIException):
+    """Provide for the base of DBAPI ``Error`` base class for dialects
+    that need to emulate the DBAPI exception hierarchy.
+
+    .. versionadded:: 2.1
+
+    """

sqlalchemy/connectors/pyodbc.py

@@ -15,7 +15,6 @@ from typing import List
 from typing import Optional
 from typing import Tuple
 from typing import Union
-from urllib.parse import unquote_plus
 
 from . import Connector
 from .. import ExecutionContext
@@ -73,7 +72,8 @@ class PyODBCConnector(Connector):
                 connect_args[param] = util.asbool(keys.pop(param))
 
         if "odbc_connect" in keys:
-            connectors = [unquote_plus(keys.pop("odbc_connect"))]
+            # (potential breaking change for issue #11250)
+            connectors = [keys.pop("odbc_connect")]
         else:
 
             def check_quote(token: str) -> str:
@@ -164,25 +164,14 @@ class PyODBCConnector(Connector):
         else:
             return False
 
-    def _dbapi_version(self) -> interfaces.VersionInfoType:
-        if not self.dbapi:
-            return ()
-        return self._parse_dbapi_version(self.dbapi.version)
-
-    def _parse_dbapi_version(self, vers: str) -> interfaces.VersionInfoType:
-        m = re.match(r"(?:py.*-)?([\d\.]+)(?:-(\w+))?", vers)
-        if not m:
-            return ()
-        vers_tuple: interfaces.VersionInfoType = tuple(
-            [int(x) for x in m.group(1).split(".")]
-        )
-        if m.group(2):
-            vers_tuple += (m.group(2),)
-        return vers_tuple
+    def retrieve_dbapi_version(
+        self, dbapi: interfaces.DBAPIModule
+    ) -> util.VersionInfo:
+        return util.parse_version_string(dbapi.version)
 
     def _get_server_version_info(
         self, connection: Connection
-    ) -> interfaces.VersionInfoType:
+    ) -> interfaces.ServerVersionInfoType:
         # NOTE: this function is not reliable, particularly when
         # freetds is in use.   Implement database-specific server version
         # queries.

sqlalchemy/dialects/__init__.py

@@ -43,7 +43,7 @@ def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
             module: Any = __import__(
                 "sqlalchemy.dialects.mysql.mariadb"
             ).dialects.mysql.mariadb
-            return module.loader(driver)  # type: ignore
+            return module.loader(driver)  # type: ignore[no-any-return]
         else:
             module = __import__("sqlalchemy.dialects.%s" % (dialect,)).dialects
             module = getattr(module, dialect)

sqlalchemy/dialects/mssql/__init__.py

@@ -8,6 +8,7 @@
 
 from . import aioodbc  # noqa
 from . import base  # noqa
+from . import mssqlpython  # noqa
 from . import pymssql  # noqa
 from . import pyodbc  # noqa
 from .base import BIGINT

sqlalchemy/dialects/mssql/aioodbc.py

@@ -42,12 +42,12 @@ styles are otherwise equivalent to those documented in the pyodbc section::
 
 from __future__ import annotations
 
+from .base import MSExecutionContext
 from .pyodbc import MSDialect_pyodbc
-from .pyodbc import MSExecutionContext_pyodbc
 from ...connectors.aioodbc import aiodbcConnector
 
 
-class MSExecutionContext_aioodbc(MSExecutionContext_pyodbc):
+class MSExecutionContext_aioodbc(MSExecutionContext):
     def create_server_side_cursor(self):
         return self._dbapi_connection.cursor(server_side=True)