TypeDAL 3.12.2__tar.gz → 3.13.0__tar.gz

{typedal-3.12.2 → typedal-3.13.0}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!--next-version-placeholder-->
 
+## v3.13.0 (2025-04-28)
+
+### Feature
+
+* Adding `_once` hooks ([`a69fbb3`](https://github.com/trialandsuccess/TypeDAL/commit/a69fbb361cdfec9352fca503206299c5bbb940d2))
+
 ## v3.12.2 (2025-04-25)
 
 ### Fix

{typedal-3.12.2 → typedal-3.13.0}/PKG-INFO

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

{typedal-3.12.2 → typedal-3.13.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.12.2"
+__version__ = "3.13.0"

{typedal-3.12.2 → typedal-3.13.0}/src/typedal/core.py

@@ -5,6 +5,7 @@ Core functionality of TypeDAL.
 import contextlib
 import csv
 import datetime as dt
+import functools
 import inspect
 import json
 import math
@@ -33,6 +34,7 @@ from .helpers import (
     all_annotations,
     all_dict,
     as_lambda,
+    classproperty,
     extract_type_optional,
     filter_out,
     instanciate,
@@ -796,6 +798,10 @@ class TypeDAL(pydal.DAL):  # type: ignore
         return to_snake(camel)
 
 
+P = typing.ParamSpec("P")
+R = typing.TypeVar("R")
+
+
 class TableMeta(type):
     """
     This metaclass contains functionality on table classes, that doesn't exist on its instances.
@@ -1196,6 +1202,19 @@ class TableMeta(type):
         return self.with_alias(key)
 
     # hooks:
+    def _hook_once(
+        cls: Type[T_MetaInstance], hooks: list[typing.Callable[P, R]], fn: typing.Callable[P, R]
+    ) -> Type[T_MetaInstance]:
+        @functools.wraps(fn)
+        def wraps(*a: P.args, **kw: P.kwargs) -> R:
+            try:
+                return fn(*a, **kw)
+            finally:
+                hooks.remove(wraps)
+
+        hooks.append(wraps)
+        return cls
+
     def before_insert(
         cls: Type[T_MetaInstance],
         fn: typing.Callable[[T_MetaInstance], Optional[bool]] | typing.Callable[[OpRow], Optional[bool]],
@@ -1207,6 +1226,15 @@ class TableMeta(type):
             cls._before_insert.append(fn)
         return cls
 
+    def before_insert_once(
+        cls: Type[T_MetaInstance],
+        fn: typing.Callable[[T_MetaInstance], Optional[bool]] | typing.Callable[[OpRow], Optional[bool]],
+    ) -> Type[T_MetaInstance]:
+        """
+        Add a before insert hook that only fires once and then removes itself.
+        """
+        return cls._hook_once(cls._before_insert, fn)  # type: ignore
+
     def after_insert(
         cls: Type[T_MetaInstance],
         fn: (
@@ -1221,6 +1249,18 @@ class TableMeta(type):
             cls._after_insert.append(fn)
         return cls
 
+    def after_insert_once(
+        cls: Type[T_MetaInstance],
+        fn: (
+            typing.Callable[[T_MetaInstance, Reference], Optional[bool]]
+            | typing.Callable[[OpRow, Reference], Optional[bool]]
+        ),
+    ) -> Type[T_MetaInstance]:
+        """
+        Add an after insert hook that only fires once and then removes itself.
+        """
+        return cls._hook_once(cls._after_insert, fn)  # type: ignore
+
     def before_update(
         cls: Type[T_MetaInstance],
         fn: typing.Callable[[Set, T_MetaInstance], Optional[bool]] | typing.Callable[[Set, OpRow], Optional[bool]],
@@ -1232,6 +1272,15 @@ class TableMeta(type):
             cls._before_update.append(fn)
         return cls
 
+    def before_update_once(
+        cls,
+        fn: typing.Callable[[Set, T_MetaInstance], Optional[bool]] | typing.Callable[[Set, OpRow], Optional[bool]],
+    ) -> Type[T_MetaInstance]:
+        """
+        Add a before update hook that only fires once and then removes itself.
+        """
+        return cls._hook_once(cls._before_update, fn)  # type: ignore
+
     def after_update(
         cls: Type[T_MetaInstance],
         fn: typing.Callable[[Set, T_MetaInstance], Optional[bool]] | typing.Callable[[Set, OpRow], Optional[bool]],
@@ -1243,6 +1292,15 @@ class TableMeta(type):
             cls._after_update.append(fn)
         return cls
 
+    def after_update_once(
+        cls: Type[T_MetaInstance],
+        fn: typing.Callable[[Set, T_MetaInstance], Optional[bool]] | typing.Callable[[Set, OpRow], Optional[bool]],
+    ) -> Type[T_MetaInstance]:
+        """
+        Add an after update hook that only fires once and then removes itself.
+        """
+        return cls._hook_once(cls._after_update, fn)  # type: ignore
+
     def before_delete(cls: Type[T_MetaInstance], fn: typing.Callable[[Set], Optional[bool]]) -> Type[T_MetaInstance]:
         """
         Add a before delete hook.
@@ -1251,6 +1309,15 @@ class TableMeta(type):
             cls._before_delete.append(fn)
         return cls
 
+    def before_delete_once(
+        cls: Type[T_MetaInstance],
+        fn: typing.Callable[[Set], Optional[bool]],
+    ) -> Type[T_MetaInstance]:
+        """
+        Add a before delete hook that only fires once and then removes itself.
+        """
+        return cls._hook_once(cls._before_delete, fn)
+
     def after_delete(cls: Type[T_MetaInstance], fn: typing.Callable[[Set], Optional[bool]]) -> Type[T_MetaInstance]:
         """
         Add an after delete hook.
@@ -1259,6 +1326,15 @@ class TableMeta(type):
             cls._after_delete.append(fn)
         return cls
 
+    def after_delete_once(
+        cls: Type[T_MetaInstance],
+        fn: typing.Callable[[Set], Optional[bool]],
+    ) -> Type[T_MetaInstance]:
+        """
+        Add an after delete hook that only fires once and then removes itself.
+        """
+        return cls._hook_once(cls._after_delete, fn)
+
 
 class TypedField(Expression, typing.Generic[T_Value]):  # pragma: no cover
     """
@@ -1482,6 +1558,17 @@ class _TypedTable:
         where you need a reference to the current database, which may not exist yet when defining the model.
         """
 
+    @classproperty
+    def _hooks(cls) -> dict[str, list[typing.Callable[..., Optional[bool]]]]:
+        return {
+            "before_insert": cls._before_insert,
+            "after_insert": cls._after_insert,
+            "before_update": cls._before_update,
+            "after_update": cls._after_update,
+            "before_delete": cls._before_delete,
+            "after_delete": cls._after_delete,
+        }
+
 
 class TypedTable(_TypedTable, metaclass=TableMeta):
     """

{typedal-3.12.2 → typedal-3.13.0}/src/typedal/helpers.py

@@ -303,3 +303,27 @@ def get_field(field: "TypedField[typing.Any] | Field") -> "Field":
         "Field",
         field,  # Table.field already is a Field, but cast to make sure the editor knows this too.
     )
+
+
+class classproperty:
+    def __init__(self, fget: typing.Callable[..., typing.Any]) -> None:
+        """
+        Initialize the classproperty.
+
+        Args:
+            fget: A function that takes the class as an argument and returns a value.
+        """
+        self.fget = fget
+
+    def __get__(self, obj: typing.Any, owner: typing.Type[T]) -> typing.Any:
+        """
+        Retrieve the property value.
+
+        Args:
+            obj: The instance of the class (unused).
+            owner: The class that owns the property.
+
+        Returns:
+            The value returned by the function.
+        """
+        return self.fget(owner)

{typedal-3.12.2 → typedal-3.13.0}/tests/test_main.py

@@ -510,10 +510,49 @@ def test_hooks_duplicates():
     HookedTableV3.after_insert(increase_counter_v2)  # other hash
 
     HookedTableV3.insert(name="Should increase counter twice")
+    assert counter == 3
+
+    for hook in HookedTableV3._hooks.values():
+        hook.clear()
 
+    HookedTableV3.insert(name="Should NOT increase counter")
     assert counter == 3
 
 
+def test_hooks_once():
+    @db.define()
+    class HookedTableV4(TypedTable):
+        name: str
+
+    counter = 0
+
+    def increase_counter_v2(_, __=None):
+        nonlocal counter
+        counter += 1
+
+    HookedTableV4.before_insert_once(increase_counter_v2)
+    HookedTableV4.after_insert_once(increase_counter_v2)
+    HookedTableV4.before_update_once(increase_counter_v2)
+    HookedTableV4.after_update_once(increase_counter_v2)
+    HookedTableV4.before_delete_once(increase_counter_v2)
+    HookedTableV4.after_delete_once(increase_counter_v2)
+
+    assert counter == 0
+
+    HookedTableV4.insert(name="1")
+    assert counter == 2
+    row = HookedTableV4.insert(name="2")
+    assert counter == 2
+
+    row.update_record(name="3")
+    assert counter == 4
+    row.update_record(name="4")
+    assert counter == 4
+
+    row.delete_record()
+    assert counter == 6
+
+
 def test_try():
     class SomeTableToRetry(TypedTable):
         key: int