Upload app.py with huggingface_hub

app.py

@@ -1,18 +1,30 @@
 import os
 import logging
-from flask import Flask, render_template, request, jsonify
-from flask_socketio import SocketIO
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 import joblib
 import torch
 import numpy as np
 from huggingface_hub import hf_hub_download
+from pydantic import BaseModel
+import uvicorn
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = Flask(__name__)
-socketio = SocketIO(app, cors_allowed_origins="*")
+app = FastAPI(title="Health Monitoring System",
+             description="A FastAPI application for health monitoring and prediction",
+             version="1.0.0")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 # Load models
 def load_models():
@@ -48,52 +60,60 @@ def load_models():
         logger.error(f"Failed to load autoencoder: {str(e)}")
 
 # Load models on startup
-logger.info("Loading trained models...")
-try:
-    load_models()
-except Exception as e:
-    logger.error(f"Error loading models: {str(e)}")
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Loading trained models...")
+    try:
+        load_models()
+    except Exception as e:
+        logger.error(f"Error loading models: {str(e)}")
+
+# Define request models
+class PredictionRequest(BaseModel):
+    data: dict
+
+# Define response models
+class HealthResponse(BaseModel):
+    status: str
+    models: dict
 
-@app.route('/')
-def home():
-    return render_template('index.html')
+class PredictionResponse(BaseModel):
+    status: str
+    prediction: str
+    message: str = None
 
-@app.route('/health')
-def health():
-    status = {
-        'status': 'healthy',
-        'models': {
-            'heart_model': heart_model is not None,
-            'autoencoder': autoencoder is not None
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the Health Monitoring System API"}
+
+@app.get("/health", response_model=HealthResponse)
+async def health():
+    return {
+        "status": "healthy",
+        "models": {
+            "heart_model": heart_model is not None,
+            "autoencoder": autoencoder is not None
         }
     }
-    return jsonify(status)
 
-@app.route('/predict', methods=['POST'])
-def predict():
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(request: PredictionRequest):
     try:
-        data = request.get_json()
-        if not data:
-            return jsonify({'status': 'error', 'message': 'No data provided'}), 400
+        if not request.data:
+            raise HTTPException(status_code=400, detail="No data provided")
         
         # Add your prediction logic here
         logger.info("Processing prediction request")
-        result = {'status': 'success', 'prediction': 'normal'}
+        result = {
+            "status": "success",
+            "prediction": "normal",
+            "message": "Prediction completed successfully"
+        }
         logger.info(f"Prediction completed: {result}")
-        return jsonify(result)
+        return result
     except Exception as e:
         logger.error(f"Error during prediction: {str(e)}")
-        return jsonify({'status': 'error', 'message': str(e)}), 500
-
-@socketio.on('connect')
-def handle_connect():
-    logger.info('Client connected')
-
-@socketio.on('disconnect')
-def handle_disconnect():
-    logger.info('Client disconnected')
+        raise HTTPException(status_code=500, detail=str(e))
 
-if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    logger.info(f"Starting server on port {port}")
-    socketio.run(app, host='0.0.0.0', port=port) 
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)