app.py

from fastapi import FastAPI
import pandas as pd
import uvicorn
import joblib
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder
from pydantic import BaseModel
import gradio as gr
import os
import requests

app = FastAPI()

# ✅ Correct Hugging Face Dataset URL
DATASET_URL = "https://huggingface.co/datasets/SailajaS/CDART/resolve/main/train.csv"

# File path for saving dataset
DATASET_PATH = "dataset.csv"

# Function to download dataset
def download_dataset():
    if not os.path.exists(DATASET_PATH):
        print("📥 Downloading dataset from Hugging Face...")
        response = requests.get(DATASET_URL)

        if response.status_code == 200:
            with open(DATASET_PATH, "wb") as file:
                file.write(response.content)
            print("✅ Dataset downloaded successfully!")
        else:
            print(f"❌ Failed to download dataset: {response.status_code}")
            raise Exception("Dataset download failed.")

# Download dataset at startup
download_dataset()

# Load dataset
df = pd.read_csv(DATASET_PATH)

# Encode categorical variables
encoder = LabelEncoder()
df["Case Problem"] = encoder.fit_transform(df["Case Problem"])
df["Feedback"] = encoder.fit_transform(df["Feedback"])

# Train Model
X = df[["Case Problem"]]
y = df["Feedback"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Save model
joblib.dump(model, "feedback_model.pkl")
print("✅ Model trained successfully!")

# API Input Model
class PredictionInput(BaseModel):
    case_problem: str

@app.post("/predict/")
def predict_feedback(data: PredictionInput):
    """ Predicts feedback based on Case Problem """
    if model is None:
        return {"error": "Model is not trained yet."}

    case_problem_encoded = encoder.transform([data.case_problem])
    prediction = model.predict([[case_problem_encoded[0]]])
    feedback_predicted = encoder.inverse_transform(prediction)[0]
    return {"Predicted Feedback": feedback_predicted}

# Gradio UI
def gradio_interface(case_problem):
    if model is None:
        return "Model not trained yet."

    case_problem_encoded = encoder.transform([case_problem])
    prediction = model.predict([[case_problem_encoded[0]]])
    feedback_predicted = encoder.inverse_transform(prediction)[0]
    return f"Predicted Feedback: {feedback_predicted}"

# Start both API & Gradio
def start_app():
    """ Start API and Gradio Interface """
    gr_interface = gr.Interface(fn=gradio_interface, inputs="text", outputs="text")
    gr_interface.launch()
    uvicorn.run(app, host="0.0.0.0", port=8000)

if __name__ == "__main__":
    start_app()