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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-rtk
-Version: 2.12.4
+Version: 2.13.1
 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.1/fastapi_rtk/_version.py

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

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.1}/fastapi_rtk/api/model_rest_api/_add_mixin.py

@@ -83,6 +83,13 @@ class AddMixin(_TypedModelRestApi):
                 after_commit_runner.remove_tasks_by_tag(
                     "file"
                 )  # Delete any file tasks scheduled to revert files on error
+            pk, _ = self.datamodel.convert_to_result(item)
+            # Re-read without base filters: a row the caller may not list is still the row it just wrote.
+            item = await smart_run(
+                self.datamodel.get_one,
+                session,
+                params={"list_columns": self.show_select_columns, "where_id": pk},
+            )
             post_add = await smart_run(
                 self.post_add,
                 item,

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.1}/fastapi_rtk/api/model_rest_api/_edit_mixin.py

@@ -108,6 +108,13 @@ class EditMixin(_TypedModelRestApi):
                 after_commit_runner.remove_tasks_by_tag(
                     "file"
                 )  # Delete any file tasks scheduled to revert files on error
+            pk, _ = self.datamodel.convert_to_result(item)
+            # Re-read without base filters: a row the caller may not list is still the row it just wrote.
+            item = await smart_run(
+                self.datamodel.get_one,
+                session,
+                params={"list_columns": self.show_select_columns, "where_id": pk},
+            )
             post_update = await smart_run(
                 self.post_update,
                 item,

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.1}/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.1}/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.13.1/tests/integration/api/test_add_edit_relation_response.py

@@ -0,0 +1,250 @@
+"""Regression tests for relation loading in the add / edit responses.
+
+Both responses serialize `show_select_columns`, which includes relationships
+that neither `SQLAInterface.add` nor `.edit` leaves loaded, so the routes
+re-read the item through `ModelRestApi._reload_item` before serializing.
+"""
+
+import contextlib
+
+import httpx
+import pytest
+import pytest_asyncio
+import sqlalchemy
+import sqlalchemy.ext.asyncio
+
+from fastapi_rtk.api.model_rest_api import ModelRestApi
+from fastapi_rtk.backends.sqla.interface import SQLAInterface
+from fastapi_rtk.backends.sqla.model import Model
+
+pytestmark = pytest.mark.asyncio
+
+
+class LazyContinent(Model):
+    __tablename__ = "lazy_continent"
+    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+    name = sqlalchemy.Column(sqlalchemy.String(50), nullable=False)
+    countries = sqlalchemy.orm.relationship(
+        "LazyCountry", back_populates="continent", lazy="select"
+    )
+
+
+class LazyCountry(Model):
+    __tablename__ = "lazy_country"
+    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+    name = sqlalchemy.Column(sqlalchemy.String(50), nullable=False)
+    continent_id = sqlalchemy.Column(
+        sqlalchemy.Integer, sqlalchemy.ForeignKey("lazy_continent.id")
+    )
+    continent = sqlalchemy.orm.relationship(
+        "LazyContinent", back_populates="countries", lazy="select"
+    )
+    widgets = sqlalchemy.orm.relationship(
+        "LazyWidget", back_populates="country", lazy="select"
+    )
+
+
+class LazyWidget(Model):
+    __tablename__ = "lazy_widget"
+    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+    name = sqlalchemy.Column(sqlalchemy.String(50), nullable=False)
+    country_id = sqlalchemy.Column(
+        sqlalchemy.Integer, sqlalchemy.ForeignKey("lazy_country.id")
+    )
+    country = sqlalchemy.orm.relationship(
+        "LazyCountry", back_populates="widgets", lazy="select"
+    )
+
+
+class LazyContinentsApi(ModelRestApi):
+    resource_name = "lazycontinents"
+    datamodel = SQLAInterface(LazyContinent)
+
+
+class LazyCountriesApi(ModelRestApi):
+    resource_name = "lazycountries"
+    datamodel = SQLAInterface(LazyCountry)
+
+
+class LazyWidgetsApi(ModelRestApi):
+    resource_name = "lazywidgets"
+    datamodel = SQLAInterface(LazyWidget)
+
+
+@pytest_asyncio.fixture
+async def lazy_app(make_toolkit_app):
+    import sys
+
+    @contextlib.asynccontextmanager
+    async def lazy_lifespan(_app):
+        engine = sys.modules["fastapi_rtk.db"].db._engine
+        async with engine.begin() as conn:
+            for model in (LazyContinent, LazyCountry, LazyWidget):
+                await conn.run_sync(
+                    lambda c, m=model: m.__table__.create(c, checkfirst=True)
+                )
+        yield
+
+    return make_toolkit_app(
+        extra_apis=[LazyContinentsApi, LazyCountriesApi, LazyWidgetsApi],
+        extra_lifespans=[lazy_lifespan],
+    )
+
+
+@pytest_asyncio.fixture
+async def lazy_client(lazy_app):
+    transport = httpx.ASGITransport(app=lazy_app)
+    async with lazy_app.router.lifespan_context(lazy_app):
+        async with httpx.AsyncClient(
+            transport=transport, base_url="http://testserver"
+        ) as ac:
+            yield ac
+
+
+@pytest_asyncio.fixture
+async def token(lazy_client):
+    import sys
+
+    db = sys.modules["fastapi_rtk.db"].db
+    from fastapi_rtk.globals import g
+
+    sm = g.current_app.sm
+    async with db.session() as session:
+        user = await sm.create_user(
+            username="admin",
+            email="admin@example.com",
+            password="adminpass123",
+            roles=["Admin"],
+            session=session,
+            raise_exception=True,
+        )
+        assert user is not None
+    response = await lazy_client.post(
+        "/api/v1/auth/jwt/login",
+        data={"username": "admin", "password": "adminpass123"},
+    )
+    assert response.status_code == 200, response.text
+    return response.json()["access_token"]
+
+
+@pytest.fixture
+def countries_api(lazy_app):
+    from fastapi_rtk.globals import g
+
+    return next(a for a in g.current_app.apis if a.resource_name == "lazycountries")
+
+
+class TestShowColumns:
+    async def test_collection_and_relation_in_show_columns(self, countries_api):
+        assert "widgets" in countries_api.show_select_columns
+        assert "continent" in countries_api.show_select_columns
+
+
+@pytest_asyncio.fixture
+async def seeded(lazy_client):
+    """Insert a continent + country + widget chain directly, bypassing the routes."""
+    import sys
+
+    db = sys.modules["fastapi_rtk.db"].db
+    async with db.session() as session:
+        continent = LazyContinent(name="Europe")
+        country = LazyCountry(name="Germany", continent=continent)
+        country.widgets.append(LazyWidget(name="Hammer"))
+        session.add(country)
+        await session.commit()
+        return country.id
+
+
+class TestReadRoutes:
+    async def test_list_and_show_load_relations(self, lazy_client, token, seeded):
+        country_id = seeded
+
+        listing = await lazy_client.get(
+            "/api/v1/lazycountries/",
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        assert listing.status_code == 200, listing.text
+        show = await lazy_client.get(
+            f"/api/v1/lazycountries/{country_id}",
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        assert show.status_code == 200, show.text
+
+
+class TestAdd:
+    async def test_post_model_with_only_a_collection(self, lazy_client, token):
+        response = await lazy_client.post(
+            "/api/v1/lazycontinents/",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"name": "Europe"},
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["result"]["countries"] == []
+
+    async def test_post_serializes_unloaded_collection(self, lazy_client, token):
+        response = await lazy_client.post(
+            "/api/v1/lazycountries/",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"name": "Germany"},
+        )
+        assert response.status_code == 200, response.text
+        assert response.json()["result"]["widgets"] == []
+
+
+class TestBuiltinRolesApi:
+    async def test_post_role(self, client, admin_token):
+        response = await client.post(
+            "/api/v1/roles/",
+            headers={"Authorization": f"Bearer {admin_token}"},
+            json={"name": "Tester"},
+        )
+        assert response.status_code == 200, response.text
+
+
+class TestEdit:
+    async def test_put_without_relation_serializes_relations(self, lazy_client, token):
+        continent = await lazy_client.post(
+            "/api/v1/lazycontinents/",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"name": "Europe"},
+        )
+        assert continent.status_code == 200, continent.text
+        post = await lazy_client.post(
+            "/api/v1/lazycountries/",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"name": "Germany", "continent": continent.json()["id"]},
+        )
+        assert post.status_code == 200, post.text
+        country_id = post.json()["id"]
+        widget = await lazy_client.post(
+            "/api/v1/lazywidgets/",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"name": "Hammer", "country": country_id},
+        )
+        assert widget.status_code == 200, widget.text
+
+        response = await lazy_client.put(
+            f"/api/v1/lazycountries/{country_id}",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"name": "Deutschland"},
+        )
+        assert response.status_code == 200, response.text
+        body = response.json()["result"]
+        assert body["continent"] is not None
+        assert len(body["widgets"]) == 1
+
+
+class TestBuiltinUsersApi:
+    async def test_post_user(self, client, admin_token):
+        response = await client.post(
+            "/api/v1/users/",
+            headers={"Authorization": f"Bearer {admin_token}"},
+            json={
+                "username": "bob",
+                "email": "bob@example.com",
+                "password": "bobpass123",
+                "first_name": "Bob",
+                "last_name": "Builder",
+            },
+        )
+        assert response.status_code == 200, response.text

{fastapi_rtk-2.12.4 → fastapi_rtk-2.13.1}/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)