TypeDAL 5.0.4__tar.gz → 5.0.6__tar.gz

{typedal-5.0.4 → typedal-5.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: TypeDAL
-Version: 5.0.4
+Version: 5.0.6
 Summary: Typing support for PyDAL
 Keywords: 
 Author: Robin van der Noord

{typedal-5.0.4 → typedal-5.0.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 name = "TypeDAL"
 description = "Typing support for PyDAL"
 readme = "README.md"
-version = "5.0.4"
+version = "5.0.6"
 requires-python = ">=3.12"
 license-expression = "MIT"
 keywords = []

{typedal-5.0.4 → typedal-5.0.6}/pyproject.toml.orig

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 name = "TypeDAL"
 description = 'Typing support for PyDAL'
 readme = "README.md"
-version = "5.0.4"
+version = "5.0.6"
 requires-python = ">=3.12"
 license-expression = "MIT"
 keywords = []

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/caching.py

@@ -9,13 +9,12 @@ import json
 import typing as t
 
 import dill  # nosec
-from pydal.objects import Field, Rows, Set
 
 from .fields import TypedField
 from .helpers import throw
 from .rows import TypedRows
 from .tables import TypedTable
-from .types import CacheStatus, Query
+from .types import CacheStatus, Field, Query, Rows, Set
 
 if t.TYPE_CHECKING:
     from .core import TypeDAL

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/core.py

@@ -51,10 +51,10 @@ if t.TYPE_CHECKING:
 
 def _expression_subclasses() -> t.Iterator[type]:
     """
-    Yield pydal.objects.Expression and every (nested) subclass currently loaded, e.g. Field and TypedField.
+    Yield Expression and every (nested) subclass currently loaded, e.g. Field and TypedField.
     """
-    seen = {pydal.objects.Expression}
-    stack = [pydal.objects.Expression]
+    seen = {Expression}
+    stack = [Expression]
     while stack:
         for subclass in stack.pop().__subclasses__():
             if subclass not in seen:
@@ -77,7 +77,7 @@ def _purge_dialect_expressions(adapter: t.Any) -> None:
     `gc.collect()` will not free it, and with it the entire db (tables, fields, models)
     it belongs to, for the lifetime of the process, unless explicitly undone here.
     """
-    expressions = pydal.objects.Expression._dialect_expressions_
+    expressions = Expression._dialect_expressions_
     stale = [
         name
         for name, wrapper in expressions.items()
@@ -544,7 +544,7 @@ class TypeDAL(_TypeDALBase):
 
         return wrapper
 
-    def __call__(self, *_args: T_Query, **kwargs: t.Any) -> "TypedSet":  # ty: ignore[invalid-method-override]
+    def __call__(self, *_args: T_Query, **kwargs: t.Any) -> "TypedSet":
         """
         A db instance can be called directly to perform a query.
 

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/define.py

@@ -12,7 +12,6 @@ import types
 import typing as t
 import warnings
 
-import pydal
 from pydal.validators import IS_IN_SET, ValidationError, Validator
 
 from .constants import BASIC_MAPPINGS
@@ -163,7 +162,7 @@ class TableDefinitionBuilder:
         if mapping := BASIC_MAPPINGS.get(ftype):
             # basi types
             return mapping
-        elif isinstance(ftype, pydal.objects.Table):
+        elif isinstance(ftype, Table):
             # db.table
             return f"reference {ftype._tablename}"
         elif issubclass(type(ftype), type) and issubclass(ftype, TypedTable):

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/fields.py

@@ -14,7 +14,6 @@ import uuid
 
 import pydal
 from pydal.helpers.classes import SQLCustomType
-from pydal.objects import Table
 
 from .core import TypeDAL
 from .types import (
@@ -26,6 +25,7 @@ from .types import (
     Query,
     T_annotation,
     T_MetaInstance,
+    Table,
     Validator,
 )
 
@@ -79,7 +79,7 @@ class TypedField[T_Value](Expression):  # pragma: no cover
     authorize: AnyCallable | None
     autodelete: bool
     requires: Validator | t.Iterable[Validator]
-    represent: t.Callable[[T_Value, TypedTable | None], t.Any]
+    represent: t.Callable[[T_Value, t.Any], t.Any]  # second argument is the model class but we can't type that
     compute: AnyCallable | None
     custom_store: AnyCallable | None
     custom_retrieve: AnyCallable | None
@@ -190,12 +190,12 @@ class TypedField[T_Value](Expression):  # pragma: no cover
             extra_kwargs,
         )
 
-    def bind(self, field: pydal.objects.Field, table: pydal.objects.Table) -> None:
+    def bind(self, field: Field, table: Table) -> None:
         """
         Bind the right db/table/field info to this class, so queries can be made using `Class.field == ...`.
         """
         self._table = table
-        self._field = t.cast(Field, field)
+        self._field = field
 
     def unbind(self) -> None:
         """Remove references to the pydal objects created during `bind`."""
@@ -280,7 +280,7 @@ class TypedField[T_Value](Expression):  # pragma: no cover
         return t.cast(Expression, self._field.lower())
 
 
-def rname(field: TypedField[t.Any] | Field | pydal.objects.Field) -> str:
+def rname(field: TypedField[t.Any] | Field) -> str:
     """
     Return the full rname (table and field).
     """
@@ -514,6 +514,7 @@ def BigintField(**kw: t.Unpack[FieldSettings]) -> TypedField[int]:
 
 Bigint = BigintField
 
+
 ## Custom:
 
 

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/query_builder.py

@@ -10,7 +10,7 @@ import time
 import typing as t
 from collections import defaultdict
 
-import pydal.objects
+from pydal.helpers.classes import SQLALL
 
 from .asynchronous import run_async
 from .constants import DEFAULT_JOIN_OPTION, JOIN_OPTIONS
@@ -38,6 +38,7 @@ from .types import (
     Query,
     Row,
     Rows,
+    Select,
     SelectKwargs,
     T_MetaInstance,
     Table,
@@ -46,7 +47,7 @@ from .types import (
 )
 
 
-class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
+class QueryBuilder[T_MetaInstance: _TypedTable](Select):
     """
     Abstration on top of pydal's query system.
     """
@@ -290,9 +291,9 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
 
         subquery = t.cast(Query, DummyQuery())
         for query_part in queries_or_lambdas:
-            if isinstance(query_part, (Field, pydal.objects.Field)) or is_typed_field(query_part):
-                subquery |= t.cast(Query, query_part != None)
-            elif isinstance(query_part, (pydal.objects.Query, Expression, pydal.objects.Expression)):
+            if isinstance(query_part, Field) or is_typed_field(query_part):
+                subquery |= query_part != None
+            elif isinstance(query_part, (Query, Expression)):
                 subquery |= t.cast(Query, query_part)
             elif callable(query_part):
                 if result := query_part(self.model):  # ty: ignore[call-top-callable]
@@ -401,7 +402,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
             if len(fields) != 1:
                 raise ValueError("join(field, condition=...) can only be used with exactly one field!")
 
-            if isinstance(condition, pydal.objects.Query):
+            if isinstance(condition, Query):
                 condition = as_lambda(condition)
 
             field = fields[0]
@@ -418,8 +419,8 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
             if len(fields) != 1:
                 raise ValueError("join(field, on=...) can only be used with exactly one field!")
 
-            if isinstance(on, pydal.objects.Expression):
-                on = t.cast(list[Expression], [on])
+            if isinstance(on, Expression):
+                on = [on]
 
             if isinstance(on, list):
                 on = t.cast(OnQuery, as_lambda(on))
@@ -856,7 +857,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
             expression_without_direction, _, direction = expression.rpartition(" ")
             return [expression_without_direction if direction.upper() in {"ASC", "DESC"} else orderby]
 
-        if isinstance(orderby, pydal.objects.Field):
+        if isinstance(orderby, Field):
             return t.cast(list[OrderBy], [orderby])
 
         fields = []
@@ -968,8 +969,8 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
             if not isinstance(on, list):
                 on = [on]
 
-            on = [_ for _ in on if isinstance(_, pydal.objects.Expression)]
-            left_joins.extend(on)  # ty: ignore[invalid-argument-type]
+            on = [_ for _ in on if isinstance(_, Expression)]
+            left_joins.extend(on)
         elif method == "left":
             # Generate left join condition
             if not is_self_reference:
@@ -1032,7 +1033,7 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
         if pre_alias != post_alias:
             updated_args = []
             for arg in select_args:
-                if isinstance(arg, pydal.objects.SQLALL):
+                if isinstance(arg, SQLALL):
                     updated_args.extend(str(field).replace(f"{pre_alias}.", f"{post_alias}.") for field in arg._table)
                 else:
                     updated_args.append(str(arg).replace(f"{pre_alias}.", f"{post_alias}."))

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/relationships.py

@@ -6,14 +6,12 @@ import inspect
 import typing as t
 import warnings
 
-import pydal.objects
-
 from .config import LazyPolicy
 from .constants import JOIN_OPTIONS
 from .core import ForwardRef, TypeDAL, evaluate_forward_reference
 from .fields import TypedField
 from .helpers import extract_type_optional, looks_like, unwrap_type
-from .types import Condition, OnQuery, T_Field
+from .types import Condition, OnQuery, T_Field, Table
 
 # default lazy policy is defined at the TypeDAL() instance settings level
 
@@ -199,7 +197,7 @@ class Relationship[To_Type]:
         if isinstance(self.table, str):
             return self.table
 
-        if isinstance(self.table, pydal.objects.Table):
+        if isinstance(self.table, Table):
             return str(self.table)
 
         # else: typed table
@@ -288,7 +286,7 @@ class Relationship[To_Type]:
             resolved_table = self.get_table(instance._db)
 
             builder = owner.where(id=instance.id).join(self.name)
-            if issubclass(resolved_table, TypedTable) or isinstance(resolved_table, pydal.objects.Table):
+            if issubclass(resolved_table, TypedTable) or isinstance(resolved_table, Table):
                 # is a table so we can select ALL and ignore non-required fields of parent row:
                 builder = builder.select(owner.id, resolved_table.ALL)
 

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/rows.py

@@ -8,8 +8,6 @@ import csv
 import json
 import typing as t
 
-import pydal.objects
-
 from .asynchronous import run_async
 from .core import TypeDAL
 from .helpers import mktable
@@ -25,6 +23,7 @@ from .types import (
     Query,
     Row,
     Rows,
+    Set,
     T_MetaInstance,
 )
 
@@ -199,18 +198,42 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
 
         return mktable(data, headers)
 
-    def group_by_value[T: t.Any, T_MetaInstance: _TypedTable](  # ty: ignore[shadowed-type-variable]
+    @t.overload
+    def group_by_value[T: t.Any](
+        self,
+        *fields: "TypedField[T] | str | Field",
+        one_result: t.Literal[True],
+        **kwargs: t.Any,
+    ) -> dict[T, T_MetaInstance]: ...
+
+    @t.overload
+    def group_by_value[T: t.Any](
+        self,
+        *fields: "TypedField[T] | str | Field",
+        one_result: t.Literal[False] = False,
+        **kwargs: t.Any,
+    ) -> dict[T, list[T_MetaInstance]]: ...
+
+    @t.overload
+    def group_by_value[T: t.Any](
+        self,
+        *fields: "TypedField[T] | str | Field",
+        one_result: bool,
+        **kwargs: t.Any,
+    ) -> dict[T, T_MetaInstance] | dict[T, list[T_MetaInstance]]: ...
+
+    def group_by_value[T: t.Any](
         self,
-        *fields: "str | Field | TypedField[T]",
+        *fields: "TypedField[T] | str | Field",
         one_result: bool = False,
         **kwargs: t.Any,
-    ) -> dict[T, list[T_MetaInstance]]:
+    ) -> dict[T, T_MetaInstance] | dict[T, list[T_MetaInstance]]:
         """
         Group the rows by a specific field (which will be the dict key).
         """
         kwargs["one_result"] = one_result
         result = super().group_by_value(*fields, **kwargs)
-        return t.cast(dict[T, list[T_MetaInstance]], result)
+        return t.cast(dict[T, T_MetaInstance] | dict[T, list[T_MetaInstance]], result)
 
     def as_csv(self) -> str:
         """
@@ -533,7 +556,7 @@ class PaginatedRows(TypedRows[T_MetaInstance]):
         return {"data": super().as_dict(), "pagination": self.pagination}
 
 
-class TypedSet(pydal.objects.Set):  # pragma: no cover
+class TypedSet(Set):  # pragma: no cover
     """
     Used to make pydal Set more typed.
 

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/tables.py

@@ -13,9 +13,9 @@ import types
 import typing as t
 import uuid
 
-import pydal.objects
+import pydal
 from pydal._globals import DEFAULT
-from pydal.helpers.classes import SQLCallableList
+from pydal.helpers.classes import SQLALL, SQLCallableList
 
 from .asynchronous import run_async
 from .constants import JOIN_OPTIONS
@@ -50,7 +50,7 @@ if t.TYPE_CHECKING:
 
 
 def reorder_fields(
-    table: pydal.objects.Table,
+    table: Table,
     fields: t.Iterable[str | TypedField[t.Any] | Field],
     keep_others: bool = True,
 ) -> None:
@@ -65,7 +65,7 @@ def reorder_fields(
             - False: remove other fields (only keep what's specified).
     """
     # Normalize input to field names
-    desired = [f.name if isinstance(f, (TypedField, Field, pydal.objects.Field)) else str(f) for f in fields]
+    desired = [f.name if isinstance(f, (TypedField, Field)) else str(f) for f in fields]
 
     new_order = [f for f in desired if f in table._fields]
 
@@ -105,6 +105,8 @@ class TableMeta(type):
     _table: Table | None = None
     _relationships: dict[str, Relationship[t.Any]] | None = None
     _permissions: Permissions | None = None
+    _singular: str
+    _plural: str
 
     #########################
     # TypeDAL custom logic: #
@@ -149,6 +151,14 @@ class TableMeta(type):
 
         return None
 
+    def __setattr__(self, name: str, value: t.Any) -> None:
+        """Keep PyDAL's table label metadata in sync with its model class."""
+        if name.startswith("_") and self._table is not None:
+            # include base table for internal stuff such as _singular/_plural:
+            setattr(self._table, name, value)
+
+        super().__setattr__(name, value)
+
     def _ensure_table_defined(self) -> Table:
         if not self._table:
             raise EnvironmentError("@define or db.define is not called on this class yet!")
@@ -182,7 +192,7 @@ class TableMeta(type):
         else:
             return f"<unbound table {self.__name__}>"
 
-    def from_row(self: t.Type[T_MetaInstance], row: pydal.objects.Row) -> T_MetaInstance:
+    def from_row(self: t.Type[T_MetaInstance], row: Row) -> T_MetaInstance:
         """
         Create a model instance from a pydal row.
         """
@@ -642,7 +652,7 @@ class TableMeta(type):
         return await QueryBuilder(self).collect_into_async(into=into, verbose=verbose, init=init)
 
     @property
-    def ALL(cls) -> pydal.objects.SQLALL:
+    def ALL(cls) -> SQLALL:
         """
         Select all fields for this table.
         """
@@ -931,6 +941,8 @@ class _TypedTable(metaclass=TableMeta):
     _after_delete: list[t.Callable[[Set], t.Optional[bool]]]
     _rows: tuple[Row, ...]
     _with: list[str]
+    _singular: t.ClassVar[str]
+    _plural: t.ClassVar[str]
 
     @classmethod
     def __on_define__(cls, db: TypeDAL) -> None:
@@ -1131,7 +1143,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
 
     def __new__(
         cls,
-        row_or_id: t.Union[Row, Query, pydal.objects.Set, int, str, "TypedTable", None] = None,
+        row_or_id: t.Union[Row, Query, Set, int, str, "TypedTable", None] = None,
         **filters: t.Any,
     ) -> t.Self:
         """
@@ -1149,7 +1161,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
             # existing typed table instance!
             return t.cast(t.Self, row_or_id)
 
-        elif isinstance(row_or_id, pydal.objects.Row):
+        elif isinstance(row_or_id, Row):
             row = row_or_id
         elif row_or_id is not None:
             row = table(row_or_id, **filters)

{typedal-5.0.4 → typedal-5.0.6}/src/typedal/types.py

@@ -20,6 +20,7 @@ from pydal.objects import Field as _Field
 from pydal.objects import Query as _Query
 from pydal.objects import Row as _Row
 from pydal.objects import Rows as _Rows
+from pydal.objects import Select as _Select
 from pydal.objects import Set as _Set
 from pydal.objects import Table as _Table
 from pydal.validators import Validator as _Validator
@@ -147,20 +148,26 @@ class FileSystemLike(t.Protocol):  # pragma: no cover
 # pydal Wrappers (to help mypy understand these classes)
 # ---------------------------------------------------------------------------
 
+# same for typing and runtime:
+Row: t.TypeAlias = _Row
+Validator: t.TypeAlias = _Validator
+Table: t.TypeAlias = _Table
+Reference: t.TypeAlias = _Reference
 
-class Query(_Query):
-    """Pydal Query object. Makes mypy happy."""
-
-
-class Expression(_Expression):
-    """Pydal Expression object. Make mypy happy."""
+# has to be (fake) subclass during type-checking:
+if t.TYPE_CHECKING:
 
+    class Query(_Query):
+        """Pydal Query object. Makes mypy happy."""
 
-class Set(_Set):
-    """Pydal Set object. Make mypy happy."""
+    class Expression(_Expression):
+        """Pydal Expression object. Makes mypy happy."""
 
+    class Set(_Set):
+        """Pydal Set object. Makes mypy happy."""
 
-if t.TYPE_CHECKING:
+    class Select(_Select):
+        """Pydal Select object. Makes mypy happy."""
 
     class OpRow:
         """
@@ -188,57 +195,34 @@ if t.TYPE_CHECKING:
         def values(self) -> t.Iterable[t.Any]:
             """Dictionary-like value iteration."""
 
-else:
-
-    class OpRow(_OpRow):
-        """Runtime OpRow, using pydal's version."""
-
-
-class Reference(_Reference):
-    """Pydal Reference object. Make mypy happy."""
-
-
-class Field(_Field):
-    """Pydal Field object. Make mypy happy."""
-
-    _rname: str
+    class Field(_Field):
+        """Pydal Field object. Make mypy happy."""
 
-    def __eq__(self, other: t.Any) -> Query:  # type: ignore[override]
-        """Comparing fields produces a PyDAL query."""
-        return t.cast(Query, super().__eq__(other))
+        _rname: str
 
-    def __ne__(self, other: t.Any) -> Query:  # type: ignore[override]
-        """Comparing fields produces a PyDAL query."""
-        return t.cast(Query, super().__ne__(other))
+        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 __hash__(self) -> int:
-        """Keep fields hashable after overriding equality."""
-        return super().__hash__()
+        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):
-    """Pydal Rows object. Make mypy happy."""
+    class Rows(_Rows):
+        def column(self, column: t.Any = None) -> list[t.Any]: ...
 
-    def column(self, column: t.Any = None) -> list[t.Any]:
-        """
-        Get a list of all values in a specific column.
-
-        Example:
-            rows.column('name') -> ['Name 1', 'Name 2', ...]
-        """
-        return [r[str(column) if column else self.colnames[0]] for r in self]
-
-
-class Row(_Row):
-    """Pydal Row object. Make mypy happy."""
-
-
-class Validator(_Validator):
-    """Pydal Validator object. Make mypy happy."""
-
-
-class Table(_Table):
-    """Pydal Table object. Make mypy happy."""
+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
 
 
 # ---------------------------------------------------------------------------