TypeDAL 4.8.0__tar.gz → 4.8.2__tar.gz

{typedal-4.8.0 → typedal-4.8.2}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v4.8.2 (2026-05-20)
+
+### Fix
+
+* **typing:** Improved LSP support + more type testing ([#10](https://github.com/trialandsuccess/TypeDAL/issues/10)) ([`ff6fc2e`](https://github.com/trialandsuccess/TypeDAL/commit/ff6fc2e1706d5cc37719c87b8b8ee565dd31cda3))
+
+## v4.8.1 (2026-05-10)
+
+### Fix
+
+* Extend from empty type-safe `DALProtocol` during type-checking to make some LSPs happier ([`d93a361`](https://github.com/trialandsuccess/TypeDAL/commit/d93a361e9caa6c9b94d6fbfa78644c8ff5e2bc23))
+
 ## v4.8.0 (2026-04-23)
 
 ### Feature

{typedal-4.8.0 → typedal-4.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.8.0
+Version: 4.8.2
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues
@@ -44,7 +44,8 @@ Requires-Dist: hatch; extra == 'dev'
 Requires-Dist: mkdocs; extra == 'dev'
 Requires-Dist: mkdocs-dracula-theme; extra == 'dev'
 Requires-Dist: pydantic<3; extra == 'dev'
-Requires-Dist: pytest-mypy-testing; extra == 'dev'
+Requires-Dist: pyright<1.1.400; extra == 'dev'
+Requires-Dist: pytest-typing; extra == 'dev'
 Requires-Dist: python-semantic-release<8; extra == 'dev'
 Requires-Dist: requests<2.32; extra == 'dev'
 Requires-Dist: su6[all]>=1.9.0; extra == 'dev'

typedal-4.8.2/coverage.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="122" height="20" role="img" aria-label="coverage: 100.00%"><title>coverage: 100.00%</title><filter id="blur"><feGaussianBlur in="SourceGraphic" stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="122" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="61" height="20" fill="#4b0"/><rect width="122" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="315" y="150" fill="#010101" fill-opacity=".80" filter="url(#blur)" transform="scale(.1)" textLength="510">coverage</text><text aria-hidden="true" x="315" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="510">coverage</text><text x="315" y="140" transform="scale(.1)" fill="#fff" textLength="510">coverage</text><text aria-hidden="true" x="905" y="150" fill="#010101" fill-opacity=".80" filter="url(#blur)" transform="scale(.1)" textLength="510">100.00%</text><text aria-hidden="true" x="905" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="510">100.00%</text><text x="905" y="140" transform="scale(.1)" fill="#fff" textLength="510">100.00%</text></g></svg>

{typedal-4.8.0 → typedal-4.8.2}/pyproject.toml

@@ -91,7 +91,9 @@ dev = [
     # test:
     "su6[all]>=1.9.0",
     "python-semantic-release < 8",
-    "pytest-mypy-testing",
+    # "pytest-mypy-testing",
+    "pytest-typing",
+    "pyright < 1.1.400",
     "contextlib-chdir",
     "testcontainers",
     "pydantic < 3",
@@ -263,11 +265,16 @@ add_ignore = [
 ## look nowhere for any code to 'build' since this is just used to manage (dev) dependencies
 #where = []
 
-[tool.pytest.ini_options]
+[tool.pytest]
 pythonpath = [
     "src",
 ]
 
+typing_checkers = [
+    "mypy",
+    "pyright",
+]
+
 [tool.typedal]
 # e.g.
 # lazy-policy = "forbid"

{typedal-4.8.0 → typedal-4.8.2}/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.8.0"
+__version__ = "4.8.2"

{typedal-4.8.0 → typedal-4.8.2}/src/typedal/core.py

@@ -37,7 +37,7 @@ except ImportError:  # pragma: no cover
 if t.TYPE_CHECKING:
     from .fields import TypedField
     from .query_builder import QueryBuilder
-    from .types import AnyDict, Expression, Rows, T_Query, Table
+    from .types import AnyDict, Expression, Rows, Set, T_Query, Table
 
 
 # note: these functions can not be moved to a different file,
@@ -144,7 +144,37 @@ def resolve_annotation(ftype: str, namespace: dict[str, type] | None = None) ->
         return resolve_annotation_314(ftype, namespace=namespace)
 
 
-class TypeDAL(pydal.DAL):
+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: ...
+
+        # 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 TypeDAL(_TypeDALBase):
     """
     Drop-in replacement for pyDAL with layer to convert class-based table definitions to classical pydal define_tables.
     """

{typedal-4.8.0 → typedal-4.8.2}/src/typedal/fields.py

@@ -29,7 +29,7 @@ from .types import (
 
 if t.TYPE_CHECKING:
     # will be imported for real later:
-    from .tables import TypedTable, _TypedTable
+    from .tables import TypedTable
 
 
 ## general
@@ -71,21 +71,21 @@ class TypedField[T_Value](Expression):  # pragma: no cover
         # super().__init__()
 
     @t.overload
-    def __get__(self, instance: T_MetaInstance, owner: t.Type[T_MetaInstance]) -> T_Value:  # pragma: no cover
+    def __get__(self, instance: None, owner: "t.Type[t.Any]") -> "TypedField[T_Value]":  # pragma: no cover
         """
-        row.field -> (actual data).
+        Table.field -> Field.
         """
 
     @t.overload
-    def __get__(self, instance: None, owner: "t.Type[_TypedTable]") -> "TypedField[T_Value]":  # pragma: no cover
+    def __get__(self, instance: object, owner: "t.Type[t.Any]") -> T_Value:  # pragma: no cover
         """
-        Table.field -> Field.
+        row.field -> (actual data).
         """
 
     def __get__(
         self,
         instance: T_MetaInstance | None,
-        owner: t.Type[T_MetaInstance],
+        owner: t.Type[t.Any],
     ) -> t.Union[T_Value, "TypedField[T_Value]"]:
         """
         Since this class is a Descriptor field, \

{typedal-4.8.0 → typedal-4.8.2}/src/typedal/query_builder.py

@@ -71,7 +71,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
         """
         self.model = model
         table = self._ensure_table_defined()
-        default_query: Query = table.id > 0
+        default_query: Query = t.cast(Query, table.id > 0)
         self.query = add_query or default_query
         self.select_args = select_args or []
         self.select_kwargs = select_kwargs or {}
@@ -111,7 +111,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
         Querybuilder is truthy if it has t.Any conditions.
         """
         table = self._ensure_table_defined()
-        default_query: Query = table.id > 0
+        default_query: Query = t.cast(Query, table.id > 0)
         return any(
             [
                 self.query != default_query,

{typedal-4.8.0 → typedal-4.8.2}/src/typedal/relationships.py

@@ -18,13 +18,17 @@ from .types import Condition, OnQuery, T_Field
 
 # default lazy policy is defined at the TypeDAL() instance settings level
 
+To_Type = t.TypeVar("To_Type", bound="TypedTable")
+_RelTable = t.TypeVar("_RelTable", bound="TypedTable")
+_RelValue = t.TypeVar("_RelValue")
 
-class Relationship[To_Type: TypedTable]:
+
+class Relationship[To_Type]:
     """
     Define a relationship to another table.
     """
 
-    _type: t.Type[To_Type]
+    _type: t.Any
     table: t.Type["TypedTable"] | type | str  # use get_table() to resolve later on
     condition: Condition
     condition_and: Condition
@@ -39,7 +43,7 @@ class Relationship[To_Type: TypedTable]:
 
     def __init__(
         self,
-        _type: t.Type[To_Type],
+        _type: t.Any,
         condition: Condition = None,
         join: JOIN_OPTIONS = None,
         on: OnQuery = None,
@@ -56,7 +60,7 @@ class Relationship[To_Type: TypedTable]:
 
         resolved_type = resolve_relationship_type(_type, keep_unresolved=True)
         if resolved_type is not None:
-            _type = t.cast(t.Type[To_Type], resolved_type)
+            _type = resolved_type
 
         self._type = _type
         self.condition = condition
@@ -201,11 +205,31 @@ class Relationship[To_Type: TypedTable]:
 
         return str(table)
 
+    @t.overload
+    def __get__(
+        self: "Relationship[list[_RelTable]]", instance: None, owner: t.Type["TypedTable"]
+    ) -> "Relationship[list[_RelTable]]": ...
+
+    @t.overload
+    def __get__(
+        self: "Relationship[list[_RelTable]]", instance: "TypedTable", owner: t.Type["TypedTable"]
+    ) -> list[_RelTable]: ...
+
+    @t.overload
+    def __get__(
+        self: "Relationship[_RelValue]", instance: None, owner: t.Type["TypedTable"]
+    ) -> "Relationship[_RelValue]": ...
+
+    @t.overload
+    def __get__(
+        self: "Relationship[_RelValue]", instance: "TypedTable", owner: t.Type["TypedTable"]
+    ) -> _RelValue: ...
+
     def __get__(
         self,
-        instance: "TypedTable",
+        instance: "TypedTable" | None,
         owner: t.Type["TypedTable"],
-    ) -> "t.Optional[list[t.Any]] | Relationship[To_Type]":
+    ) -> "Relationship[To_Type] | list[t.Any] | t.Any | None":
         """
         Relationship is a descriptor class, which can be returned from a class but not an instance.
 
@@ -285,14 +309,14 @@ class Ref[To_Type: TypedTable]:
 
 
 @t.overload
-def relationship[To_Type: TypedTable](
+def relationship(
     _type: type[list[To_Type]],
     condition: Condition = None,
     join: JOIN_OPTIONS = None,
     on: OnQuery = None,
     lazy: LazyPolicy | None = None,
     explicit: bool = False,
-) -> list[To_Type]:
+) -> "Relationship[list[To_Type]]":
     """
     Define a relationship that returns a list of related instances.
 
@@ -305,7 +329,7 @@ def relationship[To_Type: TypedTable](
 
 
 @t.overload
-def relationship[To_Type: TypedTable](
+def relationship(
     _type: t.Type[To_Type] | str | t.Type[Ref[To_Type]],
     condition: Condition = None,
     *,
@@ -313,7 +337,7 @@ def relationship[To_Type: TypedTable](
     on: OnQuery = None,
     lazy: LazyPolicy | None = None,
     explicit: bool = False,
-) -> To_Type:
+) -> "Relationship[To_Type]":
     """
     Define a relationship that returns a single related instance (never None with inner join).
 
@@ -327,14 +351,14 @@ def relationship[To_Type: TypedTable](
 
 
 @t.overload
-def relationship[To_Type: TypedTable](
+def relationship(
     _type: t.Type[To_Type] | str | t.Type[Ref[To_Type]],
     condition: Condition = None,
     join: JOIN_OPTIONS = None,
     on: OnQuery = None,
     lazy: LazyPolicy | None = None,
     explicit: bool = False,
-) -> To_Type | None:
+) -> "Relationship[To_Type | None]":
     """
     Define a relationship that returns a single optional related instance.
 
@@ -346,14 +370,14 @@ def relationship[To_Type: TypedTable](
     """
 
 
-def relationship[To_Type: TypedTable](
+def relationship(
     _type: type[list[To_Type]] | t.Type[To_Type] | str | t.Type[Ref[To_Type]],
     condition: Condition = None,
     join: JOIN_OPTIONS = None,
     on: OnQuery = None,
     lazy: LazyPolicy | None = None,
     explicit: bool = False,
-) -> list[To_Type] | To_Type | None:
+) -> "Relationship[list[To_Type]] | Relationship[To_Type] | Relationship[To_Type | None]":
     """
     Define a relationship to another table, when its id is not stored in the current table.
 
@@ -402,11 +426,8 @@ def relationship[To_Type: TypedTable](
     If you'd try to capture this in a single 'condition', pydal would create a cross join which is much less efficient.
     """
     return t.cast(
-        # note: The descriptor `Relationship[To_Type]` is more correct, but pycharm doesn't really get that.
-        # so for ease of use, just cast to the refered type for now!
-        # e.g. x = relationship(Author) -> x: Author
-        To_Type,
-        Relationship(_type, condition, join, on, lazy=lazy, explicit=explicit),  # type: ignore
+        Relationship[list[To_Type]] | Relationship[To_Type] | Relationship[To_Type | None],
+        Relationship(_type, condition, join, on, lazy=lazy, explicit=explicit),
     )
 
 

{typedal-4.8.0 → typedal-4.8.2}/src/typedal/tables.py

@@ -29,6 +29,7 @@ from .types import (
     OpRow,
     OrderBy,
     Query,
+    QueryLike,
     Reference,
     Row,
     SelectKwargs,
@@ -139,7 +140,7 @@ class TableMeta(type):
         Allow dict notation to get a column of this table (-> Field instance).
         """
         table = self._ensure_table_defined()
-        return table[item]
+        return t.cast(Field, table[item])
 
     def __str__(self) -> str:
         """
@@ -483,7 +484,7 @@ class TableMeta(type):
             **kwargs,
         )
 
-    def on(self, query: bool | Query) -> Expression:
+    def on(self, query: QueryLike) -> Expression:
         """
         Shadow Table.on.
 

{typedal-4.8.0 → typedal-4.8.2}/src/typedal/types.py

@@ -11,10 +11,7 @@ import datetime as dt
 import types
 import typing as t
 
-import pydal.objects
-
 # Third-party
-from pydal.adapters.base import BaseAdapter
 from pydal.helpers.classes import OpRow as _OpRow
 from pydal.helpers.classes import Reference as _Reference
 from pydal.helpers.classes import SQLCustomType
@@ -63,6 +60,11 @@ class TableProtocol(t.Protocol):  # pragma: no cover
         Tables have table[field] syntax.
         """
 
+    def on(self, query: "QueryLike") -> "Expression | _Expression":
+        """
+        pydal Table.on(query) helper used in join callbacks.
+        """
+
 
 class CacheFn(t.Protocol):
     """
@@ -70,7 +72,7 @@ class CacheFn(t.Protocol):
     """
 
     def __call__(
-        self: BaseAdapter,
+        self,  # : BaseAdapter
         sql: str = "",
         fields: t.Iterable[str] = (),
         attributes: t.Iterable[str] = (),
@@ -153,8 +155,8 @@ class Validator(_Validator):
     """Pydal Validator object. Make mypy happy."""
 
 
-class Table(_Table, TableProtocol):
-    """Table with protocol support. Make mypy happy."""
+class Table(_Table):
+    """Pydal Table object. Make mypy happy."""
 
 
 # ---------------------------------------------------------------------------
@@ -312,11 +314,14 @@ type T_Query = t.Union[
 type T_Field = t.Union["TypedField[t.Any]", "Table", t.Type["TypedTable"]]
 
 # table-ish parameter:
-type P_Table = t.Union[t.Type["TypedTable"], pydal.objects.Table]
+# Use protocol typing so checkers know `.id` exists in relationship callbacks.
+type P_Table = t.Union[t.Type["_TypedTable"], TableProtocol]
+
+type QueryLike = Query | _Query | bool
 
-type Condition = t.Optional[t.Callable[[P_Table, P_Table], Query | bool]]
+type Condition = t.Optional[t.Callable[[P_Table, P_Table], QueryLike]]
 
-type OnQuery = t.Optional[t.Callable[[P_Table, P_Table], list[Expression]]]
+type OnQuery = t.Optional[t.Callable[[P_Table, P_Table], list[Expression | _Expression]]]
 
 type CacheModel = t.Callable[[str, CacheFn, int], Rows]
 type CacheTuple = tuple[CacheModel, int]

typedal-4.8.2/tests/test_typing_mypy.md

@@ -0,0 +1,250 @@
+# Basics
+
+note that mypy scopes classes like typedal.tables.TypedTable or test_snippet.WithBraces
+
+```python only=mypy
+from typedal import TypeDAL, TypedTable, TypedField, relationship, Ref, Relationship
+
+db = TypeDAL()
+
+reveal_type(db)  # revealed: typedal.core.TypeDAL
+
+@db.define()
+class WithBraces(TypedTable):
+    gid = TypedField(str)
+
+with_braces = WithBraces.first_or_fail()
+
+reveal_type(with_braces) # revealed: test_snippet.WithBraces
+
+@db.define
+class WithoutBraces(TypedTable):
+    with_braces = relationship(WithBraces, condition=lambda self, other: self.id == other.id, join="inner")
+    deferred = relationship(Ref["DeferredDefine"], on=lambda self, other: [other.on(other.id == self.id)], join="left")
+    multiple = relationship(list["WithoutBraces"], condition=lambda self, other: self.id != other.id)
+
+without_braces = WithoutBraces.where().first()
+
+reveal_type(without_braces) # revealed: test_snippet.WithoutBraces | None
+
+
+class DeferredDefine(TypedTable):
+    ...
+
+db.define(DeferredDefine)
+
+for deferred_define in DeferredDefine.paginate(limit=1):
+    reveal_type(deferred_define) # revealed: test_snippet.DeferredDefine
+
+new_row = WithBraces.insert()
+
+reveal_type(new_row) # revealed: test_snippet.WithBraces
+reveal_type(new_row.id) # revealed: int
+
+reveal_type(WithBraces.gid) # revealed: typedal.fields.TypedField[str]
+reveal_type(new_row.gid) # revealed: str
+
+db.commit()
+
+joined = WithoutBraces.join().first_or_fail()
+
+reveal_type(WithoutBraces.with_braces) # revealed: typedal.relationships.Relationship[test_snippet.WithBraces]
+reveal_type(WithoutBraces.deferred) # revealed: typedal.relationships.Relationship[test_snippet.DeferredDefine | None]
+reveal_type(WithoutBraces.multiple) # revealed: typedal.relationships.Relationship[list[test_snippet.WithoutBraces]]
+
+reveal_type(joined.with_braces) # revealed: test_snippet.WithBraces
+reveal_type(joined.deferred) # revealed: test_snippet.DeferredDefine | None
+reveal_type(joined.multiple) # revealed: list[test_snippet.WithoutBraces]
+
+```
+
+# 1. Field Dual Behavior (Class vs Instance)
+
+```python only=mypy
+from typedal import TypeDAL, TypedTable, TypedField
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    fancy = TypedField(str)
+
+reveal_type(MyTable.fancy.lower())  # revealed: typedal.types.Expression
+reveal_type(MyTable().fancy.lower())  # revealed: str
+```
+
+# 2. Alias Roundtrip Typing
+
+```python only=mypy
+from typedal import TypeDAL, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+aliased_cls = MyTable.with_alias("---")
+reveal_type(aliased_cls)  # revealed: type[test_snippet.MyTable]
+
+aliased_instance = aliased_cls()
+reveal_type(aliased_instance)  # revealed: test_snippet.MyTable
+```
+
+# 3. Query Object Typing and Compatibility
+
+```python only=mypy
+from typedal import TypeDAL, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+my_query = MyTable.id > 3
+reveal_type(my_query)  # revealed: typedal.types.Query
+
+query = MyTable.id == 3
+
+reveal_type(query) # revealed: typedal.types.Query
+
+new = MyTable.update(query)
+reveal_type(new)  # revealed: test_snippet.MyTable | None
+
+MyTable.update_or_insert(MyTable)
+MyTable.update_or_insert(my_query)
+MyTable.update_or_insert(db.my_table.id > 3)
+```
+
+# 4. TypedRows Inference Behavior
+
+```python only=mypy
+from typedal import TypeDAL, TypedRows, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+select1 = db(MyTable).select()  # error: [var-annotated]
+select2: TypedRows[MyTable] = db(MyTable).select()
+select3 = MyTable.select().collect()
+
+reveal_type(select1)  # revealed: typedal.rows.TypedRows[Any]
+reveal_type(select2)  # revealed: typedal.rows.TypedRows[test_snippet.MyTable]
+reveal_type(select3)  # revealed: typedal.rows.TypedRows[test_snippet.MyTable]
+
+reveal_type(select1.first())  # revealed: Any | None
+reveal_type(select2.first())  # revealed: test_snippet.MyTable | None
+reveal_type(select3.first())  # revealed: test_snippet.MyTable | None
+
+for row in select2:
+    reveal_type(row)  # revealed: test_snippet.MyTable
+
+for row in MyTable.select():
+    reveal_type(row)  # revealed: test_snippet.MyTable
+```
+
+# 5. where().column(...) Overloads
+
+```python only=mypy
+import typing
+from typedal import TypeDAL, TypedField, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    normal: str
+    fancy = TypedField(str)
+
+SomeField: typing.Any = ...
+
+reveal_type(MyTable.where().column(SomeField))  # revealed: list[Any]
+reveal_type(MyTable.where().column(MyTable.normal))  # revealed: list[str]
+reveal_type(MyTable.where().column(MyTable.fancy))  # revealed: list[str]
+```
+
+# 6. rows.render() Overloads
+
+```python only=mypy
+from typedal import TypeDAL, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+rows = MyTable.where().collect()
+reveal_type(rows.render())  # revealed: typing.Generator[test_snippet.MyTable, None, None]
+reveal_type(rows.render(1))  # revealed: test_snippet.MyTable
+```
+
+# 7. Mixin-as-Table Type Argument
+
+```python only=mypy
+from typedal import TypeDAL, TypedTable
+from typedal.mixins import Mixin
+
+db = TypeDAL()
+
+class SearchMixin(Mixin):
+    ...
+
+@db.define
+class SearchableTable(TypedTable, SearchMixin):
+    title: str
+
+def using_mixin(table: type[SearchMixin]) -> None:
+    reveal_type(table.where())  # revealed: typedal.query_builder.QueryBuilder[test_snippet.SearchMixin]
+
+using_mixin(SearchableTable)
+```
+
+# 8. Cache Tuple Protocol Checks
+
+```python only=mypy
+import typing
+from typedal.types import CacheFn, CacheTuple, Rows
+
+def cache_model(key: str, fn: CacheFn, expire: int) -> Rows:
+    return fn()
+
+cache_valid: CacheTuple = (cache_model, 3000)
+
+def invalid_cache_model(key: str, fn: typing.Callable[..., list[str]], _: typing.Optional[int] = None) -> list[str]:
+    return fn()
+
+cache_invalid: CacheTuple = (invalid_cache_model, 3000)  # error: [assignment]
+```
+
+# Parity with test_mypy.py
+
+There are still a few tests missing in this file:
+
+- Hook callback typing parity:
+  - `_after_insert` list type behavior
+  - accepted callbacks: `(Any, Reference)`, `(MyTable, Reference)`, `(OpRow, Reference)`
+  - rejected callback: `(str, Reference)` on both `.append(...)` and `MyTable.after_insert(...)`
+
+- Instance update flow:
+  - `inst = MyTable(3)` reveal
+  - guarded `inst._update()` reveal
+  - `inst.update_record()` reveal
+
+- Old-style table count paths:
+  - `db(db.old_style).count()`
+  - `db(old_style).count()`
+
+- Raw DAL entrypoints:
+  - `db(MyTable.id > 0)`
+  - `db(db.old_style.id > 3)`
+  - `db(MyTable)`
+  - `db(db.old_style)`
+
+- Field/type reveals not explicitly repeated in new sections:
+  - `MyTable.normal` and `MyTable().normal`
+  - `MyTable.options` and `MyTable().options`

typedal-4.8.2/tests/test_typing_pyright.md

@@ -0,0 +1,225 @@
+# Basics
+
+```python only=pyright
+from typedal import TypeDAL, TypedTable, TypedField, relationship, Ref, Relationship
+
+db = TypeDAL()
+
+reveal_type(db)  # revealed: TypeDAL
+
+@db.define()
+class WithBraces(TypedTable):
+    gid = TypedField(str)
+
+with_braces = WithBraces.first_or_fail()
+
+reveal_type(with_braces) # revealed: WithBraces
+
+@db.define
+class WithoutBraces(TypedTable):
+    with_braces = relationship(WithBraces, condition=lambda self, other: self.id == other.id, join="inner")
+    deferred = relationship(Ref["DeferredDefine"], on=lambda self, other: [other.on(other.id == self.id)], join="left")
+    multiple = relationship(list["WithoutBraces"], condition=lambda self, other: self.id != other.id)
+
+without_braces = WithoutBraces.where().first()
+
+reveal_type(without_braces) # revealed: WithoutBraces | None
+
+
+class DeferredDefine(TypedTable):
+    ...
+
+db.define(DeferredDefine)
+
+for deferred_define in DeferredDefine.paginate(limit=1):
+    reveal_type(deferred_define) # revealed: DeferredDefine
+
+new_row = WithBraces.insert()
+
+reveal_type(new_row) # revealed: WithBraces
+reveal_type(new_row.id) # revealed: int
+
+reveal_type(WithBraces.gid) # revealed: TypedField[str]
+reveal_type(new_row.gid) # revealed: str
+
+db.commit()
+
+joined = WithoutBraces.join().first_or_fail()
+
+reveal_type(WithoutBraces.with_braces) # revealed: Relationship[WithBraces]
+reveal_type(WithoutBraces.deferred) # revealed: Relationship[DeferredDefine | None]
+reveal_type(WithoutBraces.multiple) # revealed: Relationship[list[WithoutBraces]]
+
+reveal_type(joined.with_braces) # revealed: WithBraces
+reveal_type(joined.deferred) # revealed: DeferredDefine | None
+reveal_type(joined.multiple) # revealed: list[WithoutBraces]
+
+```
+
+
+# 1. Field Dual Behavior (Class vs Instance)
+
+```python only=pyright
+from typedal import TypeDAL, TypedTable, TypedField
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    fancy = TypedField(str)
+
+reveal_type(MyTable.fancy.lower())  # revealed: Expression
+reveal_type(MyTable().fancy.lower())  # revealed: str
+```
+
+# 2. Alias Roundtrip Typing
+
+```python only=pyright
+from typedal import TypeDAL, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+aliased_cls = MyTable.with_alias("---")
+reveal_type(aliased_cls)  # revealed: type[MyTable]
+
+aliased_instance = aliased_cls()
+reveal_type(aliased_instance)  # revealed: MyTable
+```
+
+# 3. Query Object Typing and Compatibility
+
+```python only=pyright
+from typedal import TypeDAL, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+my_query = MyTable.id > 3
+reveal_type(my_query)  # revealed: Query
+
+query = MyTable.id == 3
+
+reveal_type(query) # revealed: Query
+
+new = MyTable.update(query)
+reveal_type(new)  # revealed: MyTable | None
+
+MyTable.update_or_insert(MyTable)
+MyTable.update_or_insert(my_query)
+# MyTable.update_or_insert(db.my_table.id > 3) # <- not supported
+```
+
+# 4. TypedRows Inference Behavior
+
+```python only=pyright
+from typedal import TypeDAL, TypedRows, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+select1 = db(MyTable).select()
+select2: TypedRows[MyTable] = db(MyTable).select()
+select3 = MyTable.select().collect()
+
+reveal_type(select1)  # revealed: TypedRows[Unknown]
+reveal_type(select2)  # revealed: TypedRows[MyTable]
+reveal_type(select3)  # revealed: TypedRows[MyTable]
+
+reveal_type(select1.first())  # revealed: Unknown | None
+reveal_type(select2.first())  # revealed: MyTable | None
+reveal_type(select3.first())  # revealed: MyTable | None
+
+for row in select2:
+    reveal_type(row)  # revealed: MyTable
+
+for row in MyTable.select():
+    reveal_type(row)  # revealed: MyTable
+```
+
+# 5. where().column(...) Overloads
+
+```python only=pyright
+import typing
+from typedal import TypeDAL, TypedField, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    normal: str
+    fancy = TypedField(str)
+
+SomeField: typing.Any = ...
+
+reveal_type(MyTable.where().column(SomeField))  # revealed: list[Any]
+reveal_type(MyTable.where().column(MyTable.normal))  # revealed: list[str]
+reveal_type(MyTable.where().column(MyTable.fancy))  # revealed: list[str]
+```
+
+# 6. rows.render() Overloads
+
+```python only=pyright
+from typedal import TypeDAL, TypedTable
+
+db = TypeDAL()
+
+@db.define
+class MyTable(TypedTable):
+    ...
+
+rows = MyTable.where().collect()
+reveal_type(rows.render())  # revealed: Generator[MyTable, None, None]
+reveal_type(rows.render(1))  # revealed: MyTable
+```
+
+# 7. Mixin-as-Table Type Argument
+
+```python only=pyright
+from typedal import TypeDAL, TypedTable
+from typedal.mixins import Mixin
+
+db = TypeDAL()
+
+class SearchMixin(Mixin):
+    ...
+
+@db.define
+class SearchableTable(TypedTable, SearchMixin):
+    title: str
+
+def using_mixin(table: type[SearchMixin]) -> None:
+    reveal_type(table.where())  # revealed: QueryBuilder[SearchMixin]
+
+using_mixin(SearchableTable)
+```
+
+# 8. Cache Tuple Protocol Checks
+
+```python only=pyright
+import typing
+from typedal.types import CacheFn, CacheTuple, Rows
+
+def cache_model(key: str, fn: CacheFn, expire: int) -> Rows:
+    return fn()
+
+cache_valid: CacheTuple = (cache_model, 3000)
+
+def invalid_cache_model(key: str, fn: typing.Callable[..., list[str]], _: typing.Optional[int] = None) -> list[str]:
+    return fn()
+
+cache_invalid: CacheTuple = (invalid_cache_model, 3000) # error: [reportAssignmentType]
+```
+
+# Parity with test_mypy.py
+
+See test_typing_mypy.md

typedal-4.8.2/typing_again.py

@@ -0,0 +1,35 @@
+from typedal import TypeDAL, TypedTable, TypedField, relationship, Relationship
+
+from typing import reveal_type
+
+db = TypeDAL()
+
+reveal_type(db)
+
+@db.define
+class OtherTable(TypedTable):
+    ...
+
+@db.define
+class MyTable(TypedTable):
+    field = TypedField(str)
+
+    rel = relationship(OtherTable)
+    multiple = relationship(list[OtherTable])
+
+
+row = MyTable.first_or_fail()
+
+reveal_type(row) # expected: MyTable; pycharm: MyTable
+reveal_type(MyTable.field) # expected: TypedField[str]; pycharm: TypedField[str]
+reveal_type(row.field) # expected: str; pycharm: TypedField[str]
+
+q = MyTable.field.belongs([""])
+
+reveal_type(q) # expected: Query; pycharm: Query
+
+reveal_type(MyTable.rel) # expected: Relationship[OtherTable]; pycharm: Relationship[OtherTable | None]
+reveal_type(row.rel)  # expected: OtherTable | None; pycharm: Relationship[OtherTable | None]
+
+reveal_type(MyTable.multiple) # expected: Relationship[list[OtherTable]]; pycharm: Relationship[list[OtherTable]]
+reveal_type(row.multiple)  # expected: list[OtherTable]; pycharm: Relationship[list[OtherTable]]

typedal-4.8.0/coverage.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="122" height="20" role="img" aria-label="coverage: 100.00%"><title>coverage: 100.00%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="122" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="61" height="20" fill="#4c1"/><rect width="122" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="315" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="510">coverage</text><text x="315" y="140" transform="scale(.1)" fill="#fff" textLength="510">coverage</text><text aria-hidden="true" x="905" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="510">100.00%</text><text x="905" y="140" transform="scale(.1)" fill="#fff" textLength="510">100.00%</text></g></svg>