TypeDAL 4.4.6__tar.gz → 4.5.0__tar.gz

{typedal-4.4.6 → typedal-4.5.0}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!--next-version-placeholder-->
 
+## v4.5.0 (2026-03-06)
+
+### Feature
+
+* **typing:** Support mixin-typed table class APIs without MRO conflicts ([`fe0c99e`](https://github.com/trialandsuccess/TypeDAL/commit/fe0c99eb2790baff8ddf4de3ec1f23c53e4b3a11))
+
 ## v4.4.6 (2026-03-05)
 
 ### Fix

{typedal-4.4.6 → typedal-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.4.6
+Version: 4.5.0
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "4.4.6"
+__version__ = "4.5.0"

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/cli.py

@@ -392,7 +392,8 @@ def fake_migrations(
 
     previously_migrated = (
         db(
-            db.ewh_implemented_features.name.belongs(to_fake) & (db.ewh_implemented_features.installed == True)  # noqa E712
+            db.ewh_implemented_features.name.belongs(to_fake)
+            & (db.ewh_implemented_features.installed == True)  # noqa E712
         )
         .select(db.ewh_implemented_features.name)
         .column("name")

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/fields.py

@@ -31,7 +31,7 @@ from .types import (
 
 if t.TYPE_CHECKING:
     # will be imported for real later:
-    from .tables import TypedTable
+    from .tables import TypedTable, _TypedTable
 
 
 ## general
@@ -79,7 +79,7 @@ class TypedField(Expression, t.Generic[T_Value]):  # pragma: no cover
         """
 
     @t.overload
-    def __get__(self, instance: None, owner: "t.Type[TypedTable]") -> "TypedField[T_Value]":  # pragma: no cover
+    def __get__(self, instance: None, owner: "t.Type[_TypedTable]") -> "TypedField[T_Value]":  # pragma: no cover
         """
         Table.field -> Field.
         """

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/mixins.py

@@ -16,21 +16,18 @@ from slugify import slugify
 
 from .core import TypeDAL
 from .fields import DatetimeField, StringField
-from .tables import _TypedTable
+from .tables import TableMeta, _TypedTable
 from .types import OpRow, Set, T_MetaInstance
 
-if t.TYPE_CHECKING:
-    from .tables import TypedTable  # noqa: F401
 
-
-class Mixin(_TypedTable):
+class Mixin(_TypedTable, metaclass=TableMeta):
     """
     A mixin should be derived from this class.
 
     The mixin base class itself doesn't do anything,
     but using it makes sure the mixin fields are placed AFTER the table's normal fields (instead of before)
 
-    During runtime, mixin should not have a base class in order to prevent MRO issues
+    During runtime, mixin should not inherit from TypedTable to prevent MRO issues
         ('inconsistent method resolution' or 'metaclass conflicts')
     """
 

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/query_builder.py

@@ -23,7 +23,7 @@ from .helpers import (
     normalize_table_keys,
     throw,
 )
-from .tables import TableMeta, TypedTable
+from .tables import TableMeta, TypedTable, _TypedTable
 from .types import (
     CacheMetadata,
     Condition,
@@ -698,7 +698,7 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         return joins
 
     def _build_inner_joins_recursive(
-        self, relation: Relationship[t.Any], parent_table: t.Type[TypedTable], key: str, parent_key: str = ""
+        self, relation: Relationship[t.Any], parent_table: t.Type[_TypedTable], key: str, parent_key: str = ""
     ) -> list[t.Any]:
         """Recursively build inner joins for a relationship and its nested relationships."""
         db = self._get_db()
@@ -764,7 +764,7 @@ class QueryBuilder(t.Generic[T_MetaInstance]):
         key: str,
         select_args: list[t.Any],
         left_joins: list[Expression],
-        parent_table: t.Type[TypedTable],
+        parent_table: t.Type[_TypedTable],
         parent_key: str = "",
     ) -> list[t.Any]:
         """Process a single relationship for left join and field selection."""

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/relationships.py

@@ -184,7 +184,7 @@ class Relationship(t.Generic[To_Type]):
             return db._config.lazy_policy
 
         # conservative fallback:
-        return "warn"
+        return "warn"  # pragma: no cover
 
     def get_table_name(self) -> str:
         """

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/rows.py

@@ -400,11 +400,27 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
         self.__dict__.update(state)
         # db etc. set after undill by caching.py
 
+    @t.overload
     def render(
         self,
-        i: int | None = None,
+        i: None = None,
         fields: list[Field] | None = None,
     ) -> t.Generator[T_MetaInstance, None, None]:
+        """With no index, yield rendered rows as a generator."""
+
+    @t.overload
+    def render(
+        self,
+        i: int,
+        fields: list[Field] | None = None,
+    ) -> T_MetaInstance:
+        """With an index, return one rendered row instance."""
+
+    def render(
+        self,
+        i: int | None = None,
+        fields: list[Field] | None = None,
+    ) -> t.Generator[T_MetaInstance, None, None] | T_MetaInstance:
         """
         Takes an index and returns a copy of the indexed row with values \
             transformed via the "represent" attributes of the associated fields.

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/tables.py

@@ -650,7 +650,7 @@ class TableMeta(type):
         return reorder_fields(cls._table, fields, keep_others=keep_others)
 
 
-class _TypedTable:
+class _TypedTable(metaclass=TableMeta):
     """
     This class is a final shared parent between TypedTable and Mixins.
 
@@ -661,6 +661,9 @@ class _TypedTable:
         -> Setting 'TypedTable' as the parent for Mixin does not work at runtime (and works semi at type check time)
     """
 
+    # This class contains weird typing glue to dodge MRO headaches without losing editor/mypy table methods
+    # you can safely ignore it when changing runtime behavior; touch it only for typing/mypy issues
+
     id: "TypedField[int]"
 
     _before_insert: list[t.Callable[[t.Self], t.Optional[bool]] | t.Callable[[OpRow], t.Optional[bool]]]
@@ -671,6 +674,8 @@ class _TypedTable:
     _after_update: list[t.Callable[[Set, t.Self], t.Optional[bool]] | t.Callable[[Set, OpRow], t.Optional[bool]]]
     _before_delete: list[t.Callable[[Set], t.Optional[bool]]]
     _after_delete: list[t.Callable[[Set], t.Optional[bool]]]
+    _rows: tuple[Row, ...]
+    _with: list[str]
 
     @classmethod
     def __on_define__(cls, db: TypeDAL) -> None:
@@ -681,16 +686,49 @@ class _TypedTable:
         where you need a reference to the current database, which may not exist yet when defining the model.
         """
 
-    @classproperty
-    def _hooks(cls) -> dict[str, list[t.Callable[..., t.Optional[bool]]]]:
-        return {
-            "before_insert": cls._before_insert,
-            "after_insert": cls._after_insert,
-            "before_update": cls._before_update,
-            "after_update": cls._after_update,
-            "before_delete": cls._before_delete,
-            "after_delete": cls._after_delete,
-        }
+    def __new__(cls, *_args: t.Any, **_kwargs: t.Any) -> t.Self:
+        """
+        Shared constructor signature for typing.
+
+        TypedTable provides the concrete behavior; this base only keeps static typing happy
+        for generic classmethod flows that instantiate `self(...)`.
+        """
+        return super().__new__(cls)
+
+    # Add an abstract placeholder here only when generic code is typed against
+    # `T_MetaInstance` (bound to `_TypedTable`) and directly calls/accesses that member.
+    # If a member is only used on concrete `TypedTable` paths, it should stay on `TypedTable`.
+    def _ensure_matching_row(self) -> Row:
+        # Typed on the shared base so generic instance helpers can call into row access safely.
+        raise NotImplementedError  # pragma: no cover
+
+    def _update(self: t.Self, **fields: t.Any) -> t.Self:
+        # Declared here for generic update flows; real behavior is implemented in TypedTable.
+        raise NotImplementedError  # pragma: no cover
+
+    def _update_record(self: t.Self, **fields: t.Any) -> t.Self:
+        # Declared here for generic update flows; real behavior is implemented in TypedTable.
+        raise NotImplementedError  # pragma: no cover
+
+    def update_record(self: t.Self, **fields: t.Any) -> t.Self:
+        # Declared here for generic update flows; real behavior is implemented in TypedTable.
+        raise NotImplementedError  # pragma: no cover
+
+    def as_dict(self, *args: t.Any, **kwargs: t.Any) -> AnyDict:
+        # Broad signature keeps class/instance serialization overrides LSP-compatible.
+        raise NotImplementedError  # pragma: no cover
+
+    def render(self: t.Self, *fields: t.Any, **kwargs: t.Any) -> t.Self:
+        # Rows/QueryBuilder treat render as model-preserving, so this returns Self for typing.
+        raise NotImplementedError  # pragma: no cover
+
+    def __getitem__(self, key: str) -> t.Any:
+        # Relationship collection writes into model instances via dict-style access.
+        raise NotImplementedError  # pragma: no cover
+
+    def __setitem__(self, key: str, value: t.Any) -> None:
+        # Relationship collection writes into model instances via dict-style access.
+        raise NotImplementedError  # pragma: no cover
 
 
 class TypedTable(_TypedTable, metaclass=TableMeta):
@@ -702,8 +740,21 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
     _row: Row | None = None
     _rows: tuple[Row, ...] = ()
 
+    id: "TypedField[int]"
+
     _with: list[str]
 
+    @classproperty
+    def _hooks(cls) -> dict[str, list[t.Callable[..., t.Optional[bool]]]]:
+        return {
+            "before_insert": cls._before_insert,
+            "after_insert": cls._after_insert,
+            "before_update": cls._before_update,
+            "after_update": cls._after_update,
+            "before_delete": cls._before_delete,
+            "after_delete": cls._after_delete,
+        }
+
     def _setup_instance_methods(self) -> None:
         self.as_dict = self._as_dict  # type: ignore
         self.__json__ = self.as_json = self._as_json  # type: ignore
@@ -990,7 +1041,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
     def _update_record(self: T_MetaInstance, **fields: t.Any) -> T_MetaInstance:
         row = self._ensure_matching_row()
         new_row = row.update_record(**fields)
-        self.update(**new_row)
+        self._update(**new_row)
         return self
 
     def update_record(self: T_MetaInstance, **fields: t.Any) -> T_MetaInstance:  # pragma: no cover

{typedal-4.4.6 → typedal-4.5.0}/src/typedal/types.py

@@ -35,7 +35,7 @@ except ImportError:
 # Internal references
 if t.TYPE_CHECKING:
     from .fields import TypedField
-    from .tables import TypedTable
+    from .tables import TypedTable, _TypedTable
 
 # ---------------------------------------------------------------------------
 # Aliases
@@ -297,7 +297,7 @@ T = t.TypeVar("T", bound=t.Any)
 P = t.ParamSpec("P")
 R = t.TypeVar("R")
 
-T_MetaInstance = t.TypeVar("T_MetaInstance", bound="TypedTable")
+T_MetaInstance = t.TypeVar("T_MetaInstance", bound="_TypedTable")
 T_Query = t.Union[
     "Table",
     Query,

{typedal-4.4.6 → typedal-4.5.0}/tests/test_mypy.py

@@ -10,6 +10,7 @@ from typedal import (  # todo: why does src.typedal not work anymore?
     TypedRows,
     TypedTable,
 )
+from typedal.mixins import Mixin
 from typedal.types import CacheFn, CacheTuple, OpRow, Reference, Rows
 
 db = TypeDAL("sqlite:memory")
@@ -29,6 +30,14 @@ class OtherTable(TypedTable): ...
 class LaterDefine(TypedTable): ...
 
 
+class SearchMixin(Mixin): ...
+
+
+@db.define
+class SearchableTable(TypedTable, SearchMixin):
+    title: str
+
+
 old_style = db.define_table("old_table")
 
 
@@ -152,6 +161,21 @@ def mypy_test_query() -> None:
     reveal_type(MyTable.where().column(MyTable.fancy))  # R: builtins.list[builtins.str]
 
 
+@pytest.mark.mypy_testing
+def mypy_test_rows_render_overload() -> None:
+    rows = MyTable.where().collect()
+    reveal_type(rows.render())  # R: typing.Generator[tests.test_mypy.MyTable, None, None]
+    reveal_type(rows.render(1))  # R: tests.test_mypy.MyTable
+
+
+@pytest.mark.mypy_testing
+def mypy_test_mixin_typed_table_argument() -> None:
+    def using_mixin(table: type[SearchMixin]) -> None:
+        reveal_type(table.where())  # R: typedal.query_builder.QueryBuilder[tests.test_mypy.SearchMixin]
+
+    using_mixin(SearchableTable)
+
+
 @pytest.mark.mypy_testing
 def mypy_test_cachefn() -> None:
     def cache_model(key: str, fn: CacheFn, expire: int) -> Rows: