commit 0000002361

app.py

@@ -1,147 +1,86 @@
-from flask import Flask, request, jsonify, Response
-from flasgger import Swagger, swag_from
 import os
-import requests
+import aiohttp
+from fastapi import FastAPI, WebSocket, UploadFile, Form
+from fastapi.responses import StreamingResponse, Response, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
 from dotenv import load_dotenv
 
 load_dotenv()
 
-app = Flask(__name__)
-swagger = Swagger(app)
+app = FastAPI(
+    title="Public API Gateway",
+    description="Proxies requests from React → private backend securely",
+    version="1.0"
+)
 
-HF_TOKEN = os.environ.get("CHAT_MATE")
+# Allow React frontend to call this API
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # you can restrict to your frontend domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-@app.route("/chat-stream", methods=["POST"])
-@swag_from({
-    'tags': ['Chat'],
-    'consumes': ['application/json'],
-    'summary': 'Stream assistant reply or image',
-    'description': 'Send a message and history, receive either a streamed text reply or base64-encoded image.',
-    'parameters': [{
-        'name': 'body',
-        'in': 'body',
-        'required': True,
-        'schema': {
-            'type': 'object',
-            'properties': {
-                'message': {'type': 'string', 'example': 'Draw a futuristic city.'},
-                'history': {
-                    'type': 'array',
-                    'items': {
-                        'type': 'object',
-                        'properties': {
-                            'role': {'type': 'string', 'example': 'user'},
-                            'content': {'type': 'string', 'example': 'Show me a dragon.'}
-                        }
-                    }
-                }
-            },
-            'required': ['message']
-        }
-    }],
-    'responses': {
-        200: {
-            'description': 'Streamed reply or image base64',
-            'content': {'text/plain': {}}
-        }
-    }
-})
-def chat_stream():
-    data = request.get_json()
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-    response = requests.post(
-        "https://fredericksundeep-chatmateapi.hf.space/chat-stream",
-        json=data,
-        headers=headers,
-        stream=True
-    )
-    return Response(response.iter_content(decode_unicode=True), mimetype="text/plain")
+HF_TOKEN = os.environ.get("CHAT_MATE")
+PRIVATE_HTTP_URL = "https://fredericksundeep-chatmateapi.hf.space/chat-stream"
+PRIVATE_DOC_URL = "https://fredericksundeep-aimateapis.hf.space/chat-stream-doc"
+PRIVATE_WS_URL = "wss://fredericksundeep-chatmateapi.hf.space/chat-stream"
 
-@app.route("/chat-stream-doc", methods=["POST"])
-@swag_from({
-    'tags': ['Chat'],
-    'consumes': ['multipart/form-data'],
-    'summary': 'Upload requirement doc & generate downloadable project code (ZIP)',
-    'description': 'Upload a PDF/TXT requirement document with stack preferences, and receive the scaffolded project code as a downloadable .zip file.',
-    'parameters': [
-        {
-            'name': 'file',
-            'in': 'formData',
-            'type': 'file',
-            'required': True,
-            'description': 'Requirement document (PDF or TXT)'
-        },
-        {
-            'name': 'frontend',
-            'in': 'formData',
-            'type': 'string',
-            'required': True,
-            'description': 'Frontend tech (React, Angular, etc.)'
-        },
-        {
-            'name': 'backend',
-            'in': 'formData',
-            'type': 'string',
-            'required': True,
-            'description': 'Backend tech (Flask, Node.js, etc.)'
-        },
-        {
-            'name': 'database',
-            'in': 'formData',
-            'type': 'string',
-            'required': True,
-            'description': 'Database (MongoDB, PostgreSQL, etc.)'
-        }
-    ],
-    'responses': {
-        200: {
-            'description': 'ZIP file of generated code',
-            'content': {'application/zip': {}}
-        }
-    }
-})
-def chat_stream_doc():
-    from werkzeug.utils import secure_filename
 
-    file = request.files.get("file")
-    if not file:
-        return jsonify({"error": "No file uploaded"}), 400
+# ✅ Streaming text/images via WebSocket
+@app.websocket("/chat-stream")
+async def chat_stream(websocket: WebSocket):
+    await websocket.accept()
+    data = await websocket.receive_json()
 
-    filename = secure_filename(file.filename)
-    frontend = request.form.get("frontend")
-    backend = request.form.get("backend")
-    database = request.form.get("database")
+    async with aiohttp.ClientSession() as session:
+        async with session.ws_connect(
+            PRIVATE_WS_URL,
+            headers={"Authorization": f"Bearer {HF_TOKEN}"}
+        ) as private_ws:
+            await private_ws.send_json(data)
 
-    headers = {
-        "Authorization": f"Bearer {HF_TOKEN}"
-    }
+            async for msg in private_ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await websocket.send_text(msg.data)
+                elif msg.type == aiohttp.WSMsgType.BINARY:
+                    await websocket.send_bytes(msg.data)
+                elif msg.type == aiohttp.WSMsgType.CLOSE:
+                    break
 
-    files = {
-        "file": (filename, file.stream, file.mimetype)
-    }
 
-    data = {
-        "frontend": frontend,
-        "backend": backend,
-        "database": database
-    }
+# ✅ Handle file uploads for doc generation
+@app.post("/chat-stream-doc")
+async def chat_stream_doc(
+    file: UploadFile,
+    frontend: str = Form(...),
+    backend: str = Form(...),
+    database: str = Form(...)
+):
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    form_data = aiohttp.FormData()
+    form_data.add_field("file", file.file, filename=file.filename, content_type=file.content_type)
+    form_data.add_field("frontend", frontend)
+    form_data.add_field("backend", backend)
+    form_data.add_field("database", database)
 
-    try:
-        response = requests.post(
-            "https://fredericksundeep-aimateapis.hf.space/chat-stream-doc",
-            headers=headers,
-            files=files,
-            data=data
-        )
+    async with aiohttp.ClientSession() as session:
+        async with session.post(PRIVATE_DOC_URL, data=form_data, headers=headers) as resp:
+            if resp.status != 200:
+                return JSONResponse({"error": await resp.text()}, status_code=resp.status)
 
-        return (response.content, response.status_code, {
-            "Content-Type": response.headers.get("Content-Type", "application/octet-stream"),
-            "Content-Disposition": response.headers.get("Content-Disposition", "attachment; filename=generated_project.zip")
-        })
+            # Stream ZIP file back to client
+            return Response(
+                content=await resp.read(),
+                media_type=resp.headers.get("Content-Type", "application/octet-stream"),
+                headers={
+                    "Content-Disposition": "attachment; filename=generated_project.zip"
+                }
+            )
 
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
 
 if __name__ == "__main__":
-    print("🔧 Warming up...")
-    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))
+    import uvicorn
+    print("🚀 Starting FastAPI server...")
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))

requirements.txt

@@ -1,4 +1,4 @@
-flask
-flasgger
-requests
+fastapi
+uvicorn
 python-dotenv
+requests