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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Fast-Controller
-Version: 0.0.0.dev2
+Version: 0.1.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.0.0.dev2 → fast_controller-0.1.0b0}/fast_controller/__init__.py

@@ -5,11 +5,11 @@ 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 import FastAPI, APIRouter, Depends, Path, Body, Query, Header
 from fastapi.openapi.models import Response
 
 from fast_controller.resource import Resource
-from fast_controller.util import docstring_format, paginated
+from fast_controller.util import docstring_format
 
 
 SessionLocal = create_engine()
@@ -42,7 +42,8 @@ class Controller:
             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())
+        api_router = APIRouter(prefix=prefix if prefix else resource.get_resource_path(),
+                               tags=[resource.doc_name()] if resource else None)
         if resource:
             cls.__register_resource_endpoints(api_router, resource, skip)
         return api_router
@@ -51,21 +52,26 @@ class Controller:
             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()])
+        api_router = APIRouter(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.app.include_router(api_router)
 
     @classmethod
-    def __register_resource_endpoints(cls, router: APIRouter, resource: type[Resource], skip) -> None:
+    def __register_resource_endpoints(cls,
+            router: APIRouter,
+            resource: type[Resource],
+            skip: Optional[set[Action]] = None) -> None:
+        if skip is None:
+            skip = set()
         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()],
+                       filters: Annotated[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 = Depends(get_daos)) -> list[DAOModel]:
                 """Searches for {resource} by criteria"""
                 results = daos[resource].find(**filters.model_dump())

{fast_controller-0.0.0.dev2 → fast_controller-0.1.0b0}/fast_controller/resource.py

@@ -1,11 +1,18 @@
 from inspect import isclass
-from typing import ClassVar
+from typing import Any
 
 from daomodel import DAOModel
 from sqlmodel import SQLModel
 
 
-def either(preferred, default):
+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
 
 
@@ -17,11 +24,16 @@ class Resource(DAOModel):
     _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())
+    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):
@@ -37,7 +49,7 @@ class Resource(DAOModel):
 
     @classmethod
     def get_default_schema(cls) -> type[SQLModel]:
-        return cls._default_schema
+        return either(cls._default_schema, cls)
 
     @classmethod
     def set_search_schema(cls, schema: type[SQLModel]) -> None:
@@ -61,7 +73,7 @@ class Resource(DAOModel):
 
     @classmethod
     def get_update_schema(cls) -> type[SQLModel]:
-        return either(cls._update_schema, cls.get_default_schema())
+        return either(cls._update_schema, cls.get_input_schema())
 
     @classmethod
     def set_output_schema(cls, schema: type[SQLModel]) -> None:

fast_controller-0.1.0b0/fast_controller/util.py

@@ -0,0 +1,30 @@
+from typing import Callable, get_type_hints, Optional
+
+from sqlmodel import SQLModel
+
+
+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.1.0b0}/pyproject.toml

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

fast_controller-0.1.0b0/tests/test_resource.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+import pytest
+from daomodel import DAOModel
+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"
+
+
+# TODO - Not convinced on this design for schema definitions
+def test_get_base_and_schemas():
+    pass

fast_controller-0.1.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/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