activemodel 0.7.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,5 +1,27 @@
 # Changelog
 
+## [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.8.0}/Makefile

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activemodel
-Version: 0.7.0
+Version: 0.8.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.8.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.8.0}/activemodel/base_model.py

@@ -9,6 +9,9 @@ from sqlalchemy import Connection, event
 from sqlalchemy.orm import Mapper, declared_attr
 from sqlmodel import Field, MetaData, Session, SQLModel, select
 from typeid import TypeID
+from inspect import isclass
+
+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
@@ -157,7 +160,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 +180,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,11 +208,11 @@ class BaseModel(SQLModel):
             session.commit()
             session.refresh(self)
 
-        return 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)
 
-        # except IntegrityError:
-        #     log.quiet(f"{self} already exists in the database.")
-        #     session.rollback()
+        return self
 
     # TODO shouldn't this be handled by pydantic?
     def json(self, **kwargs):
@@ -256,6 +267,27 @@ class BaseModel(SQLModel):
         new_model = cls(**kwargs)
         return new_model
 
+    @classmethod
+    def primary_key_field(cls):
+        """
+        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
+
+        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

{activemodel-0.7.0 → activemodel-0.8.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.8.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.8.0}/activemodel/mixins/pydantic_json.py

@@ -1,3 +1,7 @@
+"""
+https://github.com/fastapi/sqlmodel/issues/63
+"""
+
 from types import UnionType
 from typing import get_args, get_origin
 
@@ -9,11 +13,20 @@ 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
+        """
         # 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)

activemodel-0.8.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 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

{activemodel-0.7.0 → activemodel-0.8.0}/activemodel/session_manager.py

@@ -44,6 +44,7 @@ def _serialize_pydantic_model(model: BaseModel | list[BaseModel] | None) -> str
 
 class SessionManager:
     _instance: t.ClassVar[t.Optional["SessionManager"]] = None
+    "singleton instance of SessionManager"
 
     session_connection: Connection | None
     "optionally specify a specific session connection to use for all get_session() calls, useful for testing"
@@ -69,6 +70,7 @@ class SessionManager:
         if not self._engine:
             self._engine = create_engine(
                 self._database_url,
+                # NOTE very important! This enables pydantic models to be serialized for JSONB columns
                 json_serializer=_serialize_pydantic_model,
                 echo=config("ACTIVEMODEL_LOG_SQL", cast=bool, default=False),
                 # https://docs.sqlalchemy.org/en/20/core/pooling.html#disconnect-handling-pessimistic
@@ -87,6 +89,7 @@ class SessionManager:
 
             return _reuse_session()
 
+        # a connection can generate nested transactions
         if self.session_connection:
             return Session(bind=self.session_connection)
 
@@ -94,6 +97,7 @@ class SessionManager:
 
 
 def init(database_url: str):
+    "configure activemodel to connect to a specific database"
     return SessionManager.get_instance(database_url)
 
 
@@ -106,6 +110,8 @@ def get_session():
 
 
 # contextvars must be at the top-level of a module! You will not get a warning if you don't do this.
+# ContextVar is implemented in C, so it's very special and is both thread-safe and asyncio safe. This variable gives us
+# a place to persist a session to use globally across the application.
 _session_context = contextvars.ContextVar[Session | None](
     "session_context", default=None
 )
@@ -117,12 +123,23 @@ def global_session():
         token = _session_context.set(s)
 
         try:
-            yield
+            yield s
         finally:
             _session_context.reset(token)
 
 
 async def aglobal_session():
+    """
+    Use this as a fastapi dependency to get a session that is shared across the request:
+
+    >>> APIRouter(
+    >>>     prefix="/internal/v1",
+    >>>     dependencies=[
+    >>>         Depends(aglobal_session),
+    >>>     ]
+    >>> )
+    """
+
     with SessionManager.get_instance().get_session() as s:
         token = _session_context.set(s)
 

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

@@ -137,6 +137,7 @@ class TypeIDType(types.TypeDecorator):
 
         return core_schema.json_or_python_schema(
             json_schema=from_uuid_schema,
+            # TODO in the the future we could add more exact types
             # metadata=core_schema.str_schema(
             #     pattern="^[0-9a-f]{24}$",
             #     min_length=24,

activemodel-0.8.0/playground/extract_comments.py

@@ -0,0 +1,33 @@
+import sqlalchemy as sa
+from sqlmodel import SQLModel, create_engine, Session
+
+
+def extract_comments(engine):
+    comments = {}
+    # Reflect all tables if needed; otherwise, rely on model metadata
+    for model in SQLModel.__subclasses__():
+        table = model.__table__
+        # Retrieve table-level comment
+        table_comment = table.comment
+        # Retrieve comments for each column
+        column_comments = {
+            col.name: col.comment for col in table.columns if col.comment
+        }
+        comments[table.name] = {
+            "table_comment": table_comment,
+            "column_comments": column_comments,
+        }
+    return comments
+
+
+if __name__ == "__main__":
+    # Adjust your connection string accordingly
+    engine = create_engine("sqlite:///database.db")
+    with Session(engine) as session:
+        comments = extract_comments(engine)
+        for table, data in comments.items():
+            print(f"Table: {table}")
+            print(f" - Table Comment: {data['table_comment']}")
+            print(" - Column Comments:")
+            for col, comment in data["column_comments"].items():
+                print(f"    {col}: {comment}")

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

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

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

@@ -15,7 +15,7 @@ class ExampleRecord(
     BaseModel, TimestampsMixin, TypeIDMixin(EXAMPLE_TABLE_PREFIX), table=True
 ):
     something: str | None = None
-    another_with_index: str | None = Field(index=True)
+    another_with_index: str | None = Field(index=True, default=None, unique=True)
 
 
 class AnotherExample(BaseModel, TypeIDMixin("myotherid"), table=True):

activemodel-0.8.0/test/orm_test.py

@@ -0,0 +1,111 @@
+"""
+Test core ORM functions
+"""
+
+from test.models import EXAMPLE_TABLE_PREFIX, AnotherExample, ExampleRecord
+
+
+def test_empty_count(create_and_wipe_database):
+    assert ExampleRecord.count() == 0
+
+
+def test_all_and_count(create_and_wipe_database):
+    AnotherExample().save()
+
+    records_to_create = 10
+
+    # create 10 example records
+    for i in range(records_to_create):
+        ExampleRecord().save()
+
+    assert ExampleRecord.count() == records_to_create
+
+    all_records = list(ExampleRecord.all())
+    assert len(all_records) == records_to_create
+
+    assert ExampleRecord.count() == records_to_create
+
+    record = all_records[0]
+    assert isinstance(record, ExampleRecord)
+
+
+def test_where_returns_expected(create_and_wipe_database):
+    # Create records with distinct "something" field values
+    ExampleRecord(something="hello").save()
+    ExampleRecord(something="world").save()
+    ExampleRecord(something="hello").save()
+
+    # Use the "where" convenience method to filter records
+    results = list(ExampleRecord.where(ExampleRecord.something == "hello").all())
+
+    # Expecting 2 records that match "hello"
+    assert len(results) == 2
+    for record in results:
+        assert record.something == "hello"
+
+
+def test_where_no_results(create_and_wipe_database):
+    # Create a record with a specific value
+    ExampleRecord(something="foo").save()
+
+    # Filter by a value that does not exist to get no results
+    result = ExampleRecord.where(ExampleRecord.something == "bar").first()
+    assert result is None
+
+
+def test_where_chaining(create_and_wipe_database):
+    # Save multiple records; using the same condition twice should be harmless
+    ExampleRecord(something="chain").save()
+    ExampleRecord(something="chain").save()
+    ExampleRecord(something="other").save()
+
+    # Chain where calls; in our implementation, chaining should work the same as a single call
+    query = (
+        ExampleRecord.where(ExampleRecord.something == "chain")
+        .where(ExampleRecord.something == "chain")
+        .all()
+    )
+    results = list(query)
+
+    # Expecting 2 records that match "chain" even after chaining the condition
+    assert len(results) == 2
+    for record in results:
+        assert record.something == "chain"
+
+
+def test_foreign_key():
+    field = ExampleRecord.foreign_key()
+    assert field.sa_type.prefix == EXAMPLE_TABLE_PREFIX
+
+
+def test_basic_query(create_and_wipe_database):
+    example = ExampleRecord(something="hi").save()
+    query = ExampleRecord.select().where(ExampleRecord.something == "hi")
+
+    query_as_str = str(query)
+    result = query.first()
+
+
+def test_query_count(create_and_wipe_database):
+    AnotherExample().save()
+
+    example = ExampleRecord(something="hi").save()
+    count = ExampleRecord.select().where(ExampleRecord.something == "hi").count()
+
+    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()
+
+    assert ExampleRecord.count() == 1
+
+    retrieved_example = ExampleRecord.find_or_create_by(another_with_index="key_123")
+
+    assert retrieved_example
+    assert retrieved_example.id == example.id

{activemodel-0.7.0 → activemodel-0.8.0}/test/serialization_test.py

@@ -17,24 +17,25 @@ class SubObject(PydanticBaseModel):
     value: int
 
 
-class ExampleWithJSON(
+class ExampleWithJSONB(
     BaseModel, PydanticJSONMixin, TypeIDMixin("json_test"), table=True
 ):
-    list_field: list[SubObject] = Field(sa_type=JSONB())
-    # list_with_generator: list[SubObject] = Field(sa_type=JSONB())
-    optional_list_field: list[SubObject] | None = Field(sa_type=JSONB(), default=None)
-    generic_list_field: list[dict] = Field(sa_type=JSONB())
-    object_field: SubObject = Field(sa_type=JSONB())
-    unstructured_field: dict = Field(sa_type=JSONB())
-    semi_structured_field: dict[str, str] = Field(sa_type=JSONB())
-    optional_object_field: SubObject | None = Field(sa_type=JSONB(), default=None)
+    list_field: list[SubObject] = Field(sa_type=JSONB)
+    # list_with_generator: list[SubObject] = Field(sa_type=JSONB)
+    optional_list_field: list[SubObject] | None = Field(sa_type=JSONB, default=None)
+    generic_list_field: list[dict] = Field(sa_type=JSONB)
+    object_field: SubObject = Field(sa_type=JSONB)
+    unstructured_field: dict = Field(sa_type=JSONB)
+    semi_structured_field: dict[str, str] = Field(sa_type=JSONB)
+    optional_object_field: SubObject | None = Field(sa_type=JSONB, default=None)
 
     normal_field: str | None = Field(default=None)
 
 
 def test_json_serialization(create_and_wipe_database):
     sub_object = SubObject(name="test", value=1)
-    example = ExampleWithJSON(
+
+    example = ExampleWithJSONB(
         list_field=[sub_object],
         # list_with_generator=(x for x in [sub_object]),
         generic_list_field=[{"one": "two", "three": 3, "four": [1, 2, 3]}],
@@ -46,7 +47,14 @@ def test_json_serialization(create_and_wipe_database):
         optional_object_field=sub_object,
     ).save()
 
-    fresh_example = ExampleWithJSON.get(example.id)
+    # make sure the types are preserved when saved
+    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
     assert isinstance(fresh_example.object_field, SubObject)

{activemodel-0.7.0 → activemodel-0.8.0}/test/typeid_test.py

@@ -38,21 +38,24 @@ def test_get_through_prefixed_uid_as_str():
         assert record is None
 
 
-def test_get_through_plain_uid_as_str():
+def test_get_through_plain_uid_as_str(create_and_wipe_database):
     type_uid = TypeID(prefix=TYPEID_PREFIX)
 
-    with temporary_tables():
-        # pass uid as string. Ex: '01942886-7afc-7129-8f57-db09137ed002'
-        record = ExampleWithId.get(str(type_uid.uuid))
-        assert record is None
+    # pass uid as string. Ex: '01942886-7afc-7129-8f57-db09137ed002'
+    record = ExampleWithId.get(str(type_uid.uuid))
+    assert record is None
 
 
-def test_get_through_plain_uid():
+def test_get_through_plain_uid(create_and_wipe_database):
     type_uid = TypeID(prefix=TYPEID_PREFIX)
 
-    with temporary_tables():
-        record = ExampleWithId.get(type_uid.uuid)
-        assert record is None
+    record = ExampleWithId.get(type_uid.uuid)
+    assert record is None
+
+
+# def test_non_primary_typeid_key():
+#     class NonPrimaryKeyExample(PydanticBaseModel, table=True):
+#         something: str | None = None
 
 
 # the wrapped test is probably overkill, but it's protecting against a weird edge case I was running into with fastapi

activemodel-0.7.0/activemodel/pytest/transaction.py

@@ -1,51 +0,0 @@
-from activemodel import SessionManager
-
-
-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
-    >>> pytest.fixture(scope="function", autouse=True)(database_reset_transaction)
-
-    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
-    """
-
-    engine = SessionManager.get_instance().get_engine()
-
-    with engine.begin() as connection:
-        transaction = connection.begin_nested()
-
-        SessionManager.get_instance().session_connection = connection
-
-        try:
-            yield
-        finally:
-            transaction.rollback()
-            # TODO is this necessary?
-            connection.close()
-
-
-# TODO unsure if this adds any value beyond the above approach
-# def database_reset_named_truncation():
-#     start_truncation_query = """
-#         BEGIN;
-#         SAVEPOINT test_truncation_savepoint;
-#     """
-
-#     raw_sql_exec(start_truncation_query)
-
-#     yield
-
-#     end_truncation_query = """
-#         ROLLBACK TO SAVEPOINT test_truncation_savepoint;
-#         RELEASE SAVEPOINT test_truncation_savepoint;
-#         ROLLBACK;
-#     """
-
-#     raw_sql_exec(end_truncation_query)

activemodel-0.7.0/test/orm_test.py

@@ -1,51 +0,0 @@
-"""
-Test core ORM functions
-"""
-
-from test.models import EXAMPLE_TABLE_PREFIX, AnotherExample, ExampleRecord
-
-
-def test_empty_count(create_and_wipe_database):
-    assert ExampleRecord.count() == 0
-
-
-def test_all_and_count(create_and_wipe_database):
-    AnotherExample().save()
-
-    records_to_create = 10
-
-    # create 10 example records
-    for i in range(records_to_create):
-        ExampleRecord().save()
-
-    assert ExampleRecord.count() == records_to_create
-
-    all_records = list(ExampleRecord.all())
-    assert len(all_records) == records_to_create
-
-    assert ExampleRecord.count() == records_to_create
-
-    record = all_records[0]
-    assert isinstance(record, ExampleRecord)
-
-
-def test_foreign_key():
-    field = ExampleRecord.foreign_key()
-    assert field.sa_type.prefix == EXAMPLE_TABLE_PREFIX
-
-
-def test_basic_query(create_and_wipe_database):
-    example = ExampleRecord(something="hi").save()
-    query = ExampleRecord.select().where(ExampleRecord.something == "hi")
-
-    query_as_str = str(query)
-    result = query.first()
-
-
-def test_query_count(create_and_wipe_database):
-    AnotherExample().save()
-
-    example = ExampleRecord(something="hi").save()
-    count = ExampleRecord.select().where(ExampleRecord.something == "hi").count()
-
-    assert count == 1