TypeDAL 3.11.0__tar.gz → 3.12.0__tar.gz

{typedal-3.11.0 → typedal-3.12.0}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 <!--next-version-placeholder-->
 
+## v3.12.0 (2025-04-25)
+
+### Feature
+
+* Support adding a `unique_alias` which improves working with multiple joins. ([`8b2112c`](https://github.com/trialandsuccess/TypeDAL/commit/8b2112cf9c97a00a9610e1af6e80e05fcc296aad))
+
+## v3.11.1 (2025-04-25)
+
+### Fix
+
+* Improved typing (`mypy` is happy again, py4web DAL should be typed better now) ([`b3199cb`](https://github.com/trialandsuccess/TypeDAL/commit/b3199cb423f643b1826fedab45bcaa3063fdc02d))
+* `repr(rows)` crashed when `rows` contained no data ([`cc3b2d0`](https://github.com/trialandsuccess/TypeDAL/commit/cc3b2d0bd332faee579e6fdfb7068bd511f22093))
+
 ## v3.11.0 (2025-04-25)
 
 ### Fix

{typedal-3.11.0 → typedal-3.12.0}/PKG-INFO

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

{typedal-3.11.0 → typedal-3.12.0}/docs/4_relationships.md

@@ -92,16 +92,22 @@ Adding the `Relationship["Sidekick"]` hint is optional, but recommended to impro
 Setting up a relationship that uses a junction/pivot table is slightly harder.
 
 ```python
+
+# with `unique_alias()` which is better if you have multiple joins:
+
 @db.define()
 class Post(TypedTable):
     title: str
     author: Author
 
     tags = relationship(list["Tag"], on=lambda post, tag: [
-        Tagged.on(Tagged.post == post.id),
-        tag.on(tag.id == Tagged.tag),
+        # post and tag already have a unique alias, create one for tagged here:
+        tagged := Tagged.unique_alias(),
+        tagged.on(tagged.post == post.id),
+        tag.on(tag.id == tagged.tag),
     ])
 
+# without unique alias:
 
 @db.define()
 class Tag(TypedTable):

{typedal-3.11.0 → typedal-3.12.0}/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.11.0"
+__version__ = "3.12.0"

{typedal-3.11.0 → typedal-3.12.0}/src/typedal/caching.py

@@ -385,7 +385,7 @@ def _calculate_stats(db: "TypeDAL", query: Query) -> GenericStats:
     sum_len_field = _TypedalCache.data.len().sum()
     size_row = db(query).select(sum_len_field).first()
 
-    size = size_row[sum_len_field] if size_row else 0  # type: ignore
+    size = size_row[sum_len_field] if size_row else 0
 
     return {
         "entries": _TypedalCache.where(query).count(),

{typedal-3.11.0 → typedal-3.12.0}/src/typedal/core.py

@@ -11,6 +11,7 @@ import math
 import sys
 import types
 import typing
+import uuid
 import warnings
 from collections import defaultdict
 from copy import copy
@@ -189,7 +190,7 @@ class Relationship(typing.Generic[To_Type]):
                 and_code = inspect.getsource(c_and).strip()
                 src_code += " AND " + and_code
         else:
-            cls_name = self._type if isinstance(self._type, str) else self._type.__name__  # type: ignore
+            cls_name = self._type if isinstance(self._type, str) else self._type.__name__
             src_code = f"to {cls_name} (missing condition)"
 
         join = f":{self.join}" if self.join else ""
@@ -1179,11 +1180,21 @@ class TableMeta(type):
         Useful for joins when joining the same table multiple times.
 
         See Also:
-            http://web2py.com/books/default/chapter/29/06/the-database-abstraction-layer?search=export_to_csv_file#One-to-many-relation
+            http://web2py.com/books/default/chapter/29/06/the-database-abstraction-layer#One-to-many-relation
         """
         table = self._ensure_table_defined()
         return typing.cast(Type[T_MetaInstance], table.with_alias(alias))
 
+    def unique_alias(self: Type[T_MetaInstance]) -> Type[T_MetaInstance]:
+        """
+        Generates a unique alias for this table.
+
+        Useful for joins when joining the same table multiple times
+            and you don't want to keep track of aliases yourself.
+        """
+        key = f"{self.__name__.lower()}_{hash(uuid.uuid4())}"
+        return self.with_alias(key)
+
     # hooks:
     def before_insert(
         cls: Type[T_MetaInstance],
@@ -1270,9 +1281,9 @@ class TypedField(Expression, typing.Generic[T_Value]):  # pragma: no cover
 
     def __init__(
         self,
-        _type: Type[T_Value] | types.UnionType = str,
+        _type: Type[T_Value] | types.UnionType = str,  # type: ignore
         /,
-        **settings: Unpack[FieldSettings],  # type: ignore
+        **settings: Unpack[FieldSettings],
     ) -> None:
         """
         Typed version of pydal.Field, which will be converted to a normal Field in the background.
@@ -2683,6 +2694,12 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
                 if not isinstance(on, list):  # pragma: no cover
                     on = [on]
 
+                on = [
+                    _
+                    for _ in on
+                    # only allow Expressions (query and such):
+                    if isinstance(_, pydal.objects.Expression)
+                ]
                 left.extend(on)
             elif method == "left":
                 # .on not given, generate it:
@@ -2794,7 +2811,7 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         """
         yield from self.collect()
 
-    def __count(self, db: TypeDAL, distinct: bool = None):
+    def __count(self, db: TypeDAL, distinct: bool = None) -> Query:
         # internal, shared logic between .count and ._count
         model = self.model
         query = self.query
@@ -2819,14 +2836,14 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
         return db(query).count(distinct)
 
-    def _count(self, distinct: bool = None):
+    def _count(self, distinct: bool = None) -> str:
         """
         Return the SQL for .count().
         """
         db = self._get_db()
         query = self.__count(db, distinct=distinct)
 
-        return db(query)._count(distinct)
+        return typing.cast(str, db(query)._count(distinct))
 
     def exists(self) -> bool:
         """

{typedal-3.11.0 → typedal-3.12.0}/src/typedal/for_py4web.py

@@ -22,9 +22,9 @@ class Fixture(_Fixture):  # type: ignore
 
 
 class PY4WEB_DAL_SINGLETON(MetaDAL):
-    _instances: typing.ClassVar[typing.MutableMapping[str, AnyType]] = {}
+    _instances: typing.ClassVar[typing.MutableMapping[str, TypeDAL]] = {}
 
-    def __call__(cls, uri: typing.Optional[str] = None, *args: typing.Any, **kwargs: typing.Any) -> AnyType:
+    def __call__(cls, uri: typing.Optional[str] = None, *args: typing.Any, **kwargs: typing.Any) -> TypeDAL:
         db_uid = kwargs.get("db_uid", hashlib_md5(repr(uri or (args, kwargs))).hexdigest())
         if db_uid not in cls._instances:
             cls._instances[db_uid] = super().__call__(uri, *args, **kwargs)

{typedal-3.11.0 → typedal-3.12.0}/tests/test_relationships.py

@@ -25,10 +25,11 @@ class TaggableMixin:
         list["Tag"],
         # lambda self, _: (Tagged.entity == self.gid) & (Tagged.tag == Tag.id)
         # doing an .on with and & inside can lead to a cross join,
-        # for relationships with pivot tables a manual on query is prefered:
-        on=lambda entity, _tag: [
-            Tagged.on(Tagged.entity == entity.gid),
-            Tag.on((Tagged.tag == Tag.id)),
+        # for relationships with pivot tables a manual on query with aliases is prefered:
+        on=lambda entity, tag: [
+            tagged := Tagged.unique_alias(),
+            tagged.on(tagged.entity == entity.gid),
+            tag.on((tagged.tag == tag.id)),
         ],
     )
     # tags = relationship(list["Tag"], tagged)
@@ -186,7 +187,6 @@ def test_typedal_way():
         Empty.first_or_fail()
 
     # user through article: 1 - many
-
     all_articles = Article.join().collect().as_dict()
 
     assert all_articles[3]["final_editor"]["name"] == "Editor 1"