vega-framework 0.2.2__tar.gz → 0.2.4__tar.gz

{vega_framework-0.2.2 → vega_framework-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vega-framework
-Version: 0.2.2
+Version: 0.2.4
 Summary: Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
 License: MIT
 License-File: LICENSE

{vega_framework-0.2.2 → vega_framework-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vega-framework"
-version = "0.2.2"
+version = "0.2.4"
 description = "Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications."
 authors = ["Roberto Ferro"]
 license = "MIT"
@@ -102,11 +102,7 @@ addopts = [
     "--cov-report=xml",
 ]
 # Filter warnings
-filterwarnings = [
-    "error",
-    "ignore::UserWarning",
-    "ignore::DeprecationWarning",
-]
+filterwarnings = ["error", "ignore::UserWarning", "ignore::DeprecationWarning"]
 
 [tool.ruff]
 line-length = 100

{vega_framework-0.2.2 → vega_framework-0.2.4}/vega/web/openapi.py

@@ -93,15 +93,9 @@ def get_openapi_schema(
                 operation["parameters"] = params
 
             # Analyze request body
-            request_body = _get_request_body(route)
+            request_body = _get_request_body(route, components)
             if request_body:
                 operation["requestBody"] = request_body
-                # Add request body schemas to components
-                if PYDANTIC_AVAILABLE and "content" in request_body:
-                    for content_type, content_schema in request_body["content"].items():
-                        if "schema" in content_schema and "$ref" in content_schema["schema"]:
-                            model_name = content_schema["schema"]["$ref"].split("/")[-1]
-                            # Model will be added when processing response_model
 
             # Analyze response model
             if route.response_model:
@@ -192,7 +186,7 @@ def _get_parameters(route: Any) -> List[Dict[str, Any]]:
     return parameters
 
 
-def _get_request_body(route: Any) -> Optional[Dict[str, Any]]:
+def _get_request_body(route: Any, components: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """Extract request body schema from route."""
     if not PYDANTIC_AVAILABLE:
         return None
@@ -212,9 +206,12 @@ def _get_request_body(route: Any) -> Optional[Dict[str, Any]]:
 
         # Check if it's a Pydantic model
         if param_type and isinstance(param_type, type) and issubclass(param_type, BaseModel):
-            model_schema = param_type.model_json_schema()
             model_name = param_type.__name__
 
+            # Add model schema to components
+            if model_name not in components["schemas"]:
+                components["schemas"][model_name] = param_type.model_json_schema()
+
             return {
                 "required": True,
                 "content": {

{vega_framework-0.2.2 → vega_framework-0.2.4}/vega/web/routing.py

@@ -6,6 +6,7 @@ from functools import wraps
 
 from starlette.routing import Route as StarletteRoute, Mount
 from starlette.requests import Request as StarletteRequest
+from pydantic import BaseModel, ValidationError
 
 from .exceptions import HTTPException
 from .request import Request
@@ -13,6 +14,14 @@ from .response import JSONResponse, Response, create_response
 from .route_middleware import MiddlewareChain
 
 
+def _is_pydantic_model(type_hint: Any) -> bool:
+    """Check if a type hint is a Pydantic BaseModel"""
+    try:
+        return inspect.isclass(type_hint) and issubclass(type_hint, BaseModel)
+    except (TypeError, AttributeError):
+        return False
+
+
 class Route:
     """
     Represents a single route in the application.
@@ -73,6 +82,12 @@ class Route:
                 sig = inspect.signature(self.endpoint)
                 params = sig.parameters
 
+                # Get type hints for the function
+                try:
+                    type_hints = get_type_hints(self.endpoint)
+                except Exception:
+                    type_hints = {}
+
                 # Prepare kwargs for function call
                 kwargs = {}
 
@@ -93,6 +108,37 @@ class Route:
                     if param_name in params:
                         kwargs[param_name] = param_value
 
+                # Check for Pydantic model parameters (body parsing)
+                # Only parse the first Pydantic model found
+                body_parsed = False
+                for param_name, param in params.items():
+                    # Skip if already processed (request or path param)
+                    if param_name in kwargs or param_name == "request":
+                        continue
+
+                    # Get type hint for this parameter
+                    param_type = type_hints.get(param_name, param.annotation)
+
+                    # If it's a Pydantic model, parse the request body (only once)
+                    if _is_pydantic_model(param_type) and not body_parsed:
+                        try:
+                            body_data = await request.json()
+                            # Validate and parse using Pydantic
+                            kwargs[param_name] = param_type(**body_data)
+                            body_parsed = True
+                        except ValidationError as e:
+                            # Return validation errors in a user-friendly format
+                            return JSONResponse(
+                                content={"detail": e.errors()},
+                                status_code=422,
+                            )
+                        except Exception as e:
+                            # Handle JSON parsing errors
+                            return JSONResponse(
+                                content={"detail": f"Invalid JSON body: {str(e)}"},
+                                status_code=400,
+                            )
+
                 # Execute middleware chain if present
                 if self.middlewares:
                     middleware_chain = MiddlewareChain(self.middlewares)
@@ -113,6 +159,9 @@ class Route:
                 # Handle different return types
                 if isinstance(result, (Response, JSONResponse)):
                     return result
+                elif isinstance(result, BaseModel):
+                    # Serialize Pydantic models using model_dump()
+                    return JSONResponse(content=result.model_dump(), status_code=self.status_code)
                 elif isinstance(result, dict):
                     return JSONResponse(content=result, status_code=self.status_code)
                 elif isinstance(result, (list, tuple)):