Fast-Controller 0.0.0.dev0__py3-none-any.whl

fast_controller/__init__.py

@@ -0,0 +1,237 @@
+from enum import Enum, auto
+from typing import Optional, Callable, Annotated
+
+from daomodel import DAOModel
+from daomodel.dao import NotFound
+from daomodel.db import create_engine, DAOFactory
+from daomodel.util import names_of
+from fastapi import FastAPI, APIRouter, Depends, Path, Body, Query
+from fastapi.openapi.models import Response
+
+from fast_controller.resource import Resource
+from fast_controller.util import docstring_format, paginated
+
+
+SessionLocal = create_engine()
+def get_daos() -> DAOFactory:
+    """Yields a DAOFactory."""
+    with DAOFactory(SessionLocal) as daos:
+        yield daos
+
+
+class Action(Enum):
+    VIEW = auto()
+    SEARCH = auto()
+    CREATE = auto()
+    UPSERT = auto()
+    MODIFY = auto()
+    RENAME = auto()
+    DELETE = auto()
+
+
+class Controller:
+    def __init__(self, app: Optional[FastAPI] = None):
+        self.app = app
+
+    def init_app(self, app: FastAPI) -> None:
+        self.app = app
+
+    # todo : define both ways to define apis
+    @classmethod
+    def create_api_group(cls,
+            resource: Optional[type[Resource]] = None,
+            prefix: Optional[str] = None,
+            skip: Optional[set[Action]] = None) -> APIRouter:
+        api_router = APIRouter(prefix=prefix if prefix else resource.get_path())
+        if resource:
+            cls.__register_resource_endpoints(api_router, resource, skip)
+        return api_router
+
+    def register_resource(self,
+            resource: type[Resource],
+            skip: Optional[set[Action]] = None,
+            additional_endpoints: Optional[Callable] = None) -> None:
+        if skip is None:
+            skip = set()
+        api_router = APIRouter(prefix=resource.get_path(), tags=[resource.doc_name()])
+        self.__register_resource_endpoints(api_router, resource, skip)
+        if additional_endpoints:
+            additional_endpoints(api_router)
+        self.app.include_router(api_router)
+
+    @classmethod
+    def __register_resource_endpoints(cls, router: APIRouter, resource: type[Resource], skip) -> None:
+        if Action.SEARCH not in skip:
+            @router.get("/", response_model=list[resource.get_output_schema()])
+            @docstring_format(resource=resource.doc_name())
+            def search(response: Response,
+                       filters: Annotated[paginated(resource.get_search_schema()), Query()],
+                       daos: DAOFactory = Depends(get_daos)) -> list[DAOModel]:
+                """Searches for {resource} by criteria"""
+                results = daos[resource].find(**filters.model_dump())
+                response.headers["x-total-count"] = str(results.total)
+                response.headers["x-page"] = str(results.page)
+                response.headers["x-per-page"] = str(results.per_page)
+                return results
+
+        if Action.CREATE not in skip:
+            @router.post("/", response_model=resource.get_detailed_output_schema(), status_code=201)
+            @docstring_format(resource=resource.doc_name())
+            def create(data: Annotated[resource.get_input_schema(), Query()],
+                       daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                """Creates a new {resource}"""
+                return daos[resource].create_with(**data.model_dump())
+
+        if Action.UPSERT not in skip:
+            @router.put("/", response_model=resource.get_detailed_output_schema())
+            @docstring_format(resource=resource.doc_name())
+            def upsert(data: Annotated[resource.get_input_schema(), Query()],
+                       daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                """Creates/modifies a {resource}"""
+                return daos[resource].upsert(**data.model_dump())
+
+        pk = [p.name for p in resource.get_pk()]
+        path = "/".join([""] + ["{" + p + "}" for p in pk])
+
+        # Caveat: Only up to 5 columns are supported within a primary key.
+        # This allows us to avoid resorting to exec() while **kwargs is unsupported for Path variables
+        match len(pk):
+            case 1:
+                if Action.VIEW not in skip:
+                    @router.get(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def view(pk0 = Path(alias=pk[0]),
+                             daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Retrieves a detailed view of a {resource}"""
+                        return daos[resource].get(pk0)
+
+                # Caveat: Rename action is only supported for resources with a single column primary key
+                if Action.RENAME not in skip:
+                    @router.post(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def rename(pk0 = Path(alias=pk[0]),
+                               new_id = Body(alias=pk[0]),
+                               daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Renames a {resource}"""
+                        current = daos[resource].get(pk0)
+                        try:
+                            existing = daos[resource].get(new_id)
+                            # todo Set FKs
+                            for fk in resource.get_fks():
+                                fk = new_id
+                            daos[resource].remove_model(current, commit=False)
+                            current = existing
+                        except NotFound:
+                            for p in names_of(current.get_pk()):
+                                setattr(current, p, new_id)
+                                # todo Set entire PK
+                        return daos[resource].update_model(current)
+
+                # Caveat: Modify action is only supported for resources with a single column primary key
+                # Use Upsert instead for multi-column PK resources
+                if Action.MODIFY not in skip:
+                    @router.put(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def update(data: Annotated[resource.get_update_schema(), Body()],  # TODO - Remove PK from input schema
+                               pk0 = Path(alias=pk[0]),
+                               daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Creates/modifies a {resource}"""
+                        result = daos[resource].get(pk0)
+                        result.copy_values(**data.model_dump())
+                        return daos[resource].update(**result.model_dump())
+
+                if Action.DELETE not in skip:
+                    @router.delete(path, status_code=204)
+                    @docstring_format(resource=resource.doc_name())
+                    def delete(pk0 = Path(alias=pk[0]),
+                               daos: DAOFactory = Depends(get_daos)) -> None:
+                        """Deletes a {resource}"""
+                        daos[resource].remove(pk0)
+
+            case 2:
+                if Action.VIEW not in skip:
+                    @router.get(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def view(pk0 = Path(alias=pk[0]),
+                             pk1 = Path(alias=pk[1]),
+                             daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Retrieves a detailed view of a {resource}"""
+                        return daos[resource].get(pk0, pk1)
+
+                if Action.DELETE not in skip:
+                    @router.delete(path, status_code=204)
+                    @docstring_format(resource=resource.doc_name())
+                    def delete(pk0 = Path(alias=pk[0]),
+                               pk1 = Path(alias=pk[1]),
+                               daos: DAOFactory = Depends(get_daos)) -> None:
+                        """Deletes a {resource}"""
+                        daos[resource].remove(pk0, pk1)
+
+            case 3:
+                if Action.VIEW not in skip:
+                    @router.get(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def view(pk0 = Path(alias=pk[0]),
+                             pk1 = Path(alias=pk[1]),
+                             pk2 = Path(alias=pk[2]),
+                             daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Retrieves a detailed view of a {resource}"""
+                        return daos[resource].get(pk0, pk1, pk2)
+
+                if Action.DELETE not in skip:
+                    @router.delete(path, status_code=204)
+                    @docstring_format(resource=resource.doc_name())
+                    def delete(pk0 = Path(alias=pk[0]),
+                               pk1 = Path(alias=pk[1]),
+                               pk2 = Path(alias=pk[2]),
+                               daos: DAOFactory = Depends(get_daos)) -> None:
+                        """Deletes a {resource}"""
+                        daos[resource].remove(pk0, pk1, pk2)
+
+            case 4:
+                if Action.VIEW not in skip:
+                    @router.get(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def view(pk0 = Path(alias=pk[0]),
+                             pk1 = Path(alias=pk[1]),
+                             pk2 = Path(alias=pk[2]),
+                             pk3 = Path(alias=pk[3]),
+                             daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Retrieves a detailed view of a {resource}"""
+                        return daos[resource].get(pk0, pk1, pk2, pk3)
+
+                if Action.DELETE not in skip:
+                    @router.delete(path, status_code=204)
+                    @docstring_format(resource=resource.doc_name())
+                    def delete(pk0 = Path(alias=pk[0]),
+                               pk1 = Path(alias=pk[1]),
+                               pk2 = Path(alias=pk[2]),
+                               pk3 = Path(alias=pk[3]),
+                               daos: DAOFactory = Depends(get_daos)) -> None:
+                        """Deletes a {resource}"""
+                        daos[resource].remove(pk0, pk1, pk2, pk3)
+
+            case 5:
+                if Action.VIEW not in skip:
+                    @router.get(path, response_model=resource.get_detailed_output_schema())
+                    @docstring_format(resource=resource.doc_name())
+                    def view(pk0 = Path(alias=pk[0]),
+                             pk1 = Path(alias=pk[1]),
+                             pk2 = Path(alias=pk[2]),
+                             pk3 = Path(alias=pk[3]),
+                             pk4 = Path(alias=pk[4]),
+                             daos: DAOFactory = Depends(get_daos)) -> DAOModel:
+                        """Retrieves a detailed view of a {resource}"""
+                        return daos[resource].get(pk0, pk1, pk2, pk3, pk4)
+
+                if Action.DELETE not in skip:
+                    @router.delete(path, status_code=204)
+                    @docstring_format(resource=resource.doc_name())
+                    def delete(pk0 = Path(alias=pk[0]),
+                               pk1 = Path(alias=pk[1]),
+                               pk2 = Path(alias=pk[2]),
+                               pk3 = Path(alias=pk[3]),
+                               pk4 = Path(alias=pk[4]),
+                               daos: DAOFactory = Depends(get_daos)) -> None:
+                        """Deletes a {resource}"""
+                        daos[resource].remove(pk0, pk1, pk2, pk3, pk4)

fast_controller/resource.py

@@ -0,0 +1,80 @@
+from inspect import isclass
+from typing import ClassVar
+
+from daomodel import DAOModel
+from sqlmodel import SQLModel
+
+
+def either(preferred, default):
+    return preferred if isclass(preferred) and issubclass(preferred, SQLModel) else default
+
+
+class Resource(DAOModel):
+    __abstract__ = True
+    _default_schema: type[SQLModel]
+    _search_schema: type[SQLModel]
+    _input_schema: type[SQLModel]
+    _update_schema: type[SQLModel]
+    _output_schema: type[SQLModel]
+    _detailed_output_schema: type[SQLModel]
+    path: ClassVar[str]
+
+    @classmethod
+    def get_path(cls) -> str:
+        return getattr(cls, "path", "/api/" + cls.normalized_name())
+
+    @classmethod
+    def validate(cls, column_name, value):
+        return True
+
+    @classmethod
+    def get_base(cls) -> type[SQLModel]:
+        return cls
+
+    @classmethod
+    def set_default_schema(cls, schema: type[SQLModel]) -> None:
+        cls._default_schema = schema
+
+    @classmethod
+    def get_default_schema(cls) -> type[SQLModel]:
+        return cls._default_schema
+
+    @classmethod
+    def set_search_schema(cls, schema: type[SQLModel]) -> None:
+        cls._search_schema = schema
+
+    @classmethod
+    def get_search_schema(cls) -> type[SQLModel]:
+        return either(cls._search_schema, cls.get_default_schema())
+
+    @classmethod
+    def set_input_schema(cls, schema: type[SQLModel]) -> None:
+        cls._input_schema = schema
+
+    @classmethod
+    def get_input_schema(cls) -> type[SQLModel]:
+        return either(cls._input_schema, cls.get_default_schema())
+
+    @classmethod
+    def set_update_schema(cls, schema: type[SQLModel]) -> None:
+        cls._update_schema = schema
+
+    @classmethod
+    def get_update_schema(cls) -> type[SQLModel]:
+        return either(cls._update_schema, cls.get_default_schema())
+
+    @classmethod
+    def set_output_schema(cls, schema: type[SQLModel]) -> None:
+        cls._output_schema = schema
+
+    @classmethod
+    def get_output_schema(cls) -> type[SQLModel]:
+        return either(cls._output_schema, cls.get_default_schema())
+
+    @classmethod
+    def set_detailed_output_schema(cls, schema: type[SQLModel]) -> None:
+        cls._detailed_output_schema = schema
+
+    @classmethod
+    def get_detailed_output_schema(cls) -> type[SQLModel]:
+        return either(cls._detailed_output_schema, cls.get_output_schema())

fast_controller/util.py

@@ -0,0 +1,19 @@
+from typing import Callable, Optional
+
+from sqlmodel import Field, SQLModel
+
+
+def docstring_format(**kwargs):
+    def decorator(func: Callable):
+        func.__doc__ = func.__doc__.format(**kwargs)
+        return func
+    return decorator
+
+
+def paginated(superclass: type[SQLModel]):
+    class OptionalPK(superclass, table=True): # table=True is a hack to make PK optional
+        pass
+    class Paginated(OptionalPK):
+        page: Optional[int] = Field(default=None, gt=0)
+        per_page: Optional[int] = Field(default=None, gt=0)
+    return Paginated

fast_controller-0.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: Fast-Controller
+Version: 0.0.0.dev0
+Summary: The fastest way to a turn your models into a full ReST API
+Keywords: controller,base,rest,api,backend
+Author-Email: Cody M Sommer <bassmastacod@gmail.com>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+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
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Project-URL: Repository, https://github.com/BassMastaCod/Fast-Controller.git
+Project-URL: Issues, https://github.com/BassMastaCod/Fast-Controller/issues
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Fast-Controller
+A fast solution to creating a ReST backend for your Python models.
+
+Turn your models into _Resources_ and give them a controller layer.
+Provides standard functionality with limited effort using
+[DAOModel](https://pypi.org/project/DAOModel/)
+and [FastAPI](https://fastapi.tiangolo.com/).
+
+## Supported Actions
+* `search`
+* `create`
+* `upsert`
+* `view`
+* `rename`
+* `modify`
+* `delete`
+
+## Features
+* Expandable controllers so you can add endpoints for additional functionality
+* Built-in validation
+* Ability to pick and choose which actions to support for each resource
+
+## Usage
+...
+
+## Additional Functionality
+...
+
+## Caveats
+...

fast_controller-0.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,7 @@
+fast_controller-0.0.0.dev0.dist-info/METADATA,sha256=bY1DF17_Iw3ZpOHsGBuDLgVoUy5SbgiHPcRVvlXlEV0,1740
+fast_controller-0.0.0.dev0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+fast_controller-0.0.0.dev0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+fast_controller/__init__.py,sha256=dTd799KT00KJ4TFlb0LXQ5eFL3jFnWsWUAYcH4-3K_4,11860
+fast_controller/resource.py,sha256=DfI10MIy4tq6hbxwzW0HPcOFI6cOU8TpPnfM3xYKYkg,2339
+fast_controller/util.py,sha256=XcnnvnCyajF-gakfy_H1BCiFUqKGRxaoCrv75Uaxyu0,556
+fast_controller-0.0.0.dev0.dist-info/RECORD,,

fast_controller-0.0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.3)
+Root-Is-Purelib: true
+Tag: py3-none-any

fast_controller-0.0.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+