TypeDAL 3.9.3__tar.gz → 3.10.0__tar.gz

{typedal-3.9.3 → typedal-3.10.0}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v3.10.0 (2025-02-17)
+
+### Feature
+
+* Add a pydal validator to tables using the slug mixin (without a random suffix) to catch duplicates before the actual database insert (which raises a unique violation exception) ([`6466345`](https://github.com/trialandsuccess/TypeDAL/commit/64663454eab7a4f281660cb2df6e50e2dadd7740))
+
+## v3.9.4 (2024-11-10)
+
+### Fix
+
+* **p4w:** Calling `for_py4web.DAL()` without any arguments (to load from config) should work even with singleton ([`16f9e68`](https://github.com/trialandsuccess/TypeDAL/commit/16f9e681eaac2fccd06a110031c0d55261a0a7e9))
+
 ## v3.9.3 (2024-11-08)
 
 ### Fix

{typedal-3.9.3 → typedal-3.10.0}/PKG-INFO

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

{typedal-3.9.3 → typedal-3.10.0}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = 'Typing support for PyDAL'
 readme = "README.md"
 requires-python = ">=3.10"
-# license = "MIT"
+license-expression = "MIT"
 keywords = []
 authors = [
     { name = "Robin van der Noord", email = "contact@trialandsuccess.nl" },

{typedal-3.9.3 → typedal-3.10.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.9.3"
+__version__ = "3.10.0"

{typedal-3.9.3 → typedal-3.10.0}/src/typedal/for_py4web.py

@@ -24,8 +24,8 @@ class Fixture(_Fixture):  # type: ignore
 class PY4WEB_DAL_SINGLETON(MetaDAL):
     _instances: typing.ClassVar[typing.MutableMapping[str, AnyType]] = {}
 
-    def __call__(cls, uri: str, *args: typing.Any, **kwargs: typing.Any) -> AnyType:
-        db_uid = kwargs.get("db_uid", hashlib_md5(repr(uri)).hexdigest())
+    def __call__(cls, uri: typing.Optional[str] = None, *args: typing.Any, **kwargs: typing.Any) -> AnyType:
+        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.9.3 → typedal-3.10.0}/src/typedal/mixins.py

@@ -11,6 +11,8 @@ import warnings
 from datetime import datetime
 from typing import Any, Optional
 
+from pydal import DAL
+from pydal.validators import IS_NOT_IN_DB, ValidationError
 from slugify import slugify
 
 from .core import (  # noqa F401 - used by example in docstring
@@ -87,6 +89,56 @@ def slug_random_suffix(length: int = 8) -> str:
     return base64.urlsafe_b64encode(os.urandom(length)).rstrip(b"=").decode().strip("=")
 
 
+T = typing.TypeVar("T")
+
+
+# noinspection PyPep8Naming
+class HAS_UNIQUE_SLUG(IS_NOT_IN_DB):
+    """
+    Checks if slugified field is already in the db.
+
+    Usage:
+        table.name = HAS_UNIQUE_SLUG(db, "table.slug")
+    """
+
+    def __init__(
+        self,
+        db: TypeDAL | DAL,
+        field: str,  # table.slug
+        error_message: str = "This slug is not unique: %s.",
+    ):
+        """
+        Based on IS_NOT_IN_DB but with less options and a different default error message.
+        """
+        super().__init__(db, field, error_message)
+
+    def validate(self, original: T, record_id: Optional[int] = None) -> T:
+        """
+        Performs checks to see if the slug already exists for a different row.
+        """
+        value = slugify(str(original))
+        if not value.strip():
+            raise ValidationError(self.translator(self.error_message))
+
+        (tablename, fieldname) = str(self.field).split(".")
+        table = self.dbset.db[tablename]
+        field = table[fieldname]
+        query = field == value
+
+        # make sure exclude the record_id
+        row_id = record_id or self.record_id
+        if isinstance(row_id, dict):  # pragma: no cover
+            row_id = table(**row_id)
+        if row_id is not None:
+            query &= table._id != row_id
+        subset = self.dbset(query)
+
+        if subset.count():
+            raise ValidationError(self.error_message % value)
+
+        return original
+
+
 class SlugMixin(Mixin):
     """
     (Opinionated) example mixin to add a 'slug' field, which depends on a user-provided other field.
@@ -139,26 +191,40 @@ class SlugMixin(Mixin):
         cls.__settings__["slug_field"] = slug_field
         cls.__settings__["slug_suffix"] = slug_suffix
 
+    @classmethod
+    def __generate_slug_before_insert(cls, row: OpRow) -> None:
+        settings = cls.__settings__
+
+        text_input = row[settings["slug_field"]]
+        generated_slug = slugify(text_input)
+
+        if suffix_len := settings["slug_suffix"]:
+            generated_slug += f"-{slug_random_suffix(suffix_len)}"
+
+        row["slug"] = slugify(generated_slug)
+        return None
+
     @classmethod
     def __on_define__(cls, db: TypeDAL) -> None:
         """
         When db is available, include a before_insert hook to generate and include a slug.
         """
         super().__on_define__(db)
+        settings = cls.__settings__
 
         # slugs should not be editable (for SEO reasons), so there is only a before insert hook:
-        def generate_slug_before_insert(row: OpRow) -> None:
-            settings = cls.__settings__
-
-            text_input = row[settings["slug_field"]]
-            generated_slug = slugify(text_input)
+        cls._before_insert.append(cls.__generate_slug_before_insert)
 
-            if suffix_len := settings["slug_suffix"]:
-                generated_slug += f"-{slug_random_suffix(suffix_len)}"
+        if settings["slug_suffix"] == 0:
+            # add a validator to the field that will be slugified:
+            slug_field = getattr(cls, settings["slug_field"])
+            current_requires = getattr(slug_field, "requires", None) or []
+            if not isinstance(current_requires, list):
+                current_requires = [current_requires]
 
-            row["slug"] = slugify(generated_slug)
+            current_requires.append(HAS_UNIQUE_SLUG(db, f"{cls}.slug"))
 
-        cls._before_insert.append(generate_slug_before_insert)
+            slug_field.requires = current_requires
 
     @classmethod
     def from_slug(cls: typing.Type[T_MetaInstance], slug: str, join: bool = True) -> Optional[T_MetaInstance]:

{typedal-3.9.3 → typedal-3.10.0}/tests/test_mixins.py

@@ -14,7 +14,12 @@ class AllMixins(TypedTable, SlugMixin, TimestampsMixin, slug_field="name"):
     name: str
 
 
-class TableWithMixins(TypedTable, SlugMixin, slug_field="name", slug_suffix_length=1):
+class TableWithMixins(TypedTable, SlugMixin, slug_field="name", slug_suffix_length=0):
+    name: str
+    number: Optional[int]
+
+
+class TableWithSlugSuffix(TypedTable, SlugMixin, slug_field="name", slug_suffix_length=1):
     name: str
     number: Optional[int]
 
@@ -43,6 +48,7 @@ def db():
 
     _db.define(AllMixins)
     _db.define(TableWithMixins)
+    _db.define(TableWithSlugSuffix)
     _db.define(TableWithTimestamps)
     yield _db
 
@@ -57,10 +63,17 @@ def test_order(db):
 
 
 def test_slug(db):
-    row = TableWithMixins.insert(name="Two Words")
+    row, error = TableWithMixins.validate_and_insert(name="")
+    assert row is None
+    assert error
+
+    # without random suffix: duplicates are forbidden
+
+    row, error = TableWithMixins.validate_and_insert(name="Two Words")
+    assert error is None
 
     assert row.name == "Two Words"
-    assert row.slug.startswith("two-words")
+    assert row.slug == "two-words"
 
     assert TableWithMixins.from_slug(row.slug)
     assert TableWithMixins.from_slug("missing") is None
@@ -70,6 +83,26 @@ def test_slug(db):
     with pytest.raises(ValueError):
         TableWithMixins.from_slug_or_fail("missing")
 
+    row, error = TableWithMixins.validate_and_insert(name="Two Words")
+    assert row is None
+    assert error == {
+        'name': 'This slug is not unique: two-words.',
+    }
+
+    # with random suffix: duplicates are fine
+
+    row, error = TableWithSlugSuffix.validate_and_insert(name="Two Words")
+    assert error is None
+
+    assert row.name == "Two Words"
+    assert row.slug.startswith("two-words")
+
+    row, error = TableWithSlugSuffix.validate_and_insert(name="Two Words")
+    assert error is None
+
+    assert row.name == "Two Words"
+    assert row.slug.startswith("two-words")
+
 
 def test_timestamps(db):
     row = TableWithTimestamps.insert(unrelated="Hi")

{typedal-3.9.3 → typedal-3.10.0}/tests/test_py4web.py

@@ -1,12 +1,13 @@
 import json
 import tempfile
-from contextlib import chdir
+from contextlib_chdir import chdir
 
 from pydal.validators import IS_EMAIL, IS_NOT_IN_DB
 
 from src.typedal import TypedTable
 from src.typedal.for_py4web import DAL, AuthUser, setup_py4web_tables
 from src.typedal.serializers import as_json
+from typedal.config import TypeDALConfig
 
 db = DAL("sqlite:memory")
 
@@ -59,6 +60,15 @@ def test_py4web_dal_singleton():
             db_2a = DAL("sqlite://test_py4web_dal_singleton", folder=d, enable_typedal_caching=False)
             db_2b = DAL("sqlite://test_py4web_dal_singleton", folder=d, enable_typedal_caching=False)
 
+            conf = {
+                "database": "sqlite:memory",
+                "dialect": "sqlite",
+                "pyproject": "",
+                "flag_location": f"{d}/flags"
+            }
+            db_3a = DAL(config=TypeDALConfig.load(conf))
+            db_3b = DAL(config=TypeDALConfig.load(conf))
+
             assert db_1a is db_1b
             assert db_1a._uri == db_1b._uri
             assert db_1a._db_uid == db_1b._db_uid
@@ -74,6 +84,14 @@ def test_py4web_dal_singleton():
             assert db_1b is not db_2b
             assert db_1b._uri != db_2b._uri
             assert db_1b._db_uid != db_2b._db_uid
-            
+
+            assert db_3a is db_3b
+            assert db_3a is not db_1a
+            assert db_3a is not db_2a
+
+            assert db_1a._uri == db_1b._uri
+            assert db_3a._uri == db_1a._uri
+            assert db_3a._uri != db_2a._uri
+
     # reset singletons for later use:
     DAL._clear()