TypeDAL 3.8.4__tar.gz → 3.9.0__tar.gz

{typedal-3.8.4 → typedal-3.9.0}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 <!--next-version-placeholder-->
 
+## v3.9.0 (2024-10-25)
+
+### Feature
+
+* Add `condition_and` to .join so you can add additional requirements to inner joins ([`0ae688b`](https://github.com/trialandsuccess/TypeDAL/commit/0ae688ba01f421c70a660b5bb5d9672484494aa4))
+
+## v3.8.5 (2024-10-24)
+
+### Fix
+
+* Use right 'timestamp' field ([`2aedb02`](https://github.com/trialandsuccess/TypeDAL/commit/2aedb027b4490f8284253e9c7f427b0660b6bc13))
+* Allow specifying a field to Builder.count(...); support selecting extra fields (e.g. MyField.count()) ([`ce28a79`](https://github.com/trialandsuccess/TypeDAL/commit/ce28a7995a6d817424462f8b18383c85fa349ba4))
+
 ## v3.8.4 (2024-10-24)
 
 ### Fix

{typedal-3.8.4 → typedal-3.9.0}/PKG-INFO

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

{typedal-3.8.4 → typedal-3.9.0}/example_new.py

@@ -8,6 +8,8 @@ from src.typedal.fields import TextField
 from src.typedal.helpers import utcnow
 from pydal.validators import IS_NOT_EMPTY
 
+from typedal.fields import TimestampField
+
 db = TypeDAL("sqlite:memory")
 
 
@@ -20,7 +22,7 @@ class Person(TypedTable):
     age = TypedField(int, default=18, requires=IS_NOT_EMPTY())
     nicknames: list[str]
 
-    ts = TypedField(dt.datetime, type="timestamp")
+    ts = TimestampField()
 
 
 assert db.person._format == "%(name)s"

{typedal-3.8.4 → typedal-3.9.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.8.4"
+__version__ = "3.9.0"

{typedal-3.8.4 → typedal-3.9.0}/src/typedal/core.py

@@ -130,6 +130,7 @@ class Relationship(typing.Generic[To_Type]):
     _type: To_Type
     table: Type["TypedTable"] | type | str
     condition: Condition
+    condition_and: Condition
     on: OnQuery
     multiple: bool
     join: JOIN_OPTIONS
@@ -140,6 +141,7 @@ class Relationship(typing.Generic[To_Type]):
         condition: Condition = None,
         join: JOIN_OPTIONS = None,
         on: OnQuery = None,
+        condition_and: Condition = None,
     ):
         """
         Should not be called directly, use relationship() instead!
@@ -152,6 +154,7 @@ class Relationship(typing.Generic[To_Type]):
         self.condition = condition
         self.join = "left" if on else join  # .on is always left join!
         self.on = on
+        self.condition_and = condition_and
 
         if args := typing.get_args(_type):
             self.table = unwrap_type(args[0])
@@ -172,6 +175,7 @@ class Relationship(typing.Generic[To_Type]):
             update.get("condition") or self.condition,
             update.get("join") or self.join,
             update.get("on") or self.on,
+            update.get("condition_and") or self.condition_and,
         )
 
     def __repr__(self) -> str:
@@ -180,6 +184,10 @@ class Relationship(typing.Generic[To_Type]):
         """
         if callback := self.condition or self.on:
             src_code = inspect.getsource(callback).strip()
+
+            if c_and := self.condition_and:
+                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
             src_code = f"to {cls_name} (missing condition)"
@@ -1050,11 +1058,12 @@ class TableMeta(type):
         method: JOIN_OPTIONS = None,
         on: OnQuery | list[Expression] | Expression = None,
         condition: Condition = None,
+        condition_and: Condition = None,
     ) -> "QueryBuilder[T_MetaInstance]":
         """
         See QueryBuilder.join!
         """
-        return QueryBuilder(self).join(*fields, on=on, condition=condition, method=method)
+        return QueryBuilder(self).join(*fields, on=on, condition=condition, method=method, condition_and=condition_and)
 
     def collect(self: Type[T_MetaInstance], verbose: bool = False) -> "TypedRows[T_MetaInstance]":
         """
@@ -1500,7 +1509,14 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
             return None  # type: ignore
 
         inst._row = row
-        inst.__dict__.update(row)
+
+        if hasattr(row, "id"):
+            inst.__dict__.update(row)
+        else:
+            # deal with _extra (and possibly others?)
+            # Row <{actual: {}, _extra: ...}>
+            inst.__dict__.update(row[str(cls)])
+
         inst._setup_instance_methods()
         return inst
 
@@ -1828,7 +1844,22 @@ class TypedRows(typing.Collection[T_MetaInstance], Rows):
         `metadata` can be any (un)structured data
         `model` is a Typed Table class
         """
-        records = records or {row.id: model(row) for row in rows}
+
+        def _get_id(row: Row) -> int:
+            """
+            Try to find the id field in a row.
+
+            If _extra exists, the row changes:
+            <Row {'test_relationship': {'id': 1}, '_extra': {'COUNT("test_relationship"."querytable")': 8}}>
+            """
+            if idx := getattr(row, "id", None):
+                return typing.cast(int, idx)
+            elif main := getattr(row, str(model), None):
+                return typing.cast(int, main.id)
+            else:  # pragma: no cover
+                raise NotImplementedError(f"`id` could not be found for {row}")
+
+        records = records or {_get_id(row): model(row) for row in rows}
         super().__init__(rows.db, records, rows.colnames, rows.compact, rows.response, rows.fields)
         self.model = model
         self.metadata = metadata or {}
@@ -2295,6 +2326,7 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         method: JOIN_OPTIONS = None,
         on: OnQuery | list[Expression] | Expression = None,
         condition: Condition = None,
+        condition_and: Condition = None,
     ) -> "QueryBuilder[T_MetaInstance]":
         """
         Include relationship fields in the result.
@@ -2304,8 +2336,13 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
         By default, the `method` defined in the relationship is used.
             This can be overwritten with the `method` keyword argument (left or inner)
+
+        `condition_and` can be used to add extra conditions to an inner join.
         """
         # todo: allow limiting amount of related rows returned for join?
+        # todo: it would be nice if 'fields' could be an actual relationship
+        #   (Article.tags = list[Tag]) and you could change the .condition and .on
+        #  this could deprecate condition_and
 
         relationships = self.model.get_relationships()
 
@@ -2318,7 +2355,9 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
             if isinstance(condition, pydal.objects.Query):
                 condition = as_lambda(condition)
 
-            relationships = {str(fields[0]): Relationship(fields[0], condition=condition, join=method)}
+            relationships = {
+                str(fields[0]): Relationship(fields[0], condition=condition, join=method, condition_and=condition_and)
+            }
         elif on:
             if len(fields) != 1:
                 raise ValueError("join(field, on=...) can only be used with exactly one field!")
@@ -2328,15 +2367,17 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
             if isinstance(on, list):
                 on = as_lambda(on)
-            relationships = {str(fields[0]): Relationship(fields[0], on=on, join=method)}
+            relationships = {str(fields[0]): Relationship(fields[0], on=on, join=method, condition_and=condition_and)}
 
         else:
             if fields:
                 # join on every relationship
-                relationships = {str(k): relationships[str(k)] for k in fields}
+                relationships = {str(k): relationships[str(k)].clone(condition_and=condition_and) for k in fields}
 
             if method:
-                relationships = {str(k): r.clone(join=method) for k, r in relationships.items()}
+                relationships = {
+                    str(k): r.clone(join=method, condition_and=condition_and) for k, r in relationships.items()
+                }
 
         return self._extend(relationships=relationships)
 
@@ -2557,7 +2598,6 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
         metadata["relationships"] = set(self.relationships.keys())
 
-        # query = self._update_query_for_inner(db, model, query)
         join = []
         for key, relation in self.relationships.items():
             if not relation.condition or relation.join != "inner":
@@ -2565,7 +2605,11 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
             other = relation.get_table(db)
             other = other.with_alias(f"{key}_{hash(relation)}")
-            join.append(other.on(relation.condition(model, other)))
+            condition = relation.condition(model, other)
+            if callable(relation.condition_and):
+                condition &= relation.condition_and(model, other)
+
+            join.append(other.on(condition))
 
         if limitby := select_kwargs.pop("limitby", ()):
 
@@ -2615,12 +2659,12 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
                 # .on not given, generate it:
                 other = other.with_alias(f"{key}_{hash(relation)}")
                 condition = typing.cast(Query, relation.condition(model, other))
+                if callable(relation.condition_and):
+                    condition &= relation.condition_and(model, other)
                 left.append(other.on(condition))
             else:
                 # else: inner join (handled earlier)
                 other = other.with_alias(f"{key}_{hash(relation)}")  # only for replace
-                # other = other.with_alias(f"{key}_{hash(relation)}")
-                # query &= relation.condition(model, other)
 
             # if no fields of 'other' are included, add other.ALL
             # else: only add other.id if missing
@@ -2721,7 +2765,7 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         """
         yield from self.collect()
 
-    def count(self) -> int:
+    def count(self, distinct: bool = None) -> int:
         """
         Return the amount of rows matching the current query.
         """
@@ -2730,14 +2774,16 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         query = self.query
 
         for key, relation in self.relationships.items():
-            if not relation.condition or relation.join != "inner":
+            if (not relation.condition or relation.join != "inner") and not distinct:
                 continue
 
             other = relation.get_table(db)
-            other = other.with_alias(f"{key}_{hash(relation)}")
+            if not distinct:
+                # todo: can this lead to other issues?
+                other = other.with_alias(f"{key}_{hash(relation)}")
             query &= relation.condition(model, other)
 
-        return db(query).count()
+        return db(query).count(distinct)
 
     def __paginate(
         self,

{typedal-3.8.4 → typedal-3.9.0}/tests/test_query_builder.py

@@ -400,6 +400,7 @@ def test_complex_join():
 
 
 def test_reprs_and_bool():
+    _setup_data()
     assert TestQueryTable.where(id=1)
     assert not TestQueryTable.where(id=101)
 
@@ -471,3 +472,17 @@ def test_column():
 
     assert len(rows) == 4
     assert set(rows) == {33}
+
+
+def test_collect_with_extra_fields():
+    _setup_data()
+    builder = TestRelationship.select(TestRelationship.id, TestRelationship.name, TestRelationship.querytable.count())
+
+    assert builder.execute()
+
+    row = builder.first_or_fail()
+
+    assert row.id
+    assert row.name
+    assert row._extra
+    assert row[TestRelationship.querytable.count()]

{typedal-3.8.4 → typedal-3.9.0}/tests/test_relationships.py

@@ -43,7 +43,7 @@ class Role(TypedTable, TaggableMixin):
 @db.define()
 class User(TypedTable, TaggableMixin):
     gid = TypedField(str, default=uuid4)
-    name: str
+    name: TypedField[str]
     roles: TypedField[list[Role]]
     main_role = TypedField(Role)
     extra_roles = TypedField(list[Role])
@@ -110,6 +110,11 @@ def _setup_data():
         ]
     )
 
+    # no relationships:
+    new_author = User.insert(name="Untagged Author", roles=[], main_role=writer, extra_roles=[])
+    untagged1 = Article.insert(title="Untagged Article 1", author=new_author)
+    untagged2 = Article.insert(title="Untagged Article 2", author=new_author)
+
     # articles
 
     article1, article2 = Article.bulk_insert(
@@ -184,11 +189,11 @@ def test_typedal_way():
 
     all_articles = Article.join().collect().as_dict()
 
-    assert all_articles[1]["final_editor"]["name"] == "Editor 1"
-    assert all_articles[2]["secondary_author"]["name"] == "Editor 1"
+    assert all_articles[3]["final_editor"]["name"] == "Editor 1"
+    assert all_articles[4]["secondary_author"]["name"] == "Editor 1"
 
-    assert all_articles[1]["secondary_author"] is None
-    assert all_articles[2]["final_editor"] is None
+    assert all_articles[3]["secondary_author"] is None
+    assert all_articles[4]["final_editor"] is None
 
     assert Article.first_or_fail()
 
@@ -244,7 +249,7 @@ def test_typedal_way():
 
     users = User.join().collect()
 
-    assert len(users) == 3  # reader, writer, editor
+    assert len(users) == 4  # reader, writer, editor, untagged
 
     # get by id:
     reader = users[1]
@@ -290,6 +295,7 @@ def test_typedal_way():
 
 
 def test_reprs():
+    _setup_data()
     assert "Relationship:left on=" in repr(Article.tags)
 
     article = Article.first()
@@ -318,6 +324,16 @@ def test_reprs():
 
     assert empty.get_table_name() == "new"
 
+    relation = Article.join("author").relationships["author"]
+
+    assert "AND" not in repr(relation)
+
+    relation = Article.join("author",
+                            condition_and=lambda article, author: author.name != "Hank"
+                            ).relationships["author"]
+
+    assert "AND" in repr(relation) and "Hank" in repr(relation)
+
 
 @db.define()
 class CacheFirst(TypedTable):
@@ -350,6 +366,33 @@ def test_relationship_detection():
     assert user_table_relationships["extra_roles"].join == "left"
 
 
+def test_join_with_different_condition():
+    _setup_data()
+
+    role_with_users = Role.join(
+        "users",
+        method="inner",
+    ).first()
+
+    assert role_with_users.users
+    assert role_with_users.users[0].name == "Reader 1"
+
+    role_with_users = Role.join(
+        "users", method="inner", condition_and=lambda role, user: ~user.name.like("Reader%")
+    ).first()
+
+    assert role_with_users.users
+    assert role_with_users.users[0].name != "Reader 1"
+
+    # left:
+    role_with_users = Role.join(
+        "users", method="left", condition_and=lambda role, user: ~user.name.like("Reader%")
+    ).first()
+
+    assert role_with_users.users
+    assert role_with_users.users[0].name != "Reader 1"
+
+
 def test_caching():
     uncached = User.join().collect_or_fail()
     cached = User.cache().join().collect_or_fail()  # not actually cached yet!
@@ -536,3 +579,44 @@ def test_illegal():
 
         class HasRelationship:
             something = relationship("...", condition=lambda: 1, on=lambda: 2)
+
+
+def test_join_with_select():
+    _setup_data()
+
+    builder = User.select(User.id, User.gid, Article.id, Article.gid).where(id=2).join("articles")
+    user = builder.first_or_fail()
+
+    assert user.id
+    assert user.gid
+    assert not user.name
+    assert user.articles[0].id
+    assert user.articles[0].gid
+    assert not hasattr(user.articles[0], "title")
+
+    for user in builder.paginate(limit=1, page=1):
+        assert user.id
+        assert user.gid
+        assert not user.name
+        assert user.articles[0].id
+        assert user.articles[0].gid
+        assert not hasattr(user.articles[0], "title")
+
+    for user in builder.collect():
+        assert user.id
+        assert user.gid
+        assert not user.name
+        assert user.articles[0].id
+        assert user.articles[0].gid
+        assert not hasattr(user.articles[0], "title")
+
+
+def test_count_with_join():
+    _setup_data()
+
+    # 0. count via select:
+    row = User.select(User.id, User.gid, Article.id, Article.gid).where(id=4).join("articles").first_or_fail()
+    assert len(row.articles) == 2
+
+    assert User.where(id=4).join("articles").count(User.id) == 1
+    assert User.where(id=4).join("articles").count(Article.id) == 2