Upload 29 files

Dockerfile

@@ -0,0 +1,27 @@
+# Use a slim Python base image
+FROM python:3.10-slim
+
+# Prevents Python from writing pyc files to disk and buffers logs immediately
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Set working directory in the container
+WORKDIR /app
+
+# Install system dependencies (for audio, etc.)
+RUN apt-get update && apt-get install -y ffmpeg libsndfile1 && rm -rf /var/lib/apt/lists/*
+
+# Copy dependency file first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the app
+COPY . .
+
+# Expose the FastAPI port (Hugging Face prefers 7860, but 8000 is also fine)
+EXPOSE 8000
+
+# Run the app using Uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

core/database.py

@@ -0,0 +1,12 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+SQLALCHEMY_DATABASE_URL = "sqlite:///./appointments.db"
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
+Base = declarative_base()

core/models/appointment.py

@@ -0,0 +1,13 @@
+from sqlalchemy import Column, Integer, String
+from core.database import Base
+
+class Appointment(Base):
+    __tablename__ = "appointments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    patient_name = Column(String, nullable=False)
+    age = Column(Integer, nullable=False)
+    symptoms = Column(String, nullable=False)
+    specialist = Column(String, nullable=False)
+
+

core/models/user.py

@@ -0,0 +1,11 @@
+from sqlalchemy import Column, Integer, String
+from core.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    full_name = Column(String, nullable=False)
+    email = Column(String, unique=True, index=True, nullable=False)
+    password = Column(String, nullable=False)
+    specialization = Column(String, nullable=True)  # Only for doctors

main.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from core.database import engine
+from core.models.appointment import Appointment
+from core.models.user import User
+from routes import appointments, users
+
+# Create FastAPI app first
+app = FastAPI()
+
+# ✅ Enable CORS BEFORE including any routers
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],  # React frontend
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create tables
+Appointment.__table__.create(bind=engine, checkfirst=True)
+User.__table__.create(bind=engine, checkfirst=True)
+
+# Register routers
+app.include_router(appointments.router)
+app.include_router(users.router)

routes/__init__.py

@@ -0,0 +1,2 @@
+from . import appointments
+from . import users  # ✅ This should import the file

routes/appointments.py

@@ -0,0 +1,88 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from schemas.appointment import AppointmentInput
+from core.database import SessionLocal
+from core.models.appointment import Appointment
+
+router = APIRouter()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@router.post("/appointments/create")
+def create_appointment(data: AppointmentInput, db: Session = Depends(get_db)):
+    new_appointment = Appointment(
+        patient_name=data.patient_name,
+        age=data.age,
+        symptoms=data.symptoms,
+        specialist=data.specialist
+    )
+    db.add(new_appointment)
+    db.commit()
+    db.refresh(new_appointment)
+
+    return {
+        "message": "Appointment saved to database",
+        "data": {
+            "id": new_appointment.id,
+            "patient_name": new_appointment.patient_name,
+            "age": new_appointment.age,
+            "symptoms": new_appointment.symptoms,
+            "specialist": new_appointment.specialist
+        }
+    }
+from fastapi import APIRouter, UploadFile, File
+from utils.stt_processor import simulate_stt  # make sure path is correct
+import shutil
+import os
+from utils.specialist_predictor import predict_specialist
+
+@router.post("/appointments/voice")
+async def create_appointment_from_voice(audio: UploadFile = File(...), db: Session = Depends(get_db)):
+    # 1. Save temp audio
+    temp_path = f"temp_{audio.filename}"
+    with open(temp_path, "wb") as buffer:
+        shutil.copyfileobj(audio.file, buffer)
+
+    try:
+        # 2. Extract symptoms from audio
+        data = simulate_stt(temp_path)
+        symptoms = data.get("symptoms", "")
+
+        # 3. Predict specialist using model
+        specialist, score = predict_specialist(symptoms)
+
+        # 4. Create appointment object
+        new_appointment = Appointment(
+            patient_name=data.get("patient_name", "Unknown"),
+            age=data.get("age", 0),
+            symptoms=symptoms,
+            specialist=specialist
+        )
+
+        db.add(new_appointment)
+        db.commit()
+        db.refresh(new_appointment)
+
+        # 5. Return response
+        return {
+            "message": "Appointment created successfully from voice",
+            "predicted_specialist": specialist,
+            "similarity_score": round(score, 4),
+            "appointment": {
+                "id": new_appointment.id,
+                "patient_name": new_appointment.patient_name,
+                "age": new_appointment.age,
+                "symptoms": symptoms,
+                "specialist": specialist
+            }
+        }
+
+    finally:
+        # Clean up file
+        os.remove(temp_path)

routes/users.py

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, Depends,HTTPException
+from sqlalchemy.orm import Session
+from core.database import SessionLocal
+from core.models.user import User
+from schemas.user import UserCreate,UserLogin
+from utils.security import hash_password
+from utils.auth import create_access_token  # adjust based on your folder structure
+
+from passlib.hash import bcrypt
+router = APIRouter(
+    prefix="/users",  # ✅ important for proper routing like /users/signup
+    tags=["Users"]
+)
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+print("✅ users.router loaded")
+@router.post("/signup")
+def create_user(user: UserCreate, db: Session = Depends(get_db)):
+    db_user = User(
+        full_name=user.full_name,
+        email=user.email,
+        password=hash_password(user.password), # ⚠️ Should hash password before storing
+        specialization=user.specialization
+    )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return {"message": "User created successfully", "user_id": db_user.id}
+
+
+@router.post("/login")
+def login(user: UserLogin, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.email == user.email).first()
+    if not db_user:
+        raise HTTPException(status_code=400, detail="Invalid email or password")
+
+    if not bcrypt.verify(user.password, db_user.password):
+        raise HTTPException(status_code=400, detail="Invalid email or password")
+
+    # Generate JWT token
+    token = create_access_token(data={"sub": db_user.email})
+
+    return {"access_token": token, "token_type": "bearer", "user_id": db_user.id, "name": db_user.full_name}

schemas/appointment.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+router = APIRouter()
+class AppointmentInput(BaseModel):
+    patient_name: str
+    age: int
+    symptoms: str
+    specialist: str
+
+@router.post("/appointments/create")
+async def create_appointment(data: AppointmentInput):
+    print(f"Received appointment: {data}")
+    return {"message": "Appointment created", "data": data}

schemas/user.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+class UserCreate(BaseModel):
+    full_name: str
+    email: str
+    password: str
+    specialization: str
+
+
+
+class UserLogin(BaseModel):
+    email: str
+    password: str

semantic_specialist_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9472ff0898bdaadba953f7e56549c804c21dbfb5dec7a2a1f57ade6dc80a8813
+size 572198

utils/auth.py

@@ -0,0 +1,13 @@
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+
+SECRET_KEY = "your-secret-key"  # Use a strong secret and store securely
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+def create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt

utils/security.py

@@ -0,0 +1,9 @@
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def hash_password(password: str) -> str:
+    return pwd_context.hash(password)
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    return pwd_context.verify(plain_password, hashed_password)

utils/specialist_predictor.py

@@ -0,0 +1,17 @@
+from sentence_transformers import SentenceTransformer, util
+import torch
+import joblib
+
+# Load model components once
+bundle = joblib.load("semantic_specialist_model.pkl")
+model = SentenceTransformer(bundle["model_name"])
+known_embeddings = bundle["known_embeddings"]
+symptom_specialist_pairs = bundle["symptom_specialist_pairs"]
+
+def predict_specialist(symptom_text: str):
+    input_embedding = model.encode(symptom_text, convert_to_tensor=True)
+    similarities = util.pytorch_cos_sim(input_embedding, known_embeddings)[0]
+    top_idx = similarities.argmax().item()
+    specialist = symptom_specialist_pairs[top_idx][1]
+    score = similarities[top_idx].item()
+    return specialist, score

utils/stt_processor.py

@@ -0,0 +1,55 @@
+import speech_recognition as sr
+import re
+import os
+from pydub import AudioSegment
+
+def convert_to_wav_pydub(input_path: str, output_path: str = "converted_temp.wav") -> str:
+    audio = AudioSegment.from_file(input_path)
+    audio = audio.set_frame_rate(16000).set_channels(1).set_sample_width(2)  # 16-bit PCM
+    audio.export(output_path, format="wav")
+    return output_path
+
+def transcribe_audio(audio_file_path: str) -> str:
+    recognizer = sr.Recognizer()
+    
+    # Convert to proper WAV if needed
+    if not audio_file_path.lower().endswith(".wav"):
+        converted_path = convert_to_wav_pydub(audio_file_path)  # ✅ FIXED HERE
+        delete_after_use = True
+    else:
+        converted_path = convert_to_wav_pydub(audio_file_path)  # Even if WAV, reconvert to ensure PCM format
+        delete_after_use = True
+
+    try:
+        with sr.AudioFile(converted_path) as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+            print("✅ Transcribed Text:", text)
+            return text
+    except sr.UnknownValueError:
+        print("⚠️ Could not understand audio")
+        return "Could not understand audio"
+    except sr.RequestError as e:
+        print("❌ API Request Error:", e)
+        return f"Request failed: {e}"
+    finally:
+        if delete_after_use and os.path.exists(converted_path):
+            try:
+                os.remove(converted_path)
+            except PermissionError:
+                print("⚠️ Warning: File could not be deleted, still in use.")
+
+def simulate_stt(audio_file_path: str) -> dict:
+    raw_text = transcribe_audio(audio_file_path)
+
+    # Extract structured data using regex
+    name_match = re.search(r"my name is ([a-zA-Z ]+?)(?= i am| and|,|\.|$)", raw_text, re.IGNORECASE)
+    age_match = re.search(r"i am (\d+) years old", raw_text, re.IGNORECASE)
+    symptoms_match = re.search(r"suffering from (.+)", raw_text, re.IGNORECASE)
+
+    return {
+        "patient_name": name_match.group(1).strip() if name_match else "Unknown",
+        "age": int(age_match.group(1)) if age_match else 0,
+        "symptoms": symptoms_match.group(1).strip() if symptoms_match else "Not mentioned",
+        "preferred_doctor": "Not specified"
+    }