Create app.py

app.py

@@ -0,0 +1,125 @@
+import asyncio
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Dict
+import uvicorn
+
+# Initialiser l'application FastAPI
+app = FastAPI()
+
+# Configurer CORS pour autoriser toutes les origines
+# Permet à n'importe quel site web d'appeler votre API
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Autorise toutes les origines
+    allow_credentials=True,
+    allow_methods=["*"],  # Autorise toutes les méthodes (GET, POST, etc.)
+    allow_headers=["*"],  # Autorise tous les en-têtes
+)
+
+# Monter un répertoire statique pour servir le fichier index.html
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+class ConnectionManager:
+    """Gère les connexions WebSocket actives."""
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
+        # Dictionnaire pour attendre les réponses des clients
+        self.response_futures: Dict[str, asyncio.Future] = {}
+
+    async def connect(self, websocket: WebSocket):
+        """Accepte une nouvelle connexion WebSocket."""
+        await websocket.accept()
+        self.active_connections.append(websocket)
+        print(f"Nouvelle connexion WebSocket. Total: {len(self.active_connections)}")
+
+    def disconnect(self, websocket: WebSocket):
+        """Ferme une connexion WebSocket."""
+        self.active_connections.remove(websocket)
+        print(f"Déconnexion WebSocket. Total: {len(self.active_connections)}")
+
+    async def broadcast(self, message: str):
+        """Envoie un message à tous les clients connectés."""
+        # Pour ce cas simple, nous n'envoyons qu'au premier client connecté
+        if self.active_connections:
+            websocket = self.active_connections[0]
+            await websocket.send_text(message)
+            # Créer un Future pour attendre la réponse
+            future = asyncio.get_event_loop().create_future()
+            # Utilise l'identifiant du client comme clé, bien que simple, c'est plus robuste
+            client_id = str(id(websocket))
+            self.response_futures[client_id] = future
+            return future
+        return None
+
+manager = ConnectionManager()
+
+@app.post("/v1/mock")
+async def mock_endpoint(request: Request):
+    """
+    Endpoint API qui prend un string, le transmet via WebSocket,
+    attend une réponse et la retourne.
+    """
+    try:
+        # Récupérer les données JSON du corps de la requête
+        data = await request.json()
+        input_string = data.get("parameter")
+
+        if input_string is None:
+            return {"error": "Le paramètre 'parameter' est manquant."}
+            
+        print(f"Endpoint /v1/mock appelé avec: '{input_string}'")
+
+        if not manager.active_connections:
+            return {"error": "Aucun client WebSocket n'est connecté."}
+
+        # Envoyer le message via WebSocket et obtenir un "future" pour la réponse
+        print("Envoi du message au client WebSocket...")
+        response_future = await manager.broadcast(input_string)
+
+        if response_future is None:
+             return {"error": "Échec de la diffusion du message."}
+
+        try:
+            # Attendre la réponse du client WebSocket avec un timeout de 10 secondes
+            websocket_response = await asyncio.wait_for(response_future, timeout=10.0)
+            print(f"Réponse reçue du WebSocket: '{websocket_response}'")
+            return {"response_from_client": websocket_response}
+
+        except asyncio.TimeoutError:
+            print("Timeout: Aucune réponse du client WebSocket.")
+            return {"error": "Timeout: Le client n'a pas répondu à temps."}
+
+    except Exception as e:
+        print(f"Erreur dans /v1/mock: {e}")
+        return {"error": f"Une erreur interne est survenue: {str(e)}"}
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """Gère la communication WebSocket avec le client."""
+    await manager.connect(websocket)
+    try:
+        while True:
+            # Attendre un message du client
+            data = await websocket.receive_text()
+            print(f"Message reçu du client: '{data}'")
+
+            # Trouver le "future" correspondant et y mettre le résultat
+            client_id = str(id(websocket))
+            if client_id in manager.response_futures:
+                manager.response_futures[client_id].set_result(data)
+                del manager.response_futures[client_id] # Nettoyer après utilisation
+
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+        print("Client déconnecté.")
+    except Exception as e:
+        print(f"Erreur dans le WebSocket: {e}")
+        manager.disconnect(websocket)
+
+
+if __name__ == "__main__":
+    # Lance le serveur sur le port 8000
+    uvicorn.run(app, host="0.0.0.0", port=8000)