fastapi-sqlalchemy-toolkit 0.7.17__tar.gz → 0.7.19__tar.gz

{fastapi_sqlalchemy_toolkit-0.7.17 → fastapi_sqlalchemy_toolkit-0.7.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi_sqlalchemy_toolkit
-Version: 0.7.17
+Version: 0.7.19
 Summary: FastAPI SQLAlchemy Toolkit
 Project-URL: Homepage, https://github.com/e-kondr01/fastapi-sqlalchemy-toolkit
 Author-email: Egor Kondrashov <e.kondr01@gmail.com>

{fastapi_sqlalchemy_toolkit-0.7.17 → fastapi_sqlalchemy_toolkit-0.7.19}/fastapi_sqlalchemy_toolkit/model_manager.py

@@ -7,10 +7,12 @@ from fastapi_pagination.bases import BasePage
 from fastapi_pagination.ext.sqlalchemy import paginate
 from pydantic import BaseModel
 from sqlalchemy import (
+    Index,
     Integer,
     Row,
     String,
     UniqueConstraint,
+    and_,
     delete,
     func,
     insert,
@@ -65,6 +67,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         self.fk_name_to_model: dict[str, type[ModelT]] = {}
 
         self.unique_constraints: List[List[str]] = []
+        self.unique_indexes: List[Index] = []
 
         if hasattr(self.model, "__table_args__"):
             for table_arg in self.model.__table_args__:
@@ -73,6 +76,8 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                         self.unique_constraints.append(table_arg.columns.keys())
                     else:
                         self.unique_constraints.append(table_arg._pending_colargs)
+                elif isinstance(table_arg, Index) and table_arg.unique is True:
+                    self.unique_indexes.append(table_arg)
 
         self.reverse_relationships: dict[str, type[ModelT]] = {}
         self.m2m_relationships: dict[str, type[ModelT]] = {}
@@ -865,6 +870,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             await self.handle_m2m_fields(session, in_obj)
         await self.validate_unique_fields(session, in_obj, db_obj=db_obj)
         await self.validate_unique_constraints(session, in_obj)
+        await self.validate_unique_indexes(session, in_obj)
         return in_obj
 
     def get_select(self, base_stmt: Select | None = None, **_kwargs: Any) -> Select:
@@ -1045,6 +1051,37 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         return stmt
 
+    @staticmethod
+    def get_error_msg(
+        tablename: str,
+        fields: List[str],
+        *,
+        exists: bool = True,
+        field_values: List[Any] | None = None,
+    ) -> str:
+        """
+        Формирует сообщение об ошибке, которое будет возвращаться при ошибках валидации.
+        """
+
+        error_msg = tablename
+        error_msg += " с "
+        if field_values:
+            fields_with_values = []
+            for field, value in zip(fields, field_values, strict=True):
+                fields_with_values.append(f"{field} {value}")
+            error_msg += ", ".join(fields_with_values)
+        else:
+            error_msg += "таким"
+            if len(fields) > 1:
+                error_msg += "и"
+            error_msg += " "
+            error_msg += ", ".join(fields)
+        if exists:
+            error_msg += " уже существует."
+        else:
+            error_msg += " не существует."
+        return error_msg
+
     async def validate_fk_exists(
         self, session: AsyncSession, in_obj: ModelDict
     ) -> None:
@@ -1062,9 +1099,11 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 if not related_object_exists:
                     raise HTTPException(
                         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail=(
-                            f"{self.fk_name_to_model[key].__tablename__} с id "
-                            f"{in_obj[key]} не существует."
+                        detail=self.get_error_msg(
+                            self.fk_name_to_model[key].__tablename__,
+                            ["id"],
+                            field_values=[in_obj[key]],
+                            exists=False,
                         ),
                     )
 
@@ -1090,13 +1129,10 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                     session, **query, where=(self.model.id != in_obj.get("id"))
                 )
                 if object_exists:
-                    conflicting_fields = ", ".join(unique_constraint)
                     raise HTTPException(
                         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail=(
-                            f"{self.model.__tablename__} с такими "
-                            + conflicting_fields
-                            + " уже существует."
+                        detail=self.get_error_msg(
+                            self.model.__tablename__, unique_constraint
                         ),
                     )
 
@@ -1119,19 +1155,54 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                     continue
                 attrs_to_check = {column.name: in_obj[column.name]}
                 object_exists = await self.exists(
-                    session=session,
+                    session,
                     **attrs_to_check,
                     where=(self.model.id != in_obj.get("id")),
                 )
                 if object_exists:
                     raise HTTPException(
                         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail=(
-                            f"{self.model.__tablename__} c {column.name} "
-                            f"{in_obj[column.name]} уже существует"
+                        detail=self.get_error_msg(
+                            self.model.__tablename__,
+                            [column.name],
+                            field_values=[in_obj[column.name]],
                         ),
                     )
 
+    async def validate_unique_indexes(
+        self, session: AsyncSession, in_obj: ModelDict
+    ) -> None:
+        """
+        Валидирует соблюдение уникальности индексов
+        """
+        for index in self.unique_indexes:
+            condition = (
+                index.dialect_options["postgresql"].get("where")
+                if index.dialect_options.get("postgresql")
+                else None
+            )
+            filters = []
+
+            for column in index.columns:
+                try:
+                    filters.append(column == in_obj[column.name])
+                except KeyError:
+                    if column.nullable:
+                        filters.append(column.is_(None))
+
+            object_exists = await self.exists(
+                session,
+                where=and_(*filters, condition, self.model.id != in_obj.get("id")),
+            )
+            if object_exists:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=self.get_error_msg(
+                        self.model.__tablename__,
+                        [column.name for column in index.columns],
+                    ),
+                )
+
     async def handle_m2m_fields(self, session: AsyncSession, in_obj: ModelDict) -> None:
         for field in in_obj:
             if field in self.m2m_relationships:
@@ -1142,9 +1213,11 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                     if not related_object:
                         raise HTTPException(
                             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                            detail=(
-                                f"{related_model.__tablename__} с id "
-                                f"{related_object_id} не существует."
+                            detail=self.get_error_msg(
+                                related_model.__tablename__,
+                                ["id"],
+                                field_values=[related_object_id],
+                                exists=False,
                             ),
                         )
                     related_objects.append(related_object)

{fastapi_sqlalchemy_toolkit-0.7.17 → fastapi_sqlalchemy_toolkit-0.7.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fastapi_sqlalchemy_toolkit"
-version = "0.7.17"
+version = "0.7.19"
 authors = [
   { name="Egor Kondrashov", email="e.kondr01@gmail.com" },
 ]

{fastapi_sqlalchemy_toolkit-0.7.17 → fastapi_sqlalchemy_toolkit-0.7.19}/tests/test_public_methods.py

@@ -288,7 +288,7 @@ async def test_create_unique_filed_validation(session: AsyncSession):
     )
     with pytest.raises(
         HTTPException,
-        match="422: category c title test-create-category-title уже существует",
+        match="422: category с title test-create-category-title уже существует.",
     ):
         await category_manager.create(
             session=session, title="test-create-category-title"
@@ -353,7 +353,7 @@ async def test_update_unique_filed_validation(session: AsyncSession):
     )
     with pytest.raises(
         HTTPException,
-        match="422: category c title test-category-title1 уже существует",
+        match="422: category с title test-category-title1 уже существует.",
     ):
         await category_manager.update(
             session=session,