TypeDAL 3.16.1__tar.gz → 3.16.3__tar.gz

{typedal-3.16.1 → typedal-3.16.3}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v3.16.3 (2025-09-08)
+
+### Fix
+
+* Support `.render()` on individual row ([`200a64c`](https://github.com/trialandsuccess/TypeDAL/commit/200a64c0e0c2647c5036dee0476d9ad8ebb416e4))
+
+## v3.16.2 (2025-09-08)
+
+### Fix
+
+* Support `.render()` on rows ([`11e115a`](https://github.com/trialandsuccess/TypeDAL/commit/11e115aceaa0207c1b6a969cd3fec95b5e898970))
+
 ## v3.16.1 (2025-09-01)
 
 ### Fix

{typedal-3.16.1 → typedal-3.16.3}/PKG-INFO

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

{typedal-3.16.1 → typedal-3.16.3}/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__ = "3.16.1"
+__version__ = "3.16.3"

{typedal-3.16.1 → typedal-3.16.3}/src/typedal/core.py

@@ -5,6 +5,7 @@ Core functionality of TypeDAL.
 from __future__ import annotations
 
 import contextlib
+import copy
 import csv
 import datetime as dt
 import functools
@@ -18,7 +19,6 @@ import typing
 import uuid
 import warnings
 from collections import defaultdict
-from copy import copy
 from decimal import Decimal
 from pathlib import Path
 from typing import Any, Optional, Type
@@ -246,7 +246,8 @@ class Relationship(typing.Generic[To_Type]):
             return self
 
         warnings.warn(
-            "Trying to get data from a relationship object! Did you forget to join it?", category=RuntimeWarning
+            "Trying to get data from a relationship object! Did you forget to join it?",
+            category=RuntimeWarning,
         )
         if self.multiple:
             return []
@@ -255,7 +256,10 @@ class Relationship(typing.Generic[To_Type]):
 
 
 def relationship(
-    _type: typing.Type[To_Type], condition: Condition = None, join: JOIN_OPTIONS = None, on: OnQuery = None
+    _type: typing.Type[To_Type],
+    condition: Condition = None,
+    join: JOIN_OPTIONS = None,
+    on: OnQuery = None,
 ) -> To_Type:
     """
     Define a relationship to another table, when its id is not stored in the current table.
@@ -546,7 +550,7 @@ class TypeDAL(pydal.DAL):  # type: ignore
 
         for key, field in typedfields.items():
             # clone every property so it can be re-used across mixins:
-            clone = copy(field)
+            clone = copy.copy(field)
             setattr(cls, key, clone)
             typedfields[key] = clone
 
@@ -737,7 +741,9 @@ class TypeDAL(pydal.DAL):  # type: ignore
 
     @classmethod
     def _annotation_to_pydal_fieldtype(
-        cls, _ftype: T_annotation, mut_kw: typing.MutableMapping[str, Any]
+        cls,
+        _ftype: T_annotation,
+        mut_kw: typing.MutableMapping[str, Any],
     ) -> Optional[str]:
         # ftype can be a union or type. typing.cast is sometimes used to tell mypy when it's not a union.
         ftype = typing.cast(type, _ftype)  # cast from Type to type to make mypy happy)
@@ -824,12 +830,26 @@ class TypeDAL(pydal.DAL):  # type: ignore
         return to_snake(camel)
 
 
+def default_representer(field: TypedField[T], value: T, table: Type[TypedTable]) -> str:
+    """
+    Simply call field.represent on the value.
+    """
+    if represent := getattr(field, "represent", None):
+        return field.represent(value, table)
+    else:
+        return repr(value)
+
+
+TypeDAL.representers.setdefault("rows_render", default_representer)
+
 P = typing.ParamSpec("P")
 R = typing.TypeVar("R")
 
 
 def reorder_fields(
-    table: pydal.objects.Table, fields: typing.Iterable[str | Field | TypedField], keep_others: bool = True
+    table: pydal.objects.Table,
+    fields: typing.Iterable[str | Field | TypedField],
+    keep_others: bool = True,
 ) -> None:
     """
     Reorder fields of a pydal table.
@@ -987,7 +1007,9 @@ class TableMeta(type):
         return self.where(lambda row: row.id.belongs(result)).collect()
 
     def update_or_insert(
-        self: Type[T_MetaInstance], query: T_Query | AnyDict = DEFAULT, **values: Any
+        self: Type[T_MetaInstance],
+        query: T_Query | AnyDict = DEFAULT,
+        **values: Any,
     ) -> T_MetaInstance:
         """
         Update a row if query matches, else insert a new one.
@@ -1010,7 +1032,8 @@ class TableMeta(type):
         return self(record)
 
     def validate_and_insert(
-        self: Type[T_MetaInstance], **fields: Any
+        self: Type[T_MetaInstance],
+        **fields: Any,
     ) -> tuple[Optional[T_MetaInstance], Optional[dict[str, str]]]:
         """
         Validate input data and then insert a row.
@@ -1025,7 +1048,9 @@ class TableMeta(type):
             return None, result.get("errors")
 
     def validate_and_update(
-        self: Type[T_MetaInstance], query: Query, **fields: Any
+        self: Type[T_MetaInstance],
+        query: Query,
+        **fields: Any,
     ) -> tuple[Optional[T_MetaInstance], Optional[dict[str, str]]]:
         """
         Validate input data and then update max 1 row.
@@ -1045,7 +1070,9 @@ class TableMeta(type):
             return None, None
 
     def validate_and_update_or_insert(
-        self: Type[T_MetaInstance], query: Query, **fields: Any
+        self: Type[T_MetaInstance],
+        query: Query,
+        **fields: Any,
     ) -> tuple[Optional[T_MetaInstance], Optional[dict[str, str]]]:
         """
         Validate input data and then update_and_insert (on max 1 row).
@@ -1262,7 +1289,9 @@ class TableMeta(type):
 
     # hooks:
     def _hook_once(
-        cls: Type[T_MetaInstance], hooks: list[typing.Callable[P, R]], fn: typing.Callable[P, R]
+        cls: Type[T_MetaInstance],
+        hooks: list[typing.Callable[P, R]],
+        fn: typing.Callable[P, R],
     ) -> Type[T_MetaInstance]:
         @functools.wraps(fn)
         def wraps(*a: P.args, **kw: P.kwargs) -> R:
@@ -1456,7 +1485,9 @@ class TypedField(Expression, typing.Generic[T_Value]):  # pragma: no cover
         """
 
     def __get__(
-        self, instance: T_MetaInstance | None, owner: Type[T_MetaInstance]
+        self,
+        instance: T_MetaInstance | None,
+        owner: Type[T_MetaInstance],
     ) -> typing.Union[T_Value, "TypedField[T_Value]"]:
         """
         Since this class is a Descriptor field, \
@@ -1665,7 +1696,9 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         self.update_record = self._update_record  # type: ignore
 
     def __new__(
-        cls, row_or_id: typing.Union[Row, Query, pydal.objects.Set, int, str, None, "TypedTable"] = None, **filters: Any
+        cls,
+        row_or_id: typing.Union[Row, Query, pydal.objects.Set, int, str, None, "TypedTable"] = None,
+        **filters: Any,
     ) -> Self:
         """
         Create a Typed Rows model instance from an existing row, ID or query.
@@ -1848,7 +1881,9 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         return typing.cast(str, table.as_yaml(sanitize))
 
     def _as_dict(
-        self, datetime_to_str: bool = False, custom_types: typing.Iterable[type] | type | None = None
+        self,
+        datetime_to_str: bool = False,
+        custom_types: typing.Iterable[type] | type | None = None,
     ) -> AnyDict:
         row = self._ensure_matching_row()
 
@@ -2002,6 +2037,41 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
 
         return pydal2sql.generate_sql(cls)
 
+    def render(self, fields=None, compact=False) -> Self:
+        row = copy.deepcopy(self)
+        keys = list(row)
+        if not fields:
+            fields = [self._table[f] for f in self._table._fields]
+            fields = [f for f in fields if isinstance(f, Field) and f.represent]
+
+        for field in fields:
+            if field._table == self._table:
+                row[field.name] = self._db.represent(
+                    "rows_render",
+                    field,
+                    row[field.name],
+                    row,
+                )
+            # else: relationship, different logic:
+
+        for relation_name in row._with:
+            if relation := self._relationships.get(relation_name):
+                relation_table = relation.table
+
+                relation_row = row[relation_name]
+                for fieldname in relation_row:
+                    field = relation_table[fieldname]
+                    row[relation_name][fieldname] = self._db.represent(
+                        "rows_render",
+                        field,
+                        relation_row[field.name],
+                        relation_row,
+                    )
+
+        if compact and len(keys) == 1 and keys[0] != "_extra":  # pragma: no cover
+            return row[keys[0]]
+        return row
+
 
 # backwards compat:
 TypedRow = TypedTable
@@ -2104,7 +2174,9 @@ class TypedRows(typing.Collection[T_MetaInstance], Rows):
         return self[max_id]
 
     def find(
-        self, f: typing.Callable[[T_MetaInstance], Query], limitby: tuple[int, int] = None
+        self,
+        f: typing.Callable[[T_MetaInstance], Query],
+        limitby: tuple[int, int] = None,
     ) -> "TypedRows[T_MetaInstance]":
         """
         Returns a new Rows object, a subset of the original object, filtered by the function `f`.
@@ -2176,7 +2248,10 @@ class TypedRows(typing.Collection[T_MetaInstance], Rows):
         return mktable(data, headers)
 
     def group_by_value(
-        self, *fields: "str | Field | TypedField[T]", one_result: bool = False, **kwargs: Any
+        self,
+        *fields: "str | Field | TypedField[T]",
+        one_result: bool = False,
+        **kwargs: Any,
     ) -> dict[T, list[T_MetaInstance]]:
         """
         Group the rows by a specific field (which will be the dict key).
@@ -2342,7 +2417,10 @@ class TypedRows(typing.Collection[T_MetaInstance], Rows):
 
     @classmethod
     def from_rows(
-        cls, rows: Rows, model: Type[T_MetaInstance], metadata: Metadata = None
+        cls,
+        rows: Rows,
+        model: Type[T_MetaInstance],
+        metadata: Metadata = None,
     ) -> "TypedRows[T_MetaInstance]":
         """
         Internal method to convert a Rows object to a TypedRows.
@@ -2368,6 +2446,29 @@ class TypedRows(typing.Collection[T_MetaInstance], Rows):
         self.__dict__.update(state)
         # db etc. set after undill by caching.py
 
+    def render(self, i=None, fields=None) -> typing.Generator[T_MetaInstance, None, None]:
+        """
+        Takes an index and returns a copy of the indexed row with values
+        transformed via the "represent" attributes of the associated fields.
+
+        Args:
+            i: index. If not specified, a generator is returned for iteration
+                over all the rows.
+            fields: a list of fields to transform (if None, all fields with
+                "represent" attributes will be transformed)
+        """
+        if i is None:
+            # difference: uses .keys() instead of index
+            return (self.render(i, fields=fields) for i in self.records.keys())
+
+        if not self.db.has_representer("rows_render"):  # pragma: no cover
+            raise RuntimeError(
+                "Rows.render() needs a `rows_render` representer in DAL instance",
+            )
+
+        row = self.records[i]
+        return row.render(fields, compact=self.compact)
+
 
 from .caching import (  # noqa: E402
     _remove_cache,
@@ -2472,7 +2573,7 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
                 self.select_kwargs,
                 self.relationships,
                 self.metadata,
-            ]
+            ],
         )
 
     def _extend(
@@ -2631,7 +2732,10 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         return self._extend(relationships=relationships)
 
     def cache(
-        self, *deps: Any, expires_at: Optional[dt.datetime] = None, ttl: Optional[int | dt.timedelta] = None
+        self,
+        *deps: Any,
+        expires_at: Optional[dt.datetime] = None,
+        ttl: Optional[int | dt.timedelta] = None,
     ) -> "QueryBuilder[T_MetaInstance]":
         """
         Enable caching for this query to load repeated calls from a dill row \
@@ -2772,7 +2876,10 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         return db(query).select(*select_args, **select_kwargs)
 
     def collect(
-        self, verbose: bool = False, _to: Type["TypedRows[Any]"] = None, add_id: bool = True
+        self,
+        verbose: bool = False,
+        _to: Type["TypedRows[Any]"] = None,
+        add_id: bool = True,
     ) -> "TypedRows[T_MetaInstance]":
         """
         Execute the built query and turn it into model instances, while handling relationships.
@@ -2938,7 +3045,10 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         return query, select_args
 
     def _collect_with_relationships(
-        self, rows: Rows, metadata: Metadata, _to: Type["TypedRows[Any]"]
+        self,
+        rows: Rows,
+        metadata: Metadata,
+        _to: Type["TypedRows[Any]"],
     ) -> "TypedRows[T_MetaInstance]":
         """
         Transform the raw rows into Typed Table model instances.

{typedal-3.16.1 → typedal-3.16.3}/tests/test_orm.py

@@ -34,35 +34,6 @@ T_Table = typing.TypeVar("T_Table", bound=TypedTable)
 
 TypeTable = typing.Type[T_Table]
 
-# class TypeDAL:
-#     tables: list[typing.Type[TypedTable]]
-#
-#     def __init__(self, conn):
-#         self.tables = []
-#
-#     @typing.overload
-#     def define(self, table: TypeTable) -> TypeTable:
-#         ...
-#
-#     @typing.overload
-#     def define(self, table: None = None) -> typing.Callable[[TypeTable], TypeTable]:
-#         ...
-#
-#     def define(
-#         self, table: typing.Optional[TypeTable] = None
-#     ) -> TypeTable | typing.Callable[[TypeTable], TypeTable]:
-#         if table:  # and issubclass(table, Table)
-#             self.tables.append(table)
-#             table._db = self
-#             return table
-#         else:
-#             # called with ()
-#             def wrapper(table: TypeTable) -> TypeTable:
-#                 return self.define(table)
-#
-#             return wrapper
-
-
 T_Value = typing.TypeVar("T_Value")  # actual type of the Field (via Generic)
 
 # T_Table = typing.TypeVar("T_Table")  # typevar used by __get__

{typedal-3.16.1 → typedal-3.16.3}/tests/test_py4web.py

@@ -42,7 +42,7 @@ def test_auth_user():
     requirements = AuthUser.email.requires
 
     assert requirements
-    assert isinstance(requirements, tuple)
+    assert isinstance(requirements, list)
     assert len(requirements) == 2
 
     assert isinstance(requirements[0], IS_EMAIL)

{typedal-3.16.1 → typedal-3.16.3}/tests/test_row.py

@@ -9,7 +9,7 @@ import pydal
 import pytest
 from pydal.objects import Rows
 
-from src.typedal import TypeDAL, TypedField, TypedTable
+from src.typedal import TypeDAL, TypedField, TypedTable, relationship
 from src.typedal.fields import IntegerField, ReferenceField
 
 db = TypeDAL("sqlite:memory")
@@ -220,3 +220,44 @@ def test_rows():
     empty_rows = NewStyleClass.where(NewStyleClass.id < 0).collect()
     assert str(empty_rows)
     assert repr(empty_rows)
+
+
+def test_render():
+    def comma_separated(lst: list[str], _):
+        return ", ".join(lst) if lst else ""
+
+    @db.define()
+    class RelatedTable(TypedTable):
+        also_normal = TypedField(str, represent=lambda value, _: value[::-1])
+
+    @db.define()
+    class RenderTable(TypedTable):
+        normal = TypedField(str)
+        list_field = TypedField(list[str], represent=comma_separated)
+
+        related = relationship(
+            RelatedTable,
+            condition=lambda this, that: this.normal == that.also_normal,
+        )
+
+    RelatedTable.insert(also_normal="123")
+    RenderTable.insert(normal="123", list_field=["abc", "def"])
+
+    rows = RenderTable.select().join("related").collect()
+
+    first = rows.first()
+
+    assert first.related
+
+    iterator = rows.render()
+    rendered_one = next(iterator)
+
+    assert rendered_one.normal == "123"
+    assert rendered_one.list_field == "abc, def"
+    assert rendered_one.related.also_normal == "321"
+
+    # .render() on one row:
+    rendered_two = first.render()
+    assert rendered_two.normal == "123"
+    assert rendered_two.list_field == "abc, def"
+    assert rendered_two.related.also_normal == "321"