activemodel 0.9.0__tar.gz → 0.11.0__tar.gz

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

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.11.0](https://github.com/iloveitaly/activemodel/compare/v0.10.0...v0.11.0) (2025-04-05)
+
+
+### Features
+
+* add pydantic patch for TypeID schema serialization ([767726e](https://github.com/iloveitaly/activemodel/commit/767726eaf2a20f1c65162ba7d3a599495c83f721))
+* add typeid prefix to db field comments ([34e4574](https://github.com/iloveitaly/activemodel/commit/34e457488a6e59c4e7daf1d7495b59ac64bd7ea2))
+* render TypeIDType in plain old pydantic models ([8aa0a4d](https://github.com/iloveitaly/activemodel/commit/8aa0a4db51b425a60889064e723129041e418da5))
+
+
+### Bug Fixes
+
+* typing on upsert properly returns self ([8965113](https://github.com/iloveitaly/activemodel/commit/896511399c818e8a4a1c01ed324921e04073a279))
+
+
+### Documentation
+
+* add advanced SQLAlchemy tips to README.md ([c624ac0](https://github.com/iloveitaly/activemodel/commit/c624ac0712598d06759166ce9f91a37f40fefcfe))
+* update comments in session_manager to clarify usage ([e657a2e](https://github.com/iloveitaly/activemodel/commit/e657a2e5985be6f0770bf945fc062a05dcff8cc8))
+
+## [0.10.0](https://github.com/iloveitaly/activemodel/compare/v0.9.0...v0.10.0) (2025-04-01)
+
+
+### Features
+
+* add upsert method for PostgreSQL support in BaseModel ([d639de6](https://github.com/iloveitaly/activemodel/commit/d639de6cb498b72cd4b42422822c7d59ca6a646c))
+* prevent nested global sessions and add test ([3aca2cc](https://github.com/iloveitaly/activemodel/commit/3aca2ccadf3e029801d5e517f5e660af44564f73))
+* return upserted model and enhance upsert tests ([df2359a](https://github.com/iloveitaly/activemodel/commit/df2359a4ba8a00305bd3d5024b9789642b7b4718))
+
+
+### Bug Fixes
+
+* use sa_column default instead of sqlmodel ([37e299d](https://github.com/iloveitaly/activemodel/commit/37e299d43dcec7db2cdfd3bc3b572b31b3234f35))
+
+
+### Documentation
+
+* enhance docstrings in BaseModel for clarity ([12a5dee](https://github.com/iloveitaly/activemodel/commit/12a5deec1ee2480410bbad9250b253991dd12d86))
+
 ## [0.9.0](https://github.com/iloveitaly/activemodel/compare/v0.8.0...v0.9.0) (2025-03-26)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activemodel
-Version: 0.9.0
+Version: 0.11.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>
@@ -110,14 +110,14 @@ index 0d07420..a63631c 100644
  # Use forward slashes (/) also on windows to provide an os agnostic path
 -script_location = .
 +script_location = migrations
- 
+
  # template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
  # Uncomment the line below if you want the files to be prepended with date and time
  # see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
  # for all available tokens
  # file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
 +file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(rev)s_%%(slug)s
- 
+
  # sys.path path, will be prepended to sys.path if present.
  # defaults to the current working directory.
 diff --git i/test/migrations/env.py w/test/migrations/env.py
@@ -129,12 +129,12 @@ index 36112a3..a1e15c2 100644
 +# isort: off
 +
  from logging.config import fileConfig
- 
+
  from sqlalchemy import engine_from_config
 @@ -14,11 +17,17 @@ config = context.config
  if config.config_file_name is not None:
      fileConfig(config.config_file_name)
- 
+
 +from sqlmodel import SQLModel
 +from test.models import *
 +from test.utils import database_url
@@ -147,7 +147,7 @@ index 36112a3..a1e15c2 100644
  # target_metadata = mymodel.Base.metadata
 -target_metadata = None
 +target_metadata = SQLModel.metadata
- 
+
  # other values from the config, defined by the needs of env.py,
  # can be acquired:
 diff --git i/test/migrations/script.py.mako w/test/migrations/script.py.mako
@@ -155,13 +155,13 @@ index fbc4b07..9dc78bb 100644
 --- i/test/migrations/script.py.mako
 +++ w/test/migrations/script.py.mako
 @@ -9,6 +9,8 @@ from typing import Sequence, Union
- 
+
  from alembic import op
  import sqlalchemy as sa
 +import sqlmodel
 +import activemodel
  ${imports if imports else ""}
- 
+
  # revision identifiers, used by Alembic.
 ```
 
@@ -178,7 +178,7 @@ This tool is added to all `BaseModel`s and makes it easy to write SQL queries. S
 
 ### Easy Database Sessions
 
-I hate the idea f 
+I hate the idea f
 
 * Behavior should be intuitive and easy to understand. If you run `save()`, it should save, not stick the save in a transaction.
 * Don't worry about dead sessions. This makes it easy to lazy-load computed properties and largely eliminates the need to think about database sessions.
@@ -186,7 +186,7 @@ I hate the idea f
 There are a couple of thorny problems we need to solve for here:
 
 * In-memory fastapi servers are not the same as a uvicorn server, which is threaded *and* uses some sort of threadpool model for handling async requests. I don't claim to understand the entire implementation. For global DB session state (a) we can't use global variables (b) we can't use thread-local variables.
-* 
+*
 
 https://github.com/tomwojcik/starlette-context
 
@@ -202,8 +202,11 @@ https://github.com/tomwojcik/starlette-context
 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` 
+* `ModelClass.relationship_name.property.local_columns`
 * Get cached fields from a model `object_state(instance).dict.get(field_name)`
+* Set the value on a field, without marking it as dirty `attributes.set_committed_value(instance, field_name, val)`
+* Is a model dirty `instance_state(instance).modified`
+* `select(Table).outerjoin??` won't work in a ipython session, but `Table.__table__.outerjoin??` will. `__table__` is a reference to the underlying SQLAlchemy table record.
 
 ### TypeID
 

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

@@ -95,14 +95,14 @@ index 0d07420..a63631c 100644
  # Use forward slashes (/) also on windows to provide an os agnostic path
 -script_location = .
 +script_location = migrations
- 
+
  # template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
  # Uncomment the line below if you want the files to be prepended with date and time
  # see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
  # for all available tokens
  # file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
 +file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(rev)s_%%(slug)s
- 
+
  # sys.path path, will be prepended to sys.path if present.
  # defaults to the current working directory.
 diff --git i/test/migrations/env.py w/test/migrations/env.py
@@ -114,12 +114,12 @@ index 36112a3..a1e15c2 100644
 +# isort: off
 +
  from logging.config import fileConfig
- 
+
  from sqlalchemy import engine_from_config
 @@ -14,11 +17,17 @@ config = context.config
  if config.config_file_name is not None:
      fileConfig(config.config_file_name)
- 
+
 +from sqlmodel import SQLModel
 +from test.models import *
 +from test.utils import database_url
@@ -132,7 +132,7 @@ index 36112a3..a1e15c2 100644
  # target_metadata = mymodel.Base.metadata
 -target_metadata = None
 +target_metadata = SQLModel.metadata
- 
+
  # other values from the config, defined by the needs of env.py,
  # can be acquired:
 diff --git i/test/migrations/script.py.mako w/test/migrations/script.py.mako
@@ -140,13 +140,13 @@ index fbc4b07..9dc78bb 100644
 --- i/test/migrations/script.py.mako
 +++ w/test/migrations/script.py.mako
 @@ -9,6 +9,8 @@ from typing import Sequence, Union
- 
+
  from alembic import op
  import sqlalchemy as sa
 +import sqlmodel
 +import activemodel
  ${imports if imports else ""}
- 
+
  # revision identifiers, used by Alembic.
 ```
 
@@ -163,7 +163,7 @@ This tool is added to all `BaseModel`s and makes it easy to write SQL queries. S
 
 ### Easy Database Sessions
 
-I hate the idea f 
+I hate the idea f
 
 * Behavior should be intuitive and easy to understand. If you run `save()`, it should save, not stick the save in a transaction.
 * Don't worry about dead sessions. This makes it easy to lazy-load computed properties and largely eliminates the need to think about database sessions.
@@ -171,7 +171,7 @@ I hate the idea f
 There are a couple of thorny problems we need to solve for here:
 
 * In-memory fastapi servers are not the same as a uvicorn server, which is threaded *and* uses some sort of threadpool model for handling async requests. I don't claim to understand the entire implementation. For global DB session state (a) we can't use global variables (b) we can't use thread-local variables.
-* 
+*
 
 https://github.com/tomwojcik/starlette-context
 
@@ -187,8 +187,11 @@ https://github.com/tomwojcik/starlette-context
 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` 
+* `ModelClass.relationship_name.property.local_columns`
 * Get cached fields from a model `object_state(instance).dict.get(field_name)`
+* Set the value on a field, without marking it as dirty `attributes.set_committed_value(instance, field_name, val)`
+* Is a model dirty `instance_state(instance).modified`
+* `select(Table).outerjoin??` won't work in a ipython session, but `Table.__table__.outerjoin??` will. `__table__` is a reference to the underlying SQLAlchemy table record.
 
 ### TypeID
 

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

@@ -4,11 +4,11 @@ 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 sqlalchemy.orm.attributes import flag_modified as sa_flag_modified
+from sqlalchemy.orm.base import instance_state
 from sqlmodel import Column, Field, Session, SQLModel, inspect, select
 from typeid import TypeID
 
@@ -19,6 +19,7 @@ from . import get_column_from_field_patch  # noqa: F401
 from .logger import logger
 from .query_wrapper import QueryWrapper
 from .session_manager import get_session
+from sqlalchemy.dialects.postgresql import insert as postgres_insert
 
 POSTGRES_INDEXES_NAMING_CONVENTION = {
     "ix": "%(column_0_label)s_idx",
@@ -137,8 +138,15 @@ class BaseModel(SQLModel):
                 cls.__table_args__ = {"comment": doc}
             elif isinstance(table_args, dict):
                 table_args.setdefault("comment", doc)
+            elif isinstance(table_args, tuple):
+                # If it's a tuple, we need to convert it to a list and add the comment
+                table_args = list(table_args)
+                table_args.append({"comment": doc})
+                cls.__table_args__ = tuple(table_args)
             else:
-                raise ValueError("Unexpected __table_args__ type")
+                raise ValueError(
+                    f"Unexpected __table_args__ type {type(table_args)}, expected dictionary."
+                )
 
     # TODO no type check decorator here
     @declared_attr
@@ -163,8 +171,10 @@ class BaseModel(SQLModel):
         """
         Returns a `Field` object referencing the foreign key of the model.
 
-        >>> other_model_id: int
-        >>> other_model = OtherModel.foreign_key()
+        Helps quickly build a many-to-one or one-to-one relationship.
+
+        >>> other_model_id: int = OtherModel.foreign_key()
+        >>> other_model = Relationship()
         """
 
         field_options = {"nullable": False} | kwargs
@@ -186,6 +196,43 @@ class BaseModel(SQLModel):
         "convenience method to avoid having to write .select().where() in order to add conditions"
         return cls.select().where(*args)
 
+    # TODO we should add an instance method for this as well
+    @classmethod
+    def upsert(
+        cls,
+        data: dict[str, t.Any],
+        unique_by: str | list[str],
+    ) -> t.Self:
+        """
+        This method will insert a new record if it doesn't exist, or update the existing record if it does.
+
+        It uses SQLAlchemy's `on_conflict_do_update` and does not yet support MySQL. Some implementation details below.
+
+        ---
+
+        - `index_elements=["name"]`: Specifies the column(s) to check for conflicts (e.g., unique constraint or index). If a row with the same "name" exists, it triggers the update instead of an insert.
+        - `values`: Defines the data to insert (e.g., `name="example", value=123`). If no conflict occurs, this data is inserted as a new row.
+
+        The `set_` parameter (e.g., `set_=dict(value=123)`) then dictates what gets updated on conflict, overriding matching fields in `values` if specified.
+        """
+        index_elements = [unique_by] if isinstance(unique_by, str) else unique_by
+
+        stmt = (
+            postgres_insert(cls)
+            .values(**data)
+            .on_conflict_do_update(index_elements=index_elements, set_=data)
+            .returning(cls)
+        )
+
+        with get_session() as session:
+            result = session.exec(stmt)
+            session.commit()
+
+            # TODO this is so ugly:
+            result = result.one()[0]
+
+        return result
+
     def delete(self):
         with get_session() as session:
             if old_session := Session.object_session(self):
@@ -256,9 +303,9 @@ class BaseModel(SQLModel):
     def is_new(self) -> bool:
         return not self._sa_instance_state.has_identity
 
-    def flag_modified(self, *args: str):
+    def flag_modified(self, *args: str) -> None:
         """
-        Flag one or more fields as modified. Useful for marking a field containing sub-objects as modified.
+        Flag one or more fields as modified/mutated/dirty. Useful for marking a field containing sub-objects as modified.
 
         Will throw an error if an invalid field is passed.
         """

activemodel-0.11.0/activemodel/mixins/typeid.py

@@ -0,0 +1,41 @@
+from sqlmodel import Column, Field
+from typeid import TypeID
+
+from activemodel.types import typeid_patch  # noqa: F401
+from activemodel.types.typeid import TypeIDType
+
+# global list of prefixes to ensure uniqueness
+_prefixes: list[str] = []
+
+
+def TypeIDMixin(prefix: str):
+    """
+    Mixin that adds a TypeID primary key field to a SQLModel. Specify the prefix to use for the TypeID.
+    """
+
+    # make sure duplicate prefixes are not used!
+    # NOTE this will cause issues on code reloads
+    assert prefix
+    assert prefix not in _prefixes, (
+        f"prefix {prefix} already exists, pick a different one"
+    )
+
+    class _TypeIDMixin:
+        __abstract__ = True
+
+        id: TypeIDType = Field(
+            sa_column=Column(
+                TypeIDType(prefix),
+                primary_key=True,
+                nullable=False,
+                # default on the sa_column level ensures that an ID is generated when creating a new record, even when
+                # raw SQLAlchemy operations are used instead of activemodel operations
+                default=lambda: TypeID(prefix),
+            ),
+            # add a database comment to document the prefix, since it's not stored in the DB otherwise
+            description=f"TypeID with prefix: {prefix}",
+        )
+
+    _prefixes.append(prefix)
+
+    return _TypeIDMixin

{activemodel-0.9.0 → activemodel-0.11.0}/activemodel/session_manager.py

@@ -47,7 +47,7 @@ class SessionManager:
     "singleton instance of SessionManager"
 
     session_connection: Connection | None
-    "optionally specify a specific session connection to use for all get_session() calls, useful for testing"
+    "optionally specify a specific session connection to use for all get_session() calls, useful for testing and migrations"
 
     @classmethod
     def get_instance(cls, database_url: str | None = None) -> "SessionManager":
@@ -72,6 +72,7 @@ class SessionManager:
                 self._database_url,
                 # NOTE very important! This enables pydantic models to be serialized for JSONB columns
                 json_serializer=_serialize_pydantic_model,
+                # TODO move to a constants area
                 echo=config("ACTIVEMODEL_LOG_SQL", cast=bool, default=False),
                 # https://docs.sqlalchemy.org/en/20/core/pooling.html#disconnect-handling-pessimistic
                 pool_pre_ping=True,
@@ -81,6 +82,8 @@ class SessionManager:
         return self._engine
 
     def get_session(self):
+        "get a new database session, respecting any globally set sessions"
+
         if gsession := _session_context.get():
 
             @contextlib.contextmanager
@@ -102,23 +105,40 @@ def init(database_url: str):
 
 
 def get_engine():
+    "alias to get the database engine without importing SessionManager"
     return SessionManager.get_instance().get_engine()
 
 
 def get_session():
+    "alias to get a database session without importing SessionManager"
     return SessionManager.get_instance().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
 )
+"""
+This is a VERY important ContextVar, it sets a global session to be used across all ActiveModel operations by default
+and ensures get_session() uses this session as well.
+
+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.
+"""
 
 
 @contextlib.contextmanager
 def global_session():
+    """
+    Generate a session shared across all activemodel calls.
+
+    Alternatively, you can pass a session to use globally into the context manager, which is helpful for migrations
+    and testing.
+    """
+
+    if _session_context.get() is not None:
+        raise RuntimeError("global session already set")
+
     with SessionManager.get_instance().get_session() as s:
         token = _session_context.set(s)
 
@@ -140,6 +160,9 @@ async def aglobal_session():
     >>> )
     """
 
+    if _session_context.get() is not None:
+        raise RuntimeError("global session already set")
+
     with SessionManager.get_instance().get_session() as s:
         token = _session_context.set(s)
 

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

@@ -2,7 +2,6 @@
 Lifted from: https://github.com/akhundMurad/typeid-python/blob/main/examples/sqlalchemy.py
 """
 
-from typing import Optional
 from uuid import UUID
 
 from pydantic import (
@@ -19,25 +18,32 @@ from activemodel.errors import TypeIDValidationError
 class TypeIDType(types.TypeDecorator):
     """
     A SQLAlchemy TypeDecorator that allows storing TypeIDs in the database.
-    The prefix will not be persisted, instead the database-native UUID field will be used.
-    At retrieval time a TypeID will be constructed based on the configured prefix and the
-    UUID value from the database.
-
-    Usage:
-        # will result in TypeIDs such as "user_01h45ytscbebyvny4gc8cr8ma2"
-        id = mapped_column(
-            TypeIDType("user"),
-            primary_key=True,
-            default=lambda: TypeID("user")
-        )
+
+    The prefix will not be persisted to the database, instead the database-native UUID field will be used.
+    At retrieval time a TypeID will be constructed (in python) based on the configured prefix and the UUID
+    value from the database.
+
+    For example:
+
+    >>> id = mapped_column(
+    >>>     TypeIDType("user"),
+    >>>     primary_key=True,
+    >>>     default=lambda: TypeID("user")
+    >>> )
+
+    Will result in TypeIDs such as "user_01h45ytscbebyvny4gc8cr8ma2". There's a mixin provided to make it easy
+    to add a `id` pk field to your model with a specific prefix.
     """
 
+    # TODO are we sure we wouldn't use TypeID here?
     impl = types.Uuid
+    # TODO why the types version?
     # impl = uuid.UUID
+
     cache_ok = True
-    prefix: Optional[str] = None
+    prefix: str
 
-    def __init__(self, prefix: Optional[str], *args, **kwargs):
+    def __init__(self, prefix: str, *args, **kwargs):
         self.prefix = prefix
         super().__init__(*args, **kwargs)
 
@@ -90,6 +96,8 @@ class TypeIDType(types.TypeDecorator):
         raise ValueError("Unexpected input type")
 
     def process_result_value(self, value, dialect):
+        "convert a raw UUID, without a prefix, to a TypeID with the correct prefix"
+
         if value is None:
             return None
 
@@ -123,13 +131,19 @@ class TypeIDType(types.TypeDecorator):
         - https://github.com/alice-biometrics/petisco/blob/b01ef1b84949d156f73919e126ed77aa8e0b48dd/petisco/base/domain/model/uuid.py#L50
         """
 
+        def convert_from_string(value: str | TypeID) -> TypeID:
+            if isinstance(value, TypeID):
+                return value
+
+            return TypeID.from_string(value)
+
         from_uuid_schema = core_schema.chain_schema(
             [
                 # TODO not sure how this is different from the UUID schema, should try it  out.
                 # core_schema.is_instance_schema(TypeID),
                 # core_schema.uuid_schema(),
                 core_schema.no_info_plain_validator_function(
-                    TypeID.from_string,
+                    convert_from_string,
                     json_schema_input_schema=core_schema.str_schema(),
                 ),
             ]
@@ -151,11 +165,10 @@ class TypeIDType(types.TypeDecorator):
             #     )
             # },
             python_schema=core_schema.union_schema([from_uuid_schema]),
-            serialization=core_schema.plain_serializer_function_ser_schema(
-                lambda x: str(x)
-            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(str),
         )
 
+    # TODO I have a feeling that the `serialization` param in the above method solves this for us.
     @classmethod
     def __get_pydantic_json_schema__(
         cls, schema: CoreSchema, handler: GetJsonSchemaHandler
@@ -164,18 +177,18 @@ class TypeIDType(types.TypeDecorator):
         Called when generating the openapi schema. This overrides the `function-plain` type which
         is generated by the `no_info_plain_validator_function`.
 
-        This logis seems to be a hot part of the codebase, so I'd expect this to break as pydantic
+        This logic seems to be a hot part of the codebase, so I'd expect this to break as pydantic
         fastapi continue to evolve.
 
         Note that this method can return multiple types. A return value can be as simple as:
 
-        {"type": "string"}
+        >>> {"type": "string"}
 
         Or, you could return a more specific JSON schema type:
 
-        core_schema.uuid_schema()
+        >>> core_schema.uuid_schema()
 
-        The problem with using something like uuid_schema is the specifi patterns
+        The problem with using something like uuid_schema is the specific patterns
 
         https://github.com/BeanieODM/beanie/blob/2190cd9d1fc047af477d5e6897cc283799f54064/beanie/odm/fields.py#L153
         """

activemodel-0.11.0/activemodel/types/typeid_patch.py

@@ -0,0 +1,22 @@
+from typing import Any, Type
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+from typeid import TypeID
+
+
+@classmethod
+def get_pydantic_core_schema(
+    cls: Type[TypeID], source_type: Any, handler: GetCoreSchemaHandler
+) -> CoreSchema:
+    return core_schema.union_schema(
+        [
+            core_schema.str_schema(),
+            core_schema.is_instance_schema(cls),
+        ],
+        serialization=core_schema.plain_serializer_function_ser_schema(str),
+    )
+
+
+TypeID.__get_pydantic_core_schema__ = get_pydantic_core_schema

activemodel-0.11.0/playground/alternative_typeid_mixin.py

@@ -0,0 +1,22 @@
+# TODO not sure if I love the idea of a dynamic class for each mixin as used above
+#      may give this approach another shot in the future
+
+
+class TypeIDMixin2:
+    """
+    Mixin class that adds a TypeID primary key to models.
+
+
+    >>>    class MyModel(BaseModel, TypeIDMixin, prefix="xyz", table=True):
+    >>>        name: str
+
+    Will automatically have an `id` field with prefix "xyz"
+    """
+
+    def __init_subclass__(cls, *, prefix: str, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        cls.id: uuid.UUID = Field(
+            sa_column=Column(TypeIDType(prefix), primary_key=True),
+            default_factory=lambda: TypeID(prefix),
+        )

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

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

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

@@ -1,4 +1,5 @@
 from pydantic import computed_field
+from sqlalchemy import UniqueConstraint
 from sqlmodel import Column, Field, Integer, Relationship
 
 from activemodel import BaseModel
@@ -42,3 +43,15 @@ class ExampleWithComputedProperty(
     @property
     def special_note(self) -> str:
         return f"SPECIAL: {self.another_example.note}"
+
+
+class UpsertTestModel(BaseModel, TypeIDMixin("upsert_test"), table=True):
+    """Test model for upsert operations"""
+
+    name: str = Field(unique=True)
+    category: str = Field(index=True)
+    value: int = Field(default=0)
+    description: str | None = Field(default=None)
+
+    # Add a composite unique constraint for the multiple unique field test
+    __table_args__ = (UniqueConstraint("name", "category", name="compound_constraint"),)