TypeDAL 5.0.5__tar.gz → 5.1.0__tar.gz

{typedal-5.0.5 → typedal-5.1.0}/PKG-INFO

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

{typedal-5.0.5 → typedal-5.1.0}/pyproject.toml

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

{typedal-5.0.5 → typedal-5.1.0}/pyproject.toml.orig

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

{typedal-5.0.5 → typedal-5.1.0}/src/typedal/asynchronous.py

@@ -434,6 +434,7 @@ class BlockingAccessHandler(ExecutionHandler):
             f"the extra query. command: {command}",
             category=BlockingDatabaseAccessWarning,
             skip_file_prefixes=_SKIP_FRAMES,
+            stacklevel=2,
         )
 
 

{typedal-5.0.5 → typedal-5.1.0}/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.5 → typedal-5.1.0}/src/typedal/cli.py

@@ -30,6 +30,7 @@ except ImportError as e:
         "to fix this.",
         source=e,
         category=RuntimeWarning,
+        stacklevel=2,
     )
     exit(127)  # command not found
 
@@ -226,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.0.5 → typedal-5.1.0}/src/typedal/config.py

@@ -159,7 +159,7 @@ def _load_toml(path: str | bool | Path | None = True) -> tuple[str, AnyDict]:
 
         return str(toml_path) or "", t.cast(AnyDict, data["tool"]["typedal"])
     except Exception as e:
-        warnings.warn(f"Could not load typedal config toml: {e}", source=e)
+        warnings.warn(f"Could not load typedal config toml: {e}", source=e, stacklevel=2)
         return str(toml_path) or "", {}
 
 

{typedal-5.0.5 → typedal-5.1.0}/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: set[type[Expression]] = {Expression}
+    stack: list[type[Expression]] = [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()
@@ -476,7 +476,12 @@ class TypeDAL(_TypeDALBase):
                 delattr(self, tablename)
 
             if verbose:
-                warnings.warn(f"{model} could not be migrated, try faking", source=e, category=RuntimeWarning)
+                warnings.warn(
+                    f"{model} could not be migrated, try faking",
+                    source=e,
+                    category=RuntimeWarning,
+                    stacklevel=2,
+                )
 
             # try again:
             return self.define(model, migrate=self._migrate, fake_migrate=self._migrate, redefine=True)
@@ -544,7 +549,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.5 → typedal-5.1.0}/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
@@ -124,7 +123,10 @@ class TableDefinitionBuilder:
             self.class_map[table._rname] = cls  # table_model - sql name
             cls.__on_define__(self.db)
         else:
-            warnings.warn("db.define used without inheriting TypedTable. This could lead to strange problems!")
+            warnings.warn(
+                "db.define used without inheriting TypedTable. This could lead to strange problems!",
+                stacklevel=2,
+            )
 
         if not tablename.startswith("typedal_") and cache_dependency:
             from .caching import _remove_cache, remove_cache_for_table
@@ -163,7 +165,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.5 → typedal-5.1.0}/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,
 )
 
@@ -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).
     """

{typedal-5.0.5 → typedal-5.1.0}/src/typedal/mixins.py

@@ -180,6 +180,7 @@ class SlugMixin(Mixin):
             warnings.warn(
                 "The 'slug_suffix' option is deprecated, use 'slug_suffix_length' instead.",
                 DeprecationWarning,
+                stacklevel=2,
             )
 
         slug_suffix = slug_suffix_length or kw.get("slug_suffix", 0)

{typedal-5.0.5 → typedal-5.1.0}/src/typedal/query_builder.py

@@ -8,9 +8,10 @@ import datetime as dt
 import math
 import time
 import typing as t
+import warnings
 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,15 +39,17 @@ from .types import (
     Query,
     Row,
     Rows,
+    Select,
     SelectKwargs,
     T_MetaInstance,
     Table,
     merge_permissions,
     require_permission,
 )
+from .warnings import UnusedWindowWarning
 
 
-class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
+class QueryBuilder[T_MetaInstance: _TypedTable](Select):
     """
     Abstration on top of pydal's query system.
     """
@@ -290,12 +293,12 @@ 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]
+                if result := query_part(self.model):
                     subquery |= result
             elif isinstance(query_part, dict):
                 subsubquery = DummyQuery()
@@ -401,7 +404,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 +421,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))
@@ -661,6 +664,17 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
 
         query, select_args, select_kwargs = self._before_query(metadata, add_id=add_id)
 
+        window_size = metadata.get("window_size", None)
+        is_iterating = metadata.get("iterating", False)
+
+        if window_size is not None and is_iterating is not True:
+            warnings.warn(
+                "A window size was configured, but collect() was called directly. "
+                "Use iteration over the query builder to fetch rows in windows.",
+                stacklevel=2,
+                category=UnusedWindowWarning,
+            )
+
         metadata["sql"] = db(query)._select(*select_args, **select_kwargs)
 
         if verbose:  # pragma: no cover
@@ -856,7 +870,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 +982,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 +1046,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}."))
@@ -1221,13 +1235,40 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
         """
         You can start iterating a Query Builder object before calling collect, for ease of use.
         """
-        yield from self.collect()
+        builder = self._extend(metadata={"iterating": True})
+        window_size = self.metadata.get("window_size", None)
+
+        if not window_size:
+            yield from builder.collect()
+            return
+
+        for chunk in builder.chunk(window_size):
+            yield from chunk
+
+    def __await__(self):
+        return self.collect_async().__await__()
+
+    async def __aiter__(self):
+        builder = self._extend(metadata={"iterating": True})
+
+        window_size = self.metadata.get("window_size", None)
+
+        if window_size:
+            async for chunk in builder.chunk_async(window_size):
+                for row in chunk:
+                    yield row
+        else:
+            rows = await builder.collect_async()
+            for row in rows:
+                yield row
+
+    def window(self, window_size: int) -> QueryBuilder[T_MetaInstance]:
+        return self._extend(metadata={"window_size": window_size})
 
     def __count(
         self,
         db: TypeDAL,
         distinct: t.Optional[bool] = None,
-        *,
         include_left_for_distinct: bool = True,
     ) -> Query:
         # internal, shared logic between .count and ._count
@@ -1350,7 +1391,10 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
                     pass
             ```
         """
-        require_permission(self._permissions, "read")
+        # require_permission checked in .collect()
+        if "limitby" in self.select_kwargs:
+            raise ValueError("chunk() cannot be combined with an existing limitby")
+
         page = 1
 
         while rows := self.__paginate(chunk_size, page).collect():
@@ -1505,7 +1549,10 @@ class QueryBuilder[T_MetaInstance: _TypedTable](pydal.objects.Select):
         writer can be visible halfway through the iteration; wrap it in `db.session()` if you
         need every page to come from the same snapshot.
         """
-        require_permission(self._permissions, "read")
+        # require_permission checked in .collect()
+        if "limitby" in self.select_kwargs:
+            raise ValueError("chunk_async() cannot be combined with an existing limitby")
+
         db = self._get_db()
         page = 1
 

{typedal-5.0.5 → typedal-5.1.0}/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
 
@@ -112,7 +110,7 @@ class Relationship[To_Type]:
 
     @staticmethod
     def _error_duplicate_condition(condition: Condition, on: OnQuery) -> t.Never:
-        warnings.warn(f"Relation | Both specified! {condition=} {on=}")
+        warnings.warn(f"Relation | Both specified! {condition=} {on=}", stacklevel=2)
         raise ValueError("Please specify either a condition or an 'on' statement for this relationship!")
 
     def __repr__(self) -> str:
@@ -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
@@ -280,6 +278,7 @@ class Relationship[To_Type]:
                 f"Trying to access relationship '{self.name}' without joining. "
                 f"Did you forget to use .join('{self.name}')? Returning empty value.",
                 category=RuntimeWarning,
+                stacklevel=2,
             )
             return fallback_value
 
@@ -288,7 +287,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)
 
@@ -298,6 +297,7 @@ class Relationship[To_Type]:
                     "This performs an extra database query. "
                     f"Consider using .join('{self.name}') for better performance.",
                     category=RuntimeWarning,
+                    stacklevel=2,
                 )
 
             return builder.first()[self.name]  # type: ignore
@@ -306,6 +306,7 @@ class Relationship[To_Type]:
                 f"Failed to lazy load relationship '{self.name}': {e}",
                 category=RuntimeWarning,
                 source=e,
+                stacklevel=2,
             )
 
             return fallback_value
@@ -503,12 +504,12 @@ def to_relationship(
     try:
         condition = _generate_relationship_condition(cls, key, field)
     except Exception as e:  # pragma: no cover
-        warnings.warn("Could not generate Relationship condition", source=e)
+        warnings.warn("Could not generate Relationship condition", source=e, stacklevel=2)
         condition = None
 
     if not condition:  # pragma: no cover
         # something went wrong, not a valid relationship
-        warnings.warn(f"Invalid relationship for {cls.__name__}.{key}: {field}")
+        warnings.warn(f"Invalid relationship for {cls.__name__}.{key}: {field}", stacklevel=2)
         return None
 
     join = "left" if optional or t.get_origin(field) is list else "inner"

{typedal-5.0.5 → typedal-5.1.0}/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.5 → typedal-5.1.0}/src/typedal/serializers/typescript.py

@@ -31,7 +31,7 @@ class TypedDictRegistry(Singleton):
     def __init__(self) -> None:
         """Initialize the singleton registry and optional shared typtyp world."""
         self._types: dict[type, type[dict[str, t.Any]]] = {}
-        self._world = typtyp.World() if typtyp else None
+        self._world = typtyp.World() if typtyp else None  # type: ignore
         self._names: set[str] = set()
 
     @property
@@ -78,6 +78,7 @@ class TypedDictRegistry(Singleton):
         if world is None:  # pragma: ignore
             warnings.warn(
                 f"`{caller_name}` can not be used without the typescript extra. Please install `typedal[typescript]`",
+                stacklevel=2,
             )
             return ""
 

{typedal-5.0.5 → typedal-5.1.0}/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: #
@@ -136,6 +138,23 @@ class TableMeta(type):
         self._relationships = None
         self._permissions = None
 
+    def __getattribute__(self, col: str) -> t.Any:
+        """
+        Resolve bound table fields before metaclass convenience methods.
+
+        Annotation-only fields are not stored in the model class dictionary, so
+        normal class lookup would otherwise return a same-named method defined
+        on this metaclass. For example, a model may have a 'window' column
+        while this metaclass also provides 'window()'. The column takes
+        precedence on the model class; use 'QueryBuilder(Model).window()' to
+        call the query helper in that case.
+        """
+        table = type.__getattribute__(self, "_table")
+        if table is not None and col in table._fields:
+            return table[col]
+
+        return type.__getattribute__(self, col)
+
     def __getattr__(self, col: str) -> t.Optional[Field]:
         """
         Magic method used by TypedTableMeta to get a database field with dot notation on a class.
@@ -149,6 +168,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 +209,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.
         """
@@ -455,6 +482,12 @@ class TableMeta(type):
         """
         return QueryBuilder(self).join(*fields, on=on, condition=condition, method=method, condition_and=condition_and)
 
+    def window(self: t.Type[T_MetaInstance], window_size: int) -> "QueryBuilder[T_MetaInstance]":
+        """
+        See QueryBuilder.window!
+        """
+        return QueryBuilder(self).window(window_size)
+
     def collect(self: t.Type[T_MetaInstance], verbose: bool = False) -> "TypedRows[T_MetaInstance]":
         """
         See QueryBuilder.collect!
@@ -642,7 +675,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 +964,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 +1166,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 +1184,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.5 → typedal-5.1.0}/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:  # ty: ignore[invalid-method-override]
-        """Comparing fields produces a PyDAL query."""
-        return t.cast(Query, super().__eq__(other))
+        _rname: str
 
-    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 __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
 
 
 # ---------------------------------------------------------------------------
@@ -329,6 +313,8 @@ class Metadata(t.TypedDict):
     select_duration: t.NotRequired[float]
     relationships: t.NotRequired[set[str]]
     sql: t.NotRequired[str]
+    window_size: t.NotRequired[int]
+    iterating: t.NotRequired[bool]
 
 
 class FieldSettings(t.TypedDict, total=False):

typedal-5.1.0/src/typedal/warnings.py

@@ -0,0 +1,5 @@
+"""Warning types emitted by TypeDAL."""
+
+
+class UnusedWindowWarning(RuntimeWarning):
+    """Warn when a window size is configured but the query is collected directly."""