activemodel 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

activemodel/base_model.py

@@ -2,10 +2,11 @@ import json
 import typing as t
 from uuid import UUID
 
-import pydash
 import sqlalchemy as sa
 import sqlmodel as sm
+import textcase
 from sqlalchemy import Connection, event
+from sqlalchemy.dialects.postgresql import insert as postgres_insert
 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
@@ -19,7 +20,6 @@ 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",
@@ -152,19 +152,19 @@ class BaseModel(SQLModel):
     @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.
-        This is the recommended format for table names:
+        Automatically generates the table name for the model by converting the model's class name from camel case to snake case.
+        This is the recommended text case style for table names:
 
         https://wiki.postgresql.org/wiki/Don%27t_Do_This#Don.27t_use_upper_case_table_or_column_names
 
-        By default, the class is lower cased which makes it harder to read.
+        By default, the model's class name 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.
+        Also, many text case conversion libraries struggle handling words like "LLMCache", this is why we are using
+        a more precise library which processes such acronyms: [`textcase`](https://pypi.org/project/textcase/).
 
         https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case
         """
-        return pydash.strings.snake_case(cls.__name__)
+        return textcase.snake(cls.__name__)
 
     @classmethod
     def foreign_key(cls, **kwargs):
@@ -234,6 +234,8 @@ class BaseModel(SQLModel):
         return result
 
     def delete(self):
+        "Delete record completely from the database"
+
         with get_session() as session:
             if old_session := Session.object_session(self):
                 old_session.expunge(self)
@@ -404,6 +406,19 @@ class BaseModel(SQLModel):
         with get_session() as session:
             return session.exec(statement).first()
 
+    @classmethod
+    def one_or_none(cls, *args: t.Any, **kwargs: t.Any):
+        """
+        Gets a single record from the database. Pass an PK ID or a kwarg to filter by.
+        Returns None if no record is found. Throws an error if more than one record is found.
+        """
+
+        args, kwargs = cls.__process_filter_args__(*args, **kwargs)
+        statement = select(cls).filter(*args).filter_by(**kwargs)
+
+        with get_session() as session:
+            return session.exec(statement).one_or_none()
+
     @classmethod
     def one(cls, *args: t.Any, **kwargs: t.Any):
         """

activemodel/cli/__init__.py

@@ -0,0 +1,147 @@
+"""
+This module provides utilities for generating Protocol type definitions for SQLAlchemy's
+SelectOfScalar methods, as well as formatting and fixing Python files using ruff.
+"""
+
+import inspect
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Any  # already imported in header of generated file
+
+import sqlmodel as sm
+from sqlmodel.sql.expression import SelectOfScalar
+
+from test.test_wrapper import QueryWrapper
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+QUERY_WRAPPER_CLASS_NAME = QueryWrapper.__name__
+
+
+def format_python_file(file_path: str | Path) -> bool:
+    """
+    Format a Python file using ruff.
+
+    Args:
+        file_path: Path to the Python file to format
+
+    Returns:
+        bool: True if formatting was successful, False otherwise
+    """
+    try:
+        subprocess.run(["ruff", "format", str(file_path)], check=True)
+        logger.info(f"Formatted file using ruff at {file_path}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error running ruff to format the file: {e}")
+        return False
+
+
+def fix_python_file(file_path: str | Path) -> bool:
+    """
+    Fix linting issues in a Python file using ruff.
+
+    Args:
+        file_path: Path to the Python file to fix
+
+    Returns:
+        bool: True if fixing was successful, False otherwise
+    """
+    try:
+        subprocess.run(["ruff", "check", str(file_path), "--fix"], check=True)
+        logger.info(f"Fixed linting issues using ruff at {file_path}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error running ruff to fix the file: {e}")
+        return False
+
+
+def generate_sqlalchemy_protocol():
+    """Generate Protocol type definitions for SQLAlchemy SelectOfScalar methods"""
+    logger.info("Starting SQLAlchemy protocol generation")
+
+    header = """
+# IMPORTANT: This file is auto-generated. Do not edit directly.
+
+from typing import Protocol, TypeVar, Any, Generic
+import sqlmodel as sm
+from sqlalchemy.sql.base import _NoArg
+
+T = TypeVar('T', bound=sm.SQLModel, covariant=True)
+
+class SQLAlchemyQueryMethods(Protocol, Generic[T]):
+    \"""Protocol defining SQLAlchemy query methods forwarded by QueryWrapper.__getattr__\"""
+"""
+    # Initialize output list for generated method signatures
+    output: list = []
+
+    try:
+        # Get all methods from SelectOfScalar
+        methods = inspect.getmembers(SelectOfScalar)
+        logger.debug(f"Discovered {len(methods)} methods from SelectOfScalar")
+
+        for name, method in methods:
+            # Skip private/dunder methods
+            if name.startswith("_"):
+                continue
+
+            if not inspect.isfunction(method) and not inspect.ismethod(method):
+                logger.debug(f"Skipping non-method: {name}")
+                continue
+
+            logger.debug(f"Processing method: {name}")
+            try:
+                signature = inspect.signature(method)
+                params = []
+
+                # Process parameters, skipping 'self'
+                for param_name, param in list(signature.parameters.items())[1:]:
+                    if param.kind == param.VAR_POSITIONAL:
+                        params.append(f"*{param_name}: Any")
+                    elif param.kind == param.VAR_KEYWORD:
+                        params.append(f"**{param_name}: Any")
+                    else:
+                        if param.default is inspect.Parameter.empty:
+                            params.append(f"{param_name}: Any")
+                        else:
+                            default_repr = repr(param.default)
+                            params.append(f"{param_name}: Any = {default_repr}")
+
+                params_str = ", ".join(params)
+                output.append(
+                    f'    def {name}(self, {params_str}) -> "{QUERY_WRAPPER_CLASS_NAME}[T]": ...'
+                )
+            except (ValueError, TypeError) as e:
+                logger.warning(f"Could not get signature for {name}: {e}")
+                # Some methods might not have proper signatures
+                output.append(
+                    f'    def {name}(self, *args: Any, **kwargs: Any) -> "{QUERY_WRAPPER_CLASS_NAME}[T]": ...'
+                )
+
+        # Write the output to a file
+        protocol_path = (
+            Path(__file__).parent.parent / "types" / "sqlalchemy_protocol.py"
+        )
+
+        # Ensure directory exists
+        os.makedirs(protocol_path.parent, exist_ok=True)
+
+        with open(protocol_path, "w") as f:
+            f.write(header + "\n".join(output))
+
+        logger.info(f"Generated SQLAlchemy protocol at {protocol_path}")
+
+        # Format and fix the generated file with ruff
+        format_python_file(protocol_path)
+        fix_python_file(protocol_path)
+    except Exception as e:
+        logger.error(f"Error generating SQLAlchemy protocol: {e}", exc_info=True)
+        raise
+
+
+if __name__ == "__main__":
+    generate_sqlalchemy_protocol()

activemodel/mixins/timestamps.py

@@ -20,7 +20,10 @@ class TimestampsMixin:
     >>> class MyModel(TimestampsMixin, SQLModel):
     >>>    pass
 
-    Originally pulled from: https://github.com/tiangolo/sqlmodel/issues/252
+    Notes:
+    
+    - Originally pulled from: https://github.com/tiangolo/sqlmodel/issues/252
+    - Related issue: https://github.com/fastapi/sqlmodel/issues/539
     """
 
     created_at: datetime | None = Field(

activemodel/mixins/typeid.py

@@ -17,7 +17,7 @@ def TypeIDMixin(prefix: str):
     # NOTE this will cause issues on code reloads
     assert prefix
     assert prefix not in _prefixes, (
-        f"prefix {prefix} already exists, pick a different one"
+        f"TypeID prefix '{prefix}' already exists, pick a different one"
     )
 
     class _TypeIDMixin:

activemodel/pytest/__init__.py

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

activemodel/pytest/factories.py

@@ -0,0 +1,102 @@
+"""
+Notes on polyfactory:
+
+1. is_supported_type validates that the class can be used to generate a factory
+https://github.com/litestar-org/polyfactory/issues/655#issuecomment-2727450854
+"""
+
+import typing as t
+
+from polyfactory.factories.pydantic_factory import ModelFactory
+from polyfactory.field_meta import FieldMeta
+from typeid import TypeID
+
+from activemodel.session_manager import global_session
+
+# TODO not currently used
+# def type_id_provider(cls, field_meta):
+#     # TODO this doesn't work well with __ args:
+#     # https://github.com/litestar-org/polyfactory/pull/666/files
+#     return str(TypeID("hi"))
+
+
+# BaseFactory.add_provider(TypeIDType, type_id_provider)
+
+
+class SQLModelFactory[T](ModelFactory[T]):
+    """
+    Base factory for SQLModel models:
+
+    1. Ability to ignore all relationship fks
+    2. Option to ignore all pks
+    """
+
+    __is_base_factory__ = True
+
+    @classmethod
+    def should_set_field_value(cls, field_meta: FieldMeta, **kwargs: t.Any) -> bool:
+        # TODO what is this checking for?
+        has_object_override = hasattr(cls, field_meta.name)
+
+        # TODO this should be more intelligent, it's goal is to detect all of the relationship field and avoid settings them
+        if not has_object_override and (
+            field_meta.name == "id" or field_meta.name.endswith("_id")
+        ):
+            return False
+
+        return super().should_set_field_value(field_meta, **kwargs)
+
+
+# TODO we need to think through how to handle relationships and autogenerate them
+class ActiveModelFactory[T](SQLModelFactory[T]):
+    __is_base_factory__ = True
+    __sqlalchemy_session__ = None
+
+    # TODO we shouldn't have to type this, but `save()` typing is not working
+    @classmethod
+    def save(cls, *args, **kwargs) -> T:
+        """
+        Where this gets tricky, is this can be called multiple times within the same callstack. This can happen when
+        a factory uses other factories to create relationships.
+
+        In a truncation strategy, the __sqlalchemy_session__ is set to None.
+        """
+        with global_session(cls.__sqlalchemy_session__):
+            return cls.build(*args, **kwargs).save()
+
+    @classmethod
+    def foreign_key_typeid(cls):
+        """
+        Return a random type id for the foreign key on this model.
+
+        This is helpful for generating TypeIDs for testing 404s, parsing, manually settings, etc
+        """
+        # TODO right now assumes the model is typeid, maybe we should assert against this?
+        primary_key_name = cls.__model__.primary_key_column().name
+        return TypeID(
+            cls.__model__.model_fields[primary_key_name].sa_column.type.prefix
+        )
+
+    @classmethod
+    def should_set_field_value(cls, field_meta: FieldMeta, **kwargs: t.Any) -> bool:
+        # do not default deleted at mixin to deleted!
+        # TODO should be smarter about detecting if the mixin is in place
+        if field_meta.name in ["deleted_at", "updated_at", "created_at"]:
+            return False
+
+        return super().should_set_field_value(field_meta, **kwargs)
+
+    # @classmethod
+    # def build(
+    #     cls,
+    #     factory_use_construct: bool | None = None,
+    #     sqlmodel_save: bool = False,
+    #     **kwargs: t.Any,
+    # ) -> T:
+    #     result = super().build(factory_use_construct=factory_use_construct, **kwargs)
+
+    #     # TODO allow magic dunder method here
+    #     if sqlmodel_save:
+    #         result.save()
+
+    #     return result

activemodel/pytest/plugin.py

@@ -0,0 +1,81 @@
+"""Pytest plugin integration for activemodel.
+
+Currently provides:
+
+* ``db_session`` fixture – quick access to a database session (see ``test_session``)
+* ``activemodel_preserve_tables`` ini option – configure tables to preserve when using
+  ``database_reset_truncate`` (comma separated list or multiple lines depending on config style)
+
+Configuration examples:
+
+pytest.ini::
+
+    [pytest]
+    activemodel_preserve_tables = alembic_version,zip_code,seed_table
+
+pyproject.toml::
+
+    [tool.pytest.ini_options]
+    activemodel_preserve_tables = [
+      "alembic_version",
+      "zip_code",
+      "seed_table",
+    ]
+
+The list always implicitly includes ``alembic_version`` even if not specified.
+"""
+
+from activemodel.session_manager import global_session
+import pytest
+
+from .transaction import set_factory_session, set_polyfactory_session, test_session
+
+
+def pytest_addoption(
+    parser: pytest.Parser,
+) -> None:  # pragma: no cover - executed during collection
+    """Register custom ini options.
+
+    We treat this as a *linelist* so pyproject.toml list syntax works. Comma separated works too because
+    pytest splits lines first; users can still provide one line with commas.
+    """
+
+    parser.addini(
+        "activemodel_preserve_tables",
+        help=(
+            "Tables to preserve when calling activemodel.pytest.database_reset_truncate. "
+        ),
+        type="linelist",
+        default=["alembic_version"],
+    )
+
+
+@pytest.fixture(scope="function")
+def db_session():
+    """
+    Helpful for tests that are more similar to unit tests. If you doing a routing or integration test, you
+    probably don't need this. If your unit test is simple (you are just creating a couple of models) you
+    can most likely skip this.
+
+    This is helpful if you are doing a lot of lazy-loaded params or need a database session to be in place
+    for testing code that will run within a celery worker or something similar.
+
+    >>> def the_test(db_session):
+    """
+    with test_session() as session:
+        yield session
+
+
+@pytest.fixture(scope="function")
+def db_truncate_session():
+    """
+    Provides a database session for testing when using a truncation cleaning strategy.
+
+    When not using a transaction cleaning strategy, no global test session is set
+    """
+    with global_session() as session:
+        # set global database sessions for model factories to avoid lazy loading issues
+        set_factory_session(session)
+        set_polyfactory_session(session)
+
+        yield session

activemodel/pytest/transaction.py

@@ -1,19 +1,107 @@
+import contextlib
+import contextvars
+
+from sqlmodel import Session
 from activemodel import SessionManager
+from activemodel.session_manager import global_session
 
 from ..logger import logger
 
+try:
+    import factory as factory_exists
+except ImportError:
+    factory_exists = None
+
+try:
+    import polyfactory as polyfactory_exists
+except ImportError:
+    polyfactory_exists = None
+
+
+_test_session = contextvars.ContextVar[Session | None]("test_session", default=None)
+
+
+def set_factory_session(session):
+    if not factory_exists:
+        return
+    from factory.alchemy import SQLAlchemyModelFactory
+
+    # Ensure that all factories use the same session
+    for factory in SQLAlchemyModelFactory.__subclasses__():
+        factory._meta.sqlalchemy_session = factory_session
+        factory._meta.sqlalchemy_session_persistence = "commit"
+
+
+def set_polyfactory_session(session):
+    if not polyfactory_exists:
+        return
+
+    from .factories import ActiveModelFactory
+
+    ActiveModelFactory.__sqlalchemy_session__ = session
+
+
+@contextlib.contextmanager
+def test_session():
+    """
+    Configures a session-global database session for a test.
+
+    Use this as a fixture using `db_session`. This method is meant to be used as a context manager.
+
+    This is useful for tests that need to interact with the database multiple times before calling application code
+    that uses the objects. This is intended to be used outside of an integration test. Integration tests generally
+    do not use database transactions to clean the database and instead use truncation. The transaction fixture
+    configures a session, which is then used here. This method requires that this global test session is already
+    configured. If the transaction fixture is not used, then there is no session available for use and this will fail.
+
+    ActiveModelFactory.save() does this automatically, but if you need to manually create objects
+    and persist them to a DB, you can run into issues with the simple `expunge()` call
+    used to reassociate an object with a new session. If there are more complex relationships
+    this approach will fail and give you detached object errors.
+
+    >>> from activemodel.pytest import test_session
+    >>> def test_the_thing():
+    >>>     with test_session():
+    ...         obj = MyModel(name="test").save()
+    ...         obj2 = MyModelFactory.save()
+
+    More information: https://grok.com/share/bGVnYWN5_c21dd39f-84a7-44cf-a05b-9b26c8febb0b
+    """
+
+    if model_factory_session := _test_session.get():
+        with global_session(model_factory_session) as session:
+            yield session
+    else:
+        raise ValueError("No test session available")
+
+
+def database_truncate_session():
+    """
+    Provides a database session for testing when using a truncation cleaning strategy.
+
+    When not using a transaction cleaning strategy, no global test session is set
+    """
+    with test_session() as session:
+        yield session
+
 
 def database_reset_transaction():
     """
     Wrap all database interactions for a given test in a nested transaction and roll it back after the test.
 
+    This is provided as a function, not a fixture, since you'll need to determine when a integration test is run. Here's
+    an example of how to build a fixture from this method:
+
     >>> from activemodel.pytest import database_reset_transaction
     >>> database_reset_transaction = pytest.fixture(scope="function", autouse=True)(database_reset_transaction)
 
-    Transaction-based DB cleaning does *not* work if the DB mutations are happening in a separate process, which should
-    use spawn, because the same session is not shared across processes. Note that using `fork` is dangerous.
+    Transaction-based DB cleaning does *not* work if the DB mutations are happening in a separate process because the
+    same session is not shared across python processes. For this scenario, use the truncate method.
 
-    In this case, you should use the truncate.
+    Note that using `fork` as a multiprocess start method is dangerous. Use spawn. This link has more documentation
+    around this topic:
+
+    https://github.com/iloveitaly/python-starter-template/blob/master/app/configuration/lang.py
 
     References:
 
@@ -28,30 +116,29 @@ def database_reset_transaction():
 
     engine = SessionManager.get_instance().get_engine()
 
-    logger.info("starting global database transaction")
+    logger.debug("starting global database transaction")
 
     with engine.begin() as connection:
         transaction = connection.begin_nested()
 
         if SessionManager.get_instance().session_connection is not None:
-            logger.warning("session override already exists")
-            # TODO should we throw an exception here?
+            raise ValueError("global session already set")
 
+        # NOTE we very intentionally do NOT
         SessionManager.get_instance().session_connection = connection
 
         try:
-            with SessionManager.get_instance().get_session() as factory_session:
-                try:
-                    from factory.alchemy import SQLAlchemyModelFactory
+            with SessionManager.get_instance().get_session() as model_factory_session:
+                # set global database sessions for model factories to avoid lazy loading issues
+                set_factory_session(model_factory_session)
+                set_polyfactory_session(model_factory_session)
 
-                    # Ensure that all factories use the same session
-                    for factory in SQLAlchemyModelFactory.__subclasses__():
-                        factory._meta.sqlalchemy_session = factory_session
-                        factory._meta.sqlalchemy_session_persistence = "commit"
-                except ImportError:
-                    pass
+                test_session_token = _test_session.set(model_factory_session)
 
-                yield
+                try:
+                    yield
+                finally:
+                    _test_session.reset(test_session_token)
         finally:
             logger.debug("rolling back transaction")
 

activemodel/pytest/truncate.py

@@ -1,10 +1,110 @@
+import os
+from typing import Iterable
+
+import pytest
 from sqlmodel import SQLModel
 
 from ..logger import logger
 from ..session_manager import get_engine
+from pytest import Config
+import typing as t
+
+T = t.TypeVar("T")
+
+
+def _normalize_to_list_of_strings(str_or_list: list[str] | str) -> list[str]:
+    if isinstance(str_or_list, list):
+        return str_or_list
+
+    raw_list = str_or_list.split(",")
+    return [entry.strip() for entry in raw_list if entry and entry.strip()]
+
+
+def _get_pytest_option(
+    config: Config, key: str, *, cast: t.Callable[[t.Any], T] | None = str
+) -> T | None:
+    if not config:
+        return None
+
+    try:
+        val = config.getoption(key)
+    except ValueError:
+        val = None
+
+    if val is None:
+        val = config.getini(key)
+
+    if val is not None:
+        if cast:
+            return cast(val)
+
+        return val
+
+    return None
+
+
+def _normalize_preserve_tables(raw: Iterable[str]) -> list[str]:
+    """Normalize user supplied table list: strip, dedupe (order not preserved).
+
+    Returns a sorted list (case-insensitive sort while preserving original casing
+    for readability in logs).
+    """
+
+    cleaned = {name.strip() for name in raw if name and name.strip()}
+    # deterministic order: casefold sort
+    return sorted(cleaned, key=lambda s: s.casefold())
+
+
+def _get_excluded_tables(
+    pytest_config: Config | None, preserve_tables: list[str] | None
+) -> list[str]:
+    """Resolve list of tables to exclude (i.e. *preserve* / NOT truncate).
+
+    Precedence (lowest -> highest):
+        1. pytest ini option ``activemodel_preserve_tables`` (if available)
+        2. Environment variable ``ACTIVEMODEL_PRESERVE_TABLES`` (comma separated)
+        3. Function argument ``preserve_tables``
+
+            Behavior:
+                    * If user supplies nothing via any channel, defaults to ["alembic_version"].
+                    * Case-insensitive matching during truncation; returned list is normalized
+                        (deduped, sorted) for deterministic logging.
+                    * Emits a warning only when the ini option is *explicitly* specified but empty after normalization.
+    """
+
+    # 1. pytest ini option (registered as type="linelist" -> typically list[str])
+    ini_tables = (
+        _get_pytest_option(
+            pytest_config,
+            "activemodel_preserve_tables",
+            cast=_normalize_to_list_of_strings,
+        )
+        or []
+    )
+
+    # 2. environment variable
+    env_var = os.getenv("ACTIVEMODEL_PRESERVE_TABLES", "")
+    env_tables = _normalize_to_list_of_strings(env_var)
+
+    # 3. function argument
+    arg_tables = preserve_tables or []
+
+    # Consider customization only if any non-empty source provided values OR the function arg explicitly passed
+    combined_raw = [*ini_tables, *env_tables, *arg_tables]
+
+    # if no user customization, force alembic_version
+    if not combined_raw:
+        return ["alembic_version"]
+
+    normalized = _normalize_preserve_tables(combined_raw)
+    logger.debug(f"excluded tables for truncation: {normalized}")
+
+    return normalized
 
 
-def database_reset_truncate():
+def database_reset_truncate(
+    preserve_tables: list[str] | None = None, pytest_config: Config | None = None
+):
     """
     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.
@@ -28,18 +128,19 @@ def database_reset_truncate():
 
     logger.info("truncating database")
 
-    # TODO get additonal tables to preserve from config
-    exception_tables = ["alembic_version"]
+    # Determine excluded (preserved) tables and build case-insensitive lookup set
+    exception_tables = _get_excluded_tables(pytest_config, preserve_tables)
+    exception_lookup = {t.lower() for t in exception_tables}
 
-    assert (
-        SQLModel.metadata.sorted_tables
-    ), "No model metadata. Ensure model metadata is imported before running truncate_db"
+    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:
+            if table.name.lower() not in exception_lookup:
                 logger.debug(f"truncating table={table.name}")
                 connection.execute(table.delete())
 

activemodel/query_wrapper.py

@@ -1,11 +1,13 @@
 import sqlmodel as sm
 from sqlmodel.sql.expression import SelectOfScalar
 
+from activemodel.types.sqlalchemy_protocol import SQLAlchemyQueryMethods
+
 from .session_manager import get_session
 from .utils import compile_sql
 
 
-class QueryWrapper[T: sm.SQLModel]:
+class QueryWrapper[T: sm.SQLModel](SQLAlchemyQueryMethods[T]):
     """
     Make it easy to run queries off of a model
     """
@@ -46,13 +48,20 @@ class QueryWrapper[T: sm.SQLModel]:
         with get_session() as session:
             return session.scalar(sm.select(sm.func.count()).select_from(self.target))
 
+    def scalar(self):
+        """
+        >>>
+        """
+        with get_session() as session:
+            return session.scalar(self.target)
+
     def exec(self):
         with get_session() as session:
             return session.exec(self.target)
 
     def delete(self):
         with get_session() as session:
-            session.delete(self.target)
+            return session.delete(self.target)
 
     def __getattr__(self, name):
         """
@@ -87,4 +96,5 @@ class QueryWrapper[T: sm.SQLModel]:
         return compile_sql(self.target)
 
     def __repr__(self) -> str:
+        # TODO we should improve structure of this a bit more, maybe wrap in <> or something?
         return f"{self.__class__.__name__}: Current SQL:\n{self.sql()}"

activemodel/session_manager.py

@@ -13,6 +13,8 @@ from pydantic import BaseModel
 from sqlalchemy import Connection, Engine
 from sqlmodel import Session, create_engine
 
+ACTIVEMODEL_LOG_SQL = config("ACTIVEMODEL_LOG_SQL", cast=bool, default=False)
+
 
 def _serialize_pydantic_model(model: BaseModel | list[BaseModel] | None) -> str | None:
     """
@@ -50,18 +52,26 @@ class SessionManager:
     "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":
+    def get_instance(
+        cls,
+        database_url: str | None = None,
+        *,
+        engine_options: dict[str, t.Any] | 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)
+            cls._instance = cls(database_url, engine_options=engine_options)
 
         return cls._instance
 
-    def __init__(self, database_url: str):
+    def __init__(
+        self, database_url: str, *, engine_options: dict[str, t.Any] | None = None
+    ):
         self._database_url = database_url
         self._engine = None
+        self._engine_options: dict = engine_options or {}
 
         self.session_connection = None
 
@@ -72,11 +82,12 @@ 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),
+                echo=ACTIVEMODEL_LOG_SQL,
+                echo_pool=ACTIVEMODEL_LOG_SQL,
                 # 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
+                **self._engine_options,
             )
 
         return self._engine
@@ -99,9 +110,10 @@ class SessionManager:
         return Session(self.get_engine())
 
 
-def init(database_url: str):
+# TODO would be great one day to type engine_options as the SQLAlchemy EngineOptions
+def init(database_url: str, *, engine_options: dict[str, t.Any] | None = None):
     "configure activemodel to connect to a specific database"
-    return SessionManager.get_instance(database_url)
+    return SessionManager.get_instance(database_url, engine_options=engine_options)
 
 
 def get_engine():
@@ -128,18 +140,40 @@ a place to persist a session to use globally across the application.
 
 
 @contextlib.contextmanager
-def global_session():
+def global_session(session: Session | None = None):
     """
-    Generate a session shared across all activemodel calls.
+    Generate a session and share it across all activemodel calls.
 
     Alternatively, you can pass a session to use globally into the context manager, which is helpful for migrations
     and testing.
+
+    This may only be called a single time per callstack. There is one exception: if you call this multiple times
+    and pass in the same session reference, it will result in a noop.
+
+    Args:
+        session: Use an existing session instead of creating a new one
     """
 
+    if session is not None and _session_context.get() is session:
+        yield session
+        return
+
     if _session_context.get() is not None:
-        raise RuntimeError("global session already set")
+        raise RuntimeError("ActiveModel: global session already set")
 
-    with SessionManager.get_instance().get_session() as s:
+    @contextlib.contextmanager
+    def manage_existing_session():
+        "if an existing session already exists, use it without triggering another __enter__"
+        yield session
+
+    # Use provided session or create a new one
+    session_context = (
+        manage_existing_session()
+        if session is not None
+        else SessionManager.get_instance().get_session()
+    )
+
+    with session_context as s:
         token = _session_context.set(s)
 
         try:

activemodel/types/sqlalchemy_protocol.py

@@ -0,0 +1,10 @@
+# IMPORTANT: This file is auto-generated. Do not edit directly.
+
+from typing import Protocol, TypeVar, Any, Generic
+import sqlmodel as sm
+from sqlalchemy.sql.base import _NoArg
+from typing import TYPE_CHECKING
+
+
+class SQLAlchemyQueryMethods[T: sm.SQLModel](Protocol):
+    pass

activemodel/types/sqlalchemy_protocol.pyi

@@ -0,0 +1,132 @@
+# IMPORTANT: This file is auto-generated. Do not edit directly.
+
+from typing import Protocol, TypeVar, Any, Generic
+import sqlmodel as sm
+from sqlalchemy.sql.base import _NoArg
+
+from ..query_wrapper import QueryWrapper
+
+class SQLAlchemyQueryMethods[T: sm.SQLModel](Protocol):
+    """Protocol defining SQLAlchemy query methods forwarded by QueryWrapper.__getattr__"""
+
+    def add_columns(self, *entities: Any) -> "QueryWrapper[T]": ...
+    def add_cte(self, *ctes: Any, nest_here: Any = False) -> "QueryWrapper[T]": ...
+    def alias(self, name: Any = None, flat: Any = False) -> "QueryWrapper[T]": ...
+    def argument_for(self, argument_name: Any, default: Any) -> "QueryWrapper[T]": ...
+    def as_scalar(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def column(self, column: Any) -> "QueryWrapper[T]": ...
+    def compare(self, other: Any, **kw: Any) -> "QueryWrapper[T]": ...
+    def compile(
+        self, bind: Any = None, dialect: Any = None, **kw: Any
+    ) -> "QueryWrapper[T]": ...
+    def correlate(self, *fromclauses: Any) -> "QueryWrapper[T]": ...
+    def correlate_except(self, *fromclauses: Any) -> "QueryWrapper[T]": ...
+    def corresponding_column(
+        self, column: Any, require_embedded: Any = False
+    ) -> "QueryWrapper[T]": ...
+    def cte(
+        self, name: Any = None, recursive: Any = False, nesting: Any = False
+    ) -> "QueryWrapper[T]": ...
+    def distinct(self, *expr: Any) -> "QueryWrapper[T]": ...
+    def except_(self, *other: Any) -> "QueryWrapper[T]": ...
+    def except_all(self, *other: Any) -> "QueryWrapper[T]": ...
+    def execution_options(self, **kw: Any) -> "QueryWrapper[T]": ...
+    def exists(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def fetch(
+        self,
+        count: Any,
+        with_ties: Any = False,
+        percent: Any = False,
+        **dialect_kw: Any,
+    ) -> "QueryWrapper[T]": ...
+    def filter(self, *criteria: Any) -> "QueryWrapper[T]": ...
+    def filter_by(self, **kwargs: Any) -> "QueryWrapper[T]": ...
+    def from_statement(self, statement: Any) -> "QueryWrapper[T]": ...
+    def get_children(self, **kw: Any) -> "QueryWrapper[T]": ...
+    def get_execution_options(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def get_final_froms(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def get_label_style(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def group_by(
+        self, _GenerativeSelect__first: Any = _NoArg.NO_ARG, *clauses: Any
+    ) -> "QueryWrapper[T]": ...
+    def having(self, *having: Any) -> "QueryWrapper[T]": ...
+    def intersect(self, *other: Any) -> "QueryWrapper[T]": ...
+    def intersect_all(self, *other: Any) -> "QueryWrapper[T]": ...
+    def is_derived_from(self, fromclause: Any) -> "QueryWrapper[T]": ...
+    def join(
+        self, target: Any, onclause: Any = None, isouter: Any = False, full: Any = False
+    ) -> "QueryWrapper[T]": ...
+    def join_from(
+        self,
+        from_: Any,
+        target: Any,
+        onclause: Any = None,
+        isouter: Any = False,
+        full: Any = False,
+    ) -> "QueryWrapper[T]": ...
+    def label(self, name: Any) -> "QueryWrapper[T]": ...
+    def lateral(self, name: Any = None) -> "QueryWrapper[T]": ...
+    def limit(self, limit: Any) -> "QueryWrapper[T]": ...
+    def memoized_instancemethod(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def offset(self, offset: Any) -> "QueryWrapper[T]": ...
+    def options(self, *options: Any) -> "QueryWrapper[T]": ...
+    def order_by(
+        self, _GenerativeSelect__first: Any = _NoArg.NO_ARG, *clauses: Any
+    ) -> QueryWrapper[T]: ...
+    def outerjoin(
+        self, target: Any, onclause: Any = None, full: Any = False
+    ) -> "QueryWrapper[T]": ...
+    def outerjoin_from(
+        self, from_: Any, target: Any, onclause: Any = None, full: Any = False
+    ) -> "QueryWrapper[T]": ...
+    def params(
+        self, _ClauseElement__optionaldict: Any = None, **kwargs: Any
+    ) -> "QueryWrapper[T]": ...
+    def prefix_with(self, *prefixes: Any, dialect: Any = "*") -> "QueryWrapper[T]": ...
+    def reduce_columns(self, only_synonyms: Any = True) -> "QueryWrapper[T]": ...
+    def replace_selectable(self, old: Any, alias: Any) -> "QueryWrapper[T]": ...
+    def scalar_subquery(
+        self,
+    ) -> "QueryWrapper[T]": ...
+    def select(self, *arg: Any, **kw: Any) -> "QueryWrapper[T]": ...
+    def select_from(self, *froms: Any) -> "QueryWrapper[T]": ...
+    def self_group(self, against: Any = None) -> "QueryWrapper[T]": ...
+    def set_label_style(self, style: Any) -> "QueryWrapper[T]": ...
+    def slice(self, start: Any, stop: Any) -> "QueryWrapper[T]": ...
+    def subquery(self, name: Any = None) -> "QueryWrapper[T]": ...
+    def suffix_with(self, *suffixes: Any, dialect: Any = "*") -> "QueryWrapper[T]": ...
+    def union(self, *other: Any) -> "QueryWrapper[T]": ...
+    def union_all(self, *other: Any) -> "QueryWrapper[T]": ...
+    def unique_params(
+        self, _ClauseElement__optionaldict: Any = None, **kwargs: Any
+    ) -> "QueryWrapper[T]": ...
+    def where(self, *whereclause: Any) -> "QueryWrapper[T]": ...
+    def with_for_update(
+        self,
+        nowait: Any = False,
+        read: Any = False,
+        of: Any = None,
+        skip_locked: Any = False,
+        key_share: Any = False,
+    ) -> "QueryWrapper[T]": ...
+    def with_hint(
+        self, selectable: Any, text: Any, dialect_name: Any = "*"
+    ) -> "QueryWrapper[T]": ...
+    def with_only_columns(
+        self, *entities: Any, maintain_column_froms: Any = False, **_Select__kw: Any
+    ) -> "QueryWrapper[T]": ...
+    def with_statement_hint(
+        self, text: Any, dialect_name: Any = "*"
+    ) -> "QueryWrapper[T]": ...

activemodel/types/typeid.py

@@ -76,6 +76,7 @@ class TypeIDType(types.TypeDecorator):
         if isinstance(value, str):
             # no prefix, raw UUID, let's coerce it into a UUID which SQLAlchemy can handle
             # ex: '01942886-7afc-7129-8f57-db09137ed002'
+            # if an invalid uuid is passed, `ValueError('badly formed hexadecimal UUID string')` will be raised
             return UUID(value)
 
         if isinstance(value, TypeID):

activemodel/utils.py

@@ -1,18 +1,12 @@
-import inspect
-import pkgutil
-import sys
-from types import ModuleType
-
 from sqlalchemy import text
-from sqlmodel import SQLModel
 from sqlmodel.sql.expression import SelectOfScalar
 
-from .logger import logger
 from .session_manager import get_engine, get_session
 
 
-def compile_sql(target: SelectOfScalar):
-    "convert a query into SQL, helpful for debugging"
+def compile_sql(target: SelectOfScalar) -> str:
+    "convert a query into SQL, helpful for debugging sqlalchemy/sqlmodel queries"
+
     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})
@@ -25,36 +19,6 @@ def raw_sql_exec(raw_query: str):
         session.execute(text(raw_query))
 
 
-def find_all_sqlmodels(module: ModuleType):
-    """Import all model classes from module and submodules into current namespace."""
-
-    logger.debug(f"Starting model import from module: {module.__name__}")
-    model_classes = {}
-
-    # Walk through all submodules
-    for loader, module_name, is_pkg in pkgutil.walk_packages(module.__path__):
-        full_name = f"{module.__name__}.{module_name}"
-        logger.debug(f"Importing submodule: {full_name}")
-
-        # Check if module is already imported
-        if full_name in sys.modules:
-            submodule = sys.modules[full_name]
-        else:
-            logger.warning(
-                f"Module not found in sys.modules, not importing: {full_name}"
-            )
-            continue
-
-        # Get all classes from module
-        for name, obj in inspect.getmembers(submodule):
-            if inspect.isclass(obj) and issubclass(obj, SQLModel) and obj != SQLModel:
-                logger.debug(f"Found model class: {name}")
-                model_classes[name] = obj
-
-    logger.debug(f"Completed model import. Found {len(model_classes)} models")
-    return model_classes
-
-
 def hash_function_code(func):
     "get sha of a function to easily assert that it hasn't changed"
 

{activemodel-0.11.0.dist-info → activemodel-0.12.0.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: activemodel
-Version: 0.11.0
+Version: 0.12.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>
 License-File: LICENSE
 Keywords: activemodel,activerecord,orm,sqlalchemy,sqlmodel
 Requires-Python: >=3.10
-Requires-Dist: pydash>=8.0.4
 Requires-Dist: python-decouple-typed>=3.11.0
 Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: textcase>=0.4.0
 Requires-Dist: typeid-python>=0.3.1
 Description-Content-Type: text/markdown
 
@@ -59,15 +59,17 @@ from sqlmodel import SQLModel
 
 SQLModel.metadata.create_all(get_engine())
 
-# now you can create a user!
+# now you can create a user! without managing sessions!
 User(a_field="a").save()
 ```
 
 Maybe you like JSON:
 
 ```python
-from activemodel import BaseModel
+from sqlalchemy.dialects.postgresql import JSONB
 from pydantic import BaseModel as PydanticBaseModel
+
+from activemodel import BaseModel
 from activemodel.mixins import PydanticJSONMixin, TypeIDMixin, TimestampsMixin
 
 class SubObject(PydanticBaseModel):
@@ -81,11 +83,28 @@ class User(
     TypeIDMixin("user"),
     table=True
 ):
-    list_field: list[SubObject] = Field(sa_type=JSONB())
+    list_field: list[SubObject] = Field(sa_type=JSONB)
 ```
 
+You'll probably want to query the model. Look ma, no sessions!
+
+```python
+User.where(id="user_123").all()
+
+# or, even better, for this case
+User.one("user_123")
+```
+
+Magically creating sessions for DB operations is one of the main problems this project tackles. Even better, you can set
+a single session object to be used for all DB operations. This is helpful for DB transactions, [specifically rolling back
+DB operations on each test.](#pytest)
+
 ## Usage
 
+### Pytest
+
+TODO detail out truncation and transactions
+
 ### Integrating Alembic
 
 `alembic init` will not work out of the box. You need to mutate a handful of files:
@@ -207,6 +226,7 @@ SQLModel & SQLAlchemy are tricky. Here are some useful internal tricks:
 * 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.
+* `get_engine().pool.stats()` is helpful for inspecting connection pools and limits\
 
 ### TypeID
 
@@ -270,6 +290,7 @@ https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d
 
 * https://github.com/woofz/sqlmodel-basecrud
 * https://github.com/0xthiagomartins/sqlmodel-controller
+* https://github.com/litestar-org/advanced-alchemy?tab=readme-ov-file
 
 ## Inspiration
 
@@ -282,4 +303,4 @@ https://github.com/DarylStark/my_data/blob/a17b8b3a8463b9953821b89fee895e272f94d
 
 ## Upstream Changes
 
-- [ ] https://github.com/fastapi/sqlmodel/pull/1293
+- [ ] https://github.com/fastapi/sqlmodel/pull/1293

activemodel-0.12.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+activemodel/__init__.py,sha256=q_lHQyIM70ApvjduTo9GtenQjJXsfYZsAAquD_51kF4,137
+activemodel/base_model.py,sha256=zku7nKOcN4_YpIpHjP3_sWeJWGTf141gUYtPPilY0MU,17359
+activemodel/celery.py,sha256=L1vKcO_HoPA5ZCfsXjxgPpDUMYDuoQMakGA9rppN7Lo,897
+activemodel/errors.py,sha256=wycWYmk9ws4TZpxvTdtXVy2SFESb8NqKgzdivBoF0vw,115
+activemodel/get_column_from_field_patch.py,sha256=wAEDm_ZvSqyJwfgkXVpxsevw11hd-7VLy7zuJG8Ak7Y,4986
+activemodel/logger.py,sha256=vU7QiGSy_AJuJFmClUocqIJ-Ltku_8C24ZU8L6fLJR0,53
+activemodel/query_wrapper.py,sha256=gXpEAAFpRqQNUbTubTX-qkMNHeztFnyxtjdJbplCkKA,2867
+activemodel/session_manager.py,sha256=Aqc96ByAgrcuRRPsMZiTN3tlSXUFZvM3U7N8vCO2TIk,6720
+activemodel/utils.py,sha256=tZlAk0G46g6dwYuN7dIr8xU9QC_aLZYqjDXYkGiCtUg,888
+activemodel/cli/__init__.py,sha256=HrgJjB5pRuE6hbwgy0Dw4oHvGZ47kH0LPVAdG9l6-vw,5021
+activemodel/mixins/__init__.py,sha256=05EQl2u_Wgf_wkly-GTaTsR7zWpmpKcb96Js7r_rZTw,160
+activemodel/mixins/pydantic_json.py,sha256=0pprGZA95BGZL4WOh--NJcvxLWey4YW85lLk4GGTjFM,3530
+activemodel/mixins/soft_delete.py,sha256=Ax4mGsQI7AVTE8c4GiWxpyB_W179-dDct79GtjP0owU,461
+activemodel/mixins/timestamps.py,sha256=C6QQNnzrNUOW1EAsMpEVpImEeTIYDMPP0wocEw2RDQw,1078
+activemodel/mixins/typeid.py,sha256=777btWRUW6YBGPApeaEdHQaoKmwblehukHzmkKoXv6o,1340
+activemodel/pytest/__init__.py,sha256=IJpD-BwJuPii5IxTJoOCryaq4_oyXNRj4RjlS5Plmc8,112
+activemodel/pytest/factories.py,sha256=d4Mt9Lto8Pqd2bXuxDSt92IeEzTM5VGL3rQwG8jY4x4,3475
+activemodel/pytest/plugin.py,sha256=QsHnaKmkFZjR_pUHLaU7tb47vrfcNU0zsvfBaN0g2f0,2509
+activemodel/pytest/transaction.py,sha256=KMQ7jHSU9Bf14rPwdVAFxxR9mZ41uRAXwiSQ3HAzkw0,5801
+activemodel/pytest/truncate.py,sha256=LeuG2fSq92oR-S1_gE-1Y3DhO48jw4ubMIRh2tb6U08,4780
+activemodel/types/__init__.py,sha256=y5fiGVtPJxGEhuf-TvyrkhM2yaKRcIWo6XAx-CFFjM8,31
+activemodel/types/sqlalchemy_protocol.py,sha256=2MSuGIp6pcIyiy8uK7qX3FLWABBMQOJGlIC969WRQdY,277
+activemodel/types/sqlalchemy_protocol.pyi,sha256=SP4Z50SGcw6qSexGgNd_4g6E_sQwpIE44vgNT4ncmeI,5667
+activemodel/types/typeid.py,sha256=qycqklKv5nKuCqjJRnxA-6MjtcWJ4vFUsAVBc1ySwfg,7865
+activemodel/types/typeid_patch.py,sha256=y6kiCJQ_NzeKfuI4UtRAs7QW_nEog5RIA_-k4HUBMkU,575
+activemodel-0.12.0.dist-info/METADATA,sha256=j9sLMrYMP-2pnGE5yFFYELUqgbO-H8uKNCFrpHgw-8Q,10724
+activemodel-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+activemodel-0.12.0.dist-info/entry_points.txt,sha256=rytVrsNgUT4oDiW9RvRH6JBTHQn0hPZLK-jzQt3dY9s,51
+activemodel-0.12.0.dist-info/licenses/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
+activemodel-0.12.0.dist-info/RECORD,,

activemodel-0.12.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+activemodel = activemodel.pytest.plugin

activemodel-0.11.0.dist-info/RECORD

@@ -1,25 +0,0 @@
-activemodel/__init__.py,sha256=q_lHQyIM70ApvjduTo9GtenQjJXsfYZsAAquD_51kF4,137
-activemodel/base_model.py,sha256=2lUcmOxS1i1K9qdKEVjI9vLpbFltUlh-cAfvGPYbXlI,16709
-activemodel/celery.py,sha256=L1vKcO_HoPA5ZCfsXjxgPpDUMYDuoQMakGA9rppN7Lo,897
-activemodel/errors.py,sha256=wycWYmk9ws4TZpxvTdtXVy2SFESb8NqKgzdivBoF0vw,115
-activemodel/get_column_from_field_patch.py,sha256=wAEDm_ZvSqyJwfgkXVpxsevw11hd-7VLy7zuJG8Ak7Y,4986
-activemodel/logger.py,sha256=vU7QiGSy_AJuJFmClUocqIJ-Ltku_8C24ZU8L6fLJR0,53
-activemodel/query_wrapper.py,sha256=rNdvueppMse2MIi-RafTEC34GPGRal_wqH2CzhmlWS8,2520
-activemodel/session_manager.py,sha256=9Yb5sPOUginIC7M0oB3dvxkhaidX2iKGFpV3lpXkKzw,5454
-activemodel/utils.py,sha256=g17UqkphzTmb6YdpmYwT1TM00eDiXXuWn39-xNiu0AA,2112
-activemodel/mixins/__init__.py,sha256=05EQl2u_Wgf_wkly-GTaTsR7zWpmpKcb96Js7r_rZTw,160
-activemodel/mixins/pydantic_json.py,sha256=0pprGZA95BGZL4WOh--NJcvxLWey4YW85lLk4GGTjFM,3530
-activemodel/mixins/soft_delete.py,sha256=Ax4mGsQI7AVTE8c4GiWxpyB_W179-dDct79GtjP0owU,461
-activemodel/mixins/timestamps.py,sha256=Q-IFljeVVJQqw3XHdOi7dkqzefiVg1zhJvq_bldpmjg,992
-activemodel/mixins/typeid.py,sha256=VjhORJ-wf3HT43DMmez6MmZTWjH7fb5c-7Qcdwgdiqg,1331
-activemodel/pytest/__init__.py,sha256=W9KKQHbPkyq0jrMXaiL8hG2Nsbjy_LN9HhvgGm8W_7g,98
-activemodel/pytest/transaction.py,sha256=ln-3N5tXHT0fqy6a8m_NIYg5AXAeA2hDuftQtFxNqi4,2600
-activemodel/pytest/truncate.py,sha256=IGiPLkUm2yyOKww6c6CKcVbwi2xAAFBopx9q2ABfu8w,1582
-activemodel/types/__init__.py,sha256=y5fiGVtPJxGEhuf-TvyrkhM2yaKRcIWo6XAx-CFFjM8,31
-activemodel/types/typeid.py,sha256=Vqzete8IvZ5SHKf3DW2eKIWxweIZvUN2kjhLNuOl3Cc,7753
-activemodel/types/typeid_patch.py,sha256=y6kiCJQ_NzeKfuI4UtRAs7QW_nEog5RIA_-k4HUBMkU,575
-activemodel-0.11.0.dist-info/METADATA,sha256=tNJjq1XJNFXkua5Ui7XCr6DR_qtSQvbK_f_UPtCwHTE,9986
-activemodel-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-activemodel-0.11.0.dist-info/entry_points.txt,sha256=YLX62TP_hR-n3HMBkdBex4W7XRiyOtIPkwy22puIjjQ,61
-activemodel-0.11.0.dist-info/licenses/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
-activemodel-0.11.0.dist-info/RECORD,,

activemodel-0.11.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-activemodel = python_package_template:main