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

sqlalchemy/__init__.py

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

sqlalchemy/dialects/mssql/base.py

@@ -3780,7 +3780,6 @@ order by
             elif coltype in (
                 MSString,
                 MSChar,
-                MSText,
             ):
                 kwargs["length"] = maxlen if maxlen != -1 else None
                 if collation:
@@ -3788,11 +3787,20 @@ order by
             elif coltype in (
                 MSNVarchar,
                 MSNChar,
-                MSNText,
             ):
                 kwargs["length"] = maxlen // 2 if maxlen != -1 else None
                 if collation:
                     kwargs["collation"] = collation
+            elif coltype in (
+                MSText,
+                MSNText,
+            ):
+                # TEXT / NTEXT are unlengthed LOB types.
+                # sys.columns.max_length reports 16 for these, which is the
+                # size of the in-row LOB pointer and not a character length,
+                # so no length is applied.
+                if collation:
+                    kwargs["collation"] = collation
 
             if coltype is None:
                 if base_type is not None and base_type != type_:

sqlalchemy/dialects/mysql/base.py

@@ -2105,8 +2105,8 @@ class MySQLDDLCompiler(compiler.DDLCompiler):
             "SUBPARTITION_BY",
         ]
 
-        nonpart_options = set(opts).difference(partition_options)
-        part_options = set(opts).intersection(partition_options)
+        nonpart_options = util.OrderedSet(opts).difference(partition_options)
+        part_options = util.OrderedSet(opts).intersection(partition_options)
 
         for opt in topological.sort(
             [

sqlalchemy/dialects/oracle/oracledb.py

@@ -602,6 +602,7 @@ from ... import pool
 from ...connectors.asyncio import AsyncAdapt_dbapi_connection
 from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
 from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
+from ...connectors.asyncio import AsyncAdapt_terminate
 from ...connectors.asyncio import AsyncAdaptFallback_dbapi_connection
 from ...engine import default
 from ...util import asbool
@@ -795,7 +796,9 @@ class AsyncAdapt_oracledb_ss_cursor(
             self._cursor = None  # type: ignore
 
 
-class AsyncAdapt_oracledb_connection(AsyncAdapt_dbapi_connection):
+class AsyncAdapt_oracledb_connection(
+    AsyncAdapt_terminate, AsyncAdapt_dbapi_connection
+):
     _connection: AsyncConnection
     __slots__ = ()
 
@@ -860,6 +863,12 @@ class AsyncAdapt_oracledb_connection(AsyncAdapt_dbapi_connection):
     def tpc_rollback(self, *args: Any, **kwargs: Any) -> Any:
         return self.await_(self._connection.tpc_rollback(*args, **kwargs))
 
+    async def _terminate_graceful_close(self) -> None:
+        await self._connection.close()
+
+    def _terminate_force_close(self) -> None:
+        self._connection.terminate()
+
 
 class AsyncAdaptFallback_oracledb_connection(
     AsyncAdaptFallback_dbapi_connection, AsyncAdapt_oracledb_connection
@@ -918,6 +927,11 @@ class OracleDialectAsync_oracledb(OracleDialect_oracledb):
 
     _min_version = (2,)
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.has_terminate = self.oracledb_ver >= (26, 0, 0)
+
     # thick_mode mode is not supported by asyncio, oracledb will raise
     @classmethod
     def import_dbapi(cls):
@@ -937,6 +951,12 @@ class OracleDialectAsync_oracledb(OracleDialect_oracledb):
     def get_driver_connection(self, connection):
         return connection._connection
 
+    def do_terminate(self, dbapi_connection) -> None:
+        if self.has_terminate:
+            dbapi_connection.terminate()
+        else:
+            super().do_terminate(dbapi_connection)
+
 
 dialect = OracleDialect_oracledb
 dialect_async = OracleDialectAsync_oracledb

sqlalchemy/dialects/postgresql/base.py

@@ -3754,7 +3754,11 @@ class PGDialect(default.DefaultDialect):
     def get_schema_names(self, connection, **kw):
         query = (
             select(pg_catalog.pg_namespace.c.nspname)
-            .where(pg_catalog.pg_namespace.c.nspname.not_like("pg_%"))
+            .where(
+                ~pg_catalog.pg_namespace.c.nspname.startswith(
+                    "pg_", autoescape=True
+                )
+            )
             .order_by(pg_catalog.pg_namespace.c.nspname)
         )
         return connection.scalars(query).all()

sqlalchemy/dialects/sqlite/base.py

@@ -949,6 +949,15 @@ dialect in conjunction with the :class:`_schema.Table` construct:
 
   .. versionadded:: 2.0.37
 
+Both options are also reflected, so that a :class:`_schema.Table` which is
+autoloaded from a database that was created using either keyword will render
+that keyword again when the table is recreated.  The reflected values are
+also available directly from
+:meth:`_engine.Inspector.get_table_options`.
+
+.. versionadded:: 2.0.53  Added reflection support for the ``WITHOUT ROWID``
+   and ``STRICT`` table options.
+
 .. seealso::
 
     `SQLite CREATE TABLE options
@@ -2067,6 +2076,37 @@ class SQLiteExecutionContext(default.DefaultExecutionContext):
             return colname, None
 
 
+# regexp that locates a FOREIGN KEY clause within the verbatim CREATE TABLE
+# text that sqlite stores in sqlite_master.  the referred-columns group
+# requires a non-empty separator between column tokens; an earlier form made
+# the separator optional, which turned the repeat into a nested quantifier and
+# let a long word run backtrack exponentially.  kept at module level so it can
+# be exercised directly from the tests.
+FK_PATTERN = re.compile(
+    r'(?:CONSTRAINT\s+(?:"(.+?)"|(\w+))\s+)?'
+    r"FOREIGN\s+KEY\s*\(\s*(.+?)\s*\)\s+"
+    r'REFERENCES\s+(?:(?:"(.+?)")|([a-z0-9_]+))\s*\(\s*((?:"[^"]+"|[a-z0-9_]+)(?:(?:\s*,\s*|\s+)(?:"[^"]+"|[a-z0-9_]+))*\s*)\)\s*'  # noqa: E501
+    r"((?:ON\s+(?:DELETE|UPDATE)\s+"
+    r"(?:SET\s+NULL|SET\s+DEFAULT|CASCADE|RESTRICT|"
+    r"NO\s+ACTION)\s*)*)"
+    r"((?:NOT\s+)?DEFERRABLE)?"
+    r"(?:\s+INITIALLY\s+(DEFERRED|IMMEDIATE))?",
+    re.I,
+)
+
+# regexp that locates the table option keywords which may trail the closing
+# paren of the column list in the verbatim CREATE TABLE text.  the match is
+# anchored at the end of the statement, which makes the closing paren
+# unambiguous, as neither keyword can itself contain one.  the keywords may
+# be given in either order; as each may appear only once, the repeated group
+# leaves one named group per keyword holding the text that was matched.
+TABLE_OPTIONS_PATTERN = re.compile(
+    r"\)(?:\s*,?\s*(?:(?P<without_rowid>WITHOUT\s+ROWID)"
+    r"|(?P<strict>STRICT)))*\s*$",
+    re.I,
+)
+
+
 class SQLiteDialect(default.DefaultDialect):
     name = "sqlite"
     supports_alter = False
@@ -2381,6 +2421,29 @@ class SQLiteDialect(default.DefaultDialect):
                 f"{schema}.{view_name}" if schema else view_name
             )
 
+    @reflection.cache
+    def get_table_options(self, connection, table_name, schema=None, **kw):
+        tablesql = self._get_table_sql(
+            connection, table_name, schema=schema, **kw
+        )
+
+        options = {}
+
+        # tablesql is None for the internal sqlite_ tables, which have no
+        # entry in sqlite_master
+        if tablesql is not None:
+            match = TABLE_OPTIONS_PATTERN.search(tablesql.strip())
+            if match:
+                if match.group("without_rowid"):
+                    options["sqlite_with_rowid"] = False
+                if match.group("strict"):
+                    options["sqlite_strict"] = True
+
+        if options:
+            return options
+        else:
+            return ReflectionDefaults.table_options()
+
     @reflection.cache
     def get_columns(self, connection, table_name, schema=None, **kw):
         pragma = "table_info"
@@ -2549,7 +2612,7 @@ class SQLiteDialect(default.DefaultDialect):
         constraint_name = None
         table_data = self._get_table_sql(connection, table_name, schema=schema)
         if table_data:
-            PK_PATTERN = r'CONSTRAINT +(?:"(.+?)"|(\w+)) +PRIMARY KEY'
+            PK_PATTERN = r'CONSTRAINT\s+(?:"(.+?)"|(\w+))\s+PRIMARY\s+KEY'
             result = re.search(PK_PATTERN, table_data, re.I)
             if result:
                 constraint_name = result.group(1) or result.group(2)
@@ -2653,16 +2716,7 @@ class SQLiteDialect(default.DefaultDialect):
             # FKs, namely the name of the constraint and other options.
             # so parsing the columns is really about matching it up to what
             # we already have.
-            FK_PATTERN = (
-                r'(?:CONSTRAINT +(?:"(.+?)"|(\w+)) +)?'
-                r"FOREIGN KEY *\( *(.+?) *\) +"
-                r'REFERENCES +(?:(?:"(.+?)")|([a-z0-9_]+)) *\( *((?:(?:"[^"]+"|[a-z0-9_]+) *(?:, *)?)+)\) *'  # noqa: E501
-                r"((?:ON (?:DELETE|UPDATE) "
-                r"(?:SET NULL|SET DEFAULT|CASCADE|RESTRICT|NO ACTION) *)*)"
-                r"((?:NOT +)?DEFERRABLE)?"
-                r"(?: +INITIALLY +(DEFERRED|IMMEDIATE))?"
-            )
-            for match in re.finditer(FK_PATTERN, table_data, re.I):
+            for match in FK_PATTERN.finditer(table_data):
                 (
                     constraint_quoted_name,
                     constraint_name,
@@ -2687,7 +2741,13 @@ class SQLiteDialect(default.DefaultDialect):
                 referred_name = referred_quoted_name or referred_name
                 options = {}
 
-                for token in re.split(r" *\bON\b *", onupdatedelete.upper()):
+                # a newline may separate the words of an
+                # ON DELETE / ON UPDATE clause; normalize to single
+                # spaces so the tokens below compare correctly
+                onupdatedelete = re.sub(
+                    r"\s+", " ", onupdatedelete.upper()
+                ).strip()
+                for token in re.split(r" *\bON\b *", onupdatedelete):
                     if token.startswith("DELETE"):
                         ondelete = token[6:].strip()
                         if ondelete and ondelete != "NO ACTION":
@@ -2770,7 +2830,7 @@ class SQLiteDialect(default.DefaultDialect):
             if table_data is None:
                 return
             UNIQUE_PATTERN = (
-                r'(?:CONSTRAINT +(?:"(.+?)"|(\w+)) +)?UNIQUE *\((.+?)\)'
+                r'(?:CONSTRAINT\s+(?:"(.+?)"|(\w+))\s+)?UNIQUE\s*\((.+?)\)'
             )
             INLINE_UNIQUE_PATTERN = (
                 r'(?:(".+?")|(?:[\[`])?([a-z0-9_]+)(?:[\]`])?)[\t ]'

sqlalchemy/engine/reflection.py

@@ -1758,6 +1758,15 @@ class Inspector(inspection.Inspectable["Inspector"]):
             ):
                 continue
 
+            if len(set(constrained_columns)) != len(constrained_columns):
+                util.warn(
+                    f"On reflected table {table.name}, skipping reflection of "
+                    f"foreign key constraint {conname}; duplicate source "
+                    f"columns within name(s) {', '.join(constrained_columns)} "
+                    "are not supported"
+                )
+                continue
+
             referred_schema = fkey_d["referred_schema"]
             referred_table = fkey_d["referred_table"]
             referred_columns = fkey_d["referred_columns"]

sqlalchemy/ext/asyncio/engine.py

@@ -902,7 +902,7 @@ class AsyncConnection(  # type: ignore[misc]
     # statically generated** by tools/generate_proxy_methods.py
 
     @property
-    def closed(self) -> Any:
+    def closed(self) -> bool:
         r"""Return True if this connection is closed.
 
         .. container:: class_bases
@@ -915,7 +915,7 @@ class AsyncConnection(  # type: ignore[misc]
         return self._proxied.closed
 
     @property
-    def invalidated(self) -> Any:
+    def invalidated(self) -> bool:
         r"""Return True if this connection was invalidated.
 
         .. container:: class_bases
@@ -945,7 +945,7 @@ class AsyncConnection(  # type: ignore[misc]
         self._proxied.dialect = attr
 
     @property
-    def default_isolation_level(self) -> Any:
+    def default_isolation_level(self) -> Optional[IsolationLevel]:
         r"""The initial-connection time isolation level associated with the
         :class:`_engine.Dialect` in use.
 
@@ -1258,7 +1258,7 @@ class AsyncEngine(ProxyComparable[Engine], AsyncConnectable):  # type: ignore[mi
         self._proxied.dialect = attr
 
     @property
-    def engine(self) -> Any:
+    def engine(self) -> Engine:
         r"""Returns this :class:`.Engine`.
 
         .. container:: class_bases
@@ -1275,7 +1275,7 @@ class AsyncEngine(ProxyComparable[Engine], AsyncConnectable):  # type: ignore[mi
         return self._proxied.engine
 
     @property
-    def name(self) -> Any:
+    def name(self) -> str:
         r"""String name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
         in use by this :class:`Engine`.
 
@@ -1290,7 +1290,7 @@ class AsyncEngine(ProxyComparable[Engine], AsyncConnectable):  # type: ignore[mi
         return self._proxied.name
 
     @property
-    def driver(self) -> Any:
+    def driver(self) -> str:
         r"""Driver name of the :class:`~sqlalchemy.engine.interfaces.Dialect`
         in use by this :class:`Engine`.
 

sqlalchemy/ext/asyncio/scoping.py

@@ -48,15 +48,18 @@ if TYPE_CHECKING:
     from ...orm._typing import _IdentityKeyType
     from ...orm._typing import _O
     from ...orm._typing import OrmExecuteOptionsParameter
+    from ...orm.identity import IdentityMap
     from ...orm.interfaces import ORMOption
     from ...orm.session import _BindArguments
     from ...orm.session import _EntityBindKey
     from ...orm.session import _PKIdentityArgument
     from ...orm.session import _SessionBind
+    from ...sql._typing import _InfoType
     from ...sql.base import Executable
     from ...sql.elements import ClauseElement
     from ...sql.selectable import ForUpdateParameter
     from ...sql.selectable import TypedReturnsRows
+    from ...util import IdentitySet
 
 _T = TypeVar("_T", bound=Any)
 
@@ -1305,7 +1308,7 @@ class async_scoped_session(Generic[_AS]):
         self._proxied.bind = attr
 
     @property
-    def dirty(self) -> Any:
+    def dirty(self) -> IdentitySet:
         r"""The set of all persistent instances considered dirty.
 
         .. container:: class_bases
@@ -1344,7 +1347,7 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.dirty
 
     @property
-    def deleted(self) -> Any:
+    def deleted(self) -> IdentitySet:
         r"""The set of all instances marked as 'deleted' within this ``Session``
 
         .. container:: class_bases
@@ -1363,7 +1366,7 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.deleted
 
     @property
-    def new(self) -> Any:
+    def new(self) -> IdentitySet:
         r"""The set of all instances marked as 'new' within this ``Session``.
 
         .. container:: class_bases
@@ -1382,7 +1385,7 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.new
 
     @property
-    def identity_map(self) -> Any:
+    def identity_map(self) -> IdentityMap:
         r"""Proxy for the :attr:`_orm.Session.identity_map` attribute
         on behalf of the :class:`_asyncio.AsyncSession` class.
 
@@ -1397,11 +1400,11 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.identity_map
 
     @identity_map.setter
-    def identity_map(self, attr: Any) -> None:
+    def identity_map(self, attr: IdentityMap) -> None:
         self._proxied.identity_map = attr
 
     @property
-    def is_active(self) -> Any:
+    def is_active(self) -> bool:
         r"""True if this :class:`.Session` not in "partial rollback" state.
 
         .. container:: class_bases
@@ -1444,7 +1447,7 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.is_active
 
     @property
-    def autoflush(self) -> Any:
+    def autoflush(self) -> bool:
         r"""Proxy for the :attr:`_orm.Session.autoflush` attribute
         on behalf of the :class:`_asyncio.AsyncSession` class.
 
@@ -1459,7 +1462,7 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.autoflush
 
     @autoflush.setter
-    def autoflush(self, attr: Any) -> None:
+    def autoflush(self, attr: bool) -> None:
         self._proxied.autoflush = attr
 
     @property
@@ -1498,7 +1501,7 @@ class async_scoped_session(Generic[_AS]):
         return self._proxied.no_autoflush
 
     @property
-    def info(self) -> Any:
+    def info(self) -> _InfoType:
         r"""A user-modifiable dictionary.
 
         .. container:: class_bases

sqlalchemy/ext/asyncio/session.py

@@ -68,6 +68,7 @@ if TYPE_CHECKING:
     from ...sql.elements import ClauseElement
     from ...sql.selectable import ForUpdateParameter
     from ...sql.selectable import TypedReturnsRows
+    from ...util import IdentitySet
 
 _AsyncSessionBind = Union["AsyncEngine", "AsyncConnection"]
 
@@ -1385,7 +1386,7 @@ class AsyncSession(ReversibleProxy[Session]):
         return self._proxied.in_nested_transaction()
 
     @property
-    def dirty(self) -> Any:
+    def dirty(self) -> IdentitySet:
         r"""The set of all persistent instances considered dirty.
 
         .. container:: class_bases
@@ -1418,7 +1419,7 @@ class AsyncSession(ReversibleProxy[Session]):
         return self._proxied.dirty
 
     @property
-    def deleted(self) -> Any:
+    def deleted(self) -> IdentitySet:
         r"""The set of all instances marked as 'deleted' within this ``Session``
 
         .. container:: class_bases
@@ -1431,7 +1432,7 @@ class AsyncSession(ReversibleProxy[Session]):
         return self._proxied.deleted
 
     @property
-    def new(self) -> Any:
+    def new(self) -> IdentitySet:
         r"""The set of all instances marked as 'new' within this ``Session``.
 
         .. container:: class_bases
@@ -1457,7 +1458,7 @@ class AsyncSession(ReversibleProxy[Session]):
         self._proxied.identity_map = attr
 
     @property
-    def is_active(self) -> Any:
+    def is_active(self) -> bool:
         r"""True if this :class:`.Session` not in "partial rollback" state.
 
         .. container:: class_bases
@@ -1536,7 +1537,7 @@ class AsyncSession(ReversibleProxy[Session]):
         return self._proxied.no_autoflush
 
     @property
-    def info(self) -> Any:
+    def info(self) -> _InfoType:
         r"""A user-modifiable dictionary.
 
         .. container:: class_bases

sqlalchemy/orm/relationships.py

@@ -3115,10 +3115,12 @@ class JoinCondition:
             secondary_sync_pairs
         )
 
+    # ensure all references are weak so that no self-referencing cycles
+    # may form
     _track_overlapping_sync_targets: weakref.WeakKeyDictionary[
         ColumnElement[Any],
         weakref.WeakKeyDictionary[
-            RelationshipProperty[Any], ColumnElement[Any]
+            RelationshipProperty[Any], weakref.ref[ColumnElement[Any]]
         ],
     ] = weakref.WeakKeyDictionary()
 
@@ -3145,13 +3147,16 @@ class JoinCondition:
 
             if to_ not in self._track_overlapping_sync_targets:
                 self._track_overlapping_sync_targets[to_] = (
-                    weakref.WeakKeyDictionary({self.prop: from_})
+                    weakref.WeakKeyDictionary({self.prop: weakref.ref(from_)})
                 )
             else:
                 other_props = []
                 prop_to_from = self._track_overlapping_sync_targets[to_]
 
-                for pr, fr_ in prop_to_from.items():
+                for pr, fr_ref in prop_to_from.items():
+                    fr_ = fr_ref()
+                    if fr_ is None:
+                        continue
                     if (
                         not pr.mapper._dispose_called
                         and pr not in self.prop._reverse_property
@@ -3206,7 +3211,9 @@ class JoinCondition:
                         ),
                         code="qzyx",
                     )
-                self._track_overlapping_sync_targets[to_][self.prop] = from_
+                self._track_overlapping_sync_targets[to_][self.prop] = (
+                    weakref.ref(from_)
+                )
 
     @util.memoized_property
     def remote_columns(self) -> Set[ColumnElement[Any]]:

sqlalchemy/orm/scoping.py

@@ -57,6 +57,7 @@ if TYPE_CHECKING:
     from ..engine.interfaces import CoreExecuteOptionsParameter
     from ..engine.result import ScalarResult
     from ..sql._typing import _ColumnsClauseArgument
+    from ..sql._typing import _InfoType
     from ..sql._typing import _T0
     from ..sql._typing import _T1
     from ..sql._typing import _T2
@@ -71,6 +72,7 @@ if TYPE_CHECKING:
     from ..sql.roles import TypedColumnsClauseRole
     from ..sql.selectable import ForUpdateParameter
     from ..sql.selectable import TypedReturnsRows
+    from ..util import IdentitySet
 
 _T = TypeVar("_T", bound=Any)
 
@@ -1909,7 +1911,7 @@ class scoped_session(Generic[_S]):
         self._proxied.bind = attr
 
     @property
-    def dirty(self) -> Any:
+    def dirty(self) -> IdentitySet:
         r"""The set of all persistent instances considered dirty.
 
         .. container:: class_bases
@@ -1942,7 +1944,7 @@ class scoped_session(Generic[_S]):
         return self._proxied.dirty
 
     @property
-    def deleted(self) -> Any:
+    def deleted(self) -> IdentitySet:
         r"""The set of all instances marked as 'deleted' within this ``Session``
 
         .. container:: class_bases
@@ -1955,7 +1957,7 @@ class scoped_session(Generic[_S]):
         return self._proxied.deleted
 
     @property
-    def new(self) -> Any:
+    def new(self) -> IdentitySet:
         r"""The set of all instances marked as 'new' within this ``Session``.
 
         .. container:: class_bases
@@ -1981,7 +1983,7 @@ class scoped_session(Generic[_S]):
         self._proxied.identity_map = attr
 
     @property
-    def is_active(self) -> Any:
+    def is_active(self) -> bool:
         r"""True if this :class:`.Session` not in "partial rollback" state.
 
         .. container:: class_bases
@@ -2060,7 +2062,7 @@ class scoped_session(Generic[_S]):
         return self._proxied.no_autoflush
 
     @property
-    def info(self) -> Any:
+    def info(self) -> _InfoType:
         r"""A user-modifiable dictionary.
 
         .. container:: class_bases

sqlalchemy/orm/strategies.py

@@ -67,6 +67,13 @@ if TYPE_CHECKING:
     from ..sql.elements import ColumnElement
 
 
+# sentinel for _LoadLazyAttribute.extra_criteria indicating that the loader
+# option had no additional criteria.  the attribute is otherwise a single
+# element returned by Load._generate_extra_criteria(), which has no
+# meaningful boolean value of its own.
+_NO_EXTRA_CRITERIA = None
+
+
 def _register_attribute(
     prop,
     mapper,
@@ -1209,7 +1216,7 @@ class LazyLoader(
                     (
                         loadopt._generate_extra_criteria(context)
                         if loadopt._extra_criteria
-                        else None
+                        else _NO_EXTRA_CRITERIA
                     ),
                 ),
                 key,
@@ -1257,7 +1264,7 @@ class LoadLazyAttribute:
         self.extra_criteria = extra_criteria
 
     def __getstate__(self):
-        if self.extra_criteria is not None:
+        if self.extra_criteria is not _NO_EXTRA_CRITERIA:
             util.warn(
                 "Can't reliably serialize a lazyload() option that "
                 "contains additional criteria; please use eager loading "
@@ -1267,7 +1274,7 @@ class LoadLazyAttribute:
             "key": self.key,
             "strategy_key": self.strategy_key,
             "loadopt": self.loadopt,
-            "extra_criteria": (),
+            "extra_criteria": _NO_EXTRA_CRITERIA,
         }
 
     def __call__(self, state, passive=attributes.PASSIVE_OFF):