activemodel 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

activemodel/__init__.py

@@ -1,6 +1,2 @@
 from .base_model import BaseModel
-from .query_wrapper import QueryWrapper
-from .timestamps import TimestampMixin
-
-# TODO need a way to specify the session generator
-# TODO need a way to specify the session generator
+from .session_manager import SessionManager, get_engine, get_session, init

activemodel/_session_manager.py

@@ -0,0 +1,153 @@
+"""
+Adapted from: https://github.com/fastapiutils/fastapi-utils/blob/master/fastapi_utils/session.py
+"""
+
+from contextlib import contextmanager
+
+import sqlalchemy as sa
+from sqlalchemy.orm import Session
+
+
+class FastSessionMaker:
+    """
+    A convenience class for managing a (cached) sqlalchemy ORM engine and sessionmaker.
+
+    Intended for use creating ORM sessions injected into endpoint functions by FastAPI.
+    """
+
+    def __init__(self, database_uri: str):
+        """
+        `database_uri` should be any sqlalchemy-compatible database URI.
+
+        In particular, `sqlalchemy.create_engine(database_uri)` should work to create an engine.
+
+        Typically, this would look like:
+
+            "<scheme>://<user>:<password>@<host>:<port>/<database>"
+
+        A concrete example looks like "postgresql://db_user:password@db:5432/app"
+        """
+        self.database_uri = database_uri
+
+        self._cached_engine: sa.engine.Engine | None = None
+        self._cached_sessionmaker: sa.orm.sessionmaker | None = None
+
+    @property
+    def cached_engine(self) -> sa.engine.Engine:
+        """
+        Returns a lazily-cached sqlalchemy engine for the instance's database_uri.
+        """
+        engine = self._cached_engine
+        if engine is None:
+            engine = self.get_new_engine()
+            self._cached_engine = engine
+        return engine
+
+    @property
+    def cached_sessionmaker(self) -> sa.orm.sessionmaker:
+        """
+        Returns a lazily-cached sqlalchemy sessionmaker using the instance's (lazily-cached) engine.
+        """
+        sessionmaker = self._cached_sessionmaker
+        if sessionmaker is None:
+            sessionmaker = self.get_new_sessionmaker(self.cached_engine)
+            self._cached_sessionmaker = sessionmaker
+        return sessionmaker
+
+    def get_new_engine(self) -> sa.engine.Engine:
+        """
+        Returns a new sqlalchemy engine using the instance's database_uri.
+        """
+        return get_engine(self.database_uri)
+
+    def get_new_sessionmaker(
+        self, engine: sa.engine.Engine | None
+    ) -> sa.orm.sessionmaker:
+        """
+        Returns a new sessionmaker for the provided sqlalchemy engine. If no engine is provided, the
+        instance's (lazily-cached) engine is used.
+        """
+        engine = engine or self.cached_engine
+        return get_sessionmaker_for_engine(engine)
+
+    def get_db(self) -> Iterator[Session]:
+        """
+        A generator function that yields a sqlalchemy orm session and cleans up the session once resumed after yielding.
+
+        Can be used directly as a context-manager FastAPI dependency, or yielded from inside a separate dependency.
+        """
+        yield from _get_db(self.cached_sessionmaker)
+
+    @contextmanager
+    def context_session(self) -> Iterator[Session]:
+        """
+        A context-manager wrapped version of the `get_db` method.
+
+        This makes it possible to get a context-managed orm session for the relevant database_uri without
+        needing to rely on FastAPI's dependency injection.
+
+        Usage looks like:
+
+            session_maker = FastAPISessionMaker(database_uri)
+            with session_maker.context_session() as session:
+                session.query(...)
+                ...
+        """
+        yield from self.get_db()
+
+    def reset_cache(self) -> None:
+        """
+        Resets the engine and sessionmaker caches.
+
+        After calling this method, the next time you try to use the cached engine or sessionmaker,
+        new ones will be created.
+        """
+        self._cached_engine = None
+        self._cached_sessionmaker = None
+
+
+def get_engine(uri: str) -> sa.engine.Engine:
+    """
+    Returns a sqlalchemy engine with pool_pre_ping enabled.
+
+    This function may be updated over time to reflect recommended engine configuration for use with FastAPI.
+    """
+    return sa.create_engine(uri, pool_pre_ping=True)
+
+
+def get_sessionmaker_for_engine(engine: sa.engine.Engine) -> sa.orm.sessionmaker:
+    """
+    Returns a sqlalchemy sessionmaker for the provided engine with recommended configuration settings.
+
+    This function may be updated over time to reflect recommended sessionmaker configuration for use with FastAPI.
+    """
+    return sa.orm.sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+@contextmanager
+def context_session(engine: sa.engine.Engine) -> Iterator[Session]:
+    """
+    This contextmanager yields a managed session for the provided engine.
+
+    Usage is similar to `FastAPISessionMaker.context_session`, except that you have to provide the engine to use.
+
+    A new sessionmaker is created for each call, so the FastAPISessionMaker.context_session
+    method may be preferable in performance-sensitive contexts.
+    """
+    sessionmaker = get_sessionmaker_for_engine(engine)
+    yield from _get_db(sessionmaker)
+
+
+def _get_db(sessionmaker: sa.orm.sessionmaker) -> Iterator[Session]:
+    """
+    A generator function that yields an ORM session using the provided sessionmaker, and cleans it up when resumed.
+    """
+    session = sessionmaker()
+    try:
+        yield session
+        session.commit()
+    except Exception as exc:
+        session.rollback()
+        raise exc
+    finally:
+        session.close()

activemodel/base_model.py

@@ -1,41 +1,102 @@
 import json
 import typing as t
+from contextlib import contextmanager
 
 import pydash
 import sqlalchemy as sa
-from sqlalchemy.orm import declared_attr
-from sqlmodel import Session, SQLModel
+import sqlmodel as sm
+from sqlalchemy import Connection, event
+from sqlalchemy.orm import Mapper, declared_attr
+from sqlmodel import Session, SQLModel, select
+from typeid import TypeID
 
+from .logger import logger
 from .query_wrapper import QueryWrapper
+from .session_manager import get_session
 
 
-class BaseModel(SQLModel):
+# TODO this does not seem to work with the latest 2.9.x pydantic and sqlmodel
+# https://github.com/SE-Sustainability-OSS/ecodev-core/blob/main/ecodev_core/sqlmodel_utils.py
+class SQLModelWithValidation(SQLModel):
     """
-    Base model class to inherit from so we can hate python less
-
-    https://github.com/woofz/sqlmodel-basecrud/blob/main/sqlmodel_basecrud/basecrud.py
+    Helper class to ease validation in SQLModel classes with table=True
     """
 
-    # TODO implement actually calling these hooks
-
-    def before_delete(self):
-        pass
+    @classmethod
+    def create(cls, **kwargs):
+        """
+        Forces validation to take place, even for SQLModel classes with table=True
+        """
+        return cls(**cls.__bases__[0](**kwargs).model_dump())
 
-    def after_delete(self):
-        pass
 
-    def before_save(self):
-        pass
+class BaseModel(SQLModel):
+    """
+    Base model class to inherit from so we can hate python less
 
-    def after_save(self):
-        pass
+    https://github.com/woofz/sqlmodel-basecrud/blob/main/sqlmodel_basecrud/basecrud.py
 
-    def before_update(self):
-        pass
+    {before,after} hooks are modeled after Rails.
+    """
 
-    def after_update(self):
-        pass
+    # TODO implement actually calling these hooks
 
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        "Setup automatic sqlalchemy lifecycle events for the class"
+
+        super().__init_subclass__(**kwargs)
+
+        def event_wrapper(method_name: str):
+            """
+            This does smart heavy lifting for us to make sqlalchemy lifecycle events nicer to work with:
+
+            * Passes the target first to the lifecycle method, so it feels like an instance method
+            * Allows as little as a single positional argument, so methods can be simple
+            * Removes the need for decorators or anything fancy on the subclass
+            """
+
+            def wrapper(mapper: Mapper, connection: Connection, target: BaseModel):
+                if hasattr(cls, method_name):
+                    method = getattr(cls, method_name)
+
+                    if callable(method):
+                        arg_count = method.__code__.co_argcount
+
+                        if arg_count == 1:  # Just self/cls
+                            method(target)
+                        elif arg_count == 2:  # Self, mapper
+                            method(target, mapper)
+                        elif arg_count == 3:  # Full signature
+                            method(target, mapper, connection)
+                        else:
+                            raise TypeError(
+                                f"Method {method_name} must accept either 1 to 3 arguments, got {arg_count}"
+                            )
+                    else:
+                        logger.warning(
+                            "SQLModel lifecycle hook found, but not callable hook_name=%s",
+                            method_name,
+                        )
+
+            return wrapper
+
+        event.listen(cls, "before_insert", event_wrapper("before_insert"))
+        event.listen(cls, "before_update", event_wrapper("before_update"))
+
+        # before_save maps to two type of events
+        event.listen(cls, "before_insert", event_wrapper("before_save"))
+        event.listen(cls, "before_update", event_wrapper("before_save"))
+
+        # now, let's handle after_* variants
+        event.listen(cls, "after_insert", event_wrapper("after_insert"))
+        event.listen(cls, "after_update", event_wrapper("after_update"))
+
+        # after_save maps to two type of events
+        event.listen(cls, "after_insert", event_wrapper("after_save"))
+        event.listen(cls, "after_update", event_wrapper("after_save"))
+
+    # TODO no type check decorator here
     @declared_attr
     def __tablename__(cls) -> str:
         """
@@ -55,51 +116,79 @@ class BaseModel(SQLModel):
         return QueryWrapper[cls](cls, *args)
 
     def save(self):
-        old_session = Session.object_session(self)
         with get_session() as session:
-            if old_session:
+            if old_session := Session.object_session(self):
                 # I was running into an issue where the object was already
                 # associated with a session, but the session had been closed,
                 # to get around this, you need to remove it from the old one,
                 # then add it to the new one (below)
                 old_session.expunge(self)
 
-            self.before_update()
-            # self.before_save()
-
             session.add(self)
+            # NOTE very important method! This triggers sqlalchemy lifecycle hooks automatically
             session.commit()
             session.refresh(self)
 
-            self.after_update()
-            # self.after_save()
-
-            return self
+        return self
 
-            # except IntegrityError:
-            #     log.quiet(f"{self} already exists in the database.")
-            #     session.rollback()
+        # except IntegrityError:
+        #     log.quiet(f"{self} already exists in the database.")
+        #     session.rollback()
 
     # TODO shouldn't this be handled by pydantic?
     def json(self, **kwargs):
         return json.dumps(self.dict(), default=str, **kwargs)
 
+    # TODO should move this to the wrapper
     @classmethod
-    def count(cls):
+    def count(cls) -> int:
         """
         Returns the number of records in the database.
         """
-        # TODO should move this to the wrapper
-        with get_session() as session:
-            query = sql.select(sql.func.count()).select_from(cls)
-            return session.exec(query).one()
+        return get_session().exec(sm.select(sm.func.count()).select_from(cls)).one()
+
+    # TODO throw an error if this field is set on the model
+    def is_new(self):
+        return not self._sa_instance_state.has_identity
+
+    @classmethod
+    def find_or_create_by(cls, **kwargs):
+        """
+        Find record or create it with the passed args if it doesn't exist.
+        """
+
+        result = cls.get(**kwargs)
+
+        if result:
+            return result
+
+        new_model = cls(**kwargs)
+        new_model.save()
+
+        return new_model
+
+    @classmethod
+    def find_or_initialize_by(cls, **kwargs):
+        """
+        Unfortunately, unlike ruby, python does not have a great lambda story. This makes writing convenience methods
+        like this a bit more difficult.
+        """
+
+        result = cls.get(**kwargs)
+
+        if result:
+            return result
+
+        new_model = cls(**kwargs)
+        return new_model
 
     # 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
     # TODO can we pass the generic of the superclass in?
     @classmethod
-    def get(cls, *args: sa.BinaryExpression, **kwargs: t.Any):
+    # def get(cls, *args: sa.BinaryExpression, **kwargs: t.Any):
+    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.
         """
@@ -109,15 +198,17 @@ class BaseModel(SQLModel):
             # TODO id is hardcoded, not good! Need to dynamically pick the best uid field
             kwargs["id"] = args[0]
             args = []
+        elif len(args) == 1 and isinstance(args[0], TypeID):
+            kwargs["id"] = args[0]
+            args = []
 
-        statement = sql.select(cls).filter(*args).filter_by(**kwargs)
-        with get_session() as session:
-            return session.exec(statement).first()
+        statement = select(cls).filter(*args).filter_by(**kwargs)
+        return get_session().exec(statement).first()
 
     @classmethod
     def all(cls):
         with get_session() as session:
-            results = session.exec(sql.select(cls))
+            results = session.exec(sa.sql.select(cls))
 
             # TODO do we need this or can we just return results?
             for result in results:

activemodel/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger(__name__)

activemodel/mixins/__init__.py

@@ -0,0 +1,2 @@
+from .timestamps import TimestampsMixin
+from .typeid import TypeIDMixin

activemodel/{timestamps.py → mixins/timestamps.py}

@@ -1,10 +1,9 @@
 from datetime import datetime
 
 import sqlalchemy as sa
-
-# TODO raw sql https://github.com/tiangolo/sqlmodel/discussions/772
 from sqlmodel import Field
 
+# TODO raw sql https://github.com/tiangolo/sqlmodel/discussions/772
 # @classmethod
 # def select(cls):
 #     with get_session() as session:
@@ -14,11 +13,11 @@ from sqlmodel import Field
 #             yield result
 
 
-class TimestampMixin:
+class TimestampsMixin:
     """
     Simple created at and updated at timestamps. Mix them into your model:
 
-    >>> class MyModel(TimestampMixin, SQLModel):
+    >>> class MyModel(TimestampsMixin, SQLModel):
     >>>    pass
 
     Originally pulled from: https://github.com/tiangolo/sqlmodel/issues/252

activemodel/mixins/typeid.py

@@ -0,0 +1,36 @@
+import uuid
+
+from sqlmodel import Column, Field
+from typeid import TypeID
+
+from activemodel.types.typeid import TypeIDType
+
+
+def TypeIDMixin(prefix: str):
+    class _TypeIDMixin:
+        id: uuid.UUID = Field(
+            sa_column=Column(TypeIDType(prefix), primary_key=True),
+            default_factory=lambda: TypeID(prefix),
+        )
+
+    return _TypeIDMixin
+
+
+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/pytest/__init__.py

@@ -0,0 +1,2 @@
+from .transaction import database_reset_transaction
+from .truncate import database_reset_truncate

activemodel/pytest/transaction.py

@@ -0,0 +1,51 @@
+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/pytest/truncate.py

@@ -0,0 +1,46 @@
+from sqlmodel import SQLModel
+
+from ..logger import logger
+from ..session_manager import get_engine
+
+
+def database_reset_truncate():
+    """
+    Transaction is most likely the better way to go, but there are some scenarios where the session override
+    logic does not work properly and you need to truncate tables back to their original state.
+
+    Here's how to do this once at the start of the test:
+
+    >>> from activemodel.pytest import database_reset_truncation
+    >>> def pytest_configure(config):
+    >>> 	database_reset_truncation()
+
+    Or, if you want to use this as a fixture:
+
+    >>> pytest.fixture(scope="function")(database_reset_truncation)
+    >>> def test_the_thing(database_reset_truncation)
+
+    This approach has a couple of problems:
+
+    * You can't run multiple tests in parallel without separate databases
+    * If you have important seed data and want to truncate those tables, the seed data will be lost
+    """
+
+    logger.info("truncating database")
+
+    # TODO get additonal tables to preserve from config
+    exception_tables = ["alembic_version"]
+
+    assert (
+        SQLModel.metadata.sorted_tables
+    ), "No model metadata. Ensure model metadata is imported before running truncate_db"
+
+    with get_engine().connect() as connection:
+        for table in reversed(SQLModel.metadata.sorted_tables):
+            transaction = connection.begin()
+
+            if table.name not in exception_tables:
+                logger.debug("truncating table=%s", table.name)
+                connection.execute(table.delete())
+
+            transaction.commit()

activemodel/query_wrapper.py

@@ -1,15 +1,7 @@
-from typing import Generic, TypeVar
+import sqlmodel
 
-from sqlmodel.sql.expression import SelectOfScalar
 
-WrappedModelType = TypeVar("WrappedModelType")
-
-
-def compile_sql(target: SelectOfScalar):
-    return str(target.compile(get_engine().connect()))
-
-
-class QueryWrapper(Generic[WrappedModelType]):
+class QueryWrapper[T]:
     """
     Make it easy to run queries off of a model
     """
@@ -20,7 +12,7 @@ class QueryWrapper(Generic[WrappedModelType]):
 
         if args:
             # very naive, let's assume the args are specific select statements
-            self.target = sql.select(*args).select_from(cls)
+            self.target = sqlmodel.sql.select(*args).select_from(cls)
         else:
             self.target = sql.select(cls)
 
@@ -75,7 +67,7 @@ class QueryWrapper(Generic[WrappedModelType]):
 
     def sql(self):
         """
-        Output the raw SQL of the query
+        Output the raw SQL of the query for debugging
         """
 
         return compile_sql(self.target)

activemodel/session_manager.py

@@ -0,0 +1,62 @@
+"""
+Class to make managing sessions with SQL Model easy. Also provides a common entrypoint to make it easy to mutate the
+database environment when testing.
+"""
+
+import typing as t
+
+from decouple import config
+from sqlalchemy import Engine
+from sqlmodel import Session, create_engine
+
+
+class SessionManager:
+    _instance: t.ClassVar[t.Optional["SessionManager"]] = None
+
+    session_connection: str
+
+    @classmethod
+    def get_instance(cls, database_url: str | None = None) -> "SessionManager":
+        if cls._instance is None:
+            assert (
+                database_url is not None
+            ), "Database URL required for first initialization"
+            cls._instance = cls(database_url)
+
+        return cls._instance
+
+    def __init__(self, database_url: str):
+        self._database_url = database_url
+        self._engine = None
+        self.session_connection = None
+
+    # TODO why is this type not reimported?
+    def get_engine(self) -> Engine:
+        if not self._engine:
+            self._engine = create_engine(
+                self._database_url,
+                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,
+                # some implementations include `future=True` but it's not required anymore
+            )
+
+        return self._engine
+
+    def get_session(self):
+        if self.session_connection:
+            return Session(bind=self.session_connection)
+
+        return Session(self.get_engine())
+
+
+def init(database_url: str):
+    return SessionManager.get_instance(database_url)
+
+
+def get_engine():
+    return SessionManager.get_instance().get_engine()
+
+
+def get_session():
+    return SessionManager.get_instance().get_session()

activemodel/types/typeid.py

@@ -0,0 +1,56 @@
+"""
+Lifted from: https://github.com/akhundMurad/typeid-python/blob/main/examples/sqlalchemy.py
+"""
+
+from typing import Optional
+
+from sqlalchemy import types
+from sqlalchemy.util import generic_repr
+from typeid import TypeID
+
+
+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")
+        )
+    """
+
+    impl = types.Uuid
+    # impl = uuid.UUID
+    cache_ok = True
+    prefix: Optional[str] = None
+
+    def __init__(self, prefix: Optional[str], *args, **kwargs):
+        self.prefix = prefix
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        # Customize __repr__ to ensure that auto-generated code e.g. from alembic includes
+        # the right __init__ params (otherwise by default prefix will be omitted because
+        # uuid.__init__ does not have such an argument).
+        # TODO this makes it so inspected code does NOT include the suffix
+        return generic_repr(
+            self,
+            to_inspect=TypeID(self.prefix),
+        )
+
+    def process_bind_param(self, value, dialect):
+        if self.prefix is None:
+            assert value.prefix is None
+        else:
+            assert value.prefix == self.prefix
+
+        return value.uuid
+
+    def process_result_value(self, value, dialect):
+        return TypeID.from_uuid(value, self.prefix)

activemodel/utils.py

@@ -0,0 +1,15 @@
+from sqlmodel.sql.expression import SelectOfScalar
+
+from activemodel import get_engine
+
+
+def compile_sql(target: SelectOfScalar):
+    dialect = get_engine().dialect
+    # TODO I wonder if we could store the dialect to avoid getting an engine reference
+    compiled = target.compile(dialect=dialect, compile_kwargs={"literal_binds": True})
+    return str(compiled)
+
+
+def raw_sql_exec(raw_query: str):
+    with get_session() as session:
+        session.execute(text(raw_query))

activemodel-0.5.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: activemodel
+Version: 0.5.0
+Summary: Make SQLModel more like an a real ORM
+Author-email: Michael Bianco <iloveitaly@gmail.com>
+Project-URL: Repository, https://github.com/iloveitaly/activemodel
+Keywords: sqlmodel,orm,activerecord,activemodel,sqlalchemy
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydash>=8.0.4
+Requires-Dist: python-decouple-typed>=3.11.0
+Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: typeid-python>=0.3.1
+
+# ActiveModel: ORM Wrapper for SQLModel
+
+No, this isn't *really* [ActiveModel](https://guides.rubyonrails.org/active_model_basics.html). It's just a wrapper around SQLModel that provides a more ActiveRecord-like interface.
+
+SQLModel is *not* an ORM. It's a SQL query builder and a schema definition tool.
+
+This package provides a thin wrapper around SQLModel that provides a more ActiveRecord-like interface with things like:
+
+* Timestamp column mixins
+* Lifecycle hooks
+
+## Limitations
+
+### Validation
+
+SQLModel does not currently support pydantic validations (when `table=True`). This is very surprising, but is actually the intended functionality:
+
+* https://github.com/fastapi/sqlmodel/discussions/897
+* https://github.com/fastapi/sqlmodel/pull/1041
+* https://github.com/fastapi/sqlmodel/issues/453
+* https://github.com/fastapi/sqlmodel/issues/52#issuecomment-1311987732
+
+For validation:
+
+* When consuming API data, use a separate shadow model to validate the data with `table=False` and then inherit from that model in a model with `table=True`.
+* When validating ORM data, use SQL Alchemy hooks.
+
+<!--
+
+This looks neat
+https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d2a4/src/my_model/model.py#L155
+        schema_extra={
+            'pattern': r'^[a-z0-9_\-\.]+\@[a-z0-9_\-\.]+\.[a-z\.]+$'
+        },
+
+extra constraints
+
+https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d2a4/src/my_model/model.py#L424C1-L426C6
+-->
+## Related Projects
+
+* https://github.com/woofz/sqlmodel-basecrud
+
+## Inspiration
+
+* https://github.com/peterdresslar/fastapi-sqlmodel-alembic-pg
+* [Albemic instructions](https://github.com/fastapi/sqlmodel/pull/899/files)
+* https://github.com/fastapiutils/fastapi-utils/
+* https://github.com/fastapi/full-stack-fastapi-template
+* https://github.com/DarylStark/my_data/
+* https://github.com/petrgazarov/FastAPI-app/tree/main/fastapi_app

activemodel-0.5.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+activemodel/__init__.py,sha256=lO75TeJeSm7spmP4P1_Z5oIXBHlL7kKjr1LS2Z4dNUA,109
+activemodel/_session_manager.py,sha256=ojFIpK_fl1-JZsj98zn-zp4RIK1_eyDl-Ga4F1XXbVw,5249
+activemodel/base_model.py,sha256=y8gLmowqk950AELE67u69YJAT9pJSmm67apjOd1g2yo,8081
+activemodel/logger.py,sha256=vU7QiGSy_AJuJFmClUocqIJ-Ltku_8C24ZU8L6fLJR0,53
+activemodel/query_wrapper.py,sha256=zqaA3yAHPTfGLrkzZ6ge6byedV497C7YG1QJe_4ah7Q,2100
+activemodel/session_manager.py,sha256=zU4Eu3YeKSlZrYEBkN70XAHJOHka40Rl4qMBZvEgNwA,1822
+activemodel/utils.py,sha256=dY6wvAS2RCqMVMQfnpXGJxgWRBet0jV5ZXxGIRX1iRw,476
+activemodel/mixins/__init__.py,sha256=VAVLc96oSSultP0BNAlaE3ZBNGlcuVD0JjS1FMCno7k,72
+activemodel/mixins/timestamps.py,sha256=Q-IFljeVVJQqw3XHdOi7dkqzefiVg1zhJvq_bldpmjg,992
+activemodel/mixins/typeid.py,sha256=0TOJ74As9JL4WVvlRm0yuZB49xHAcX0n1fzwKpgdpys,894
+activemodel/pytest/__init__.py,sha256=W9KKQHbPkyq0jrMXaiL8hG2Nsbjy_LN9HhvgGm8W_7g,98
+activemodel/pytest/transaction.py,sha256=rrsoHnbu79kNdnI5fZeOZr5hzrLB-cQH10MueQp5jV4,1670
+activemodel/pytest/truncate.py,sha256=BdltCtLQNPDgRSxpBnGYGSjB_7DAceV5kHdQ_vLrw74,1583
+activemodel/types/typeid.py,sha256=rcr9tSiu5rowD_WOcF4zzBpEUy2izmYEPteDQgCIbhs,1799
+activemodel-0.5.0.dist-info/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
+activemodel-0.5.0.dist-info/METADATA,sha256=4nieriFioXBxTPOIuxul3RXzNMwKPiDgSYX4KMkwSbQ,2429
+activemodel-0.5.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+activemodel-0.5.0.dist-info/entry_points.txt,sha256=YLX62TP_hR-n3HMBkdBex4W7XRiyOtIPkwy22puIjjQ,61
+activemodel-0.5.0.dist-info/top_level.txt,sha256=JCMUN_seFIi6GXtnTQRWfxXDx6Oj1uok8qapQWbWKDM,12
+activemodel-0.5.0.dist-info/RECORD,,

activemodel-0.3.0.dist-info/METADATA

@@ -1,34 +0,0 @@
-Metadata-Version: 2.1
-Name: activemodel
-Version: 0.3.0
-Summary: Make SQLModel more like an a real ORM
-Author-email: Michael Bianco <iloveitaly@gmail.com>
-Project-URL: Repository, https://github.com/iloveitaly/activemodel
-Keywords: sqlmodel,orm,activerecord,activemodel,sqlalchemy
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydash>=8.0.4
-Requires-Dist: sqlmodel>=0.0.22
-
-# ActiveModel: ORM Wrapper for SQLModel
-
-No, this isn't *really* [ActiveModel](https://guides.rubyonrails.org/active_model_basics.html). It's just a wrapper around SQLModel that provides a more ActiveRecord-like interface.
-
-SQLModel is *not* an ORM. It's a SQL query builder and a schema definition tool.
-
-This package provides a thin wrapper around SQLModel that provides a more ActiveRecord-like interface with things like:
-
-* Timestamp column mixins
-* Lifecycle hooks
-
-## Related Projects
-
-* https://github.com/woofz/sqlmodel-basecrud
-
-## Inspiration
-
-* https://github.com/peterdresslar/fastapi-sqlmodel-alembic-pg
-* [Albemic instructions](https://github.com/fastapi/sqlmodel/pull/899/files)
-* https://github.com/fastapiutils/fastapi-utils/
-*

activemodel-0.3.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-activemodel/__init__.py,sha256=WWLMytAi2VO3-HdySf4IpbeSCPMlVVO_GGQlQNA6UWU,216
-activemodel/base_model.py,sha256=fk_g6jC1GCkAFo78UYjTONyFE8iYQH1bfvxdWG-_178,4200
-activemodel/query_wrapper.py,sha256=JiYN8EN9_gXpKrFw348gs4QixwtrEN50fJF-3uv5Gmg,2319
-activemodel/timestamps.py,sha256=8odUxQ1c0OouPAVioMTkD277w6S28Pk17pwCsaxKgww,991
-activemodel-0.3.0.dist-info/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
-activemodel-0.3.0.dist-info/METADATA,sha256=PrnCUuQVLSuCQ-tbwEMzHXrqMHq9MHTNYVgvRh9uXng,1174
-activemodel-0.3.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-activemodel-0.3.0.dist-info/entry_points.txt,sha256=YLX62TP_hR-n3HMBkdBex4W7XRiyOtIPkwy22puIjjQ,61
-activemodel-0.3.0.dist-info/top_level.txt,sha256=JCMUN_seFIi6GXtnTQRWfxXDx6Oj1uok8qapQWbWKDM,12
-activemodel-0.3.0.dist-info/RECORD,,