dplex 0.1.0__tar.gz

dplex-0.1.0/LICENSE

@@ -0,0 +1,2 @@
+License
+

dplex-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: dplex
+Version: 0.1.0
+Summary: 
+License-Expression: MIT
+License-File: LICENSE
+Author: Igor Chesnokov
+Author-email: front-gold@mail.ru
+Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pydantic (>=2.11.9,<3.0.0)
+Requires-Dist: sqlalchemy (>=2.0.43,<3.0.0)
+Description-Content-Type: text/markdown
+
+# dplex

dplex-0.1.0/README.md

@@ -0,0 +1 @@
+# dplex

dplex-0.1.0/dplex/__init__.py

@@ -0,0 +1,50 @@
+"""
+dplex - Enterprise-grade data layer framework for Python
+"""
+
+from dplex.repositories.dp_repo import DPRepo
+from dplex.types import NullMarker, NULL
+from dplex.services.dp_service import DPService
+from dplex.services.dp_filters import DPFilters
+from dplex.services.sort import Sort, Order, NullsPlacement
+from dplex.services.filters import (
+    StringFilter,
+    IntFilter,
+    FloatFilter,
+    DecimalFilter,
+    BooleanFilter,
+    DateFilter,
+    DateTimeFilter,
+    TimeFilter,
+    TimestampFilter,
+    EnumFilter,
+    UUIDFilter,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Core classes
+    "DPRepo",
+    "DPService",
+    "DPFilters",
+    # Sort
+    "Sort",
+    "Order",
+    "NullsPlacement",
+    # Filters
+    "StringFilter",
+    "IntFilter",
+    "FloatFilter",
+    "DecimalFilter",
+    "BooleanFilter",
+    "DateFilter",
+    "DateTimeFilter",
+    "TimeFilter",
+    "TimestampFilter",
+    "EnumFilter",
+    "UUIDFilter",
+    # Null marker
+    "NULL",
+    "NullMarker",
+]

dplex-0.1.0/dplex/repositories/dp_repo.py

@@ -0,0 +1,141 @@
+import uuid
+from typing import Any, Generic
+
+from sqlalchemy import select, func, and_, delete, ColumnElement, update
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import InstrumentedAttribute
+
+from dplex.repositories.query_builder import QueryBuilder
+from dplex.types import ModelType, KeyType
+
+
+class DPRepo(Generic[ModelType, KeyType]):
+    """Базовый репозиторий с улучшенной типизацией"""
+
+    def __init__(
+        self,
+        model: type[ModelType],
+        session: AsyncSession,
+        key_type: type[KeyType] = uuid.UUID,
+        id_field_name: str = "id",
+    ) -> None:
+        self.model = model
+        self.session = session
+        self.key_type = key_type
+        self.id_field_name = id_field_name
+        self._id_column = self._get_id_column()
+
+    def _get_id_column(self) -> InstrumentedAttribute[KeyType]:
+        """Получить типизированную ID колонку"""
+        if not hasattr(self.model, self.id_field_name):
+            raise ValueError(
+                f"Model {self.model.__name__} does not have field '{self.id_field_name}'"
+            )
+
+        column = getattr(self.model, self.id_field_name)
+
+        # Проверяем что это SQLAlchemy column
+        if not hasattr(column, "property"):
+            raise ValueError(
+                f"Field '{self.id_field_name}' in {self.model.__name__} is not a SQLAlchemy column"
+            )
+
+        return column
+
+    def query(self) -> "QueryBuilder[ModelType]":
+        """Создать типизированный query builder"""
+        return QueryBuilder(self, self.model)
+
+    def id_eq(self, value: KeyType) -> ColumnElement[bool]:
+        """Возвращает условие для сравнения ID с entity_id"""
+        return self._id_column == value
+
+    def id_in(self, values: list[KeyType]) -> ColumnElement[bool]:
+        """Возвращает условие для проверки ID в списке значений"""
+        return self._id_column.in_(values)
+
+    # Методы с использованием закешированной колонки
+    async def find_by_id(self, entity_id: KeyType) -> ModelType | None:
+        """Найти сущность по ID"""
+        return await self.query().where(self.id_eq(entity_id)).find_one()
+
+    async def find_by_ids(self, entity_ids: list[KeyType]) -> list[ModelType]:
+        """Найти сущности по списку ID"""
+        return await self.query().where(self.id_in(entity_ids)).find_all()
+
+    async def delete_by_id(self, entity_id: KeyType) -> None:
+        """Удалить сущность по ID"""
+        stmt = delete(self.model).where(self.id_eq(entity_id))
+        await self.session.execute(stmt)
+
+    async def delete_by_ids(self, entity_ids: list[KeyType]) -> None:
+        """Удалить сущности по ID"""
+        stmt = delete(self.model).where(self.id_in(entity_ids))
+        await self.session.execute(stmt)
+
+    async def update_by_id(self, entity_id: KeyType, values: dict[str, Any]) -> None:
+        """Обновить сущность по ID"""
+        stmt = update(self.model).where(self.id_eq(entity_id)).values(**values)
+        await self.session.execute(stmt)
+
+    async def update_by_ids(
+        self, entity_ids: list[KeyType], values: dict[str, Any]
+    ) -> None:
+        """Обновить сущности по ID"""
+        stmt = update(self.model).where(self.id_in(entity_ids)).values(**values)
+        await self.session.execute(stmt)
+
+    async def exists_by_id(self, entity_id: KeyType) -> bool:
+        """Проверить существование сущности по ID"""
+        count = await self.query().where(self.id_eq(entity_id)).count()
+        return count > 0
+
+    async def create(self, entity: ModelType) -> ModelType:
+        """Создать новую сущность"""
+        self.session.add(entity)
+        return entity
+
+    async def create_bulk(self, entities: list[ModelType]) -> list[ModelType]:
+        """Создать несколько сущностей"""
+        self.session.add_all(entities)
+        return entities
+
+    async def save_changes(self) -> None:
+        """Сохранить изменения в базе данных"""
+        await self.session.commit()
+
+    async def rollback(self) -> None:
+        """Откатить изменения"""
+        await self.session.rollback()
+
+    # Методы для выполнения запросов билдера
+    async def execute_typed_query(
+        self, builder: "QueryBuilder[ModelType]"
+    ) -> list[ModelType]:
+        """Выполнить типизированный запрос"""
+        stmt = select(self.model)
+
+        if builder.filters:
+            stmt = stmt.where(and_(*builder.filters))
+
+        if builder.order_by_clauses:
+            stmt = stmt.order_by(*builder.order_by_clauses)
+
+        if builder.limit_value is not None:
+            stmt = stmt.limit(builder.limit_value)
+
+        if builder.offset_value is not None:
+            stmt = stmt.offset(builder.offset_value)
+
+        result = await self.session.scalars(stmt)
+        return list(result.all())
+
+    async def execute_typed_count(self, builder: "QueryBuilder[ModelType]") -> int:
+        """Подсчитать записи через типизированный билдер"""
+        stmt = select(func.count()).select_from(self.model)
+
+        if builder.filters:
+            stmt = stmt.where(and_(*builder.filters))
+
+        result = await self.session.execute(stmt)
+        return result.scalar_one()

dplex-0.1.0/dplex/repositories/query_builder.py

@@ -0,0 +1,294 @@
+from typing import Any, Generic, TYPE_CHECKING
+from sqlalchemy import ColumnElement, asc, desc, nullsfirst, nullslast
+from sqlalchemy.orm import InstrumentedAttribute
+
+
+from dplex.services.sort import Sort, Order, NullsPlacement
+from dplex.types import ModelType
+
+if TYPE_CHECKING:
+    from dplex.repositories.dp_repo import DPRepo
+
+
+class QueryBuilder(Generic[ModelType]):
+    """Query Builder с улучшенной типизацией и поддержкой Sort"""
+
+    def __init__(self, repo: "DPRepo[ModelType, Any]", model: type[ModelType]) -> None:
+        self.repo = repo
+        self.model = model
+        self.filters: list[ColumnElement[bool]] = []
+        self.limit_value: int | None = None
+        self.offset_value: int | None = None
+        self.order_by_clauses: list[Any] = []
+
+    def where(self, condition: ColumnElement[bool]) -> "QueryBuilder[ModelType]":
+        """WHERE condition (принимает готовое условие)"""
+        self.filters.append(condition)
+        return self
+
+    def where_eq(
+        self, column: InstrumentedAttribute[Any], value: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column = value"""
+        condition: ColumnElement[bool] = column == value
+        return self.where(condition)
+
+    def where_ne(
+        self, column: InstrumentedAttribute[Any], value: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column != value"""
+        condition: ColumnElement[bool] = column != value
+        return self.where(condition)
+
+    def where_in(
+        self, column: InstrumentedAttribute[Any], values: list[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column IN (values)"""
+        if not values:
+            # Если список пустой, добавляем условие которое всегда false
+            condition: ColumnElement[bool] = column.in_([])
+        else:
+            condition = column.in_(values)
+        return self.where(condition)
+
+    def where_not_in(
+        self, column: InstrumentedAttribute[Any], values: list[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column NOT IN (values)"""
+        if not values:
+            # Если список пустой, условие всегда true - не добавляем фильтр
+            return self
+        condition: ColumnElement[bool] = ~column.in_(values)
+        return self.where(condition)
+
+    def where_is_null(
+        self, column: InstrumentedAttribute[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column IS NULL"""
+        condition: ColumnElement[bool] = column.is_(None)
+        return self.where(condition)
+
+    def where_is_not_null(
+        self, column: InstrumentedAttribute[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column IS NOT NULL"""
+        condition: ColumnElement[bool] = column.isnot(None)
+        return self.where(condition)
+
+    def where_like(
+        self, column: InstrumentedAttribute[Any], pattern: str
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column LIKE pattern"""
+        condition: ColumnElement[bool] = column.like(pattern)
+        return self.where(condition)
+
+    def where_ilike(
+        self, column: InstrumentedAttribute[Any], pattern: str
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column ILIKE pattern (case-insensitive)"""
+        condition: ColumnElement[bool] = column.ilike(pattern)
+        return self.where(condition)
+
+    def where_between(
+        self, column: InstrumentedAttribute[Any], start: Any, end: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column BETWEEN start AND end"""
+        condition: ColumnElement[bool] = column.between(start, end)
+        return self.where(condition)
+
+    def where_gt(
+        self, column: InstrumentedAttribute[Any], value: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column > value"""
+        condition: ColumnElement[bool] = column > value
+        return self.where(condition)
+
+    def where_gte(
+        self, column: InstrumentedAttribute[Any], value: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column >= value"""
+        condition: ColumnElement[bool] = column >= value
+        return self.where(condition)
+
+    def where_lt(
+        self, column: InstrumentedAttribute[Any], value: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column < value"""
+        condition: ColumnElement[bool] = column < value
+        return self.where(condition)
+
+    def where_lte(
+        self, column: InstrumentedAttribute[Any], value: Any
+    ) -> "QueryBuilder[ModelType]":
+        """WHERE column <= value"""
+        condition: ColumnElement[bool] = column <= value
+        return self.where(condition)
+
+    def limit(self, limit: int) -> "QueryBuilder[ModelType]":
+        """LIMIT записей"""
+        if limit < 0:
+            raise ValueError("Limit must be non-negative")
+        self.limit_value = limit
+        return self
+
+    def offset(self, offset: int) -> "QueryBuilder[ModelType]":
+        """OFFSET записей"""
+        if offset < 0:
+            raise ValueError("Offset must be non-negative")
+        self.offset_value = offset
+        return self
+
+    def paginate(self, page: int, per_page: int) -> "QueryBuilder[ModelType]":
+        """Пагинация (page начинается с 1)"""
+        if page < 1:
+            raise ValueError("Page must be >= 1")
+        if per_page < 1:
+            raise ValueError("Per page must be >= 1")
+        self.limit_value = per_page
+        self.offset_value = (page - 1) * per_page
+        return self
+
+    def order_by(
+        self, column: InstrumentedAttribute[Any], desc_order: bool = False
+    ) -> "QueryBuilder[ModelType]":
+        """
+        ORDER BY column
+
+        Args:
+            column: Колонка для сортировки
+            desc_order: True для DESC, False для ASC (по умолчанию)
+        """
+        order_clause = column.desc() if desc_order else column.asc()
+        self.order_by_clauses.append(order_clause)
+        return self
+
+    def order_by_desc(
+        self, column: InstrumentedAttribute[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """ORDER BY column DESC"""
+        return self.order_by(column, desc_order=True)
+
+    def order_by_asc(
+        self, column: InstrumentedAttribute[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """ORDER BY column ASC"""
+        return self.order_by(column, desc_order=False)
+
+    def order_by_with_nulls(
+        self,
+        column: InstrumentedAttribute[Any],
+        desc_order: bool = False,
+        nulls_placement: NullsPlacement | None = None,
+    ) -> "QueryBuilder[ModelType]":
+        """
+        ORDER BY column с управлением NULL значениями
+
+        Args:
+            column: Колонка для сортировки
+            desc_order: True для DESC, False для ASC
+            nulls_placement: Размещение NULL (FIRST или LAST)
+
+        Example:
+            qb.order_by_with_nulls(
+                User.created_at,
+                desc_order=True,
+                nulls_placement=NullsPlacement.LAST
+            )
+        """
+        # Создаем базовую сортировку
+        if desc_order:
+            order_clause = desc(column)
+        else:
+            order_clause = asc(column)
+
+        # Применяем nulls placement если указан
+        if nulls_placement == NullsPlacement.FIRST:
+            order_clause = nullsfirst(order_clause)
+        elif nulls_placement == NullsPlacement.LAST:
+            order_clause = nullslast(order_clause)
+
+        self.order_by_clauses.append(order_clause)
+        return self
+
+    def apply_sort(
+        self, sort_item: Sort[Any], column: InstrumentedAttribute[Any]
+    ) -> "QueryBuilder[ModelType]":
+        """
+        Применить Sort объект к query builder
+
+        Args:
+            sort_item: Объект Sort с параметрами сортировки
+            column: Колонка модели для сортировки
+
+        Example:
+            sort = Sort(
+                field=UserSortField.CREATED_AT,
+                order=Order.DESC,
+                nulls=NullsPlacement.LAST
+            )
+            qb.apply_sort(sort, User.created_at)
+        """
+        desc_order = sort_item.order == Order.DESC
+        return self.order_by_with_nulls(column, desc_order, sort_item.nulls)
+
+    def apply_sorts(
+        self,
+        sort_list: list[Sort[Any]],
+        column_mapper: dict[Any, InstrumentedAttribute[Any]],
+    ) -> "QueryBuilder[ModelType]":
+        """
+        Применить список Sort объектов к query builder
+
+        Args:
+            sort_list: Список объектов Sort
+            column_mapper: Словарь для маппинга field -> column
+                          {SortField.USERNAME: User.username, ...}
+
+        Example:
+            sorts = [
+                Sort(field=UserSortField.CREATED_AT, order=Order.DESC),
+                Sort(field=UserSortField.USERNAME, order=Order.ASC)
+            ]
+            mapper = {
+                UserSortField.CREATED_AT: User.created_at,
+                UserSortField.USERNAME: User.username
+            }
+            qb.apply_sorts(sorts, mapper)
+        """
+        for sort_item in sort_list:
+            column = column_mapper.get(sort_item.by)
+            if column is None:
+                raise ValueError(f"Column mapping not found for field: {sort_item.by}")
+            self.apply_sort(sort_item, column)
+        return self
+
+    def clear_order(self) -> "QueryBuilder[ModelType]":
+        """Очистить сортировку"""
+        self.order_by_clauses = []
+        return self
+
+    async def find_all(self) -> list[ModelType]:
+        """Выполнить запрос и вернуть все результаты"""
+        return await self.repo.execute_typed_query(self)
+
+    async def find_one(self) -> ModelType | None:
+        """Выполнить запрос и вернуть первый результат"""
+        self.limit_value = 1
+        results = await self.find_all()
+        return results[0] if results else None
+
+    async def find_first(self) -> ModelType:
+        """Выполнить запрос и вернуть первый результат, иначе ошибка"""
+        result = await self.find_one()
+        if result is None:
+            raise ValueError(f"No {self.model.__name__} found matching criteria")
+        return result
+
+    async def count(self) -> int:
+        """Подсчитать количество записей"""
+        return await self.repo.execute_typed_count(self)
+
+    async def exists(self) -> bool:
+        """Проверить существование записей"""
+        count = await self.count()
+        return count > 0