TypeDAL 5.1.2__tar.gz → 5.1.4__tar.gz

{typedal-5.1.2 → typedal-5.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: TypeDAL
-Version: 5.1.2
+Version: 5.1.4
 Summary: Typing support for PyDAL
 Keywords: 
 Author: Robin van der Noord
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: pydal>=20251012.3
+Requires-Dist: pydal-stubs>=0.1.0
 Requires-Dist: dill<1
 Requires-Dist: configuraptor>=2.1.0,<3
 Requires-Dist: configurable-json<2

{typedal-5.1.2 → typedal-5.1.4}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 name = "TypeDAL"
 description = "Typing support for PyDAL"
 readme = "README.md"
-version = "5.1.2"
+version = "5.1.4"
 requires-python = ">=3.12"
 license-expression = "MIT"
 keywords = []
@@ -21,6 +21,7 @@ classifiers = [
 ]
 dependencies = [
     "pydal >= 20251012.3",
+    "pydal-stubs >= 0.1.0",
     "dill < 1",
     "configuraptor >= 2.1.0, < 3",
     "Configurable-JSON < 2",
@@ -226,7 +227,10 @@ extend-ignore = [
     "D212",
     "D418",
 ]
-ignore = ["RUF013"]
+ignore = [
+    "RUF012",
+    "RUF013",
+]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{typedal-5.1.2 → typedal-5.1.4}/pyproject.toml.orig

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 name = "TypeDAL"
 description = 'Typing support for PyDAL'
 readme = "README.md"
-version = "5.1.2"
+version = "5.1.4"
 requires-python = ">=3.12"
 license-expression = "MIT"
 keywords = []
@@ -24,6 +24,7 @@ classifiers = [
 ]
 dependencies = [
     "pydal >= 20251012.3", # core
+    "pydal-stubs >= 0.1.0", # improved typing for pydal
     "dill < 1", # caching
     "configuraptor >= 2.1.0, < 3", # config
     "Configurable-JSON < 2", # json dumping
@@ -270,7 +271,8 @@ extend-ignore = [
 ]
 
 ignore = [
-    "RUF013" # implicit optional
+    "RUF012", # mutable class attributes
+    "RUF013", # implicit optional
 ]
 
 

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/cli.py

@@ -227,7 +227,7 @@ def setup(
     data.pop("connection", None)
 
     # ignore any None:
-    old_contents["tool"]["typedal"] = {k: v for k, v in data.items() if v is not None}
+    old_contents["tool"]["typedal"] = {k: v for k, v in data.items() if v is not None}  # type: ignore
 
     with toml_path.open("w") as f:
         tomlkit.dump(old_contents, f)

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/core.py

@@ -46,7 +46,7 @@ except ImportError:  # pragma: no cover
 if t.TYPE_CHECKING:
     from .fields import TypedField
     from .query_builder import QueryBuilder
-    from .types import AnyDict, DefineKwargs, Rows, Set, T_Query, Table
+    from .types import AnyDict, DefineKwargs, Rows, T_Query, Table
 
 
 def _expression_subclasses() -> t.Iterator[type[Expression]]:
@@ -200,36 +200,8 @@ def resolve_annotation(ftype: str, namespace: t.Mapping[str, type] | None = None
         return resolve_annotation_314(ftype, namespace=namespace)
 
 
-if t.TYPE_CHECKING:
-
-    class _TypeDALBase:
-        # attributes accessed throughout the codebase
-        _adapter: t.Any
-        _migrate: t.Any
-        representers: t.Any
-
-        def __init__(self, *args: t.Any, **kwargs: t.Any) -> None: ...
-
-        def __call__(self, query: t.Any = None) -> "Set": ...
-
-        def commit(self) -> None: ...
-
-        def rollback(self) -> None: ...
-
-        def define_table(self, *args: t.Any, **kwargs: t.Any) -> "Table": ...
-
-        def has_representer(self, field_type: str) -> bool: ...
-
-        def represent(self, name: str, *args: t.Any, **kwargs: t.Any) -> str: ...
-
-        # pydal exposes dynamic table attributes like `db.my_table`.
-        # this keeps type checkers from flagging these as missing attributes.
-        def __getattr__(self, item: str) -> "Table": ...
-
-else:
-
-    class _TypeDALBase(pydal.DAL):
-        pass
+class _TypeDALBase(pydal.DAL):
+    pass
 
 
 class TypeDAL(_TypeDALBase):
@@ -251,7 +223,7 @@ class TypeDAL(_TypeDALBase):
     _async_workers: ConnectionWorkerPool
 
     # pydal runs these around every statement; drop BlockingAccessHandler to disable the guard.
-    execution_handlers: t.ClassVar[list[type[ExecutionHandler]]] = [
+    execution_handlers: list[type[ExecutionHandler]] = [
         *pydal.DAL.execution_handlers,
         BlockingAccessHandler,
     ]
@@ -419,7 +391,7 @@ class TypeDAL(_TypeDALBase):
         self._async_workers.shutdown()
         adapter = self._adapter
         try:
-            super().close()  # ty: ignore[unresolved-attribute]
+            super().close()
         finally:
             for model in set(self._builder.class_map.values()):
                 model.unbind()
@@ -447,7 +419,9 @@ class TypeDAL(_TypeDALBase):
                         hooks.clear()
 
                 if hasattr(table, "_db"):
-                    table._db = None
+                    # outside pydal's contract: pydal only ever nulls a *field's*
+                    # bindings, but the cycle has to be broken here too.
+                    table._db = None  # ty: ignore[invalid-assignment]
 
                 for field_name in getattr(table, "fields", ()):
                     field: Field | None = getattr(table, field_name, None)
@@ -561,7 +535,9 @@ class TypeDAL(_TypeDALBase):
             db(query).select()
 
         """
-        args = list(_args)
+        # heterogeneous on purpose: this list is splatted across pydal's
+        # (query, ignore_common_filters) parameters.
+        args: list[t.Any] = list(_args)
         if args:
             cls = args[0]
             if isinstance(cls, bool):
@@ -584,7 +560,7 @@ class TypeDAL(_TypeDALBase):
         Example:
             db['users'] -> user
         """
-        return t.cast(Table, super().__getitem__(str(key)))  # ty: ignore[unresolved-attribute]
+        return super().__getitem__(str(key))
 
     def find_model(self, table_name: str) -> t.Type["TypedTable"] | None:
         """
@@ -664,7 +640,7 @@ class TypeDAL(_TypeDALBase):
         if SYSTEM_SUPPORTS_TEMPLATES and isinstance(query, Template):  # pragma: no cover
             query = sql_escape_template(self, query)
 
-        rows: list[t.Any] = super().executesql(  # ty: ignore[unresolved-attribute]
+        rows: list[t.Any] = super().executesql(
             query,
             placeholders=placeholders,
             as_dict=as_dict,

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/define.py

@@ -133,7 +133,7 @@ class TableDefinitionBuilder:
 
             table._after_insert.append(lambda _row, _id: remove_cache_for_table(tablename))
             table._before_update.append(lambda s, _: _remove_cache(s, tablename))
-            table._before_delete.append(lambda s: _remove_cache(s, tablename))  # ty: ignore[invalid-argument-type]
+            table._before_delete.append(lambda s: _remove_cache(s, tablename))
 
         return cls
 

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/fields.py

@@ -268,7 +268,7 @@ class TypedField[T_Value](Expression):  # pragma: no cover
         if not self._field:  # pragma: no cover
             raise ValueError("Unbound Field can not be inverted!")
 
-        return t.cast(Expression, ~self._field)
+        return ~self._field
 
     def lower(self) -> Expression:
         """
@@ -277,7 +277,7 @@ class TypedField[T_Value](Expression):  # pragma: no cover
         if not self._field:  # pragma: no cover
             raise ValueError("Unbound Field can not be lowered!")
 
-        return t.cast(Expression, self._field.lower())
+        return self._field.lower()
 
 
 def rname(field: TypedField[t.Any] | Field) -> str:

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/helpers.py

@@ -311,7 +311,7 @@ def get_table(table: "TypedTable | Table") -> "Table":
     """
     Get the underlying pydal table for a typedal table.
     """
-    return t.cast("Table", table._table)  # ty: ignore[unresolved-attribute]
+    return t.cast("Table", table._table)
 
 
 def get_field(field: "TypedField[t.Any] | Field") -> "Field":

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/query_builder.py

@@ -111,7 +111,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable](Select):
         """
         self.model = model
         table = self._ensure_table_defined()
-        default_query: Query = t.cast(Query, table.id > 0)  # ty: ignore[unresolved-attribute]
+        default_query: Query = table.id > 0
         self.query = add_query or default_query
         self.select_args = select_args or []
         self.select_kwargs = select_kwargs or {}
@@ -152,7 +152,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable](Select):
         Querybuilder is truthy if it has t.Any conditions.
         """
         table = self._ensure_table_defined()
-        default_query: Query = t.cast(Query, table.id > 0)  # ty: ignore[unresolved-attribute]
+        default_query: Query = table.id > 0
         return any(
             [
                 self.query != default_query,
@@ -330,13 +330,14 @@ class QueryBuilder[T_MetaInstance: _TypedTable](Select):
                 subquery |= t.cast(Query, query_part)
             elif callable(query_part):
                 if result := query_part(self.model):
-                    subquery |= result
+                    subquery |= t.cast(Query, result)
             elif isinstance(query_part, dict):
                 subsubquery = DummyQuery()
                 for field, value in query_part.items():
                     subsubquery &= table[field] == value
                 if subsubquery:
-                    subquery |= subsubquery
+                    # DummyQuery is falsy, so reaching here means it became a Query.
+                    subquery |= t.cast(Query, subsubquery)
             else:
                 raise ValueError(f"Unexpected query type ({type(query_part)}).")
 
@@ -559,7 +560,9 @@ class QueryBuilder[T_MetaInstance: _TypedTable](Select):
         db = self._get_db()
         return str(db(self.query)._delete())
 
-    def update(self, **fields: t.Any) -> list[int]:
+    # QueryBuilder subclasses Select for its query-building surface but yields
+    # model instances rather than fields, so these two are not substitutable.
+    def update(self, **fields: t.Any) -> list[int]:  # ty: ignore[invalid-method-override]
         """
         Based on the current query, update `fields` and return a list of updated IDs.
         """
@@ -1262,7 +1265,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable](Select):
         """
         return self.collect() or throw(exception or ValueError("Nothing found!"))
 
-    def __iter__(self) -> t.Generator[T_MetaInstance, None, None]:
+    def __iter__(self) -> t.Generator[T_MetaInstance, None, None]:  # ty: ignore[invalid-method-override]
         """
         You can start iterating a Query Builder object before calling collect, for ease of use.
         """

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/rows.py

@@ -106,7 +106,10 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
         """
         return ind in self.records
 
-    def first(self) -> T_MetaInstance | None:
+    # TypedRows deliberately re-types pydal's row container: its elements are
+    # _TypedTable instances, which are row-like but not pydal Rows. The overrides
+    # below therefore narrow Row to T_MetaInstance and are not Liskov-substitutable.
+    def first(self) -> T_MetaInstance | None:  # ty: ignore[invalid-method-override]
         """
         Get the row with the lowest id.
         """
@@ -115,7 +118,7 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
 
         return next(iter(self))
 
-    def last(self) -> T_MetaInstance | None:
+    def last(self) -> T_MetaInstance | None:  # ty: ignore[invalid-method-override]
         """
         Get the row with the highest id.
         """
@@ -125,7 +128,7 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
         max_id = max(self.records.keys())
         return self[max_id]
 
-    def find(
+    def find(  # ty: ignore[invalid-method-override]
         self,
         f: t.Callable[[T_MetaInstance], Query],
         limitby: tuple[int, int] | None = None,
@@ -152,7 +155,9 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
 
         return self.__class__(self, self.model, records)
 
-    def exclude(self, f: t.Callable[[T_MetaInstance], Query]) -> "TypedRows[T_MetaInstance]":
+    def exclude(  # ty: ignore[invalid-method-override]
+        self, f: t.Callable[[T_MetaInstance], Query]
+    ) -> "TypedRows[T_MetaInstance]":
         """
         Removes elements from the calling Rows object, filtered by the function `f`, \
             and returns a new Rows object containing the removed elements.
@@ -175,7 +180,9 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
             removed,
         )
 
-    def sort(self, f: t.Callable[[T_MetaInstance], t.Any], reverse: bool = False) -> list[T_MetaInstance]:
+    def sort(  # ty: ignore[invalid-method-override]
+        self, f: t.Callable[[T_MetaInstance], t.Any], reverse: bool = False
+    ) -> list[T_MetaInstance]:
         """
         Returns a list of sorted elements (not sorted in place).
         """
@@ -240,7 +247,7 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
         """
         Dump the data to csv.
         """
-        return t.cast(str, super().as_csv())
+        return super().as_csv()
 
     def as_dict(
         self,
@@ -283,7 +290,7 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
 
     def json(
         self, default: t.Callable[[t.Any], t.Any] | None = None, indent: int | None = None, **kwargs: t.Any
-    ) -> str:  # ty: ignore[invalid-method-override]
+    ) -> str:
         """
         Turn the data into a dict and then dump to JSON.
         """
@@ -360,7 +367,7 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
         """
         return await run_async(self.db, self.delete)
 
-    def join(
+    def join(  # ty: ignore[invalid-method-override]
         self,
         field: "Field | TypedField[t.Any]",
         name: str | None = None,
@@ -373,7 +380,9 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
 
         Using the querybuilder's .join() method is prefered!
         """
-        result = super().join(field, name, constraint, fields or [], orderby)
+        # TypedField is an Expression, not a pydal Field, but carries the
+        # .name/.tablename attributes join() actually reads.
+        result = super().join(field, name, constraint, fields or [], orderby)  # ty: ignore[invalid-argument-type]
         return t.cast(T_MetaInstance, result)
 
     def export_to_csv_file(
@@ -465,7 +474,7 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
     ) -> T_MetaInstance:
         """With an index, return one rendered row instance."""
 
-    def render(
+    def render(  # ty: ignore[invalid-method-override]
         self,
         i: int | None = None,
         fields: list[Field] | None = None,
@@ -569,7 +578,7 @@ class TypedSet(Set):  # pragma: no cover
         Count returns an int.
         """
         result = super().count(distinct, cache)
-        return t.cast(int, result)
+        return result
 
     def select(self, *fields: t.Any, **attributes: t.Any) -> TypedRows[T_MetaInstance]:
         """

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/tables.py

@@ -198,7 +198,7 @@ class TableMeta(type):
         Allow dict notation to get a column of this table (-> Field instance).
         """
         table = self._ensure_table_defined()
-        return t.cast(Field, table[item])
+        return table[item]
 
     def __str__(self) -> str:
         """
@@ -766,7 +766,7 @@ class TableMeta(type):
             http://web2py.com/books/default/chapter/29/06/the-database-abstraction-layer?search=export_to_csv_file#One-to-mt.Any-relation
         """
         table = self._ensure_table_defined()
-        return t.cast(Expression, table.on(query))
+        return table.on(query)
 
     def with_alias(self: t.Type[T_MetaInstance], alias: str) -> t.Type[T_MetaInstance]:
         """
@@ -1321,7 +1321,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         """
         table = cls._ensure_table_defined()
         result = table.as_dict(flat, sanitize)
-        return t.cast(AnyDict, result)
+        return result
 
     @classmethod
     def as_typeddict(
@@ -1441,7 +1441,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         - dumps the row info if it's an instance (see _as_xml)
         """
         table = cls._ensure_table_defined()
-        return t.cast(str, table.as_xml(sanitize))
+        return table.as_xml(sanitize)
 
     @classmethod
     def as_yaml(cls, sanitize: bool = True) -> str:
@@ -1453,7 +1453,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         - dumps the row info if it's an instance (see _as_yaml)
         """
         table = cls._ensure_table_defined()
-        return t.cast(str, table.as_yaml(sanitize))
+        return table.as_yaml(sanitize)
 
     def _as_dict(
         self,
@@ -1483,7 +1483,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
 
                 result[relationship] = data
 
-        return t.cast(AnyDict, result)
+        return result
 
     def _as_json(
         self,
@@ -1494,9 +1494,11 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         data = self._as_dict()
         return as_json.encode(data, default=default, indent=indent, **kwargs)
 
-    def _as_xml(self, sanitize: bool = True) -> str:  # pragma: no cover
+    def _as_xml(self, sanitize: bool = True) -> str:  # noqa: ARG002  # pragma: no cover
         row = self._ensure_matching_row()
-        return t.cast(str, row.as_xml(sanitize))
+        # pydal's Row.as_xml has no sanitize flag (its first parameter is the
+        # element name), so the argument is intentionally not forwarded.
+        return row.as_xml()
 
     # def _as_yaml(self, sanitize: bool = True) -> str:
     #     row = self._ensure_matching_row()

{typedal-5.1.2 → typedal-5.1.4}/src/typedal/types.py

@@ -116,7 +116,7 @@ class TableProtocol(t.Protocol):  # pragma: no cover
         Tables have table[field] syntax.
         """
 
-    def on(self, query: "QueryLike") -> "Expression | _Expression":
+    def on(self, query: "QueryLike") -> "Expression":
         """
         PyDAL `Table.on(query)` helper used in join callbacks.
         """
@@ -151,78 +151,18 @@ class FileSystemLike(t.Protocol):  # pragma: no cover
 # same for typing and runtime:
 Row: t.TypeAlias = _Row
 Validator: t.TypeAlias = _Validator
-Table: t.TypeAlias = _Table
 Reference: t.TypeAlias = _Reference
 
-# has to be (fake) subclass during type-checking:
-if t.TYPE_CHECKING:
-
-    class Query(_Query):
-        """Pydal Query object. Makes mypy happy."""
-
-    class Expression(_Expression):
-        """Pydal Expression object. Makes mypy happy."""
-
-    class Set(_Set):
-        """Pydal Set object. Makes mypy happy."""
-
-    class Select(_Select):
-        """Pydal Select object. Makes mypy happy."""
-
-    class OpRow:
-        """
-        Pydal OpRow object for typing (otherwise mypy thinks it's Any).
-        """
-
-        def __getattr__(self, name: str) -> t.Any:
-            """Dynamic attribute access (e.g. row.email)."""
-
-        def __getitem__(self, item: str) -> t.Any:
-            """row.item syntax."""
-
-        def __setitem__(self, key: str, value: t.Any) -> None:
-            """row.item = key syntax."""
-
-        def get(self, key: str, default: t.Any = None) -> t.Any:
-            """Dictionary-like get used by update hooks."""
-
-        def keys(self) -> t.Iterable[str]:
-            """Dictionary-like key access."""
-
-        def items(self) -> t.Iterable[tuple[str, t.Any]]:
-            """Dictionary-like item iteration."""
-
-        def values(self) -> t.Iterable[t.Any]:
-            """Dictionary-like value iteration."""
-
-    class Field(_Field):
-        """Pydal Field object. Make mypy happy."""
-
-        _rname: str
-
-        def __eq__(self, other: t.Any) -> Query:  # ty: ignore[invalid-method-override]
-            """Comparing fields produces a PyDAL query."""
-            return t.cast(Query, super().__eq__(other))
-
-        def __ne__(self, other: t.Any) -> Query:  # ty: ignore[invalid-method-override]
-            """Comparing fields produces a PyDAL query."""
-            return t.cast(Query, super().__ne__(other))
-
-        def __hash__(self) -> int:
-            """Keep fields hashable after overriding equality."""
-            return super().__hash__()
-
-    class Rows(_Rows):
-        def column(self, column: t.Any = None) -> list[t.Any]: ...
-
-else:
-    Query: t.TypeAlias = _Query
-    Expression: t.TypeAlias = _Expression
-    Set: t.TypeAlias = _Set
-    Select: t.TypeAlias = _Select
-    Rows: t.TypeAlias = _Rows
-    OpRow: t.TypeAlias = _OpRow
-    Field: t.TypeAlias = _Field
+# pydal ships PEP 561 stubs (pydal-stubs), so these need no type-checking-only
+# subclass to carry extra declarations; plain aliases keep one name per concept.
+Query: t.TypeAlias = _Query
+Expression: t.TypeAlias = _Expression
+Set: t.TypeAlias = _Set
+Select: t.TypeAlias = _Select
+Table: t.TypeAlias = _Table
+Field: t.TypeAlias = _Field
+Rows: t.TypeAlias = _Rows
+OpRow: t.TypeAlias = _OpRow
 
 
 # ---------------------------------------------------------------------------
@@ -414,7 +354,7 @@ type T_Field = t.Union["TypedField[t.Any]", "Table", t.Type["TypedTable"]]
 # checked while its dynamic attribute fallback covers model-specific fields.
 type P_Table = TableProtocol
 
-type QueryLike = Query | _Query | bool
+type QueryLike = Query | bool
 
 type Condition = t.Callable[[type["TypedTable"], type["TypedTable"]], QueryLike] | None