fastapi-crudrouter-v2 0.1.3__tar.gz

fastapi_crudrouter_v2-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Adam Watkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastapi_crudrouter_v2-0.1.3/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: fastapi-crudrouter-v2
+Version: 0.1.3
+Summary: A dynamic FastAPI router that automatically creates CRUD routes for your models
+License-File: LICENSE
+Author: pasha_danilevich
+Author-email: danilevitch.pasha@yandex.ru
+Requires-Python: >=3.9,<4.0
+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
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/awtkns/fastapi-crudrouter/master/docs/en/docs/assets/logo.png" height="200" />
+</p>
+<p align="center">
+  <em>⚡ Create CRUD routes with lighting speed</em> ⚡</br>
+  <sub>A dynamic FastAPI router that automatically creates CRUD routes for your models</sub>
+</p>
+<p align="center">
+<img alt="Tests" src="https://img.shields.io/github/actions/workflow/status/awtkns/fastapi-crudrouter/.github/workflows/pytest.yml?color=%2334D058" />
+<img alt="Downloads" src="https://img.shields.io/pypi/dm/fastapi-crudrouter?color=%2334D058" />
+  <a href="https://pypi.org/project/fastapi-crudrouter" target="_blank">
+    <img src="https://img.shields.io/pypi/v/fastapi-crudrouter?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+  <img alt="License" src="https://img.shields.io/github/license/awtkns/fastapi-crudrouter?color=%2334D058" />
+</p>
+<p align="center">
+<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/fastapi-crudrouter">
+</p>
+
+---
+
+**Documentation**: <a href="https://fastapi-crudrouter.awtkns.com" target="_blank">https://fastapi-crudrouter.awtkns.com</a>
+
+**Source Code**: <a href="https://github.com/awtkns/fastapi-crudrouter" target="_blank">https://github.com/awtkns/fastapi-crudrouter</a>
+
+---
+Tired of rewriting generic CRUD routes? Need to rapidly prototype a feature for a presentation
+or a hackathon? Thankfully, [fastapi-crudrouter](https://github.com/awtkns/fastapi-crudrouter) has your back. As an 
+extension to the APIRouter included with [FastAPI](https://fastapi.tiangolo.com/), the FastAPI CRUDRouter will automatically
+generate and document your CRUD routes for you, all you have to do is pass your model and maybe your database connection.
+
+FastAPI-CRUDRouter is **lighting fast**, well tested, and **production ready**.
+
+
+## Installation
+```bash
+pip install fastapi-crudrouter
+```
+
+## Basic Usage
+Below is a simple example of what the CRUDRouter can do. In just ten lines of code, you can generate all 
+the crud routes you need for any model. A full list of the routes generated can be found [here](https://fastapi-crudrouter.awtkns.com/routing).
+
+```python
+from pydantic import BaseModel
+from fastapi import FastAPI
+from fastapi_crudrouter import MemoryCRUDRouter as CRUDRouter
+
+class Potato(BaseModel):
+    id: int
+    color: str
+    mass: float
+
+app = FastAPI()
+app.include_router(CRUDRouter(schema=Potato))
+```
+
+## Advanced Usage
+fastapi-crudrouter provides a number of features that allow you to get the most out of your automatically generated CRUD
+routes. Listed below are some highlights.
+
+- Automatic Pagination ([docs](https://fastapi-crudrouter.awtkns.com/pagination/))
+- Ability to Provide Custom Create and Update Schemas ([docs](https://fastapi-crudrouter.awtkns.com/schemas/))
+- Dynamic Generation of Create and Update Schemas ([docs](https://fastapi-crudrouter.awtkns.com/schemas/))
+- Ability to Add, Customize, or Disable Specific Routes ([docs](https://fastapi-crudrouter.awtkns.com/routing/))
+- Native Support for FastAPI Dependency Injection ([docs](https://fastapi-crudrouter.awtkns.com/dependencies/))
+
+## Supported Backends / ORMs
+fastapi-crudrouter currently supports a number of backends / ORMs. Listed below are the backends currently supported. This list will
+likely grow in future releases.
+
+- In Memory ([docs](https://fastapi-crudrouter.awtkns.com/backends/memory/))
+- SQLAlchemy ([docs](https://fastapi-crudrouter.awtkns.com/backends/sqlalchemy/))
+- Databases (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/async/))
+- Gino (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/gino.html)) 
+- Ormar (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/ormar/))
+- Tortoise ORM  (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/tortoise/))
+
+## OpenAPI Support
+By default, all routes generated by the CRUDRouter will be documented according to OpenAPI spec.
+
+Below are the default routes created by the CRUDRouter shown in the generated OpenAPI documentation.
+
+![OpenAPI Route Overview](https://raw.githubusercontent.com/awtkns/fastapi-crudrouter/master/docs/en/docs/assets/RouteOverview.png)
+
+The CRUDRouter is able to dynamically generate detailed documentation based on the models given to it.
+
+![OpenAPI Route Detail](https://raw.githubusercontent.com/awtkns/fastapi-crudrouter/master/docs/en/docs/assets/RouteDetail.png)
+

fastapi_crudrouter_v2-0.1.3/README.md

@@ -0,0 +1,88 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/awtkns/fastapi-crudrouter/master/docs/en/docs/assets/logo.png" height="200" />
+</p>
+<p align="center">
+  <em>⚡ Create CRUD routes with lighting speed</em> ⚡</br>
+  <sub>A dynamic FastAPI router that automatically creates CRUD routes for your models</sub>
+</p>
+<p align="center">
+<img alt="Tests" src="https://img.shields.io/github/actions/workflow/status/awtkns/fastapi-crudrouter/.github/workflows/pytest.yml?color=%2334D058" />
+<img alt="Downloads" src="https://img.shields.io/pypi/dm/fastapi-crudrouter?color=%2334D058" />
+  <a href="https://pypi.org/project/fastapi-crudrouter" target="_blank">
+    <img src="https://img.shields.io/pypi/v/fastapi-crudrouter?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+  <img alt="License" src="https://img.shields.io/github/license/awtkns/fastapi-crudrouter?color=%2334D058" />
+</p>
+<p align="center">
+<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/fastapi-crudrouter">
+</p>
+
+---
+
+**Documentation**: <a href="https://fastapi-crudrouter.awtkns.com" target="_blank">https://fastapi-crudrouter.awtkns.com</a>
+
+**Source Code**: <a href="https://github.com/awtkns/fastapi-crudrouter" target="_blank">https://github.com/awtkns/fastapi-crudrouter</a>
+
+---
+Tired of rewriting generic CRUD routes? Need to rapidly prototype a feature for a presentation
+or a hackathon? Thankfully, [fastapi-crudrouter](https://github.com/awtkns/fastapi-crudrouter) has your back. As an 
+extension to the APIRouter included with [FastAPI](https://fastapi.tiangolo.com/), the FastAPI CRUDRouter will automatically
+generate and document your CRUD routes for you, all you have to do is pass your model and maybe your database connection.
+
+FastAPI-CRUDRouter is **lighting fast**, well tested, and **production ready**.
+
+
+## Installation
+```bash
+pip install fastapi-crudrouter
+```
+
+## Basic Usage
+Below is a simple example of what the CRUDRouter can do. In just ten lines of code, you can generate all 
+the crud routes you need for any model. A full list of the routes generated can be found [here](https://fastapi-crudrouter.awtkns.com/routing).
+
+```python
+from pydantic import BaseModel
+from fastapi import FastAPI
+from fastapi_crudrouter import MemoryCRUDRouter as CRUDRouter
+
+class Potato(BaseModel):
+    id: int
+    color: str
+    mass: float
+
+app = FastAPI()
+app.include_router(CRUDRouter(schema=Potato))
+```
+
+## Advanced Usage
+fastapi-crudrouter provides a number of features that allow you to get the most out of your automatically generated CRUD
+routes. Listed below are some highlights.
+
+- Automatic Pagination ([docs](https://fastapi-crudrouter.awtkns.com/pagination/))
+- Ability to Provide Custom Create and Update Schemas ([docs](https://fastapi-crudrouter.awtkns.com/schemas/))
+- Dynamic Generation of Create and Update Schemas ([docs](https://fastapi-crudrouter.awtkns.com/schemas/))
+- Ability to Add, Customize, or Disable Specific Routes ([docs](https://fastapi-crudrouter.awtkns.com/routing/))
+- Native Support for FastAPI Dependency Injection ([docs](https://fastapi-crudrouter.awtkns.com/dependencies/))
+
+## Supported Backends / ORMs
+fastapi-crudrouter currently supports a number of backends / ORMs. Listed below are the backends currently supported. This list will
+likely grow in future releases.
+
+- In Memory ([docs](https://fastapi-crudrouter.awtkns.com/backends/memory/))
+- SQLAlchemy ([docs](https://fastapi-crudrouter.awtkns.com/backends/sqlalchemy/))
+- Databases (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/async/))
+- Gino (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/gino.html)) 
+- Ormar (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/ormar/))
+- Tortoise ORM  (async) ([docs](https://fastapi-crudrouter.awtkns.com/backends/tortoise/))
+
+## OpenAPI Support
+By default, all routes generated by the CRUDRouter will be documented according to OpenAPI spec.
+
+Below are the default routes created by the CRUDRouter shown in the generated OpenAPI documentation.
+
+![OpenAPI Route Overview](https://raw.githubusercontent.com/awtkns/fastapi-crudrouter/master/docs/en/docs/assets/RouteOverview.png)
+
+The CRUDRouter is able to dynamically generate detailed documentation based on the models given to it.
+
+![OpenAPI Route Detail](https://raw.githubusercontent.com/awtkns/fastapi-crudrouter/master/docs/en/docs/assets/RouteDetail.png)

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/__init__.py

@@ -0,0 +1,9 @@
+from .core import (
+    TortoiseCRUDRouter,
+)
+
+from ._version import __version__  # noqa: F401
+
+__all__ = [
+    "TortoiseCRUDRouter",
+]

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/core/__init__.py

@@ -0,0 +1,4 @@
+from ._base import NOT_FOUND, CRUDGenerator
+from ._router import TortoiseCRUDRouter
+
+__all__ = ["TortoiseCRUDRouter", "CRUDGenerator", "NOT_FOUND"]

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/core/_base.py

@@ -0,0 +1,212 @@
+# mypy: ignore-errors
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Generic, List, Optional, Type, Union
+
+from fastapi import APIRouter, HTTPException
+from fastapi.types import DecoratedCallable
+
+from ._types import DEPENDENCIES, T
+from ._utils import pagination_factory, schema_factory
+
+NOT_FOUND = HTTPException(404, "Item not found")
+
+
+class CRUDGenerator(Generic[T], APIRouter, ABC):
+    schema: Type[T]
+    create_schema: Type[T]
+    update_schema: Type[T]
+    _base_path: str = "/"
+
+    def __init__(
+        self,
+        schema: Type[T],
+        create_schema: Optional[Type[T]] = None,
+        update_schema: Optional[Type[T]] = None,
+        prefix: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        paginate: Optional[int] = None,
+        get_all_route: Union[bool, DEPENDENCIES] = True,
+        get_one_route: Union[bool, DEPENDENCIES] = True,
+        create_route: Union[bool, DEPENDENCIES] = True,
+        update_route: Union[bool, DEPENDENCIES] = True,
+        delete_one_route: Union[bool, DEPENDENCIES] = True,
+        delete_all_route: Union[bool, DEPENDENCIES] = True,
+        trailing_slash: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        self.schema = schema
+        self.pagination = pagination_factory(max_limit=paginate)
+        self._pk: str = self._pk if hasattr(self, "_pk") else "id"
+        self.create_schema = (
+            create_schema
+            if create_schema
+            else schema_factory(self.schema, pk_field_name=self._pk, name="Create")
+        )
+        self.update_schema = (
+            update_schema
+            if update_schema
+            else schema_factory(self.schema, pk_field_name=self._pk, name="Update")
+        )
+
+        prefix = str(prefix if prefix else self.schema.__name__).lower()
+        prefix = self._base_path + prefix.strip("/")
+        tags = tags or [prefix.strip("/").capitalize()]
+        path = "/" if trailing_slash else ""
+        path_param = "/{item_id}" + path
+
+        super().__init__(prefix=prefix, tags=tags, **kwargs)
+
+        if get_all_route:
+            self._add_api_route(
+                path,
+                self._get_all(),
+                methods=["GET"],
+                response_model=Optional[List[self.schema]],  # type: ignore
+                summary="Get All",
+                dependencies=get_all_route,
+            )
+
+        if create_route:
+            self._add_api_route(
+                path,
+                self._create(),
+                methods=["POST"],
+                response_model=self.schema,
+                summary="Create One",
+                dependencies=create_route,
+            )
+
+        if delete_all_route:
+            self._add_api_route(
+                path,
+                self._delete_all(),
+                methods=["DELETE"],
+                response_model=Optional[List[self.schema]],  # type: ignore
+                summary="Delete All",
+                dependencies=delete_all_route,
+            )
+
+        if get_one_route:
+            self._add_api_route(
+                path_param,
+                self._get_one(),
+                methods=["GET"],
+                response_model=self.schema,
+                summary="Get One",
+                dependencies=get_one_route,
+                error_responses=[NOT_FOUND],
+            )
+
+        if update_route:
+            self._add_api_route(
+                path_param,
+                self._update(),
+                methods=["PUT"],
+                response_model=self.schema,
+                summary="Update One",
+                dependencies=update_route,
+                error_responses=[NOT_FOUND],
+            )
+
+        if delete_one_route:
+            self._add_api_route(
+                path_param,
+                self._delete_one(),
+                methods=["DELETE"],
+                response_model=self.schema,
+                summary="Delete One",
+                dependencies=delete_one_route,
+                error_responses=[NOT_FOUND],
+            )
+
+    def _add_api_route(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        dependencies: Union[bool, DEPENDENCIES],
+        error_responses: Optional[List[HTTPException]] = None,
+        **kwargs: Any,
+    ) -> None:
+        dependencies = [] if isinstance(dependencies, bool) else dependencies
+        responses: Any = (
+            {err.status_code: {"detail": err.detail} for err in error_responses}
+            if error_responses
+            else None
+        )
+
+        super().add_api_route(
+            path, endpoint, dependencies=dependencies, responses=responses, **kwargs
+        )
+
+    def api_route(
+        self, path: str, *args: Any, **kwargs: Any
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        """Overrides and exiting route if it exists"""
+        methods = kwargs["methods"] if "methods" in kwargs else ["GET"]
+        self.remove_api_route(path, methods)
+        return super().api_route(path, *args, **kwargs)
+
+    def get(
+        self, path: str, *args: Any, **kwargs: Any
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        self.remove_api_route(path, ["Get"])
+        return super().get(path, *args, **kwargs)
+
+    def post(
+        self, path: str, *args: Any, **kwargs: Any
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        self.remove_api_route(path, ["POST"])
+        return super().post(path, *args, **kwargs)
+
+    def put(
+        self, path: str, *args: Any, **kwargs: Any
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        self.remove_api_route(path, ["PUT"])
+        return super().put(path, *args, **kwargs)
+
+    def delete(
+        self, path: str, *args: Any, **kwargs: Any
+    ) -> Callable[[DecoratedCallable], DecoratedCallable]:
+        self.remove_api_route(path, ["DELETE"])
+        return super().delete(path, *args, **kwargs)
+
+    def remove_api_route(self, path: str, methods: List[str]) -> None:
+        methods_ = set(methods)
+
+        for route in self.routes:
+            if (
+                route.path == f"{self.prefix}{path}"  # type: ignore
+                and route.methods == methods_  # type: ignore
+            ):
+                self.routes.remove(route)
+
+    @abstractmethod
+    def _get_all(self, *args: Any, **kwargs: Any) -> Callable[..., Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_one(self, *args: Any, **kwargs: Any) -> Callable[..., Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _create(self, *args: Any, **kwargs: Any) -> Callable[..., Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _update(self, *args: Any, **kwargs: Any) -> Callable[..., Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _delete_one(self, *args: Any, **kwargs: Any) -> Callable[..., Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _delete_all(self, *args: Any, **kwargs: Any) -> Callable[..., Any]:
+        raise NotImplementedError
+
+    def _raise(self, e: Exception, status_code: int = 422) -> HTTPException:
+        raise HTTPException(422, ", ".join(e.args)) from e
+
+    @staticmethod
+    def get_routes() -> List[str]:
+        return ["get_all", "create", "delete_all", "get_one", "update", "delete_one"]

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/core/_router.py

@@ -0,0 +1,114 @@
+# mypy: ignore-errors
+
+from typing import Any, Callable, Coroutine, List, Optional, Type, Union, cast
+
+from tortoise.models import Model
+
+from . import NOT_FOUND, CRUDGenerator
+from ._types import DEPENDENCIES, PAGINATION
+from ._types import PYDANTIC_SCHEMA as SCHEMA
+
+tortoise_installed = True
+
+
+CALLABLE = Callable[..., Coroutine[Any, Any, Model]]
+CALLABLE_LIST = Callable[..., Coroutine[Any, Any, List[Model]]]
+
+
+class TortoiseCRUDRouter(CRUDGenerator[SCHEMA]):
+    def __init__(
+        self,
+        schema: Type[SCHEMA],
+        db_model: Type[Model],
+        create_schema: Optional[Type[SCHEMA]] = None,
+        update_schema: Optional[Type[SCHEMA]] = None,
+        prefix: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        paginate: Optional[int] = None,
+        get_all_route: Union[bool, DEPENDENCIES] = True,
+        get_one_route: Union[bool, DEPENDENCIES] = True,
+        create_route: Union[bool, DEPENDENCIES] = True,
+        update_route: Union[bool, DEPENDENCIES] = True,
+        delete_one_route: Union[bool, DEPENDENCIES] = True,
+        delete_all_route: Union[bool, DEPENDENCIES] = True,
+        **kwargs: Any
+    ) -> None:
+        assert (
+            tortoise_installed
+        ), "Tortoise ORM must be installed to use the TortoiseCRUDRouter."
+
+        self.db_model = db_model
+        self._pk: str = db_model.describe()["pk_field"]["db_column"]
+
+        super().__init__(
+            schema=schema,
+            create_schema=create_schema,
+            update_schema=update_schema,
+            prefix=prefix or db_model.describe()["name"].replace("None.", ""),
+            tags=tags,
+            paginate=paginate,
+            get_all_route=get_all_route,
+            get_one_route=get_one_route,
+            create_route=create_route,
+            update_route=update_route,
+            delete_one_route=delete_one_route,
+            delete_all_route=delete_all_route,
+            **kwargs
+        )
+
+    def _get_all(self, *args: Any, **kwargs: Any) -> CALLABLE_LIST:
+        async def get_all(pagination: PAGINATION = self.pagination) -> List[Model]:
+            skip, limit = pagination.get("skip"), pagination.get("limit")
+            query = self.db_model.all().offset(cast(int, skip))
+            if limit:
+                query = query.limit(limit)
+            return await query
+
+        return get_all
+
+    def _get_one(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def get_one(item_id: int) -> Model:
+            model = await self.db_model.filter(id=item_id).first()
+
+            if model:
+                return model
+            else:
+                raise NOT_FOUND
+
+        return get_one
+
+    def _create(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def create(model: self.create_schema) -> Model:  # type: ignore
+            db_model = self.db_model(**model.dict())
+            await db_model.save()
+
+            return db_model
+
+        return create
+
+    def _update(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def update(
+            item_id: int, model: self.update_schema  # type: ignore
+        ) -> Model:
+            await self.db_model.filter(id=item_id).update(
+                **model.dict(exclude_unset=True)
+            )
+            return await self._get_one()(item_id)
+
+        return update
+
+    def _delete_all(self, *args: Any, **kwargs: Any) -> CALLABLE_LIST:
+        async def delete_all() -> List[Model]:
+            await self.db_model.all().delete()
+            return await self._get_all()(pagination={"skip": 0, "limit": None})
+
+        return delete_all
+
+    def _delete_one(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def delete_one(item_id: int) -> Model:
+            model: Model = await self._get_one()(item_id)
+            await self.db_model.filter(id=item_id).delete()
+
+            return model
+
+        return delete_one

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/core/_types.py

@@ -0,0 +1,12 @@
+# mypy: ignore-errors
+
+from typing import Dict, Optional, Sequence, TypeVar
+
+from fastapi.params import Depends
+from pydantic import BaseModel
+
+PAGINATION = Dict[str, Optional[int]]
+PYDANTIC_SCHEMA = BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+DEPENDENCIES = Optional[Sequence[Depends]]

fastapi_crudrouter_v2-0.1.3/fastapi_crudrouter_v2/core/_utils.py

@@ -0,0 +1,74 @@
+# mypy: ignore-errors
+
+from typing import Any, Optional, Type
+
+from fastapi import Depends, HTTPException
+from pydantic import create_model
+
+from ._types import PAGINATION, T
+
+
+def schema_factory(
+    schema_cls: Type[T], pk_field_name: str = "id", name: str = "Create"
+) -> Type[T]:
+    """
+    Is used to create a CreateSchema which does not contain pk
+    """
+
+    fields = {}
+
+    for field_name, field_info in schema_cls.model_fields.items():
+        if field_name != pk_field_name:
+
+            annotation = field_info.annotation
+
+            if field_info.is_required():
+                fields[field_name] = (annotation, ...)
+            else:
+
+                default = field_info.default if field_info.default is not ... else ...
+                fields[field_name] = (annotation, default)
+
+    name = schema_cls.__name__ + name
+
+    schema: Type[T] = create_model(name, **fields)
+    return schema
+
+
+def create_query_validation_exception(field: str, msg: str) -> HTTPException:
+    return HTTPException(
+        422,
+        detail={
+            "detail": [
+                {"loc": ["query", field], "msg": msg, "type": "type_error.integer"}
+            ]
+        },
+    )
+
+
+def pagination_factory(max_limit: Optional[int] = None) -> Any:
+    """
+    Created the pagination dependency to be used in the router
+    """
+
+    def pagination(skip: int = 0, limit: Optional[int] = max_limit) -> PAGINATION:
+        if skip < 0:
+            raise create_query_validation_exception(
+                field="skip",
+                msg="skip query parameter must be greater or equal to zero",
+            )
+
+        if limit is not None:
+            if limit <= 0:
+                raise create_query_validation_exception(
+                    field="limit", msg="limit query parameter must be greater than zero"
+                )
+            elif max_limit and max_limit < limit:
+                raise create_query_validation_exception(
+                    field="limit",
+                    msg=f"limit query parameter must be less than {max_limit}",
+                )
+
+        return {"skip": skip, "limit": limit}
+
+    return Depends(pagination)

fastapi_crudrouter_v2-0.1.3/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "fastapi-crudrouter-v2"
+version = "0.1.3"
+description = "A dynamic FastAPI router that automatically creates CRUD routes for your models"
+authors = [
+    {name = "pasha_danilevich",email = "danilevitch.pasha@yandex.ru"}
+]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = ">=3.9, <4.0"
+
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"