generate dynamically endpoints forwarding to the ML module

src/api_factory.py

@@ -0,0 +1,94 @@
+from fastapi import Query
+from typing import Dict, Literal
+import httpx
+
+def extract_type(p):
+    schema = p.get("schema", {})
+    if "$ref" in schema:
+        return str  # fallback
+
+    if "enum" in schema:
+        return Literal[tuple(schema["enum"])]
+    
+    return openapi_type_to_python(schema.get("type", "string"))
+
+def get_param_metadata(p):
+    schema = p.get("schema", {})
+    return {
+        "name": p["name"],
+        "type": extract_type(p),
+        "required": p.get("required", False),
+        "description": p.get("description", ""),
+        "default": schema.get("default", ...),  # `...` => required if undefined
+        "enum": schema.get("enum", None),
+    }
+
+async def get_remote_params(base_url: str,
+                            endpoint: str,
+                            method: str = 'get'):
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"{base_url}openapi.json")
+        spec = response.json()
+    
+    # Extraction of the parameters from the OpenAPI spec
+    path_def = spec["paths"].get(f'/{endpoint}', {})
+    method_def = path_def.get(method, {})
+    params = method_def.get("parameters", [])
+
+    return [
+        get_param_metadata(p)
+        for p in params if p["in"] == "query"
+    ]
+
+def openapi_type_to_python(t: str):
+    return {
+        "string": str,
+        "integer": int,
+        "number": float,
+        "boolean": bool,
+        "array": list,
+    }.get(t, str)  # fallback = str
+
+def create_forward_endpoint(base_url: str, _endpoint: str, param_defs: Dict):
+    # Dynamic endpoint creation
+    def endpoint_factory():
+        async def endpoint(**kwargs):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{base_url}{_endpoint}",
+                    params=kwargs
+                )
+                return response.json()
+        return endpoint
+
+    endpoint = endpoint_factory()
+
+    # Add the parameters to the endpoint
+    endpoint.__annotations__ = {
+        p["name"]: openapi_type_to_python(p["type"]) for p in param_defs
+    }
+
+    # Add dependencies to the endpoint
+    from inspect import Parameter, Signature
+
+    parameters = []
+    for p in param_defs:
+        annotation = p["type"]
+        default = p.get("default", ...) if p.get("required", False) else p.get("default", None)
+
+        query = Query(
+            default=default,
+            description=p.get("description", "")
+        )
+
+        param = Parameter(
+            name=p["name"],
+            kind=Parameter.KEYWORD_ONLY,
+            default=query,
+            annotation=annotation
+        )
+        parameters.append(param)
+
+    endpoint.__signature__ = Signature(parameters)
+
+    return endpoint

src/main.py

@@ -39,7 +39,7 @@ from src.repository.common import get_session
 from src.service.match import insert_new_match
 
 from contextlib import asynccontextmanager
-import httpx
+from src.api_factory import create_forward_endpoint, get_remote_params
 
 load_dotenv()
 
@@ -59,9 +59,28 @@ TENNIS_ML_API = os.getenv("TENNIS_ML_API")
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Other server that requests should be forwarded to
-    async with httpx.AsyncClient(base_url=TENNIS_ML_API) as client:
-        yield {'client': client}
+    endpoints = [
+        "run_experiment",
+        "predict",
+        "list_available_models"
+    ]
+
+    for endpoint in endpoints:
+        param_defs = await get_remote_params(base_url=TENNIS_ML_API,
+                                             endpoint=endpoint,
+                                             method='get')
+        forward_endpoint = create_forward_endpoint(base_url=TENNIS_ML_API,
+                                                   _endpoint=endpoint,
+                                                   param_defs=param_defs)
+
+        app.add_api_route(
+            path=f'/{endpoint}',
+            endpoint=forward_endpoint,
+            methods=["GET"],
+            name=f"Forward to remote {forward_endpoint.__name__}",
+        )
+    
+    yield
 
 # ------------------------------------------------------------------------------
 
@@ -98,45 +117,6 @@ def redirect_to_docs():
     '''
     return RedirectResponse(url='/docs')
 
-@app.get("/run_experiment", tags=["model"], description="Schedule a run of the ML experiment")
-async def run_xp(request: Request):
-    """
-    Train the model
-    """
-    params = dict(request.query_params)
-
-    async with httpx.AsyncClient() as client:
-        response = await client.get(TENNIS_ML_API + "run_experiment", params=params)
-        return response.json()
-
-@app.get("/predict",
-         tags=["model"],
-         description="Predict the outcome of a tennis match",)
-async def make_prediction(request: Request):
-    """
-    Predict the matches
-    """
-    params = dict(request.query_params)
-
-    if not TENNIS_ML_API:
-        return {"message": "TENNIS_ML_API environment variable not set."}
-    
-    async with httpx.AsyncClient() as client:
-        response = await client.get(TENNIS_ML_API + "predict", params=params)
-        return response.json()
-
-@app.get("/list_available_models", tags=["model"], description="List the available models")
-async def list_available_models():
-    """
-    List the available models
-    """
-    if not TENNIS_ML_API:
-        return {"message": "TENNIS_ML_API environment variable not set."}
-    
-    async with httpx.AsyncClient() as client:
-        response = await client.get(TENNIS_ML_API + "list_available_models")
-        return response.json()
-
 # List all the tournament names and years
 @app.get("/tournament/names", tags=["tournament"], description="List all the tournament names and years", response_model=List[Dict])
 async def list_tournament_names(