Spaces:

govinuts
/

manan-ml-api

Running

App Files Files Community

CodeGovindz commited on 5 days ago

Commit

bc48447

1 Parent(s): d8c5526

Add auth endpoints: OTP, registration, profile, emotions

Browse files

Files changed (2) hide show

app.py +380 -0
requirements.txt +2 -0

app.py CHANGED Viewed

@@ -7,6 +7,9 @@ import torch.nn as nn
 import whisper
 import librosa
 import asyncio
 from typing import List, Dict, Any, Optional
 from fastapi import FastAPI, UploadFile, File, HTTPException, Request, Form
 from fastapi.middleware.cors import CORSMiddleware
@@ -17,6 +20,8 @@ from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassific
 from speechbrain.inference.classifiers import EncoderClassifier
 import torchaudio
 import json
 # Setup logging
 logging.basicConfig(
@@ -557,3 +562,378 @@ async def predict_text_emotion(files: List[UploadFile] = File(...)):
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

 import whisper
 import librosa
 import asyncio
+import random
+import requests
+from datetime import datetime, timedelta
 from typing import List, Dict, Any, Optional
 from fastapi import FastAPI, UploadFile, File, HTTPException, Request, Form
 from fastapi.middleware.cors import CORSMiddleware
 from speechbrain.inference.classifiers import EncoderClassifier
 import torchaudio
 import json
+from pydantic import BaseModel
+from supabase import create_client, Client
 # Setup logging
 logging.basicConfig(
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
+# =============================================================================
+# AUTHENTICATION & USER MANAGEMENT ENDPOINTS
+# =============================================================================
+# Supabase configuration
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+BREVO_API_KEY = os.environ.get("EMAIL_API")
+# Initialize Supabase client
+supabase: Client = None
+try:
+    if SUPABASE_URL and SUPABASE_KEY:
+        supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+        logger.info("Supabase client initialized successfully")
+    else:
+        logger.warning("Supabase credentials not found in environment variables")
+except Exception as e:
+    logger.error(f"Failed to initialize Supabase: {str(e)}")
+# OTP storage (in-memory, resets on restart)
+otp_store = {}
+# -------------------------------
+# Request Models for Auth
+# -------------------------------
+class OTPRequest(BaseModel):
+    email: str
+class OTPVerifyRequest(BaseModel):
+    email: str
+    otp: str
+class RegisterUserRequest(BaseModel):
+    name: str
+    email: str
+    password: str
+class SendEmotionRequest(BaseModel):
+    email: str
+    emotion: str
+class UpdateProfilePicRequest(BaseModel):
+    email: str
+    profile_pic_url: str
+class UpdateProfileRequest(BaseModel):
+    email: str
+    name: str = None
+    age: int = None
+    phone: str = None
+# -------------------------------
+# Helper Function - Send Email via Brevo
+# -------------------------------
+def send_email_brevo(to_email: str, otp: str):
+    url = "https://api.brevo.com/v3/smtp/email"
+    headers = {
+        "accept": "application/json",
+        "api-key": BREVO_API_KEY,
+        "content-type": "application/json",
+    }
+    data = {
+        "sender": {"name": "मनन", "email": "noreplymanan@gmail.com"},
+        "to": [{"email": to_email}],
+        "subject": "Your Manan OTP Code",
+        "htmlContent": f"""
+            <html>
+              <body>
+                <h2>Your OTP Code</h2>
+                <p>Your verification code is: <strong>{otp}</strong></p>
+                <p>This code will expire in 5 minutes.</p>
+              </body>
+            </html>
+        """,
+    }
+    response = requests.post(url, headers=headers, json=data)
+    if response.status_code not in [200, 201]:
+        raise HTTPException(status_code=500, detail=f"Email sending failed: {response.text}")
+# -------------------------------
+# Auth Endpoints
+# -------------------------------
+@app.get("/status")
+def get_status():
+    try:
+        if supabase is None:
+            return {"status": "Supabase not configured", "supabase_data_retrieved": False}
+        response = supabase.table('users').select("id").limit(1).execute()
+        return {"status": "Connection successful", "supabase_data_retrieved": len(response.data) > 0}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Connection failed: {str(e)}")
+@app.post("/send_otp")
+def send_otp(req: OTPRequest):
+    try:
+        otp = str(random.randint(100000, 999999))
+        otp_store[req.email] = {"otp": otp, "timestamp": datetime.utcnow()}
+        logger.info(f"OTP generated for {req.email}")
+        # Send email
+        send_email_brevo(req.email, otp)
+        return {"message": f"OTP sent successfully to {req.email}"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error sending OTP: {str(e)}")
+@app.post("/check_otp")
+def check_otp(req: OTPVerifyRequest):
+    try:
+        if req.email not in otp_store:
+            raise HTTPException(status_code=404, detail="No OTP found for this email")
+        stored_data = otp_store[req.email]
+        stored_otp = stored_data["otp"]
+        timestamp = stored_data["timestamp"]
+        # Expiry check (5 minutes)
+        if datetime.utcnow() - timestamp > timedelta(minutes=5):
+            del otp_store[req.email]
+            raise HTTPException(status_code=400, detail="OTP expired")
+        if req.otp == stored_otp:
+            # Mark as verified instead of deleting
+            otp_store[req.email]["verified"] = True
+            otp_store[req.email]["otp"] = None
+            return {"verified": True}
+        else:
+            raise HTTPException(status_code=400, detail="Invalid OTP")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error verifying OTP: {str(e)}")
+@app.post("/register_user")
+def register_user(req: RegisterUserRequest):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        # Check OTP verification
+        if req.email not in otp_store or not otp_store[req.email].get("verified", False):
+            raise HTTPException(status_code=403, detail="Email not verified via OTP")
+        # Insert into Supabase
+        response = supabase.table("users").insert({
+            "name": req.name,
+            "email": req.email,
+            "password": req.password
+        }).execute()
+        # Cleanup
+        del otp_store[req.email]
+        return {"message": "User registered successfully", "data": response.data}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error registering user: {str(e)}")
+@app.get("/get_profile/{email}")
+def get_profile(email: str):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        response = supabase.table("users").select("*").eq("email", email).single().execute()
+        if not response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        # Remove password from response for security
+        profile_data = response.data.copy()
+        profile_data.pop('password', None)
+        return {"profile": profile_data}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching profile: {str(e)}")
+@app.put("/update_profile")
+def update_profile(req: UpdateProfileRequest):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        update_data = {}
+        if req.name is not None:
+            update_data["name"] = req.name
+        if req.age is not None:
+            update_data["age"] = req.age
+        if req.phone is not None:
+            update_data["phone"] = req.phone
+        if not update_data:
+            raise HTTPException(status_code=400, detail="No data provided for update")
+        response = supabase.table("users").update(update_data).eq("email", req.email).execute()
+        if not response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        return {"message": "Profile updated successfully", "data": response.data}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error updating profile: {str(e)}")
+@app.post("/update_profile_pic")
+def update_profile_pic(req: UpdateProfilePicRequest):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        response = supabase.table("users").update({
+            "profilepic": req.profile_pic_url
+        }).eq("email", req.email).execute()
+        if not response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        return {"message": "Profile picture updated successfully", "data": response.data}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error updating profile picture: {str(e)}")
+@app.get("/get_score/{email}")
+def get_score(email: str):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        user_response = supabase.table("users").select("id").eq("email", email).execute()
+        if not user_response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        user_id = user_response.data[0]["id"]
+        predict_response = supabase.table("predict").select("prediction, timestamp") \
+            .eq("user_id", user_id).order("timestamp", desc=True).limit(1).execute()
+        if not predict_response.data:
+            raise HTTPException(status_code=404, detail="No predictions found for this user")
+        return predict_response.data[0]
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching score: {str(e)}")
+@app.post("/send_emotion")
+def send_emotion(req: SendEmotionRequest):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        user_response = supabase.table("users").select("id").eq("email", req.email).execute()
+        if not user_response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        user_id = user_response.data[0]["id"]
+        data = {
+            "user_id": user_id,
+            "prediction": req.emotion,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        response = supabase.table("predict").insert(data).execute()
+        return {"message": "Emotion saved successfully", "data": response.data}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error saving emotion: {str(e)}")
+@app.get("/get_emotion/{email}")
+def get_emotion(email: str):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        user_response = supabase.table("users").select("id").eq("email", email).execute()
+        if not user_response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        user_id = user_response.data[0]["id"]
+        predict_response = supabase.table("predict").select("prediction") \
+            .eq("user_id", user_id).order("timestamp", desc=True).limit(1).execute()
+        if not predict_response.data:
+            return {"emotion": "Neutral"}
+        return {"emotion": predict_response.data[0]["prediction"]}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching emotion: {str(e)}")
+@app.get("/get_mental_health_details/{email}")
+def get_mental_health_details(email: str):
+    try:
+        if supabase is None:
+            raise HTTPException(status_code=500, detail="Supabase not configured")
+        user_response = supabase.table("users").select("id").eq("email", email).execute()
+        if not user_response.data:
+            raise HTTPException(status_code=404, detail="User not found")
+        user_id = user_response.data[0]["id"]
+        # Get most recent prediction
+        recent_prediction = supabase.table("predict").select("prediction, timestamp") \
+            .eq("user_id", user_id).order("timestamp", desc=True).limit(1).execute()
+        current_prediction = recent_prediction.data[0]["prediction"] if recent_prediction.data else None
+        # Calculate this week's active days
+        week_ago = datetime.utcnow() - timedelta(days=7)
+        weekly_predictions = supabase.table("predict").select("timestamp") \
+            .eq("user_id", user_id).gte("timestamp", week_ago.isoformat()).execute()
+        if weekly_predictions.data:
+            dates = set()
+            for p in weekly_predictions.data:
+                if p.get("timestamp"):
+                    try:
+                        ts_str = p["timestamp"].replace('Z', '+00:00')
+                        dt = datetime.fromisoformat(ts_str)
+                        dates.add(dt.date())
+                    except (ValueError, AttributeError):
+                        try:
+                            ts_str = p["timestamp"].split('+')[0].split('Z')[0]
+                            dt = datetime.strptime(ts_str, '%Y-%m-%dT%H:%M:%S.%f')
+                            dates.add(dt.date())
+                        except:
+                            try:
+                                dt = datetime.strptime(ts_str, '%Y-%m-%dT%H:%M:%S')
+                                dates.add(dt.date())
+                            except:
+                                pass
+            active_days = len(dates)
+        else:
+            active_days = 0
+        # Total conversations
+        total_conversations = supabase.table("predict").select("*", count="exact") \
+            .eq("user_id", user_id).execute()
+        total_count = total_conversations.count if total_conversations else 0
+        return {
+            "current_prediction": current_prediction,
+            "active_days_this_week": active_days,
+            "total_conversations": total_count
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching mental health details: {str(e)}")

requirements.txt CHANGED Viewed

@@ -17,3 +17,5 @@ audioread==3.0.1
 speechbrain==1.0.0
 pydantic==2.8.0
 python-dotenv==1.0.1

 speechbrain==1.0.0
 pydantic==2.8.0
 python-dotenv==1.0.1
+supabase==2.4.0
+requests==2.31.0