начата работа с бд

Author: albertalexandrov

README.md

@@ -1,4 +1,23 @@
-# Работа с базами данных
+# Fastapi-Django
+
+Приложение, разрабатываемое при помощи это библиотеки: [https://github.com/albertalexandrov/fastapi-django-example](https://github.com/albertalexandrov/fastapi-django-example)
+
+Вспомогательная библиотека для разработки приложений на FastAPI.
+
+Реализует функционал для наиболее распространных ситуаций (создание экзмепляра приложения FastAPI по заданным настройкам, 
+работа с БД, фильтрация, пагинация, авторизация, аутентификация).
+
+- [Названия библиотеки](#названия-библиотеки)
+- [TODO](#todo)
+- [Создание приложения](#создание-приложения)
+- [Запуск приложения](#запуск-приложения)
+- [Работа с БД](#работа-с-бд)
+  - [Сессии SQLAlchemy](#сессии-sqlalchemy)
+  - [Миграции](#миграции)
+- [Исследование имеющихся решений](#исследование-имеющихся-решений)
+  - [fastapi-sqla](#fastapi-sqla)
+  - [repository-sqlalchemy](#repository-sqlalchemy)
+  - [FastAPI-SQLAlchemy](#fastapi-sqlalchemy)
 
 ## Названия библиотеки
 
@@ -75,6 +94,54 @@ python manage.py runserver
 
 Это запустит экземпляр указанного в UVICORN_APP приложения при помощи uvicorn. 
 
+## Работа с БД
+
+### Сессии SQLAlchemy
+
+Работа с базами данных происходит через слой репозиториев. Для этого разработан [базовый класс репозитория BaseRepository](fastapi_django/db/repositories/base.py#L13), 
+который предоставляет возможность работать с данными в стиле Django ORM:
+
+```python
+from fastapi_django.db.repositories.base import BaseRepository
+from fastapi_django.db.sessions import contextified_autocommit_session
+
+
+class UsersRepository(BaseRepository):
+    model_cls = User
+
+
+async with contextified_autocommit_session():
+    repository = UsersRepository()
+    users = await repository.objects.filter(name="Иван").all()
+```
+
+Обратите внимание, что сессия SQLAlchemy не передается при инициализации репозитория. Вместо этого она инициализируется 
+контекстным менеджером contextified_autocommit_session() и помещается в ContextVars. Репозитории (все в пределах действия 
+контекстного менеджера) затем берут инициализированную сессию оттуда. contextified_autocommit_session() также управляет 
+жизненным циклом сессии.
+
+Настройки базы данных задаются в settings(.py) в DATABASE. Пример:
+
+```python
+DATABASE = {
+    "DRIVERNAME": "postgresql+asyncpg",
+    "DATABASE": "fastapi-django",
+    "USERNAME": "postgres",
+    "PASSWORD": "postgres",
+    "HOST": "127.0.0.1",
+    "PORT": "5433",
+    "OPTIONS": {
+        "echo": True
+    },
+}
+```
+
+где OPTIONS - необязательные аргументы, которые будут переданы как kwargs в функцию create_async_engine().
+
+### Миграции
+
+Работа с миграциями остается привычной - через консольную команду alembic.
+
 ## Исследование имеющихся решений
 
 [https://github.com/mjhea0/awesome-fastapi](https://github.com/mjhea0/awesome-fastapi)

fastapi_django/conf/__init__.py

@@ -19,7 +19,7 @@ def _setup(self, name=None):
         This is used the first time settings are needed, if the user hasn't
         configured settings manually.
         """
-        settings_module = os.environ.get(ENVIRONMENT_VARIABLE)
+        settings_module = os.environ.get(ENVIRONMENT_VARIABLE, "settings")
         if not settings_module:
             raise ValueError("не сконфигурировано")
 

fastapi_django/conf/global_settings.py

@@ -14,7 +14,22 @@
 
 TRUSTED_HOST_MIDDLEWARE_ALLOWED_HOSTS = ["*"]
 
-# DATABASES = {}
+DATABASE: dict = {}
+# пример:
+# DATABASE: dict = {
+#     "DRIVERNAME": "postgresql+asyncpg",
+#     "USERNAME": "username",
+#     "PASSWORD": "password",
+#     "HOST": "localhost",
+#     "PORT": 5432,
+#     "DATABASE": "database",
+#     "OPTIONS": {
+#         "connect_args": {"timeout": 30},
+#         "echo": True,
+#         "pool_recycle": 3600,
+#         # другие параметры, которые будут переданы как kw в функцию create_async_engine()
+#     }
+# }
 
 # UVICORN_APP определяется непосредственно в настройках приложения,
 # тк библиотека предоставляет только функцию get_default_app, которая создает экзмепляр приложения

fastapi_django/db/__init__.py

@@ -0,0 +1,42 @@
+from sqlalchemy import URL
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from fastapi_django.conf import settings
+from fastapi_django.exceptions import ImproperlyConfigured
+
+
+# поддерживаемые диалекты SQLAlchemy https://docs.sqlalchemy.org/en/20/dialects/index.html
+# SQLAlchemy как безоговорочный вариант для взаимодействия с БД
+
+# TODO:
+#  по умолчанию не устанавливать библиотеку SQLAlchemy
+#  проверять факт установки SQLAlchemy
+
+
+class EngineProxy:
+    def __init__(self):
+        if not settings.DATABASE:
+            raise ImproperlyConfigured("База данных не сконфигурирована")
+        # TODO: прочекать параметры для разных диалектов
+        url = URL.create(
+            drivername=settings.DATABASE["DRIVERNAME"],
+            username=settings.DATABASE.get("USERNAME"),
+            password=settings.DATABASE.get("PASSWORD"),
+            host=settings.DATABASE.get("HOST"),
+            port=settings.DATABASE.get("PORT"),
+            database=settings.DATABASE["DATABASE"],
+        )
+        kw = settings.DATABASE.get("OPTIONS", {})
+        self.__dict__["_engine"] = create_async_engine(url, **kw)  # иначе будет RecursionError: maximum recursion depth exceeded
+
+    def __getattr__(self, item):
+        return getattr(self._engine, item)
+
+    def __setattr__(self, name, value):
+        return setattr(self._engine, name, value)
+
+    def __delattr__(self, name):
+        return delattr(self._engine, name)
+
+
+engine = EngineProxy()

fastapi_django/db/dependencies.py

@@ -0,0 +1,24 @@
+from typing import Any, AsyncIterator, Callable, Annotated
+
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from fastapi_django.db.sessions import contextified_transactional_session, contextified_autocommit_session
+
+
+def contextify_transactional_session(**kw: Any) -> Callable:
+    async def wrapper() -> AsyncIterator[AsyncSession]:
+        async with contextified_transactional_session(**kw) as session:
+            yield session
+    return wrapper
+
+
+def contextify_autocommit_session(**kw: Any) -> Callable:
+    async def wrapper() -> AsyncIterator[AsyncSession]:
+        async with contextified_autocommit_session(**kw) as session:
+            yield session
+    return wrapper
+
+
+ContextifiedTransactionalSession = Annotated[AsyncSession, Depends(contextify_transactional_session())]
+ContextifiedAutocommitSession = Annotated[AsyncSession, Depends(contextify_autocommit_session())]

fastapi_django/db/exceptions.py

@@ -0,0 +1,6 @@
+class ColumnNotFoundError(Exception):
+    def __init__(self, model, column_name: str):
+        error = (
+            f"Столбец `{column_name}` не найден в модели {model.__name__}"
+        )
+        super().__init__(error)

fastapi_django/db/models/__init__.py

@@ -0,0 +1,16 @@
+from typing import Self
+
+from sqlalchemy import MetaData
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase
+
+metadata = MetaData()
+
+
+class Model(AsyncAttrs, DeclarativeBase):
+    metadata = metadata
+
+    def update(self, **values) -> Self:
+        for key, value in values.items():
+            setattr(self, key, value)
+        return self

fastapi_django/db/models/base.py

@@ -0,0 +1,3 @@
+from fastapi_django.db.repositories.base import BaseRepository
+
+__all__ = ["BaseRepository"]

fastapi_django/db/repositories/__init__.py

@@ -0,0 +1,78 @@
+import logging
+from itertools import islice
+from typing import Generic, Any, Type, Self
+
+from fastapi_django.db.repositories.queryset import QuerySet
+from fastapi_django.db.sessions import session_context_var
+from fastapi_django.db.types import Model
+from fastapi_django.exceptions import ImproperlyConfigured
+
+logger = logging.getLogger(__name__)
+
+
+class BaseRepository(Generic[Model]):
+    model_cls: Type[Model]
+
+    def __init__(self):
+        if not self.model_cls:
+            raise ImproperlyConfigured(f"Не задана модель в атрибуте `{self.__class__.__name__}.model_cls`")
+        self._session = session_context_var.get()
+        assert self._session is not None, "Сессия не определена. Используйте декоратор"
+        print(self._session)
+        self._flush = False
+        self._commit = False
+        print(f"Инициировали репозиторий {self.__class__.__name__}")
+
+    def _clone(self) -> Self:
+        clone = self.__class__()
+        clone._flush = self._flush
+        clone._commit = self._commit
+        return clone
+
+    def flush(self, flush: bool = True, /) -> Self:
+        clone = self._clone()
+        clone._flush = flush
+        return clone
+
+    def commit(self, commit: bool = True, /) -> Self:
+        clone = self._clone()
+        clone._commit = commit
+        return clone
+
+    async def _flush_commit_reset(self, *objs: Model) -> None:
+        if self._flush and not self._commit and objs:
+            await self._session.flush(objs)
+        elif self._commit:
+            await self._session.commit()
+        self._flush = False
+        self._commit = False
+
+    async def create(self, **kw: Any) -> Model:
+        obj = self.model_cls(**kw)
+        self._session.add(obj)
+        await self._flush_commit_reset(obj)
+        return obj
+
+    async def bulk_create(self, values: list[dict], batch_size: int | None = None) -> list[Model]:
+        if batch_size is not None and (not isinstance(batch_size, int) or batch_size <= 0):
+            raise ValueError("batch_size должен быть целым положительным числом")
+        objs = []
+        if batch_size:
+            it = iter(values)
+            while batch := list(islice(it, batch_size)):
+                batch_objs = [self.model_cls(**item) for item in batch]
+                await self._flush_commit_reset(*batch_objs)
+                objs.extend(batch_objs)
+        else:
+            for item in values:
+                obj = self.model_cls(**item)
+                objs.append(obj)
+            await self._flush_commit_reset(*objs)
+        return objs
+
+    async def get_by_pk(self, pk: Any) -> Model | None:
+        return await self._session.get(self.model_cls, pk)
+
+    @property
+    def objects(self) -> QuerySet:
+        return QuerySet(self.model_cls, self._session)