activemodel 0.7.0__tar.gz → 0.9.0__tar.gz

{activemodel-0.7.0 → activemodel-0.9.0}/.envrc

@@ -10,3 +10,5 @@ export POSTGRES_DB=development
 export DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${DATABASE_HOST}:5432/development
 
 export PYTHONBREAKPOINT=ipdb.set_trace
+
+# export ACTIVEMODEL_LOG_SQL=true

{activemodel-0.7.0 → activemodel-0.9.0}/.github/workflows/build_and_publish.yml

@@ -5,11 +5,6 @@ on:
       - main
       - master
 
-# write permissions for release-please
-# permissions:
-#   contents: write
-#   pull-requests: write
-
 env:
   # avoid build failures due to flaky pypi
   PIP_DEFAULT_TIMEOUT: 60
@@ -17,10 +12,13 @@ env:
 
   DATABASE_HOST: localhost
 
+  # required otherwise github api calls are rate limited
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
 jobs:
   release-please:
     runs-on: ubuntu-latest
-    needs: [build]
+    needs: [matrix-test]
     outputs:
       release_created: ${{ steps.release.outputs.release_created }}
     steps:
@@ -42,17 +40,19 @@ jobs:
       - run: uv build
       - run: uv publish --token ${{ secrets.PYPI_API_TOKEN }}
 
-  build:
-    runs-on: ubuntu-latest
+  matrix-test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        # TODO test on macos-latest, does not have docker by default :/
+        # unfortunately, some of the typing stuff we use requires new python versions
+        python-version: ["3.13", "3.12"]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
       - uses: jdx/mise-action@v2
-      - run: direnv allow . && direnv export gha >> "$GITHUB_ENV"
+      - run: mise use python@${{ matrix.python-version }}
       - run: docker compose up -d --wait
+      - uses: iloveitaly/github-action-direnv-load-and-mask@master
       - run: uv sync
-
-      # `uv run` prefix is required since the venv is not activated
-
-      - name: Make sure we can import the module
-        run: uv run python -c 'import ${{ github.event.repository.name }}'
       - run: uv run pytest

activemodel-0.9.0/.tool-versions

@@ -0,0 +1,3 @@
+python 3.13.2
+uv 0.6.10
+direnv 2.35.0

{activemodel-0.7.0 → activemodel-0.9.0}/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## [0.9.0](https://github.com/iloveitaly/activemodel/compare/v0.8.0...v0.9.0) (2025-03-26)
+
+
+### Features
+
+* add flag_modified and modified_fields to BaseModel ([3059903](https://github.com/iloveitaly/activemodel/commit/305990387797f4fde26c7c89a8d332b6ef7ff21f))
+* add refresh method to BaseModel for database sync ([59be3bb](https://github.com/iloveitaly/activemodel/commit/59be3bb87c64c865b08a2856f043678650c07194))
+* add robust record retrieval methods to BaseModel ([d15b5a1](https://github.com/iloveitaly/activemodel/commit/d15b5a1ffbbb18b6fde94d64dbc76f45c21f7da8))
+
+
+### Bug Fixes
+
+* use set_committed_value in PydanticJSONMixin ([5446204](https://github.com/iloveitaly/activemodel/commit/5446204fc4b17ed5f1daa4c898f5ba2242b0fc40))
+
+
+### Documentation
+
+* update TODOs and correct typeid return value ([52b2514](https://github.com/iloveitaly/activemodel/commit/52b2514b6d30212a56e34c2fe4c849ff79e36e6a))
+
+## [0.8.0](https://github.com/iloveitaly/activemodel/compare/v0.7.0...v0.8.0) (2025-03-18)
+
+
+### Features
+
+* add BaseModel.where method and update test cases ([9fe4c5a](https://github.com/iloveitaly/activemodel/commit/9fe4c5af619690ffb6344cf5c74a2d4b2b46ef02))
+* add primary_key_field ([947a410](https://github.com/iloveitaly/activemodel/commit/947a410766dd764e8ac5b3177152d2ff22cdb609))
+* log start of database transaction in tests ([ac90d6f](https://github.com/iloveitaly/activemodel/commit/ac90d6f18bb0a4cca68527dec9c55b4af1f6e851))
+* reload json fields when record is reloaded from db ([c013082](https://github.com/iloveitaly/activemodel/commit/c013082004bb3a93e81f00eb0c990833a9cae7e2))
+
+
+### Bug Fixes
+
+* yield session object in global_session function ([47b33cc](https://github.com/iloveitaly/activemodel/commit/47b33cc1aa66d6076363635191c297c52fcc3deb))
+
+
+### Documentation
+
+* add comments to clarify SessionManager use and config ([e73561b](https://github.com/iloveitaly/activemodel/commit/e73561b3d52e617a0f92da5cd93981ff429da16f))
+* update comments and README with additional examples and info ([209ee36](https://github.com/iloveitaly/activemodel/commit/209ee36a9df53f927cd9e5b2bb15b3a5776b34ce))
+* update README with setup instructions and SQLModel tips ([f2520b5](https://github.com/iloveitaly/activemodel/commit/f2520b5fa5d7c462e8f7a591b83d874239a34b8d))
+
 ## [0.7.0](https://github.com/iloveitaly/activemodel/compare/v0.6.0...v0.7.0) (2025-02-08)
 
 

{activemodel-0.7.0 → activemodel-0.9.0}/Makefile

@@ -2,6 +2,12 @@ setup:
 	uv venv && uv sync
 	@echo "activate: source ./.venv/bin/activate"
 
+up:
+	docker compose up -d --wait
+
+db_open:
+	open -a TablePlus $$DATABASE_URL
+
 clean:
 	rm -rf *.egg-info
 	rm -rf .venv

{activemodel-0.7.0 → activemodel-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activemodel
-Version: 0.7.0
+Version: 0.9.0
 Summary: Make SQLModel more like an a real ORM
 Project-URL: Repository, https://github.com/iloveitaly/activemodel
 Author-email: Michael Bianco <iloveitaly@gmail.com>
@@ -29,10 +29,11 @@ This package provides a thin wrapper around SQLModel that provides a more Active
 First, setup your DB:
 
 ```python
-
+import activemodel
+activemodel.init("sqlite:///database.db")
 ```
 
-Then, setup some models:
+Create models:
 
 ```python
 from activemodel import BaseModel
@@ -51,6 +52,38 @@ class User(
     a_field: str
 ```
 
+You'll need to create the models in the DB. Alembic is the best way to do it, but you can cheat as well:
+
+```python
+from sqlmodel import SQLModel
+
+SQLModel.metadata.create_all(get_engine())
+
+# now you can create a user!
+User(a_field="a").save()
+```
+
+Maybe you like JSON:
+
+```python
+from activemodel import BaseModel
+from pydantic import BaseModel as PydanticBaseModel
+from activemodel.mixins import PydanticJSONMixin, TypeIDMixin, TimestampsMixin
+
+class SubObject(PydanticBaseModel):
+    name: str
+    value: int
+
+class User(
+    BaseModel,
+    TimestampsMixin,
+    PydanticJSONMixin,
+    TypeIDMixin("user"),
+    table=True
+):
+    list_field: list[SubObject] = Field(sa_type=JSONB())
+```
+
 ## Usage
 
 ### Integrating Alembic
@@ -60,6 +93,7 @@ class User(
 * To import all of your models you want in your DB. [Here's my recommended way to do this.](https://github.com/iloveitaly/python-starter-template/blob/master/app/models/__init__.py)
 * Use your DB URL from the ENV
 * Target sqlalchemy metadata to the sqlmodel-generated metadata
+* Most likely you'll want to add [alembic-postgresql-enum](https://pypi.org/project/alembic-postgresql-enum/) so migrations work properly
 
 [Take a look at these scripts for an example of how to fully integrate Alembic into your development workflow.](https://github.com/iloveitaly/python-starter-template/blob/0af2c7e95217e34bde7357cc95be048900000e48/Justfile#L618-L712)
 
@@ -161,6 +195,15 @@ https://github.com/tomwojcik/starlette-context
 * Conditional: `Scrape.select().where(Scrape.id < last_scraped.id).all()`
 * Equality: `MenuItem.select().where(MenuItem.menu_id == menu.id).all()`
 * `IN` example: `CanonicalMenuItem.select().where(col(CanonicalMenuItem.id).in_(canonized_ids)).all()`
+* Compound where query: `User.where((User.last_active_at != None) & (User.last_active_at > last_24_hours)).count()`
+
+### SQLModel Internals
+
+SQLModel & SQLAlchemy are tricky. Here are some useful internal tricks:
+
+* `__sqlmodel_relationships__` is where any `RelationshipInfo` objects are stored. This is used to generate relationship fields on the object.
+* `ModelClass.relationship_name.property.local_columns` 
+* Get cached fields from a model `object_state(instance).dict.get(field_name)`
 
 ### TypeID
 
@@ -186,7 +229,7 @@ class Appointment(
     TypeIDMixin("appointment"),
     table=True
 ):
-    # `foreign_key` is a activemodel-specific method to generate the right `Field` for the relationship
+    # `foreign_key` is a activemodel method to generate the right `Field` for the relationship
     # TypeIDType is really important here for fastapi serialization
     doctor_id: TypeIDType = Doctor.foreign_key()
     doctor: Doctor = Relationship()
@@ -233,3 +276,7 @@ https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d
 * https://github.com/fastapi/full-stack-fastapi-template
 * https://github.com/DarylStark/my_data/
 * https://github.com/petrgazarov/FastAPI-app/tree/main/fastapi_app
+
+## Upstream Changes
+
+- [ ] https://github.com/fastapi/sqlmodel/pull/1293

{activemodel-0.7.0 → activemodel-0.9.0}/README.md

@@ -14,10 +14,11 @@ This package provides a thin wrapper around SQLModel that provides a more Active
 First, setup your DB:
 
 ```python
-
+import activemodel
+activemodel.init("sqlite:///database.db")
 ```
 
-Then, setup some models:
+Create models:
 
 ```python
 from activemodel import BaseModel
@@ -36,6 +37,38 @@ class User(
     a_field: str
 ```
 
+You'll need to create the models in the DB. Alembic is the best way to do it, but you can cheat as well:
+
+```python
+from sqlmodel import SQLModel
+
+SQLModel.metadata.create_all(get_engine())
+
+# now you can create a user!
+User(a_field="a").save()
+```
+
+Maybe you like JSON:
+
+```python
+from activemodel import BaseModel
+from pydantic import BaseModel as PydanticBaseModel
+from activemodel.mixins import PydanticJSONMixin, TypeIDMixin, TimestampsMixin
+
+class SubObject(PydanticBaseModel):
+    name: str
+    value: int
+
+class User(
+    BaseModel,
+    TimestampsMixin,
+    PydanticJSONMixin,
+    TypeIDMixin("user"),
+    table=True
+):
+    list_field: list[SubObject] = Field(sa_type=JSONB())
+```
+
 ## Usage
 
 ### Integrating Alembic
@@ -45,6 +78,7 @@ class User(
 * To import all of your models you want in your DB. [Here's my recommended way to do this.](https://github.com/iloveitaly/python-starter-template/blob/master/app/models/__init__.py)
 * Use your DB URL from the ENV
 * Target sqlalchemy metadata to the sqlmodel-generated metadata
+* Most likely you'll want to add [alembic-postgresql-enum](https://pypi.org/project/alembic-postgresql-enum/) so migrations work properly
 
 [Take a look at these scripts for an example of how to fully integrate Alembic into your development workflow.](https://github.com/iloveitaly/python-starter-template/blob/0af2c7e95217e34bde7357cc95be048900000e48/Justfile#L618-L712)
 
@@ -146,6 +180,15 @@ https://github.com/tomwojcik/starlette-context
 * Conditional: `Scrape.select().where(Scrape.id < last_scraped.id).all()`
 * Equality: `MenuItem.select().where(MenuItem.menu_id == menu.id).all()`
 * `IN` example: `CanonicalMenuItem.select().where(col(CanonicalMenuItem.id).in_(canonized_ids)).all()`
+* Compound where query: `User.where((User.last_active_at != None) & (User.last_active_at > last_24_hours)).count()`
+
+### SQLModel Internals
+
+SQLModel & SQLAlchemy are tricky. Here are some useful internal tricks:
+
+* `__sqlmodel_relationships__` is where any `RelationshipInfo` objects are stored. This is used to generate relationship fields on the object.
+* `ModelClass.relationship_name.property.local_columns` 
+* Get cached fields from a model `object_state(instance).dict.get(field_name)`
 
 ### TypeID
 
@@ -171,7 +214,7 @@ class Appointment(
     TypeIDMixin("appointment"),
     table=True
 ):
-    # `foreign_key` is a activemodel-specific method to generate the right `Field` for the relationship
+    # `foreign_key` is a activemodel method to generate the right `Field` for the relationship
     # TypeIDType is really important here for fastapi serialization
     doctor_id: TypeIDType = Doctor.foreign_key()
     doctor: Doctor = Relationship()
@@ -218,3 +261,7 @@ https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d
 * https://github.com/fastapi/full-stack-fastapi-template
 * https://github.com/DarylStark/my_data/
 * https://github.com/petrgazarov/FastAPI-app/tree/main/fastapi_app
+
+## Upstream Changes
+
+- [ ] https://github.com/fastapi/sqlmodel/pull/1293

{activemodel-0.7.0 → activemodel-0.9.0}/TODO

@@ -1,5 +1,6 @@
 Docs are bad:
 
+- `another_example_id: TypeIDType = AnotherExample.foreign_key(nullable=True)` nullable should be able to be defined via types
 - JSON field, specifically JSONB https://github.com/tiangolo/sqlmodel/discussions/696 and https://github.com/fastapi/sqlmodel/discussions/1105
 - One-to-many relationships
 - Data validation https://github.com/tiangolo/sqlmodel/issues/52
@@ -9,8 +10,8 @@ Docs are bad:
 
 TODO
 
+- [ ] sessions in tests, they don't work right now
 - [ ] snake case for attributes https://github.com/sqlalchemy/sqlalchemy/issues/7149
-- [ ] foreign key names https://github.com/fastapi/sqlmodel/discussions/1213
 
 
 find_or_create

{activemodel-0.7.0 → activemodel-0.9.0}/activemodel/base_model.py

@@ -4,12 +4,16 @@ from uuid import UUID
 
 import pydash
 import sqlalchemy as sa
+from sqlalchemy.orm.attributes import flag_modified as sa_flag_modified
+from sqlalchemy.orm.base import instance_state
 import sqlmodel as sm
 from sqlalchemy import Connection, event
 from sqlalchemy.orm import Mapper, declared_attr
-from sqlmodel import Field, MetaData, Session, SQLModel, select
+from sqlmodel import Column, Field, Session, SQLModel, inspect, select
 from typeid import TypeID
 
+from activemodel.mixins.pydantic_json import PydanticJSONMixin
+
 # NOTE: this patches a core method in sqlmodel to support db comments
 from . import get_column_from_field_patch  # noqa: F401
 from .logger import logger
@@ -157,7 +161,10 @@ class BaseModel(SQLModel):
     @classmethod
     def foreign_key(cls, **kwargs):
         """
-        Returns a Field object referencing the foreign key of the model.
+        Returns a `Field` object referencing the foreign key of the model.
+
+        >>> other_model_id: int
+        >>> other_model = OtherModel.foreign_key()
         """
 
         field_options = {"nullable": False} | kwargs
@@ -174,6 +181,11 @@ class BaseModel(SQLModel):
         "create a query wrapper to easily run sqlmodel queries on this model"
         return QueryWrapper[cls](cls, *args)
 
+    @classmethod
+    def where(cls, *args):
+        "convenience method to avoid having to write .select().where() in order to add conditions"
+        return cls.select().where(*args)
+
     def delete(self):
         with get_session() as session:
             if old_session := Session.object_session(self):
@@ -197,13 +209,32 @@ class BaseModel(SQLModel):
             session.commit()
             session.refresh(self)
 
+            # Only call the transform method if the class is a subclass of PydanticJSONMixin
+            if issubclass(self.__class__, PydanticJSONMixin):
+                self.__class__.__transform_dict_to_pydantic__(self)
+
         return self
 
-        # except IntegrityError:
-        #     log.quiet(f"{self} already exists in the database.")
-        #     session.rollback()
+    def refresh(self):
+        "Refreshes an object from the database"
+
+        with get_session() as session:
+            if (
+                old_session := Session.object_session(self)
+            ) and old_session is not session:
+                old_session.expunge(self)
+
+            session.add(self)
+            session.refresh(self)
+
+            # Only call the transform method if the class is a subclass of PydanticJSONMixin
+            if issubclass(self.__class__, PydanticJSONMixin):
+                self.__class__.__transform_dict_to_pydantic__(self)
+
+        return self
 
     # TODO shouldn't this be handled by pydantic?
+    # TODO where is this actually used? shoudl prob remove this
     def json(self, **kwargs):
         return json.dumps(self.dict(), default=str, **kwargs)
 
@@ -225,6 +256,29 @@ class BaseModel(SQLModel):
     def is_new(self) -> bool:
         return not self._sa_instance_state.has_identity
 
+    def flag_modified(self, *args: str):
+        """
+        Flag one or more fields as modified. Useful for marking a field containing sub-objects as modified.
+
+        Will throw an error if an invalid field is passed.
+        """
+
+        assert len(args) > 0, "Must pass at least one field name"
+
+        for field_name in args:
+            if field_name not in self.__fields__:
+                raise ValueError(f"Field '{field_name}' does not exist in the model.")
+
+            # check if the field exists
+            sa_flag_modified(self, field_name)
+
+    def modified_fields(self) -> set[str]:
+        "set of fields that are modified"
+
+        insp = inspect(self)
+
+        return {attr.key for attr in insp.attrs if attr.history.has_changes()}
+
     @classmethod
     def find_or_create_by(cls, **kwargs):
         """
@@ -256,6 +310,29 @@ class BaseModel(SQLModel):
         new_model = cls(**kwargs)
         return new_model
 
+    @classmethod
+    def primary_key_column(cls) -> Column:
+        """
+        Returns the primary key column of the model by inspecting SQLAlchemy field information.
+
+        >>> ExampleModel.primary_key_field().name
+        """
+
+        # TODO note_schema.__class__.__table__.primary_key
+        # TODO no reason why this couldn't be cached
+
+        pk_columns = list(cls.__table__.primary_key.columns)
+
+        if not pk_columns:
+            raise ValueError("No primary key defined for the model.")
+
+        if len(pk_columns) > 1:
+            raise ValueError(
+                "Multiple primary keys defined. This method supports only single primary key models."
+            )
+
+        return pk_columns[0]
+
     # TODO what's super dangerous here is you pass a kwarg which does not map to a specific
     #      field it will result in `True`, which will return all records, and not give you any typing
     #      errors. Dangerous when iterating on structure quickly
@@ -265,9 +342,8 @@ class BaseModel(SQLModel):
     @classmethod
     def get(cls, *args: t.Any, **kwargs: t.Any):
         """
-        Gets a single record from the database. Pass an PK ID or a kwarg to filter by.
+        Gets a single record (or None) from the database. Pass an PK ID or kwargs to filter by.
         """
-
         # TODO id is hardcoded, not good! Need to dynamically pick the best uid field
         id_field_name = "id"
 
@@ -281,8 +357,37 @@ class BaseModel(SQLModel):
         with get_session() as session:
             return session.exec(statement).first()
 
+    @classmethod
+    def one(cls, *args: t.Any, **kwargs: t.Any):
+        """
+        Gets a single record from the database. Pass an PK ID or a kwarg to filter by.
+        """
+
+        args, kwargs = cls.__process_filter_args__(*args, **kwargs)
+        statement = select(cls).filter(*args).filter_by(**kwargs)
+
+        with get_session() as session:
+            return session.exec(statement).one()
+
+    @classmethod
+    def __process_filter_args__(cls, *args: t.Any, **kwargs: t.Any):
+        """
+        Helper method to process filter arguments and implement some nice DX for our devs.
+        """
+
+        id_field_name = cls.primary_key_column().name
+
+        # special case for getting by ID without having to specify the field name
+        # TODO should dynamically add new pk types based on column definition
+        if len(args) == 1 and isinstance(args[0], (int, TypeID, str, UUID)):
+            kwargs[id_field_name] = args[0]
+            args = ()
+
+        return args, kwargs
+
     @classmethod
     def all(cls):
+        "get a generator for all records in the database"
         with get_session() as session:
             results = session.exec(sm.select(cls))
 
@@ -293,7 +398,7 @@ class BaseModel(SQLModel):
     @classmethod
     def sample(cls):
         """
-        Pick a random record from the database.
+        Pick a random record from the database. Raises if none exist.
 
         Helpful for testing and console debugging.
         """

{activemodel-0.7.0 → activemodel-0.9.0}/activemodel/celery.py

@@ -4,12 +4,17 @@ Do not import unless you have Celery/Kombu installed.
 In order for TypeID objects to be properly handled by celery, a custom encoder must be registered.
 """
 
+# this is not an explicit dependency, only import this file if you have Celery installed
 from kombu.utils.json import register_type
 from typeid import TypeID
 
 
 def register_celery_typeid_encoder():
-    "this ensures TypeID objects passed as arguments to a delayed function are properly serialized"
+    """
+    Ensures TypeID objects passed as arguments to a delayed function are properly serialized.
+
+    Run at the top of your celery initialization script.
+    """
 
     def class_full_name(clz) -> str:
         return ".".join([clz.__module__, clz.__qualname__])

{activemodel-0.7.0 → activemodel-0.9.0}/activemodel/get_column_from_field_patch.py

@@ -6,6 +6,8 @@ Making sure these docstrings make their way to the DB schema is helpful for a bu
 This patch mutates a core sqlmodel function which translates pydantic FieldInfo objects into sqlalchemy Column objects. It adds the field description as a comment to the column.
 
 Note that FieldInfo *from pydantic* is used when a "bare" field is defined. This can be confusing, because when inspecting model fields, the class name looks exactly the same.
+
+Some ideas for this originally sourced from: https://github.com/fastapi/sqlmodel/issues/492#issuecomment-2489858633
 """
 
 from typing import (

{activemodel-0.7.0 → activemodel-0.9.0}/activemodel/mixins/pydantic_json.py

@@ -1,19 +1,38 @@
+"""
+Need to store nested Pydantic models in PostgreSQL using FastAPI and SQLModel.
+
+SQLModel lacks a direct JSONField equivalent (like Tortoise ORM's JSONField), making it tricky to handle nested model data as JSON in the DB.
+
+Extensive discussion on the problem: https://github.com/fastapi/sqlmodel/issues/63
+"""
+
 from types import UnionType
 from typing import get_args, get_origin
 
 from pydantic import BaseModel as PydanticBaseModel
-from sqlalchemy.orm import reconstructor
+from sqlalchemy.orm import reconstructor, attributes
 
 
 class PydanticJSONMixin:
     """
     By default, SQLModel does not convert JSONB columns into pydantic models when they are loaded from the database.
 
-    This mixin, combined with a custom serializer, fixes that issue.
+    This mixin, combined with a custom serializer (`_serialize_pydantic_model`), fixes that issue.
+
+    >>> class ExampleWithJSON(BaseModel, PydanticJSONMixin, table=True):
+    >>>    list_field: list[SubObject] = Field(sa_type=JSONB()
     """
 
     @reconstructor
-    def init_on_load(self):
+    def __transform_dict_to_pydantic__(self):
+        """
+        Transforms dictionary fields into Pydantic models upon loading.
+
+        - Reconstructor only runs once, when the object is loaded.
+        - We manually call this method on save(), etc to ensure the pydantic types are maintained
+        - `set_committed_value` sets Pydantic models as committed, avoiding `setattr` marking fields as modified
+          after loading from the database.
+        """
         # TODO do we need to inspect sa_type
         for field_name, field_info in self.model_fields.items():
             raw_value = getattr(self, field_name, None)
@@ -60,10 +79,9 @@ class PydanticJSONMixin:
                     model_cls, PydanticBaseModel
                 ):
                     parsed_value = [model_cls(**item) for item in raw_value]
-                    setattr(self, field_name, parsed_value)
-
+                    attributes.set_committed_value(self, field_name, parsed_value)
                 continue
 
             # single class
             if issubclass(model_cls, PydanticBaseModel):
-                setattr(self, field_name, model_cls(**raw_value))
+                attributes.set_committed_value(self, field_name, model_cls(**raw_value))

activemodel-0.9.0/activemodel/pytest/transaction.py

@@ -0,0 +1,63 @@
+from activemodel import SessionManager
+
+from ..logger import logger
+
+
+def database_reset_transaction():
+    """
+    Wrap all database interactions for a given test in a nested transaction and roll it back after the test.
+
+    >>> from activemodel.pytest import database_reset_transaction
+    >>> database_reset_transaction = pytest.fixture(scope="function", autouse=True)(database_reset_transaction)
+
+    Transaction-based DB cleaning does *not* work if the DB mutations are happening in a separate process, which should
+    use spawn, because the same session is not shared across processes. Note that using `fork` is dangerous.
+
+    In this case, you should use the truncate.
+
+    References:
+
+    - https://stackoverflow.com/questions/62433018/how-to-make-sqlalchemy-transaction-rollback-drop-tables-it-created
+    - https://aalvarez.me/posts/setting-up-a-sqlalchemy-and-pytest-based-test-suite/
+    - https://github.com/nickjj/docker-flask-example/blob/93af9f4fbf185098ffb1d120ee0693abcd77a38b/test/conftest.py#L77
+    - https://github.com/caiola/vinhos.com/blob/c47d0a5d7a4bf290c1b726561d1e8f5d2ac29bc8/backend/test/conftest.py#L46
+    - https://stackoverflow.com/questions/64095876/multiprocessing-fork-vs-spawn
+
+    Using a named SAVEPOINT does not give us anything extra, so we are not using it.
+    """
+
+    engine = SessionManager.get_instance().get_engine()
+
+    logger.info("starting global database transaction")
+
+    with engine.begin() as connection:
+        transaction = connection.begin_nested()
+
+        if SessionManager.get_instance().session_connection is not None:
+            logger.warning("session override already exists")
+            # TODO should we throw an exception here?
+
+        SessionManager.get_instance().session_connection = connection
+
+        try:
+            with SessionManager.get_instance().get_session() as factory_session:
+                try:
+                    from factory.alchemy import SQLAlchemyModelFactory
+
+                    # Ensure that all factories use the same session
+                    for factory in SQLAlchemyModelFactory.__subclasses__():
+                        factory._meta.sqlalchemy_session = factory_session
+                        factory._meta.sqlalchemy_session_persistence = "commit"
+                except ImportError:
+                    pass
+
+                yield
+        finally:
+            logger.debug("rolling back transaction")
+
+            transaction.rollback()
+
+            # TODO is this necessary? unclear
+            connection.close()
+
+            SessionManager.get_instance().session_connection = None