dbdm 0.1.0__tar.gz

dbdm-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Roma Koshel
+
+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.

dbdm-0.1.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.1
+Name: dbdm
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: Roman Koshel
+Author-email: roma.koshel@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Dist: asyncpg
+Requires-Dist: sqlalchemy[asyncio] (>=2,<3)
+Description-Content-Type: text/markdown
+
+# DBDM [wip]
+
+
+## Examples
+
+```python
+from typing import ClassVar, Type
+
+import sqlalchemy as sa
+
+from cwtch import dataclass, resolve_types, view
+from cwtch.types import UNSET, Unset
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from dbdm import DM, NotFoundError, bind_engine
+
+
+class BaseDB(DeclarativeBase):
+    pass
+
+
+class ParentDB(BaseDB):
+    __tablename__ = "parents"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str]
+    data: Mapped[str]
+    children = relationship("ChildDB", uselist=True, viewonly=True)
+
+
+class ChildDB(BaseDB):
+    __tablename__ = "children"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str]
+    parent_id: Mapped[int] = mapped_column(sa.ForeignKey("parents.id"))
+    parent = relationship("ParentDB", uselist=False, viewonly=True)
+
+
+@dataclass(handle_circular_refs=True)
+class Parent:
+    id: int
+    name: str
+    data: str
+    children: Unset[list["Child"]] = UNSET
+
+    # Parent views
+    Create: ClassVar[Type["ParentCreate"]]
+    Save: ClassVar[Type["ParentSave"]]
+    Update: ClassVar[Type["ParentUpdate"]]
+
+
+@view(Parent, "Create", exclude=["id", "children"])
+class ParentCreate:
+    pass
+
+
+@view(Parent, "Save", exclude=["children"])
+class ParentSave:
+    pass
+
+
+@view(Parent, "Update", exclude=["children"])
+class ParentUpdate:
+    name: Unset[str] = UNSET
+    data: Unset[str] = UNSET
+
+
+@dataclass(handle_circular_refs=True)
+class Child:
+    id: int
+    name: str
+    parent_id: int
+    parent: Unset[Parent] = UNSET
+
+    # Child views
+    Create: ClassVar[Type["ChildCreate"]]
+    Save: ClassVar[Type["ChildSave"]]
+    Update: ClassVar[Type["ChildUpdate"]]
+
+
+@view(Child, "Create", exclude=["id", "parent"])
+class ChildCreate:
+    pass
+
+
+@view(Child, "Save", exclude=["parent"])
+class ChildSave:
+    pass
+
+
+@view(Child, "Update", exclude=["parent"])
+class ChildUpdate:
+    name: Unset[str] = UNSET
+    parent_id: Unset[int] = UNSET
+
+
+resolve_types(Parent, globals(), locals())
+
+
+class ParentDM(DM):
+    model_db = ParentDB
+    model = Parent
+    model_create = Parent.Create
+    model_save = Parent.Save
+    model_update = Parent.Update
+    key = "id"
+    index_elements = ["id"]
+    joinedload = {"children": lambda m: sa.orm.joinedload(m.children)}
+
+
+class ChildDM(DM):
+    model_db = ChildDB
+    model = Child
+    model_create = Child.Create
+    model_save = Child.Save
+    model_update = Child.Update
+    key = "id"
+    index_elements = ["id"]
+    joinedload = {"parent": lambda m: sa.orm.joinedload(m.parent)}
+
+
+@pytest_asyncio.fixture
+async def create_all(engine):
+    async with engine.begin() as conn:
+        await conn.run_sync(BaseDB.metadata.create_all)
+
+
+async def example(engine):
+    engine = create_async_engine(...)
+
+    async with engine.begin() as conn:
+        await conn.run_sync(BaseDB.metadata.create_all)
+
+    bind_engine(engine)
+
+    parent = await ParentDM.create(Parent.Create(name=f"Parent_{i}", data="data"))
+
+    # parents: list[Parent]
+    total, parents = await ParentDM.get_many()
+
+    # parents: list[Parent]
+    total, parents = await ParentDM.get_many(page_size=1)
+
+    # parents: list[Parent]
+    total, parents = await ParentDM.get_many(page_size=1, page=2)
+
+    # parent: Parent
+    parent = await ParentDM.get(1)
+
+    # parent: Parent
+    parent = await ParentDM.get(1, joinedload={"children": True})
+
+    # parent: Parent
+    parent = await ParentDM.save(parent.Save())
+
+    # parent: Parent
+    parent = await ParentDM.update(Parent.Update(id=1, data="new data"), key="id")
+
+    await ParentDM.delete(1)
+
+    # child : Child 
+    child = await ChildDM.create(Child.Create(name=f"Child_{i}", parent_id=i))
+
+    # parent: Parent
+    parent = await ParentDM.get(1, joinedload={"children": True})
+```
+

dbdm-0.1.0/README.md

@@ -0,0 +1,168 @@
+# DBDM [wip]
+
+
+## Examples
+
+```python
+from typing import ClassVar, Type
+
+import sqlalchemy as sa
+
+from cwtch import dataclass, resolve_types, view
+from cwtch.types import UNSET, Unset
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from dbdm import DM, NotFoundError, bind_engine
+
+
+class BaseDB(DeclarativeBase):
+    pass
+
+
+class ParentDB(BaseDB):
+    __tablename__ = "parents"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str]
+    data: Mapped[str]
+    children = relationship("ChildDB", uselist=True, viewonly=True)
+
+
+class ChildDB(BaseDB):
+    __tablename__ = "children"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str]
+    parent_id: Mapped[int] = mapped_column(sa.ForeignKey("parents.id"))
+    parent = relationship("ParentDB", uselist=False, viewonly=True)
+
+
+@dataclass(handle_circular_refs=True)
+class Parent:
+    id: int
+    name: str
+    data: str
+    children: Unset[list["Child"]] = UNSET
+
+    # Parent views
+    Create: ClassVar[Type["ParentCreate"]]
+    Save: ClassVar[Type["ParentSave"]]
+    Update: ClassVar[Type["ParentUpdate"]]
+
+
+@view(Parent, "Create", exclude=["id", "children"])
+class ParentCreate:
+    pass
+
+
+@view(Parent, "Save", exclude=["children"])
+class ParentSave:
+    pass
+
+
+@view(Parent, "Update", exclude=["children"])
+class ParentUpdate:
+    name: Unset[str] = UNSET
+    data: Unset[str] = UNSET
+
+
+@dataclass(handle_circular_refs=True)
+class Child:
+    id: int
+    name: str
+    parent_id: int
+    parent: Unset[Parent] = UNSET
+
+    # Child views
+    Create: ClassVar[Type["ChildCreate"]]
+    Save: ClassVar[Type["ChildSave"]]
+    Update: ClassVar[Type["ChildUpdate"]]
+
+
+@view(Child, "Create", exclude=["id", "parent"])
+class ChildCreate:
+    pass
+
+
+@view(Child, "Save", exclude=["parent"])
+class ChildSave:
+    pass
+
+
+@view(Child, "Update", exclude=["parent"])
+class ChildUpdate:
+    name: Unset[str] = UNSET
+    parent_id: Unset[int] = UNSET
+
+
+resolve_types(Parent, globals(), locals())
+
+
+class ParentDM(DM):
+    model_db = ParentDB
+    model = Parent
+    model_create = Parent.Create
+    model_save = Parent.Save
+    model_update = Parent.Update
+    key = "id"
+    index_elements = ["id"]
+    joinedload = {"children": lambda m: sa.orm.joinedload(m.children)}
+
+
+class ChildDM(DM):
+    model_db = ChildDB
+    model = Child
+    model_create = Child.Create
+    model_save = Child.Save
+    model_update = Child.Update
+    key = "id"
+    index_elements = ["id"]
+    joinedload = {"parent": lambda m: sa.orm.joinedload(m.parent)}
+
+
+@pytest_asyncio.fixture
+async def create_all(engine):
+    async with engine.begin() as conn:
+        await conn.run_sync(BaseDB.metadata.create_all)
+
+
+async def example(engine):
+    engine = create_async_engine(...)
+
+    async with engine.begin() as conn:
+        await conn.run_sync(BaseDB.metadata.create_all)
+
+    bind_engine(engine)
+
+    parent = await ParentDM.create(Parent.Create(name=f"Parent_{i}", data="data"))
+
+    # parents: list[Parent]
+    total, parents = await ParentDM.get_many()
+
+    # parents: list[Parent]
+    total, parents = await ParentDM.get_many(page_size=1)
+
+    # parents: list[Parent]
+    total, parents = await ParentDM.get_many(page_size=1, page=2)
+
+    # parent: Parent
+    parent = await ParentDM.get(1)
+
+    # parent: Parent
+    parent = await ParentDM.get(1, joinedload={"children": True})
+
+    # parent: Parent
+    parent = await ParentDM.save(parent.Save())
+
+    # parent: Parent
+    parent = await ParentDM.update(Parent.Update(id=1, data="new data"), key="id")
+
+    await ParentDM.delete(1)
+
+    # child : Child 
+    child = await ChildDM.create(Child.Create(name=f"Child_{i}", parent_id=i))
+
+    # parent: Parent
+    parent = await ParentDM.get(1, joinedload={"children": True})
+```

dbdm-0.1.0/dbdm/__init__.py

@@ -0,0 +1,7 @@
+import importlib.metadata
+
+
+__version__ = importlib.metadata.version("dbdm")
+
+
+from .common import *  # noqa: F403

dbdm-0.1.0/dbdm/common.py

@@ -0,0 +1,736 @@
+import re
+import typing
+
+from asyncio import gather
+from contextlib import asynccontextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any, AsyncIterator, Callable, Literal, Never, Optional, Protocol, Type, TypeVar
+
+import sqlalchemy as sa
+
+from sqlalchemy import delete, func, literal, select, union_all, update
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.ext.asyncio import async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase, aliased
+
+
+__all__ = [
+    "DMError",
+    "AlreadyExistsError",
+    "BadParamsError",
+    "NotFoundError",
+    "OrderBy",
+    "bind_engine",
+    "transaction",
+]
+
+
+_conn: dict[Optional[str], ContextVar] = {}
+_engine: dict[Optional[str], sa.ext.asyncio.AsyncEngine] = {}
+
+
+class DMError(Exception):
+    pass
+
+
+class BadParamsError(DMError):
+    def __init__(self, message: str, param: Optional[str] = None):
+        self.message = message
+        self.param = param
+
+    def __str__(self):
+        return self.message
+
+    def __repr__(self):
+        return self.__str__()
+
+
+class NotFoundError(DMError):
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+
+    def __str__(self):
+        return f"item with ({self.key})=({self.value}) not found"
+
+
+class AlreadyExistsError(DMError):
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+
+    def __str__(self):
+        return f"key ({self.key})=({self.value}) already exists"
+
+
+@dataclass
+class OrderBy:
+    by: Any
+    order: Literal["asc", "desc"] = "asc"
+
+
+def bind_engine(engine: sa.ext.asyncio.AsyncEngine, name: Optional[str] = None):
+    if engine.dialect.name != "postgresql":
+        raise DMError("only 'postgresql' dialect is supported")
+    _engine[name] = engine
+    _conn[name] = ContextVar("conn", default=None)
+
+
+@asynccontextmanager
+async def transaction(engine_name: Optional[str] = None) -> AsyncIterator[sa.ext.asyncio.AsyncConnection]:
+    if (conn := _conn[engine_name].get()) is None:
+        async with _engine[engine_name].connect() as conn:
+            async with conn.begin():
+                _conn[engine_name].set(conn)
+                try:
+                    yield conn
+                finally:
+                    _conn[engine_name].set(None)
+    else:
+        yield conn
+
+
+@asynccontextmanager
+async def get_conn(engine_name: Optional[str] = None) -> AsyncIterator[sa.ext.asyncio.AsyncConnection]:
+    if (conn := _conn[engine_name].get()) is None:
+        async with _engine[engine_name].connect() as conn:
+            async with conn.begin():
+                yield conn
+    else:
+        yield conn
+
+
+@asynccontextmanager
+async def get_sess(engine_name: Optional[str] = None):
+    async with get_conn(engine_name=engine_name) as conn:
+        async_session = async_sessionmaker(conn, expire_on_commit=False)
+        async with async_session() as sess:
+            async with sess.begin():
+                yield sess
+
+
+def _raise_exc(e: Exception) -> Never:
+    if isinstance(e, sa.exc.IntegrityError):
+        detail_match = re.match(r".*\nDETAIL:\s*(?P<text>.*)$", e.orig.args[0])  # type: ignore
+        if detail_match:
+            text = detail_match.groupdict()["text"].strip()
+            m = re.match(r"Key \((?P<key>.*)\)=\((?P<key_value>.*)\) already exists.", text)
+            if m:
+                key = m.groupdict()["key"]
+                key_value = m.groupdict()["key_value"].strip('\\"')
+                raise AlreadyExistsError(key, key_value)
+    raise e
+
+
+ModelDB = TypeVar("ModelDB", bound=DeclarativeBase)
+
+
+class _BaseProtocol(Protocol):
+    engine_name: Optional[str]
+
+    model_db: Type[DeclarativeBase]
+    model: Type
+
+    @classmethod
+    async def _execute(cls, query) -> sa.ResultProxy: ...
+
+    @classmethod
+    def _make_from_db_data(
+        cls,
+        db_item,
+        row: Optional[tuple] = None,
+        joinedload: Optional[dict] = None,
+    ) -> dict: ...
+
+    @classmethod
+    def _from_db(
+        cls,
+        item: sa.Row | ModelDB,
+        data: Optional[dict] = None,
+        exclude: Optional[list] = None,
+        suffix: Optional[str] = None,
+        model_out=None,
+    ): ...
+
+    @classmethod
+    def _get_key(cls, key=None): ...
+
+    @classmethod
+    async def get(
+        cls,
+        key_value,
+        key=None,
+        raise_not_found: Optional[bool] = None,
+        joinedload: Optional[dict] = None,
+        model_out: Optional[Type] = None,
+        **kwds,
+    ) -> Optional[type]: ...
+
+    @classmethod
+    async def get_many(
+        cls,
+        flt: Optional[sa.sql.elements.BinaryExpression] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        order_by: Optional[list[OrderBy | str] | OrderBy | str] = None,
+        joinedload: Optional[dict] = None,
+        model_out: Optional[Type] = None,
+        **kwds,
+    ) -> tuple[int, list]: ...
+
+
+class _Meta(typing._ProtocolMeta):
+    def __new__(cls, name, bases, ns, skip_checks: bool = False):
+        if not skip_checks:
+
+            def get_all_bases(bases: tuple) -> set:
+                result = set()
+                for base in bases:
+                    result.add(base)
+                    result |= get_all_bases(getattr(base, "__bases__", ()))
+                return result
+
+            all_bases = get_all_bases(bases)
+
+            if _GetDM not in all_bases:
+                raise TypeError("Any DM class should be subclassed from GetDM class")
+
+            if (model_db := ns.get("model_db")) is None:
+                raise ValueError("'model_db' field is required")
+
+            if (model := ns.get("model")) is None:
+                raise ValueError("'model' field is required")
+
+            if (
+                getattr(model, "__dataclass_fields__", None) is None
+                and getattr(model, "__pydantic_fields__", None) is None
+            ):
+                raise ValueError("'model' is not a valid model")
+
+            if _CreateDM in all_bases or _SaveDM in all_bases:
+                if (model_create := ns.get("model_create")) is None:
+                    raise ValueError("'model_create' field is required")
+                if (
+                    getattr(model_create, "__dataclass_fields__", None) is None
+                    and getattr(model_create, "__pydantic_fields__", None) is None
+                ):
+                    raise ValueError("'model_create' is not a valid model")
+                ns["_fields_create"] = set(model_db.__table__.columns.keys()) & set(
+                    getattr(model_create, "__dataclass_fields__", None)
+                    or getattr(model_create, "__pydantic_fields__", None)
+                    or set()
+                )
+                if not ns["_fields_create"]:
+                    raise DMError("model_create does not contain valid fields")
+
+            if _SaveDM in all_bases:
+                if (model_save := ns.get("model_save")) is None:
+                    raise ValueError("'model_save' field is required")
+                if (
+                    getattr(model_save, "__dataclass_fields__", None) is None
+                    and getattr(model_save, "__pydantic_fields__", None) is None
+                ):
+                    raise ValueError("'model_save' is not a valid model")
+                ns["_fields_save"] = set(model_db.__table__.columns.keys()) & set(
+                    getattr(model_save, "__dataclass_fields__", None)
+                    or getattr(model_save, "__pydantic_fields__", None)
+                    or set()
+                )
+                if not ns["_fields_save"]:
+                    raise DMError("model_save does not contain valid fields")
+
+            if _UpdateDM in all_bases:
+                if (model_update := ns.get("model_update")) is None:
+                    raise ValueError("'model_update' field is required")
+                if (
+                    getattr(model_update, "__dataclass_fields__", None) is None
+                    and getattr(model_update, "__pydantic_fields__", None) is None
+                ):
+                    raise ValueError("'model_update' is not a valid model")
+                ns["_fields_update"] = set(model_db.__table__.columns.keys()) & set(
+                    getattr(model_update, "__dataclass_fields__", None)
+                    or getattr(model_update, "__pydantic_fields__", None)
+                    or set()
+                )
+                if not ns["_fields_update"]:
+                    raise DMError("model_update does not contain valid fields")
+
+        return super().__new__(cls, name, bases, ns)
+
+
+class _GetDM(_BaseProtocol, metaclass=_Meta, skip_checks=True):
+    engine_name: Optional[str] = None
+
+    model_db: Type[DeclarativeBase] = typing.cast(Type[DeclarativeBase], None)
+    model: Type = typing.cast(Type, None)
+
+    key = None
+    order_by: Optional[list[OrderBy | str | Callable] | OrderBy | str | Callable] = None
+
+    joinedload: dict = {}
+
+    @classmethod
+    async def _execute(cls, query) -> sa.ResultProxy:
+        async with get_conn(engine_name=cls.engine_name) as conn:
+            try:
+                return await conn.execute(query)
+            except Exception as e:
+                _raise_exc(e)
+
+    @classmethod
+    def _make_from_db_data(
+        cls,
+        db_item,
+        row: Optional[tuple] = None,
+        joinedload: Optional[dict] = None,
+    ) -> dict:
+        return {}
+
+    @classmethod
+    def _from_db(
+        cls,
+        item: sa.Row | ModelDB,
+        data: Optional[dict] = None,
+        exclude: Optional[list] = None,
+        suffix: Optional[str] = None,
+        model_out=None,
+    ): ...
+
+    @classmethod
+    def _get_key(cls, key=None):
+        if key is None:
+            key = cls.key
+        if key is None:
+            raise ValueError("key is None")
+        if isinstance(key, str):
+            key = getattr(cls.model_db, key)
+        return key
+
+    @classmethod
+    def _get_order_by(cls, c, order_by: Optional[list[OrderBy | str] | OrderBy | str] = None) -> list:
+        _order_by = order_by
+        if _order_by is None:
+            if callable(cls.order_by):
+                _order_by = cls.order_by(c)
+            else:
+                _order_by = cls.order_by or cls._get_key()
+        if _order_by is not None:
+            if not isinstance(_order_by, list):
+                _order_by = [_order_by]
+            else:
+                _order_by = list(_order_by)
+            for i, x in enumerate(_order_by):
+                if isinstance(x, OrderBy):
+                    x = OrderBy(by=x.by, order=x.order)
+                else:
+                    x = OrderBy(by=x)
+                if isinstance(x.by, str):
+                    if getattr(c, x.by, None) is None:
+                        raise BadParamsError(f"invalid order_by '{x.by}'", param=f"{x.by}")
+                    x.by = getattr(c, x.by)
+                _order_by[i] = getattr(sa, x.order)(x.by)
+        return typing.cast(list, _order_by)
+
+    @classmethod
+    def _make_get_query(cls, key, key_value, **kwds) -> sa.sql.Select:
+        return select(cls.model_db).where(key == key_value)
+
+    @classmethod
+    async def get(
+        cls,
+        key_value,
+        key=None,
+        raise_not_found: Optional[bool] = None,
+        joinedload: Optional[dict] = None,
+        model_out: Optional[Type] = None,
+        **kwds,
+    ) -> Optional[type]:
+        key = cls._get_key(key=key)
+        query = cls._make_get_query(key, key_value, **kwds)
+        model_out = model_out or cls.model
+
+        if joinedload is None or not any(joinedload.values()):
+            item = (await cls._execute(query)).one_or_none()
+            if item:
+                return cls._from_db(item, data=cls._make_from_db_data(item), model_out=model_out)
+            if raise_not_found:
+                raise NotFoundError(key=key, value=key_value)
+            return
+
+        exclude = []
+        for k, v in cls.joinedload.items():
+            if joinedload.get(k) is True:
+                query = query.options(v(cls.model_db))
+            else:
+                exclude.append(k)
+
+        async with get_sess(engine_name=cls.engine_name) as sess:
+            item = (await sess.execute(query)).unique().scalars().one_or_none()
+            if item:
+                return cls._from_db(
+                    item,
+                    exclude=exclude,
+                    data=cls._make_from_db_data(item, joinedload=joinedload),
+                    model_out=model_out,
+                )
+            if raise_not_found:
+                raise NotFoundError(key=key, value=key_value)
+
+    @classmethod
+    def _make_get_many_query(
+        cls,
+        flt: Optional[sa.sql.elements.BinaryExpression] = None,
+        order_by: Optional[list[OrderBy | str] | OrderBy | str] = None,
+        **kwds,
+    ) -> sa.sql.Select:
+        query = select(func.count(literal("*")).over().label("rows_total"), cls.model_db)
+        if flt is not None:
+            query = query.where(flt)
+        query = query.order_by(*cls._get_order_by(cls.model_db, order_by))
+        return query
+
+    @classmethod
+    async def get_many(
+        cls,
+        flt: Optional[sa.sql.elements.BinaryExpression] = None,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        order_by: Optional[list[OrderBy | str] | OrderBy | str] = None,
+        joinedload: Optional[dict] = None,
+        model_out: Optional[Type] = None,
+        **kwds,
+    ) -> tuple[int, list]:
+        model_db = cls.model_db
+        model_out = model_out or cls.model
+
+        query = cls._make_get_many_query(flt=flt, order_by=order_by, **kwds)
+
+        cte = query.cte("cte")
+
+        query = select(literal(1).label("i"), cte)
+
+        if page_size:
+            page = page or 1
+            query = query.limit(page_size).offset((page - 1) * page_size)
+
+        query = union_all(select(literal(0).label("i"), cte).limit(1), query)
+
+        from_db = cls._from_db
+        make_from_orm_data = cls._make_from_db_data
+
+        if joinedload is None or not any(joinedload.values()):
+            rows = (await cls._execute(query)).all()
+            return rows[0].rows_total if rows else 0, [
+                from_db(row, data=make_from_orm_data(row), model_out=model_out) for row in rows[1:]
+            ]
+
+        main_cte = query.cte("main_cte")
+
+        model_db_alias = aliased(model_db, main_cte)
+        query = select(main_cte, model_db_alias)
+
+        exclude = []
+        for k, v in cls.joinedload.items():
+            if joinedload.get(k) is True:
+                query = query.options(v(model_db_alias))
+            else:
+                exclude.append(k)
+
+        query = query.order_by(sa.asc(main_cte.c.i), *cls._get_order_by(main_cte.c, order_by))
+
+        def _hash(row):
+            return hash((row[0], row[1], row[-1]))
+
+        async with get_sess(engine_name=cls.engine_name) as sess:
+            rows = (await sess.execute(query)).unique(_hash).all()
+            return rows[0].rows_total if rows else 0, [
+                from_db(
+                    row[-1],
+                    exclude=exclude,
+                    data=make_from_orm_data(row[-1], row=typing.cast(tuple, row), joinedload=joinedload),
+                    model_out=model_out,
+                )
+                for row in rows[1:]
+            ]
+
+
+class _CreateDM(_BaseProtocol, metaclass=_Meta, skip_checks=True):
+    model_create: Type = typing.cast(Type, None)
+
+    index_elements: Optional[list] = None
+
+    _fields_create: set[str] = set()
+
+    @classmethod
+    def _get_values_for_create_query(cls, model) -> dict: ...
+
+    @classmethod
+    def _make_create_query(cls, model, returning: Optional[bool] = None) -> sa.sql.Insert:
+        model_db = cls.model_db
+        query = insert(model_db).values(cls._get_values_for_create_query(model))
+        if returning:
+            query = query.returning(model_db)
+        return query
+
+    @classmethod
+    async def create(
+        cls,
+        model,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ):
+        result = await cls._execute(cls._make_create_query(model, returning=returning))
+        if returning:
+            item = result.one()
+            model_out = model_out or cls.model
+            return cls._from_db(item, data=cls._make_from_db_data(item), model_out=model_out)
+
+    @classmethod
+    def _make_create_many_query(cls, models: list, returning: bool | None = None) -> sa.sql.Insert:
+        model_db = cls.model_db
+        query = insert(cls.model_db).values([cls._get_values_for_create_query(model) for model in models])
+        if returning:
+            query = query.returning(model_db)
+        return query
+
+    @classmethod
+    async def create_many(
+        cls,
+        models: list,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ) -> list | None:
+        if not models:
+            return []
+        result = await cls._execute(cls._make_create_many_query(models, returning=returning))
+        if returning:
+            from_db = cls._from_db
+            make_from_db_data = cls._make_from_db_data
+            model_out = model_out or cls.model
+            return [from_db(item, data=make_from_db_data(item), model_out=model_out) for item in result.all()]
+
+    @classmethod
+    def _make_get_or_create_query(
+        cls,
+        model,
+        update_element: str,
+        index_elements: Optional[list] = None,
+    ) -> sa.sql.Insert:
+        model_db = cls.model_db
+        query = insert(model_db).values(cls._get_values_for_create_query(model))
+        index_elements = index_elements or cls.index_elements
+        if index_elements is None:
+            raise ValueError("index_elements is None")
+        index_elements = list(map(lambda e: isinstance(e, str) and getattr(model_db, e) or e, index_elements))
+        return query.on_conflict_do_update(
+            index_elements=index_elements,
+            set_={update_element: getattr(query.excluded, update_element)},
+        ).returning(model_db)
+
+    @classmethod
+    async def get_or_create(
+        cls,
+        model,
+        update_element: str,
+        index_elements: Optional[list] = None,
+        model_out: Optional[Type] = None,
+    ):
+        model_out = model_out or cls.model
+        item = (
+            await cls._execute(
+                cls._make_get_or_create_query(
+                    model,
+                    update_element,
+                    index_elements=index_elements,
+                )
+            )
+        ).one()
+        return cls._from_db(item, data=cls._make_from_db_data(item), model_out=model_out)
+
+
+class _SaveDM(_CreateDM, metaclass=_Meta, skip_checks=True):
+    model_create: Type = typing.cast(Type, None)
+    model_save: Type = typing.cast(Type, None)
+
+    index_elements: Optional[list] = None
+
+    _fields_create: set[str] = set()
+    _fields_save: set[str] = set()
+
+    @classmethod
+    def _get_values_for_save_query(cls, model) -> dict: ...
+
+    @classmethod
+    def _get_on_conflict_do_update_set_for_save_query(cls, excluded, model) -> dict:
+        if isinstance(model, typing.cast(Type, cls.model_create)):
+            return {k: getattr(excluded, k) for k in cls._fields_create}
+        return {k: getattr(excluded, k) for k in cls._fields_save}
+
+    @classmethod
+    def _make_save_query(
+        cls,
+        model,
+        index_elements: Optional[list] = None,
+        returning: Optional[bool] = None,
+    ) -> sa.sql.Insert:
+        model_db = cls.model_db
+        query = insert(model_db).values(cls._get_values_for_save_query(model))
+        index_elements = index_elements or cls.index_elements
+        if index_elements is None:
+            raise ValueError("index_elements is None")
+        index_elements = list(map(lambda e: isinstance(e, str) and getattr(model_db, e) or e, index_elements))
+        query = query.on_conflict_do_update(
+            index_elements=index_elements,
+            set_=cls._get_on_conflict_do_update_set_for_save_query(query.excluded, model),
+        )
+        if returning:
+            query = query.returning(model_db)
+        return query
+
+    @classmethod
+    async def save(
+        cls,
+        model,
+        index_elements: Optional[list] = None,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ):
+        result = await cls._execute(
+            cls._make_save_query(
+                model,
+                index_elements=index_elements,
+                returning=returning,
+            )
+        )
+        if returning:
+            item = result.one()
+            model_out = model_out or cls.model
+            return cls._from_db(item, data=cls._make_from_db_data(item), model_out=model_out)
+
+    @classmethod
+    def _make_save_many_query(
+        cls,
+        models: list,
+        index_elements: Optional[list] = None,
+        returning: Optional[bool] = None,
+    ) -> sa.sql.Insert:
+        model_db = cls.model_db
+        query = insert(model_db).values([cls._get_values_for_save_query(model) for model in models])
+        index_elements = index_elements or cls.index_elements
+        if index_elements is None:
+            raise ValueError("index_elements is None")
+        index_elements = list(map(lambda e: isinstance(e, str) and getattr(model_db, e) or e, index_elements))
+        query = query.on_conflict_do_update(
+            index_elements=index_elements,
+            set_=cls._get_on_conflict_do_update_set_for_save_query(query.excluded, models[0]),
+        )
+        if returning:
+            query = query.returning(model_db)
+        return query
+
+    @classmethod
+    async def save_many(
+        cls,
+        models: list,
+        index_elements: Optional[list] = None,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ) -> list | None:
+        if not models:
+            return []
+        result = await cls._execute(
+            cls._make_save_many_query(
+                models,
+                index_elements=index_elements,
+                returning=returning,
+            )
+        )
+        if returning:
+            from_db = cls._from_db
+            make_from_db_data = cls._make_from_db_data
+            model_out = model_out or cls.model
+            return [from_db(item, data=make_from_db_data(item), model_out=model_out) for item in result.all()]
+
+
+class _UpdateDM(_CreateDM, metaclass=_Meta, skip_checks=True):
+    model_update: Type = typing.cast(Type, None)
+    _fields_update: set[str] = set()
+
+    @classmethod
+    def _get_values_for_update_query(cls, model) -> dict: ...
+
+    @classmethod
+    def _make_update_query(cls, model, key: str, returning: Optional[bool] = None) -> sa.sql.Update:
+        model_db = cls.model_db
+        query = (
+            update(model_db)
+            .values(cls._get_values_for_update_query(model))
+            .where(getattr(model_db, key) == getattr(model, key))
+            .returning(getattr(model_db, key))
+        )
+        if returning:
+            query = query.returning(model_db)
+        return query
+
+    @classmethod
+    async def update(
+        cls,
+        model,
+        key: str,
+        raise_not_found: Optional[bool] = None,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ):
+        result = await cls._execute(cls._make_update_query(model, key, returning=returning or raise_not_found))
+        if raise_not_found and result.rowcount == 0:
+            raise NotFoundError(key=key, value=getattr(model, key))
+        if returning:
+            item = result.one_or_none()
+            if item:
+                model_out = model_out or cls.model
+                return cls._from_db(item, data=cls._make_from_db_data(item), model_out=model_out)
+
+    @classmethod
+    async def update_many(
+        cls,
+        models: list,
+        key: str,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ) -> list | None:
+        async with transaction():
+            results = await gather(
+                *[cls.update(model, key, model_out=model_out, returning=returning) for model in models]
+            )
+            if returning:
+                return typing.cast(list | None, results)
+
+
+class _DeleteDM(_CreateDM, metaclass=_Meta, skip_checks=True):
+    @classmethod
+    def _make_delete_query(cls, key, key_value, returning: Optional[bool] = None):
+        query = delete(cls.model_db).where(key == key_value)
+        if returning:
+            query = query.returning(cls.model_db)
+        return query
+
+    @classmethod
+    async def delete(
+        cls,
+        key_value,
+        key=None,
+        raise_not_found: Optional[bool] = None,
+        model_out: Optional[Type] = None,
+        returning: bool = True,
+    ):
+        key = cls._get_key(key=key)
+        result = await cls._execute(cls._make_delete_query(key, key_value, returning=returning))
+        if raise_not_found:
+            if raise_not_found and result.rowcount == 0:
+                raise NotFoundError(key=key, value=key_value)
+        if returning:
+            item = result.one_or_none()
+            if item:
+                model_out = model_out or cls.model
+                return cls._from_db(item, data=cls._make_from_db_data(item), model_out=model_out)

dbdm-0.1.0/dbdm/cwtch.py

@@ -0,0 +1,66 @@
+import typing
+
+from typing import Optional, Type
+
+import sqlalchemy as sa
+
+from cwtch import asdict, from_attributes
+
+from .common import ModelDB, OrderBy, _CreateDM, _DeleteDM, _GetDM, _SaveDM, _UpdateDM
+
+
+__all__ = [
+    "OrderBy",
+    "GetDM",
+    "CreateDM",
+    "SaveDM",
+    "UpdateDM",
+    "DeleteDM",
+    "DM",
+]
+
+
+class GetDM(_GetDM, skip_checks=True):
+    @classmethod
+    def _from_db(
+        cls,
+        item: sa.Row | ModelDB,
+        data: Optional[dict] = None,
+        exclude: Optional[list] = None,
+        suffix: Optional[str] = None,
+        model_out=None,
+    ):
+        return from_attributes(
+            model_out or cls.model,
+            item,
+            data=data,
+            exclude=exclude,
+            suffix=suffix,
+            reset_circular_refs=True,
+        )
+
+
+class CreateDM(_CreateDM, skip_checks=True):
+    @classmethod
+    def _get_values_for_create_query(cls, model) -> dict:
+        return asdict(model, include=typing.cast(list[str], cls._fields_create))
+
+
+class SaveDM(_SaveDM, skip_checks=True):
+    @classmethod
+    def _get_values_for_save_query(cls, model) -> dict:
+        if isinstance(model, typing.cast(Type, cls.model_create)):
+            return asdict(model, include=typing.cast(list[str], cls._fields_create))
+        return asdict(model, include=typing.cast(list[str], cls._fields_save))
+
+
+class UpdateDM(_UpdateDM, skip_checks=True):
+    @classmethod
+    def _get_values_for_update_query(cls, model) -> dict:
+        return asdict(model, include=typing.cast(list[str], cls._fields_update), exclude_unset=True)
+
+
+class DeleteDM(_DeleteDM, skip_checks=True): ...
+
+
+class DM(GetDM, CreateDM, SaveDM, UpdateDM, DeleteDM, skip_checks=True): ...

dbdm-0.1.0/dbdm/pydantic.py

@@ -0,0 +1,76 @@
+import typing
+
+from typing import Optional, Type
+
+import pydantic  # noqa: F401 # type: ignore
+import sqlalchemy as sa
+
+from .common import ModelDB, OrderBy, _CreateDM, _DeleteDM, _GetDM, _SaveDM, _UpdateDM
+
+
+__all__ = [
+    "OrderBy",
+    "GetDM",
+    "CreateDM",
+    "SaveDM",
+    "UpdateDM",
+    "DeleteDM",
+    "DM",
+]
+
+
+class _object:
+    pass
+
+
+class GetDM(_GetDM, skip_checks=True):
+    @classmethod
+    def _from_db(
+        cls,
+        item: sa.Row | ModelDB,
+        data: Optional[dict] = None,
+        exclude: Optional[list] = None,
+        suffix: Optional[str] = None,
+        model_out=None,
+    ):
+        if isinstance(item, sa.Row):
+            data = {**item._asdict(), **(data or {})}
+        else:
+            data = {**item.__dict__, **(data or {})}
+
+        obj = _object()
+
+        if suffix:
+            obj.__dict__ = {
+                k.rstrip(suffix): v for k, v in data.items() if (not exclude or k not in exclude) and k.endswith(suffix)
+            }
+        else:
+            obj.__dict__ = {k: v for k, v in data.items() if not exclude or k not in exclude}
+
+        return (model_out or cls.model).model_validate(obj, from_attributes=True)
+
+
+class CreateDM(_CreateDM, skip_checks=True):
+    @classmethod
+    def _get_values_for_create_query(cls, model) -> dict:
+        return model.model_dump(include=typing.cast(list[str], cls._fields_create))
+
+
+class SaveDM(_SaveDM, skip_checks=True):
+    @classmethod
+    def _get_values_for_save_query(cls, model) -> dict:
+        if isinstance(model, typing.cast(Type, cls.model_create)):
+            return model.model_dump(include=typing.cast(list[str], cls._fields_create))
+        return model.model_dump(include=typing.cast(list[str], cls._fields_save))
+
+
+class UpdateDM(_UpdateDM, skip_checks=True):
+    @classmethod
+    def _get_values_for_update_query(cls, model) -> dict:
+        return model.model_dump(include=typing.cast(list[str], cls._fields_update), exclude_unset=True)
+
+
+class DeleteDM(_DeleteDM, skip_checks=True): ...
+
+
+class DM(GetDM, CreateDM, SaveDM, UpdateDM, DeleteDM, skip_checks=True): ...

dbdm-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[tool.poetry]
+name = "dbdm"
+version = "0.1.0"
+description = ""
+authors = ["Roman Koshel <roma.koshel@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+keywords = []
+packages = [{ include = "dbdm" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+    "License :: OSI Approved :: MIT License",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.11, <4.0"
+asyncpg = "*"
+sqlalchemy = { version="^2", extras=["asyncio"] }
+
+[tool.poetry.group.test.dependencies]
+coverage = "*"
+cwtch = ">=0.10.0"
+docker = "*"
+pydantic = "^2"
+pylint = "*"
+pytest = "*"
+pytest_asyncio = "*"
+pytest_timeout = "*"
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = "*"
+mkdocs-material = "*"
+mkdocstrings = { extras = ["python"], version = "*" }
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 120
+
+[tool.isort]
+indent = 4
+lines_after_imports = 2
+lines_between_types = 1
+src_paths = ["."]
+profile = "black"