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

fastapi_rtk/bases/__init__.py

@@ -0,0 +1,20 @@
+from .db import *
+from .file_manager import *
+from .filter import *
+from .interface import *
+from .model import *
+from .session import *
+
+__all__ = [
+    "DBQueryParams",
+    "AbstractQueryBuilder",
+    "FileNotAllowedException",
+    "AbstractFileManager",
+    "AbstractImageManager",
+    "AbstractBaseFilter",
+    "AbstractBaseOprFilter",
+    "PydanticGenerationSchema",
+    "AbstractInterface",
+    "BasicModel",
+    "AbstractSession",
+]

fastapi_rtk/bases/db.py

@@ -4,13 +4,17 @@ import typing
 import fastapi
 
 from ..const import logger
-from ..schemas import PRIMARY_KEY, FilterSchema
+from ..exceptions import HTTPWithValidationException
+from ..lang import translate
+from ..schemas import PRIMARY_KEY, FilterSchema, OprFilterSchema
 from ..utils import T, safe_call, use_default_when_none
-from .filter import AbstractBaseFilter
+from .filter import AbstractBaseFilter, AbstractBaseOprFilter
 
 if typing.TYPE_CHECKING:
     from .interface import AbstractInterface
 
+__all__ = ["DBQueryParams", "AbstractQueryBuilder"]
+
 BUILD_STEPS = typing.Literal[
     "list_columns",
     "page|page_size",
@@ -21,6 +25,8 @@ BUILD_STEPS = typing.Literal[
     "where_id_in",
     "filters",
     "filter_classes",
+    "opr_filters",
+    "opr_filter_classes",
     "global_filter",
 ]
 DEFAULT_ORDER = [
@@ -33,6 +39,8 @@ DEFAULT_ORDER = [
     "where_id_in",
     "filters",
     "filter_classes",
+    "opr_filters",
+    "opr_filter_classes",
     "global_filter",
 ]
 
@@ -47,8 +55,16 @@ class DBQueryParams(typing.TypedDict):
     where_in: tuple[str, list[typing.Any]] | None
     where_id: PRIMARY_KEY | None
     where_id_in: list[PRIMARY_KEY] | None
-    filters: list[FilterSchema] | None
+    filters: (
+        list[FilterSchema | dict[str, typing.Any] | tuple[str, str, typing.Any] | list]
+        | None
+    )
     filter_classes: list[tuple[str, AbstractBaseFilter, typing.Any]] | None
+    opr_filters: (
+        list[OprFilterSchema | dict[str, typing.Any] | tuple[str, typing.Any] | list]
+        | None
+    )
+    opr_filter_classes: list[tuple[AbstractBaseFilter, typing.Any]] | None
     global_filter: tuple[list[str], str] | None
 
 
@@ -172,12 +188,34 @@ class AbstractQueryBuilder(abc.ABC, typing.Generic[T]):
                 )
             elif step == "filters" and params.get("filters"):
                 for filter in params["filters"]:
+                    if isinstance(filter, dict):
+                        filter = FilterSchema(**filter)
+                    elif isinstance(filter, (list, tuple)):
+                        filter = FilterSchema(
+                            col=filter[0], opr=filter[1], value=filter[2]
+                        )
                     statement = await safe_call(self.apply_filter(statement, filter))
             elif step == "filter_classes" and params.get("filter_classes"):
                 for filter_class in params["filter_classes"]:
                     statement = await safe_call(
                         self.apply_filter_class(statement, *filter_class)
                     )
+            elif step == "opr_filters" and params.get("opr_filters"):
+                for opr_filter in params["opr_filters"]:
+                    if isinstance(opr_filter, dict):
+                        opr_filter = OprFilterSchema(**opr_filter)
+                    elif isinstance(opr_filter, (list, tuple)):
+                        opr_filter = OprFilterSchema(
+                            opr=opr_filter[0], value=opr_filter[1]
+                        )
+                    statement = await safe_call(
+                        self.apply_opr_filter(statement, opr_filter)
+                    )
+            elif step == "opr_filter_classes" and params.get("opr_filter_classes"):
+                for opr_filter_class in params["opr_filter_classes"]:
+                    statement = await safe_call(
+                        self.apply_opr_filter_class(statement, *opr_filter_class)
+                    )
             elif step == "global_filter" and params.get("global_filter"):
                 columns, global_filter = params["global_filter"]
                 statement = await safe_call(
@@ -310,6 +348,40 @@ class AbstractQueryBuilder(abc.ABC, typing.Generic[T]):
         """
         raise NotImplementedError("This method should be implemented by subclasses.")
 
+    @abc.abstractmethod
+    async def apply_opr_filter(self, statement: T, filter: OprFilterSchema) -> T:
+        """
+        Handles the filtering of the query based on an OprFilterSchema.
+
+        Args:
+            statement (T): The SQLAlchemy query statement to modify.
+            filter (OprFilterSchema): The filter schema to apply without the column name.
+
+        Returns:
+            T: The modified SQLAlchemy query statement with the filter applied.
+        """
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+    @abc.abstractmethod
+    async def apply_opr_filter_class(
+        self,
+        statement: T,
+        filter_class: AbstractBaseOprFilter[T] | AbstractBaseFilter[T],
+        value,
+    ) -> T:
+        """
+        Handles the filtering of the query using an operation filter class without a column name.
+
+        Args:
+            statement (T): The SQLAlchemy query statement to modify.
+            filter_class (AbstractBaseFilter[T]): The filter class to apply.
+            value: The value to filter by.
+
+        Returns:
+            T: The modified SQLAlchemy query statement with the operation filter class applied.
+        """
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
     @abc.abstractmethod
     async def apply_global_filter(
         self, statement: T, columns: list[str], global_filter: str
@@ -398,14 +470,29 @@ class AbstractQueryBuilder(abc.ABC, typing.Generic[T]):
                 # Assume the ID is a string, split the string to ','
                 id = id.split(",") if isinstance(id, str) else id
                 if len(id) != len(self.datamodel.get_pk_attrs()):
-                    raise fastapi.HTTPException(
-                        status_code=400,
-                        detail=f"Invalid ID: {id}, expected {len(self.datamodel.get_pk_attrs())} values",
+                    raise HTTPWithValidationException(
+                        fastapi.status.HTTP_400_BAD_REQUEST,
+                        "greater_than"
+                        if len(id) < len(self.datamodel.get_pk_attrs())
+                        else "less_than",
+                        "path",
+                        "id",
+                        translate(
+                            "Invalid ID: {id}, expected {count} values",
+                            id=id,
+                            count=len(self.datamodel.get_pk_attrs()),
+                        ),
                     )
                 for pk_key in self.datamodel.get_pk_attrs():
                     pk_dict[pk_key] = id.pop(0)
             except Exception:
-                raise fastapi.HTTPException(status_code=400, detail="Invalid ID")
+                raise HTTPWithValidationException(
+                    fastapi.status.HTTP_400_BAD_REQUEST,
+                    "string_type",
+                    "path",
+                    "id",
+                    translate("Invalid ID"),
+                )
         else:
             pk_dict[self.datamodel.get_pk_attr()] = id
 

fastapi_rtk/bases/file_manager.py

@@ -3,7 +3,19 @@ import typing
 
 import fastapi
 
-from ..utils import lazy, uuid_namegen
+from ..exceptions import FastAPIReactToolkitException
+from ..utils import hooks, lazy, uuid_namegen
+
+__all__ = ["FileNotAllowedException", "AbstractFileManager", "AbstractImageManager"]
+
+
+class FileNotAllowedException(FastAPIReactToolkitException):
+    """
+    Exception raised when a file is not allowed based on its extension.
+    """
+
+    def __init__(self, filename: str):
+        super().__init__(f"File '{filename}' is not allowed.")
 
 
 class AbstractFileManager(abc.ABC):
@@ -11,8 +23,8 @@ class AbstractFileManager(abc.ABC):
     Abstract base class for file managers.
     """
 
-    base_path = None
-    allowed_extensions = None
+    base_path: str = None
+    allowed_extensions: list[str] = None
     namegen = lazy(lambda: uuid_namegen)
     permission = lazy(lambda: 0o755)
 
@@ -23,6 +35,18 @@ class AbstractFileManager(abc.ABC):
         namegen: typing.Callable[[str], str] | None = None,
         permission: int | None = None,
     ):
+        """
+        Initializes the AbstractFileManager.
+
+        Args:
+            base_path (str | None, optional): Base path for file storage. Defaults to None.
+            allowed_extensions (list[str] | None, optional): Allowed file extensions. Defaults to None.
+            namegen (typing.Callable[[str], str] | None, optional): Callable for generating file names. Defaults to None.
+            permission (int | None, optional): File permission settings. Defaults to None.
+
+        Raises:
+            ValueError: If `base_path` is not set.
+        """
         if base_path is not None:
             self.base_path = base_path
         if allowed_extensions is not None:
@@ -40,6 +64,26 @@ class AbstractFileManager(abc.ABC):
         # Ensure base_path does not end with a slash
         self.base_path = self.base_path.rstrip("/")
 
+    def __init_subclass__(cls):
+        # Add pre-hook to save_file and save_content_to_file to check if the file is allowed
+        def check_is_file_allowed(self, *args, **kwargs):
+            filename = None
+            if "filename" in kwargs:
+                filename = kwargs["filename"]
+            elif len(args) > 1:
+                filename = args[1]
+            if filename and not self.is_filename_allowed(filename):
+                raise FileNotAllowedException(filename)
+
+        if cls.save_file is not AbstractFileManager.save_file:
+            wrapped_save_file = hooks(pre=check_is_file_allowed)(cls.save_file)
+            cls.save_file = wrapped_save_file
+        if cls.save_content_to_file is not AbstractFileManager.save_content_to_file:
+            wrapped_save_content_to_file = hooks(pre=check_is_file_allowed)(
+                cls.save_content_to_file
+            )
+            cls.save_content_to_file = wrapped_save_content_to_file
+
     """
     --------------------------------------------------------------------------------------------------------
         CRUD METHODS - to be implemented

fastapi_rtk/bases/filter.py

@@ -6,6 +6,8 @@ from ..utils import T
 if typing.TYPE_CHECKING:
     from .interface import AbstractInterface
 
+__all__ = ["AbstractBaseFilter", "AbstractBaseOprFilter"]
+
 
 class AbstractBaseFilter(abc.ABC, typing.Generic[T]):
     """
@@ -41,3 +43,23 @@ class AbstractBaseFilter(abc.ABC, typing.Generic[T]):
             T: The modified SQLAlchemy query statement.
         """
         raise NotImplementedError("Subclasses must implement this method.")
+
+
+class AbstractBaseOprFilter(AbstractBaseFilter[T]):
+    """
+    Abstract base class to apply filters to select statements without a column name.
+    """
+
+    @abc.abstractmethod
+    def apply(self, statement: T, value) -> T:
+        """
+        Apply the filter to the given SQLAlchemy Select statement.
+
+        Args:
+            statement (T): The SQLAlchemy query statement to modify.
+            value: The value to filter the column by.
+
+        Returns:
+            T: The modified SQLAlchemy query statement.
+        """
+        raise NotImplementedError("Subclasses must implement this method.")

fastapi_rtk/bases/interface.py

@@ -12,7 +12,8 @@ from ..globals import g
 from ..schemas import PRIMARY_KEY, ColumnEnumInfo, ColumnInfo, ColumnRelationInfo
 from ..utils import AsyncTaskRunner, C, T, deep_merge, lazy_self, smart_run
 from .db import DBQueryParams
-from .filter import AbstractBaseFilter
+from .file_manager import AbstractFileManager, AbstractImageManager
+from .filter import AbstractBaseFilter, AbstractBaseOprFilter
 
 CT = typing.TypeVar("CT")
 
@@ -23,6 +24,8 @@ if typing.TYPE_CHECKING:
 
     filter_converter_type = SQLAFilterConverter
 
+__all__ = ["PydanticGenerationSchema", "AbstractInterface"]
+
 
 class PydanticGenerationSchema(typing.TypedDict):
     """
@@ -80,6 +83,22 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
     """
     Filter class to be used for global filtering.
     """
+    file_manager = lazy(
+        lambda: raise_exception(
+            "file_manager must be set in the subclass", AbstractFileManager
+        )
+    )
+    """
+    The file manager instance for the datamodel.
+    """
+    image_manager = lazy(
+        lambda: raise_exception(
+            "image_manager must be set in the subclass", AbstractImageManager
+        )
+    )
+    """
+    The image manager instance for the datamodel.
+    """
 
     id_schema = lazy(lambda self: self.init_id_schema())
     """
@@ -113,6 +132,10 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
 
     Automatically filled by `ModelRestApi`.
     """
+    opr_filters = lazy(lambda: list[AbstractBaseOprFilter | AbstractBaseFilter]())
+    """
+    A list of filters to apply to the model when filtering without a specific column.
+    """
 
     _cache_schema: dict[str, typing.Type[pydantic.BaseModel]] = {}
 
@@ -480,6 +503,12 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
     def is_unique(self, col_name: str) -> bool:
         return False
 
+    def is_images(self, col_name: str) -> bool:
+        return False
+
+    def is_files(self, col_name: str) -> bool:
+        return False
+
     def is_image(self, col_name: str) -> bool:
         return False
 
@@ -848,6 +877,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
         optional=False,
         name="",
         hide_sensitive_columns=True,
+        is_form_data=False,
         related_kwargs: dict[str, typing.Any] | None = None,
     ):
         """
@@ -860,7 +890,8 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
             with_property (bool, optional): Whether to include @property columns. Defaults to True.
             optional (bool, optional): Whether the columns should be optional. Defaults to False.
             name (str, optional): The name of the schema. If not specified, the name is generated based on the object's name and the specified options. Defaults to ''.
-            hide_sensitive_columns (bool, optional): Whether to hide sensitive columns such as `password`. Defaults to True.
+            hide_sensitive_columns (bool, optional): Whether to hide sensitive columns such as `password`. The sensitive columns are retrieved from `g.sensitive_data`. Defaults to True.
+            is_form_data (bool, optional): Whether the schema is for form data. Defaults to False.
             related_kwargs (dict[str, typing.Any] | None, optional): Additional keyword arguments for schema generation of the related models. The options are the same as this function with `with_fk`. Defaults to None.
 
         Returns:
@@ -887,6 +918,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
                 optional=optional,
                 name=name,
                 hide_sensitive_columns=hide_sensitive_columns,
+                is_form_data=is_form_data,
                 related_kwargs=related_kwargs,
             )
         )
@@ -922,7 +954,8 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
                 return self
 
             decorated_func = pydantic.model_validator(mode="after")(fill_columns)
-            schema_dict["__validators__"] = {fill_columns.__name__: decorated_func}
+            schema_dict["__validators__"] = schema_dict.get("__validators__", {})
+            schema_dict["__validators__"][fill_columns.__name__] = decorated_func
 
         if self.is_pk_composite():
             self.id_schema = str
@@ -963,6 +996,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
         optional: bool,
         name: str,
         hide_sensitive_columns: bool,
+        is_form_data: bool,
         related_kwargs: dict[str, typing.Any] | None = None,
     ):
         """
@@ -975,7 +1009,8 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
             with_property (bool): Whether to include @property columns.
             optional (bool): Whether the columns should be optional.
             name (str): The name of the schema. If not specified, the name is generated based on the object's name and the specified options.
-            hide_sensitive_columns (bool): Whether to hide sensitive columns such as `password`.
+            hide_sensitive_columns (bool): Whether to hide sensitive columns such as `password`. The sensitive columns are retrieved from `g.sensitive_data`.
+            is_form_data (bool): Whether the schema is for form data.
             related_kwargs (dict[str, typing.Any] | None, optional): Additional keyword arguments for schema generation of the related models. The options are the same as this function with `with_fk`. Defaults to None.
 
         Returns:
@@ -1071,6 +1106,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
                             hide_sensitive_columns=sub_hide_sensitive_columns,
                         ),
                         hide_sensitive_columns=sub_hide_sensitive_columns,
+                        is_form_data=is_form_data,
                         related_kwargs=related_kwargs,
                     ),
                 )
@@ -1095,6 +1131,14 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
                 if self.is_nullable(col) or optional:
                     params["default"] = None
                     type = type | None
+                    if is_form_data:
+                        type = (
+                            typing.Annotated[
+                                typing.Literal["null"],
+                                pydantic.AfterValidator(lambda _: None),
+                            ]
+                            | type
+                        )
                 # if self.get_max_length(col) != -1:
                 #     params["max_length"] = self.get_max_length(col)
                 current_schema[col] = (type, pydantic.Field(**params))
@@ -1120,7 +1164,7 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
             with_name (bool, optional): Whether to include the name_ column. Defaults to False.
             with_property (bool, optional): Whether to include @property columns. Defaults to False.
             optional (bool, optional): Whether the columns should be optional. Defaults to False.
-            hide_sensitive_columns (bool, optional): Whether to hide sensitive columns such as `password`. Defaults to True.
+            hide_sensitive_columns (bool, optional): Whether to hide sensitive columns such as `password`. The sensitive columns are retrieved from `g.sensitive_data`. Defaults to True.
 
         Returns:
             str: The generated name for the schema.

fastapi_rtk/bases/model.py

@@ -1,3 +1,6 @@
+__all__ = ["BasicModel"]
+
+
 class BasicModel:
     """
     A basic model class that provides a method to update the model instance with the given data.

fastapi_rtk/bases/session.py

@@ -1,5 +1,7 @@
 import abc
 
+__all__ = ["AbstractSession"]
+
 
 class AbstractSession(abc.ABC):
     """

fastapi_rtk/cli/cli.py

@@ -1,18 +1,14 @@
+import io
+import typing
+import zipfile
 from pathlib import Path
 from typing import Annotated, Union
 
+import httpx
 import typer
 
-from .commands import path_callback, version_callback
-from .db import db_app
-from .export import export_app
-from .security import security_app
-
 app = typer.Typer(rich_markup_mode="rich")
-
-app.add_typer(db_app, name="db")
-app.add_typer(security_app, name="security")
-app.add_typer(export_app, name="export")
+from .commands import path_callback, version_callback  # noqa: E402
 
 
 @app.callback()
@@ -38,5 +34,62 @@ def callback(
     """
 
 
+@app.command()
+def create_app(
+    directory: typing.Annotated[
+        str,
+        typer.Option(
+            ...,
+            help="The directory where the new FastAPI RTK application will be created.",
+        ),
+    ] = ".",
+):
+    """
+    Create a new FastAPI RTK application with a predefined structure from https://codeberg.org/datatactics/fastapi-rtk-skeleton.
+
+    This command sets up the necessary files and directories for a FastAPI RTK project,
+    allowing you to get started quickly with development.
+    """
+    with httpx.Client() as client:
+        url = "https://codeberg.org/datatactics/fastapi-rtk-skeleton/archive/main.zip"
+        response = client.get(url)
+        response.raise_for_status()
+
+        # Unzip the content into the specified directory
+        with zipfile.ZipFile(io.BytesIO(response.content)) as zip_ref:
+            # Get all members (files/folders) in the zip
+            members = zip_ref.namelist()
+
+            # Find the top-level directory name
+            top_level_dir = members[0].split("/")[0] + "/"
+
+            # Extract each file, stripping the top-level directory
+            for member in members:
+                # Skip the top-level directory itself
+                if member == top_level_dir:
+                    continue
+
+                # Get the path without the top-level directory
+                target_path = member[len(top_level_dir) :]
+
+                # Skip if empty (this was the root folder)
+                if not target_path:
+                    continue
+
+                # Get the source file
+                source = zip_ref.open(member)
+                target_file = Path(directory) / target_path
+
+                # Create directories if needed
+                if member.endswith("/"):
+                    target_file.mkdir(parents=True, exist_ok=True)
+                else:
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    with open(target_file, "wb") as f:
+                        f.write(source.read())
+
+            typer.echo(f"FastAPI RTK application skeleton created in {directory}")
+
+
 def main():
     app()

fastapi_rtk/cli/commands/__init__.py

@@ -0,0 +1,23 @@
+# Import every modules in this directory
+import importlib
+import pathlib
+import pkgutil
+
+import typer
+
+from ...globals import g
+from ...version import __version__
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print(f"FastAPI-RTK CLI version: [green]{__version__}[/green]")
+        raise typer.Exit()
+
+
+def path_callback(value: pathlib.Path | None) -> None:
+    g.path = value
+
+
+for loader, module_name, is_pkg in pkgutil.walk_packages(__path__):
+    importlib.import_module(f"{__name__}.{module_name}")