fastabc 0.1.0__tar.gz

fastabc-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: fastabc
+Version: 0.1.0
+Summary: Ready-made API Abstractions: basic models, repositories, unit of work and other stuff.
+Author: Ivan Stasevich
+Author-email: pravitel2015ify@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 1
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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 :: Only
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: pydantic (>=2.7.3,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.3.1,<3.0.0)
+Requires-Dist: sqlalchemy (>=2.0.30,<3.0.0)
+Description-Content-Type: text/markdown
+
+

fastabc-0.1.0/fastabc/__init__.py

@@ -0,0 +1,17 @@
+"""Ready-made API Abstractions: basic models, repositories, unit of work and other stuff."""
+
+__version__ = "0.1.0"
+
+from .alchemy import SkeletonBase, MixinBase, AlchemyEntity
+from .schemas import SkeletonModel, MixinModel, Page, PageParams, EntityModel
+
+__all__ = [
+    "SkeletonModel",
+    "SkeletonBase",
+    "MixinModel",
+    "MixinBase",
+    "Page",
+    "PageParams",
+    "AlchemyEntity",
+    "EntityModel",
+]

fastabc-0.1.0/fastabc/abc/__init__.py

@@ -0,0 +1,12 @@
+from .gateway import AbstractGateway
+from .repository import AbstractRepository
+from .service import AbstractService
+from .uow import AbstractUOW, FakeUOW
+
+__all__ = [
+    "AbstractGateway",
+    "AbstractService",
+    "AbstractUOW",
+    "AbstractRepository",
+    "FakeUOW",
+]

fastabc-0.1.0/fastabc/abc/gateway.py

@@ -0,0 +1,20 @@
+from abc import ABC
+
+
+class AbstractGateway(ABC):
+    """
+    Provides access to application services.
+
+    e.g.::
+
+        async def get_user(
+            email: str, gateway: Annotated[Gateway, Depends(get_gateway)]
+        ) -> None:
+            user = await gateway.users.get_by_email(email)
+            return user
+
+
+        async def handler(message: types.Message, gateway: Gateway) -> None:
+            user = await gateway.users.get_by_email(message.text)
+            await message.answer(user.model_dump_json())
+    """  # noqa: E501

fastabc-0.1.0/fastabc/abc/repository.py

@@ -0,0 +1,5 @@
+from abc import ABC
+
+
+class AbstractRepository(ABC):
+    """Provides access to the data storage."""

fastabc-0.1.0/fastabc/abc/service.py

@@ -0,0 +1,5 @@
+from abc import ABC
+
+
+class AbstractService(ABC):
+    """Implements the business logic"""

fastabc-0.1.0/fastabc/abc/uow.py

@@ -0,0 +1,60 @@
+from abc import ABC, abstractmethod
+from typing import Any, Self
+
+
+class AbstractUOW(ABC):
+    """Provides transaction management"""
+
+    @property
+    @abstractmethod
+    def is_opened(self) -> bool:
+        pass
+
+    async def on_open(self) -> None:
+        pass
+
+    @abstractmethod
+    async def open(self) -> None:
+        await self.on_open()
+
+    @abstractmethod
+    async def close(self, type_: Any, value: Any, traceback: Any) -> None:
+        pass
+
+    @abstractmethod
+    async def commit(self) -> None:
+        pass
+
+    @abstractmethod
+    async def rollback(self) -> None:
+        pass
+
+    async def __aenter__(self) -> Self:
+        await self.open()
+        return self
+
+    async def __aexit__(self, type_: Any, value: Any, traceback: Any) -> None:
+        await self.rollback()
+        await self.close(type_, value, traceback)
+
+
+class FakeUOW(AbstractUOW, ABC):
+    _is_opened: bool = False
+
+    @property
+    def is_opened(self) -> bool:
+        return self._is_opened
+
+    async def open(self) -> None:
+        self._is_opened = True
+        await super().open()
+
+    async def close(self, type_: Any, value: Any, traceback: Any) -> None:
+        self._is_opened = False
+        await super().close(type_, value, traceback)
+
+    async def commit(self) -> None:
+        pass
+
+    async def rollback(self) -> None:
+        pass

fastabc-0.1.0/fastabc/alchemy/__init__.py

@@ -0,0 +1,17 @@
+from .base import SkeletonBase
+from .mixins import AlchemyEntity, HasTimestamp, MixinBase
+from .repository import AlchemyRepository
+from .testing import TestUser
+from .uow import AlchemyUOW
+from .service import AlchemyService
+
+__all__ = [
+    "SkeletonBase",
+    "AlchemyEntity",
+    "AlchemyRepository",
+    "HasTimestamp",
+    "TestUser",
+    "MixinBase",
+    "AlchemyUOW",
+    "AlchemyService",
+]

fastabc-0.1.0/fastabc/alchemy/base.py

@@ -0,0 +1,41 @@
+from enum import Enum
+from typing import Any, Self
+
+from pydantic import BaseModel
+from sqlalchemy import BigInteger, inspect, Enum as SAEnum, MetaData
+from sqlalchemy.orm import (
+    DeclarativeBase,
+)
+
+type_map = {int: BigInteger, Enum: SAEnum(Enum, native_enum=False)}
+
+POSTGRES_INDEXES_NAMING_CONVENTION = {
+    "ix": "%(column_0_label)s_idx",
+    "uq": "%(table_name)s_%(column_0_name)s_key",
+    "ck": "%(table_name)s_%(constraint_name)s_check",
+    "fk": "%(table_name)s_%(column_0_name)s_fkey",
+    "pk": "%(table_name)s_pkey",
+}
+metadata = MetaData(naming_convention=POSTGRES_INDEXES_NAMING_CONVENTION)
+
+
+class SkeletonBase(DeclarativeBase):
+    type_annotation_map = type_map
+    metadata = metadata
+
+    def update(self, attributes: BaseModel | dict[str, Any]) -> Self:
+        """Update an object with given attribute values."""
+        if isinstance(attributes, BaseModel):
+            attributes = attributes.model_dump(exclude_unset=True)
+
+        for name, value in attributes.items():
+            setattr(self, name, value)
+
+        return self
+
+    def dump(self) -> dict[str, Any]:
+        """Dump the object to a dictionary."""
+        return {
+            c.key: getattr(self, c.key)
+            for c in inspect(self).mapper.column_attrs  # noqa
+        }

fastabc-0.1.0/fastabc/alchemy/mixins.py

@@ -0,0 +1,52 @@
+import datetime
+
+from sqlalchemy import func, Identity
+from sqlalchemy.orm import mapped_column, Mapped
+
+from .base import SkeletonBase
+
+
+# https://docs.sqlalchemy.org/en/20/core/defaults.html
+# https://docs.sqlalchemy.org/en/20/orm/declarative_config.html#abstract
+# https://docs.sqlalchemy.org/en/20/orm/declarative_tables.html#orm-declarative-mapped-column-type-map-pep593
+
+
+class MixinBase(SkeletonBase):
+    __abstract__ = True
+
+
+class HasID(MixinBase):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(
+        Identity(), primary_key=True, sort_order=-100
+    )
+
+
+class HasTimestamp(MixinBase):
+    __abstract__ = True
+
+    created_at: Mapped[datetime.datetime] = mapped_column(
+        server_default=func.now(), sort_order=100
+    )
+    updated_at: Mapped[datetime.datetime] = mapped_column(
+        server_default=func.now(),
+        onupdate=datetime.datetime.utcnow,  # noqa
+        sort_order=101,
+    )
+
+
+class AlchemyEntity(HasID, HasTimestamp):
+    __abstract__ = True
+
+
+class SoftDeletable(MixinBase):
+    __abstract__ = True
+
+    deleted_at: Mapped[datetime.datetime | None] = mapped_column(
+        nullable=True, sort_order=102
+    )
+
+    def delete(self) -> None:
+        # self.deleted_at = func.now()
+        self.deleted_at = datetime.datetime.utcnow()  # noqa

fastabc-0.1.0/fastabc/alchemy/multiple.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from fastabc.abc import AbstractUOW
+
+
+class MultipleAlchemyUOW(AbstractUOW):
+    """
+    This UOW allows to work with multiple SQLAlchemy sessions.
+
+    Usage::
+
+        def get_session_factories() -> dict[str, async_sessionmaker[AsyncSession]]:
+            engines = {
+                "first-db": create_async_engine(
+                    "postgresql+asyncpg://user:password@localhost/first_db"
+                ),
+                "second-db": create_async_engine(
+                    "postgresql+asyncpg://user:password@localhost/second_db"
+                ),
+            }
+
+            return {
+                name: async_sessionmaker(engine)
+                for name, engine in engines.items()
+            }
+
+
+        class UOW(BaseMultipleUOW):
+            users: UserRepository
+            music: MusicRepository
+
+            async def open(self) -> None:
+                self.users = UserRepository(self.sessions["first-db"])
+                self.music = MusicRepository(self.sessions["second-db"])
+
+
+        async with UOW(get_session_factories()) as uow:
+            # TRANSACTION IS BEGUN...
+
+            uow.users.add(User(name="Bob", age="18"))
+            now.music.add(Music(name="Song", author="Bob"))
+
+            uow.commit()
+
+    """  # noqa: E501
+
+    session_factories: dict[str, async_sessionmaker[AsyncSession]]
+    sessions: dict[str, AsyncSession]
+
+    def __init__(
+        self, session_factories: dict[str, async_sessionmaker[AsyncSession]]
+    ) -> None:
+        self.session_factories = session_factories
+
+    @property
+    def is_opened(self) -> bool:
+        if not self.sessions:
+            return False
+
+        return any(session.is_active for session in self.sessions.values())
+
+    async def open(self) -> None:
+        self.sessions = {
+            name: factory() for name, factory in self.session_factories.items()
+        }
+
+        for session in self.sessions.values():
+            await session.__aenter__()
+
+    async def close(self, type_: Any, value: Any, traceback: Any) -> None:
+        for session in self.sessions.values():
+            await session.__aexit__(type_, value, traceback)
+
+    async def flush(self) -> None:
+        for session in self.sessions.values():
+            await session.flush()
+
+    async def commit(self) -> None:
+        for session in self.sessions.values():
+            await session.commit()
+
+    async def rollback(self) -> None:
+        for session in self.sessions.values():
+            await session.rollback()

fastabc-0.1.0/fastabc/alchemy/repository.py

@@ -0,0 +1,203 @@
+from abc import ABC
+from typing import TypeVar, Generic, Sequence, Any, cast
+
+from sqlalchemy import (
+    select,
+    func,
+    ColumnElement,
+    BinaryExpression,
+    UnaryExpression,
+    insert,
+    update,
+)
+from sqlalchemy.exc import NoResultFound, MultipleResultsFound
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import InstrumentedAttribute
+from sqlalchemy.orm.interfaces import ORMOption
+
+from .base import SkeletonBase
+from ..abc.repository import AbstractRepository
+from ..schemas import PageParams
+
+Model = TypeVar("Model", bound=SkeletonBase)
+IdLike = Any | tuple[Any, ...]
+WhereClause = Sequence[BinaryExpression[bool] | ColumnElement[bool]]
+OrderBy = Sequence[UnaryExpression[Any] | ColumnElement[Any]]
+T = TypeVar("T")
+
+
+class AlchemyRepository(AbstractRepository, Generic[Model], ABC):
+    """Repository for SQLAlchemy models."""
+
+    model_type: type[Model]
+    session: AsyncSession
+
+    def __init__(self, session: AsyncSession):
+        self.session = session
+
+    def add(self, *instances: Model) -> None:
+        """Add an instance in the session."""
+        self.session.add_all(instances)
+
+    async def insert(
+        self,
+        *instances: Model,
+    ) -> None:
+        """Insert instances into the database."""
+        if not instances:
+            return
+        stmt = insert(self.model_type)
+        instance_dicts = [instance.dump() for instance in instances]
+        await self.session.execute(stmt, instance_dicts)
+
+    async def insert_and_return(
+        self,
+        *instances: Model,
+        sort: bool = True,
+    ) -> list[Model]:
+        """Insert instances into the database and return them."""
+        if not instances:
+            return []
+        stmt = insert(self.model_type).returning(
+            self.model_type,
+            sort_by_parameter_order=sort,
+        )
+        instance_dicts = [instance.dump() for instance in instances]
+        scalars = await self.session.scalars(stmt, instance_dicts)
+        return list(scalars)
+
+    async def get(
+        self, ident: IdLike, options: Sequence[ORMOption] | None = None
+    ) -> Model | None:
+        """Get an instance by ID. Return `None` if not found."""
+        return await self.session.get(self.model_type, ident, options=options)
+
+    async def get_one(
+        self, ident: IdLike, options: Sequence[ORMOption] | None = None
+    ) -> Model:
+        """Get an instance by ID. Raise `sqlalchemy.exc.NoResultFound` if not found."""
+        return await self.session.get_one(
+            self.model_type, ident, options=options
+        )
+
+    async def get_many(
+        self,
+        *,
+        where: WhereClause | None = None,
+        group_by: Sequence[ColumnElement[Any]] | None = None,
+        having: WhereClause | None = None,
+        distinct: Sequence[ColumnElement[Any]] | None = None,
+        order_by: OrderBy | None = None,
+        limit: int | None = 10,
+        offset: int | None = None,
+    ) -> list[Model]:
+        """Get instances from the database that meet the condition."""
+        stmt = select(self.model_type)
+        if where is not None:
+            stmt = stmt.where(*where)
+        if group_by is not None:
+            stmt = stmt.group_by(*group_by)
+        if having is not None:
+            stmt = stmt.having(*having)
+        if distinct is not None:
+            stmt = stmt.distinct(*distinct)
+        if order_by is not None:
+            stmt = stmt.order_by(*order_by)
+        if limit is not None:
+            stmt = stmt.limit(limit)
+        if offset is not None:
+            stmt = stmt.offset(offset)
+        result = await self.session.execute(stmt)
+        instances = list(result.scalars().all())
+        return instances
+
+    async def paginate(
+        self,
+        params: PageParams,
+        where: WhereClause | None = None,
+        group_by: Sequence[ColumnElement[Any]] | None = None,
+        having: WhereClause | None = None,
+        distinct: Sequence[ColumnElement[Any]] | None = None,
+    ) -> list[Model]:
+        """Paginate instances from the database."""
+        attr = getattr(self.model_type, params.sort_by)
+        order_by = [attr.desc() if params.order == "desc" else attr.asc()]
+        return await self.get_many(
+            where=where,
+            group_by=group_by,
+            having=having,
+            distinct=distinct,
+            limit=params.limit,
+            offset=params.offset,
+            order_by=order_by,
+        )
+
+    async def get_by_where(
+        self, where: WhereClause | None = None
+    ) -> Model | None:
+        """
+        Get instance from the database that meets the condition.
+
+        Return None if not found.
+        Raise `sqlalchemy.exc.MultipleResultsFound` if more than one found.
+        """
+        model_list = await self.get_many(where=where, limit=2)
+
+        if not model_list:
+            return None
+
+        if len(model_list) > 1:
+            raise MultipleResultsFound()
+
+        return model_list[0]
+
+    async def get_one_by_where(
+        self, where: WhereClause | None = None
+    ) -> Model:
+        """
+        Get instance from the database that meets the condition.
+
+        Raise `sqlalchemy.exc.NoResultFound` if not found.
+        Raise `sqlalchemy.exc.MultipleResultsFound` if more than one found.
+        """
+        instance = await self.get_by_where(where)
+
+        if not instance:
+            raise NoResultFound()
+
+        return instance
+
+    async def update(self, *instances: Model) -> None:
+        """Update instances in the database."""
+        stmt = update(self.model_type)
+        dicts = [instance.dump() for instance in instances]
+        await self.session.execute(stmt, dicts)
+
+    async def merge(self, instance: Model) -> Model:
+        """Merge an instance with the corresponding session state."""
+        return await self.session.merge(instance)
+
+    async def delete(self, model: Model) -> None:
+        """Delete an instance from the session."""
+        await self.session.delete(model)
+
+    async def count(self, where: WhereClause) -> int:
+        """Count instances in the database that meets the condition."""
+        stmt = select(func.total(self.model_type)).where(*where)
+        result = await self.session.execute(stmt)
+        scalar = cast(int, result.scalar_one())
+        return scalar
+
+    async def max(self, attribute: InstrumentedAttribute[T]) -> T:
+        """Get the maximum value of an attribute from the database."""
+        stmt = select(func.max(attribute))
+        result = await self.session.execute(stmt)
+        scalar = result.scalar_one()
+        return scalar
+
+    async def min(self, attribute: InstrumentedAttribute[T]) -> T:
+        """Get the minimum value of an attribute from the database."""
+        stmt = select(func.min(attribute))
+        result = await self.session.execute(stmt)
+        scalar = result.scalar_one()
+        return scalar

fastabc-0.1.0/fastabc/alchemy/service.py

@@ -0,0 +1,9 @@
+from fastabc.abc import AbstractService
+from fastabc.alchemy import AlchemyUOW
+
+
+class AlchemyService(AbstractService):
+    uow: AlchemyUOW
+
+    def __init__(self, uow: AlchemyUOW):
+        self.uow = uow

fastabc-0.1.0/fastabc/alchemy/testing.py

@@ -0,0 +1,10 @@
+from sqlalchemy.orm import Mapped
+
+from .mixins import AlchemyEntity
+
+
+class TestUser(AlchemyEntity):
+    __tablename__ = "__test_users__"
+
+    name: Mapped[str]
+    age: Mapped[int]

fastabc-0.1.0/fastabc/alchemy/uow.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from fastabc.abc import AbstractUOW
+
+
+class AlchemyUOW(AbstractUOW):
+    """
+    SQLAlchemy UOW.
+
+    Usage::
+
+        class UOW(AlchemyUOW):
+            users: UserRepository
+
+            async def on_open(self) -> None:
+                self.users = UserRepository(self.session)
+
+
+        async with UOW(session_factory) as uow:
+            # TRANSACTION IS BEGUN...
+
+            uow.users.add(User(name="Bob", age="18"))
+            uow.commit()
+
+    """  # noqa: E501
+
+    session_factory: async_sessionmaker[AsyncSession]
+    session: AsyncSession
+
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]):
+        self.session_factory = session_factory
+
+    @property
+    def is_opened(self) -> bool:
+        if not self.session:
+            return False
+
+        return cast(bool, self.session.is_active)
+
+    async def on_open(self) -> None:
+        ...
+
+    async def open(self) -> None:
+        self.session = self.session_factory()
+        await self.session.__aenter__()
+        await self.on_open()
+
+    async def close(self, type_: Any, value: Any, traceback: Any) -> None:
+        await self.session.__aexit__(type_, value, traceback)
+
+    async def flush(self) -> None:
+        await self.session.flush()
+
+    async def rollback(self) -> None:
+        await self.session.rollback()
+
+    async def commit(self) -> None:
+        await self.session.commit()

fastabc-0.1.0/fastabc/api/__init__.py

@@ -0,0 +1,11 @@
+from .openapi import (
+    OpenAPIResponseType,
+    StringErrorResponse,
+    ResponseGroup,
+)
+
+__all__ = [
+    "OpenAPIResponseType",
+    "StringErrorResponse",
+    "ResponseGroup",
+]

fastabc-0.1.0/fastabc/api/openapi.py

@@ -0,0 +1,103 @@
+from abc import ABC
+from typing import Any, Annotated
+
+from pydantic import BaseModel, Field
+
+# https://fastapi.tiangolo.com/how-to/extending-openapi/
+OpenAPIResponseType = dict[int | str, dict[str, Any]]
+
+
+class StringErrorResponse(BaseModel):
+    detail: Annotated[str, Field(min_length=1, max_length=1024)]
+
+
+class ResponseGroup(ABC):
+    @classmethod
+    def create(cls) -> OpenAPIResponseType:
+        """400 Bad Request, 403 Forbidden."""
+        return {
+            400: {
+                "description": "Already exists",
+                "model": StringErrorResponse,
+            },
+            403: {
+                "description": "Access denied",
+                "model": StringErrorResponse,
+            },
+        }
+
+    @classmethod
+    def create_many(cls) -> OpenAPIResponseType:
+        """403 Forbidden."""
+        return {
+            403: {
+                "description": "Access denied",
+                "model": StringErrorResponse,
+            }
+        }
+
+    @classmethod
+    def get(cls) -> OpenAPIResponseType:
+        """403 Forbidden, 404 Not Found"""
+        return {
+            404: {
+                "description": "Not found",
+                "model": StringErrorResponse,
+            },
+            403: {
+                "description": "Access denied",
+                "model": StringErrorResponse,
+            },
+        }
+
+    @classmethod
+    def get_many(cls) -> OpenAPIResponseType:
+        """403 Forbidden."""
+        return {
+            403: {
+                "description": "Access denied",
+                "model": StringErrorResponse,
+            }
+        }
+
+    @classmethod
+    def update(cls) -> OpenAPIResponseType:
+        """403 Forbidden, 404 Not Found."""
+        return {
+            404: {
+                "description": "Not found",
+                "model": StringErrorResponse,
+            },
+            403: {
+                "description": "Access denied",
+                "model": StringErrorResponse,
+            },
+        }
+
+    @classmethod
+    def delete(cls) -> OpenAPIResponseType:
+        """403 Forbidden, 404 Not Found"""
+        return {
+            404: {
+                "description": "Not found",
+                "model": StringErrorResponse,
+            },
+            403: {
+                "description": "Access denied",
+                "model": StringErrorResponse,
+            },
+        }
+
+    @classmethod
+    def multi_response(cls, examples: dict[str | int, str]) -> dict[str, Any]:
+        return {
+            "content": {
+                "application/json": {
+                    "examples": {
+                        code: {"summary": summary, "value": {"detail": code}}
+                        for code, summary in examples.items()
+                    }
+                }
+            },
+            "model": StringErrorResponse,
+        }

fastabc-0.1.0/fastabc/exceptions.py

@@ -0,0 +1,6 @@
+class FastABCException(Exception):
+    pass
+
+
+class SettingsNotFound(FastABCException):
+    pass

fastabc-0.1.0/fastabc/schemas/__init__.py

@@ -0,0 +1,23 @@
+from .base import SkeletonModel
+from .mixins import (
+    HasTimestamp,
+    SoftDeletable,
+    HasID,
+    MixinModel,
+    EntityModel,
+)
+from .pagination import (
+    PageParams,
+    Page,
+)
+
+__all__ = [
+    "PageParams",
+    "Page",
+    "HasTimestamp",
+    "SoftDeletable",
+    "HasID",
+    "MixinModel",
+    "EntityModel",
+    "SkeletonModel",
+]

fastabc-0.1.0/fastabc/schemas/base.py

@@ -0,0 +1,19 @@
+from abc import ABC
+from typing import TypeVar, Type, Any
+
+from pydantic import BaseModel, ConfigDict
+
+Model = TypeVar("Model", bound=BaseModel)
+
+
+class SkeletonModel(BaseModel, ABC):
+    @classmethod
+    def validate_or_none(
+        cls: Type[Model], model: Any, **kwargs: Any
+    ) -> Model | None:
+        if model is None:
+            return None
+
+        return cls.model_validate(model, **kwargs)
+
+    model_config = ConfigDict(from_attributes=True)

fastabc-0.1.0/fastabc/schemas/mixins.py

@@ -0,0 +1,38 @@
+import datetime
+from abc import ABC
+
+from pydantic import Field
+
+from .base import SkeletonModel
+
+
+# https://docs.pydantic.dev/latest/concepts/models/#abstract-base-classes
+
+
+class MixinModel(SkeletonModel, ABC):
+    """Base class for all mixins."""
+
+    pass
+
+
+class HasID(MixinModel):
+    id: int = Field(ge=1)
+
+
+class HasTimestamp(MixinModel):
+    created_at: datetime.datetime = Field(
+        default_factory=datetime.datetime.now,
+    )
+    updated_at: datetime.datetime = Field(
+        default_factory=datetime.datetime.now,
+    )
+
+
+class SoftDeletable(MixinModel):
+    deleted_at: datetime.datetime | None = Field(
+        None,
+    )
+
+
+class EntityModel(HasID, HasTimestamp):
+    pass

fastabc-0.1.0/fastabc/schemas/pagination.py

@@ -0,0 +1,27 @@
+from typing import Generic, TypeVar, Literal
+
+from pydantic import Field, computed_field, BaseModel
+
+from .base import SkeletonModel
+
+
+class PageParams(SkeletonModel):
+    limit: int = Field(10, ge=0, le=100)
+    offset: int = Field(0, ge=0)
+    sort_by: Literal["updated_at", "created_at"] = "updated_at"
+    order: Literal["asc", "desc"] = "desc"
+
+
+# https://docs.pydantic.dev/latest/concepts/models/#generic-models
+
+
+Model = TypeVar("Model", bound=BaseModel)
+
+
+class Page(SkeletonModel, Generic[Model]):
+    items: list[Model]
+
+    @computed_field
+    @property
+    def total(self) -> int:
+        return len(self.items)

fastabc-0.1.0/fastabc/settings/__init__.py

@@ -0,0 +1,22 @@
+from .app import AppModel, APIModel, BotModel
+from .db import DatabaseServerDsn, DatabaseDsn
+from .env import load_env
+from .pg import PgServerDsn, PostgresDsn
+from .mysql import MysqlServerDsn, MysqlDsn
+from .url import ConnectionUrl
+from .redis import RedisDsn
+
+__all__ = [
+    "DatabaseServerDsn",
+    "PgServerDsn",
+    "DatabaseDsn",
+    "PostgresDsn",
+    "ConnectionUrl",
+    "AppModel",
+    "APIModel",
+    "BotModel",
+    "load_env",
+    "RedisDsn",
+    "MysqlServerDsn",
+    "MysqlDsn",
+]

fastabc-0.1.0/fastabc/settings/app.py

@@ -0,0 +1,22 @@
+from typing import Literal
+
+from pydantic import Field
+
+from fastabc import SkeletonModel
+
+
+class AppModel(SkeletonModel):
+    title: str = "Test"
+    version: str = "1.0.0"
+    env: Literal["dev", "prod", "test"] = "dev"
+    debug: bool = False
+
+
+class APIModel(AppModel):
+    cors_origins: list[str] = Field(["*"])
+    cors_headers: list[str] = Field(["*"])
+    cors_methods: list[str] = Field(["*"])
+
+
+class BotModel(AppModel):
+    bot_token: str

fastabc-0.1.0/fastabc/settings/db.py

@@ -0,0 +1,34 @@
+from abc import ABC
+
+from sqlalchemy import URL
+
+from .url import ConnectionUrl
+
+
+class DatabaseServerDsn(ConnectionUrl, ABC):
+    dialect: str
+    sync_driver: str
+    async_driver: str
+
+    def get_dsn(self, db: str, sync: bool = True) -> str:
+        driver = self.sync_driver if sync else self.async_driver
+        return URL.create(
+            drivername=f"{self.dialect}+{driver}",
+            username=self.username,
+            password=self.password.get_secret_value(),
+            host=self.host,
+            port=self.port,
+            database=db,
+        ).render_as_string(hide_password=False)
+
+
+class DatabaseDsn(DatabaseServerDsn):
+    db: str
+
+    @property
+    def sync_dsn(self) -> str:
+        return super().get_dsn(self.db)
+
+    @property
+    def async_dsn(self) -> str:
+        return super().get_dsn(self.db, sync=False)

fastabc-0.1.0/fastabc/settings/env.py

@@ -0,0 +1,18 @@
+import os
+from typing import Sequence
+
+from dotenv import load_dotenv
+
+from fastabc.exceptions import SettingsNotFound
+
+
+def load_env(
+    env_files: Sequence[str] = (".dev.env", ".prod.env", ".env"),
+    no_env_file_var: str = "NO_ENV_FILE",
+) -> None:
+    if os.getenv(no_env_file_var):
+        return
+    for file in env_files:
+        if load_dotenv(file):
+            return
+    raise SettingsNotFound(f"Settings file not found: {env_files}")

fastabc-0.1.0/fastabc/settings/mysql.py

@@ -0,0 +1,11 @@
+from .db import DatabaseServerDsn, DatabaseDsn
+
+
+class MysqlServerDsn(DatabaseServerDsn):
+    dialect: str = "mysql"
+    sync_driver: str = "mysql"
+    async_driver: str = "aiomysql"
+
+
+class MysqlDsn(MysqlServerDsn, DatabaseDsn):
+    pass

fastabc-0.1.0/fastabc/settings/pg.py

@@ -0,0 +1,11 @@
+from .db import DatabaseServerDsn, DatabaseDsn
+
+
+class PgServerDsn(DatabaseServerDsn):
+    dialect: str = "postgresql"
+    sync_driver: str = "psycopg2"
+    async_driver: str = "asyncpg"
+
+
+class PostgresDsn(PgServerDsn, DatabaseDsn):
+    pass

fastabc-0.1.0/fastabc/settings/redis.py

@@ -0,0 +1,16 @@
+from abc import ABC
+
+from pydantic import SecretStr
+
+from fastabc.settings import ConnectionUrl
+
+
+class RedisDsn(ConnectionUrl, ABC):
+    host: str
+    port: int
+    username: str = "default"
+    password: SecretStr = SecretStr("")
+    db: int = 0
+
+    state_ttl: int | None = None
+    data_ttl: int | None = None

fastabc-0.1.0/fastabc/settings/url.py

@@ -0,0 +1,29 @@
+from abc import ABC
+from typing import Any
+
+from pydantic import model_validator, SecretStr
+
+from fastabc import SkeletonModel
+
+
+class ConnectionUrl(SkeletonModel, ABC):
+    host: str
+    port: int
+    username: str
+    password: SecretStr
+
+    # aliases
+    user: str
+
+    @model_validator(mode="before")
+    def check_model(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if "user" in data and "username" in data:
+                raise ValueError(
+                    "Cannot have both 'user' and 'username' in the same URL"
+                )
+            if "user" in data:
+                data["username"] = data["user"]
+            if "username" in data:
+                data["user"] = data["username"]
+        return data

fastabc-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[tool.poetry]
+name = "fastabc"
+version = "0.1.0"
+description = "Ready-made API Abstractions: basic models, repositories, unit of work and other stuff."
+authors = ["Ivan Stasevich <pravitel2015ify@gmail.com>"]
+readme = "README.md"
+classifiers = [
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python",
+    "Topic :: Internet",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Framework :: FastAPI",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 1",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Internet :: WWW/HTTP",
+]
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.10.0"
+ruff = "^0.4.8"
+
+[project.urls]
+Homepage = "https://github.com/everysoftware/fastabc"
+Documentation = ""
+Repository = "https://github.com/everysoftware/fastabc"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pydantic = "^2.7.3"
+sqlalchemy = "^2.0.30"
+pydantic-settings = "^2.3.1"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.ruff]
+fix = true
+indent-width = 4
+line-length = 79
+src = ["src"]
+target-version = "py311"
+
+[tool.ruff.format]
+docstring-code-format = true
+
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = "*.*"
+ignore_missing_imports = true