fastapi-rtk 0.2.27__py3-none-any.whl → 1.0.13__py3-none-any.whl

fastapi_rtk/backends/sqla/extensions/geoalchemy2/filters.py

@@ -1,8 +1,10 @@
 from typing import Any
 
-from fastapi import HTTPException
+import fastapi
 from sqlalchemy import Select, func
 
+from .....exceptions import HTTPWithValidationException
+from .....lang import lazy_text
 from ...filters import (
     BaseFilter,
     FilterContains,
@@ -32,13 +34,14 @@ class GeoBaseFilter(BaseFilter):
                 value, self._get_column(col).type.geometry_type if check else ""
             )
         except ValueError as e:
-            detail = {
-                "type": type(value).__name__,
-                "loc": ["query", "filters", {"col": col, "opr": self.arg_name}],
-                "msg": f"Value error, {e}",
-                "input": value,
-            }
-            raise HTTPException(status_code=422, detail=[detail])
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                "value_error",
+                "query",
+                "filters",
+                f"Value error, {e}",
+                value,
+            )
 
         if isinstance(value, dict):
             return func.ST_GeomFromGeoJSON(value)
@@ -77,7 +80,7 @@ class GeoFilterNotContains(GeoBaseFilter, FilterNotContains):
 
 
 class GeoFilterIntersects(GeoBaseFilter):
-    name = "Intersects"
+    name = lazy_text("Intersects")
     arg_name = "int"
 
     def apply(self, stmt: Select, col: str, value: Any) -> Select:
@@ -87,7 +90,7 @@ class GeoFilterIntersects(GeoBaseFilter):
 
 
 class GeoFilterNotIntersects(GeoBaseFilter):
-    name = "Not Intersects"
+    name = lazy_text("Not Intersects")
     arg_name = "nint"
 
     def apply(self, stmt: Select, col: str, value: Any) -> Select:
@@ -97,7 +100,7 @@ class GeoFilterNotIntersects(GeoBaseFilter):
 
 
 class GeoFilterOverlaps(GeoBaseFilter):
-    name = "Overlaps"
+    name = lazy_text("Overlaps")
     arg_name = "ovl"
 
     def apply(self, stmt: Select, col: str, value: Any) -> Select:
@@ -107,7 +110,7 @@ class GeoFilterOverlaps(GeoBaseFilter):
 
 
 class GeoFilterNotOverlaps(GeoBaseFilter):
-    name = "Not Overlaps"
+    name = lazy_text("Not Overlaps")
     arg_name = "novl"
 
     def apply(self, stmt: Select, col: str, value: Any) -> Select:

fastapi_rtk/backends/sqla/filters.py

@@ -2,13 +2,15 @@ import enum
 import typing
 from datetime import datetime
 
+import fastapi
 import sqlalchemy
 import sqlalchemy.types as sa_types
-from fastapi import HTTPException
 from sqlalchemy import Column, Select, and_, cast, func, or_, select
 
-from ...bases.filter import AbstractBaseFilter
+from ...bases.filter import AbstractBaseFilter, AbstractBaseOprFilter
 from ...const import logger
+from ...exceptions import HTTPWithValidationException
+from ...lang import lazy_text, translate
 from .model import Model
 
 __all__ = [
@@ -36,6 +38,7 @@ __all__ = [
     "FilterRelationOneToManyOrManyToManyIn",
     "FilterRelationOneToManyOrManyToManyNotIn",
     "FilterGlobal",
+    "BaseOprFilter",
     "SQLAFilterConverter",
 ]
 
@@ -237,7 +240,7 @@ class BaseFilterRelationOneToManyOrManyToMany(BaseFilterRelationOneToOneOrManyTo
 
 
 class FilterTextContains(BaseFilterTextContains):
-    name = "Text contains"
+    name = lazy_text(message="Text contains")
     arg_name = "tc"
 
     def apply(self, statement, col: str, value):
@@ -253,7 +256,7 @@ class FilterTextContains(BaseFilterTextContains):
 
 
 class FilterEqual(BaseFilter):
-    name = "Equal to"
+    name = lazy_text("Equal to")
     arg_name = "eq"
 
     def apply(self, statement, col: str, value):
@@ -262,7 +265,7 @@ class FilterEqual(BaseFilter):
 
 
 class FilterNotEqual(BaseFilter):
-    name = "Not Equal to"
+    name = lazy_text("Not equal to")
     arg_name = "neq"
 
     def apply(self, statement, col: str, value):
@@ -271,7 +274,7 @@ class FilterNotEqual(BaseFilter):
 
 
 class FilterStartsWith(BaseFilter):
-    name = "Starts with"
+    name = lazy_text("Starts with")
     arg_name = "sw"
 
     def apply(self, statement, col: str, value):
@@ -280,7 +283,7 @@ class FilterStartsWith(BaseFilter):
 
 
 class FilterNotStartsWith(BaseFilter):
-    name = "Not Starts with"
+    name = lazy_text("Not Starts with")
     arg_name = "nsw"
 
     def apply(self, statement, col: str, value):
@@ -289,7 +292,7 @@ class FilterNotStartsWith(BaseFilter):
 
 
 class FilterEndsWith(BaseFilter):
-    name = "Ends with"
+    name = lazy_text("Ends with")
     arg_name = "ew"
 
     def apply(self, statement, col: str, value):
@@ -298,7 +301,7 @@ class FilterEndsWith(BaseFilter):
 
 
 class FilterNotEndsWith(BaseFilter):
-    name = "Not Ends with"
+    name = lazy_text("Not Ends with")
     arg_name = "new"
 
     def apply(self, statement, col: str, value):
@@ -307,7 +310,7 @@ class FilterNotEndsWith(BaseFilter):
 
 
 class FilterContains(BaseFilter):
-    name = "Contains"
+    name = lazy_text("Contains")
     arg_name = "ct"
 
     def apply(self, statement, col: str, value):
@@ -316,7 +319,7 @@ class FilterContains(BaseFilter):
 
 
 class FilterNotContains(BaseFilter):
-    name = "Not Contains"
+    name = lazy_text("Not Contains")
     arg_name = "nct"
 
     def apply(self, statement, col: str, value):
@@ -325,7 +328,7 @@ class FilterNotContains(BaseFilter):
 
 
 class FilterGreater(BaseFilter):
-    name = "Greater than"
+    name = lazy_text("Greater than")
     arg_name = "gt"
 
     def apply(self, statement, col: str, value):
@@ -334,7 +337,7 @@ class FilterGreater(BaseFilter):
 
 
 class FilterSmaller(BaseFilter):
-    name = "Smaller than"
+    name = lazy_text("Smaller than")
     arg_name = "lt"
 
     def apply(self, statement, col: str, value):
@@ -343,7 +346,7 @@ class FilterSmaller(BaseFilter):
 
 
 class FilterGreaterEqual(BaseFilter):
-    name = "Greater equal"
+    name = lazy_text("Greater equal")
     arg_name = "ge"
 
     def apply(self, statement, col: str, value):
@@ -352,7 +355,7 @@ class FilterGreaterEqual(BaseFilter):
 
 
 class FilterSmallerEqual(BaseFilter):
-    name = "Smaller equal"
+    name = lazy_text("Smaller equal")
     arg_name = "le"
 
     def apply(self, statement, col: str, value):
@@ -361,7 +364,7 @@ class FilterSmallerEqual(BaseFilter):
 
 
 class FilterIn(BaseFilter):
-    name = "One of"
+    name = lazy_text("One of")
     arg_name = "in"
 
     def apply(self, statement, col: str, value):
@@ -370,7 +373,7 @@ class FilterIn(BaseFilter):
 
 
 class FilterBetween(BaseFilter):
-    name = "Between"
+    name = lazy_text("Between")
     arg_name = "bw"
 
     def apply(self, statement, col: str, value):
@@ -378,7 +381,14 @@ class FilterBetween(BaseFilter):
             return statement
 
         if len(value) != 2:
-            raise HTTPException(400, "Between filter requires two values")
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_400_BAD_REQUEST,
+                "greater_than" if len(value) < 2 else "less_than",
+                "query",
+                "filters",
+                translate("Between filter requires 2 values"),
+                value,
+            )
 
         value = [self._cast_value(col, v) for v in value]
         if value[0] is None or value[1] is None:
@@ -421,7 +431,7 @@ class FilterRelationOneToOneOrManyToOneNotEqual(
 
 
 class FilterRelationOneToManyOrManyToManyIn(BaseFilterRelationOneToManyOrManyToMany):
-    name = "In"
+    name = lazy_text("In")
     arg_name = "rel_m_m"
 
     def apply(self, statement, col: str, value):
@@ -439,7 +449,7 @@ class FilterRelationOneToManyOrManyToManyIn(BaseFilterRelationOneToManyOrManyToM
 
 
 class FilterRelationOneToManyOrManyToManyNotIn(BaseFilterRelationOneToManyOrManyToMany):
-    name = "Not In"
+    name = lazy_text("Not In")
     arg_name = "nrel_m_m"
 
     def apply(self, statement, col: str, value):
@@ -457,7 +467,7 @@ class FilterRelationOneToManyOrManyToManyNotIn(BaseFilterRelationOneToManyOrMany
 
 
 class FilterGlobal(BaseFilterTextContains):
-    name = "Global Filter"
+    name = lazy_text("Global Filter")
     arg_name = "global"
 
     def apply(self, statement, cols: list[str], value):
@@ -489,6 +499,9 @@ class FilterGlobal(BaseFilterTextContains):
         return statement.filter(and_(*filters))
 
 
+class BaseOprFilter(AbstractBaseOprFilter, BaseFilter): ...
+
+
 class SQLAFilterConverter:
     """
     Helper class to get available filters for a column type.
@@ -604,6 +617,22 @@ class SQLAFilterConverter:
                 FilterIn,
             ],
         ),
+        (
+            "is_files",
+            [
+                FilterTextContains,
+                # TODO: Make compatible filters
+                # FilterEqual,
+                # FilterNotEqual,
+                # FilterStartsWith,
+                # FilterNotStartsWith,
+                # FilterEndsWith,
+                # FilterNotEndsWith,
+                # FilterContains,
+                # FilterNotContains,
+                # FilterIn,
+            ],
+        ),
         (
             "is_integer",
             [

fastapi_rtk/backends/sqla/interface.py

@@ -3,7 +3,7 @@ import enum
 import json
 import typing
 from datetime import date, datetime
-from typing import Annotated, List, Literal, Type
+from typing import Annotated, Literal, Type
 
 import fastapi
 import marshmallow_sqlalchemy
@@ -22,26 +22,48 @@ from sqlalchemy.sql import sqltypes as sa_types
 
 from ...bases.db import DBQueryParams
 from ...bases.interface import AbstractInterface
+from ...const import logger
 from ...db import get_session_factory as _get_session_factory
+from ...globals import g
 from ...schemas import (
     DatetimeUTC,
 )
-from ...types import FileColumn, ImageColumn
-from ...utils import T, is_sqla_type, lazy_import, lazy_self, safe_call, smart_run
+from ...types import (
+    FileColumn,
+    FileColumns,
+    ImageColumn,
+    ImageColumns,
+    JSONBFileColumns,
+    JSONBImageColumns,
+)
+from ...utils import (
+    AsyncTaskRunner,
+    T,
+    is_sqla_type,
+    lazy_import,
+    lazy_self,
+    safe_call,
+    smart_run,
+)
 from .db import SQLAQueryBuilder
 from .filters import BaseFilter, FilterGlobal, SQLAFilterConverter
 from .model import Model
 
-__all__ = ["SQLAInterface"]
-
 if typing.TYPE_CHECKING:
     from .extensions.geoalchemy2 import GeometryConverter
 
+__all__ = ["SQLAInterface"]
+
+logger = logger.getChild("SQLAInterface")
+
+
+ModelType = typing.TypeVar("ModelType", bound=Model)
+
 
 class lazy(lazy_self["SQLAInterface", T]): ...
 
 
-class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
+class SQLAInterface(AbstractInterface[ModelType, Session | AsyncSession, Column]):
     """
     Datamodel interface for SQLAlchemy models.
     """
@@ -60,6 +82,18 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
         "fastapi_rtk.backends.sqla.extensions.geoalchemy2",
         lambda mod: mod.GeometryConverter(),
     )
+    file_manager = lazy(
+        lambda self: g.file_manager.get_instance_with_subfolder(self.obj.__tablename__)
+    )
+    """
+    The file manager instance for the datamodel. Defaults to `g.file_manager` with the subfolder set to the table name.
+    """
+    image_manager = lazy(
+        lambda self: g.image_manager.get_instance_with_subfolder(self.obj.__tablename__)
+    )
+    """
+    The image manager instance for the datamodel. Defaults to `g.image_manager` with the subfolder set to the table name.
+    """
 
     _cache_field: dict[str, str] = {}
     """
@@ -88,26 +122,26 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
         relevant_params.pop("page_size", None)
         relevant_params.pop("order_column", None)
         relevant_params.pop("order_direction", None)
-
         statement = await self.query_count.build_query(relevant_params)
         result = await smart_run(session.scalars, statement)
         return result.one()
 
-    async def get_many(self, session, params=None):
+    async def get_many(self, session, params=None) -> list[ModelType]:
         statement = await self.query.build_query(params)
         result = await smart_run(session.scalars, statement)
         return list(result.all())
 
-    async def get_one(self, session, params=None):
+    async def get_one(self, session, params=None) -> ModelType | None:
         statement = await self.query.build_query(params)
         result = await smart_run(session.scalars, statement)
         return result.first()
 
-    async def yield_per(self, session, params=None):
+    async def yield_per(
+        self, session, params=None
+    ) -> typing.AsyncGenerator[list[ModelType], None]:
         relevant_params = params.copy() if params else DBQueryParams()
         relevant_params.pop("page", None)
         page_size = relevant_params.pop("page_size", 100)
-
         statement = await self.query.build_query(relevant_params)
         statement = statement.execution_options(stream_results=True)
         if isinstance(session, AsyncSession):
@@ -124,30 +158,36 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
 
     async def add(self, session, item, *, flush=True, commit=True, refresh=True):
         await smart_run(session.add, item)
-        if flush:
-            await smart_run(session.flush)
-        if commit:
-            await smart_run(session.commit)
+        async with AsyncTaskRunner():
+            if flush:
+                await smart_run(session.flush)
+        async with AsyncTaskRunner():
+            if commit:
+                await smart_run(session.commit)
         if (flush or commit) and refresh:
             await smart_run(session.refresh, item)
         return item
 
     async def edit(self, session, item, *, flush=True, commit=True, refresh=False):
-        result: Model = await smart_run(session.merge, item)
-        if flush:
-            await smart_run(session.flush)
-        if commit:
-            await smart_run(session.commit)
+        result: ModelType = await smart_run(session.merge, item)
+        async with AsyncTaskRunner():
+            if flush:
+                await smart_run(session.flush)
+        async with AsyncTaskRunner():
+            if commit:
+                await smart_run(session.commit)
         if (flush or commit) and refresh:
             await smart_run(session.refresh, result)
         return result
 
     async def delete(self, session, item, *, flush=True, commit=True):
         await smart_run(session.delete, item)
-        if flush:
-            await smart_run(session.flush)
-        if commit:
-            await smart_run(session.commit)
+        async with AsyncTaskRunner():
+            if flush:
+                await smart_run(session.flush)
+        async with AsyncTaskRunner():
+            if commit:
+                await smart_run(session.commit)
 
     """
     --------------------------------------------------------------------------------------------------------
@@ -173,17 +213,17 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
     def get_edit_column_list(self):
         return self.get_user_column_list()
 
-    def get_order_column_list(self, list_columns: List[str], *, depth=0, max_depth=-1):
+    def get_order_column_list(self, list_columns: list[str], *, depth=0, max_depth=-1):
         """
         Get all columns that can be used for ordering
 
         Args:
-            list_columns (List[str]): Columns to be used for ordering.
+            list_columns (list[str]): Columns to be used for ordering.
             depth (int, optional): Depth of the relation. Defaults to 0. Used for recursive calls.
             max_depth (int, optional): Maximum depth of the relation. When set to -1, it will be ignored. Defaults to -1.
 
         Returns:
-            List[str]: List of columns that can be used for ordering
+            list[str]: List of columns that can be used for ordering
         """
         unique_order_columns: set[str] = set()
         for col_name in list_columns:
@@ -215,7 +255,12 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
                     unique_order_columns.update(
                         [f"{col_name}.{sub_col}" for sub_col in sub_order_columns]
                     )
-            elif self.is_property(col_name) and not self.is_hybrid_property(col_name):
+            elif (
+                self.is_property(col_name)
+                and not self.is_hybrid_property(col_name)
+                or self.is_files(col_name)
+                or self.is_images(col_name)
+            ):
                 continue
 
             # Allow the column to be used for ordering by default
@@ -312,12 +357,13 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
                 ),
             ]
         elif self.is_file(col) or self.is_image(col):
-            return (
-                fastapi.UploadFile
-                | typing.Annotated[
-                    str | None, BeforeValidator(lambda x: None if x == "null" else x)
-                ]
-            )
+            value_type = fastapi.UploadFile
+            annotated_str_type = typing.Annotated[
+                str | None, BeforeValidator(lambda x: None if x == "null" else x)
+            ]
+            if self.is_files(col) or self.is_images(col):
+                value_type = list[value_type | annotated_str_type]
+            return value_type | annotated_str_type
         elif self.is_date(col):
             return date
         elif self.is_datetime(col):
@@ -450,6 +496,22 @@ class SQLAInterface(AbstractInterface[Model, Session | AsyncSession, Column]):
         except KeyError:
             return False
 
+    def is_images(self, col_name):
+        try:
+            return is_sqla_type(
+                self.list_columns[col_name].type, ImageColumns
+            ) or is_sqla_type(self.list_columns[col_name].type, JSONBImageColumns)
+        except KeyError:
+            return False
+
+    def is_files(self, col_name):
+        try:
+            return is_sqla_type(
+                self.list_columns[col_name].type, FileColumns
+            ) or is_sqla_type(self.list_columns[col_name].type, JSONBFileColumns)
+        except KeyError:
+            return False
+
     def is_image(self, col_name):
         try:
             return is_sqla_type(self.list_columns[col_name].type, ImageColumn)

fastapi_rtk/backends/sqla/model.py

@@ -1,9 +1,8 @@
-import asyncio
 import collections
 import re
-from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Callable, Collection, Dict, Sequence, Set, Tuple
 
+import sqlalchemy.ext.asyncio
 from sqlalchemy import Connection, Engine, MetaData
 from sqlalchemy import Table as SA_Table
 from sqlalchemy.ext.declarative import declared_attr
@@ -12,6 +11,9 @@ from sqlalchemy.sql.schema import SchemaConst, SchemaItem
 from sqlalchemy.util.typing import Literal
 
 from ...bases.model import BasicModel
+from ...const import DEFAULT_METADATA_KEY
+from ...exceptions import FastAPIReactToolkitException
+from ...utils import AsyncTaskRunner, smart_run_sync
 
 __all__ = ["Model", "metadata", "metadatas", "Base"]
 
@@ -31,13 +33,13 @@ def camel_to_snake_case(name):
 
 
 metadatas: dict[str, MetaData] = {
-    "default": MetaData(),
+    DEFAULT_METADATA_KEY: MetaData(),
 }
 
 cache_id_property: dict[str, list[str]] = {}
 
 
-class Model(BasicModel, DeclarativeBase):
+class Model(sqlalchemy.ext.asyncio.AsyncAttrs, BasicModel, DeclarativeBase):
     """
     Use this class has the base for your models,
     it will define your table names automatically
@@ -61,17 +63,21 @@ class Model(BasicModel, DeclarativeBase):
     The bind key to use for this model. This allow you to use multiple databases. None means the default database. Default is None.
     """
 
-    metadata = metadatas["default"]
+    metadata = metadatas[DEFAULT_METADATA_KEY]
 
     def __init_subclass__(cls, **kw: Any) -> None:
         # Set the bind key from the metadata __table__ if it exists
         if hasattr(cls, "__table__"):
             for key, metadata in metadatas.items():
-                if metadata is cls.__table__.metadata and key != "default":
+                if metadata is cls.__table__.metadata and key != DEFAULT_METADATA_KEY:
                     cls.__bind_key__ = key
 
         # Overwrite the metadata if the bind key is set
         if cls.__bind_key__:
+            if cls.__bind_key__ == DEFAULT_METADATA_KEY:
+                raise FastAPIReactToolkitException(
+                    f"__bind_key__ cannot be '{DEFAULT_METADATA_KEY}', use None instead"
+                )
             if cls.__bind_key__ not in metadatas:
                 metadatas[cls.__bind_key__] = MetaData()
             cls.metadata = metadatas[cls.__bind_key__]
@@ -119,6 +125,21 @@ class Model(BasicModel, DeclarativeBase):
     def get_pk_attrs(cls):
         return [col.name for col in cls.__mapper__.primary_key]
 
+    async def load(self, *cols: list[str] | str):
+        """
+        Asynchronously loads the specified columns of the model instance.
+
+        Args:
+            *cols (list[str] | str): The columns to load. Can be a list of strings or individual string arguments.
+        """
+        cols = [
+            item for col in cols for item in (col if isinstance(col, list) else [col])
+        ]
+
+        async with AsyncTaskRunner() as runner:
+            for col in cols:
+                runner.add_task(getattr(self.awaitable_attrs, col))
+
 
 class Table(SA_Table):
     """
@@ -160,39 +181,35 @@ class Table(SA_Table):
             else:
                 db.init_db(autoload_with.engine.url)
 
-        with ThreadPoolExecutor() as executor:
-            future = executor.submit(
-                asyncio.run,
-                db.autoload_table(
-                    lambda conn: SA_Table.__init__(
-                        self,
-                        name,
-                        metadata,
-                        *args,
-                        schema=schema,
-                        quote=quote,
-                        quote_schema=quote_schema,
-                        autoload_with=conn,
-                        autoload_replace=autoload_replace,
-                        keep_existing=keep_existing,
-                        extend_existing=extend_existing,
-                        resolve_fks=resolve_fks,
-                        include_columns=include_columns,
-                        implicit_returning=implicit_returning,
-                        comment=comment,
-                        info=info,
-                        listeners=listeners,
-                        prefixes=prefixes,
-                        _extend_on=_extend_on,
-                        _no_init=_no_init,
-                        **kw,
-                    )
-                ),
-            )
-            future.result()
-
-
-metadata = metadatas["default"]
+        smart_run_sync(
+            db.autoload_table,
+            lambda conn: SA_Table.__init__(
+                self,
+                name,
+                metadata,
+                *args,
+                schema=schema,
+                quote=quote,
+                quote_schema=quote_schema,
+                autoload_with=conn,
+                autoload_replace=autoload_replace,
+                keep_existing=keep_existing,
+                extend_existing=extend_existing,
+                resolve_fks=resolve_fks,
+                include_columns=include_columns,
+                implicit_returning=implicit_returning,
+                comment=comment,
+                info=info,
+                listeners=listeners,
+                prefixes=prefixes,
+                _extend_on=_extend_on,
+                _no_init=_no_init,
+                **kw,
+            ),
+        )
+
+
+metadata = metadatas[DEFAULT_METADATA_KEY]
 
 
 """