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

activemodel-0.8.0.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: activemodel
+Version: 0.8.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: typeid-python>=0.3.1
+Description-Content-Type: text/markdown
+
+# 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
+
+## Getting Started
+
+First, setup your DB:
+
+```python
+import activemodel
+activemodel.init("sqlite:///database.db")
+```
+
+Create models:
+
+```python
+from activemodel import BaseModel
+from activemodel.mixins import TimestampsMixin, TypeIDMixin
+
+class User(
+    BaseModel,
+    # optionally, obviously
+    TimestampsMixin,
+    # you can use a different pk type, but why would you?
+    # put this mixin last otherwise `id` will not be the first column in the DB
+    TypeIDMixin("user"),
+    # wire this model into the DB, without this alembic will not generate a migration
+    table=True
+):
+    a_field: str
+```
+
+You'll need to create the models in the DB. Alembic is the best way to do it, but you can cheat as well:
+
+```python
+from sqlmodel import SQLModel
+
+SQLModel.metadata.create_all(get_engine())
+
+# now you can create a user!
+User(a_field="a").save()
+```
+
+Maybe you like JSON:
+
+```python
+from activemodel import BaseModel
+from pydantic import BaseModel as PydanticBaseModel
+from activemodel.mixins import PydanticJSONMixin, TypeIDMixin, TimestampsMixin
+
+class SubObject(PydanticBaseModel):
+    name: str
+    value: int
+
+class User(
+    BaseModel,
+    TimestampsMixin,
+    PydanticJSONMixin,
+    TypeIDMixin("user"),
+    table=True
+):
+    list_field: list[SubObject] = Field(sa_type=JSONB())
+```
+
+## Usage
+
+### Integrating Alembic
+
+`alembic init` will not work out of the box. You need to mutate a handful of files:
+
+* To import all of your models you want in your DB. [Here's my recommended way to do this.](https://github.com/iloveitaly/python-starter-template/blob/master/app/models/__init__.py)
+* Use your DB URL from the ENV
+* Target sqlalchemy metadata to the sqlmodel-generated metadata
+* Most likely you'll want to add [alembic-postgresql-enum](https://pypi.org/project/alembic-postgresql-enum/) so migrations work properly
+
+[Take a look at these scripts for an example of how to fully integrate Alembic into your development workflow.](https://github.com/iloveitaly/python-starter-template/blob/0af2c7e95217e34bde7357cc95be048900000e48/Justfile#L618-L712)
+
+Here's a diff from the bare `alembic init` from version `1.14.1`.
+
+```diff
+diff --git i/test/migrations/alembic.ini w/test/migrations/alembic.ini
+index 0d07420..a63631c 100644
+--- i/test/migrations/alembic.ini
++++ w/test/migrations/alembic.ini
+@@ -3,13 +3,14 @@
+ [alembic]
+ # path to migration scripts
+ # Use forward slashes (/) also on windows to provide an os agnostic path
+-script_location = .
++script_location = migrations
+ 
+ # template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+ # Uncomment the line below if you want the files to be prepended with date and time
+ # see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+ # for all available tokens
+ # file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
++file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(rev)s_%%(slug)s
+ 
+ # sys.path path, will be prepended to sys.path if present.
+ # defaults to the current working directory.
+diff --git i/test/migrations/env.py w/test/migrations/env.py
+index 36112a3..a1e15c2 100644
+--- i/test/migrations/env.py
++++ w/test/migrations/env.py
+@@ -1,3 +1,6 @@
++# fmt: off
++# isort: off
++
+ from logging.config import fileConfig
+ 
+ from sqlalchemy import engine_from_config
+@@ -14,11 +17,17 @@ config = context.config
+ if config.config_file_name is not None:
+     fileConfig(config.config_file_name)
+ 
++from sqlmodel import SQLModel
++from test.models import *
++from test.utils import database_url
++
++config.set_main_option("sqlalchemy.url", database_url())
++
+ # add your model's MetaData object here
+ # for 'autogenerate' support
+ # from myapp import mymodel
+ # target_metadata = mymodel.Base.metadata
+-target_metadata = None
++target_metadata = SQLModel.metadata
+ 
+ # other values from the config, defined by the needs of env.py,
+ # can be acquired:
+diff --git i/test/migrations/script.py.mako w/test/migrations/script.py.mako
+index fbc4b07..9dc78bb 100644
+--- i/test/migrations/script.py.mako
++++ w/test/migrations/script.py.mako
+@@ -9,6 +9,8 @@ from typing import Sequence, Union
+ 
+ from alembic import op
+ import sqlalchemy as sa
++import sqlmodel
++import activemodel
+ ${imports if imports else ""}
+ 
+ # revision identifiers, used by Alembic.
+```
+
+Here are some useful resources around Alembic + SQLModel:
+
+* https://github.com/fastapi/sqlmodel/issues/85
+* https://testdriven.io/blog/fastapi-sqlmodel/
+
+### Query Wrapper
+
+This tool is added to all `BaseModel`s and makes it easy to write SQL queries. Some examples:
+
+
+
+### Easy Database Sessions
+
+I hate the idea f 
+
+* Behavior should be intuitive and easy to understand. If you run `save()`, it should save, not stick the save in a transaction.
+* Don't worry about dead sessions. This makes it easy to lazy-load computed properties and largely eliminates the need to think about database sessions.
+
+There are a couple of thorny problems we need to solve for here:
+
+* In-memory fastapi servers are not the same as a uvicorn server, which is threaded *and* uses some sort of threadpool model for handling async requests. I don't claim to understand the entire implementation. For global DB session state (a) we can't use global variables (b) we can't use thread-local variables.
+* 
+
+https://github.com/tomwojcik/starlette-context
+
+### Example Queries
+
+* Conditional: `Scrape.select().where(Scrape.id < last_scraped.id).all()`
+* Equality: `MenuItem.select().where(MenuItem.menu_id == menu.id).all()`
+* `IN` example: `CanonicalMenuItem.select().where(col(CanonicalMenuItem.id).in_(canonized_ids)).all()`
+* Compound where query: `User.where((User.last_active_at != None) & (User.last_active_at > last_24_hours)).count()`
+
+### SQLModel Internals
+
+SQLModel & SQLAlchemy are tricky. Here are some useful internal tricks:
+
+* `__sqlmodel_relationships__` is where any `RelationshipInfo` objects are stored. This is used to generate relationship fields on the object.
+* `ModelClass.relationship_name.property.local_columns` 
+* Get cached fields from a model `object_state(instance).dict.get(field_name)`
+
+### TypeID
+
+I'm a massive fan of Stripe-style prefixed UUIDs. [There's an excellent project](https://github.com/jetify-com/typeid)
+that defined a clear spec for these IDs. I've used the python implementation of this spec and developed a clean integration
+with SQLModel that plays well with fastapi as well.
+
+Here's an example of defining a relationship:
+
+```python
+import uuid
+
+from activemodel import BaseModel
+from activemodel.mixins import TimestampsMixin, TypeIDMixin
+from activemodel.types import TypeIDType
+from sqlmodel import Field, Relationship
+
+from .patient import Patient
+
+class Appointment(
+    BaseModel,
+    # this adds an `id` field to the model with the correct type
+    TypeIDMixin("appointment"),
+    table=True
+):
+    # `foreign_key` is a activemodel method to generate the right `Field` for the relationship
+    # TypeIDType is really important here for fastapi serialization
+    doctor_id: TypeIDType = Doctor.foreign_key()
+    doctor: Doctor = Relationship()
+```
+
+## 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
+* https://github.com/0xthiagomartins/sqlmodel-controller
+
+## 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
+
+## Upstream Changes
+
+- [ ] https://github.com/fastapi/sqlmodel/pull/1293

activemodel-0.8.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+activemodel/__init__.py,sha256=q_lHQyIM70ApvjduTo9GtenQjJXsfYZsAAquD_51kF4,137
+activemodel/base_model.py,sha256=MM-TRlf_0DnCZHeNWxQ1S-VMq8JSBYybPfhtLZHZeRE,12066
+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=Vtg8Lf8vUNPegdRW-fyE-Ng5wtN3hTMfUezdFUiJ1fs,4585
+activemodel/utils.py,sha256=g17UqkphzTmb6YdpmYwT1TM00eDiXXuWn39-xNiu0AA,2112
+activemodel/mixins/__init__.py,sha256=05EQl2u_Wgf_wkly-GTaTsR7zWpmpKcb96Js7r_rZTw,160
+activemodel/mixins/pydantic_json.py,sha256=8A5X6QVzMSvDkBIb1impZ9PYskkUviG1UW7kkoxI8Wg,3057
+activemodel/mixins/soft_delete.py,sha256=Ax4mGsQI7AVTE8c4GiWxpyB_W179-dDct79GtjP0owU,461
+activemodel/mixins/timestamps.py,sha256=Q-IFljeVVJQqw3XHdOi7dkqzefiVg1zhJvq_bldpmjg,992
+activemodel/mixins/typeid.py,sha256=DGjlIg8PRBYoaBbWkkxc6jkScyl-p53KuSR98lLgAvE,1284
+activemodel/pytest/__init__.py,sha256=W9KKQHbPkyq0jrMXaiL8hG2Nsbjy_LN9HhvgGm8W_7g,98
+activemodel/pytest/transaction.py,sha256=GfUpGUiTHATooVfxU3FMF28FHljBVdfVcb51g2KMzhY,2593
+activemodel/pytest/truncate.py,sha256=IGiPLkUm2yyOKww6c6CKcVbwi2xAAFBopx9q2ABfu8w,1582
+activemodel/types/__init__.py,sha256=y5fiGVtPJxGEhuf-TvyrkhM2yaKRcIWo6XAx-CFFjM8,31
+activemodel/types/typeid.py,sha256=XrwCMvAkoZSeM5WhKH-aGJeiK0e9HoTXCheEDUgBBgQ,7292
+activemodel-0.8.0.dist-info/METADATA,sha256=niH50sWYcT1c8eprDrEhetodN2bx_otnMsuzpKQZAAk,9651
+activemodel-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+activemodel-0.8.0.dist-info/entry_points.txt,sha256=YLX62TP_hR-n3HMBkdBex4W7XRiyOtIPkwy22puIjjQ,61
+activemodel-0.8.0.dist-info/licenses/LICENSE,sha256=L8mmpX47rB-xtJ_HsK0zpfO6viEjxbLYGn70BMp8os4,1071
+activemodel-0.8.0.dist-info/RECORD,,

{activemodel-0.5.0.dist-info → activemodel-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

activemodel/_session_manager.py

@@ -1,153 +0,0 @@
-"""
-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.dist-info/METADATA

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

activemodel-0.5.0.dist-info/RECORD

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

activemodel-0.5.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-activemodel