Fast-Controller 0.4.2b0__tar.gz → 0.4.4b0__tar.gz

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Fast-Controller
-Version: 0.4.2b0
+Version: 0.4.4b0
 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>
@@ -25,6 +25,7 @@ Requires-Dist: fastapi
 Requires-Dist: daomodel
 Requires-Dist: SQLModel
 Requires-Dist: inflect
+Requires-Dist: str-case-util
 Description-Content-Type: text/markdown
 
 # Fast-Controller

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/fast_controller/__init__.py

@@ -14,7 +14,7 @@ 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, inflect, to_condition_operator
+from fast_controller.util import docstring_format, InvalidInput, expose_path_params, extract_values, inflect
 
 
 class Action(Enum):
@@ -64,8 +64,8 @@ def _register_search_endpoint(controller, router: APIRouter, resource: type[Reso
                x_unique: Optional[str] = Header(default=None),  # TODO: move to filters
                daos: DAOFactory = controller.daos) -> list[DAOModel]:
         """Searches for {resource} by criteria"""
-        filters = {col: to_condition_operator(val) for col, val in filters.model_dump(exclude_unset=True)}
-        results = daos[resource].find(x_page, x_per_page, x_order, x_duplicate, x_unique, **filters)
+        provided_filters = filters.model_dump(exclude_unset=True)
+        results = daos[resource].find(x_page, x_per_page, x_order, x_duplicate, x_unique, **provided_filters)
         response.headers["x-total-count"] = str(results.total)
         response.headers["x-page"] = str(results.page)
         response.headers["x-per-page"] = str(results.per_page)

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/fast_controller/resource.py

@@ -2,6 +2,7 @@ from inspect import isclass
 from typing import Any
 
 from daomodel import DAOModel
+from daomodel.search_util import ConditionOperator
 from pydantic import create_model, BaseModel
 from str_case_util import Case
 
@@ -70,7 +71,7 @@ class Resource(DAOModel):
             return field_name
         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
+            get_field_name(field): (ConditionOperator[get_field_type(field)], None) for field in fields
         }
         return create_model(
             f'{cls.doc_name()}SearchSchema',
@@ -128,7 +129,3 @@ class Resource(DAOModel):
     @classmethod
     def get_detailed_output_schema(cls) -> type[BaseModel]:
         return either(cls._detailed_output_schema, cls.get_output_schema())
-
-
-class Schema(BaseModel):
-    pass

fast_controller-0.4.4b0/fast_controller/schema.py

@@ -0,0 +1,113 @@
+from typing import Mapping
+
+from daomodel import DAOModel
+from str_case_util import Case
+
+from fast_controller import Resource
+
+
+class Schema(DAOModel):
+    """Base class for schemas, to act as a label."""
+    pass
+
+
+def schemas(**kwargs):
+    """Applies multiple schema decorators at once.
+
+    Example:
+        class UserInput(Schema):
+            name: Identifier[str]
+            email: Optional[str]
+            password: str
+
+        @schemas(
+            input=UserInput,
+            detailed_output={
+                'name': str,
+                'email': Optional[str],
+                'last_seen': datetime
+            }
+        )
+        class User(Resource):
+            ...
+
+    Each keyword corresponds to a schema role:
+        default, input, update, output, detailed_output
+
+    Values may be:
+        - A Schema subclass
+        - An inline schema definition: {field_name: type}
+
+    Raises: AttributeError if applied to a class that does not define the
+        expected setter method (e.g., not a Resource subclass or invalid schema role).
+    """
+    def decorator(cls):
+        for schema_role, schema in kwargs.items():
+            setter_name = f'set_{schema_role}_schema'
+            if not hasattr(cls, setter_name):
+                raise AttributeError(
+                    f'{cls.__name__} does not support schema role "{schema_role}". '
+                    f'Expected one of: default, input, update, output, detailed_output.'
+                )
+            decorator_fn = _schema_decorator_factory(schema_role)
+            cls = decorator_fn(schema)(cls)
+        return cls
+    return decorator
+
+
+InlineSchema = Mapping[str, type]
+
+
+def _resolve_schema(schema: type[Schema]|InlineSchema, resource: type[Resource], suffix: str) -> type[Schema]:
+    if isinstance(schema, Mapping):
+        fields = {name: typ for name, typ in schema.items()}
+        schema = type(
+            f'{resource.__name__}{suffix}',
+            (Schema,),
+            {
+                '__annotations__': fields,
+                '__module__': resource.__module__,
+            }
+        )
+    return schema
+
+
+def _schema_decorator_factory(schema_role: str):
+    setter_name = f"set_{schema_role}_schema"
+    suffix = Case.CAPITAL_CAMEL_CASE.format(schema_role)
+
+    def decorator(schema=None, **inline_fields):
+        if inline_fields:
+            if schema is not None:
+                raise TypeError(
+                    f"Schema decorator for role '{schema_role}' received both "
+                    f"a schema argument and inline fields. Use one or the other."
+                )
+            schema = inline_fields
+
+        if schema is None:
+            raise TypeError(
+                f"Schema decorator for role '{schema_role}' requires either "
+                f"a Schema subclass or inline field definitions."
+            )
+
+        def wrapper(cls):
+            if not hasattr(cls, setter_name):
+                raise AttributeError(
+                    f'Cannot apply schema role "{schema_role}" to {cls.__name__}. '
+                    f'This decorator may only be used on Resource subclasses. '
+                    f'Expected method "{setter_name}" to exist.'
+                )
+            setter = getattr(cls, setter_name)
+            setter(_resolve_schema(schema, cls, suffix))
+            return cls
+
+        return wrapper
+    return decorator
+
+
+default_schema = _schema_decorator_factory('default')
+input_schema = _schema_decorator_factory('input')
+update_schema = _schema_decorator_factory('update')
+output_schema = _schema_decorator_factory('output')
+detailed_output_schema = _schema_decorator_factory('detailed_output')

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/fast_controller/util.py

@@ -1,9 +1,11 @@
 import inspect
-from typing import Callable, get_type_hints, Optional
+from functools import wraps
+from typing import Callable, get_type_hints
 from warnings import deprecated
 
 import inflect as _inflect
 from daomodel.search_util import *
+from fastapi import Response
 from sqlmodel import SQLModel
 
 
@@ -82,39 +84,28 @@ def extract_values(kwargs: dict, field_names: list[str]) -> list:
     return [kwargs[field] for field in field_names]
 
 
-def to_condition_operator(value: str) -> ConditionOperator:
-    """Maps a value with a potential operator prefix (e.g. 'lt:', 'contains:') to a ConditionOperator.
+def cache_control(value: str):
+    def decorator(func):
+        if inspect.iscoroutinefunction(func):
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                response = await func(*args, **kwargs)
+                if isinstance(response, Response):
+                    response.headers['Cache-Control'] = value
+                return response
+            return wrapper
+        else:
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                response = func(*args, **kwargs)
+                if isinstance(response, Response):
+                    response.headers['Cache-Control'] = value
+                return response
+            return wrapper
 
-    :param value: The query value with optional operator prefix
-    :return: The ConditionOperator defined by the prefix
-    """
-    op, part = None, None
-    if ':' in value:
-        op, value = value.split(':', 1)
-        if '_' in op:
-            part, op = op.split('_', 1)
-    match op:  # TODO: support contains, starts, and ends
-        case 'lt':
-            return LessThan(value, _part=part)
-        case 'le':
-            return LessThanEqualTo(value, _part=part)
-        case 'gt':
-            return GreaterThan(value, _part=part)
-        case 'ge':
-            return GreaterThanEqualTo(value, _part=part)
-        case 'between':
-            return Between(*value.split('|', 1), _part=part)
-        case 'anyof':
-            return AnyOf(*value.split('|'), _part=part)
-        case 'noneof':
-            return NoneOf(*value.split('|'), _part=part)
-        case 'is':
-            match value:
-                case 'set':
-                    return IsSet()
-                case 'notset':
-                    return NotSet()
-                case _:
-                    return Equals(value, _part=part)
-        case _:
-            return Equals(value, _part=part)
+    return decorator
+
+
+immutable = cache_control('public, max-age=31536000, immutable')
+no_cache = cache_control('no-store')
+cache_1h = cache_control('public, max-age=3600')

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/pyproject.toml

@@ -25,6 +25,7 @@ dependencies = [
     "daomodel",
     "SQLModel",
     "inflect",
+    "str-case-util",
 ]
 classifiers = [
     "License :: OSI Approved :: MIT License",
@@ -41,7 +42,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries",
     "Typing :: Typed",
 ]
-version = "0.4.2b0"
+version = "0.4.4b0"
 
 [project.license]
 text = "MIT"

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/tests/test_resource.py

@@ -4,6 +4,7 @@ from typing import Any, Optional
 import pytest
 from daomodel import DAOModel
 from daomodel.fields import Unsearchable, Identifier, ReferenceTo
+from daomodel.search_util import ConditionOperator
 from sqlmodel import SQLModel
 
 from fast_controller import Resource, Controller
@@ -68,15 +69,14 @@ 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
+        name: ConditionOperator[str]
+        book_title: ConditionOperator[str]
+        book_page_count: ConditionOperator[int]
+        book_publication_date: ConditionOperator[datetime]
+        author_name: ConditionOperator[str]
+        author_active: ConditionOperator[bool]
+    assert {k: str(v.annotation) for k, v in actual.model_fields.items()} == \
+           {k: str(v.annotation) for k, v in Expected.model_fields.items()}
 
 
 # TODO - Not convinced on this design for schema definitions

{fast_controller-0.4.2b0 → fast_controller-0.4.4b0}/tests/test_util.py

@@ -1,10 +1,8 @@
 import inspect
 from unittest.mock import Mock
 
-from daomodel.search_util import *
-
 from fast_controller import docstring_format
-from fast_controller.util import expose_path_params, extract_values, to_condition_operator
+from fast_controller.util import expose_path_params, extract_values
 
 
 @docstring_format(key="value")
@@ -184,70 +182,3 @@ def test_extract_values__different_types():
     expected = ["string_value", 123, True, [1, 2, 3], None]
 
     assert extract_values(kwargs, field_names) == expected
-
-
-def test_to_condition_operator__equals():
-    op = to_condition_operator("value")
-    assert isinstance(op, Equals)
-    assert op.values == ("value",)
-
-    op = to_condition_operator("is:value")
-    assert isinstance(op, Equals)
-    assert op.values == ("value",)
-
-
-def test_to_condition_operator__lt():
-    op = to_condition_operator("lt:5")
-    assert isinstance(op, LessThan)
-    assert op.values == ("5",)
-
-
-def test_to_condition_operator__le():
-    op = to_condition_operator("le:5")
-    assert isinstance(op, LessThanEqualTo)
-    assert op.values == ("5",)
-
-
-def test_to_condition_operator__gt():
-    op = to_condition_operator("gt:5")
-    assert isinstance(op, GreaterThan)
-    assert op.values == ("5",)
-
-
-def test_to_condition_operator__ge():
-    op = to_condition_operator("ge:5")
-    assert isinstance(op, GreaterThanEqualTo)
-    assert op.values == ("5",)
-
-
-def test_to_condition_operator__between():
-    op = to_condition_operator("between:1|5")
-    assert isinstance(op, Between)
-    assert op.values == ("1", "5")
-
-
-def test_to_condition_operator__anyof():
-    op = to_condition_operator("anyof:1|2|3")
-    assert isinstance(op, AnyOf)
-    assert op.values == ("1", "2", "3")
-
-
-def test_to_condition_operator__noneof():
-    op = to_condition_operator("noneof:1|2|3")
-    assert isinstance(op, NoneOf)
-    assert op.values == ("1", "2", "3")
-
-
-def test_to_condition_operator__isset():
-    assert isinstance(to_condition_operator("is:set"), IsSet)
-
-
-def test_to_condition_operator__notset():
-    assert isinstance(to_condition_operator("is:notset"), NotSet)
-
-
-def test_to_condition_operator__part():
-    op = to_condition_operator("part_is:value")
-    assert isinstance(op, Equals)
-    assert op.values == ("value",)
-    assert op.part == "part"