TypeDAL 3.16.2__tar.gz → 3.16.4__tar.gz

{typedal-3.16.2 → typedal-3.16.4}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v3.16.4 (2025-09-08)
+
+### Fix
+
+* Support `.render()` with list:str relationships ([`e7d6d82`](https://github.com/trialandsuccess/TypeDAL/commit/e7d6d82de82034eee882ab4bc4e1ebf8178f8639))
+
+## 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

{typedal-3.16.2 → typedal-3.16.4}/PKG-INFO

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

{typedal-3.16.2 → typedal-3.16.4}/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.2"
+__version__ = "3.16.4"

{typedal-3.16.2 → typedal-3.16.4}/src/typedal/core.py

@@ -2037,6 +2037,61 @@ 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 getattr(row, "_with", []):
+            if relation := self._relationships.get(relation_name):
+                relation_table = relation.table
+
+                relation_row = row[relation_name]
+
+                if isinstance(relation_row, list):
+                    # list of rows
+                    combined = []
+
+                    for related_og in relation_row:
+                        related = copy.deepcopy(related_og)
+                        for fieldname in related:
+                            field = relation_table[fieldname]
+                            related[field.name] = self._db.represent(
+                                "rows_render",
+                                field,
+                                related[field.name],
+                                related,
+                            )
+                        combined.append(related)
+
+                    row[relation_name] = combined
+                else:
+                    # 1 row
+                    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
@@ -2431,38 +2486,8 @@ class TypedRows(typing.Collection[T_MetaInstance], Rows):
                 "Rows.render() needs a `rows_render` representer in DAL instance",
             )
 
-        row = copy.deepcopy(self.records[i])
-        keys = list(row)
-        if not fields:
-            fields = [f for f in self.fields if isinstance(f, Field) and f.represent]
-
-        for field in fields:
-            if field._table == self.model._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.model._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 self.compact and len(keys) == 1 and keys[0] != "_extra":  # pragma: no cover
-            return row[keys[0]]
-        return row
+        row = self.records[i]
+        return row.render(fields, compact=self.compact)
 
 
 from .caching import (  # noqa: E402

{typedal-3.16.2 → typedal-3.16.4}/tests/test_row.py

@@ -240,16 +240,50 @@ def test_render():
             condition=lambda this, that: this.normal == that.also_normal,
         )
 
+        related_list = relationship(
+            list[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()
 
-    assert rows.first().related
+    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"
+
+    # test list:
+
+    rows = RenderTable.select().join("related_list").collect()
+
+    second = rows.first()
+
+    assert second.related_list
 
     iterator = rows.render()
-    first = next(iterator)
+    rendered_three = next(iterator)
+
+    assert rendered_three.normal == "123"
+    assert rendered_three.list_field == "abc, def"
+    assert rendered_three.related_list[0].also_normal == "321"
+
+    rendered_four = second.render()
 
-    assert first.normal == "123"
-    assert first.list_field == "abc, def"
-    assert first.related.also_normal == "321"
+    assert rendered_four.normal == "123"
+    assert rendered_four.list_field == "abc, def"
+    assert rendered_four.related_list[0].also_normal == "321"