activemodel 0.8.0__tar.gz → 0.9.0__tar.gz

{activemodel-0.8.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.8.0 → activemodel-0.9.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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)
 
 

{activemodel-0.8.0 → activemodel-0.9.0}/Makefile

@@ -2,6 +2,9 @@ setup:
 	uv venv && uv sync
 	@echo "activate: source ./.venv/bin/activate"
 
+up:
+	docker compose up -d --wait
+
 db_open:
 	open -a TablePlus $$DATABASE_URL
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activemodel
-Version: 0.8.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>

{activemodel-0.8.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.8.0 → activemodel-0.9.0}/activemodel/base_model.py

@@ -4,12 +4,13 @@ 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 inspect import isclass
 
 from activemodel.mixins.pydantic_json import PydanticJSONMixin
 
@@ -214,7 +215,26 @@ class BaseModel(SQLModel):
 
         return self
 
+    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)
 
@@ -236,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):
         """
@@ -268,13 +311,15 @@ class BaseModel(SQLModel):
         return new_model
 
     @classmethod
-    def primary_key_field(cls):
+    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)
 
@@ -297,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"
 
@@ -313,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))
 
@@ -325,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.8.0 → activemodel-0.9.0}/activemodel/mixins/pydantic_json.py

@@ -1,12 +1,16 @@
 """
-https://github.com/fastapi/sqlmodel/issues/63
+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:
@@ -26,6 +30,8 @@ class PydanticJSONMixin:
 
         - 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():
@@ -73,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.8.0 → activemodel-0.9.0}/activemodel/pytest/transaction.py

@@ -28,7 +28,7 @@ def database_reset_transaction():
 
     engine = SessionManager.get_instance().get_engine()
 
-    logger.info("starting database transaction")
+    logger.info("starting global database transaction")
 
     with engine.begin() as connection:
         transaction = connection.begin_nested()

{activemodel-0.8.0 → activemodel-0.9.0}/activemodel/types/typeid.py

@@ -188,5 +188,3 @@ class TypeIDType(types.TypeDecorator):
             # "minLength": 24,
             # "maxLength": 24,
         }
-
-        return core_schema.uuid_schema()

{activemodel-0.8.0 → activemodel-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "activemodel"
-version = "0.8.0"
+version = "0.9.0"
 description = "Make SQLModel more like an a real ORM"
 readme = "README.md"
 requires-python = ">=3.10"

activemodel-0.9.0/test/import_test.py

@@ -0,0 +1,5 @@
+import activemodel
+
+
+def test_import() -> None:
+    assert isinstance(activemodel.__name__, str)

{activemodel-0.8.0 → activemodel-0.9.0}/test/models.py

@@ -1,5 +1,5 @@
 from pydantic import computed_field
-from sqlmodel import Field, Relationship
+from sqlmodel import Column, Field, Integer, Relationship
 
 from activemodel import BaseModel
 from activemodel.mixins import TypeIDMixin

activemodel-0.9.0/test/mutation_test.py

@@ -0,0 +1,35 @@
+import pytest
+from sqlalchemy.orm.base import instance_state
+from test.models import ExampleRecord
+
+
+def assert_modified(model):
+    assert instance_state(model).modified
+
+
+def assert_clean(model):
+    assert not instance_state(model).modified
+
+
+def test_flag_modified(create_and_wipe_database):
+    example = ExampleRecord().save()
+    assert_clean(example)
+
+    example.flag_modified("something")
+    assert example.modified_fields() == {"something"}
+
+
+def test_modified_list(create_and_wipe_database):
+    example = ExampleRecord().save()
+    assert_clean(example)
+
+    example.something = "hi"
+    assert example.modified_fields() == {"something"}
+
+
+def test_error_on_bad_field(create_and_wipe_database):
+    example = ExampleRecord().save()
+    assert_clean(example)
+
+    with pytest.raises(ValueError, match="bad_field"):
+        example.flag_modified("bad_field")

activemodel-0.8.0/test/serialization_test.py → activemodel-0.9.0/test/nested_pydantic_json_test.py

@@ -4,9 +4,11 @@ By default, fast API does not handle converting JSONB to and from Pydantic model
 
 from pydantic import BaseModel as PydanticBaseModel
 from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm.base import instance_state
 from sqlmodel import Field, Session
 
 from activemodel import BaseModel
+from sqlalchemy.dialects.postgresql import JSON
 from activemodel.mixins import PydanticJSONMixin, TypeIDMixin
 from activemodel.session_manager import global_session
 from test.models import AnotherExample, ExampleWithComputedProperty
@@ -32,6 +34,13 @@ class ExampleWithJSONB(
     normal_field: str | None = Field(default=None)
 
 
+class ExampleWithSimpleJSON(
+    BaseModel, PydanticJSONMixin, TypeIDMixin("simple_json_test"), table=True
+):
+    # NOT JSONB!
+    object_field: SubObject = Field(sa_type=JSON)
+
+
 def test_json_serialization(create_and_wipe_database):
     sub_object = SubObject(name="test", value=1)
 
@@ -54,6 +63,18 @@ def test_json_serialization(create_and_wipe_database):
     assert isinstance(example.object_field, SubObject)
     assert isinstance(example.optional_object_field, SubObject)
 
+    example.refresh()
+
+    # make sure the automatic dict re-parse doesn't mark as dirty
+    assert not instance_state(example).modified
+
+    # make sure the types are preserved when refreshed
+    assert isinstance(example.list_field[0], SubObject)
+    assert example.optional_list_field
+    assert isinstance(example.optional_list_field[0], SubObject)
+    assert isinstance(example.object_field, SubObject)
+    assert isinstance(example.optional_object_field, SubObject)
+
     fresh_example = ExampleWithJSONB.get(example.id)
 
     assert fresh_example is not None
@@ -91,3 +112,80 @@ def test_computed_serialization(create_and_wipe_database):
 
     assert ExampleWithComputedProperty.count() == 1
     assert AnotherExample.count() == 1
+
+
+def test_simple_json_object(create_and_wipe_database):
+    sub_object = SubObject(name="test", value=1)
+    example = ExampleWithSimpleJSON(
+        object_field=sub_object,
+    ).save()
+
+    # make sure the types are preserved when saved
+    assert isinstance(example.object_field, SubObject)
+
+    example.refresh()
+    assert not instance_state(example).modified
+
+    # make sure the types are preserved when refreshed
+    assert isinstance(example.object_field, SubObject)
+    assert example.object_field.name == "test"
+    assert example.object_field.value == 1
+
+    fresh_example = ExampleWithSimpleJSON.get(example.id)
+
+    assert fresh_example is not None
+    assert isinstance(fresh_example.object_field, SubObject)
+    assert fresh_example.object_field.name == "test"
+    assert fresh_example.object_field.value == 1
+
+
+def test_json_object_update(create_and_wipe_database):
+    "if we update a entry in a list of json objects, does the change persist?"
+
+    sub_object = SubObject(name="test", value=1)
+    sub_object_2 = SubObject(name="test_2", value=2)
+
+    example = ExampleWithJSONB(
+        list_field=[sub_object, sub_object_2],
+        generic_list_field=[{"one": "two"}],
+        object_field=sub_object,
+        unstructured_field={"one": "two"},
+        semi_structured_field={"one": "two"},
+    ).save()
+
+    # saving serializes the pydantic model and reloads it, which must not mark the object as dirty!
+    assert not instance_state(example).modified
+
+    # modify a nested object
+    example.list_field[0].name = "updated"
+
+    # the field will *not* be marked as dirty by default
+    assert not instance_state(example).modified
+
+    # so we have to force it to be dirty
+    example.flag_modified("list_field")
+
+    example.object_field.value = 42
+    assert instance_state(example).modified
+
+    example.save()
+
+    assert example.list_field[0].name == "updated"
+
+    # NOTE this should be inverted, but we are asserting against the current behavior of `object_field` state not being updated
+    assert example.object_field.value != 42
+
+    # now, let's mark it as modified
+    example.object_field.value = 42
+    example.flag_modified("object_field")
+    example.save()
+
+    assert example.object_field.value == 42
+
+    # refresh from database
+    fresh_example = ExampleWithJSONB.one(example.id)
+    assert not instance_state(example).modified
+
+    # verify changes persisted
+    assert fresh_example.list_field[0].name == "updated"
+    assert fresh_example.object_field.value == 42

{activemodel-0.8.0 → activemodel-0.9.0}/test/orm_test.py

@@ -2,7 +2,14 @@
 Test core ORM functions
 """
 
-from test.models import EXAMPLE_TABLE_PREFIX, AnotherExample, ExampleRecord
+import pytest
+from test.models import (
+    EXAMPLE_TABLE_PREFIX,
+    AnotherExample,
+    ExampleRecord,
+    ExampleWithId,
+)
+import sqlalchemy.exc
 
 
 def test_empty_count(create_and_wipe_database):
@@ -95,10 +102,6 @@ def test_query_count(create_and_wipe_database):
     assert count == 1
 
 
-def test_primary_key(create_and_wipe_database):
-    assert ExampleRecord.primary_key_field().name == "id"
-
-
 def test_get_non_pk(create_and_wipe_database):
     # some paranoid checks here as I attempt to debug the issue
     example = ExampleRecord(something="hi", another_with_index="key_123").save()
@@ -109,3 +112,48 @@ def test_get_non_pk(create_and_wipe_database):
 
     assert retrieved_example
     assert retrieved_example.id == example.id
+
+
+def test_database_refresh(create_and_wipe_database):
+    example = ExampleRecord(something="hi").save()
+    example_2 = ExampleRecord.get(example.id)
+
+    # now, let's update the "hi" on the 2nd example
+    example_2.something = "hello"
+    example_2.save()
+
+    # now let's refresh the first example
+    example.refresh()
+
+    assert example.something == "hello"
+
+
+def test_primary_key_column():
+    assert ExampleRecord.primary_key_column().name == "id"
+    assert ExampleWithId.primary_key_column().name == "id"
+
+
+def test_one_no_results(create_and_wipe_database):
+    record = ExampleRecord()
+    # do not save!
+
+    with pytest.raises(sqlalchemy.exc.NoResultFound):
+        ExampleRecord.one(record.id)
+
+
+def test_one_single_result(create_and_wipe_database):
+    example = ExampleRecord().save()
+    result = ExampleRecord.one(example.id)
+
+    assert result
+    assert isinstance(result, ExampleRecord)
+    assert result.id == example.id
+
+
+def test_one_multiple_results(create_and_wipe_database):
+    # not a pk, but should still throw an error
+    example = ExampleRecord(something="hi").save()
+    another_example = ExampleRecord(something="hi").save()
+
+    with pytest.raises(sqlalchemy.exc.MultipleResultsFound):
+        ExampleRecord.one(something="hi")

activemodel-0.8.0/.tool-versions

@@ -1,3 +0,0 @@
-python 3.13.1
-uv 0.5.29
-direnv 2.35.0