fastapi-rtk 2.12.4__tar.gz → 2.13.0__tar.gz

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-rtk
-Version: 2.12.4
+Version: 2.13.0
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.13.0/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.13.0"

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.0}/fastapi_rtk/backends/generic/column.py

@@ -1,4 +1,5 @@
 import collections.abc
+import copy
 import inspect
 import typing
 
@@ -6,7 +7,11 @@ import pydantic
 
 from ...mixins import LoggerMixin
 from ...utils import T
-from .exceptions import ColumnInvalidTypeException, GenericColumnException
+from .exceptions import (
+    ColumnInvalidTypeException,
+    ColumnNotSetException,
+    GenericColumnException,
+)
 
 if typing.TYPE_CHECKING:
     from .model import GenericModel
@@ -45,7 +50,7 @@ class GenericColumn(typing.Generic[T], LoggerMixin):
         auto_increment (bool, optional): Whether the column is auto incremented. Only works if the column is a primary key. Defaults to False.
         unique (bool, optional): Whether the column is unique. Defaults to False.
         nullable (bool, optional): Whether the column is nullable. Defaults to True.
-        default (T | collections.abc.Callable[[], T] | collections.abc.Callable[[GenericModel], T] | NoDefault, optional): The default value of the column. Will be used if the column is not set by the user. Defaults to NoDefault (no default value).
+        default (T | collections.abc.Callable[[], T] | collections.abc.Callable[[GenericModel], T] | NoDefault, optional): The default value of the column. Will be used if the column is not set by the user. It is resolved once, when the model is initialized: a callable taking no argument is called, and a mutable value is copied. Defaults to NoDefault (no default value).
     """
 
     col_type: type[T]
@@ -78,7 +83,7 @@ class GenericColumn(typing.Generic[T], LoggerMixin):
             auto_increment (bool, optional): Whether the column is auto incremented. Only works if the column is a primary key. Defaults to False.
             unique (bool, optional): Whether the column is unique. Defaults to False.
             nullable (bool, optional): Whether the column is nullable. Defaults to True.
-            default (T | collections.abc.Callable[[], T] | collections.abc.Callable[["GenericModel"], T] | _NoDefaultValue, optional): The default value of the column. Will be used if the column is not set by the user. Defaults to UNSET (no default value).
+            default (T | collections.abc.Callable[[], T] | collections.abc.Callable[["GenericModel"], T] | _NoDefaultValue, optional): The default value of the column. Will be used if the column is not set by the user. It is resolved once, when the model is initialized: a callable taking no argument is called, and a mutable value is copied. Defaults to UNSET (no default value).
 
         Raises:
             GenericColumnException: If auto increment is set on a non-primary key column or if the column type is not int when auto increment is set.
@@ -95,10 +100,8 @@ class GenericColumn(typing.Generic[T], LoggerMixin):
             self.unique = True
             self.nullable = False
 
-        if inspect.isfunction(self.default):
-            # If the function takes no parameters, convert it to a function that needs the instance
-            if inspect.signature(self.default).parameters == {}:
-                self.default = lambda instance, func=self.default: func()
+        if self.default is not UNSET:
+            self.default = self._normalize_default(self.default)
 
         if not self.primary_key and self.auto_increment:
             raise GenericColumnException(
@@ -125,22 +128,30 @@ class GenericColumn(typing.Generic[T], LoggerMixin):
         instance: "GenericModel | None",
         owner: type["GenericModel"],
     ):
+        """
+        Read the column value of the instance, or the descriptor itself when read on the class.
+
+        Args:
+            instance (GenericModel | None): The instance to read from, or None when read on the class.
+            owner (type[GenericModel]): The model class owning the column.
+
+        Raises:
+            ColumnNotSetException: If a column that is neither nullable nor an auto incrementing primary key was never set.
+
+        Returns:
+            GenericColumn | T | None: The descriptor on class access, else the value, None for an unset nullable column, or PK_AUTO_INCREMENT for an unset auto incrementing primary key.
+        """
         if not instance:
             return self
 
-        default_value = self.default
-        if callable(default_value):
-            default_value = default_value(instance)
-
-        value: T | GenericUnset = instance.__dict__.get(
-            f"_{self._col_name}", default_value
-        )
+        value: T | GenericUnset = instance.__dict__.get(f"_{self._col_name}", UNSET)
 
-        if value is default_value:
-            if self.nullable and value is UNSET:
+        if value is UNSET:
+            if self.nullable:
                 return None
-            elif self.primary_key and self.auto_increment:
+            if self.primary_key and self.auto_increment:
                 return PK_AUTO_INCREMENT
+            raise ColumnNotSetException(instance, f"Column {self._col_name} is not set")
 
         return value
 
@@ -161,7 +172,8 @@ class GenericColumn(typing.Generic[T], LoggerMixin):
         if self.nullable:
             validation_type = validation_type | None
         if self.default is not UNSET:
-            validation_type = validation_type | type(self.default)
+            if not callable(self.default):
+                validation_type = validation_type | type(self.default)
             validation_field = pydantic.Field(default=self.default)
         else:
             validation_field = pydantic.Field
@@ -194,3 +206,60 @@ class GenericColumn(typing.Generic[T], LoggerMixin):
             f"_{self._col_name}" in instance.__dict__
             and getattr(instance, f"_{self._col_name}") is not UNSET
         )
+
+    def apply_default(self, instance: "GenericModel") -> None:
+        """
+        Write the column default into the instance, leaving an already set column untouched.
+
+        A default resolving to a sentinel is skipped, so a default reading a not yet assigned primary key leaves the column unset.
+
+        Args:
+            instance (GenericModel): The instance to write the default into.
+        """
+        if self.default is UNSET or self.is_column_set(instance):
+            return
+
+        value = self.default(instance) if callable(self.default) else self.default
+        if isinstance(value, (GenericUnset, GenericPKAutoIncrement)):
+            return
+
+        instance.__dict__[f"_{self._col_name}"] = value
+
+    def _normalize_default(
+        self,
+        default: T | collections.abc.Callable[..., T],
+    ) -> T | collections.abc.Callable[["GenericModel"], T]:
+        """
+        Normalize a column default into either a plain value or a callable taking the model instance.
+
+        A mutable value becomes a copying callable, so one instance cannot mutate the default of every other instance.
+
+        Args:
+            default (T | collections.abc.Callable[..., T]): The default given to the column.
+
+        Returns:
+            T | collections.abc.Callable[[GenericModel], T]: The value itself, or a callable taking the instance.
+        """
+        if not callable(default):
+            if isinstance(default, collections.abc.Hashable):
+                return default
+            return lambda instance, value=default: copy.deepcopy(value)
+
+        try:
+            parameters = inspect.signature(default).parameters.values()
+        except (TypeError, ValueError):
+            # A builtin without an introspectable signature (dict, str, ...) can only be a zero argument factory.
+            return lambda instance, func=default: func()
+
+        if any(
+            parameter.default is inspect.Parameter.empty
+            and parameter.kind
+            in (
+                inspect.Parameter.POSITIONAL_ONLY,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            )
+            for parameter in parameters
+        ):
+            return default
+
+        return lambda instance, func=default: func()

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.0}/fastapi_rtk/backends/generic/model.py

@@ -117,15 +117,20 @@ class GenericModel(BasicModel):
         """
         Initialize the model with the given keyword arguments.
 
+        A column without a given value takes its default, like a dataclass mapped SQLAlchemy model does.
+
         Args:
             __check_on_init__ (bool, optional): Whether to check the model's validity on initialization. Defaults to True.
         """
-        if not kwargs:
-            return
         for key, value in kwargs.items():
             if key not in self.__mapper__.properties.keys():
                 continue
             setattr(self, key, value)
+
+        # After the given values, so a default reading another column sees it.
+        for column in self.__mapper__.properties.values():
+            column.apply_default(self)
+
         if __check_on_init__:
             self.is_model_valid()
 
@@ -166,8 +171,10 @@ class GenericModel(BasicModel):
         """
         errors: list[Exception] = []
         for key in self.__mapper__.properties.keys():
-            if getattr(self, key) is UNSET:
-                errors.append(ColumnNotSetException(self, f"Column {key} is not set"))
+            try:
+                getattr(self, key)
+            except ColumnNotSetException as e:
+                errors.append(e)
 
         if errors:
             # Rollback to last valid state
@@ -186,4 +193,10 @@ class GenericModel(BasicModel):
         return [cls.__mapper__.pk]
 
     def __repr__(self):
-        return f"{self.__class__.__name__}({';'.join([f'{col}={getattr(self, col)}' for col in self.__mapper__.properties.keys()])})"
+        values = []
+        for col in self.__mapper__.properties.keys():
+            try:
+                values.append(f"{col}={getattr(self, col)}")
+            except ColumnNotSetException:
+                values.append(f"{col}={UNSET}")
+        return f"{self.__class__.__name__}({';'.join(values)})"

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.0}/tests/unit/backends/generic/test_column.py

@@ -1,4 +1,7 @@
+import datetime
+
 import pytest
+
 from fastapi_rtk.backends.generic.column import (
     PK_AUTO_INCREMENT,
     UNSET,
@@ -8,6 +11,7 @@ from fastapi_rtk.backends.generic.column import (
 )
 from fastapi_rtk.backends.generic.exceptions import (
     ColumnInvalidTypeException,
+    ColumnNotSetException,
     GenericColumnException,
 )
 from fastapi_rtk.backends.generic.model import GenericModel
@@ -54,6 +58,28 @@ class TestColumnInit:
         col = GenericColumn(int, default=with_instance)
         assert col.default is with_instance
 
+    def test_default_hashable_value_kept_as_is(self):
+        col = GenericColumn(int, default=99)
+        assert col.default == 99
+
+    def test_default_builtin_with_optional_arg_wrapped(self):
+        col = GenericColumn(list, default=list)
+        assert col.default(None) == []
+
+    def test_default_builtin_without_signature_wrapped(self):
+        col = GenericColumn(dict, default=dict)
+        assert col.default(None) == {}
+
+    def test_default_builtin_method_wrapped(self):
+        col = GenericColumn(datetime.datetime, default=datetime.datetime.now)
+        assert isinstance(col.default(None), datetime.datetime)
+
+    def test_default_mutable_value_wrapped(self):
+        col = GenericColumn(list, default=[])
+        first = col.default(None)
+        assert first == []
+        assert first is not col.default(None)
+
 
 class TestColumnDescriptorAccess:
     def _make_model(self, **column_kwargs):
@@ -94,6 +120,12 @@ class TestColumnDescriptorAccess:
         m.x = 7
         assert m.x == 7
 
+    def test_get_unset_not_nullable_raises(self):
+        M = self._make_model(nullable=False)
+        m = M(__check_on_init__=False)
+        with pytest.raises(ColumnNotSetException, match="is not set"):
+            m.x
+
     def test_pk_auto_increment_returns_sentinel_when_not_set(self):
         M = self._make_model()
         m = M(__check_on_init__=False)
@@ -101,6 +133,40 @@ class TestColumnDescriptorAccess:
         assert m.id is PK_AUTO_INCREMENT
 
 
+class TestMutableDefault:
+    def _make_model(self, **column_kwargs):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            x = GenericColumn(list, **column_kwargs)
+
+        return M
+
+    def test_mutation_does_not_leak_between_instances(self):
+        M = self._make_model(default=[])
+        first = M(__check_on_init__=False)
+        second = M(__check_on_init__=False)
+        first.x.append("leak")
+        assert second.x == []
+
+    def test_nested_mutation_does_not_leak_between_instances(self):
+        M = self._make_model(default=[[]])
+        first = M(__check_on_init__=False)
+        second = M(__check_on_init__=False)
+        first.x[0].append("leak")
+        assert second.x == [[]]
+
+    def test_builtin_factory_default_is_read(self):
+        M = self._make_model(default=list)
+        m = M(__check_on_init__=False)
+        assert m.x == []
+
+    def test_callable_default_rejected_as_value(self):
+        M = self._make_model(default=[])
+        m = M(__check_on_init__=False)
+        with pytest.raises(ColumnInvalidTypeException):
+            m.x = list
+
+
 class TestIsColumnSet:
     def test_unset_returns_false(self):
         class M(GenericModel):
@@ -120,6 +186,34 @@ class TestIsColumnSet:
         assert M.x.is_column_set(m) is True
 
 
+class TestApplyDefault:
+    def _make_model(self, **column_kwargs):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            x = GenericColumn(int, **column_kwargs)
+
+        return M
+
+    def test_no_default_writes_nothing(self):
+        M = self._make_model()
+        m = M(__check_on_init__=False)
+        M.x.apply_default(m)
+        assert M.x.is_column_set(m) is False
+
+    def test_set_column_is_not_overwritten(self):
+        M = self._make_model(default=99)
+        m = M(__check_on_init__=False)
+        m.x = 1
+        M.x.apply_default(m)
+        assert m.x == 1
+
+    def test_sentinel_result_is_not_written(self):
+        M = self._make_model(default=lambda instance: instance.id)
+        m = M(__check_on_init__=False)
+        M.x.apply_default(m)
+        assert M.x.is_column_set(m) is False
+
+
 class TestRepr:
     def test_repr_includes_attrs(self):
         col = GenericColumn(int, primary_key=True)

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.0}/tests/unit/backends/generic/test_model.py

@@ -1,3 +1,5 @@
+import datetime
+
 import pytest
 from fastapi_rtk.backends.generic.column import GenericColumn
 from fastapi_rtk.backends.generic.exceptions import (
@@ -73,10 +75,83 @@ class TestModelInit:
 
         return M
 
-    def test_empty_kwargs_no_validation(self):
-        M = self._model()
-        m = M()  # bypass validation entirely
-        assert m is not None
+    def test_empty_kwargs_still_validates(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True)
+            required = GenericColumn(str, nullable=False)
+
+        with pytest.raises(MultipleColumnsException):
+            M()
+
+    def test_default_applied_on_init(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            name = GenericColumn(str, nullable=False, default="anon")
+
+        m = M()
+        assert m.name == "anon"
+        assert M.name.is_column_set(m) is True
+
+    def test_default_not_applied_when_value_given(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            name = GenericColumn(str, nullable=False, default="anon")
+
+        assert M(name="given").name == "given"
+
+    def test_callable_default_frozen_on_init(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            created = GenericColumn(datetime.datetime, default=datetime.datetime.now)
+
+        m = M()
+        assert m.created == m.created
+
+    def test_mutable_default_persists_mutation_per_instance(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            tags = GenericColumn(list, default=[])
+
+        m = M()
+        m.tags.append("x")
+        assert m.tags == ["x"]
+        assert M().tags == []
+
+    def test_default_reads_column_given_in_kwargs(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            first = GenericColumn(str, nullable=False)
+            slug = GenericColumn(str, default=lambda instance: instance.first.lower())
+
+        assert M(first="Ada").slug == "ada"
+
+    def test_default_reads_column_defaulted_earlier_in_class_body(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            first = GenericColumn(str, nullable=False, default="Ada")
+            slug = GenericColumn(str, default=lambda instance: instance.first.lower())
+
+        assert M().slug == "ada"
+
+    def test_default_reading_unassigned_pk_leaves_column_unset(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            from_pk = GenericColumn(int, default=lambda instance: instance.id)
+
+        m = M()
+        assert M.from_pk.is_column_set(m) is False
+        assert m.from_pk is None
+        m.id = 5
+        assert m.from_pk is None
+
+    def test_default_is_not_reapplied_after_init(self):
+        class M(GenericModel):
+            id = GenericColumn(int, primary_key=True, auto_increment=True)
+            name = GenericColumn(str, default="anon")
+
+        m = M()
+        del m.__dict__["_name"]
+        assert m.name is None
 
     def test_kwargs_unknown_keys_skipped(self):
         M = self._model()

fastapi_rtk-2.12.4/fastapi_rtk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.12.4"