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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Fast-Controller
-Version: 0.4.0b0
+Version: 0.4.2b0
 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.4.0b0 → fast_controller-0.4.2b0}/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
+from fast_controller.util import docstring_format, InvalidInput, expose_path_params, extract_values, inflect, to_condition_operator
 
 
 class Action(Enum):
@@ -59,9 +59,13 @@ def _register_search_endpoint(controller, router: APIRouter, resource: type[Reso
                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),
+               x_order: Optional[str] = Header(default=None),
+               x_duplicate: Optional[str] = Header(default=None),  # TODO: move to filters
+               x_unique: Optional[str] = Header(default=None),  # TODO: move to filters
                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))
+        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)
         response.headers["x-total-count"] = str(results.total)
         response.headers["x-page"] = str(results.page)
         response.headers["x-per-page"] = str(results.per_page)
@@ -274,12 +278,15 @@ class Controller:
     def dependencies_for(self, resource: type[Resource], action: Action) -> list[Depends]:
         return []
 
+    def get_path_for(self, resource: type[Resource]) -> str:
+        return self.prefix + resource.get_resource_path()
+
     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(),
+            prefix=self.get_path_for(resource),
             tags=[resource.resource_name()])
         self._register_resource_endpoints(api_router, resource, skip)
         if additional_endpoints:

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

@@ -2,26 +2,26 @@ from inspect import isclass
 from typing import Any
 
 from daomodel import DAOModel
-from pydantic import create_model
+from pydantic import create_model, BaseModel
 from str_case_util import Case
 
 from fast_controller.util import inflect
 
 
-def either(preferred: Any, default: type[SQLModel]) -> type[SQLModel]:
+def either(preferred: Any, default: type[BaseModel]) -> type[BaseModel]:
     """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
+    return preferred if isclass(preferred) and issubclass(preferred, BaseModel) else default
 
 
 def get_field_type(field) -> type:
     """Returns the equivalent type for the given field.
 
-    :param field: The Column of an SQLModel
+    :param field: The Column of a model
     :return: the Python type used to represent the DB Column value
     """
     return getattr(field.type, 'impl', field.type).python_type
@@ -29,11 +29,11 @@ def get_field_type(field) -> type:
 
 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]
+    _default_schema: type[BaseModel]
+    _input_schema: type[BaseModel]
+    _update_schema: type[BaseModel]
+    _output_schema: type[BaseModel]
+    _detailed_output_schema: type[BaseModel]
 
     @classmethod
     def resource_name(cls):
@@ -60,8 +60,8 @@ class Resource(DAOModel):
         return True
 
     @classmethod
-    def get_search_schema(cls) -> type[SQLModel]:
-        """Returns an SQLModel representing the searchable fields"""
+    def get_search_schema(cls) -> type[BaseModel]:
+        """Returns a BaseModel representing the searchable fields"""
         def get_field_name(field) -> str:
             """Constructs the field's name, optionally prepending the table name."""
             field_name = field.name
@@ -78,53 +78,57 @@ class Resource(DAOModel):
         )
 
     @classmethod
-    def get_pk_schema(cls) -> type[SQLModel]:
-        """Returns an SQLModel representing the primary key fields"""
+    def get_pk_schema(cls) -> type[BaseModel]:
+        """Returns a BaseModel 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]:
+    def get_base(cls) -> type[BaseModel]:
         return cls
 
     @classmethod
-    def set_default_schema(cls, schema: type[SQLModel]) -> None:
+    def set_default_schema(cls, schema: type[BaseModel]) -> None:
         cls._default_schema = schema
 
     @classmethod
-    def get_default_schema(cls) -> type[SQLModel]:
+    def get_default_schema(cls) -> type[BaseModel]:
         return either(cls._default_schema, cls)
 
     @classmethod
-    def set_input_schema(cls, schema: type[SQLModel]) -> None:
+    def set_input_schema(cls, schema: type[BaseModel]) -> None:
         cls._input_schema = schema
 
     @classmethod
-    def get_input_schema(cls) -> type[SQLModel]:
+    def get_input_schema(cls) -> type[BaseModel]:
         return either(cls._input_schema, cls.get_default_schema())
 
     @classmethod
-    def set_update_schema(cls, schema: type[SQLModel]) -> None:
+    def set_update_schema(cls, schema: type[BaseModel]) -> None:
         cls._update_schema = schema
 
     @classmethod
-    def get_update_schema(cls) -> type[SQLModel]:
+    def get_update_schema(cls) -> type[BaseModel]:
         return either(cls._update_schema, cls.get_input_schema())
 
     @classmethod
-    def set_output_schema(cls, schema: type[SQLModel]) -> None:
+    def set_output_schema(cls, schema: type[BaseModel]) -> None:
         cls._output_schema = schema
 
     @classmethod
-    def get_output_schema(cls) -> type[SQLModel]:
+    def get_output_schema(cls) -> type[BaseModel]:
         return either(cls._output_schema, cls.get_default_schema())
 
     @classmethod
-    def set_detailed_output_schema(cls, schema: type[SQLModel]) -> None:
+    def set_detailed_output_schema(cls, schema: type[BaseModel]) -> None:
         cls._detailed_output_schema = schema
 
     @classmethod
-    def get_detailed_output_schema(cls) -> type[SQLModel]:
+    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.0b0 → fast_controller-0.4.2b0}/fast_controller/util.py

@@ -3,6 +3,7 @@ from typing import Callable, get_type_hints, Optional
 from warnings import deprecated
 
 import inflect as _inflect
+from daomodel.search_util import *
 from sqlmodel import SQLModel
 
 
@@ -79,3 +80,41 @@ def extract_values(kwargs: dict, field_names: list[str]) -> list:
     :return: List of values in the same order as field_names
     """
     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.
+
+    :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)

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

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

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

@@ -33,9 +33,9 @@ def test_either(preferred: Any, default: type[SQLModel], expected: type[SQLModel
 
 
 def test_get_path():
-    class C(Resource):
+    class Class(Resource):
         pass
-    assert C.get_resource_path() == "/api/c"
+    assert Class.get_resource_path() == "/api/classes"
 
 
 class Author(Resource, table=True):

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

@@ -1,8 +1,10 @@
 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
+from fast_controller.util import expose_path_params, extract_values, to_condition_operator
 
 
 @docstring_format(key="value")
@@ -182,3 +184,70 @@ 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"