Fast-Controller 0.0.0.dev2__tar.gz → 0.2.0b0__tar.gz

{fast_controller-0.0.0.dev2 → fast_controller-0.2.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Fast-Controller
-Version: 0.0.0.dev2
+Version: 0.2.0b0
 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>

fast_controller-0.2.0b0/fast_controller/__init__.py

@@ -0,0 +1,272 @@
+from contextlib import contextmanager
+from enum import Enum, auto
+from typing import Optional, Callable
+
+from daomodel import DAOModel
+from daomodel.dao import NotFound
+from daomodel.db import DAOFactory
+from daomodel.transaction import Conflict
+from fastapi import FastAPI, APIRouter, Request, Response, Depends, Path, Body, Query, Header
+from fastapi.responses import JSONResponse
+from sqlalchemy import Engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+from fast_controller.resource import Resource
+from fast_controller.util import docstring_format, InvalidInput
+
+
+class Action(Enum):
+    VIEW = auto()
+    SEARCH = auto()
+    CREATE = auto()
+    UPSERT = auto()
+    MODIFY = auto()
+    RENAME = auto()
+    DELETE = auto()
+
+
+class Controller:
+    def __init__(self,
+            prefix: Optional[str] = '',
+            app: Optional[FastAPI] = None,
+            engine: Optional[Engine] = None) -> None:
+        self.prefix = prefix
+        self.app = None
+        self.engine = None
+        self.models = None
+        if app is not None and engine is not None:
+            self.init_app(app, engine)
+        self.daos = Depends(self.dao_generator)
+
+    def init_app(self, app: FastAPI, engine: Engine) -> None:
+        self.app = app
+        self.engine = engine
+
+        @app.exception_handler(InvalidInput)
+        async def not_found_handler(request: Request, exc: InvalidInput):
+            return JSONResponse(status_code=400, content={"detail": exc.detail})
+
+        @app.exception_handler(NotFound)
+        async def not_found_handler(request: Request, exc: NotFound):
+            return JSONResponse(status_code=404, content={"detail": exc.detail})
+
+        @app.exception_handler(Conflict)
+        async def not_found_handler(request: Request, exc: Conflict):
+            return JSONResponse(status_code=409, content={"detail": exc.detail})
+
+    def dao_generator(self) -> DAOFactory:
+        """Yields a DAOFactory."""
+        with DAOFactory(sessionmaker(bind=self.engine)) as daos:
+            yield daos
+
+    @contextmanager
+    def dao_context(self):
+        yield from self.dao_generator()
+
+    def dependencies_for(self, resource: type[Resource], action: Action) -> list[Depends]:
+        return []
+
+    def register_resource(self,
+            resource: type[Resource],
+            skip: Optional[set[Action]] = None,
+            additional_endpoints: Optional[Callable] = None) -> None:
+        api_router = APIRouter(
+            prefix=self.prefix + resource.get_resource_path(),
+            tags=[resource.doc_name()])
+        self._register_resource_endpoints(api_router, resource, skip)
+        if additional_endpoints:
+            additional_endpoints(api_router, self)
+        self.app.include_router(api_router)
+
+    def _register_resource_endpoints(self,
+            router: APIRouter,
+            resource: type[Resource],
+            skip: Optional[set[Action]] = None) -> None:
+        if skip is None:
+            skip = set()
+        if Action.SEARCH not in skip:
+            self._register_search_endpoint(router, resource)
+        if Action.CREATE not in skip:
+            self._register_create_endpoint(router, resource)
+        if Action.UPSERT not in skip:
+            self._register_update_endpoint(router, resource)
+
+        pk = [p.name for p in resource.get_pk()]
+        path = "/".join([""] + ["{" + p + "}" for p in pk])
+
+        # Caveat: Only up to 2 columns are supported within a primary key.
+        # This allows us to avoid resorting to exec() while **kwargs is unsupported for Path variables
+        if len(pk) == 1:
+            if Action.VIEW not in skip:
+                self._register_view_endpoint(router, resource, path, pk)
+
+            # Caveat: Rename action is only supported for resources with a single column primary key
+            if Action.RENAME not in skip:
+                self._register_rename_endpoint(router, resource, path, pk)
+
+            # 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:
+                self._register_modify_endpoint(router, resource, path, pk)
+
+            # Caveat: Delete action is only supported for resources with a single column primary key
+            if Action.DELETE not in skip:
+                self._register_delete_endpoint(router, resource, path, pk)
+        elif len(pk) == 2:
+            if Action.VIEW not in skip:
+                self._register_view_endpoint_dual_pk(router, resource, path, pk)
+
+    def _register_search_endpoint(self, router: APIRouter, resource: type[Resource]):
+        @router.get(
+            "/",
+            response_model=list[resource.get_output_schema()],
+            dependencies=self.dependencies_for(resource, Action.SEARCH))
+        @docstring_format(resource=resource.doc_name())
+        def search(response: Response,
+                   filters: resource.get_search_schema() = Query(),
+                   x_page: Optional[int] = Header(default=None, gt=0),
+                   x_per_page: Optional[int] = Header(default=None, gt=0),
+                   daos: DAOFactory = self.daos) -> list[DAOModel]:
+            """Searches for {resource} by criteria"""
+            results = daos[resource].find(x_page, x_per_page, **filters.model_dump(exclude_unset=True))
+            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
+
+    def _register_create_endpoint(self, router: APIRouter, resource: type[Resource]):
+        @router.post(
+            "/",
+            response_model=resource.get_detailed_output_schema(),
+            status_code=201,
+            dependencies=self.dependencies_for(resource, Action.CREATE))
+        @docstring_format(resource=resource.doc_name())
+        def create(model: resource.get_input_schema(),
+                   daos: DAOFactory = self.daos) -> DAOModel:
+            """Creates a new {resource}"""
+            return daos[resource].create_with(**model.model_dump(exclude_unset=True))
+
+    def _register_update_endpoint(self, router: APIRouter, resource: type[Resource]):
+        @router.put(
+            "/",
+            response_model=resource.get_detailed_output_schema(),
+            dependencies=self.dependencies_for(resource, Action.UPSERT))
+        @docstring_format(resource=resource.doc_name())
+        def upsert(model: resource.get_input_schema(),
+                   daos: DAOFactory = self.daos) -> SQLModel:
+            """Creates/modifies a {resource}"""
+            daos[resource].upsert(model)
+            return model
+
+    def _register_view_endpoint(self,
+            router: APIRouter,
+            resource: type[Resource],
+            path: str,
+            pk: list[str]):
+        @router.get(
+            path,
+            response_model=resource.get_detailed_output_schema(),
+            dependencies=self.dependencies_for(resource, Action.VIEW))
+        @docstring_format(resource=resource.doc_name())
+        def view(pk0=Path(alias=pk[0]),
+                 daos: DAOFactory = self.daos) -> DAOModel:
+            """Retrieves a detailed view of a {resource}"""
+            return daos[resource].get(pk0)
+
+    def _register_view_endpoint_dual_pk(self,
+            router: APIRouter,
+            resource: type[Resource],
+            path: str,
+            pk: list[str]):
+        @router.get(
+            path,
+            response_model=resource.get_detailed_output_schema(),
+            dependencies=self.dependencies_for(resource, Action.VIEW))
+        @docstring_format(resource=resource.doc_name())
+        def view(pk0=Path(alias=pk[0]),
+                 pk1=Path(alias=pk[1]),
+                 daos: DAOFactory = self.daos) -> DAOModel:
+            """Retrieves a detailed view of a {resource}"""
+            return daos[resource].get(pk0, pk1)
+
+    def _register_rename_endpoint(self,
+            router: APIRouter,
+            resource: type[Resource],
+            path: str,
+            pk: list[str]):
+        @router.post(
+            f'{path}/rename',
+            response_model=resource.get_detailed_output_schema(),
+            dependencies=self.dependencies_for(resource, Action.RENAME))
+        @docstring_format(resource=resource.doc_name())
+        def rename(pk0=Path(alias=pk[0]),
+                   new_id=Body(alias=pk[0]),
+                   daos: DAOFactory = self.daos) -> DAOModel:
+            """Renames a {resource}"""
+            dao = daos[resource]
+            current = dao.get(pk0)
+            dao.rename(current, dao.get(new_id))
+            return current
+
+    def _register_merge_endpoint(self,
+            router: APIRouter,
+            resource: type[Resource],
+            path: str,
+            pk: list[str]):
+        @router.post(
+            f'{path}/merge',
+            response_model=resource.get_detailed_output_schema(),
+            dependencies=self.dependencies_for(resource, Action.RENAME))
+        @docstring_format(resource=resource.doc_name())
+        def merge(pk0=Path(alias=pk[0]),
+                   target_id=Body(alias=pk[0]),
+                   daos: DAOFactory = self.daos) -> DAOModel:
+            source = daos[resource].get(pk0)
+         #   for model in all_models(self.engine):
+        #        for column in model.get_references_of(resource):
+                    #daos[type[model]].find(column.name=)
+         #           if fk.column.table.name == target_table_name and fk.column.name in target_column_values:
+        #                print(f"Foreign key in table {table.name} references the column '{fk.column.name}' in {target_table.name}")
+        #                # Retrieve rows in this table that reference the target row
+        #                conn = engine.connect()
+        #                condition = (table.c[fk.parent.name] == target_column_values[fk.column.name])
+        #                result = conn.execute(table.select().where(condition))
+       #                 referencing_rows.extend(result.fetchall())
+        #                conn.close()
+#
+        #    return referencing_rows
+
+    def _register_modify_endpoint(self,
+            router: APIRouter,
+            resource: type[Resource],
+            path: str,
+            pk: list[str]):
+        @router.put(
+            path,
+            response_model=resource.get_detailed_output_schema(),
+            dependencies=self.dependencies_for(resource, Action.MODIFY))
+        @docstring_format(resource=resource.doc_name())
+        def update(model: resource.get_update_schema(),  # TODO - Remove PK from input schema
+                   pk0=Path(alias=pk[0]),
+                   daos: DAOFactory = self.daos) -> DAOModel:
+            """Creates/modifies a {resource}"""
+            result = daos[resource].get(pk0)
+            result.set_values(**model.model_dump(exclude_unset=True))
+            daos[resource].commit(result)
+            return result
+
+    def _register_delete_endpoint(self,
+            router: APIRouter,
+            resource: type[Resource],
+            path: str,
+            pk: list[str]):
+        @router.delete(
+            path,
+            status_code=204,
+            dependencies=self.dependencies_for(resource, Action.DELETE))
+        @docstring_format(resource=resource.doc_name())
+        def delete(pk0=Path(alias=pk[0]),
+                   daos: DAOFactory = self.daos) -> None:
+            """Deletes a {resource}"""
+            daos[resource].remove(pk0)

fast_controller-0.2.0b0/fast_controller/resource.py

@@ -0,0 +1,107 @@
+from inspect import isclass
+from typing import Any
+
+from daomodel import DAOModel
+from pydantic import create_model
+from sqlmodel import SQLModel
+
+
+def either(preferred: Any, default: type[SQLModel]) -> type[SQLModel]:
+    """
+    Returns the preferred type if present, otherwise the default type.
+
+    :param preferred: The type to return if not None
+    :param default: The type to return if the preferred is not a model
+    :return: either the preferred type or the default type
+    """
+    return preferred if isclass(preferred) and issubclass(preferred, SQLModel) else default
+
+
+class Resource(DAOModel):
+    __abstract__ = True
+    _default_schema: type[SQLModel]
+    _input_schema: type[SQLModel]
+    _update_schema: type[SQLModel]
+    _output_schema: type[SQLModel]
+    _detailed_output_schema: type[SQLModel]
+
+    @classmethod
+    def get_resource_path(cls) -> str:
+        """
+        Returns the URI path to this resource as defined by the 'path' class variable.
+        A default value of `/api/{resource_name} is returned unless overridden.
+
+        :return: The URI path to be used for this Resource
+        """
+        return "/api/" + cls.normalized_name()
+
+    @classmethod
+    def validate(cls, column_name, value):
+        return True
+
+    @classmethod
+    def get_search_schema(cls) -> type[SQLModel]:
+        """Returns an SQLModel representing the searchable fields"""
+        def get_field_name(field) -> str:
+            """Constructs the field's name, optionally prepending the table name."""
+            field_name = field.name
+            if hasattr(field, 'class_') and field.class_ is not cls and hasattr(field, 'table') and field.table.name:
+                field_name = f'{field.table.name}_{field_name}'
+            return field_name
+        def get_field_type(field) -> type:
+            field_type = field.type
+            if hasattr(field_type, 'impl'):
+                field_type = field_type.impl
+            return field_type.python_type
+        fields = [field[-1] if isinstance(field, tuple) else field for field in cls.get_searchable_properties()]
+        field_types = {
+            get_field_name(field): (get_field_type(field), None) for field in fields
+        }
+        return create_model(
+            f'{cls.doc_name()}SearchSchema',
+            **field_types
+        )
+
+    @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 either(cls._default_schema, cls)
+
+    @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_input_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-0.2.0b0/fast_controller/util.py

@@ -0,0 +1,36 @@
+from typing import Callable, get_type_hints, Optional
+
+from sqlmodel import SQLModel
+
+
+class InvalidInput(Exception):
+    """Indicates that the user provided bad input."""
+    def __init__(self, detail: str):
+        self.detail = detail
+
+
+def docstring_format(**kwargs):
+    """
+    A decorator that formats the docstring of a function with specified values.
+
+    :param kwargs: The values to inject into the docstring
+    """
+    def decorator(func: Callable):
+        func.__doc__ = func.__doc__.format(**kwargs)
+        return func
+    return decorator
+
+
+# TODO: Determine bast way to add test coverage
+def all_optional(superclass: type[SQLModel]):
+    """Creates a new SQLModel for the specified class but having no required fields.
+
+    :param superclass: The SQLModel of which to make all fields Optional
+    :return: The newly wrapped Model
+    """
+    class OptionalModel(superclass):
+        pass
+    for field, field_type in get_type_hints(OptionalModel).items():
+        if not isinstance(field_type, type(Optional)):
+            OptionalModel.__annotations__[field] = Optional[field_type]
+    return OptionalModel

{fast_controller-0.0.0.dev2 → fast_controller-0.2.0b0}/pyproject.toml

@@ -40,7 +40,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries",
     "Typing :: Typed",
 ]
-version = "0.0.0.dev2"
+version = "0.2.0b0"
 
 [project.license]
 text = "MIT"

fast_controller-0.2.0b0/tests/test_resource.py

@@ -0,0 +1,84 @@
+from datetime import datetime
+from typing import Any, Optional
+
+import pytest
+from daomodel import DAOModel
+from daomodel.fields import Unsearchable, Identifier, ReferenceTo
+from sqlmodel import SQLModel
+
+from fast_controller import Resource, Controller
+from fast_controller.resource import either
+
+
+class Preferred(SQLModel):
+    pass
+
+
+class Default(SQLModel):
+    pass
+
+
+@pytest.mark.parametrize("preferred, default, expected", [
+    (Preferred, Default, Preferred),
+    (SQLModel, Default, SQLModel),
+    (DAOModel, Default, DAOModel),
+    (Resource, Default, Resource),
+    (None, Default, Default),
+    (1, Default, Default),
+    ("test", Default, Default),
+    (Controller, Default, Default)
+])
+def test_either(preferred: Any, default: type[SQLModel], expected: type[SQLModel]):
+    assert either(preferred, default) == expected
+
+
+def test_get_path():
+    class C(Resource):
+        pass
+    assert C.get_resource_path() == "/api/c"
+
+
+class Author(Resource, table=True):
+    name: Identifier[str]
+    bio: Optional[str]
+    active: bool = True
+
+
+class Book(Resource, table=True):
+    title: Identifier[str]
+    author_name: Author
+    description: Unsearchable[Optional[str]]
+    page_count: Optional[int]
+    publication_date: Optional[datetime]
+    publisher_name: str = ReferenceTo('publisher.name')
+
+
+class Publisher(Resource, table=True):
+    name: Identifier[str]
+
+    class Meta:
+        searchable_relations = {
+            Book.title, Book.page_count, Book.publication_date,
+            (Book, Author.name),
+            (Book, Author.active)
+        }
+
+
+def test_get_search_schema():
+    actual = Publisher.get_search_schema()
+    assert actual.__name__ == 'PublisherSearchSchema'
+    class Expected(SQLModel):
+        name: str
+        book_title: str
+        book_page_count: int
+        book_publication_date: datetime
+        author_name: str
+        author_active: bool
+    actual_fields = {k: v.annotation for k, v in actual.model_fields.items()}
+    expected_fields = {k: v.annotation for k, v in Expected.model_fields.items()}
+    assert actual_fields == expected_fields
+
+
+# TODO - Not convinced on this design for schema definitions
+def test_get_base_and_schemas():
+    pass

fast_controller-0.2.0b0/tests/test_util.py

@@ -0,0 +1,27 @@
+import inspect
+
+from fast_controller import docstring_format
+
+
+@docstring_format(key="value")
+def test_docstring_format():
+    """{key}"""
+    assert inspect.getdoc(test_docstring_format) == "value"
+
+
+@docstring_format(key="value")
+def test_docstring_format__empty():
+    """"""
+    assert inspect.getdoc(test_docstring_format__empty) == ""
+
+
+@docstring_format(key="value")
+def test_docstring_format__multiple_values():
+    """{key}1, {key}2"""
+    assert inspect.getdoc(test_docstring_format__multiple_values) == "value1, value2"
+
+
+@docstring_format(key1="value1", key2="value2")
+def test_docstring_format__multiple_keys():
+    """{key1}, {key2}"""
+    assert inspect.getdoc(test_docstring_format__multiple_keys) == "value1, value2"

fast_controller-0.0.0.dev2/fast_controller/__init__.py

@@ -1,237 +0,0 @@
-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-0.0.0.dev2/fast_controller/resource.py

@@ -1,80 +0,0 @@
-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-0.0.0.dev2/fast_controller/util.py

@@ -1,19 +0,0 @@
-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