formaxapi 0.1.8__py3-none-any.whl

routex/core/route_base.py

@@ -0,0 +1,70 @@
+"""RouteBase - Base class with schema generation."""
+
+from __future__ import annotations
+from typing import ClassVar
+from .metaclass import RouteMetaclass
+from .route_field import FieldInfo, RouteField
+from .field_config import FieldConfig
+from .model_factory import ModelFactory
+from .self_derived import SelfDerivedModel
+from pydantic import BaseModel
+
+
+class RouteBase(BaseModel,metaclass=RouteMetaclass):
+    """Base class. Routes defined inside with @route decorator.
+
+        class UserRoute(RouteBase):
+            name: str = RouteField(add=Add(), edit=Edit())
+
+            @route(path="/users", method="POST")
+            async def create_user(cls, request, data: UserRoute.schema("add")):
+                ...
+    """
+
+    _fields: ClassVar[dict[str, FieldInfo]] = {}
+    _schema_types: ClassVar[set[str]] = set()
+    _route_group: ClassVar[str] = ""
+
+    @classmethod
+    def schema(cls, schema_type: str, *, name: str | None = None,
+               include_fields: list[str] | None = None,
+               exclude_fields: list[str] | None = None,
+               forbid_extra: bool = True, as_literal: bool = False) -> type[BaseModel]:
+        """Generate a Pydantic model for the given schema type."""
+        if schema_type not in cls._schema_types:
+            raise ValueError(
+                f"Unknown schema type '{schema_type}'. Available: {sorted(cls._schema_types)}"
+            )
+        model_name = name or f"{cls.__name__}_{schema_type.title()}"
+        return ModelFactory.create(
+            fields=cls._fields, schema_type=schema_type,
+            model_name=model_name, forbid_extra=forbid_extra,
+            include_fields=include_fields, exclude_fields=exclude_fields,
+            as_literal=as_literal, route_cls=cls,
+        )
+
+    @classmethod
+    def schema_fields(cls, schema_type: str) -> list[str]:
+        return ModelFactory.field_names(cls._fields, schema_type)
+
+    @classmethod
+    def all_fields(cls) -> dict[str, FieldInfo]:
+        return dict(cls._fields)
+
+    @classmethod
+    def field_names(cls) -> list[str]:
+        return list(cls._fields.keys())
+
+    @classmethod
+    def schema_types(cls) -> list[str]:
+        return sorted(cls._schema_types)
+
+    @classmethod
+    def from_schema(cls, data):
+        """Create an instance from a schema model without re-validating nested models."""
+        return cls.model_validate(data, from_attributes=True)
+
+    @classmethod
+    def field_config_for(cls, field_name: str, schema_type: str) -> FieldConfig | None:
+        info = cls._fields.get(field_name)
+        return info.get_config(schema_type) if info else None

routex/core/route_decorator.py

@@ -0,0 +1,70 @@
+"""route decorator and route_factory."""
+
+from __future__ import annotations
+from typing import Callable, Literal
+from fastapi import APIRouter, status
+
+
+class _RouteInfo:
+    __slots__ = ('path', 'method', 'name', 'description', 'status_code', 'tags')
+
+    def __init__(self, path, method, name, description, status_code, tags):
+        self.path = path
+        self.method = method
+        self.name = name
+        self.description = description
+        self.status_code = status_code
+        self.tags = tags
+
+
+def route(
+    path: str,
+    method: Literal['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] = 'GET',
+    name: str | None = None,
+    description: str | None = None,
+    status_code: int = status.HTTP_200_OK,
+    tags: list[str] | None = None,
+) -> Callable:
+    """Decorator to mark a method as a route endpoint."""
+    def decorator(func: Callable) -> Callable:
+        func._route_info = _RouteInfo(
+            path=path, method=method,
+            name=name or func.__name__,
+            description=description,
+            status_code=status_code,
+            tags=tags or [],
+        )
+        return func
+    return decorator
+
+
+def route_factory(*route_classes: type) -> APIRouter:
+    """Collect all @route methods from Route classes into a FastAPI APIRouter."""
+    router = APIRouter()
+
+    for cls in route_classes:
+        default_tags = [getattr(cls, '_route_group', None) or cls.__name__]
+
+        for attr_name in dir(cls):
+            attr = getattr(cls, attr_name, None)
+            if attr is None:
+                continue
+
+            func = getattr(attr, '__func__', attr)
+            info = getattr(func, '_route_info', None)
+            if info is None:
+                continue
+
+            tags = info.tags if info.tags else default_tags
+
+            router.add_api_route(
+                path=info.path,
+                endpoint=attr,
+                methods=[info.method],
+                name=info.name,
+                description=info.description,
+                status_code=info.status_code,
+                tags=tags,
+            )
+
+    return router

routex/core/route_field.py

@@ -0,0 +1,135 @@
+"""RouteField and FieldInfo."""
+
+from __future__ import annotations
+from typing import Any, Callable
+from pydantic.fields import FieldInfo as PydanticFieldInfo
+from .field_config import FieldConfig, _UNSET
+
+
+# Pydantic FieldInfo attribute names (to separate from schema_configs)
+_PYDANTIC_FIELD_ATTRS = frozenset(PydanticFieldInfo.__slots__)
+
+
+class FieldInfo:
+    __slots__ = ('name', 'annotation', 'default', 'default_factory', 'configs',
+                 'db_field', 'alias', 'description', 'field_info_kwargs', 'metadata')
+
+    def __init__(self, name, annotation, default=_UNSET, default_factory=None,
+                 configs=None, db_field=None, alias=None, description=None,
+                 field_info_kwargs=None, metadata=None):
+        self.name = name
+        self.annotation = annotation
+        self.default = default
+        self.default_factory = default_factory
+        self.configs = configs or {}
+        self.db_field = db_field or alias or name
+        self.alias = alias
+        self.description = description
+        self.field_info_kwargs = field_info_kwargs or {}
+        self.metadata = metadata
+
+    def get_config(self, schema_type: str) -> FieldConfig | None:
+        return self.configs.get(schema_type)
+
+    def has_config(self, schema_type: str) -> bool:
+        return schema_type in self.configs
+
+
+class RouteField(PydanticFieldInfo):
+    """Declarative field with per-schema configs.
+
+    Inherits from Pydantic's FieldInfo, so it works in both RouteBase and BaseModel:
+
+        # In RouteBase — schema configs work
+        class UserRoute(RouteBase):
+            title: str = RouteField(add=Add(), edit=Edit())
+
+        # In BaseModel — Pydantic Field params work
+        class MyModel(BaseModel):
+            title: str = RouteField(alias="x", description="test")
+    """
+
+    def __init__(self, default: Any = _UNSET, *, default_factory: Callable | None = None,
+                 alias: str | None = None, validation_alias: str | None = None,
+                 serialization_alias: str | None = None,
+                 description: str | None = None, title: str | None = None,
+                 exclude: bool = False, frozen: bool = False,
+                 deprecated: str | None = None,
+                 json_schema_extra: dict | None = None,
+                 validate_default: bool = False,
+                 repr: bool = True,
+                 **kwargs: Any):
+        # Extract schema_configs (FieldConfig instances) from all kwargs
+        self.schema_configs = {k: v for k, v in kwargs.items() if isinstance(v, FieldConfig)}
+
+        # Build kwargs for Pydantic FieldInfo
+        # These are the params Pydantic FieldInfo stores as direct attributes
+        pydantic_kwargs = {}
+        if default is not _UNSET:
+            pydantic_kwargs['default'] = default
+        if default_factory is not None:
+            pydantic_kwargs['default_factory'] = default_factory
+        if alias is not None:
+            pydantic_kwargs['alias'] = alias
+        if validation_alias is not None:
+            pydantic_kwargs['validation_alias'] = validation_alias
+        if serialization_alias is not None:
+            pydantic_kwargs['serialization_alias'] = serialization_alias
+        if description is not None:
+            pydantic_kwargs['description'] = description
+        if title is not None:
+            pydantic_kwargs['title'] = title
+        if exclude:
+            pydantic_kwargs['exclude'] = exclude
+        if frozen:
+            pydantic_kwargs['frozen'] = frozen
+        if deprecated is not None:
+            pydantic_kwargs['deprecated'] = deprecated
+        if json_schema_extra is not None:
+            pydantic_kwargs['json_schema_extra'] = json_schema_extra
+        if validate_default:
+            pydantic_kwargs['validate_default'] = validate_default
+        if not repr:
+            pydantic_kwargs['repr'] = repr
+
+        # Pass constraint kwargs (min_length, max_length, gt, ge, lt, le, pattern, etc.)
+        # These are stored in metadata by Pydantic
+        for k, v in kwargs.items():
+            if k not in self.schema_configs and k not in pydantic_kwargs:
+                pydantic_kwargs[k] = v
+
+        super().__init__(**pydantic_kwargs)
+
+    def to_field_info(self, name: str, annotation: type) -> FieldInfo:
+        return FieldInfo(
+            name=name, annotation=annotation,
+            default=self.default, default_factory=self.default_factory,
+            configs=self.schema_configs,
+            alias=getattr(self, 'alias', None),
+            description=getattr(self, 'description', None),
+            field_info_kwargs=self._field_info_kwargs(),
+            metadata=self._constraint_kwargs(),
+        )
+
+    def _field_info_kwargs(self) -> dict:
+        kwargs = {}
+        # Only include public FieldInfo attributes, skip internal ones
+        _skip = {'_original_assignment', '_attributes_set', '_original_annotation',
+                 '_qualifiers', '_complete', '_final', 'metadata'}
+        for attr in _PYDANTIC_FIELD_ATTRS:
+            if attr in _skip:
+                continue
+            val = getattr(self, attr, None)
+            if val is not None and val is not False and val != []:
+                kwargs[attr] = val
+        return kwargs
+
+    def _constraint_kwargs(self) -> dict:
+        """Return constraint kwargs (max_length, min_length, gt, ge, lt, le, etc.) for Field()."""
+        constraints = {}
+        for item in (self.metadata or []):
+            for attr in ('max_length', 'min_length', 'gt', 'ge', 'lt', 'le',
+                         'multiple_of', 'pattern'):
+                if hasattr(item, attr):
+                    constraints[attr] = getattr(item, attr)
+        return constraints

routex/core/self_derived.py

@@ -0,0 +1,27 @@
+"""SelfDerivedModel - Derive a field's schema from the route's own fields."""
+
+from __future__ import annotations
+
+
+class SelfDerivedModel:
+    """Metadata for a field whose schema is derived from the route's own fields.
+
+        class UserRoute(RouteBase):
+            name: str = RouteField(add=Add(), edit=Edit())
+            items: list = RouteField(
+                bulk_add=BulkAddConfig(
+                    default=SelfDerivedModel(schema='add', exclude_fields=['email'])
+                )
+            )
+    """
+
+    def __init__(self, schema: str, is_optional: bool = True, format: str = 'model',
+                 include_fields: list[str] | None = None, exclude_fields: list[str] | None = None):
+        self.schema = schema
+        self.is_optional = is_optional
+        self.format = format
+        self.include_fields = include_fields
+        self.exclude_fields = exclude_fields
+
+    def __repr__(self):
+        return f"SelfDerivedModel(schema={self.schema!r}, include={self.include_fields}, exclude={self.exclude_fields})"