SQLAlchemy 2.1.5__py3-none-any.whl → 2.1.6__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.5"
+__version__ = "2.1.6"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/dialects/mysql/base.py

@@ -2386,6 +2386,8 @@ class MySQLDDLCompiler(
 class MySQLTypeCompiler(
     _mariadb_shim.MariaDBTypeCompilerShim, compiler.GenericTypeCompiler
 ):
+    dialect: MySQLDialect
+
     def _extend_numeric(self, type_: _NumericCommonType, spec: str) -> str:
         "Extend a numeric-type declaration with MySQL specific extensions."
 
@@ -2680,9 +2682,12 @@ class MySQLTypeCompiler(
     ) -> str:
         quoted_enums = []
         for e in enumerated_values:
+            e = e.replace("'", "''")
+            if self.dialect._backslash_escapes:
+                e = e.replace("\\", "\\\\")
             if self.dialect.identifier_preparer._double_percents:
                 e = e.replace("%", "%%")
-            quoted_enums.append("'%s'" % e.replace("'", "''"))
+            quoted_enums.append("'%s'" % e)
         return self._extend_string(
             type_, {}, "%s(%s)" % (name, ",".join(quoted_enums))
         )

sqlalchemy/engine/base.py

@@ -1273,24 +1273,29 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
                 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()
-
+            try:
+                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()
+            finally:
                 # 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.
+                #
+                # there is also a chance that the conn.close() here could
+                # itself be interrupted, such as by a cancellation; hence a
+                # second try/finally is needed as well (see #13699)
                 self._dbapi_connection = None
-            self.__can_reconnect = False
+                self.__can_reconnect = False
 
     # special case to handle mypy issue:
     # https://github.com/python/mypy/issues/20651

sqlalchemy/engine/result.py

@@ -1774,10 +1774,12 @@ class FrozenResult(Generic[Unpack[_Ts]]):
         self._source_supports_scalars = result._source_supports_scalars
         self._attributes = result._attributes
 
+        # use _allrows() rather than fetchall() so that AsyncResult, whose
+        # fetchall() is a coroutine, may be frozen within greenlet_spawn()
         if self._source_supports_scalars:
             self.data = list(result._raw_row_iterator())
         else:
-            self.data = result.fetchall()
+            self.data = result._allrows()
 
     def _rewrite_rows(self) -> Sequence[Sequence[Any]]:
         # used only by the orm fn merge_frozen_result

sqlalchemy/engine/url.py

@@ -364,7 +364,11 @@ class URL(NamedTuple):
         return self._replace(**kw)
 
     def update_query_string(
-        self, query_string: str, append: bool = False
+        self,
+        query_string: str,
+        append: bool = False,
+        *,
+        keep_blank_values: bool = False,
     ) -> URL:
         """Return a new :class:`_engine.URL` object with the :attr:`_engine.URL.query`
         parameter dictionary updated by the given query string.
@@ -387,6 +391,13 @@ class URL(NamedTuple):
          If left at its default of False, keys present in the given query
          parameters will replace those of the existing query string.
 
+        :param keep_blank_values: if True, parameters with blank values
+         such as ``key=`` are retained in the query dictionary as empty
+         strings.  If left at its default of False, parameters with blank
+         values are omitted.
+
+         .. versionadded:: 2.1.6
+
         .. versionadded:: 1.4
 
         .. seealso::
@@ -396,7 +407,10 @@ class URL(NamedTuple):
             :meth:`_engine.URL.update_query_dict`
 
         """  # noqa: E501
-        return self.update_query_pairs(parse_qsl(query_string), append=append)
+        return self.update_query_pairs(
+            parse_qsl(query_string, keep_blank_values=keep_blank_values),
+            append=append,
+        )
 
     def update_query_pairs(
         self,
@@ -836,7 +850,9 @@ class URL(NamedTuple):
         return translated
 
 
-def make_url(name_or_url: Union[str, URL]) -> URL:
+def make_url(
+    name_or_url: Union[str, URL], *, keep_blank_values: bool = False
+) -> URL:
     """Given a string, produce a new URL instance.
 
     The format of the URL generally follows `RFC-1738
@@ -846,6 +862,21 @@ def make_url(name_or_url: Union[str, URL]) -> URL:
 
     If a :class:`.URL` object is passed, it is returned as is.
 
+    :param name_or_url: a string URL or :class:`.URL` object.
+
+    :param keep_blank_values: if True, query string parameters with blank
+     values such as ``key=`` are retained in the :attr:`.URL.query`
+     dictionary as empty strings.  If left at its default of False,
+     parameters with blank values are omitted.  Has no effect when a
+     :class:`.URL` object is passed.
+
+     As :func:`_sa.create_engine` parses string URLs using the default
+     setting, a string URL with blank values to be retained should be
+     parsed with :func:`.make_url` first, and the resulting :class:`.URL`
+     passed to :func:`_sa.create_engine`.
+
+     .. versionadded:: 2.1.6
+
     .. seealso::
 
         :ref:`database_urls`
@@ -853,7 +884,7 @@ def make_url(name_or_url: Union[str, URL]) -> URL:
     """
 
     if isinstance(name_or_url, str):
-        return _parse_url(name_or_url)
+        return _parse_url(name_or_url, keep_blank_values=keep_blank_values)
     elif not isinstance(name_or_url, URL) and not hasattr(
         name_or_url, "_sqla_is_testing_if_this_is_a_mock_object"
     ):
@@ -864,7 +895,7 @@ def make_url(name_or_url: Union[str, URL]) -> URL:
         return name_or_url
 
 
-def _parse_url(name: str) -> URL:
+def _parse_url(name: str, keep_blank_values: bool = False) -> URL:
     pattern = re.compile(
         r"""
             (?P<name>[\w\+]+)://
@@ -892,7 +923,9 @@ def _parse_url(name: str) -> URL:
         if components["query"] is not None:
             query = {}
 
-            for key, value in parse_qsl(components["query"]):
+            for key, value in parse_qsl(
+                components["query"], keep_blank_values=keep_blank_values
+            ):
                 if key in query:
                     query[key] = util.to_list(query[key])
                     cast("List[str]", query[key]).append(value)

sqlalchemy/ext/asyncio/result.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import operator
 from typing import Any
 from typing import AsyncIterator
+from typing import Iterator
 from typing import Literal
 from typing import Optional
 from typing import overload
@@ -20,6 +21,7 @@ from typing import TypeVar
 from . import exc as async_exc
 from ... import util
 from ...engine import Result
+from ...engine._result_cy import _RowData
 from ...engine.result import _NO_ROW
 from ...engine.result import _R
 from ...engine.result import _WithKeys
@@ -467,6 +469,11 @@ class AsyncResult(_WithKeys, AsyncCommon[Row[Unpack[_Ts]]]):
 
         return await greenlet_spawn(FrozenResult, self)
 
+    def _raw_row_iterator(self) -> Iterator[_RowData]:
+        # used by FrozenResult when the source result supports scalars;
+        # must be invoked within greenlet_spawn()
+        return self._real_result._raw_row_iterator()
+
     @overload
     def scalars(
         self: AsyncResult[_T, Unpack[TupleAny]], index: Literal[0]
@@ -494,7 +501,7 @@ class AsyncResult(_WithKeys, AsyncCommon[Row[Unpack[_Ts]]]):
          referring to this :class:`_asyncio.AsyncResult` object.
 
         """
-        return AsyncScalarResult(self._real_result, index)
+        return AsyncScalarResult(self, index)
 
     def mappings(self) -> AsyncMappingResult:
         """Apply a mappings filter to returned rows, returning an instance of
@@ -505,11 +512,11 @@ class AsyncResult(_WithKeys, AsyncCommon[Row[Unpack[_Ts]]]):
         objects.
 
         :return: a new :class:`_asyncio.AsyncMappingResult` filtering object
-         referring to the underlying :class:`_result.Result` object.
+         referring to this :class:`_asyncio.AsyncResult` object.
 
         """
 
-        return AsyncMappingResult(self._real_result)
+        return AsyncMappingResult(self)
 
 
 class AsyncScalarResult(AsyncCommon[_R]):
@@ -532,19 +539,21 @@ class AsyncScalarResult(AsyncCommon[_R]):
 
     def __init__(
         self,
-        real_result: Result[Unpack[TupleAny]],
+        result: AsyncResult[Unpack[TupleAny]],
         index: _KeyIndexType,
     ):
-        self._real_result = real_result
+        # rows are fetched from the sync Result; metadata and unique state
+        # come from the AsyncResult, where unique() and columns() apply them
+        self._real_result = result._real_result
 
-        if real_result._source_supports_scalars:
-            self._metadata = real_result._metadata
+        if result._source_supports_scalars:
+            self._metadata = result._metadata
             self._post_creational_filter = None
         else:
-            self._metadata = real_result._metadata._reduce([index])
+            self._metadata = result._metadata._reduce([index])
             self._post_creational_filter = operator.itemgetter(0)
 
-        self._unique_filter_state = real_result._unique_filter_state
+        self._unique_filter_state = result._unique_filter_state
 
     def unique(
         self,
@@ -665,8 +674,11 @@ class AsyncMappingResult(_WithKeys, AsyncCommon[RowMapping]):
 
     _post_creational_filter = operator.attrgetter("_mapping")
 
-    def __init__(self, result: Result[Unpack[TupleAny]]):
-        self._real_result = result
+    def __init__(self, result: AsyncResult[Unpack[TupleAny]]):
+        # rows are fetched from the sync Result; metadata and unique state
+        # come from the AsyncResult, where unique() and columns() apply them
+        self._real_result = result._real_result
+
         self._unique_filter_state = result._unique_filter_state
         self._metadata = result._metadata
         if result._source_supports_scalars:

sqlalchemy/orm/context.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import collections
 import itertools
+from typing import AbstractSet
 from typing import Any
 from typing import cast
 from typing import Dict
@@ -50,6 +51,8 @@ from ..sql import visitors
 from ..sql._typing import is_dml
 from ..sql._typing import is_insert_update
 from ..sql._typing import is_select_base
+from ..sql.base import _expand_cloned
+from ..sql.base import _from_objects
 from ..sql.base import _select_iterables
 from ..sql.base import CacheableOptions
 from ..sql.base import CompileState
@@ -91,6 +94,7 @@ if TYPE_CHECKING:
     from ..sql.selectable import _LabelConventionCallable
     from ..sql.selectable import _SetupJoinsElement
     from ..sql.selectable import ExecutableReturnsRows
+    from ..sql.selectable import FromClause
     from ..sql.selectable import SelectBase
     from ..sql.type_api import TypeEngine
 
@@ -1025,6 +1029,9 @@ class FromStatement(GroupedElement, Generative, TypedReturnsRows[Unpack[_Ts]]):
 
         """
 
+        if compiler._collect_params:
+            compiler._add_to_params(self)
+
         compile_state = self._compile_state_factory(self, compiler, **kw)
 
         toplevel = not compiler.stack
@@ -1104,6 +1111,10 @@ class _ORMSelectCompileState(_ORMCompileState, SelectState):
     _where_criteria = ()
     _having_criteria = ()
 
+    # see SQLCompiler._enclosing_correlate_froms()
+    _explicit_correlate_froms: AbstractSet[FromClause] = util.EMPTY_SET
+    _implicit_correlate_froms: AbstractSet[FromClause] = util.EMPTY_SET
+
     @classmethod
     def _create_orm_context(
         cls,
@@ -1116,6 +1127,17 @@ class _ORMSelectCompileState(_ORMCompileState, SelectState):
 
         self = cls.__new__(cls)
 
+        if not toplevel:
+            assert compiler is not None
+            (
+                self._explicit_correlate_froms,
+                self._implicit_correlate_froms,
+            ) = compiler._enclosing_correlate_froms(
+                compiler.stack[-1],
+                kw.get("asfrom", False),
+                kw.get("lateral", False),
+            )
+
         select_statement = statement
 
         # if we are a select() that was never a legacy Query, we won't
@@ -2519,6 +2541,44 @@ class _ORMSelectCompileState(_ORMCompileState, SelectState):
         else:
             return ()
 
+    def _get_correlated_froms(self):
+        """Return the set of FROM objects that will be correlated away
+        from this SELECT, given its current state.
+
+        This runs ahead of the final statement being generated, so the
+        FROM list is derived from the ORM-level statement.
+
+        """
+        if not self._explicit_correlate_froms and (
+            not self._implicit_correlate_froms
+        ):
+            return util.EMPTY_SET
+
+        froms = self._get_froms(self.select_statement)
+
+        if self.correlate:
+            to_correlate = [c for c in self.correlate if c is not None]
+        else:
+            to_correlate = None
+
+        display_froms = set(
+            self._correlate_froms(
+                froms,
+                self.select_statement,
+                to_correlate,
+                self.correlate_except,
+                self.select_statement._auto_correlate,
+                self._explicit_correlate_froms,
+                self._implicit_correlate_froms,
+            )
+        )
+
+        return set(
+            _expand_cloned(
+                _from_objects(*[f for f in froms if f not in display_froms])
+            )
+        )
+
     def _adjust_for_extra_criteria(self):
         """Apply extra criteria filtering.
 
@@ -2532,13 +2592,39 @@ class _ORMSelectCompileState(_ORMCompileState, SelectState):
         associated with the global context.
 
         """
+        # entities that are referenced only within the WHERE clause also
+        # receive criteria (#13070), except when the entity is correlated
+        # to an enclosing SELECT, which has the criteria applied
+        # already (#13701)
+        correlated_froms = (
+            self._get_correlated_froms()
+            if self.select_statement._where_criteria
+            else util.EMPTY_SET
+        )
         ext_infos = [
             fromclause._annotations.get("parententity", None)
             for fromclause in self.from_clauses
         ] + [
-            elem._annotations.get("parententity", None)
-            for where_crit in self.select_statement._where_criteria
-            for elem in sql_util.surface_expressions(where_crit)
+            ext_info
+            for elem, ext_info in [
+                (elem, elem._annotations.get("parententity", None))
+                for where_crit in self.select_statement._where_criteria
+                for elem in sql_util.surface_expressions(where_crit)
+            ]
+            if ext_info
+            and not (
+                # if all FROMs for this expression are correlated to an
+                # enclosing query, then skip adding loader criteria for the
+                # entity on behalf of this element, since the actual FROM
+                # clause(s) for it are not local to this subquery
+                # (#13701)
+                correlated_froms
+                and elem._from_objects
+                and all(
+                    correlated_froms.intersection(from_._cloned_set)
+                    for from_ in elem._from_objects
+                )
+            )
         ]
 
         for ext_info in ext_infos:

sqlalchemy/orm/session.py

@@ -3523,10 +3523,17 @@ class Session(_SessionClassMethods, EventTarget):
                 # that is replaced when the primary keys of two instances
                 # are swapped; see test/orm/test_naturalpks.py -> test_reverse
                 old = self.identity_map.replace(state)
+
+                # check the replaced state's identity without emitting
+                # any SQL; an expired state such as one left over from
+                # a rollback will not match and does not warn
                 if (
                     old is not None
-                    and mapper._identity_key_from_state(old) == instance_key
                     and old.obj() is not None
+                    and mapper._identity_key_from_state(
+                        old, PassiveFlag.PASSIVE_NO_FETCH
+                    )
+                    == instance_key
                 ):
                     util.warn(
                         "Identity map already had an identity for %s, "

sqlalchemy/pool/base.py

@@ -1045,7 +1045,14 @@ def _finalize_fairy(
             if not isinstance(e, Exception):
                 # a cancellation or similar propagates from here, so the
                 # checkin() below is not reached; return the record now,
-                # rather than leaving it to garbage collection of the fairy
+                # rather than leaving it to garbage collection of the fairy.
+                # the cleanup of the fairy below is not reached either, so
+                # detach it from the record first, so that it can't act on
+                # the record once that's checked out again.  see #13699
+                if fairy is not None:
+                    fairy._finalizer.detach()
+                    fairy.dbapi_connection = None  # type: ignore[assignment]
+                    fairy._connection_record = None
                 if connection_record:
                     connection_record._checkin_failed(e)
                 raise

sqlalchemy/sql/compiler.py

@@ -36,6 +36,7 @@ import operator
 import re
 from time import perf_counter
 import typing
+from typing import AbstractSet
 from typing import Any
 from typing import Callable
 from typing import cast
@@ -1920,6 +1921,19 @@ class SQLCompiler(Compiled):
             if value is not None
         }
 
+    @util.memoized_property
+    def _expanded_bind_names_reserved(self) -> FrozenSet[str]:
+        """Names that the individual elements of an expanding parameter
+        may not take when the parameter is expanded at execution time.
+
+        This is every bound parameter name in the statement, both in its
+        compiled and in its escaped form.  See :ticket:`13695`.
+
+        """
+        return frozenset(self.bind_names.values()).union(
+            self.escaped_bind_names, self.escaped_bind_names.values()
+        )
+
     def is_subquery(self):
         return len(self.stack) > 1
 
@@ -2189,6 +2203,16 @@ class SQLCompiler(Compiled):
         replacement_expressions: Dict[str, Any] = {}
         to_update_sets: Dict[str, Any] = {}
 
+        # names that the elements of expanding parameters can't take, as
+        # they are in use either by other parameters in the statement or by
+        # elements of expanding parameters that were already expanded.
+        # copied into a mutable set, as it is added to within this method's
+        # scope to track the additional element names generated for this
+        # execution
+        expanded_taken_names: Set[str] = set(
+            self._expanded_bind_names_reserved
+        )
+
         # notes:
         # *unescaped* parameter names in:
         # self.bind_names, self.binds, self._bind_processors, self.positiontup
@@ -2239,7 +2263,10 @@ class SQLCompiler(Compiled):
                     values = parameters.pop(name)
 
                     leep_res = self._literal_execute_expanding_parameter(
-                        escaped_name, parameter, values
+                        escaped_name,
+                        parameter,
+                        values,
+                        taken_names=expanded_taken_names,
                     )
                     to_update, replacement_expr = leep_res
 
@@ -2249,17 +2276,16 @@ class SQLCompiler(Compiled):
                 if not parameter.literal_execute:
                     parameters.update(to_update)
                     if parameter.type._is_tuple_type:
-                        assert values is not None
-                        new_processors.update(
-                            (
-                                "%s_%s_%s" % (name, i, j),
-                                tuple_processors[name][j - 1],
+                        if name in tuple_processors:
+                            # to_update is flattened row by row, one entry
+                            # per element of each tuple
+                            element_processors = tuple_processors[name]
+                            num = len(element_processors)
+                            new_processors.update(
+                                (key, element_processors[idx % num])
+                                for idx, (key, _) in enumerate(to_update)
+                                if element_processors[idx % num] is not None
                             )
-                            for i, tuple_element in enumerate(values, 1)
-                            for j, _ in enumerate(tuple_element, 1)
-                            if name in tuple_processors
-                            and tuple_processors[name][j - 1] is not None
-                        )
                     else:
                         new_processors.update(
                             (key, single_processors[name])
@@ -3554,7 +3580,22 @@ class SQLCompiler(Compiled):
 
         return (), replacement_expression
 
-    def _literal_execute_expanding_parameter(self, name, parameter, values):
+    def _literal_execute_expanding_parameter(
+        self, name, parameter, values, *, taken_names
+    ):
+        """Render the per-element bound parameters of an expanding
+        parameter.
+
+        ``taken_names`` is a set of names the elements may not use; each
+        name generated is checked against it and added to it.  The element
+        names are normally ``<name>_<n>``, or ``<name>_<n>_<m>`` for tuples,
+        which may be the name of another parameter in the same statement,
+        e.g. a parameter ``x_1`` alongside the expanding parameter ``x``, or
+        the element of another expanding parameter.  A colliding name is
+        uniquified with a counter, rather than the element value replacing
+        the value of the other parameter.  See :ticket:`13695`.
+
+        """
         if parameter.literal_execute:
             return self._literal_execute_expanding_parameter_literal_binds(
                 parameter, values
@@ -3585,6 +3626,20 @@ class SQLCompiler(Compiled):
             def _render_bindtemplate(name):
                 return bind_template % {"name": name}
 
+        def _unique_name(key):
+            if key in taken_names:
+                base = key
+                counter = 0
+                while key in taken_names:
+                    counter += 1
+                    # double underscore keeps the suffix out of the
+                    # <name>_<n> form generated for anonymous names and
+                    # for the elements themselves, so a renamed element
+                    # won't take a name another element would generate
+                    key = "%s__%d" % (base, counter)
+            taken_names.add(key)
+            return key
+
         if not values:
             to_update = []
             if typ_dialect_impl._is_tuple_type:
@@ -3603,7 +3658,7 @@ class SQLCompiler(Compiled):
         ):
             assert not typ_dialect_impl._is_array
             to_update = [
-                ("%s_%s_%s" % (name, i, j), value)
+                (_unique_name("%s_%s_%s" % (name, i, j)), value)
                 for i, tuple_element in enumerate(values, 1)
                 for j, value in enumerate(tuple_element, 1)
             ]
@@ -3624,7 +3679,7 @@ class SQLCompiler(Compiled):
             )
         else:
             to_update = [
-                ("%s_%s" % (name, i), value)
+                (_unique_name("%s_%s" % (name, i)), value)
                 for i, value in enumerate(values, 1)
             ]
             replacement_expression = ", ".join(
@@ -5071,24 +5126,44 @@ class SQLCompiler(Compiled):
         toplevel = not self.stack
         entry = self._default_stack_entry if toplevel else self.stack[-1]
 
-        compile_state = select_stmt._compile_state_factory(select_stmt, self)
+        compile_state = select_stmt._compile_state_factory(
+            select_stmt, self, asfrom=asfrom, lateral=lateral
+        )
+
+        explicit, implicit = self._enclosing_correlate_froms(
+            entry, asfrom, lateral
+        )
+        return compile_state._get_display_froms(
+            explicit_correlate_froms=explicit,
+            implicit_correlate_froms=implicit,
+        )
+
+    def _enclosing_correlate_froms(
+        self, entry: _CompilerStackEntry, asfrom: bool, lateral: bool
+    ) -> Tuple[AbstractSet[FromClause], AbstractSet[FromClause]]:
+        """Given the stack entry of an enclosing statement, return the
+        explicit and implicit correlate FROMs for a SELECT that's embedded
+        within it, as passed to :meth:`.SelectState._get_display_froms`.
 
+        explicit_correlate_froms: FROMs of enclosing SELECTs that this SELECT
+        may correlate to when explicit correlation is used, i.e.
+        :meth:`.Select.correlate` or :meth:`.Select.correlate_except`.
+        Includes the FROMs of all enclosing SELECTs.
+
+        implicit_correlate_froms: FROMs of enclosing SELECTs that this SELECT
+        will correlate to automatically, assuming auto-correlation is in
+        effect.  Includes only the FROMs of the immediately enclosing SELECT,
+        and is empty if this SELECT is a subquery in a FROM clause that's not
+        LATERAL.  Is always a subset of explicit_correlate_froms.
+
+        """
         correlate_froms = entry["correlate_froms"]
         asfrom_froms = entry["asfrom_froms"]
 
         if asfrom and not lateral:
-            froms = compile_state._get_display_froms(
-                explicit_correlate_froms=correlate_froms.difference(
-                    asfrom_froms
-                ),
-                implicit_correlate_froms=(),
-            )
+            return correlate_froms.difference(asfrom_froms), util.EMPTY_SET
         else:
-            froms = compile_state._get_display_froms(
-                explicit_correlate_froms=correlate_froms,
-                implicit_correlate_froms=asfrom_froms,
-            )
-        return froms
+            return correlate_froms, asfrom_froms
 
     translate_select_structure: Any = None
     """if not ``None``, should be a callable which accepts ``(select_stmt,
@@ -5126,7 +5201,7 @@ class SQLCompiler(Compiled):
         kwargs["within_columns_clause"] = False
 
         compile_state = select_stmt._compile_state_factory(
-            select_stmt, self, **kwargs
+            select_stmt, self, asfrom=asfrom, lateral=lateral, **kwargs
         )
         kwargs["ambiguous_table_name_map"] = (
             compile_state._ambiguous_table_name_map
@@ -5157,7 +5232,11 @@ class SQLCompiler(Compiled):
                 select_stmt = new_select_stmt
 
                 compile_state = select_stmt._compile_state_factory(
-                    select_stmt, self, **kwargs
+                    select_stmt,
+                    self,
+                    asfrom=asfrom,
+                    lateral=lateral,
+                    **kwargs,
                 )
                 select_stmt = compile_state.statement
 
@@ -5335,9 +5414,6 @@ class SQLCompiler(Compiled):
     def _setup_select_stack(
         self, select, compile_state, entry, asfrom, lateral, compound_index
     ):
-        correlate_froms = entry["correlate_froms"]
-        asfrom_froms = entry["asfrom_froms"]
-
         if compound_index == 0:
             entry["select_0"] = select
         elif compound_index:
@@ -5358,21 +5434,18 @@ class SQLCompiler(Compiled):
                     )
                 )
 
-        if asfrom and not lateral:
-            froms = compile_state._get_display_froms(
-                explicit_correlate_froms=correlate_froms.difference(
-                    asfrom_froms
-                ),
-                implicit_correlate_froms=(),
-            )
-        else:
-            froms = compile_state._get_display_froms(
-                explicit_correlate_froms=correlate_froms,
-                implicit_correlate_froms=asfrom_froms,
-            )
+        explicit, implicit = self._enclosing_correlate_froms(
+            entry, asfrom, lateral
+        )
+        froms = compile_state._get_display_froms(
+            explicit_correlate_froms=explicit,
+            implicit_correlate_froms=implicit,
+        )
 
         new_correlate_froms = set(_from_objects(*froms))
-        all_correlate_froms = new_correlate_froms.union(correlate_froms)
+        all_correlate_froms = new_correlate_froms.union(
+            entry["correlate_froms"]
+        )
 
         new_entry: _CompilerStackEntry = {
             "asfrom_froms": new_correlate_froms,

sqlalchemy/sql/ddl.py

@@ -682,11 +682,11 @@ class CreateTableAs(DialectKWArgs, _TableViaSelect):
             conn.execute(cas)
 
         # or alternatively, invoke metadata.create_all()
-        some_metdata.create_all(engine)
+        some_metadata.create_all(engine)
 
         # drop is performed in the usual way, via drop_all
         # or table.drop()
-        some_metdata.drop_all(engine)
+        some_metadata.drop_all(engine)
 
     For detailed background on :class:`.CreateTableAs` see
     :ref:`metadata_create_table_as`.
@@ -792,11 +792,11 @@ class CreateView(DialectKWArgs, _TableViaSelect):
             conn.execute(create_view)
 
         # or alternatively, invoke metadata.create_all()
-        some_metdata.create_all(engine)
+        some_metadata.create_all(engine)
 
         # drop is performed in the usual way, via drop_all
         # or table.drop() (will emit DROP VIEW)
-        some_metdata.drop_all(engine)
+        some_metadata.drop_all(engine)
 
     For detailed background on :class:`.CreateView` see
     :ref:`metadata_create_view`.

sqlalchemy/sql/dml.py

@@ -69,6 +69,7 @@ from .selectable import SelectLabelStyle
 from .selectable import TableClause
 from .selectable import TypedReturnsRows
 from .sqltypes import NullType
+from .visitors import _TraverseInternalsType
 from .visitors import InternalTraversal
 from .. import exc
 from .. import util
@@ -436,6 +437,18 @@ class UpdateBase(
     _supplemental_returning: Optional[Tuple[_ColumnsClauseElement, ...]] = None
     _returning: Tuple[_ColumnsClauseElement, ...] = ()
 
+    _return_defaults_traverse_internals: _TraverseInternalsType = [
+        ("_return_defaults", InternalTraversal.dp_boolean),
+        (
+            "_return_defaults_columns",
+            InternalTraversal.dp_clauseelement_tuple,
+        ),
+        (
+            "_supplemental_returning",
+            InternalTraversal.dp_clauseelement_tuple,
+        ),
+    ]
+
     is_dml = True
 
     def _generate_fromclause_column_proxies(
@@ -1258,17 +1271,13 @@ class Insert(ValuesBase, HasSyntaxExtensions[Literal["post_values"]]):
             ("_post_values_clause", InternalTraversal.dp_clauseelement),
             ("_returning", InternalTraversal.dp_clauseelement_tuple),
             ("_hints", InternalTraversal.dp_table_hint_list),
-            ("_return_defaults", InternalTraversal.dp_boolean),
-            (
-                "_return_defaults_columns",
-                InternalTraversal.dp_clauseelement_tuple,
-            ),
+            ("_sort_by_parameter_order", InternalTraversal.dp_boolean),
             (
-                "_supplemental_returning",
-                InternalTraversal.dp_clauseelement_tuple,
+                "include_insert_from_select_defaults",
+                InternalTraversal.dp_boolean,
             ),
-            ("_sort_by_parameter_order", InternalTraversal.dp_boolean),
         ]
+        + UpdateBase._return_defaults_traverse_internals
         + HasPrefixes._has_prefixes_traverse_internals
         + DialectKWArgs._dialect_kwargs_traverse_internals
         + ExecutableStatement._executable_traverse_internals
@@ -1661,17 +1670,9 @@ class Update(
             ("_values", InternalTraversal.dp_dml_values),
             ("_returning", InternalTraversal.dp_clauseelement_tuple),
             ("_hints", InternalTraversal.dp_table_hint_list),
-            ("_return_defaults", InternalTraversal.dp_boolean),
             ("_post_criteria_clause", InternalTraversal.dp_clauseelement),
-            (
-                "_return_defaults_columns",
-                InternalTraversal.dp_clauseelement_tuple,
-            ),
-            (
-                "_supplemental_returning",
-                InternalTraversal.dp_clauseelement_tuple,
-            ),
         ]
+        + UpdateBase._return_defaults_traverse_internals
         + HasPrefixes._has_prefixes_traverse_internals
         + DialectKWArgs._dialect_kwargs_traverse_internals
         + ExecutableStatement._executable_traverse_internals
@@ -1874,6 +1875,7 @@ class Delete(
             ("_hints", InternalTraversal.dp_table_hint_list),
             ("_post_criteria_clause", InternalTraversal.dp_clauseelement),
         ]
+        + UpdateBase._return_defaults_traverse_internals
         + HasPrefixes._has_prefixes_traverse_internals
         + DialectKWArgs._dialect_kwargs_traverse_internals
         + ExecutableStatement._executable_traverse_internals

sqlalchemy/sql/selectable.py

@@ -5088,32 +5088,55 @@ class SelectState(util.MemoizedSlots, CompileState):
         correlating.
 
         """
+        statement = self.statement
+        return self._correlate_froms(
+            self.froms,
+            statement,
+            statement._correlate,
+            statement._correlate_except,
+            statement._auto_correlate,
+            explicit_correlate_froms,
+            implicit_correlate_froms,
+        )
+
+    @classmethod
+    def _correlate_froms(
+        cls,
+        froms: List[FromClause],
+        statement: Select[Unpack[TupleAny]],
+        to_correlate: Optional[Sequence[FromClause]],
+        to_correlate_except: Optional[Sequence[FromClause]],
+        auto_correlate: bool,
+        explicit_correlate_froms: Optional[Sequence[FromClause]],
+        implicit_correlate_froms: Optional[Sequence[FromClause]],
+    ) -> List[FromClause]:
+        """Given a list of FROM clauses and correlation settings, return
+        the list of FROM clauses that remain after correlation.
 
-        froms = self.froms
+        This is the implementation for :meth:`.SelectState._get_display_froms`
+        that is also used by the ORM, which needs to know which FROM clauses
+        will be correlated before it has generated the final statement.
 
-        if self.statement._correlate:
-            to_correlate = self.statement._correlate
-            if to_correlate:
-                to_remove = _cloned_intersection(
-                    _cloned_intersection(
-                        froms, explicit_correlate_froms or ()
-                    ),
-                    to_correlate,
-                )
-                froms = [f for f in froms if f not in to_remove]
+        For ``explicit_correlate_froms`` and ``implicit_correlate_froms``,
+        see :meth:`.SQLCompiler._enclosing_correlate_froms`.
 
-        if self.statement._correlate_except is not None:
+        """
+
+        if to_correlate:
+            to_remove = _cloned_intersection(
+                _cloned_intersection(froms, explicit_correlate_froms or ()),
+                to_correlate,
+            )
+            froms = [f for f in froms if f not in to_remove]
+
+        if to_correlate_except is not None:
             to_remove = _cloned_difference(
                 _cloned_intersection(froms, explicit_correlate_froms or ()),
-                self.statement._correlate_except,
+                to_correlate_except,
             )
             froms = [f for f in froms if f not in to_remove]
 
-        if (
-            self.statement._auto_correlate
-            and implicit_correlate_froms
-            and len(froms) > 1
-        ):
+        if auto_correlate and implicit_correlate_froms and len(froms) > 1:
             to_remove = _cloned_intersection(froms, implicit_correlate_froms)
             froms = [f for f in froms if f not in to_remove]
 
@@ -5124,7 +5147,7 @@ class SelectState(util.MemoizedSlots, CompileState):
                     "due to auto-correlation; "
                     "specify correlate(<tables>) "
                     "to control correlation "
-                    "manually." % self.statement
+                    "manually." % statement
                 )
 
         return froms

sqlalchemy/util/langhelpers.py

@@ -1046,6 +1046,8 @@ def class_hierarchy(cls):
     Fibs slightly: subclasses of builtin types are not returned.  Thus
     class_hierarchy(class A(object)) returns (A, object), not A plus every
     class systemwide that derives from object.
+    Likewise, class_hierarchy(class A(Generic[T])) returns
+    (A, Generic, object), not every class systemwide that derives from Generic.
 
     """
 
@@ -1059,7 +1061,11 @@ def class_hierarchy(cls):
             process.append(b)
             hier.add(b)
 
-        if c.__module__ == "builtins" or not hasattr(c, "__subclasses__"):
+        if (
+            c is Generic
+            or c.__module__ == "builtins"
+            or not hasattr(c, "__subclasses__")
+        ):
             continue
 
         for s in [

{sqlalchemy-2.1.5.dist-info → sqlalchemy-2.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SQLAlchemy
-Version: 2.1.5
+Version: 2.1.6
 Summary: Database Abstraction Library
 Author-email: Mike Bayer <mike_mp@zzzcomputing.com>
 License-Expression: MIT
@@ -153,8 +153,7 @@ Major SQLAlchemy features include:
   an extensible Python-based SQL expression
   language, schema metadata, connection pooling,
   type coercion, and custom types.
-* All primary and foreign key constraints are
-  assumed to be composite and natural.  Surrogate
+* Primary and foreign key constraints may be composite and natural. Surrogate
   integer primary keys are of course still the
   norm, but SQLAlchemy never assumes or hardcodes
   to this model.

{sqlalchemy-2.1.5.dist-info → sqlalchemy-2.1.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlalchemy/__init__.py,sha256=Hnbd58adinVx0ixPexLwMYDC8VEemlyvjSGs_dwWw4M,13562
+sqlalchemy/__init__.py,sha256=7wWqnfydTy9a9U0rJ5_9j1FcdJFh6dg1f9SXxDYOQzo,13562
 sqlalchemy/events.py,sha256=vEDW04X_PMhMw5y0_95tbEzht3wua8_gnkMBJstYNRw,525
 sqlalchemy/exc.py,sha256=CKyzx9WSeWTYxueZLAtTFpZTNKSon0YlpGt9v-C8dl8,27503
 sqlalchemy/inspection.py,sha256=2mcgybcOVuQDB2bSIhwidrMteP9qOpEbmehyT2lrnt8,5661
@@ -26,7 +26,7 @@ sqlalchemy/dialects/mysql/__init__.py,sha256=xOiKZDkLvsuyjJxYk1Hp_jwePmTBd2Sw312
 sqlalchemy/dialects/mysql/_mariadb_shim.py,sha256=3RyOxZDknEojK0hpYp9_u3lHOOtmd6tQf0jhgwsVPM0,10819
 sqlalchemy/dialects/mysql/aiomysql.py,sha256=EY0nNh13OixGIMB6rIYqzPr5JTq5QJwkkrnlPY7LIK4,8309
 sqlalchemy/dialects/mysql/asyncmy.py,sha256=LY29o8L4t3d2IU6FD4_At9utbHU9Wsi2-Kr-sKbFceM,7680
-sqlalchemy/dialects/mysql/base.py,sha256=EZl0wlZoJTWHTEWmgL-J8cyJPkMntEmCeJ9p5tkCDP8,135863
+sqlalchemy/dialects/mysql/base.py,sha256=SbDV5qT_rDEZvqRHW8H5FCGr_1IyhZDw-wHZLGSbl60,136000
 sqlalchemy/dialects/mysql/cymysql.py,sha256=GSoPEjug8UXoNxatfhXqC_LhL970arpzrZIItOnvpos,3216
 sqlalchemy/dialects/mysql/dml.py,sha256=gyRfFRoKgZz16YF7kgykp_EH2nvIx2LS4XK0L3JIdQc,9560
 sqlalchemy/dialects/mysql/enumerated.py,sha256=44aqHgDmso9aIcax3hrLZBQdUS3kHrPNMw57s_DDM7w,10215
@@ -84,7 +84,7 @@ sqlalchemy/engine/_processors_cy.py,sha256=Q68s_s1zINR4nFQCfUfMJqjdRWI-J2BIF01tp
 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=No50TjNw8uWfPug5CAgWQjLe6IIA29sZUfgyUEMdED0,124432
+sqlalchemy/engine/base.py,sha256=NwGhPNQTiO0999tIPJmNrVlJR1cWKfLALpe4Ggg-qcY,124749
 sqlalchemy/engine/characteristics.py,sha256=QctD35XaPso4brk2W8zQmdomMkRRV6X7vbeo96eUvA4,4768
 sqlalchemy/engine/create.py,sha256=6iVLjpTt3DcYKwdlwkWZu_Q0DOd2xbXYJt2Zf62oais,34245
 sqlalchemy/engine/cursor.py,sha256=B5NmeqIEsOiPU8QaE4dXh7s1cSp2_5erukysuKs7ipo,85474
@@ -94,10 +94,10 @@ sqlalchemy/engine/interfaces.py,sha256=IKYAaYa-iA44O3bsxsmhyNWwIf3FToX7Wx8N-I9xD
 sqlalchemy/engine/mock.py,sha256=i9J-z0NsL78VlqC85MRgo5SNNQU256UtEqficO3DCwY,4155
 sqlalchemy/engine/processors.py,sha256=uh6xb1ajvSzJufQDG2DmmMeP0VbgaeSHZOJPBSN3mwU,2710
 sqlalchemy/engine/reflection.py,sha256=vbRdfQ00pekzzdC3mwL6gwZ8iFnsVIbiawvDzoXTXBc,77136
-sqlalchemy/engine/result.py,sha256=Z1NMmi3t_ihv5kCLSU4WajyMBhRaCdGQtW3lhWeTB28,66166
+sqlalchemy/engine/result.py,sha256=4a1leqUbZCGJ0eXDeB47_rdDwDIzJbDlVKkvBKeqYVU,66316
 sqlalchemy/engine/row.py,sha256=8LTxWWUKiDerzelGRRNtXe1S66nvcrED4hyJ3kUO9cI,12091
 sqlalchemy/engine/strategies.py,sha256=EUOp1y78tDlpbC2J9XJnyDMH-lVjusFBx_39zCh1khE,439
-sqlalchemy/engine/url.py,sha256=57sVfPuku1qweg2UY2Js7QYd-mHRgOrdLGXP82V-4UA,31025
+sqlalchemy/engine/url.py,sha256=BYgnzXVa15FGaiXsW0_MKd5OkOU4fVSNHXuBd8rjs5g,32295
 sqlalchemy/engine/util.py,sha256=dyPzgmZbPmnVa1eKCTammVdjLUgevNwvBuArAlBuTd4,5702
 sqlalchemy/event/__init__.py,sha256=DfSYrhLMf1nrCnEBeKaZT4bJkksge2cY2Tg506E41mU,1066
 sqlalchemy/event/api.py,sha256=s1qCAQ0yxC3W1erIvTt79QoEvOYo4u44xostJYaBWOs,8109
@@ -121,7 +121,7 @@ sqlalchemy/ext/asyncio/__init__.py,sha256=0MnGUog_nAVA71tE0IAiyqVbOn2Dpt71QpMAf5
 sqlalchemy/ext/asyncio/base.py,sha256=xglkFz_OXJvwEirKp0_dgL45nKkgkM7ayBuQ4OhIi7Q,10137
 sqlalchemy/ext/asyncio/engine.py,sha256=YljEm1OndgZFLzTIJpYDeWu3cXD1H-zex2197AEJE2M,49151
 sqlalchemy/ext/asyncio/exc.py,sha256=XiR-wyLJGuYNwL7yNrjmNq_RvfatH7aU8iXFeF4t-28,817
-sqlalchemy/ext/asyncio/result.py,sha256=MkwK2VAJhJuYKpUEHSxqkUGZYyrMiemureuJwERu6Gg,31714
+sqlalchemy/ext/asyncio/result.py,sha256=EPdEY0Iw50p7cSCh2POkmI-MzupWQqLbpW5ismmf3aE,32296
 sqlalchemy/ext/asyncio/scoping.py,sha256=waZ7UY7dXfyPKbhVUiPjcDGGs3H1axSSm9x4ltY2c18,58731
 sqlalchemy/ext/asyncio/session.py,sha256=-7SvcVsoaQLzAgQqCQP6Qc3h-s1RA-S_kCWzjMXqbbk,74747
 sqlalchemy/ext/declarative/__init__.py,sha256=wrIs8z6am8-rSwDYwoxZntw_3T2Dj_28NbyODnDxA8s,1818
@@ -136,7 +136,7 @@ sqlalchemy/orm/base.py,sha256=IM8QpIF_rKpslfEa3bpZzL2igw_0KJhJ6FJZPvDYq64,30272
 sqlalchemy/orm/bulk_persistence.py,sha256=RXmWN0DaLGtSbSAhgNAQW_QMOGT5l0BCPA3AhMtwQhY,74414
 sqlalchemy/orm/clsregistry.py,sha256=dmIYdM2VTyLVLYiale_x9-JGSK6GpQ0JOqsZuxfSfQE,20241
 sqlalchemy/orm/collections.py,sha256=sc-KrVjRZ1EKArBPn2lqmH9QX7HKr6d2oX0fPV5a4h8,50026
-sqlalchemy/orm/context.py,sha256=F1poIa-NftQTO_cNUfSnbJKjbPQs9kWy6tBEyznTD_8,120868
+sqlalchemy/orm/context.py,sha256=U8NhYbD9oItGws6od3PfN5hBjXNEOKGjSq-2ti7SY00,123933
 sqlalchemy/orm/decl_api.py,sha256=CqKg0SPyvYb2zWK4rVZvScWAhGsT5LEqXWYlkR3aK_w,79344
 sqlalchemy/orm/decl_base.py,sha256=ZbYvSZfSn5l1GPwuX8wXoQiW7SVgJ9Nw4qfMBIDNo6Y,91508
 sqlalchemy/orm/dependency.py,sha256=gqUUJi7LMF2RIEvq7hw_w-WfbpW8CXzSaDW5QTW5NlQ,47739
@@ -157,7 +157,7 @@ sqlalchemy/orm/properties.py,sha256=W-6JnQ5QCGP3OiEwEoNHowFMbhtGpZWXXakUEUJec3g,
 sqlalchemy/orm/query.py,sha256=kltlyhiUqSbfh6dfSpB30n3OrdMTTjA0q4kuQMDZLX8,121505
 sqlalchemy/orm/relationships.py,sha256=huDSvUgKxKms5zcj3jWMKBqoEazs0-vjUrn1Hp2enXM,133724
 sqlalchemy/orm/scoping.py,sha256=eGXEv3sthVrBau1t7XCy-Irq9DA1uc7vpqw0IulAwjk,81158
-sqlalchemy/orm/session.py,sha256=6-nextPWqVjwA7hW79oozm6pXbGHXF7Js3HLfJcgyUQ,203522
+sqlalchemy/orm/session.py,sha256=E-7R3YWPH1WzLAOhG0ikMmb_bvhTMO9wGt3hQAQK634,203823
 sqlalchemy/orm/state.py,sha256=IxVE17w39HuK_U3vYKEGry-TE53ptfdCVuZmHjKn2MM,38600
 sqlalchemy/orm/state_changes.py,sha256=zbtHp9OaZhU80uTQSPyiDyQuCOQZsYil4mdiRa0Lvrw,6809
 sqlalchemy/orm/strategies.py,sha256=jJxPsfhUR_PGNogmrxQ83XiU53oOb9SvqDXphOIbEes,124439
@@ -167,7 +167,7 @@ sqlalchemy/orm/unitofwork.py,sha256=ewxWWxVZw62LndJL0K_L3VFaACe_9m7ub0w-j2vyIjU,
 sqlalchemy/orm/util.py,sha256=sQDShyvhf3Lyy3vGRNcG6aROsBppFidALgFk2hgsqVw,87079
 sqlalchemy/orm/writeonly.py,sha256=LAbF6qIkV6agnH6f9piLFdsPvdewLsvhEagNebd-Kig,23096
 sqlalchemy/pool/__init__.py,sha256=h3EJgaBrR5w7aTqbf9cH8j3qf64jKj4fGe7nQ61jKNg,1714
-sqlalchemy/pool/base.py,sha256=PATgMCc8HI95SCtpIi18QsEAxAaAL6xnviHFSQHCmZ4,55614
+sqlalchemy/pool/base.py,sha256=yP_wXm5On9in-rHXQH_LJKoBdJ-7a7u3Sy8nRrMSf6s,56051
 sqlalchemy/pool/events.py,sha256=Fma2EvUl8XfbnPEYsRYmarRtumYJmpFTExxvO4bmOmk,13455
 sqlalchemy/pool/impl.py,sha256=18axjQPyIIVr8QviQSMd05ok71j6YYj5nYgzSuCljg4,19108
 sqlalchemy/sql/__init__.py,sha256=bQP61xcHeqWHjKiHbA-X3rNakpBKQO2cDnsZ_DSHemk,6438
@@ -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=9vNcKzGXY-gqOl_R42tzwQR0V0MjBNn79OmJmjiVjQo,301830
+sqlalchemy/sql/compiler.py,sha256=Y7xWkxvUobvd3LTPmjd4EnP5lzebKNYdCczpRdnifew,305285
 sqlalchemy/sql/crud.py,sha256=1qtcYPM-p9DsjMaqixYgKVSPuQEK43QEsAdgmXYY_ok,61581
-sqlalchemy/sql/ddl.py,sha256=6vfeMHtVcV6vWBQLxDZ906CHBnnadG5C8vmQNbpY5k8,65048
+sqlalchemy/sql/ddl.py,sha256=lytVJHoLxOU9T0XoHL42hyMMnhqNEzRh7fCmngz8eFg,65052
 sqlalchemy/sql/default_comparator.py,sha256=MC1yWLbOArtLAsVWho_08Jk8ogP6mEgtRP-IxBYFtv4,18684
-sqlalchemy/sql/dml.py,sha256=-j0vtiT_JPyZoxUxtgOwtSOT3BHK_S6BlBR5vzfrzcM,71911
+sqlalchemy/sql/dml.py,sha256=lc6cBkLvDiZkvFLefKo41gBZxhBr3ZcEt7D8Pe3EfjA,71971
 sqlalchemy/sql/elements.py,sha256=zPomd9yuJm5DJ9Jie87V5w2M8Zcv6mrd1nx174QKSmo,196427
 sqlalchemy/sql/events.py,sha256=xpqx3irkG8N3gysXAViLCqXXke9KCSU-6w4zZUdYXzw,18312
 sqlalchemy/sql/expression.py,sha256=SStPoDh7LSBTj6-4_KZSzyH0i5f493lqx4EnwcGPCZU,8342
@@ -198,7 +198,7 @@ sqlalchemy/sql/naming.py,sha256=qBLfM2BizVlnFrDTcZ2AzTiUMml281BiOHRD-Qw1uXg,6705
 sqlalchemy/sql/operators.py,sha256=91HJboxRkDFNHx9JlpO9hsss7wqTfeoANOxjMFszTt0,87215
 sqlalchemy/sql/roles.py,sha256=QG4iNsYMCqjnMP3wt-5lEKxQZIh3uD2yVhurcS-z7VM,7857
 sqlalchemy/sql/schema.py,sha256=v-F5LUroXFN1TjKz4q9bj29z6gf7oAe-k3ejww81-0U,262539
-sqlalchemy/sql/selectable.py,sha256=PcrGphf752_nMgFvA5d5LLUGhio9glG3nrCSEJtbvTs,257803
+sqlalchemy/sql/selectable.py,sha256=x6Q-52QhBrVKVGRxkyZRNvHrjXvo-F6-XRv6dKmWnyc,258794
 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
@@ -254,15 +254,15 @@ sqlalchemy/util/compat.py,sha256=9_xMEtXJsbe5IWgKbqRT9u6bdgmq47c_xXc4FtFmxcc,891
 sqlalchemy/util/concurrency.py,sha256=MpIMr-DqUnsYool27DfOeIMXndyzdWe_JnsktAYxLSc,8849
 sqlalchemy/util/cython.py,sha256=mfWXvmFqP4y3eiA2kGgcgV5GR5sTZfOob32UGY1BYA4,1968
 sqlalchemy/util/deprecations.py,sha256=9X3kYnZcVCEf1hyWU14_RNFahgUejlaLQX78B4UbhP8,12041
-sqlalchemy/util/langhelpers.py,sha256=CmSvEzkhj7IfW6gDrTZPo4NoUSZL60OVhKoYkGKoFBc,84552
+sqlalchemy/util/langhelpers.py,sha256=_Kz4ejcbQ9kfSEyjc817pO8fS5K3O9gRWJpYEOmodS0,84755
 sqlalchemy/util/preloaded.py,sha256=DMfxtGeRyWpnUN3T9NvFdkPkTBPmruWOnUjLqrw8L0M,5975
 sqlalchemy/util/queue.py,sha256=p9FOM0eUWGC_2VK1euQLzQ0gQoUyaGvinEIuKXbKAFw,10237
 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.5.dist-info/licenses/AUTHORS,sha256=3B2wtdF0Va3De2k_-OQJyagPYD5EFpWCVRjDb3hslj4,492
-sqlalchemy-2.1.5.dist-info/licenses/LICENSE,sha256=6GK7W5BPtVE8PhQojXoloS6w7MeEegqWXTEOmpVefLk,1100
-sqlalchemy-2.1.5.dist-info/METADATA,sha256=f1aOpxrs-yl5LM7iyLE0WCXjhdVLfnu6dV5EXlO1aW8,9680
-sqlalchemy-2.1.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-sqlalchemy-2.1.5.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
-sqlalchemy-2.1.5.dist-info/RECORD,,
+sqlalchemy-2.1.6.dist-info/licenses/AUTHORS,sha256=3B2wtdF0Va3De2k_-OQJyagPYD5EFpWCVRjDb3hslj4,492
+sqlalchemy-2.1.6.dist-info/licenses/LICENSE,sha256=6GK7W5BPtVE8PhQojXoloS6w7MeEegqWXTEOmpVefLk,1100
+sqlalchemy-2.1.6.dist-info/METADATA,sha256=8XT7KgUqw2efOZup5ztb1ai9H2mnixRgrryQ63692lA,9662
+sqlalchemy-2.1.6.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+sqlalchemy-2.1.6.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
+sqlalchemy-2.1.6.dist-info/RECORD,,

{sqlalchemy-2.1.5.dist-info → sqlalchemy-2.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any