Fast-Controller 0.2.0b0__tar.gz → 0.3.0b0__tar.gz

{fast_controller-0.2.0b0 → fast_controller-0.3.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Fast-Controller
-Version: 0.2.0b0
+Version: 0.3.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.3.0b0/fast_controller/__init__.py

@@ -0,0 +1,324 @@
+from contextlib import contextmanager
+from enum import Enum, auto
+from typing import Optional, Callable
+import inspect
+
+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, RedirectResponse
+from sqlalchemy import Engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+from fast_controller.resource import Resource, get_field_type
+from fast_controller.util import docstring_format, InvalidInput, expose_path_params, extract_values
+
+
+class Action(Enum):
+    SEARCH = auto()
+    CREATE = auto()
+    UPSERT = auto()
+    VIEW = auto()
+    UPDATE = auto()
+    MODIFY = auto()
+    DELETE = auto()
+    RENAME = auto()
+
+    def register_endpoint(self, controller, router: APIRouter, resource: type[Resource]):
+        {
+            Action.SEARCH: _register_search_endpoint,
+            Action.CREATE: _register_create_endpoint,
+            Action.UPSERT: _register_upsert_endpoint,
+            Action.VIEW: _register_view_endpoint,
+            Action.UPDATE: _register_update_endpoint,
+            Action.MODIFY: _register_modify_endpoint,
+            Action.DELETE: _register_delete_endpoint,
+            Action.RENAME: _register_rename_endpoint,
+        }[self](controller, router, resource)
+
+
+def _construct_path(pk):
+    path = '/'.join([''] + ['{' + p + '}' for p in pk])
+    return path
+
+
+def _register_search_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    @router.get('/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url='', status_code=307)
+
+    @router.get(
+        '',
+        response_model=list[resource.get_output_schema()],
+        dependencies=controller.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 = controller.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(controller, router: APIRouter, resource: type[Resource]):
+    @router.post('/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url='', status_code=307)
+
+    @router.post(
+        '',
+        response_model=resource.get_detailed_output_schema(),
+        status_code=201,
+        dependencies=controller.dependencies_for(resource, Action.CREATE))
+    @docstring_format(resource=resource.doc_name())
+    def create(model: resource.get_input_schema(),
+               daos: DAOFactory = controller.daos) -> DAOModel:
+        """Creates a new {resource}"""
+        return daos[resource].create_with(**model.model_dump(exclude_unset=True))
+
+
+def _register_upsert_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    @router.put('/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url='', status_code=307)
+
+    @router.put(
+        '',
+        response_model=resource.get_detailed_output_schema(),
+        dependencies=controller.dependencies_for(resource, Action.UPSERT))
+    @docstring_format(resource=resource.doc_name())
+    def upsert(model: resource.get_input_schema(),
+               daos: DAOFactory = controller.daos) -> SQLModel:
+        """Creates/modifies a {resource}"""
+        daos[resource].upsert(model)
+        return model
+
+
+def _register_view_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    pk = [p.name for p in resource.get_pk()]
+    path = _construct_path(pk)
+
+    @router.get(f'{path}/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url=path, status_code=307)
+
+    @router.get(
+        path,
+        response_model=resource.get_detailed_output_schema(),
+        dependencies=controller.dependencies_for(resource, Action.VIEW))
+    @docstring_format(resource=resource.doc_name())
+    def view(daos: DAOFactory = controller.daos, **kwargs) -> DAOModel:
+        """Retrieves a detailed view of a {resource}"""
+        return daos[resource].get(*extract_values(kwargs, pk))
+
+    expose_path_params(view, pk)
+
+
+def _register_update_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    pk = [p.name for p in resource.get_pk()]
+    path = _construct_path(pk)
+
+    @router.put(f'{path}/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url=path, status_code=307)
+
+    @router.put(
+        path,
+        response_model=resource.get_detailed_output_schema(),
+        dependencies=controller.dependencies_for(resource, Action.UPDATE))
+    @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 = controller.daos) -> DAOModel:
+        """Creates/modifies a {resource}"""
+        result = daos[resource].get(pk0)
+        result.set_values(**model.model_dump(exclude_unset=False))
+        daos[resource].commit(result)
+        return result
+
+    expose_path_params(update, pk)
+
+
+def _register_modify_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    pk = [p.name for p in resource.get_pk()]
+    path = _construct_path(pk)
+
+    @router.patch(f'{path}/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url=path, status_code=307)
+
+    @router.patch(
+        path,
+        response_model=resource.get_detailed_output_schema(),
+        dependencies=controller.dependencies_for(resource, Action.MODIFY))
+    @docstring_format(resource=resource.doc_name())
+    def modify(model: resource.get_update_schema(),  # TODO - Remove PK from input schema
+               daos: DAOFactory = controller.daos, **kwargs) -> DAOModel:
+        """Modifies specific fields of a {resource} while leaving others unchanged"""
+        dao = daos[resource]
+        result = dao.get(*extract_values(kwargs, pk))
+        result.set_values(**model.model_dump(exclude_unset=True))
+        dao.commit(result)
+        return result
+
+    expose_path_params(modify, pk)
+
+
+def _register_delete_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    pk = [p.name for p in resource.get_pk()]
+    path = _construct_path(pk)
+
+    @router.delete(f'{path}/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url=path, status_code=307)
+
+    @router.delete(
+        path,
+        status_code=204,
+        dependencies=controller.dependencies_for(resource, Action.DELETE))
+    @docstring_format(resource=resource.doc_name())
+    def delete(daos: DAOFactory = controller.daos, **kwargs) -> None:
+        """Deletes a {resource}"""
+        daos[resource].remove(*extract_values(kwargs, pk))
+
+    expose_path_params(delete, pk)
+
+
+def _register_rename_endpoint(controller, router: APIRouter, resource: type[Resource]):
+    pk = [p.name for p in resource.get_pk()]
+    path = f'{_construct_path(pk)}/rename'
+
+    @router.post(f'{path}/', include_in_schema=False)
+    async def redirect():
+        return RedirectResponse(url=path, status_code=307)
+
+    @router.post(
+        path,
+        response_model=resource.get_detailed_output_schema(),
+        dependencies=controller.dependencies_for(resource, Action.RENAME))
+    @docstring_format(resource=resource.doc_name())
+    def rename(daos: DAOFactory = controller.daos, **kwargs) -> DAOModel:
+        """Renames a {resource}"""
+        dao = daos[resource]
+        current = dao.get(*extract_values(kwargs, pk))
+
+        if len(pk) == 1:
+            new_value = kwargs['new_pk']
+            dao.rename(current, dao.get(new_value))
+        else:
+            new_values = kwargs.get('new_pk', {})
+            new_pk_values = [new_values.get(field, kwargs[field]) for field in pk]
+            dao.rename(current, dao.get(*new_pk_values))
+
+        return current
+
+    expose_path_params(rename, pk)
+
+    sig = inspect.signature(rename)
+    new_params = list(sig.parameters.values())
+    new_params.append(inspect.Parameter(
+        'new_pk',
+        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+        default=Body(),
+        annotation=resource.get_pk_schema() if len(pk) > 1 else get_field_type(next(iter(resource.get_pk())))
+    ))
+    rename.__signature__ = sig.replace(parameters=new_params)
+
+
+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]] = frozenset(),
+            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]] = frozenset()) -> None:
+        for action in Action:
+            if action not in skip:
+                action.register_endpoint(self, router, resource)
+
+    # TODO: finish implementing merge endpoint
+    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

{fast_controller-0.2.0b0 → fast_controller-0.3.0b0}/fast_controller/resource.py

@@ -7,8 +7,7 @@ from sqlmodel import SQLModel
 
 
 def either(preferred: Any, default: type[SQLModel]) -> type[SQLModel]:
-    """
-    Returns the preferred type if present, otherwise the default type.
+    """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
@@ -17,6 +16,15 @@ def either(preferred: Any, default: type[SQLModel]) -> type[SQLModel]:
     return preferred if isclass(preferred) and issubclass(preferred, SQLModel) else default
 
 
+def get_field_type(field) -> type:
+    """Returns the equivalent type for the given field.
+
+    :param field: The Column of an SQLModel
+    :return: the Python type used to represent the DB Column value
+    """
+    return getattr(field.type, 'impl', field.type).python_type
+
+
 class Resource(DAOModel):
     __abstract__ = True
     _default_schema: type[SQLModel]
@@ -27,8 +35,8 @@ class Resource(DAOModel):
 
     @classmethod
     def get_resource_path(cls) -> str:
-        """
-        Returns the URI path to this resource as defined by the 'path' class variable.
+        """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
@@ -48,11 +56,6 @@ class Resource(DAOModel):
             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
@@ -62,6 +65,14 @@ class Resource(DAOModel):
             **field_types
         )
 
+    @classmethod
+    def get_pk_schema(cls) -> type[SQLModel]:
+        """Returns an SQLModel representing the primary key fields"""
+        return create_model(
+            f'{cls.doc_name()}PKSchema',
+            **{field.name: (get_field_type(field), ...) for field in cls.get_pk()}
+        )
+
     @classmethod
     def get_base(cls) -> type[SQLModel]:
         return cls

fast_controller-0.3.0b0/fast_controller/util.py

@@ -0,0 +1,77 @@
+import inspect
+from typing import Callable, get_type_hints, Optional
+from warnings import deprecated
+
+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
+
+
+@deprecated("No usages and no 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
+
+
+def expose_path_params(func: Callable, field_names: list[str]) -> Callable:
+    """Converts implicit path parameters from **kwargs to explicit parameters.
+
+    Takes a function using **kwargs and modifies its signature to expose specific
+    field names as explicit path parameters (field1, field2, etc.) with Path defaults,
+    making them visible to FastAPI's routing system. All existing parameters
+    (except **kwargs) are preserved in their original order.e
+
+    :param func: The function to modify
+    :param field_names: List of field names to expose as path parameters
+    :return: The modified function with an updated signature
+    """
+    sig = inspect.signature(func)
+    new_params = []
+
+    for field_name in field_names:
+        new_params.append(inspect.Parameter(
+            field_name,
+            inspect.Parameter.POSITIONAL_OR_KEYWORD
+        ))
+
+    for param_name, param in sig.parameters.items():
+        if param.kind != inspect.Parameter.VAR_KEYWORD:
+            new_params.append(param)
+
+    func.__signature__ = sig.replace(parameters=new_params)
+    return func
+
+
+def extract_values(kwargs: dict, field_names: list[str]) -> list:
+    """Extracts values from kwargs in the specified order.
+
+    :param kwargs: Dictionary containing the function arguments
+    :param field_names: List of field names in the desired order
+    :return: List of values in the same order as field_names
+    """
+    return [kwargs[field] for field in field_names]

{fast_controller-0.2.0b0 → fast_controller-0.3.0b0}/pyproject.toml

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

fast_controller-0.3.0b0/tests/test_util.py

@@ -0,0 +1,184 @@
+import inspect
+from unittest.mock import Mock
+
+from fast_controller import docstring_format
+from fast_controller.util import expose_path_params, extract_values
+
+
+@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"
+
+
+# TODO: Convert to labeled_tests
+def test_expose_path_params():
+    def test_func(**kwargs):
+        return kwargs
+
+    modified_func = expose_path_params(test_func, ["id"])
+    sig = inspect.signature(modified_func)
+
+    assert list(sig.parameters.keys()) == ["id"]
+
+
+def test_expose_path_params__multiple_params():
+    def test_func(**kwargs):
+        pass
+
+    modified_func = expose_path_params(test_func, ["field1", "field2", "field3"])
+    sig = inspect.signature(modified_func)
+
+    assert list(sig.parameters.keys()) == ["field1", "field2", "field3"]
+
+
+def test_expose_path_params__no_params():
+    def test_func(**kwargs):
+        pass
+
+    modified_func = expose_path_params(test_func, [])
+    sig = inspect.signature(modified_func)
+
+    assert list(sig.parameters.keys()) == []
+
+
+def test_expose_path_params__existing_params():
+    def test_func(model: str = "default_model", daos: Mock = Mock(), **kwargs):
+        pass
+
+    modified_func = expose_path_params(test_func, ["user_id", "role_id"])
+    sig = inspect.signature(modified_func)
+
+    assert list(sig.parameters.keys()) == ["user_id", "role_id", "model", "daos"]
+
+    assert sig.parameters["model"].annotation == str
+    assert sig.parameters["model"].default == "default_model"
+    assert sig.parameters["daos"].annotation == Mock
+    assert isinstance(sig.parameters["daos"].default, Mock)
+
+
+def test_expose_path_params__original_preserved():
+    def test_func(**kwargs):
+        return kwargs
+
+    modified_func = expose_path_params(test_func, ["field1"])
+
+    assert modified_func is test_func
+
+    result = test_func(field1="test_value")
+    assert result["field1"] == "test_value"
+
+
+def test_extract_values():
+    kwargs = {
+        "field1": "value1",
+        "field2": "value2",
+        "field3": "value3"
+    }
+    field_names = ["field1", "field2", "field3"]
+    expected = ["value1", "value2", "value3"]
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values___order():
+    kwargs = {
+        "field1": "value1",
+        "field2": "value2",
+        "field3": "value3"
+    }
+    field_names = ["field3", "field1", "field2"]
+    expected = ["value3", "value1", "value2"]
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values__single_field():
+    kwargs = {"id": "test_id"}
+    field_names = ["id"]
+
+    result = extract_values(kwargs, field_names)
+    assert result == ["test_id"]
+
+
+def test_extract_values__matching_values():
+    kwargs = {
+        "field1": "value",
+        "field2": "value"
+    }
+    field_names = ["field1", "field2"]
+    expected = ["value", "value"]
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values__duplicated_field():
+    kwargs = {
+        "field1": "value1",
+        "field2": "value2"
+    }
+    field_names = ["field1", "field1", "field2", "field1"]
+    expected = ["value1", "value1", "value2", "value1"]
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values__partial_extract():
+    kwargs = {
+        "field1": "value1",
+        "field2": "value2",
+        "extra1": "ignored",
+        "extra2": "ignored",
+    }
+    field_names = ["field1", "field2"]
+    expected = ["value1", "value2"]
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values__no_fields():
+    kwargs = {"field": "value"}
+    field_names = []
+    expected = []
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values__empty():
+    kwargs = {}
+    field_names = []
+    expected = []
+
+    assert extract_values(kwargs, field_names) == expected
+
+
+def test_extract_values__different_types():
+    kwargs = {
+        "string_field": "string_value",
+        "int_field": 123,
+        "bool_field": True,
+        "list_field": [1, 2, 3],
+        "none_field": None
+    }
+    field_names = ["string_field", "int_field", "bool_field", "list_field", "none_field"]
+    expected = ["string_value", 123, True, [1, 2, 3], None]
+
+    assert extract_values(kwargs, field_names) == expected

fast_controller-0.2.0b0/fast_controller/__init__.py

@@ -1,272 +0,0 @@
-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/util.py

@@ -1,36 +0,0 @@
-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.2.0b0/tests/test_util.py

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