SQLAlchemy 2.1.3__py3-none-any.whl → 2.1.4__py3-none-any.whl

sqlalchemy/__init__.py

@@ -285,7 +285,7 @@ from .types import Uuid as Uuid
 from .types import VARBINARY as VARBINARY
 from .types import VARCHAR as VARCHAR
 
-__version__ = "2.1.3"
+__version__ = "2.1.4"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/dialects/mssql/base.py

@@ -2098,6 +2098,13 @@ class MSSQLCompiler(compiler.SQLCompiler):
             self.process(binary.right, **kw),
         )
 
+    def visit_truediv_binary(self, binary, operator, **kw):
+        return (
+            self.process(binary.left, **kw)
+            + " / "
+            + f"({self.process(binary.right, **kw)} + 0.0)"
+        )
+
     def visit_true(self, expr, **kw):
         return "1"
 

sqlalchemy/dialects/postgresql/asyncpg.py

@@ -886,14 +886,18 @@ class AsyncAdapt_asyncpg_connection(
 
         assert self._transaction is None
         try:
-            self._transaction = self._connection.transaction(
+            transaction = self._connection.transaction(
                 isolation=self.isolation_level,
                 readonly=self.readonly,
                 deferrable=self.deferrable,
             )
-            await self._transaction.start()
+            await transaction.start()
         except Exception as error:
             self._handle_exception(error)
+        else:
+            # only track the transaction once BEGIN has succeeded; a
+            # transaction that failed to start has nothing to roll back
+            self._transaction = transaction
 
     async def _call_and_discard(self, fn: Callable[[], Awaitable[Any]]):
         try:

sqlalchemy/dialects/postgresql/named_types.py

@@ -339,6 +339,9 @@ class ENUM(NamedType, type_api.NativeForEmulated, sqltypes.Enum):
         kw.setdefault("_create_events", False)
         kw.setdefault("values_callable", impl.values_callable)
         kw.setdefault("omit_aliases", impl._omit_aliases)
+        kw.setdefault("sort_key_function", impl._sort_key_function)
+        kw.setdefault("create_constraint", impl.create_constraint)
+        kw.setdefault("length", impl.length)
         kw.setdefault("_adapted_from", impl)
 
         return cls(**kw)
@@ -514,6 +517,19 @@ class DOMAIN(NamedType, sqltypes.SchemaType):
     def __test_init__(cls):
         return cls("name", sqltypes.Integer)
 
+    def adapt(self, cls, **kw):
+        # the DOMAIN-specific arguments are keyword-only, which are not
+        # picked up by util.constructor_copy(); pass them explicitly so
+        # that copy(), to_metadata() and dialect adaptation retain them
+        kw.setdefault("collation", self.collation)
+        kw.setdefault("collation_schema", self.collation_schema)
+        kw.setdefault("default", self.default)
+        kw.setdefault("constraint_name", self.constraint_name)
+        kw.setdefault("not_null", self.not_null)
+        kw.setdefault("check", self.check)
+        kw.setdefault("create_type", self.create_type)
+        return super().adapt(cls, **kw)
+
 
 class CreateEnumType(schema._CreateDropBase):
     __visit_name__ = "create_enum_type"

sqlalchemy/engine/_result_cy.py

@@ -91,6 +91,37 @@ class _NoRow(Enum):
 _NO_ROW = _NoRow._NO_ROW
 
 
+def _list_map(
+    fn: Callable[[Any], _T], /
+) -> Callable[[Sequence[Any]], list[_T]]:
+    """Return a callable that applies ``fn`` to each element of a sequence,
+    returning a list.
+
+    This function serves to prevent a reference cycle between ``fn`` and
+    the closure scope of the function that defines it, when compiled with
+    Cython.
+
+    """
+    if cython.compiled:
+
+        def list_map(rows: Sequence[Any], /) -> list[_T]:
+            size: cython.Py_hash_t = len(rows)
+            i: cython.Py_ssize_t
+            result: list = PyList_New(size)
+            for i in range(size):
+                row: object = fn(rows[i])
+                Py_INCREF(row)
+                PyList_SET_ITEM(result, i, row)
+            return result
+
+    else:
+
+        def list_map(rows: Sequence[Any], /) -> list[_T]:
+            return [fn(row) for row in rows]
+
+    return list_map
+
+
 class BaseResultInternal(Generic[_R]):
     __slots__ = ()
 
@@ -245,22 +276,7 @@ class BaseResultInternal(Generic[_R]):
                 row = log_row(row)
             return row
 
-        if cython.compiled:
-
-            def many_rows(rows: Sequence[Any], /) -> list[Any]:
-                size: cython.Py_hash_t = len(rows)
-                i: cython.Py_ssize_t
-                result: list = PyList_New(size)
-                for i in range(size):
-                    row: object = single_row(rows[i])
-                    Py_INCREF(row)
-                    PyList_SET_ITEM(result, i, row)
-                return result
-
-        else:
-
-            def many_rows(rows: Sequence[Any], /) -> list[Any]:
-                return [single_row(row) for row in rows]
+        many_rows = _list_map(single_row)
 
         if flag == _FLAG_SCALAR_TO_TUPLE or has_log_row:
             # scalar-source rows have no tuple form; row logging requires
@@ -279,27 +295,12 @@ class BaseResultInternal(Generic[_R]):
                     input_row = tuple(input_row)
                 return input_row
 
-            if cython.compiled:
-
-                def interim_rows(rows: Sequence[Any], /) -> Sequence[Any]:
-                    size: cython.Py_hash_t = len(rows)
-                    i: cython.Py_ssize_t
-                    result: list = PyList_New(size)
-                    for i in range(size):
-                        row: object = single_interim_row(rows[i])
-                        Py_INCREF(row)
-                        PyList_SET_ITEM(result, i, row)
-                    return result
-
-            else:
-
-                def interim_rows(rows: Sequence[Any], /) -> Sequence[Any]:
-                    return [single_interim_row(row) for row in rows]
+            interim_rows = _list_map(single_interim_row)
 
         return single_row, many_rows, interim_rows  # type: ignore[return-value] # noqa: E501
 
     @HasMemoized_ro_memoized_attribute
-    def _iterator_getter(self) -> Callable[[], Iterator[_R]]:
+    def _iterator_getter(self) -> Callable[[Self], Iterator[_R]]:
         make_row = self._row_getter[0]
 
         post_creational_filter = self._post_creational_filter
@@ -308,7 +309,7 @@ class BaseResultInternal(Generic[_R]):
             uniques: set
             uniques, strategy = self._unique_strategy
 
-            def iterrows() -> Iterator[_R]:
+            def iterrows(self: Self) -> Iterator[_R]:
                 for raw_row in self._fetchiter_impl():
                     row = (
                         make_row(raw_row) if make_row is not None else raw_row
@@ -323,7 +324,7 @@ class BaseResultInternal(Generic[_R]):
 
         else:
 
-            def iterrows() -> Iterator[_R]:
+            def iterrows(self: Self) -> Iterator[_R]:
                 for raw_row in self._fetchiter_impl():
                     row = (
                         make_row(raw_row) if make_row is not None else raw_row
@@ -617,7 +618,7 @@ class BaseResultInternal(Generic[_R]):
             return row  # type: ignore[return-value]
 
     def _iter_impl(self) -> Iterator[_R]:
-        return self._iterator_getter()
+        return self._iterator_getter(self)
 
     def _next_impl(self) -> _R:
         row = self._onerow_getter(self)

sqlalchemy/engine/base.py

@@ -1257,30 +1257,33 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
 
         """
 
-        if self._transaction:
-            self._transaction.close()
-            skip_reset = True
-        else:
-            skip_reset = False
-
-        if self._dbapi_connection is not None:
-            conn = self._dbapi_connection
-
-            # as we just closed the transaction, close the connection
-            # pool connection without doing an additional reset
-            if skip_reset:
-                cast("_ConnectionFairy", conn)._close_special(
-                    transaction_reset=True
-                )
-            else:
-                conn.close()
-
-            # There is a slight chance that conn.close() may have
-            # triggered an invalidation here in which case
-            # _dbapi_connection would already be None, however usually
-            # it will be non-None here and in a "closed" state.
-            self._dbapi_connection = None
-        self.__can_reconnect = False
+        # if the rollback here raises, skip_reset stays False and the pool
+        # does its own reset of the connection, invalidating it if that
+        # fails also.  see #13657
+        skip_reset = False
+        try:
+            if self._transaction:
+                self._transaction.close()
+                skip_reset = True
+        finally:
+            if self._dbapi_connection is not None:
+                conn = self._dbapi_connection
+
+                # as we just closed the transaction, close the connection
+                # pool connection without doing an additional reset
+                if skip_reset:
+                    cast("_ConnectionFairy", conn)._close_special(
+                        transaction_reset=True
+                    )
+                else:
+                    conn.close()
+
+                # There is a slight chance that conn.close() may have
+                # triggered an invalidation here in which case
+                # _dbapi_connection would already be None, however usually
+                # it will be non-None here and in a "closed" state.
+                self._dbapi_connection = None
+            self.__can_reconnect = False
 
     # special case to handle mypy issue:
     # https://github.com/python/mypy/issues/20651

sqlalchemy/engine/characteristics.py

@@ -142,7 +142,7 @@ class LoggingTokenCharacteristic(ConnectionCharacteristic):
         if value:
             conn._message_formatter = lambda msg: "[%s] %s" % (value, msg)
         else:
-            del conn._message_formatter
+            conn._message_formatter = None
 
     def get_characteristic(
         self, dialect: Dialect, dbapi_conn: DBAPIConnection

sqlalchemy/engine/default.py

@@ -2137,6 +2137,15 @@ class DefaultExecutionContext(ExecutionContext):
         ):
             self._setup_out_parameters(result)
 
+        if not result._soft_closed and not result._metadata.returns_rows:
+            # no results, get rowcount (which requires open cursor on
+            # some drivers) and release the cursor.  this applies to all
+            # statements that don't return rows, including DML, text(),
+            # DDL and SAVEPOINT
+            if self._rowcount is None:
+                self._rowcount = self.cursor.rowcount
+            result._soft_close()
+
         self._soft_closed = result._soft_closed
 
         if yp:
@@ -2272,12 +2281,6 @@ class DefaultExecutionContext(ExecutionContext):
             # the rows have all been fetched however.
             assert result._metadata.returns_rows
 
-        elif not result._metadata.returns_rows:
-            # no results, get rowcount
-            # (which requires open cursor on some drivers)
-            if self._rowcount is None:
-                self._rowcount = self.cursor.rowcount
-            result._soft_close()
         elif self.isupdate or self.isdelete:
             if self._rowcount is None:
                 self._rowcount = self.cursor.rowcount

sqlalchemy/ext/mutable.py

@@ -840,6 +840,12 @@ class MutableDict(Mutable, Dict[_KT, _VT]):
         dict.update(self, *a, **kw)
         self.changed()
 
+    def __ior__(  # type: ignore[override,misc]
+        self, other: Any
+    ) -> MutableDict[_KT, _VT]:
+        self.update(other)
+        return self
+
     if TYPE_CHECKING:
 
         @overload
@@ -949,6 +955,11 @@ class MutableList(Mutable, List[_T]):
         self.extend(x)
         return self
 
+    def __imul__(self, n: SupportsIndex) -> MutableList[_T]:
+        list.__imul__(self, n)
+        self.changed()
+        return self
+
     def insert(self, i: SupportsIndex, x: _T) -> None:
         list.insert(self, i, x)
         self.changed()

sqlalchemy/orm/decl_base.py

@@ -67,6 +67,7 @@ from ..sql import expression
 from ..sql._annotated_cols import TypedColumns
 from ..sql.base import _NoArg
 from ..sql.schema import Column
+from ..sql.schema import MetaData
 from ..sql.schema import Table
 from ..util import topological
 from ..util.typing import _AnnotationScanType
@@ -80,7 +81,6 @@ if TYPE_CHECKING:
     from .decl_api import declared_attr
     from .instrumentation import ClassManager
     from ..sql.elements import NamedColumn
-    from ..sql.schema import MetaData
     from ..sql.selectable import FromClause
 
 _T = TypeVar("_T", bound=Any)
@@ -1525,7 +1525,9 @@ class _DeclarativeMapperConfig(_MapperConfig, _ClassScanAbstractConfig):
                 value = SynonymProperty(value.key)
                 setattr(cls, k, value)
 
-            if k in ("metadata", "registry"):
+            if k == "registry" or (
+                k == "metadata" and not isinstance(value, MetaData)
+            ):
                 noun = {
                     "metadata": "MetaData instance",
                     "registry": "Declarative class registry",

sqlalchemy/sql/compiler.py

@@ -3136,12 +3136,20 @@ class SQLCompiler(Compiled):
             self.process(element.aggregate_order_by, **kw),
         )
 
-    def visit_aggregate_strings_func(self, fn, *, use_function_name, **kw):
+    def visit_aggregate_strings_func(
+        self, fn, *, use_function_name=None, **kw
+    ):
         # aggreagate_order_by attribute is present if visit_function
         # gave us a Function with aggregate_orderby_inline() as the inner
         # contents
         order_by = getattr(fn.clauses, "aggregate_order_by", None)
 
+        if use_function_name is None:
+            raise exc.CompileError(
+                "%s dialect does not support the aggregate_strings function"
+                % self.dialect.name
+            )
+
         literal_exec = dict(kw)
         literal_exec["literal_execute"] = True
 
@@ -3338,7 +3346,7 @@ class SQLCompiler(Compiled):
             util.warn(
                 "Column-expression-level unary distinct() "
                 "should not be used outside of an aggregate "
-                "function. For general 'SELECT DISTINCT' support"
+                "function. For general 'SELECT DISTINCT' support "
                 "use select().distinct()."
             )
 
@@ -7092,6 +7100,11 @@ class StrSQLCompiler(SQLCompiler):
     def get_from_hint_text(self, table, text):
         return "[%s]" % text
 
+    def visit_aggregate_strings_func(self, fn, **kw):
+        return super().visit_aggregate_strings_func(
+            fn, use_function_name=fn.name, **kw
+        )
+
     def visit_regexp_match_op_binary(self, binary, operator, **kw):
         return self._generate_generic_binary(binary, " <regexp> ", **kw)
 

sqlalchemy/sql/dml.py

@@ -1263,6 +1263,10 @@ class Insert(ValuesBase, HasSyntaxExtensions[Literal["post_values"]]):
                 "_return_defaults_columns",
                 InternalTraversal.dp_clauseelement_tuple,
             ),
+            (
+                "_supplemental_returning",
+                InternalTraversal.dp_clauseelement_tuple,
+            ),
             ("_sort_by_parameter_order", InternalTraversal.dp_boolean),
         ]
         + HasPrefixes._has_prefixes_traverse_internals
@@ -1663,6 +1667,10 @@ class Update(
                 "_return_defaults_columns",
                 InternalTraversal.dp_clauseelement_tuple,
             ),
+            (
+                "_supplemental_returning",
+                InternalTraversal.dp_clauseelement_tuple,
+            ),
         ]
         + HasPrefixes._has_prefixes_traverse_internals
         + DialectKWArgs._dialect_kwargs_traverse_internals

sqlalchemy/sql/sqltypes.py

@@ -1939,6 +1939,7 @@ class Enum(String, SchemaType, Emulated, TypeEngine[Union[str, enum.Enum]]):
         kw.setdefault("create_constraint", self.create_constraint)
         kw.setdefault("length", self.length)
         kw.setdefault("omit_aliases", self._omit_aliases)
+        kw.setdefault("sort_key_function", self._sort_key_function)
         return kw
 
     def adapt_to_emulated(self, impltype, **kw):

sqlalchemy/testing/plugin/pytestplugin.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import argparse
 import collections
 from functools import update_wrapper
+import hashlib
 import inspect
 import itertools
 import operator
@@ -545,6 +546,31 @@ def pytest_runtest_call(item):
 _current_report = None
 
 
+_MAX_PARAM_ID_LEN = 60
+
+
+def _shorten_param_id(ident):
+    """shorten a very long parameter id for console / junit output.
+
+    keeps the leading portion of the string and appends a short digest of
+    the full value, so that ids remain stable and distinct.
+
+    """
+    if len(ident) <= _MAX_PARAM_ID_LEN:
+        return ident
+    digest = hashlib.md5(
+        ident.encode("utf-8"), usedforsecurity=False
+    ).hexdigest()[:8]
+    return f"{ident[:_MAX_PARAM_ID_LEN - 12]}...{digest}"
+
+
+def pytest_make_parametrize_id(config, val, argname):
+    if isinstance(val, str) and len(val) > _MAX_PARAM_ID_LEN:
+        return _shorten_param_id(val.encode("unicode_escape").decode("ascii"))
+    else:
+        return None
+
+
 def pytest_runtest_logreport(report):
     global _current_report
     if report.when == "call":
@@ -768,7 +794,8 @@ class PytestFixtureFunctions(plugin_base.FixtureFunctions):
                         parameters,
                         param_exclusions,
                         "-".join(
-                            comb_fn(getter(arg)) for getter, comb_fn in fns
+                            _shorten_param_id(comb_fn(getter(arg)))
+                            for getter, comb_fn in fns
                         ),
                     )
                 )

sqlalchemy/testing/profiling.py

@@ -119,7 +119,9 @@ class ProfileStatsFile:
     def platform_key(self) -> PlatformKey:
         db = config.db
         assert db is not None, "no database configured"
+        return self.platform_key_for(db)
 
+    def platform_key_for(self, db: Any) -> PlatformKey:
         dbapi_flags = []
         if db.dialect.is_async:
             dbapi_flags.append("async")
@@ -144,6 +146,27 @@ class ProfileStatsFile:
             cextensions=has_compiled_ext(),
         )
 
+    def has_platform(self, db: Any) -> bool:
+        """Return True if profiling tests should run against the given
+        engine.
+
+        This is the case when the profile file has counts for at least
+        one test on the engine's platform, or when profiles are being
+        written.  Used to keep profiling test classes from being generated
+        at all for drivers / interpreters that would only have each
+        test skip from within :func:`.count_functions`, after the class
+        has already run its fixture setup.
+
+        """
+        if self.write:
+            return True
+
+        platform_key = self.platform_key_for(db)
+        return any(
+            platform_key in self.profiles.platforms_for(test_key)
+            for test_key in self.profiles.test_keys()
+        )
+
     def has_stats(self) -> bool:
         return (
             self.profiles.counts_for(_current_test, self.platform_key)

sqlalchemy/testing/requirements.py

@@ -1271,6 +1271,11 @@ class SuiteRequirements(Requirements):
         to represent very large values."""
         return exclusions.open()
 
+    @property
+    def float_cast(self):
+        """target backend supports CAST to a FLOAT type"""
+        return exclusions.open()
+
     @property
     def precision_numerics_many_significant_digits(self):
         """target backend supports values with many digits on both sides,

sqlalchemy/testing/suite/test_select.py

@@ -1646,6 +1646,12 @@ class LikeFunctionsTest(fixtures.TablesTest):
 
 
 class ComputedColumnTest(fixtures.TablesTest):
+    """This test uses Computed without specifying the persisted mode.
+    On some postgresql version the compiler may raise a warning.
+    Use `warns_if` in the computed_columns requirement to catch the warning
+    conditionally on the postgresql version.
+    """
+
     __sparse_driver_backend__ = True
     __requires__ = ("computed_columns",)
 

sqlalchemy/testing/suite/test_types.py

@@ -34,6 +34,7 @@ from ... import Date
 from ... import DateTime
 from ... import Enum
 from ... import Float
+from ... import func
 from ... import Integer
 from ... import Interval
 from ... import JSON
@@ -1120,6 +1121,80 @@ class TrueDivTest(fixtures.TestBase):
             1,
         )
 
+    @testing.combinations(
+        ("typed", lambda divisor: divisor),
+        ("untyped_function", lambda divisor: func.nullif(divisor, 0)),
+        id_="ia",
+        argnames="wrap_divisor",
+    )
+    @testing.combinations(
+        (
+            "float",
+            "7.0",
+            "3.5",
+            Float(),
+            "2",
+            testing.requires.float_cast,
+        ),
+        ("numeric_whole_number", "1", "2.00", Numeric(10, 2), "0.5"),
+        (
+            "numeric_many_decimals",
+            "5.02797279921331664759",
+            "0.71828182845904523537",
+            Numeric(22, 20),
+            "7",
+            (
+                testing.requires.precision_numerics_many_significant_digits
+            ).as_skips(),
+        ),
+        (
+            "numeric_tiny_divisor",
+            "0.00000000000049382716",
+            "0.00000000000012345679",
+            Numeric(38, 20),
+            "4",
+        ),
+        (
+            "numeric_38_digit_divisor",
+            "30000000000000000000000000000000000000",
+            "10000000000000000000000000000000000000",
+            Numeric(38, 0),
+            "3",
+        ),
+        id_="iaaaa",
+        argnames="left, right, type_, expected",
+    )
+    def test_truediv_divisor(
+        self, connection, wrap_divisor, left, right, type_, expected
+    ):
+        """test #13631
+
+        each pair of operands is divided with the divisor's type visible to
+        SQLAlchemy ("typed") and hidden behind a function of unknown type
+        ("untyped_function").  The operand pairs each rule out an approach
+        to forcing true division that loses precision on some backend:
+
+        * float - a bare CAST(x AS NUMERIC) truncates 3.5 on SQL Server,
+          where NUMERIC means NUMERIC(18, 0)
+        * numeric_whole_number - SQLite stores 2.00 as the integer 2, so a
+          CAST to NUMERIC alone gives integer division
+        * numeric_many_decimals - CAST to FLOAT gives 7.000000000000001.
+          skipped rather than xfailed on backends without decimal
+          arithmetic such as SQLite, where whether the result comes out
+          as 7 depends on how the platform parses the literals to floats
+        * numeric_tiny_divisor - on SQL Server, multiplying a
+          NUMERIC(38, 20) by 1.0 reduces the scale and rounds the divisor
+        * numeric_38_digit_divisor - on SQL Server, multiplying a
+          NUMERIC(38, 0) by 1.0 overflows
+
+        """
+        expr = cast(literal_column(left), type_) / wrap_divisor(
+            cast(literal_column(right), type_)
+        )
+        result = connection.scalar(select(expr))
+
+        eq_(decimal.Decimal(str(result)), decimal.Decimal(expected))
+
 
 class NumericTest(_LiteralRoundTripFixture, fixtures.TestBase):
     __backend__ = True

{sqlalchemy-2.1.3.dist-info → sqlalchemy-2.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SQLAlchemy
-Version: 2.1.3
+Version: 2.1.4
 Summary: Database Abstraction Library
 Author-email: Mike Bayer <mike_mp@zzzcomputing.com>
 License-Expression: MIT

{sqlalchemy-2.1.3.dist-info → sqlalchemy-2.1.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlalchemy/__init__.py,sha256=qa3skGcwWR4Z4U7px2QG0OA-nKAGNHLwsJ9q_9k52AI,13562
+sqlalchemy/__init__.py,sha256=_uCHzwTy6ReaEDykCpWE3XmTA1iJqz7Xej7ma48rhS8,13562
 sqlalchemy/events.py,sha256=vEDW04X_PMhMw5y0_95tbEzht3wua8_gnkMBJstYNRw,525
 sqlalchemy/exc.py,sha256=CKyzx9WSeWTYxueZLAtTFpZTNKSon0YlpGt9v-C8dl8,27503
 sqlalchemy/inspection.py,sha256=2mcgybcOVuQDB2bSIhwidrMteP9qOpEbmehyT2lrnt8,5661
@@ -15,7 +15,7 @@ sqlalchemy/dialects/_typing.py,sha256=oUmFIxU_AVXmJyRXiE5IsDvKFh8HvAcyiGMQaWmY7M
 sqlalchemy/dialects/type_migration_guidelines.txt,sha256=-uHNdmYFGB7bzUNT6i8M5nb4j6j9YUKAtW4lcBZqsMg,8239
 sqlalchemy/dialects/mssql/__init__.py,sha256=j1pNh_cHkSRoTzCjUQcjRNZEVtIfdFCgkTT87mgSs5s,1913
 sqlalchemy/dialects/mssql/aioodbc.py,sha256=RS9TZI4cDa9My9YHQbWW2nD3lUBx-s8aQZ7G2080dDA,2005
-sqlalchemy/dialects/mssql/base.py,sha256=KiiuQ7DTUzovfE4ipKKU2C1D99xpBvUGQS6R6_FjfZY,160720
+sqlalchemy/dialects/mssql/base.py,sha256=Jt_N-oZt4_uaqPqVDFvLKN1Xyj9eJSnlwKORu5S33vQ,160932
 sqlalchemy/dialects/mssql/information_schema.py,sha256=xoO2mKqq99GBN9osJaaYjLw3VQg4YB8rFrh5K6gGfaI,10544
 sqlalchemy/dialects/mssql/json.py,sha256=SgcLWK-xmy_5FCzgxoz2Xa8pnJemVFCuiNQ6aFApHyk,5338
 sqlalchemy/dialects/mssql/mssqlpython.py,sha256=Boe6dsrabesUauvFUDIHeFXDXLBh3qi2pgqYCqI__eI,7832
@@ -54,14 +54,14 @@ sqlalchemy/dialects/oracle/vector.py,sha256=v7zf88XX7ICORNuycw3da1d5G7KHmYytNtU6
 sqlalchemy/dialects/postgresql/__init__.py,sha256=uqvgSydDm7mbLeLtuARI8AXFkcHPCkqTgd8UNDKznxs,3988
 sqlalchemy/dialects/postgresql/_psycopg_common.py,sha256=3btoOFqAcFmkectNE1Vgs7cOv4ccF28xIQZIDEYwOWA,7178
 sqlalchemy/dialects/postgresql/array.py,sha256=fHA_e2ez1SGHXa4BrXxbwCKMEkrDxn2GFzWJOjZrM0c,17907
-sqlalchemy/dialects/postgresql/asyncpg.py,sha256=IE2FNLURUBGvsofgGpqCJ6sx8Qd_alUsOz2Mb0YkeVk,42376
+sqlalchemy/dialects/postgresql/asyncpg.py,sha256=ne9Fr2-dWoD0qLjpsLxTvkRmYGD1CtBR-wSeG0E1Or8,42563
 sqlalchemy/dialects/postgresql/base.py,sha256=pMvzDesY5HsgmNnfPDa7HUD7rU_W11QlZfQDM4Y3A44,214444
 sqlalchemy/dialects/postgresql/bitstring.py,sha256=-AowJ4DqlcT0PcFXML44TU4VND_hFuvtkwqUgKBcE1I,10603
 sqlalchemy/dialects/postgresql/dml.py,sha256=ckxPBWuAXCRKkSFvdmwEppvirvczFY-voniqgC3X6DA,12959
 sqlalchemy/dialects/postgresql/ext.py,sha256=ZgdhLnWDYcm3RQ0XlUtrsW3WF1YRcGmzEK-8sdg16wc,19603
 sqlalchemy/dialects/postgresql/hstore.py,sha256=i14ZMZ2oml63W1OMfLiq_IAFAFbh-QUPKT1_vN5obY0,12728
 sqlalchemy/dialects/postgresql/json.py,sha256=LGa5zmfU5tqwcJSKpWwy9azQHklNqNLBuK5HXIUNEKc,14996
-sqlalchemy/dialects/postgresql/named_types.py,sha256=_ElGK3gHGMrgmClftppPF4Zlb-yRQ7lf16hIjwxqSh4,18617
+sqlalchemy/dialects/postgresql/named_types.py,sha256=qwxZKnBtzujRe6lYJaH8v0kRSCmS--fT6UrHAwDPbXE,19459
 sqlalchemy/dialects/postgresql/operators.py,sha256=CndNmzeu8ytmDA497ZeTxcbHxSVlVrOCmGREuUfjWhU,2840
 sqlalchemy/dialects/postgresql/pg8000.py,sha256=Hb54csBYBbFZS5wkJFH63BDPxp1E1bQtaH_r_U-pSNQ,18392
 sqlalchemy/dialects/postgresql/pg_catalog.py,sha256=7NWViTqCyWjgWiY3buavYo-CA2h-nxwfpc-vzYnNotg,10475
@@ -81,14 +81,14 @@ sqlalchemy/dialects/sqlite/pysqlcipher.py,sha256=k3qMGR2VvHHT29vsJ-eJYUe7jIXhgGS
 sqlalchemy/dialects/sqlite/pysqlite.py,sha256=_jD3LdPia8SV9ma3pz9zm9g46Rp9m4nQ4Hyd6yMDnVk,36592
 sqlalchemy/engine/__init__.py,sha256=Nn05AJVAfZn_sToGjt09vBcZET343-wYwl-oo2Fg6R8,2818
 sqlalchemy/engine/_processors_cy.py,sha256=Q68s_s1zINR4nFQCfUfMJqjdRWI-J2BIF01tpgP7LiE,2498
-sqlalchemy/engine/_result_cy.py,sha256=da5adBl8TpsBdL3dgT2L3HPv2R38376LraS2YqP7A9U,24230
+sqlalchemy/engine/_result_cy.py,sha256=Lk65cmkNwSM0tDRBFHCMB8mdMmaAPjP-LY9L6qwdRqo,24006
 sqlalchemy/engine/_row_cy.py,sha256=GUX53624m7KpLOTQhsi5aMHv-ypdB4caWMQPGkuAIC4,7413
 sqlalchemy/engine/_util_cy.py,sha256=AicwKLv6IuJ46WNVhEkT0MUPEFS5z8ltxKKTIA_HyNI,4504
-sqlalchemy/engine/base.py,sha256=3knlkSPdTmEYeEwbgkFRJ_EgqK0474aXOrX8KGBTeNk,123741
-sqlalchemy/engine/characteristics.py,sha256=wRg6uE8NYSH38wvp0CMY2U5hv9u3VTOkTHyJeXYrkvQ,4765
+sqlalchemy/engine/base.py,sha256=Aq3OSbeo-9re9IDDJLNwMUWfnJUfReIexBqHdXGeCDU,124009
+sqlalchemy/engine/characteristics.py,sha256=QctD35XaPso4brk2W8zQmdomMkRRV6X7vbeo96eUvA4,4768
 sqlalchemy/engine/create.py,sha256=7G0aidSUYtghZjyv7C19TZcv_3o3pS62UXj-sRgsWVs,33661
 sqlalchemy/engine/cursor.py,sha256=B5NmeqIEsOiPU8QaE4dXh7s1cSp2_5erukysuKs7ipo,85474
-sqlalchemy/engine/default.py,sha256=mpIQfaHFhojYTJuMmxWpNvtvrZTYybjjZpC_Fp5eeVg,94592
+sqlalchemy/engine/default.py,sha256=u4h11cJackuZ-ImOinv4JbSTiiQGO3I6Em9i8LjL7L8,94768
 sqlalchemy/engine/events.py,sha256=d-BzEd6M8dG8q22w3N6RX98cDcrANTgYyPjb5oFQznE,37475
 sqlalchemy/engine/interfaces.py,sha256=IKYAaYa-iA44O3bsxsmhyNWwIf3FToX7Wx8N-I9xD0E,123015
 sqlalchemy/engine/mock.py,sha256=i9J-z0NsL78VlqC85MRgo5SNNQU256UtEqficO3DCwY,4155
@@ -114,7 +114,7 @@ sqlalchemy/ext/horizontal_shard.py,sha256=uWbe4iP7pDzYR-8jBmrifyOEPTn7N1_a33YKma
 sqlalchemy/ext/hybrid.py,sha256=vfyfb54vRd6S_JpbWsswlketD6mFX-OeK9I06R2mN70,64744
 sqlalchemy/ext/indexable.py,sha256=MhqYUA_KuB95t3kzKTtUwEbh5OMhuNNujwyJ0ENKZrM,11761
 sqlalchemy/ext/instrumentation.py,sha256=4DL2RBcYE8bymiRNTjEDYevBpXTftECjFwg90DBqEuw,15708
-sqlalchemy/ext/mutable.py,sha256=xiKl9pl_l_YgoSV3L5p5c0m3lh3UfduYIrmAv7lUIL0,37115
+sqlalchemy/ext/mutable.py,sha256=vjS-EhR2GW26fSb61woPucZEEzEJCxMYt6AcxxX-NBg,37404
 sqlalchemy/ext/orderinglist.py,sha256=ItEwaVvzeYdoSwj0Ipao0xi8BThXCeLZqFxChsQuCo8,15157
 sqlalchemy/ext/serializer.py,sha256=uOicJGYMBW5S1VXDGU61UIiSfLT3ricVVt5a9oKJJVI,6113
 sqlalchemy/ext/asyncio/__init__.py,sha256=0MnGUog_nAVA71tE0IAiyqVbOn2Dpt71QpMAf5Y1-Lk,1410
@@ -138,7 +138,7 @@ sqlalchemy/orm/clsregistry.py,sha256=dmIYdM2VTyLVLYiale_x9-JGSK6GpQ0JOqsZuxfSfQE
 sqlalchemy/orm/collections.py,sha256=sc-KrVjRZ1EKArBPn2lqmH9QX7HKr6d2oX0fPV5a4h8,50026
 sqlalchemy/orm/context.py,sha256=F1poIa-NftQTO_cNUfSnbJKjbPQs9kWy6tBEyznTD_8,120868
 sqlalchemy/orm/decl_api.py,sha256=gK5IGcbAXMdCN6SzprewMhfbXiZe1yO1Ghv2y2z3EHA,78721
-sqlalchemy/orm/decl_base.py,sha256=V30p5ILt8jRGhR3bv-LaQu2mZtSEys5TTMmSS9NUj8g,87679
+sqlalchemy/orm/decl_base.py,sha256=DF132BFspNgbSrnVIA63RNk8b8MIzfOe4vk6wqKMQ8g,87748
 sqlalchemy/orm/dependency.py,sha256=gqUUJi7LMF2RIEvq7hw_w-WfbpW8CXzSaDW5QTW5NlQ,47739
 sqlalchemy/orm/descriptor_props.py,sha256=2R4NUuPIyinL5RrTbOAYebb3ZJNJLnT6_J2QCWy0nEM,42407
 sqlalchemy/orm/dynamic.py,sha256=7wyr0eM7xIRqWQk6jcoHjqGYatORwImRbrysJhQaGm8,9968
@@ -184,11 +184,11 @@ sqlalchemy/sql/annotation.py,sha256=gkFPOq3qGo6fahIxTwXgxCdcEyiD8W4CH0q01d1E0mo,
 sqlalchemy/sql/base.py,sha256=1xkh7mgC25GVZS8tczZbwDAxRvdumoaW3UPrJXbynbQ,98615
 sqlalchemy/sql/cache_key.py,sha256=OihJqOVsdU0F_IShr0FIptTRHtIlM1UIZ_5LR8LQd0Q,28872
 sqlalchemy/sql/coercions.py,sha256=XyV6wyiIHHD6ViGdZhLMQ8OVWNk4_LyBvv15t504UYI,39144
-sqlalchemy/sql/compiler.py,sha256=2GLICV4e506Y65tuiULpgjWXTSwO6LMYxHL8jntG1i4,301442
+sqlalchemy/sql/compiler.py,sha256=9vNcKzGXY-gqOl_R42tzwQR0V0MjBNn79OmJmjiVjQo,301830
 sqlalchemy/sql/crud.py,sha256=1qtcYPM-p9DsjMaqixYgKVSPuQEK43QEsAdgmXYY_ok,61581
 sqlalchemy/sql/ddl.py,sha256=6vfeMHtVcV6vWBQLxDZ906CHBnnadG5C8vmQNbpY5k8,65048
 sqlalchemy/sql/default_comparator.py,sha256=MC1yWLbOArtLAsVWho_08Jk8ogP6mEgtRP-IxBYFtv4,18684
-sqlalchemy/sql/dml.py,sha256=m-rOUqw5SmcTXHVt92ICLiEoHuRLG85cAIZEUTNCSMA,71651
+sqlalchemy/sql/dml.py,sha256=-j0vtiT_JPyZoxUxtgOwtSOT3BHK_S6BlBR5vzfrzcM,71911
 sqlalchemy/sql/elements.py,sha256=zPomd9yuJm5DJ9Jie87V5w2M8Zcv6mrd1nx174QKSmo,196427
 sqlalchemy/sql/events.py,sha256=xpqx3irkG8N3gysXAViLCqXXke9KCSU-6w4zZUdYXzw,18312
 sqlalchemy/sql/expression.py,sha256=SStPoDh7LSBTj6-4_KZSzyH0i5f493lqx4EnwcGPCZU,8342
@@ -199,7 +199,7 @@ sqlalchemy/sql/operators.py,sha256=91HJboxRkDFNHx9JlpO9hsss7wqTfeoANOxjMFszTt0,8
 sqlalchemy/sql/roles.py,sha256=QG4iNsYMCqjnMP3wt-5lEKxQZIh3uD2yVhurcS-z7VM,7857
 sqlalchemy/sql/schema.py,sha256=55oc5r8Mqtkcr2ker8kHjlBSUSO3QhwyyqrG2gaFgu4,262469
 sqlalchemy/sql/selectable.py,sha256=PcrGphf752_nMgFvA5d5LLUGhio9glG3nrCSEJtbvTs,257803
-sqlalchemy/sql/sqltypes.py,sha256=tCggHZBkFFn9JmH_eIbImgu07a-Y8aj9-QBrqsisKOU,138754
+sqlalchemy/sql/sqltypes.py,sha256=zykH4bSbQRbmrdq9_lqnOqwwtgWAq0j-XnWa4zQPtQw,138822
 sqlalchemy/sql/traversals.py,sha256=xLBzv1qpTUjBTiTGMBvPUvl1UPffYSWMxV4wHgOM4i4,34355
 sqlalchemy/sql/type_api.py,sha256=nIjquO8VkktzgurEYoxPYDMShBRi_xfCyV0wsw8yEAQ,89578
 sqlalchemy/sql/util.py,sha256=2k520E59ONQEtChkhy7E8Dpmw1WPWbJePwDfG0rRi4A,48610
@@ -215,9 +215,9 @@ sqlalchemy/testing/entities.py,sha256=ZIE4OCzDlKE1OxVArkWF755gvYZDS8oUuX5fuwPAQg
 sqlalchemy/testing/exclusions.py,sha256=Iwz9xZABIW8BmD-3URvCV20-d0LHKncd8xMpBEHGEUE,14572
 sqlalchemy/testing/pickleable.py,sha256=gXgySNI39dUcuNY6e-vM9HFKxQ7Uva7NVZgeYyNY4Zw,2833
 sqlalchemy/testing/profiles_file.py,sha256=sxwF-c6Wd6IBEMHpU1QSdsouyCX7b-4EWWsTTdD8m4w,11349
-sqlalchemy/testing/profiling.py,sha256=pCeurQNGnsyMHotKuaT8GM8Aq_p1JADaIXPsWsvEJ9w,9159
+sqlalchemy/testing/profiling.py,sha256=ES3F7pklXaQJXUMdXmcUmoyXvOC3koYYARsIMGyjtqI,10049
 sqlalchemy/testing/provision.py,sha256=pOMK51WaXJyWAh48HbBjgywDPLk02pSS7rHQqoMLulI,18628
-sqlalchemy/testing/requirements.py,sha256=XPJmgocHGf9vEbDgrCryxwEgSkxPZgve0FyzTLBKHAo,58360
+sqlalchemy/testing/requirements.py,sha256=WShbncr8vR1oZKhoap3r3eZMmsnK70oUqtSCc6Ao5CQ,58493
 sqlalchemy/testing/schema.py,sha256=49x-TXARL2k8oIiaSzyGxXG5fh7vJOuBoUv5h9YTfKo,5360
 sqlalchemy/testing/util.py,sha256=vbd6v3shfmdxqnqbL0K_hg-yi-ou5Fe9FpkUZeCEyUk,15809
 sqlalchemy/testing/warnings.py,sha256=j8GWiP-yraCW0Ig5iJxAa5ekN82ZWqcQWyR-BUb4MZA,1546
@@ -229,7 +229,7 @@ sqlalchemy/testing/fixtures/sql.py,sha256=LAp9DhOJ7gInbcCBDqUaIhDCFIHt4ydh_g53v8
 sqlalchemy/testing/plugin/__init__.py,sha256=8LB-gN7jwvGVW4bPAM1b8MmAQQwBSKh_BGVS3HQc4EM,247
 sqlalchemy/testing/plugin/bootstrap.py,sha256=5hrNoDrExsOv6fUaa-4JPPEnTJJVJYlBMYGMPu7PjZ8,1684
 sqlalchemy/testing/plugin/plugin_base.py,sha256=aS9A5zoKaoGKMy8F2OIKbPOMe5SG49lChANZ_cd3UM0,23102
-sqlalchemy/testing/plugin/pytestplugin.py,sha256=swDvlVLofRYz3Q-w-svvHgdWIPoS_bvSMIVBkz0-9bM,28690
+sqlalchemy/testing/plugin/pytestplugin.py,sha256=H_F1GFG8-NqaP-FgjEkZnyPY9F81OA-JygtiddZ0iQs,29468
 sqlalchemy/testing/suite/__init__.py,sha256=jLYLmFQ6k0Fn7N2iPrbXwzJMKDSe4oMdmD-AC6yu3ws,726
 sqlalchemy/testing/suite/test_cte.py,sha256=7AnV9dR9h76JWY0yWuyeQT-5GQsYbNMz3q2SG8IA_R4,7276
 sqlalchemy/testing/suite/test_ddl.py,sha256=03nV2s8lfcCw4Czq6pkHl0ZGho8KyFe_C-f0HthP3B0,13010
@@ -238,10 +238,10 @@ sqlalchemy/testing/suite/test_insert.py,sha256=tapEYecSPKqL8xrjlcQzDOfbWdKJz9ldT
 sqlalchemy/testing/suite/test_reflection.py,sha256=Em0XdladxD6Lk9YH6ZQUw0cdEvkaXJfEPs-1E21xVn0,128866
 sqlalchemy/testing/suite/test_results.py,sha256=Aw8RK5CX1y39wDK6U8ub8PX9OYe8aoBCBCohjVPvRks,22499
 sqlalchemy/testing/suite/test_rowcount.py,sha256=V6RQGwe9LO5tKzFPFoa29dDs8M0eY8JZ9tqgbzgtCYs,7900
-sqlalchemy/testing/suite/test_select.py,sha256=IPOqGE7N8avGLfmjxHEa2SKGwj5dIJc_g2RM1e-fAL8,65806
+sqlalchemy/testing/suite/test_select.py,sha256=qNeb6RgssJZWur-R4TZ88xyLVi6Offo067It0el-K90,66071
 sqlalchemy/testing/suite/test_sequence.py,sha256=8a6UO3pjRFnQ23ELG9m5cMMRoD3iD7aSgul-HnkeLns,9979
 sqlalchemy/testing/suite/test_table_via_select.py,sha256=ZMJKUhAiqIzTKyK9J2cA_rvTij7CUt77d6o5sqDdrkc,21706
-sqlalchemy/testing/suite/test_types.py,sha256=FcKVoK0biEXoEAhmHTgLOOVrBFHYECh3zPhdmyQhLE4,76391
+sqlalchemy/testing/suite/test_types.py,sha256=Uva7OT-mmdizJMunxpaaV-SbeK9hhMp799PIPTb5V10,79090
 sqlalchemy/testing/suite/test_unicode_ddl.py,sha256=tVLf9RqCJe-CsyhCWL9d-WuWazDx5iWYzoBrSCbgjXs,6141
 sqlalchemy/testing/suite/test_update_delete.py,sha256=llAnxDGvbK-C7CzEXbSNEjczhOSL1sKTLuzGyJahqV8,5195
 sqlalchemy/util/__init__.py,sha256=2DHFcXP7fB86rfMhHWvngoIZMjKU9ur3L74jd-ROGaE,8671
@@ -260,9 +260,9 @@ sqlalchemy/util/queue.py,sha256=9cMV3Dea0l5tfWIHw3LUE0L3knt48gtUP_C8fBKLQeo,9740
 sqlalchemy/util/tool_support.py,sha256=iZSwvKdF5pA8UtXuwbtln6dEDgerKJWasELSi7q6Epw,6136
 sqlalchemy/util/topological.py,sha256=yMpaA2s0JYIekQF4XKwzJzy8lVo-8yeo8o1J2xzxq48,3451
 sqlalchemy/util/typing.py,sha256=p3vOTJ4F7i3eqeFw7W_tayq88U0e53ZgOsCu7eNQ3lA,21125
-sqlalchemy-2.1.3.dist-info/licenses/AUTHORS,sha256=3B2wtdF0Va3De2k_-OQJyagPYD5EFpWCVRjDb3hslj4,492
-sqlalchemy-2.1.3.dist-info/licenses/LICENSE,sha256=6GK7W5BPtVE8PhQojXoloS6w7MeEegqWXTEOmpVefLk,1100
-sqlalchemy-2.1.3.dist-info/METADATA,sha256=RV-yWu2uBDF_TUquRZTNlA2vl4dvPHsCP3vNX5o03b4,9680
-sqlalchemy-2.1.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-sqlalchemy-2.1.3.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
-sqlalchemy-2.1.3.dist-info/RECORD,,
+sqlalchemy-2.1.4.dist-info/licenses/AUTHORS,sha256=3B2wtdF0Va3De2k_-OQJyagPYD5EFpWCVRjDb3hslj4,492
+sqlalchemy-2.1.4.dist-info/licenses/LICENSE,sha256=6GK7W5BPtVE8PhQojXoloS6w7MeEegqWXTEOmpVefLk,1100
+sqlalchemy-2.1.4.dist-info/METADATA,sha256=VBbisMQ5oM7iGeIEldC9z43kICE7kpYZqYHIPQr5e_Y,9680
+sqlalchemy-2.1.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sqlalchemy-2.1.4.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
+sqlalchemy-2.1.4.dist-info/RECORD,,