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

fastapi_rtk/auth/auth.py

@@ -142,15 +142,6 @@ class Authenticator(BaseAuthenticator):
         except HTTPException as e:
             if not default_to_none:
                 raise e
-
-        # Retrieve list of apis, that user has access to
-        if user:
-            user.permissions = []
-            for role in user.roles:
-                for permission_api in role.permissions:
-                    user.permissions.append(permission_api.api.name)
-            user.permissions = list(set(user.permissions))
-
         return user, token
 
 

fastapi_rtk/backends/generic/__init__.py

@@ -8,6 +8,10 @@ from .session import *
 
 __all__ = [
     # .column
+    "GenericPKAutoIncrement",
+    "GenericUnset",
+    "PK_AUTO_INCREMENT",
+    "UNSET",
     "GenericColumn",
     # .db
     "GenericQueryBuilder",
@@ -36,10 +40,12 @@ __all__ = [
     "GenericFilterSmallerEqual",
     "GenericFilterIn",
     "GenericFilterGlobal",
+    "GenericBaseOprFilter",
     "GenericFilterConverter",
     # .interface
     "GenericInterface",
     # .model
+    "GenericMapper",
     "GenericModel",
     # .session
     "GenericSession",

fastapi_rtk/backends/generic/column.py

@@ -9,31 +9,38 @@ from pydantic import (
     create_model,
 )
 
+from ...mixins import LoggerMixin
 from ...utils import T
 from .exceptions import ColumnInvalidTypeException, GenericColumnException
 
 if typing.TYPE_CHECKING:
     from .model import GenericModel
 
-__all__ = ["GenericColumn"]
+__all__ = [
+    "GenericPKAutoIncrement",
+    "GenericUnset",
+    "PK_AUTO_INCREMENT",
+    "UNSET",
+    "GenericColumn",
+]
 
 
-class _CapitalClass:
+class GenericCapitalClass:
     def __repr__(self) -> str:
-        return self.__class__.__name__.lstrip("_").upper()
+        return self.__class__.__name__.upper()
 
 
-class _PKAutoIncrement(_CapitalClass): ...
+class GenericPKAutoIncrement(GenericCapitalClass): ...
 
 
-class _Unset(_CapitalClass): ...
+class GenericUnset(GenericCapitalClass): ...
 
 
-PK_AUTO_INCREMENT = _PKAutoIncrement()
-UNSET = _Unset()
+PK_AUTO_INCREMENT = GenericPKAutoIncrement()
+UNSET = GenericUnset()
 
 
-class GenericColumn(typing.Generic[T]):
+class GenericColumn(typing.Generic[T], LoggerMixin):
     """
     A generic column for `GenericModel`. This works similar to a SQLAlchemy column.
 
@@ -51,7 +58,7 @@ class GenericColumn(typing.Generic[T]):
     auto_increment: bool
     unique: bool
     nullable: bool
-    default: T | typing.Callable[["GenericModel"], T] | _Unset
+    default: T | typing.Callable[["GenericModel"], T] | GenericUnset
 
     _validation_model: BaseModel = None
     _col_name: str = None
@@ -67,7 +74,7 @@ class GenericColumn(typing.Generic[T]):
         default: T
         | typing.Callable[[], T]
         | typing.Callable[["GenericModel"], T]
-        | _Unset = UNSET,
+        | GenericUnset = UNSET,
     ):
         """
         Initializes a GenericColumn instance.
@@ -133,7 +140,9 @@ class GenericColumn(typing.Generic[T]):
         if callable(default_value):
             default_value = default_value(instance)
 
-        value: T | _Unset = instance.__dict__.get(f"_{self._col_name}", default_value)
+        value: T | GenericUnset = instance.__dict__.get(
+            f"_{self._col_name}", default_value
+        )
 
         if value is default_value:
             if self.nullable and value is UNSET:
@@ -143,7 +152,7 @@ class GenericColumn(typing.Generic[T]):
 
         return value
 
-    def __set__(self, instance: "GenericModel", value: T | _Unset) -> None:
+    def __set__(self, instance: "GenericModel", value: T | GenericUnset) -> None:
         try:
             validated = self._validation_model.model_validate({self._col_name: value})
         except ValidationError as e:

fastapi_rtk/backends/generic/db.py

@@ -1,9 +1,12 @@
 import typing
 
-from fastapi import HTTPException
+import fastapi
 
 from ...bases.db import AbstractQueryBuilder
+from ...exceptions import HTTPWithValidationException
+from ...lang import translate
 from ...utils import lazy
+from .filters import GenericBaseOprFilter
 from .session import GenericSession
 
 if typing.TYPE_CHECKING:
@@ -55,18 +58,50 @@ class GenericQueryBuilder(AbstractQueryBuilder[GenericSession]):
                 filter_class = f
                 break
         if not filter_class:
-            raise HTTPException(
-                status_code=400, detail=f"Invalid filter opr: {filter.opr}"
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_400_BAD_REQUEST,
+                "invalid_key",
+                "query",
+                "filters",
+                translate("Invalid filter operator: {operator}", operator=filter.opr),
+                filter.model_dump(mode="json"),
             )
 
-        col = filter.col
-        value = filter.value
-
-        return self.apply_filter_class(statement, col, filter_class, value)
+        return self.apply_filter_class(
+            statement, filter.col, filter_class, filter.value
+        )
 
     def apply_filter_class(self, statement, col, filter_class, value):
         return filter_class.apply(statement, col, value)
 
+    def apply_opr_filter(self, statement, filter):
+        filter_class = None
+        for f in self.datamodel.opr_filters:
+            if f.arg_name == filter.opr:
+                filter_class = f
+                break
+        if not filter_class:
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_400_BAD_REQUEST,
+                "invalid_key",
+                "query",
+                "opr_filters",
+                translate(
+                    "Invalid opr_filter operator: {operator}", operator=filter.opr
+                ),
+                filter.model_dump(mode="json"),
+            )
+
+        return self.apply_opr_filter_class(statement, filter_class, filter.value)
+
+    def apply_opr_filter_class(self, statement, filter_class, value):
+        params = [statement]
+        if isinstance(filter_class, GenericBaseOprFilter):
+            params.append(value)
+        else:
+            params.extend([None, value])
+        return filter_class.apply(statement, *params)
+
     def apply_global_filter(self, statement, columns, global_filter):
         return self.apply_filter_class(
             statement,

fastapi_rtk/backends/generic/filters.py

@@ -2,8 +2,9 @@ import enum
 import typing
 from datetime import date, datetime
 
-from ...bases.filter import AbstractBaseFilter
+from ...bases.filter import AbstractBaseFilter, AbstractBaseOprFilter
 from ...const import logger
+from ...lang import lazy_text
 from .session import GenericSession
 
 if typing.TYPE_CHECKING:
@@ -27,6 +28,7 @@ __all__ = [
     "GenericFilterSmallerEqual",
     "GenericFilterIn",
     "GenericFilterGlobal",
+    "GenericBaseOprFilter",
     "GenericFilterConverter",
 ]
 
@@ -76,7 +78,7 @@ class GenericBaseFilter(AbstractBaseFilter[GenericSession]):
 
 
 class GenericFilterTextContains(GenericBaseFilter):
-    name = "Text contains"
+    name = lazy_text("Text contains")
     arg_name = "tc"
 
     def apply(self, statement, col, value):
@@ -84,7 +86,7 @@ class GenericFilterTextContains(GenericBaseFilter):
 
 
 class GenericFilterEqual(GenericBaseFilter):
-    name = "Equal to"
+    name = lazy_text("Equal to")
     arg_name = "eq"
 
     def apply(
@@ -112,7 +114,7 @@ class GenericFilterNotEqual(GenericBaseFilter):
 
 
 class GenericFilterStartsWith(GenericBaseFilter):
-    name = "Starts with"
+    name = lazy_text("Starts with")
     arg_name = "sw"
 
     def apply(self, statement, col: str, value):
@@ -121,7 +123,7 @@ class GenericFilterStartsWith(GenericBaseFilter):
 
 
 class GenericFilterNotStartsWith(GenericBaseFilter):
-    name = "Not Starts with"
+    name = lazy_text("Not Starts with")
     arg_name = "nsw"
 
     def apply(self, statement, col: str, value):
@@ -130,7 +132,7 @@ class GenericFilterNotStartsWith(GenericBaseFilter):
 
 
 class GenericFilterEndsWith(GenericBaseFilter):
-    name = "Ends with"
+    name = lazy_text("Ends with")
     arg_name = "ew"
 
     def apply(self, statement, col: str, value):
@@ -139,7 +141,7 @@ class GenericFilterEndsWith(GenericBaseFilter):
 
 
 class GenericFilterNotEndsWith(GenericBaseFilter):
-    name = "Not Ends with"
+    name = lazy_text("Not Ends with")
     arg_name = "new"
 
     def apply(self, statement, col: str, value):
@@ -148,7 +150,7 @@ class GenericFilterNotEndsWith(GenericBaseFilter):
 
 
 class GenericFilterContains(GenericBaseFilter):
-    name = "Contains"
+    name = lazy_text("Contains")
     arg_name = "ct"
 
     def apply(self, statement, col: str, value):
@@ -157,7 +159,7 @@ class GenericFilterContains(GenericBaseFilter):
 
 
 class GenericFilterIContains(GenericBaseFilter):
-    name = "Contains (insensitive)"
+    name = lazy_text("Contains (insensitive)")
     arg_name = "ict"
 
     def apply(self, statement, col: str, value):
@@ -166,7 +168,7 @@ class GenericFilterIContains(GenericBaseFilter):
 
 
 class GenericFilterNotContains(GenericBaseFilter):
-    name = "Not Contains"
+    name = lazy_text("Not Contains")
     arg_name = "nct"
 
     def apply(self, statement, col: str, value):
@@ -175,7 +177,7 @@ class GenericFilterNotContains(GenericBaseFilter):
 
 
 class GenericFilterGreater(GenericBaseFilter):
-    name = "Greater than"
+    name = lazy_text("Greater than")
     arg_name = "gt"
 
     def apply(self, statement, col: str, value: int | date | datetime):
@@ -184,7 +186,7 @@ class GenericFilterGreater(GenericBaseFilter):
 
 
 class GenericFilterSmaller(GenericBaseFilter):
-    name = "Smaller than"
+    name = lazy_text("Smaller than")
     arg_name = "lt"
 
     def apply(self, statement, col: str, value: int | date | datetime):
@@ -193,7 +195,7 @@ class GenericFilterSmaller(GenericBaseFilter):
 
 
 class GenericFilterGreaterEqual(GenericBaseFilter):
-    name = "Greater equal"
+    name = lazy_text("Greater equal")
     arg_name = "ge"
 
     def apply(self, statement, col: str, value: int | date | datetime):
@@ -202,7 +204,7 @@ class GenericFilterGreaterEqual(GenericBaseFilter):
 
 
 class GenericFilterSmallerEqual(GenericBaseFilter):
-    name = "Smaller equal"
+    name = lazy_text("Smaller equal")
     arg_name = "le"
 
     def apply(self, statement, col: str, value: int | date | datetime):
@@ -211,7 +213,7 @@ class GenericFilterSmallerEqual(GenericBaseFilter):
 
 
 class GenericFilterIn(GenericBaseFilter):
-    name = "One of"
+    name = lazy_text("One of")
     arg_name = "in"
 
     def apply(self, statement, col: str, value: list[str | bool | int]):
@@ -220,7 +222,7 @@ class GenericFilterIn(GenericBaseFilter):
 
 
 class GenericFilterGlobal(GenericBaseFilter):
-    name = "Global Filter"
+    name = lazy_text("Global Filter")
     arg_name = "global"
 
     def apply(self, statement, col: str, value: str):
@@ -228,6 +230,9 @@ class GenericFilterGlobal(GenericBaseFilter):
         return statement.global_filter(col, value)
 
 
+class GenericBaseOprFilter(AbstractBaseOprFilter, GenericBaseFilter): ...
+
+
 class GenericFilterConverter:
     """
     Helper class to get available filters for a generic column type.

fastapi_rtk/backends/generic/interface.py

@@ -15,11 +15,15 @@ from .session import GenericSession
 
 __all__ = ["GenericInterface"]
 
+GenericModelType = typing.TypeVar("GenericModelType", bound=GenericModel)
+
 
 class lazy(lazy_self["GenericInterface", T]): ...
 
 
-class GenericInterface(AbstractInterface[GenericModel, GenericSession, GenericColumn]):
+class GenericInterface(
+    AbstractInterface[GenericModelType, GenericSession, GenericColumn]
+):
     """
     Represents an interface for a Generic model (Based on pydantic).
     """
@@ -33,7 +37,7 @@ class GenericInterface(AbstractInterface[GenericModel, GenericSession, GenericCo
     query_count = lazy(lambda self: GenericQueryBuilder(self, self.session))
 
     def __init__(
-        self, obj: typing.Type[GenericModel], session: typing.Type[GenericSession]
+        self, obj: typing.Type[GenericModelType], session: typing.Type[GenericSession]
     ):
         super().__init__(obj)
         if not isinstance(session, type):
@@ -62,23 +66,23 @@ class GenericInterface(AbstractInterface[GenericModel, GenericSession, GenericCo
         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)
         return statement.count()
 
-    async def get_many(self, session, params=None):
+    async def get_many(self, session, params=None) -> list[GenericModelType]:
         statement = await self.query.build_query(params)
         return statement.all()
 
-    async def get_one(self, session, params=None):
+    async def get_one(self, session, params=None) -> GenericModelType | None:
         statement = await self.query.build_query(params)
         return statement.first()
 
-    async def yield_per(self, session, params=None):
+    async def yield_per(
+        self, session, params=None
+    ) -> typing.AsyncGenerator[list[GenericModelType], 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)
         items = statement.yield_per(page_size)
         while True:
@@ -98,7 +102,9 @@ class GenericInterface(AbstractInterface[GenericModel, GenericSession, GenericCo
             session.refresh(item)
         return item
 
-    async def edit(self, session, item, *, flush=True, commit=True, refresh=False):
+    async def edit(
+        self, session, item, *, flush=True, commit=True, refresh=False
+    ) -> GenericModelType:
         result = session.merge(item)
         if flush:
             session.flush()

fastapi_rtk/backends/generic/model.py

@@ -2,7 +2,7 @@ import typing
 
 from ...bases.model import BasicModel
 from ...utils import T, lazy
-from .column import UNSET, GenericColumn, _PKAutoIncrement
+from .column import UNSET, GenericColumn, GenericPKAutoIncrement
 from .exceptions import (
     ColumnNotSetException,
     MultipleColumnsException,
@@ -13,10 +13,10 @@ from .exceptions import (
 if typing.TYPE_CHECKING:
     from .session import Table
 
-__all__ = ["GenericModel"]
+__all__ = ["GenericMapper", "GenericModel"]
 
 
-class Mapper(typing.Generic[T]):
+class GenericMapper(typing.Generic[T]):
     """
     Mapper class that contains a model's definitions.
     """
@@ -46,8 +46,8 @@ class GenericModel(BasicModel):
     GenericModel is a base class for all models that does not use SQLAlchemy, but want to behave like one.
     """
 
-    __mapper__: Mapper[GenericColumn] = lazy(
-        lambda: Mapper[GenericColumn](), only_instance=False
+    __mapper__: GenericMapper[GenericColumn] = lazy(
+        lambda: GenericMapper[GenericColumn](), only_instance=False
     )
     """
     A mapper that contains the primary key, properties, and columns of the model.
@@ -92,21 +92,28 @@ class GenericModel(BasicModel):
         if not cls.__mapper__.pk:
             raise PKMissingException(cls.__name__, "Primary key is missing")
 
-    def __init__(self, **kwargs):
+    def __init__(self, *, __check_on_init__=True, **kwargs):
+        """
+        Initialize the model with the given keyword arguments.
+
+        Args:
+            __check_on_init__ (bool, optional): Whether to check the model's validity on initialization. Defaults to True.
+        """
         if not kwargs:
             return
         for key, value in kwargs.items():
             if key not in self.__mapper__.properties.keys():
                 continue
             setattr(self, key, value)
-        self.is_model_valid()
+        if __check_on_init__:
+            self.is_model_valid()
 
-    def get_pk(self) -> str | int | _PKAutoIncrement:
+    def get_pk(self) -> str | int | GenericPKAutoIncrement:
         """
         Get the primary key of the model.
 
         Returns:
-            str | int | _PKAutoIncrement: The primary key of the model.
+            str | int | GenericPKAutoIncrement: The primary key of the model.
         """
         return getattr(self, self.__mapper__.pk)
 
@@ -122,11 +129,12 @@ class GenericModel(BasicModel):
     def get_col_type(self, col_name: str):
         return self.__mapper__.properties[col_name].col_type
 
-    def update(self, data):
+    def update(self, data, *, check=True):
         super().update(data)
 
         # Check if the model is valid
-        self.is_model_valid()
+        if check:
+            self.is_model_valid()
 
     def is_model_valid(self):
         """

fastapi_rtk/backends/sqla/__init__.py

@@ -60,6 +60,7 @@ __all__ = [
     "FilterRelationOneToManyOrManyToManyIn",
     "FilterRelationOneToManyOrManyToManyNotIn",
     "FilterGlobal",
+    "BaseOprFilter",
     "SQLAFilterConverter",
     # .interface
     "SQLAInterface",