activemodel 0.3.0__py3-none-any.whl

activemodel/__init__.py

@@ -0,0 +1,6 @@
+from .base_model import BaseModel
+from .query_wrapper import QueryWrapper
+from .timestamps import TimestampMixin
+
+# TODO need a way to specify the session generator
+# TODO need a way to specify the session generator

activemodel/base_model.py

@@ -0,0 +1,137 @@
+import json
+import typing as t
+
+import pydash
+import sqlalchemy as sa
+from sqlalchemy.orm import declared_attr
+from sqlmodel import Session, SQLModel
+
+from .query_wrapper import QueryWrapper
+
+
+class BaseModel(SQLModel):
+    """
+    Base model class to inherit from so we can hate python less
+
+    https://github.com/woofz/sqlmodel-basecrud/blob/main/sqlmodel_basecrud/basecrud.py
+    """
+
+    # TODO implement actually calling these hooks
+
+    def before_delete(self):
+        pass
+
+    def after_delete(self):
+        pass
+
+    def before_save(self):
+        pass
+
+    def after_save(self):
+        pass
+
+    def before_update(self):
+        pass
+
+    def after_update(self):
+        pass
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        """
+        Automatically generates the table name for the model by converting the class name from camel case to snake case.
+
+        By default, the class is lower cased which makes it harder to read.
+
+        Many snake_case libraries struggle with snake case for names like LLMCache, which is why we are using a more
+        complicated implementation from pydash.
+
+        https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case
+        """
+        return pydash.strings.snake_case(cls.__name__)
+
+    @classmethod
+    def select(cls, *args):
+        return QueryWrapper[cls](cls, *args)
+
+    def save(self):
+        old_session = Session.object_session(self)
+        with get_session() as session:
+            if old_session:
+                # I was running into an issue where the object was already
+                # associated with a session, but the session had been closed,
+                # to get around this, you need to remove it from the old one,
+                # then add it to the new one (below)
+                old_session.expunge(self)
+
+            self.before_update()
+            # self.before_save()
+
+            session.add(self)
+            session.commit()
+            session.refresh(self)
+
+            self.after_update()
+            # self.after_save()
+
+            return self
+
+            # except IntegrityError:
+            #     log.quiet(f"{self} already exists in the database.")
+            #     session.rollback()
+
+    # TODO shouldn't this be handled by pydantic?
+    def json(self, **kwargs):
+        return json.dumps(self.dict(), default=str, **kwargs)
+
+    @classmethod
+    def count(cls):
+        """
+        Returns the number of records in the database.
+        """
+        # TODO should move this to the wrapper
+        with get_session() as session:
+            query = sql.select(sql.func.count()).select_from(cls)
+            return session.exec(query).one()
+
+    # TODO what's super dangerous here is you pass a kwarg which does not map to a specific
+    #      field it will result in `True`, which will return all records, and not give you any typing
+    #      errors. Dangerous when iterating on structure quickly
+    # TODO can we pass the generic of the superclass in?
+    @classmethod
+    def get(cls, *args: sa.BinaryExpression, **kwargs: t.Any):
+        """
+        Gets a single record from the database. Pass an PK ID or a kwarg to filter by.
+        """
+
+        # special case for getting by ID
+        if len(args) == 1 and isinstance(args[0], int):
+            # TODO id is hardcoded, not good! Need to dynamically pick the best uid field
+            kwargs["id"] = args[0]
+            args = []
+
+        statement = sql.select(cls).filter(*args).filter_by(**kwargs)
+        with get_session() as session:
+            return session.exec(statement).first()
+
+    @classmethod
+    def all(cls):
+        with get_session() as session:
+            results = session.exec(sql.select(cls))
+
+            # TODO do we need this or can we just return results?
+            for result in results:
+                yield result
+
+    @classmethod
+    def sample(cls):
+        """
+        Pick a random record from the database.
+
+        Helpful for testing and console debugging.
+        """
+
+        query = sql.select(cls).order_by(sql.func.random()).limit(1)
+
+        with get_session() as session:
+            return session.exec(query).one()

activemodel/query_wrapper.py

@@ -0,0 +1,84 @@
+from typing import Generic, TypeVar
+
+from sqlmodel.sql.expression import SelectOfScalar
+
+WrappedModelType = TypeVar("WrappedModelType")
+
+
+def compile_sql(target: SelectOfScalar):
+    return str(target.compile(get_engine().connect()))
+
+
+class QueryWrapper(Generic[WrappedModelType]):
+    """
+    Make it easy to run queries off of a model
+    """
+
+    def __init__(self, cls, *args) -> None:
+        # TODO add generics here
+        # self.target: SelectOfScalar[T] = sql.select(cls)
+
+        if args:
+            # very naive, let's assume the args are specific select statements
+            self.target = sql.select(*args).select_from(cls)
+        else:
+            self.target = sql.select(cls)
+
+    # TODO the .exec results should be handled in one shot
+
+    def first(self):
+        with get_session() as session:
+            return session.exec(self.target).first()
+
+    def one(self):
+        with get_session() as session:
+            return session.exec(self.target).one()
+
+    def all(self):
+        with get_session() as session:
+            result = session.exec(self.target)
+            for row in result:
+                yield row
+
+    def exec(self):
+        # TODO do we really need a unique session each time?
+        with get_session() as session:
+            return session.exec(self.target)
+
+    def delete(self):
+        with get_session() as session:
+            session.delete(self.target)
+
+    def __getattr__(self, name):
+        """
+        This is called to retrieve the function to execute
+        """
+
+        # TODO prefer methods defined in this class
+        if not hasattr(self.target, name):
+            return super().__getattribute__(name)
+
+        attr = getattr(self.target, name)
+
+        if callable(attr):
+
+            def wrapper(*args, **kwargs):
+                result = attr(*args, **kwargs)
+                self.target = result
+                return self
+
+            return wrapper
+
+        # If the attribute or method is not defined in this class,
+        # delegate the call to the `target` object
+        return getattr(self.target, name)
+
+    def sql(self):
+        """
+        Output the raw SQL of the query
+        """
+
+        return compile_sql(self.target)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}: Current SQL:\n{self.sql()}"

activemodel/timestamps.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+import sqlalchemy as sa
+
+# TODO raw sql https://github.com/tiangolo/sqlmodel/discussions/772
+from sqlmodel import Field
+
+# @classmethod
+# def select(cls):
+#     with get_session() as session:
+#         results = session.exec(sql.select(cls))
+
+#         for result in results:
+#             yield result
+
+
+class TimestampMixin:
+    """
+    Simple created at and updated at timestamps. Mix them into your model:
+
+    >>> class MyModel(TimestampMixin, SQLModel):
+    >>>    pass
+
+    Originally pulled from: https://github.com/tiangolo/sqlmodel/issues/252
+    """
+
+    created_at: datetime | None = Field(
+        default=None,
+        sa_type=sa.DateTime(timezone=True),
+        sa_column_kwargs={"server_default": sa.func.now()},
+        nullable=False,
+    )
+
+    updated_at: datetime | None = Field(
+        default=None,
+        sa_type=sa.DateTime(timezone=True),
+        sa_column_kwargs={"onupdate": sa.func.now(), "server_default": sa.func.now()},
+    )

activemodel-0.3.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Michael Bianco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

activemodel-0.3.0.dist-info/METADATA

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

activemodel-0.3.0.dist-info/RECORD

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

activemodel-0.3.0.dist-info/WHEEL

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

activemodel-0.3.0.dist-info/entry_points.txt

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

activemodel-0.3.0.dist-info/top_level.txt

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