Update app.py

app.py

@@ -1,69 +1,64 @@
 import gradio as gr
 import pandas as pd
-import torch
 import matplotlib.pyplot as plt
 import seaborn as sns
-from fastapi import FastAPI
-from transformers import pipeline
-
-# ✅ Load Hugging Face models dynamically
-code_generator = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.2")
-user_input_processor = pipeline("text-generation", model="tiiuae/falcon-7b-instruct")
-table_analyzer = pipeline("table-question-answering", model="google/tapas-large")
-image_captioner = pipeline("image-to-text", model="Salesforce/blip2-opt-2.7b")
+import openai
+import fastapi
+from fastapi import FastAPI, UploadFile, File
+import io
 
+# Initialize FastAPI app
 app = FastAPI()
 
-def generate_visualization(excel_file, user_request):
-    try:
-        # ✅ Load Excel file
-        df = pd.read_excel(excel_file)
-
-        # ✅ Convert DataFrame to JSON (for TAPAS model input)
-        table_data = df.to_dict(orient="records")
-
-        # ✅ Analyze table using TAPAS (Google's Table-based QA model)
-        table_answer = table_analyzer(question=user_request, table=table_data)
+# Function to generate Python visualization code using Hugging Face model
+def generate_viz_code(prompt: str) -> str:
+    """Generate Python code for visualization based on user prompt."""
+    response = openai.ChatCompletion.create(
+        model="mistralai/Mistral-7B",  # Replace with the actual Hugging Face model
+        messages=[
+            {"role": "system", "content": "You are an AI assistant for data visualization."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return response["choices"][0]["message"]["content"]
 
-        # ✅ Generate Python visualization code with StarCoder
-        prompt = f"Generate Python code using Matplotlib and Seaborn to visualize: {user_request} from this data:\n{df.head()}"
-        code_response = code_generator(prompt, max_new_tokens=200, do_sample=True)[0]["generated_text"]
+# Function to handle file upload and visualization
+def visualize_data(file: UploadFile, prompt: str):
+    try:
+        # Read the uploaded Excel file
+        contents = file.file.read()
+        df = pd.read_excel(io.BytesIO(contents))
 
-        # ✅ Extract relevant Python code
-        code_lines = code_response.split("\n")
-        python_code = "\n".join([line for line in code_lines if "import" in line or "plt." in line or "sns." in line])
+        # Generate visualization code
+        code = generate_viz_code(prompt)
+        print("Generated Code:\n", code)  # Debug output
 
-        # ✅ Execute generated code safely
-        exec_globals = {"df": df, "plt": plt, "sns": sns}
-        try:
-            exec(python_code, exec_globals)
-        except Exception as e:
-            return None, f"Error in generated code: {str(e)}", table_answer
+        # Execute the generated code
+        exec_globals = {"plt": plt, "sns": sns, "pd": pd, "df": df}
+        exec(code, exec_globals)
 
-        # ✅ Save the visualization as an image
-        plt.savefig("output.png")
+        # Save the generated plot
+        img_path = "visualization.png"
+        plt.savefig(img_path)
         plt.close()
-
-        return "output.png", python_code, table_answer
+        return img_path
     except Exception as e:
-        return None, None, f"Error: {str(e)}"
+        return f"Error: {str(e)}"
 
-# ✅ Gradio UI
-gradio_ui = gr.Interface(
-    fn=generate_visualization,
-    inputs=[gr.File(label="Upload Excel File"), gr.Textbox(label="Enter Visualization Request")],
-    outputs=[gr.Image(label="Generated Visualization"), gr.Code(label="Generated Python Code"), gr.Textbox(label="Table Insights")],
-    title="AI-Powered Data Visualization"
+# Define Gradio interface
+gui = gr.Interface(
+    fn=visualize_data,
+    inputs=[gr.File(label="Upload Excel File"), gr.Textbox(label="Describe your visualization request")],
+    outputs=gr.Image(label="Generated Visualization"),
+    title="AI-Powered Data Visualization Generator",
+    description="Upload an Excel file and describe the visualization, and AI will generate it using Matplotlib/Seaborn."
 )
 
-# ✅ Mount Gradio app to FastAPI
-@app.get("/")
-def home():
-    return {"message": "Welcome to AI-Powered Data Visualization"}
-
-app = gr.mount_gradio_app(app, gradio_ui, path="/visualization")
+# Integrate Gradio with FastAPI
+app = gr.mount_gradio_app(app, gui, path="/")
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+# Uncomment below to run standalone FastAPI app
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)