Add module config for module_example and module_text_llm

assessment_module_manager/assessment_module_manager/endpoints/modules_proxy_endpoint.py

@@ -1,16 +1,16 @@
-from typing import Dict, Any
+from typing import Dict, Any, Optional
+from fastapi import Body, HTTPException, Request
+from starlette.responses import JSONResponse
 
-from assessment_module_manager.app import app
-from assessment_module_manager.module import ModuleResponse, AvailableModuleNames, find_module_by_name, \
-    request_to_module
 from athena.authenticate import authenticated
 from athena.schemas import ExerciseType
-from fastapi import HTTPException
-from starlette.responses import JSONResponse
+from assessment_module_manager.app import app
+from assessment_module_manager.module import ModuleResponse, AvailableModuleNames, find_module_by_name, request_to_module
 
 
-@app.post(
+@app.api_route(
     "/modules/{module_type}/{module_name}/{path:path}",
+    methods=["POST", "GET"],
     responses={
         400: {
             "description": "Module is not of the requested type",
@@ -26,26 +26,33 @@
             "description": "Module is not available",
         },
     },
-    response_model=ModuleResponse[Any],
+    response_model=ModuleResponse[Any, Any],
 )
 @authenticated
 async def proxy_to_module(
-    module_type: ExerciseType, module_name: AvailableModuleNames, path: str, data: Dict[Any, Any],
+    module_type: ExerciseType, module_name: AvailableModuleNames, path: str, request: Request, data: Optional[Dict[Any, Any]] = Body(None),
 ) -> JSONResponse:
     """
     This endpoint is called by the LMS to proxy requests to modules.
     See the module documentation for the possible choices for paths.
     Example module documentation on this: [http://localhost:5001/docs](http://localhost:5001/docs).
     """
+    if request.method == "GET" and data is not None:
+        raise HTTPException(status_code=400, detail="GET request should not contain a body")
+
     module = await find_module_by_name(module_name)
     if module is None:
         raise HTTPException(status_code=404, detail=f"Module {module_name} not found. Is it listed in modules.ini?")
     if module.type != module_type:
         raise HTTPException(status_code=400, detail=f"Found module {module_name} is not of type {module_type}.")
+
+    module_config = request.headers.get('X-Module-Config')
     resp = await request_to_module(
         module,
+        module_config,
         '/' + path,
         data,
+        method=request.method,
     )
     return JSONResponse(
         status_code=resp.status,

assessment_module_manager/assessment_module_manager/module/request_to_module.py

@@ -9,15 +9,18 @@
 from .available_module_enum import AvailableModuleNames
 from .list_modules import list_modules
 from assessment_module_manager import env
+from assessment_module_manager.logger import logger
 
-T = TypeVar('T')
-class ModuleResponse(GenericModel, Generic[T]):
+D = TypeVar('D')
+M = TypeVar('M')
+class ModuleResponse(GenericModel, Generic[D, M]):
     """
     A response from a module.
     """
     module_name: str
     status: int
-    data: T
+    data: D
+    meta: M
 
 
 async def find_module_by_name(
@@ -32,23 +35,36 @@ async def find_module_by_name(
     return None
 
 
-async def request_to_module(module: Module, path: str, data: dict) -> ModuleResponse:
+async def request_to_module(module: Module, module_config: Optional[str], path: str, data: Optional[dict], method: str) -> ModuleResponse:
     """
     Helper function to send a request to a module.
     It raises appropriate FastAPI HTTPException if the request fails.
     """
     module_secret = env.MODULE_SECRETS[module.name]
+    headers = {}
+    if module_secret:
+        headers['X-API-Secret'] = module_secret
+    if module_config:
+        headers['X-Module-Config'] = module_config
+
     try:
         async with httpx.AsyncClient(base_url=module.url, timeout=600) as client:
-            response = await client.post(path, json=data, headers={'X-API-Secret': module_secret} if module_secret else None)
+            if method == "POST":
+                response = await client.post(path, json=data, headers=headers)
+            elif method == "GET":
+                response = await client.get(path, headers=headers)
+            else:
+                raise NotImplementedError(f"Method {method} is not implemented")
     except httpx.ConnectError as exc:
         raise HTTPException(status_code=503, detail=f"Module {module.name} is not available") from exc
+
     try:
-        response.raise_for_status()
-    except httpx.HTTPStatusError:
-        try:
-            response_data = response.json()
-        except json.JSONDecodeError:
-            response_data = response.text
-        return ModuleResponse(module_name=module.name, status=response.status_code, data=response_data)
-    return ModuleResponse(module_name=module.name, status=response.status_code, data=response.json())
+        response_data = response.json()
+        meta = response_data.get('meta', {})
+        response_data = response_data.get('data', response_data)
+    except json.JSONDecodeError:
+        response_data = response.text
+        meta = None
+        logger.warning("Module %s returned non-JSON response: %s", module.name, response.text)
+
+    return ModuleResponse(module_name=module.name, status=response.status_code, data=response_data, meta=meta)

athena/athena/__init__.py

@@ -4,7 +4,8 @@
 
 from .app import app
 from .schemas import ExerciseType
-from .endpoints import submission_selector, submissions_consumer, feedback_consumer, feedback_provider  # type: ignore
+from .metadata import emit_meta, get_meta
+from .endpoints import submission_selector, submissions_consumer, feedback_consumer, feedback_provider, config_schema_provider  # type: ignore
 
 
 @app.get("/")
@@ -25,6 +26,9 @@ def run_module():
     "submissions_consumer",
     "feedback_consumer",
     "feedback_provider",
+    "config_schema_provider",
+    "emit_meta",
+    "get_meta",
     "ExerciseType",
     "app"
 ]

athena/athena/app.py

@@ -10,6 +10,7 @@
 from .database import create_tables
 from .logger import logger
 from .module_config import get_module_config
+from .metadata import MetaDataMiddleware
 
 
 class FastAPIWithStart(FastAPI):
@@ -18,6 +19,11 @@ class FastAPIWithStart(FastAPI):
     We expose the start function this way to ensure that modules have to import `app`,
     which uvicorn needs to discover in the module.
     """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.add_middleware(MetaDataMiddleware)
+
+
     def start(self) -> None:
         """Start Athena. You have to ensure to have `app` in your module main scope so that it can be imported."""
         logger.info("Starting athena module")