activemodel 0.3.0__tar.gz → 0.5.0__tar.gz

activemodel-0.5.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,51 @@
+# 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/activemodel/__init__.py

@@ -0,0 +1,2 @@
+from .base_model import BaseModel
+from .session_manager import SessionManager, get_engine, get_session, init

activemodel-0.5.0/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-0.5.0/activemodel/base_model.py

@@ -0,0 +1,228 @@
+import json
+import typing as t
+from contextlib import contextmanager
+
+import pydash
+import sqlalchemy as sa
+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
+
+
+# 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):
+    """
+    Helper class to ease validation in SQLModel classes with table=True
+    """
+
+    @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())
+
+
+class BaseModel(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
+
+    {before,after} hooks are modeled after Rails.
+    """
+
+    # 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:
+        """
+        Automatically generates the table name for the model by converting the class name from camel case to snake case.
+
+        By default, the class is lower cased which makes it harder to read.
+
+        Many snake_case libraries struggle with snake case for names like LLMCache, which is why we are using a more
+        complicated implementation from pydash.
+
+        https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case
+        """
+        return pydash.strings.snake_case(cls.__name__)
+
+    @classmethod
+    def select(cls, *args):
+        return QueryWrapper[cls](cls, *args)
+
+    def save(self):
+        with get_session() as 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)
+
+            session.add(self)
+            # NOTE very important method! This triggers sqlalchemy lifecycle hooks automatically
+            session.commit()
+            session.refresh(self)
+
+        return self
+
+        # 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) -> int:
+        """
+        Returns the number of records in the database.
+        """
+        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: t.Any, **kwargs: t.Any):
+        """
+        Gets a single record from the database. Pass an PK ID or a kwarg to filter by.
+        """
+
+        # special case for getting by ID
+        if len(args) == 1 and isinstance(args[0], int):
+            # 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 = 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(sa.sql.select(cls))
+
+            # TODO do we need this or can we just return results?
+            for result in results:
+                yield result
+
+    @classmethod
+    def sample(cls):
+        """
+        Pick a random record from the database.
+
+        Helpful for testing and console debugging.
+        """
+
+        query = sql.select(cls).order_by(sql.func.random()).limit(1)
+
+        with get_session() as session:
+            return session.exec(query).one()

activemodel-0.5.0/activemodel/logger.py

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

activemodel-0.5.0/activemodel/mixins/__init__.py

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

{activemodel-0.3.0/activemodel → activemodel-0.5.0/activemodel/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-0.5.0/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-0.5.0/activemodel/pytest/__init__.py

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

activemodel-0.5.0/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-0.5.0/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-0.3.0 → activemodel-0.5.0}/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-0.5.0/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-0.5.0/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-0.5.0/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/activemodel.egg-info/PKG-INFO

@@ -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/activemodel.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+activemodel/__init__.py
+activemodel/_session_manager.py
+activemodel/base_model.py
+activemodel/logger.py
+activemodel/query_wrapper.py
+activemodel/session_manager.py
+activemodel/utils.py
+activemodel.egg-info/PKG-INFO
+activemodel.egg-info/SOURCES.txt
+activemodel.egg-info/dependency_links.txt
+activemodel.egg-info/entry_points.txt
+activemodel.egg-info/requires.txt
+activemodel.egg-info/top_level.txt
+activemodel/mixins/__init__.py
+activemodel/mixins/timestamps.py
+activemodel/mixins/typeid.py
+activemodel/pytest/__init__.py
+activemodel/pytest/transaction.py
+activemodel/pytest/truncate.py
+activemodel/types/typeid.py

activemodel-0.5.0/activemodel.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pydash>=8.0.4
+python-decouple-typed>=3.11.0
+sqlmodel>=0.0.22
+typeid-python>=0.3.1

{activemodel-0.3.0 → activemodel-0.5.0}/pyproject.toml

@@ -1,12 +1,14 @@
 [project]
 name = "activemodel"
-version = "0.3.0"
+version = "0.5.0"
 description = "Make SQLModel more like an a real ORM"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "pydash>=8.0.4",
+    "python-decouple-typed>=3.11.0",
     "sqlmodel>=0.0.22",
+    "typeid-python>=0.3.1",
 ]
 authors = [{ name = "Michael Bianco", email = "iloveitaly@gmail.com" }]
 keywords = ["sqlmodel", "orm", "activerecord", "activemodel", "sqlalchemy"]

activemodel-0.3.0/PKG-INFO

@@ -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/README.md

@@ -1,21 +0,0 @@
-# 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/activemodel/__init__.py

@@ -1,6 +0,0 @@
-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

activemodel-0.3.0/activemodel/base_model.py

@@ -1,137 +0,0 @@
-import json
-import typing as t
-
-import pydash
-import sqlalchemy as sa
-from sqlalchemy.orm import declared_attr
-from sqlmodel import Session, SQLModel
-
-from .query_wrapper import QueryWrapper
-
-
-class BaseModel(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
-    """
-
-    # TODO implement actually calling these hooks
-
-    def before_delete(self):
-        pass
-
-    def after_delete(self):
-        pass
-
-    def before_save(self):
-        pass
-
-    def after_save(self):
-        pass
-
-    def before_update(self):
-        pass
-
-    def after_update(self):
-        pass
-
-    @declared_attr
-    def __tablename__(cls) -> str:
-        """
-        Automatically generates the table name for the model by converting the class name from camel case to snake case.
-
-        By default, the class is lower cased which makes it harder to read.
-
-        Many snake_case libraries struggle with snake case for names like LLMCache, which is why we are using a more
-        complicated implementation from pydash.
-
-        https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case
-        """
-        return pydash.strings.snake_case(cls.__name__)
-
-    @classmethod
-    def select(cls, *args):
-        return QueryWrapper[cls](cls, *args)
-
-    def save(self):
-        old_session = Session.object_session(self)
-        with get_session() as session:
-            if old_session:
-                # 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)
-            session.commit()
-            session.refresh(self)
-
-            self.after_update()
-            # self.after_save()
-
-            return self
-
-            # 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)
-
-    @classmethod
-    def count(cls):
-        """
-        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()
-
-    # 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):
-        """
-        Gets a single record from the database. Pass an PK ID or a kwarg to filter by.
-        """
-
-        # special case for getting by ID
-        if len(args) == 1 and isinstance(args[0], int):
-            # TODO id is hardcoded, not good! Need to dynamically pick the best uid field
-            kwargs["id"] = args[0]
-            args = []
-
-        statement = sql.select(cls).filter(*args).filter_by(**kwargs)
-        with get_session() as session:
-            return session.exec(statement).first()
-
-    @classmethod
-    def all(cls):
-        with get_session() as session:
-            results = session.exec(sql.select(cls))
-
-            # TODO do we need this or can we just return results?
-            for result in results:
-                yield result
-
-    @classmethod
-    def sample(cls):
-        """
-        Pick a random record from the database.
-
-        Helpful for testing and console debugging.
-        """
-
-        query = sql.select(cls).order_by(sql.func.random()).limit(1)
-
-        with get_session() as session:
-            return session.exec(query).one()

activemodel-0.3.0/activemodel.egg-info/PKG-INFO

@@ -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/activemodel.egg-info/SOURCES.txt

@@ -1,13 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-activemodel/__init__.py
-activemodel/base_model.py
-activemodel/query_wrapper.py
-activemodel/timestamps.py
-activemodel.egg-info/PKG-INFO
-activemodel.egg-info/SOURCES.txt
-activemodel.egg-info/dependency_links.txt
-activemodel.egg-info/entry_points.txt
-activemodel.egg-info/requires.txt
-activemodel.egg-info/top_level.txt

activemodel-0.3.0/activemodel.egg-info/requires.txt

@@ -1,2 +0,0 @@
-pydash>=8.0.4
-sqlmodel>=0.0.22