Draft refactoring. Added form\file processing

Author: mr-fatalyst

README.md

@@ -13,7 +13,7 @@
 <p align="center">
   <img src="https://img.shields.io/github/license/mr-fatalyst/fastopenapi">
   <img src="https://github.com/mr-fatalyst/fastopenapi/actions/workflows/master.yml/badge.svg">
-  <img src="https://codecov.io/gh/mr-fatalyst/fastopenapi/branch/master/graph/badge.svg?token=USHR1I0CJB">
+  <img src="https://codecov.io/gh/mr-fatalyst/fastopenapi/branch/master/graph/badge.svg">
   <img src="https://img.shields.io/pypi/v/fastopenapi">
   <img src="https://img.shields.io/pypi/pyversions/fastopenapi">
   <img src="https://static.pepy.tech/badge/fastopenapi" alt="PyPI Downloads">

fastopenapi/core/__init__.py

@@ -4,6 +4,6 @@
     Header,
 )
 from fastopenapi.core.router import BaseRouter
-from fastopenapi.core.types import Response
+from fastopenapi.core.types import FileUpload, Response
 
-__all__ = ["BaseRouter", "Header", "Cookie", "Form", "Response"]
+__all__ = ["BaseRouter", "Header", "Cookie", "Form", "Response", "FileUpload"]

fastopenapi/core/types.py

@@ -1,6 +1,63 @@
+import inspect
 from typing import Any
 
 
+class FileUpload:
+    """Unified file upload container with framework-agnostic API"""
+
+    __slots__ = ("filename", "content_type", "size", "_file")
+
+    def __init__(
+        self,
+        filename: str,
+        content_type: str | None = None,
+        size: int | None = None,
+        file: Any = None,
+    ):
+        self.filename = filename
+        self.content_type = content_type or "application/octet-stream"
+        self.size = size
+        self._file = file
+
+    @property
+    def file(self) -> Any:
+        """Access native framework file object"""
+        return self._file
+
+    def read(self) -> bytes:
+        """Read entire file content (sync frameworks)"""
+        if isinstance(self._file, bytes):
+            return self._file
+        if hasattr(self._file, "read"):
+            result = self._file.read()
+            if isinstance(result, bytes):
+                return result
+            return result.encode("utf-8") if isinstance(result, str) else result
+        raise NotImplementedError("File object does not support synchronous read")
+
+    async def aread(self) -> bytes:
+        """Read entire file content (async frameworks)"""
+        if isinstance(self._file, bytes):
+            return self._file
+        if hasattr(self._file, "read"):
+            result = self._file.read()
+            if inspect.iscoroutine(result):
+                data = await result
+                if isinstance(data, bytes):
+                    return data
+                return data.encode("utf-8") if isinstance(data, str) else data
+            if isinstance(result, bytes):
+                return result
+            return result.encode("utf-8") if isinstance(result, str) else result
+        raise NotImplementedError("File object does not support read")
+
+    def __repr__(self) -> str:
+        return (
+            f"FileUpload(filename={self.filename!r}, "
+            f"content_type={self.content_type!r}, size={self.size})"
+        )
+
+
 class Response:
     """Custom response with headers"""
 
@@ -26,7 +83,7 @@ def __init__(
         cookies: dict[str, str] = None,
         body: Any = None,
         form_data: dict[str, Any] = None,
-        files: dict[str, bytes] = None,
+        files: dict[str, FileUpload | list[FileUpload]] = None,
     ):
         self.path_params = path_params or {}
         self.query_params = query_params or {}

fastopenapi/response/builder.py

@@ -40,9 +40,9 @@ def build(cls, result: Any, meta: dict) -> Response:
     def _serialize(cls, data: Any) -> Any:
         """Serialize response data"""
         if isinstance(data, BaseModel):
-            return data.model_dump(by_alias=True)
+            return data.model_dump(by_alias=True, mode="json")
         if isinstance(data, list) and data and isinstance(data[0], BaseModel):
-            return [item.model_dump(by_alias=True) for item in data]
+            return [item.model_dump(by_alias=True, mode="json") for item in data]
         if isinstance(data, list):
             return [cls._serialize(item) for item in data]
         if isinstance(data, dict):

fastopenapi/routers/aiohttp/async_router.py

@@ -34,6 +34,28 @@ async def _aiohttp_view(request: web.Request, router, endpoint: Callable):
 
     def build_framework_response(self, response: Response) -> web.Response:
         """Build AioHttp response"""
+        content_type = response.headers.get("Content-Type", "application/json")
+
+        # Binary content
+        if isinstance(response.content, bytes):
+            return web.Response(
+                body=response.content,
+                status=response.status_code,
+                headers={**response.headers, "Content-Type": content_type},
+            )
+
+        # String non-JSON content (CSV, XML, plain text, etc.)
+        if isinstance(response.content, str) and content_type not in [
+            "application/json",
+            "text/json",
+        ]:
+            return web.Response(
+                text=response.content,
+                status=response.status_code,
+                headers={**response.headers, "Content-Type": content_type},
+            )
+
+        # JSON content (dict, list, None)
         return web.json_response(
             response.content, status=response.status_code, headers=response.headers
         )

fastopenapi/routers/aiohttp/extractors.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from fastopenapi.core.types import FileUpload
 from fastopenapi.routers.extractors import BaseAsyncRequestDataExtractor
 
 
@@ -42,15 +43,53 @@ async def _get_body(cls, request: Any) -> dict | list | None:
     async def _get_form_data(cls, request: Any) -> dict:
         """Extract form data"""
         form_data = {}
+        content_type = request.content_type or ""
 
-        if request.content_type == "multipart/form-data":
+        if content_type == "application/x-www-form-urlencoded":
+            post_data = await request.post()
+            for key in post_data:
+                values = (
+                    post_data.getall(key)
+                    if hasattr(post_data, "getall")
+                    else [post_data[key]]
+                )
+                form_data[key] = values[0] if len(values) == 1 else values
+
+        elif content_type == "multipart/form-data":
             reader = await request.multipart()
             async for part in reader:
+                if part.filename:
+                    continue  # Files handled separately
                 form_data[part.name] = await part.text()
 
         return form_data
 
     @classmethod
-    async def _get_files(cls, request: Any) -> dict[str, bytes]:
+    async def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
         """Extract files from AioHTTP request"""
-        return {}
+        files = {}
+        content_type = request.content_type or ""
+
+        if content_type == "multipart/form-data":
+            reader = await request.multipart()
+            async for part in reader:
+                if not part.filename:
+                    continue
+
+                file_data = await part.read()
+                file_upload = FileUpload(
+                    filename=part.filename,
+                    content_type=part.headers.get("Content-Type"),
+                    size=len(file_data),
+                    file=file_data,
+                )
+
+                if part.name in files:
+                    if isinstance(files[part.name], list):
+                        files[part.name].append(file_upload)
+                    else:
+                        files[part.name] = [files[part.name], file_upload]
+                else:
+                    files[part.name] = file_upload
+
+        return files

fastopenapi/routers/django/extractors.py

@@ -2,6 +2,7 @@
 
 from pydantic_core import from_json
 
+from fastopenapi.core.types import FileUpload
 from fastopenapi.routers.extractors import (
     BaseAsyncRequestDataExtractor,
     BaseRequestDataExtractor,
@@ -54,9 +55,23 @@ def _get_form_data(cls, request: Any) -> dict:
         return {}
 
     @classmethod
-    def _get_files(cls, request: Any) -> dict:
-        """Extract files"""
-        return {}
+    def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
+        """Extract files from Django request"""
+        files = {}
+        if hasattr(request, "FILES"):
+            for key in request.FILES.keys():
+                file_list = request.FILES.getlist(key)
+                uploads = []
+                for uploaded_file in file_list:
+                    file_upload = FileUpload(
+                        filename=uploaded_file.name,
+                        content_type=uploaded_file.content_type,
+                        size=uploaded_file.size,
+                        file=uploaded_file,
+                    )
+                    uploads.append(file_upload)
+                files[key] = uploads[0] if len(uploads) == 1 else uploads
+        return files
 
 
 class DjangoAsyncRequestDataExtractor(
@@ -74,6 +89,6 @@ async def _get_form_data(cls, request: Any) -> dict:
         return super()._get_form_data(request)
 
     @classmethod
-    async def _get_files(cls, request: Any) -> dict:
+    async def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
         """Extract files"""
         return super()._get_files(request)

fastopenapi/routers/django/sync_router.py

@@ -70,8 +70,26 @@ def handle(self, req, **path_params):  # pragma: no cover
 
     def build_framework_response(self, response: Response) -> HttpResponse:
         """Build Django response"""
-        if response.content is None:
-            http_response = HttpResponse(status=response.status_code)
+        content_type = response.headers.get("Content-Type", "application/json")
+
+        # Binary content
+        if isinstance(response.content, bytes):
+            http_response = HttpResponse(
+                content=response.content,
+                status=response.status_code,
+                content_type=content_type,
+            )
+        # String non-JSON content
+        elif isinstance(response.content, str) and content_type not in [
+            "application/json",
+            "text/json",
+        ]:
+            http_response = HttpResponse(
+                content=response.content,
+                status=response.status_code,
+                content_type=content_type,
+            )
+        # JSON content
         else:
             http_response = HttpResponse(
                 content=to_json(response.content).decode("utf-8"),
@@ -80,7 +98,8 @@ def build_framework_response(self, response: Response) -> HttpResponse:
             )
 
         for key, value in response.headers.items():
-            http_response[key] = value
+            if key.lower() != "content-type":
+                http_response[key] = value
 
         return http_response
 

fastopenapi/routers/extractors.py

@@ -3,7 +3,7 @@
 
 from pydantic_core import from_json
 
-from fastopenapi.core.types import RequestData
+from fastopenapi.core.types import FileUpload, RequestData
 from fastopenapi.routers.common import RequestEnvelope
 
 
@@ -42,7 +42,7 @@ def _get_form_data(cls, request: Any) -> dict:
 
     @classmethod
     @abstractmethod
-    def _get_files(cls, request: Any) -> dict:
+    def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
         """Extract files"""
 
     @staticmethod
@@ -97,7 +97,7 @@ async def _get_form_data(cls, request: Any) -> dict:
 
     @classmethod
     @abstractmethod
-    async def _get_files(cls, request: Any) -> dict:
+    async def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
         """Extract files"""
 
     @classmethod

fastopenapi/routers/falcon/extractors.py

@@ -2,6 +2,7 @@
 
 from pydantic_core import from_json
 
+from fastopenapi.core.types import FileUpload
 from fastopenapi.routers.extractors import (
     BaseAsyncRequestDataExtractor,
     BaseRequestDataExtractor,
@@ -52,17 +53,46 @@ def _get_body(cls, request: Any) -> dict | list | None:
     @classmethod
     def _get_form_data(cls, request: Any) -> dict:
         """Extract form data"""
-        return {}
+        form_data = {}
+        ct = (request.content_type or "").lower()
+
+        if ct == "application/x-www-form-urlencoded":
+            form_data = request.media or {}
+
+        return form_data
 
     @classmethod
-    def _get_files(cls, request: Any) -> dict:
-        """Extract files"""
+    def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
+        """Extract files from Falcon request (sync)"""
         files = {}
-        if hasattr(request, "files"):
-            for name, file in request.files.items():
-                # Read file content into temporary file
-                content = file.stream.read()
-                files[name] = content
+        ct = (request.content_type or "").lower()
+
+        if "multipart/form-data" in ct and hasattr(request, "get_media"):
+            form = request.get_media()
+            for part in form:
+                filename = getattr(part, "secure_filename", None) or getattr(
+                    part, "filename", None
+                )
+                if not filename:
+                    continue
+
+                content = part.stream.read()
+                file_upload = FileUpload(
+                    filename=filename,
+                    content_type=getattr(part, "content_type", None),
+                    size=len(content),
+                    file=content,
+                )
+
+                field_name = getattr(part, "name", filename)
+                if field_name in files:
+                    if isinstance(files[field_name], list):
+                        files[field_name].append(file_upload)
+                    else:
+                        files[field_name] = [files[field_name], file_upload]
+                else:
+                    files[field_name] = file_upload
+
         return files
 
 
@@ -89,6 +119,6 @@ async def _get_form_data(cls, request: Any) -> dict:
         return super()._get_form_data(request)
 
     @classmethod
-    async def _get_files(cls, request: Any) -> dict:
+    async def _get_files(cls, request: Any) -> dict[str, FileUpload | list[FileUpload]]:
         """Extract files"""
         return super()._get_files(request)