/procesador listo

.gitignore

@@ -0,0 +1,136 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Project specific
+*.db
+tmp/
+logs/

Dockerfile

@@ -0,0 +1,15 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,53 @@
+"""
+FastAPI application for API Blackbox.
+"""
+
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+
+from routers.procesador import router as procesador_router
+
+app = FastAPI(
+    title="API Blackbox",
+    description="Blackbox API service",
+    version="1.0.0",
+)
+
+app.include_router(procesador_router)
+
+
+@app.get("/health")
+async def health_check():
+    """
+    Health check endpoint.
+    
+    Returns:
+        dict: Status of the application
+    """
+    return JSONResponse(
+        status_code=200,
+        content={
+            "status": "healthy",
+            "message": "API is running"
+        }
+    )
+
+
+@app.get("/")
+async def root():
+    """
+    Root endpoint.
+    
+    Returns:
+        dict: Welcome message
+    """
+    return {
+        "message": "Welcome to API Blackbox",
+        "docs": "/docs",
+        "redoc": "/redoc"
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+pydantic
+pydantic-settings
+fastapi[standard]
+httpx

routers/procesador.py

@@ -0,0 +1,143 @@
+import base64
+import json
+
+import httpx
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+from fastapi.responses import Response
+
+from schemas import ProcessorManifest
+
+router = APIRouter()
+
+
+def _resolve_url(url: str, path_params: dict[str, str] | None) -> str:
+    """Replace {placeholder} in URL with path_params values."""
+    if not path_params:
+        return url
+    for key, value in path_params.items():
+        url = url.replace(f"{{{key}}}", str(value))
+    return url
+
+
+def _resolve_files(
+    manifest_files: list | None, files_map: dict[str, bytes]
+) -> dict[str, tuple[str, bytes]]:
+    """Build a dict of field_name -> (filename, bytes) from manifest files list."""
+    if not manifest_files:
+        return {}
+    resolved = {}
+    for f in manifest_files:
+        if f.filename not in files_map:
+            raise HTTPException(
+                status_code=400,
+                detail=f"File '{f.filename}' referenced in manifest but not uploaded in items",
+            )
+        resolved[f.field_name] = (f.filename, files_map[f.filename])
+    return resolved
+
+
+def _build_json_body(body: dict, file_refs: dict[str, tuple[str, bytes]]) -> dict:
+    """Build a JSON body. File fields get base64-encoded."""
+    result = dict(body)
+    for field_name, (filename, file_bytes) in file_refs.items():
+        result[field_name] = base64.b64encode(file_bytes).decode("utf-8")
+    return result
+
+
+def _build_form_body(body: dict, file_refs: dict[str, tuple[str, bytes]]) -> dict[str, str]:
+    """Build a form-urlencoded body (text fields only)."""
+    if file_refs:
+        raise HTTPException(
+            status_code=400,
+            detail="body_type 'form' does not support file fields. Use 'multipart' or 'json'.",
+        )
+    return {k: str(v) for k, v in body.items()}
+
+
+def _build_multipart(
+    body: dict, file_refs: dict[str, tuple[str, bytes]]
+) -> tuple[dict[str, str], list[tuple[str, tuple[str, bytes]]]]:
+    """Build multipart data and files lists."""
+    data = {k: str(v) for k, v in body.items()}
+    files = []
+    for field_name, (filename, file_bytes) in file_refs.items():
+        data.pop(field_name, None)
+        files.append((field_name, (filename, file_bytes)))
+    return data, files
+
+
+@router.post("/procesador")
+async def procesador(
+    manifest: str = Form(..., description="JSON manifest with url, method, headers, body_type, body, etc."),
+    items: list[UploadFile] = File(default=[], description="Optional files referenced in manifest.files"),
+):
+    # Parse and validate manifest
+    try:
+        manifest_data = json.loads(manifest)
+    except json.JSONDecodeError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid JSON in manifest: {e}")
+
+    try:
+        m = ProcessorManifest(**manifest_data)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid manifest: {e}")
+
+    if m.body_type not in ("json", "form", "multipart"):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid body_type '{m.body_type}'. Must be 'json', 'form', or 'multipart'.",
+        )
+
+    # Read uploaded files into memory: filename -> bytes
+    files_map: dict[str, bytes] = {}
+    for item in items:
+        content = await item.read()
+        files_map[item.filename] = content
+
+    # Resolve path params in URL
+    url = _resolve_url(m.url, m.path_params)
+
+    # Resolve file references
+    file_refs = _resolve_files(m.files, files_map)
+
+    # Build the outgoing request
+    method = m.method.upper()
+    headers = m.headers or {}
+    params = m.query_params or {}
+    body = m.body or {}
+
+    request_kwargs: dict = {
+        "method": method,
+        "url": url,
+        "headers": headers,
+        "params": params,
+    }
+
+    if body or file_refs:
+        if m.body_type == "json":
+            request_kwargs["json"] = _build_json_body(body, file_refs)
+        elif m.body_type == "form":
+            request_kwargs["data"] = _build_form_body(body, file_refs)
+        elif m.body_type == "multipart":
+            data, files = _build_multipart(body, file_refs)
+            request_kwargs["data"] = data
+            if files:
+                request_kwargs["files"] = files
+
+    # Execute the request to the target API
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            response = await client.request(**request_kwargs)
+    except httpx.RequestError as e:
+        raise HTTPException(
+            status_code=502,
+            detail=f"Error calling target API: {e}",
+        )
+
+    # Return the target API's response
+    return Response(
+        content=response.content,
+        status_code=response.status_code,
+        headers=dict(response.headers),
+        media_type=response.headers.get("content-type"),
+    )

schemas.py

@@ -0,0 +1,31 @@
+from typing import Any, Optional
+from pydantic import BaseModel
+
+
+class ManifestParameter(BaseModel):
+    name: str
+    location: str
+    type: str
+    required: bool = False
+    description: Optional[str] = None
+    default: Optional[Any] = None
+    resolved_value: Optional[Any] = None
+
+
+class ManifestFile(BaseModel):
+    field_name: str
+    filename: str
+
+
+class ProcessorManifest(BaseModel):
+    api_name: Optional[str] = None
+    api_description: Optional[str] = None
+    url: str
+    method: str = "POST"
+    body_type: str = "json"  # "json" | "form" | "multipart"
+    headers: Optional[dict[str, str]] = None
+    parameters: Optional[list[ManifestParameter]] = None
+    body: Optional[dict[str, Any]] = None
+    query_params: Optional[dict[str, str]] = None
+    path_params: Optional[dict[str, str]] = None
+    files: Optional[list[ManifestFile]] = None