TypeDAL 3.8.1__tar.gz → 3.8.2__tar.gz

{typedal-3.8.1 → typedal-3.8.2}/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 <!--next-version-placeholder-->
 
+## v3.8.2 (2024-10-23)
+
+
+
 ## v3.8.1 (2024-10-22)
 
 ### Fix

{typedal-3.8.1 → typedal-3.8.2}/PKG-INFO

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

{typedal-3.8.1 → typedal-3.8.2}/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.1"
+__version__ = "3.8.2"

{typedal-3.8.1 → typedal-3.8.2}/src/typedal/core.py

@@ -279,9 +279,10 @@ def relationship(_type: To_Type, condition: Condition = None, join: JOIN_OPTIONS
     )
 
 
-def _generate_relationship_condition(
-    _: Type["TypedTable"], key: str, field: typing.Union["TypedField[Any]", "Table", Type["TypedTable"]]
-) -> Condition:
+T_Field: typing.TypeAlias = typing.Union["TypedField[Any]", "Table", Type["TypedTable"]]
+
+
+def _generate_relationship_condition(_: Type["TypedTable"], key: str, field: T_Field) -> Condition:
     origin = typing.get_origin(field)
     # else: generic
 
@@ -299,7 +300,7 @@ def _generate_relationship_condition(
 def to_relationship(
     cls: Type["TypedTable"] | type[Any],
     key: str,
-    field: typing.Union["TypedField[Any]", "Table", Type["TypedTable"]],
+    field: T_Field,
 ) -> typing.Optional[Relationship[Any]]:
     """
     Used to automatically create relationship instance for reference fields.
@@ -317,9 +318,14 @@ def to_relationship(
     Also works for list:reference (list[OtherTable]) and TypedField[OtherTable].
     """
     if looks_like(field, TypedField):
+        # typing.get_args works for list[str] but not for TypedField[role] :(
         if args := typing.get_args(field):
+            # TypedField[SomeType] -> SomeType
             field = args[0]
-        else:
+        elif hasattr(field, "_type"):
+            # TypedField(SomeType) -> SomeType
+            field = typing.cast(T_Field, field._type)
+        else:  # pragma: no cover
             # weird
             return None
 
@@ -543,13 +549,16 @@ class TypeDAL(pydal.DAL):  # type: ignore
         ]
 
         # add implicit relationships:
-        # User; list[User]; TypedField[User]; TypedField[list[User]]
+        # User; list[User]; TypedField[User]; TypedField[list[User]]; TypedField(User); TypedField(list[User])
         relationships |= {
             k: new_relationship
             for k in reference_field_keys
             if k not in relationships and (new_relationship := to_relationship(cls, k, annotations[k]))
         }
 
+        # fixme: list[Reference] is recognized as relationship,
+        #        TypedField(list[Reference]) is NOT recognized!!!
+
         cache_dependency = self._config.caching and kwargs.pop("cache_dependency", True)
 
         table: Table = self.define_table(tablename, *fields.values(), **kwargs)

{typedal-3.8.1 → typedal-3.8.2}/src/typedal/for_web2py.py

@@ -10,6 +10,8 @@ from .core import TypeDAL, TypedField, TypedTable
 from .fields import TextField
 from .web2py_py4web_shared import AuthUser
 
+DAL = TypeDAL  # export as DAL for compatibility with py4web
+
 
 class AuthGroup(TypedTable):
     """

{typedal-3.8.1 → typedal-3.8.2}/src/typedal/mixins.py

@@ -36,6 +36,14 @@ class Mixin(_TypedTable):
         ('inconsistent method resolution' or 'metaclass conflicts')
     """
 
+    __settings__: typing.ClassVar[dict[str, Any]]
+
+    def __init_subclass__(cls, **kwargs: Any):
+        """
+        Ensures __settings__ exists for other mixins.
+        """
+        cls.__settings__ = getattr(cls, "__settings__", None) or {}
+
 
 class TimestampsMixin(Mixin):
     """
@@ -102,12 +110,16 @@ class SlugMixin(Mixin):
         },
     )  # set via init subclass
 
-    def __init_subclass__(cls, slug_field: str = None, slug_suffix_length: int = 0, **kw: Any) -> None:
+    def __init_subclass__(
+        cls, slug_field: str = None, slug_suffix_length: int = 0, slug_suffix: Optional[int] = None, **kw: Any
+    ) -> None:
         """
         Bind 'slug field' option to be used later (on_define).
 
         You can control the length of the random suffix with the `slug_suffix_length` option (0 is no suffix).
         """
+        super().__init_subclass__(**kw)
+
         # unfortunately, PyCharm and mypy do not recognize/autocomplete/typecheck init subclass (keyword) arguments.
         if slug_field is None:
             raise ValueError(
@@ -115,7 +127,7 @@ class SlugMixin(Mixin):
                 "e.g. `class MyClass(TypedTable, SlugMixin, slug_field='title'): ...`"
             )
 
-        if "slug_suffix" in kw:
+        if slug_suffix:
             warnings.warn(
                 "The 'slug_suffix' option is deprecated, use 'slug_suffix_length' instead.",
                 DeprecationWarning,
@@ -123,10 +135,9 @@ class SlugMixin(Mixin):
 
         slug_suffix = slug_suffix_length or kw.get("slug_suffix", 0)
 
-        cls.__settings__ = {
-            "slug_field": slug_field,
-            "slug_suffix": slug_suffix,
-        }
+        # append settings:
+        cls.__settings__["slug_field"] = slug_field
+        cls.__settings__["slug_suffix"] = slug_suffix
 
     @classmethod
     def __on_define__(cls, db: TypeDAL) -> None:

{typedal-3.8.1 → typedal-3.8.2}/tests/test_config.py

@@ -1,24 +1,25 @@
+import datetime as dt
 import os
 import shutil
 import tempfile
-from pathlib import Path
-import datetime as dt
 import uuid
+from pathlib import Path
 
-from pydal2sql import generate_sql
 import pytest
+
 # from contextlib import chdir
 from contextlib_chdir import chdir
+from pydal2sql import generate_sql
 from testcontainers.postgres import PostgresContainer
 
-from src.typedal import TypeDAL, TypedTable, TypedField
+from src.typedal import TypeDAL, TypedField, TypedTable
 from src.typedal.config import (
     _load_dotenv,
     _load_toml,
     expand_env_vars_into_toml_values,
     load_config,
 )
-from src.typedal.fields import TimestampField, PointField, UUIDField
+from src.typedal.fields import PointField, TimestampField, UUIDField
 
 postgres = PostgresContainer(
     dbname="postgres",
@@ -58,10 +59,12 @@ def test_load_toml(at_temp_dir):
     base = Path("pyproject.toml")
     base.write_text("# empty")
 
-    assert _load_toml(False) == ("", {})
-    assert _load_toml(None) == (str(base.resolve().absolute()), {})
-    assert _load_toml(str(base)) == ("pyproject.toml", {})
-    assert _load_toml(".") == (str(base.resolve().absolute()), {})
+    with pytest.warns(UserWarning):
+        # it should warn because the toml is empty
+        assert _load_toml(False) == ("", {})
+        assert _load_toml(None) == (str(base.resolve().absolute()), {})
+        assert _load_toml(str(base)) == ("pyproject.toml", {})
+        assert _load_toml(".") == (str(base.resolve().absolute()), {})
 
 
 def test_load_dotenv(at_temp_dir):
@@ -160,6 +163,7 @@ def test_expand_env_vars():
 
 # note: these are not really 'config' specific but we already have access to postgres here so good enough:
 
+
 def test_timestamp_fields_sqlite(at_temp_dir):
     db = TypeDAL("sqlite:memory")
 

{typedal-3.8.1 → typedal-3.8.2}/tests/test_helpers.py

@@ -11,6 +11,9 @@ from src.typedal.helpers import (
     all_annotations,
     as_lambda,
     extract_type_optional,
+    get_db,
+    get_field,
+    get_table,
     instanciate,
     is_union,
     looks_like,
@@ -18,7 +21,7 @@ from src.typedal.helpers import (
     mktable,
     origin_is_subclass,
     to_snake,
-    unwrap_type, get_db, get_table, get_field,
+    unwrap_type,
 )
 from typedal import TypeDAL, TypedTable
 from typedal.types import Field
@@ -202,7 +205,5 @@ def test_get_functions():
     assert isinstance(table, pydal.objects.Table)
     assert not isinstance(table, TypedTable)
     field = get_field(TestGetFunctions.string)
-    print(
-        type(field)
-    )
+    print(type(field))
     assert isinstance(field, Field)

{typedal-3.8.1 → typedal-3.8.2}/tests/test_mixins.py

@@ -1,11 +1,13 @@
 import time
+import uuid
 from datetime import datetime
 from typing import Optional
 
 import pytest
 
 from src.typedal import TypeDAL, TypedTable
-from src.typedal.mixins import SlugMixin, TimestampsMixin
+from src.typedal.fields import StringField, TypedField, UUIDField
+from src.typedal.mixins import Mixin, SlugMixin, TimestampsMixin
 
 
 class AllMixins(TypedTable, SlugMixin, TimestampsMixin, slug_field="name"):
@@ -93,3 +95,35 @@ def test_reusing(db):
 
     assert str(TableWithTimestamps.created_at) == "table_with_timestamps.created_at"
     assert str(TableWithTimestamps.unrelated) == "table_with_timestamps.unrelated"
+
+
+def test_combining_mixins():
+    class FirstMixin(Mixin):
+        def __init_subclass__(cls, first: str, **kw):
+            super().__init_subclass__(**kw)
+
+            cls.__settings__["first"] = first
+
+        @classmethod
+        def one(cls):
+            return cls.__settings__["first"] == "first" and cls.__settings__["second"] == "second"
+
+    class SecondMixin(Mixin):
+        def __init_subclass__(cls, second: str, **kw):
+            super().__init_subclass__(**kw)
+
+            cls.__settings__["second"] = second
+
+        @classmethod
+        def two(cls):
+            return cls.__settings__["first"] == "first" and cls.__settings__["second"] == "second"
+
+    class Combined(TypedTable, FirstMixin, SecondMixin, first="first", second="second"): ...
+
+    assert Combined.one()
+    assert Combined.two()
+
+    class CombinedDifferentOrder(TypedTable, SecondMixin, FirstMixin, first="first", second="second"): ...
+
+    assert CombinedDifferentOrder.one()
+    assert CombinedDifferentOrder.two()

{typedal-3.8.1 → typedal-3.8.2}/tests/test_relationships.py

@@ -45,6 +45,8 @@ class User(TypedTable, TaggableMixin):
     gid = TypedField(str, default=uuid4)
     name: str
     roles: TypedField[list[Role]]
+    main_role = TypedField(Role)
+    extra_roles = TypedField(list[Role])
 
     # relationships:
     articles = relationship(list["Article"], lambda self, other: other.author == self.id)
@@ -102,9 +104,9 @@ def _setup_data():
 
     reader, writer, editor = User.bulk_insert(
         [
-            {"name": "Reader 1", "roles": [reader]},
-            {"name": "Writer 1", "roles": [reader, writer]},
-            {"name": "Editor 1", "roles": [reader, writer, editor]},
+            {"name": "Reader 1", "roles": [reader], "main_role": reader, "extra_roles": []},
+            {"name": "Writer 1", "roles": [reader, writer], "main_role": writer, "extra_roles": []},
+            {"name": "Editor 1", "roles": [reader, writer, editor], "main_role": editor, "extra_roles": []},
         ]
     )
 
@@ -333,9 +335,22 @@ class CacheTwoRelationships(TypedTable):
     second: NoCacheSecond
 
 
-def test_caching():
-    _setup_data()
+def test_relationship_detection():
+    user_table_relationships = User.get_relationships()
+
+    assert user_table_relationships["roles"]
+    assert user_table_relationships["main_role"]
+    assert user_table_relationships["extra_roles"]
+    assert user_table_relationships["articles"]
+    assert user_table_relationships["bestie"]
+    assert user_table_relationships["tags"]
 
+    assert user_table_relationships["roles"].join == "left"
+    assert user_table_relationships["main_role"].join == "inner"
+    assert user_table_relationships["extra_roles"].join == "left"
+
+
+def test_caching():
     uncached = User.join().collect_or_fail()
     cached = User.cache().join().collect_or_fail()  # not actually cached yet!
     cached_user_only = User.join().cache(User.id).collect_or_fail()  # idem