activemodel 0.13.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

activemodel/base_model.py

@@ -15,7 +15,7 @@ from sqlalchemy.orm import declared_attr
 from activemodel.mixins.pydantic_json import PydanticJSONMixin
 
 # NOTE: this patches a core method in sqlmodel to support db comments
-from . import get_column_from_field_patch  # noqa: F401
+from .patches import get_column_from_field_patch  # noqa: F401
 from .query_wrapper import QueryWrapper
 from .session_manager import get_session
 
@@ -72,11 +72,9 @@ class BaseModel(SQLModel):
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
 
-        from sqlmodel._compat import set_config_value
-
         # Enables field-level docstrings on the pydantic `description` field, which we
         # copy into table/column comments by patching SQLModel internals elsewhere.
-        set_config_value(model=cls, parameter="use_attribute_docstrings", value=True)
+        cls.model_config["use_attribute_docstrings"] = True
 
         cls._apply_class_doc()
 
@@ -290,7 +288,7 @@ class BaseModel(SQLModel):
     # TODO where is this actually used? shoudl prob remove this
     # TODO should we even do this? Can we specify a better json rendering class?
     def json(self, **kwargs):
-        return json.dumps(self.dict(), default=str, **kwargs)
+        return json.dumps(self.model_dump(), default=str, **kwargs)
 
     # TODO should move this to the wrapper
     @classmethod
@@ -325,7 +323,7 @@ class BaseModel(SQLModel):
         assert len(args) > 0, "Must pass at least one field name"
 
         for field_name in args:
-            if field_name not in self.__fields__:
+            if field_name not in self.model_fields:
                 raise ValueError(f"Field '{field_name}' does not exist in the model.")
 
             # check if the field exists

activemodel/mixins/pydantic_json.py

@@ -6,9 +6,9 @@ SQLModel lacks a direct JSONField equivalent (like Tortoise ORM's JSONField), ma
 Extensive discussion on the problem: https://github.com/fastapi/sqlmodel/issues/63
 """
 
-from types import UnionType
 from typing import get_args, get_origin
-
+import typing
+import types
 from pydantic import BaseModel as PydanticBaseModel
 from sqlalchemy.orm import reconstructor, attributes
 
@@ -21,6 +21,11 @@ class PydanticJSONMixin:
 
     >>> class ExampleWithJSON(BaseModel, PydanticJSONMixin, table=True):
     >>>    list_field: list[SubObject] = Field(sa_type=JSONB()
+
+    Notes:
+
+    - Tuples of pydantic models are not supported, only lists.
+    - Nested lists of pydantic models are not supported, e.g. list[list[SubObject]]
     """
 
     @reconstructor
@@ -37,6 +42,7 @@ class PydanticJSONMixin:
         for field_name, field_info in self.model_fields.items():
             raw_value = getattr(self, field_name, None)
 
+            # if the field is not set on the model, we can avoid doing anything with it
             if raw_value is None:
                 continue
 
@@ -44,32 +50,43 @@ class PydanticJSONMixin:
             origin = get_origin(annotation)
 
             # e.g. `dict` or `dict[str, str]`, we don't want to do anything with these
-            if origin is dict:
+            if origin in (dict, tuple):
                 continue
 
             annotation_args = get_args(annotation)
             is_top_level_list = origin is list
+            model_cls = annotation
 
+            # TODO not sure what was going on here...
             # if origin is not None:
             #     assert annotation.__class__ == origin
 
-            model_cls = annotation
+            # UnionType is only one way of defining an optional. If older typing syntax is used `Tuple[str] | None` the
+            # type annotation is different: `typing.Optional[typing.Tuple[float, float]]`. This is why we check both
+            # types below.
 
             # e.g. SomePydanticModel | None or list[SomePydanticModel] | None
-            # annotation_args are (type, NoneType) in this case
-            if isinstance(annotation, UnionType):
+            # annotation_args are (type, NoneType) in this case. Remove NoneType.
+            if origin in (typing.Union, types.UnionType):
                 non_none_types = [t for t in annotation_args if t is not type(None)]
 
                 if len(non_none_types) == 1:
                     model_cls = non_none_types[0]
+                else:
+                    # if there's more than one non-none type, it isn't meant to be serialized to JSON
+                    pass
+
+            model_cls_origin = get_origin(model_cls)
 
             # e.g. list[SomePydanticModel] | None, we have to unpack it
             # model_cls will print as a list, but it contains a subtype if you dig into it
             if (
-                get_origin(model_cls) is list
+                model_cls_origin is list
                 and len(list_annotation_args := get_args(model_cls)) == 1
             ):
                 model_cls = list_annotation_args[0]
+                model_cls_origin = get_origin(model_cls)
+
                 is_top_level_list = True
 
             # e.g. list[SomePydanticModel] or list[SomePydanticModel] | None
@@ -82,6 +99,9 @@ class PydanticJSONMixin:
                     attributes.set_committed_value(self, field_name, parsed_value)
                 continue
 
+            if model_cls_origin in (list, tuple):
+                continue
+
             # single class
             if issubclass(model_cls, PydanticBaseModel):
                 attributes.set_committed_value(self, field_name, model_cls(**raw_value))

activemodel/patches/__init__.py

@@ -0,0 +1,2 @@
+# NOTE: this patches a core method in sqlmodel to support db comments
+from . import get_column_from_field_patch  # noqa: F401

activemodel/{get_column_from_field_patch.py → patches/get_column_from_field_patch.py}

@@ -13,26 +13,23 @@ Some ideas for this originally sourced from: https://github.com/fastapi/sqlmodel
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Sequence,
     cast,
 )
 
 import sqlmodel
-from pydantic.fields import FieldInfo as PydanticFieldInfo
 from sqlalchemy import (
     Column,
     ForeignKey,
 )
 from sqlmodel._compat import (  # type: ignore[attr-defined]
-    IS_PYDANTIC_V2,
     ModelMetaclass,
     Representation,
     Undefined,
     UndefinedType,
     is_field_noneable,
 )
-from sqlmodel.main import FieldInfo, get_sqlalchemy_type
+from sqlmodel.main import get_sqlalchemy_type
 
 from activemodel.utils import hash_function_code
 
@@ -43,37 +40,31 @@ if TYPE_CHECKING:
     from pydantic_core import PydanticUndefinedType as UndefinedType
 
 
+# https://github.com/fastapi/sqlmodel/blob/5c2dbe419edc2d15200eee5269c9508987944ed8/sqlmodel/main.py#L691
 assert (
     hash_function_code(sqlmodel.main.get_column_from_field)
-    == "398006ef8fd8da191ca1a271ef25b6e135da0f400a80df2f29526d8674f9ec51"
+    == "ab3cdd5d20079358911b6aef76b3916ba3890b20eb07e970a0f35bd63e1713d9"
+), (
+    f"get_column_from_field has changed, please verify the patch is still valid: {hash_function_code(sqlmodel.main.get_column_from_field)}"
 )
 
 
-def get_column_from_field(field: PydanticFieldInfo | FieldInfo) -> Column:  # type: ignore
-    """
-    Takes a field definition, which can either come from the sqlmodel FieldInfo class or the pydantic variant of that class,
-    and converts it into a sqlalchemy Column object.
-    """
-    if IS_PYDANTIC_V2:
-        field_info = field
-    else:
-        field_info = field.field_info
-
+def get_column_from_field(field: Any) -> Column:  # type: ignore
+    field_info = field
     sa_column = getattr(field_info, "sa_column", Undefined)
     if isinstance(sa_column, Column):
-        # IMPORTANT: change from the original function
+        # <Change>
         if not sa_column.comment and (field_comment := field_info.description):
             sa_column.comment = field_comment
+        # </Change>
         return sa_column
-
+    sa_type = get_sqlalchemy_type(field)
     primary_key = getattr(field_info, "primary_key", Undefined)
     if primary_key is Undefined:
         primary_key = False
-
     index = getattr(field_info, "index", Undefined)
     if index is Undefined:
         index = False
-
     nullable = not primary_key and is_field_noneable(field)
     # Override derived nullability if the nullable property is set explicitly
     # on the field
@@ -103,7 +94,6 @@ def get_column_from_field(field: PydanticFieldInfo | FieldInfo) -> Column:  # ty
         "index": index,
         "unique": unique,
     }
-
     sa_default = Undefined
     if field_info.default_factory:
         sa_default = field_info.default_factory
@@ -111,14 +101,12 @@ def get_column_from_field(field: PydanticFieldInfo | FieldInfo) -> Column:  # ty
         sa_default = field_info.default
     if sa_default is not Undefined:
         kwargs["default"] = sa_default
-
     sa_column_args = getattr(field_info, "sa_column_args", Undefined)
     if sa_column_args is not Undefined:
         args.extend(list(cast(Sequence[Any], sa_column_args)))
-
     sa_column_kwargs = getattr(field_info, "sa_column_kwargs", Undefined)
 
-    # IMPORTANT: change from the original function
+    # <Change>
     if field_info.description:
         if sa_column_kwargs is Undefined:
             sa_column_kwargs = {}
@@ -128,11 +116,10 @@ def get_column_from_field(field: PydanticFieldInfo | FieldInfo) -> Column:  # ty
         # only update comments if not already set
         if "comment" not in sa_column_kwargs:
             sa_column_kwargs["comment"] = field_info.description
+    # </Change>
 
     if sa_column_kwargs is not Undefined:
-        kwargs.update(cast(Dict[Any, Any], sa_column_kwargs))
-
-    sa_type = get_sqlalchemy_type(field)
+        kwargs.update(cast(dict[Any, Any], sa_column_kwargs))
     return Column(sa_type, *args, **kwargs)  # type: ignore
 
 

activemodel/pytest/factories.py

@@ -12,6 +12,7 @@ from polyfactory.field_meta import FieldMeta
 from typeid import TypeID
 
 from activemodel.session_manager import global_session
+from activemodel.logger import logger
 
 # TODO not currently used
 # def type_id_provider(cls, field_meta):
@@ -56,11 +57,20 @@ class ActiveModelFactory[T](SQLModelFactory[T]):
     @classmethod
     def save(cls, *args, **kwargs) -> T:
         """
+        Builds and persists a new model to the database.
+
         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.
+        a factory uses other factories to create relationships. This is fine if `__sqlalchemy_session__` is set, but
+        if it's not (in the case of a truncation DB strategy) you'll run into issues.
 
         In a truncation strategy, the __sqlalchemy_session__ is set to None.
         """
+
+        if cls.__sqlalchemy_session__ is None:
+            logger.warning(
+                "No __sqlalchemy_session__ set on factory class, nested factory save() will fail. Use `db_session` or `db_truncate_session` to avoid this."
+            )
+
         with global_session(cls.__sqlalchemy_session__):
             return cls.build(*args, **kwargs).save()
 
@@ -74,6 +84,7 @@ class ActiveModelFactory[T](SQLModelFactory[T]):
         # 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(
+            # gets the prefix associated with the pk field
             cls.__model__.model_fields[primary_key_name].sa_column.type.prefix
         )
 

activemodel/pytest/plugin.py

@@ -2,8 +2,8 @@
 
 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
+* ``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:
@@ -28,7 +28,10 @@ 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
+from .transaction import (
+    set_factory_sessions,
+    test_session,
+)
 
 
 def pytest_addoption(
@@ -53,7 +56,7 @@ def pytest_addoption(
 @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
+    Helpful for tests that are 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.
 
@@ -71,11 +74,12 @@ 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
+    When using a truncation cleaning strategy, no global test session is set. This means all models that are created
+    are tied to a detached session, which makes it hard to mutate models after creation. This fixture fixes that problem
+    by setting the session used by all model factories to a global session.
     """
     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)
+        set_factory_sessions(session)
 
         yield session

activemodel/pytest/transaction.py

@@ -41,6 +41,13 @@ def set_polyfactory_session(session):
     ActiveModelFactory.__sqlalchemy_session__ = session
 
 
+def set_factory_sessions(session):
+    "set all supported model factories to use the provided session"
+
+    set_factory_session(session)
+    set_polyfactory_session(session)
+
+
 @contextlib.contextmanager
 def test_session():
     """

activemodel/pytest/truncate.py

@@ -1,7 +1,6 @@
 import os
 from typing import Iterable
 
-import pytest
 from sqlmodel import SQLModel
 
 from ..logger import logger

activemodel/query_wrapper.py

@@ -1,5 +1,6 @@
 import sqlmodel as sm
 from sqlmodel.sql.expression import SelectOfScalar
+from typing import overload, Literal
 
 from activemodel.types.sqlalchemy_protocol import SQLAlchemyQueryMethods
 
@@ -48,6 +49,8 @@ class QueryWrapper[T: sm.SQLModel](SQLAlchemyQueryMethods[T]):
         with get_session() as session:
             return session.scalar(sm.select(sm.func.count()).select_from(self.target))
 
+    # TODO typing is broken here
+    # TODO would be great to define a default return type if nothing is found
     def scalar(self):
         """
         >>>
@@ -63,6 +66,17 @@ class QueryWrapper[T: sm.SQLModel](SQLAlchemyQueryMethods[T]):
         with get_session() as session:
             return session.delete(self.target)
 
+    def exists(self) -> bool:
+        """Return True if the current query yields at least one row.
+
+        Uses the SQLAlchemy exists() construct against a LIMIT 1 version of
+        the current target for efficiency. Keeps the original target intact.
+        """
+        with get_session() as session:
+            exists_stmt = sm.select(sm.exists(self.target))
+            result = session.scalar(exists_stmt)
+            return bool(result)
+
     def __getattr__(self, name):
         """
         This implements the magic that forwards function calls to sqlalchemy.
@@ -79,7 +93,7 @@ class QueryWrapper[T: sm.SQLModel](SQLAlchemyQueryMethods[T]):
 
             def wrapper(*args, **kwargs):
                 result = sqlalchemy_target(*args, **kwargs)
-                self.target = result
+                self.target = result  # type: ignore[assignment]
                 return self
 
             return wrapper
@@ -95,6 +109,48 @@ class QueryWrapper[T: sm.SQLModel](SQLAlchemyQueryMethods[T]):
 
         return compile_sql(self.target)
 
+    @overload
+    def sample(self) -> T | None: ...
+
+    @overload
+    def sample(self, n: Literal[1]) -> T | None: ...
+
+    @overload
+    def sample(self, n: int) -> list[T]: ...
+
+    def sample(self, n: int = 1) -> T | None | list[T]:
+        """Return a random sample of rows from the current query.
+
+        Parameters
+        ----------
+        n: int
+            Number of rows to return. Defaults to 1.
+
+        Behavior
+        --------
+        - Returns a single model instance when ``n == 1`` (or ``None`` if no rows)
+        - Returns a list[Model] when ``n > 1`` (possibly empty list when no rows)
+        - Sampling is performed by appending an ``ORDER BY RANDOM()`` / ``func.random()``
+          and ``LIMIT n`` clause to the existing query target.
+        - Keeps original query intact (does not mutate ``self.target``) so further
+          chaining works as expected.
+        """
+
+        if n < 1:
+            raise ValueError("n must be >= 1")
+
+        # Build a new randomized limited query leaving self.target untouched
+        randomized = self.target.order_by(sm.func.random()).limit(n)
+
+        with get_session() as session:
+            result = list(session.exec(randomized))
+
+        if n == 1:
+            # Return the single instance or None
+            return result[0] if result else None
+
+        return result
+
     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

@@ -150,6 +150,14 @@ def global_session(session: Session | None = None):
     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.
 
+    In complex testing code, you'll need to be careful here. For example:
+
+    - Unit test using a transaction db fixture (which sets __sqlalchemy_session__)
+    - Factory has a after_save hook
+    - That hook triggers a celery job
+    - The celery job (properly) calls `with global_session()`
+    - However, since `global_session()` is already set with __sqlalchemy_session__, this will raise an error
+
     Args:
         session: Use an existing session instead of creating a new one
     """

activemodel/types/sqlalchemy_protocol.py

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

activemodel/types/sqlalchemy_protocol.pyi

@@ -1,6 +1,6 @@
 # IMPORTANT: This file is auto-generated. Do not edit directly.
 
-from typing import Protocol, TypeVar, Any, Generic
+from typing import Protocol, Any
 import sqlmodel as sm
 from sqlalchemy.sql.base import _NoArg
 

activemodel/types/typeid_patch.py

@@ -1,3 +1,9 @@
+"""
+Pydantic v2 support for TypeID.
+
+TODO should push this upstream to the typeid package
+"""
+
 from typing import Any, Type
 
 from pydantic import GetCoreSchemaHandler

{activemodel-0.13.0.dist-info → activemodel-0.14.1.dist-info}/METADATA

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: activemodel
-Version: 0.13.0
+Version: 0.14.1
 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-Python: >=3.12
 Requires-Dist: python-decouple-typed>=3.11.0
-Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: sqlmodel>=0.0.27
 Requires-Dist: textcase>=0.4.0
-Requires-Dist: typeid-python>=0.3.1
+Requires-Dist: typeid-python==0.3.3
 Description-Content-Type: text/markdown
 
 # ActiveModel: ORM Wrapper for SQLModel
@@ -290,7 +290,8 @@ 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
+* https://github.com/litestar-org/advanced-alchemy
+* https://github.com/dialoguemd/fastapi-sqla
 
 ## Inspiration
 

activemodel-0.14.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+activemodel/__init__.py,sha256=q_lHQyIM70ApvjduTo9GtenQjJXsfYZsAAquD_51kF4,137
+activemodel/base_model.py,sha256=qSbC_42o_kPEBx22Pl6AgrAwd6U-eNRBaenkFQmx-Ns,17430
+activemodel/celery.py,sha256=L1vKcO_HoPA5ZCfsXjxgPpDUMYDuoQMakGA9rppN7Lo,897
+activemodel/errors.py,sha256=wycWYmk9ws4TZpxvTdtXVy2SFESb8NqKgzdivBoF0vw,115
+activemodel/logger.py,sha256=vU7QiGSy_AJuJFmClUocqIJ-Ltku_8C24ZU8L6fLJR0,53
+activemodel/query_wrapper.py,sha256=DLfmpMQr5veBjQIU2KEsp7Pe3MvdxQ-R-C6tkj0SgU8,4832
+activemodel/session_manager.py,sha256=4jK0rs3KxU84WOvHCX6iuy0mauJg02tQ2VUQj-OEk68,7124
+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=Nm8Y0ra7N-2lEvLHtmZYq1XE1-4n2BIff812DzKgOb4,4461
+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/patches/__init__.py,sha256=Jc6yYPtNCOBI6AdbKfeYUfLikpEdFyefM6h3nTLRID8,126
+activemodel/patches/get_column_from_field_patch.py,sha256=HRAljRDxWF03kA4wICWDO9KUKToVzESYp1tbKs-bg5A,4798
+activemodel/pytest/__init__.py,sha256=IJpD-BwJuPii5IxTJoOCryaq4_oyXNRj4RjlS5Plmc8,112
+activemodel/pytest/factories.py,sha256=o9kBVCESZUD4ypTVfG2_FD2Zew3mAcnguVhagDH1Ry8,4016
+activemodel/pytest/plugin.py,sha256=IbRKTCjYnay0N5ucTK7PmA9ETx4OQOuR5hlFf3Lyez4,2681
+activemodel/pytest/transaction.py,sha256=ZeGj_7gaGREjZBqlPC9JhwouDOTUhqblT3070OyybII,5977
+activemodel/pytest/truncate.py,sha256=YcDxNXF074VWP8IHnTU4K8bxnQTNKuaNi1ZyCUpLqro,4766
+activemodel/types/__init__.py,sha256=y5fiGVtPJxGEhuf-TvyrkhM2yaKRcIWo6XAx-CFFjM8,31
+activemodel/types/sqlalchemy_protocol.py,sha256=Uc8hKmTdx0boNQAthNYQNCbfxRwz0mGH044mvjZCj0A,182
+activemodel/types/sqlalchemy_protocol.pyi,sha256=yhLXOiZtCHOLA6YNPu_-xSiUJhfi8dyfjcmcAFhDY-Y,5649
+activemodel/types/typeid.py,sha256=qycqklKv5nKuCqjJRnxA-6MjtcWJ4vFUsAVBc1ySwfg,7865
+activemodel/types/typeid_patch.py,sha256=Wkt8Ok_y49vEpuvhR8iB2xOcuFqa7vGC2RXYPcF6WZ0,670
+activemodel-0.14.1.dist-info/METADATA,sha256=EUnStn5l6Cm_uTEu5BJBl6M_o9ROsnPEq2ya_BebwI8,10750
+activemodel-0.14.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+activemodel-0.14.1.dist-info/entry_points.txt,sha256=rytVrsNgUT4oDiW9RvRH6JBTHQn0hPZLK-jzQt3dY9s,51
+activemodel-0.14.1.dist-info/licenses/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
+activemodel-0.14.1.dist-info/RECORD,,

{activemodel-0.13.0.dist-info → activemodel-0.14.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

activemodel-0.13.0.dist-info/RECORD

@@ -1,30 +0,0 @@
-activemodel/__init__.py,sha256=q_lHQyIM70ApvjduTo9GtenQjJXsfYZsAAquD_51kF4,137
-activemodel/base_model.py,sha256=0QRs2C_QtJFx6voSWr0jFXsbEgtn_PmYA2rrwejVzCU,17496
-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.13.0.dist-info/METADATA,sha256=744GzqxDiyQQYxv5jlVcC8PBDLj8Xj0gL7P49oM3buI,10724
-activemodel-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-activemodel-0.13.0.dist-info/entry_points.txt,sha256=rytVrsNgUT4oDiW9RvRH6JBTHQn0hPZLK-jzQt3dY9s,51
-activemodel-0.13.0.dist-info/licenses/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
-activemodel-0.13.0.dist-info/RECORD,,