blank image issue on multiple req

Dockerfile

@@ -13,9 +13,6 @@ RUN mkdir -p /app/cache && chmod -R 777 /app/cache
 # Create the log file and set permissions
 RUN touch /app/pandasai.log && chmod 666 /app/pandasai.log
 
-# Set the MPLCONFIGDIR environment variable to a writable directory
-ENV MPLCONFIGDIR=/tmp/matplotlib
-
 # Copy the requirements file first
 COPY requirements.txt .
 

controller.py

@@ -38,7 +38,6 @@ os.makedirs("/app/cache", exist_ok=True)
 
 os.makedirs("/app", exist_ok=True)
 open("/app/pandasai.log", "a").close()  # Create the file if it doesn't exist
-os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib'
 
 # Ensure the generated_charts directory exists
 os.makedirs("/app/generated_charts", exist_ok=True)
@@ -308,179 +307,179 @@ def handle_out_of_range_float(value):
 
 # CHART CODING STARTS FROM HERE
 
-# instructions = """
+instructions = """
 
-# - Please ensure that each value is clearly visible, You may need to adjust the font size, rotate the labels, or use truncation to improve readability (if needed).
-# - For multiple charts, arrange them in a grid format (2x2, 3x3, etc.)
-# - Use colorblind-friendly palette
-# - Read above instructions and follow them.
+- Please ensure that each value is clearly visible, You may need to adjust the font size, rotate the labels, or use truncation to improve readability (if needed).
+- For multiple charts, arrange them in a grid format (2x2, 3x3, etc.)
+- Use colorblind-friendly palette
+- Read above instructions and follow them.
 
-# """
+"""
 
-# # Thread-safe configuration for chart endpoints
-# current_groq_chart_key_index = 0
-# current_groq_chart_lock = threading.Lock()
+# Thread-safe configuration for chart endpoints
+current_groq_chart_key_index = 0
+current_groq_chart_lock = threading.Lock()
 
-# current_langchain_chart_key_index = 0
-# current_langchain_chart_lock = threading.Lock()
+current_langchain_chart_key_index = 0
+current_langchain_chart_lock = threading.Lock()
 
-# def model():
-#     global current_groq_chart_key_index, current_groq_chart_lock
-#     with current_groq_chart_lock:
-#         if current_groq_chart_key_index >= len(groq_api_keys):
-#             raise Exception("All API keys exhausted for chart generation")
-#         api_key = groq_api_keys[current_groq_chart_key_index]
-#     return ChatGroq(model=model_name, api_key=api_key)
+def model():
+    global current_groq_chart_key_index, current_groq_chart_lock
+    with current_groq_chart_lock:
+        if current_groq_chart_key_index >= len(groq_api_keys):
+            raise Exception("All API keys exhausted for chart generation")
+        api_key = groq_api_keys[current_groq_chart_key_index]
+    return ChatGroq(model=model_name, api_key=api_key)
 
-# def groq_chart(csv_url: str, question: str):
-#     global current_groq_chart_key_index, current_groq_chart_lock
+def groq_chart(csv_url: str, question: str):
+    global current_groq_chart_key_index, current_groq_chart_lock
     
-#     for attempt in range(len(groq_api_keys)):
-#         try:
-#             # Clean cache before processing
-#             cache_db_path = "/workspace/cache/cache_db_0.11.db"
-#             if os.path.exists(cache_db_path):
-#                 try:
-#                     os.remove(cache_db_path)
-#                 except Exception as e:
-#                     print(f"Cache cleanup error: {e}")
-
-#             data = clean_data(csv_url)
-#             with current_groq_chart_lock:
-#                 current_api_key = groq_api_keys[current_groq_chart_key_index]
+    for attempt in range(len(groq_api_keys)):
+        try:
+            # Clean cache before processing
+            cache_db_path = "/workspace/cache/cache_db_0.11.db"
+            if os.path.exists(cache_db_path):
+                try:
+                    os.remove(cache_db_path)
+                except Exception as e:
+                    print(f"Cache cleanup error: {e}")
+
+            data = clean_data(csv_url)
+            with current_groq_chart_lock:
+                current_api_key = groq_api_keys[current_groq_chart_key_index]
             
-#             llm = ChatGroq(model=model_name, api_key=current_api_key)
+            llm = ChatGroq(model=model_name, api_key=current_api_key)
             
-#             # Generate unique filename using UUID
-#             chart_filename = f"chart_{uuid.uuid4()}.png"
-#             chart_path = os.path.join("generated_charts", chart_filename)
+            # Generate unique filename using UUID
+            chart_filename = f"chart_{uuid.uuid4()}.png"
+            chart_path = os.path.join("generated_charts", chart_filename)
             
-#             # Configure SmartDataframe with chart settings
-#             df = SmartDataframe(
-#                 data,
-#                 config={
-#                     'llm': llm,
-#                     'save_charts': True,  # Enable chart saving
-#                     'open_charts': False,
-#                     'save_charts_path': os.path.dirname(chart_path),  # Directory to save
-#                     'custom_chart_filename': chart_filename  # Unique filename
-#                 }
-#             )
+            # Configure SmartDataframe with chart settings
+            df = SmartDataframe(
+                data,
+                config={
+                    'llm': llm,
+                    'save_charts': True,  # Enable chart saving
+                    'open_charts': False,
+                    'save_charts_path': os.path.dirname(chart_path),  # Directory to save
+                    'custom_chart_filename': chart_filename  # Unique filename
+                }
+            )
             
-#             answer = df.chat(question + instructions)
+            answer = df.chat(question + instructions)
             
-#             if process_answer(answer):
-#                 return "Chart not generated"
-#             return answer
+            if process_answer(answer):
+                return "Chart not generated"
+            return answer
 
-#         except Exception as e:
-#             error = str(e)
-#             if "429" in error:
-#                 with current_groq_chart_lock:
-#                     current_groq_chart_key_index = (current_groq_chart_key_index + 1) % len(groq_api_keys)
-#             else:
-#                 print(f"Chart generation error: {error}")
-#                 return {"error": error}
+        except Exception as e:
+            error = str(e)
+            if "429" in error:
+                with current_groq_chart_lock:
+                    current_groq_chart_key_index = (current_groq_chart_key_index + 1) % len(groq_api_keys)
+            else:
+                print(f"Chart generation error: {error}")
+                return {"error": error}
     
-#     return {"error": "All API keys exhausted for chart generation"}
+    return {"error": "All API keys exhausted for chart generation"}
 
 
 
-# def langchain_csv_chart(csv_url: str, question: str, chart_required: bool):
-#     global current_langchain_chart_key_index, current_langchain_chart_lock
+def langchain_csv_chart(csv_url: str, question: str, chart_required: bool):
+    global current_langchain_chart_key_index, current_langchain_chart_lock
     
-#     data = clean_data(csv_url)
+    data = clean_data(csv_url)
 
-#     for attempt in range(len(groq_api_keys)):
-#         try:
-#             with current_langchain_chart_lock:
-#                 api_key = groq_api_keys[current_langchain_chart_key_index]
-#                 current_key = current_langchain_chart_key_index
-#                 current_langchain_chart_key_index = (current_langchain_chart_key_index + 1) % len(groq_api_keys)
-
-#             llm = ChatGroq(model=model_name, api_key=api_key)
-#             tool = PythonAstREPLTool(locals={
-#                 "df": data,
-#                 "pd": pd,
-#                 "np": np,
-#                 "plt": plt,
-#                 "sns": sns,
-#                 "matplotlib": matplotlib,
-#                 "uuid": uuid
-#             })
-
-#             agent = create_pandas_dataframe_agent(
-#                 llm,
-#                 data,
-#                 agent_type="openai-tools",
-#                 verbose=True,
-#                 allow_dangerous_code=True,
-#                 extra_tools=[tool],
-#                 return_intermediate_steps=True
-#             )
+    for attempt in range(len(groq_api_keys)):
+        try:
+            with current_langchain_chart_lock:
+                api_key = groq_api_keys[current_langchain_chart_key_index]
+                current_key = current_langchain_chart_key_index
+                current_langchain_chart_key_index = (current_langchain_chart_key_index + 1) % len(groq_api_keys)
+
+            llm = ChatGroq(model=model_name, api_key=api_key)
+            tool = PythonAstREPLTool(locals={
+                "df": data,
+                "pd": pd,
+                "np": np,
+                "plt": plt,
+                "sns": sns,
+                "matplotlib": matplotlib,
+                "uuid": uuid
+            })
 
-#             result = agent.invoke({"input": _prompt_generator(question, True)})
-#             output = result.get("output", "")
+            agent = create_pandas_dataframe_agent(
+                llm,
+                data,
+                agent_type="openai-tools",
+                verbose=True,
+                allow_dangerous_code=True,
+                extra_tools=[tool],
+                return_intermediate_steps=True
+            )
 
-#             # Verify chart file creation
-#             chart_files = extract_chart_filenames(output)
-#             if len(chart_files) > 0:
-#                 return chart_files
+            result = agent.invoke({"input": _prompt_generator(question, True)})
+            output = result.get("output", "")
 
-#             if attempt < len(groq_api_keys) - 1:
-#                 print(f"Langchain chart error (key {current_key}): {output}")
+            # Verify chart file creation
+            chart_files = extract_chart_filenames(output)
+            if len(chart_files) > 0:
+                return chart_files
 
-#         except Exception as e:
-#             print(f"Langchain chart error (key {current_key}): {str(e)}")
+            if attempt < len(groq_api_keys) - 1:
+                print(f"Langchain chart error (key {current_key}): {output}")
+
+        except Exception as e:
+            print(f"Langchain chart error (key {current_key}): {str(e)}")
     
-#     return "Chart generation failed after all retries"
+    return "Chart generation failed after all retries"
 
-# @app.post("/api/csv-chart")
-# async def csv_chart(request: dict, authorization: str = Header(None)):
-#     # Authorization verification
-#     if not authorization or not authorization.startswith("Bearer "):
-#         raise HTTPException(status_code=401, detail="Authorization required")
+@app.post("/api/csv-chart")
+async def csv_chart(request: dict, authorization: str = Header(None)):
+    # Authorization verification
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Authorization required")
     
-#     token = authorization.split(" ")[1]
-#     if token != os.getenv("AUTH_TOKEN"):
-#         raise HTTPException(status_code=403, detail="Invalid credentials")
+    token = authorization.split(" ")[1]
+    if token != os.getenv("AUTH_TOKEN"):
+        raise HTTPException(status_code=403, detail="Invalid credentials")
 
-#     try:
-#         query = request.get("query", "")
-#         csv_url = unquote(request.get("csv_url", ""))
+    try:
+        query = request.get("query", "")
+        csv_url = unquote(request.get("csv_url", ""))
         
-#         # Parallel processing with thread pool
-#         if if_initial_chart_question(query):
-#             chart_paths = await asyncio.to_thread(
-#                 langchain_csv_chart, csv_url, query, True
-#             )
-#             print(chart_paths)
+        # Parallel processing with thread pool
+        if if_initial_chart_question(query):
+            chart_paths = await asyncio.to_thread(
+                langchain_csv_chart, csv_url, query, True
+            )
+            print(chart_paths)
         
-#             if len(chart_paths) > 0:
-#                return FileResponse(f"{image_file_path}/{chart_paths[0]}", media_type="image/png")
+            if len(chart_paths) > 0:
+               return FileResponse(f"{image_file_path}/{chart_paths[0]}", media_type="image/png")
         
-#         # Groq-based chart generation
-#         groq_result = await asyncio.to_thread(groq_chart, csv_url, query)
-#         print(f"Generated Chart: {groq_result}")
-#         if groq_result != 'Chart not generated':
-#             return FileResponse(groq_result, media_type="image/png")
+        # Groq-based chart generation
+        groq_result = await asyncio.to_thread(groq_chart, csv_url, query)
+        print(f"Generated Chart: {groq_result}")
+        if groq_result != 'Chart not generated':
+            return FileResponse(groq_result, media_type="image/png")
           
         
-#         # Fallback to Langchain
-#         langchain_paths = await asyncio.to_thread(
-#             langchain_csv_chart, csv_url, query, True
-#         )
+        # Fallback to Langchain
+        langchain_paths = await asyncio.to_thread(
+            langchain_csv_chart, csv_url, query, True
+        )
         
-#         print (langchain_paths)
+        print (langchain_paths)
        
-#         if len(langchain_paths) > 0:
-#            return FileResponse(f"{image_file_path}/{langchain_paths[0]}", media_type="image/png")
-#         else:
-#            return {"error": "All chart generation methods failed"}
-
-#     except Exception as e:
-#         print(f"Critical chart error: {str(e)}")
-#         return {"error": "Internal system error"}
+        if len(langchain_paths) > 0:
+           return FileResponse(f"{image_file_path}/{langchain_paths[0]}", media_type="image/png")
+        else:
+           return {"error": "All chart generation methods failed"}
+
+    except Exception as e:
+        print(f"Critical chart error: {str(e)}")
+        return {"error": "Internal system error"}
     
     
     
@@ -569,233 +568,3 @@ def handle_out_of_range_float(value):
         
 
         
-
-
-import os
-import asyncio
-import threading
-import uuid
-from fastapi import FastAPI, HTTPException, Header
-from fastapi.responses import FileResponse
-from urllib.parse import unquote
-from pydantic import BaseModel
-from concurrent.futures import ProcessPoolExecutor
-import matplotlib.pyplot as plt
-import matplotlib
-import pandas as pd
-import numpy as np
-import seaborn as sns
-
-# Import your custom modules (assumed available)
-from csv_service import clean_data, extract_chart_filenames
-from langchain_experimental.tools import PythonAstREPLTool
-from langchain_experimental.agents import create_pandas_dataframe_agent
-from langchain_groq import ChatGroq
-from util_service import _prompt_generator, process_answer
-from intitial_q_handler import if_initial_chart_question
-
-# Use non-interactive backend
-matplotlib.use('Agg')
-
-# FastAPI app initialization
-app = FastAPI()
-
-# Ensure necessary directories exist
-os.makedirs("/app/generated_charts", exist_ok=True)
-
-
-groq_api_keys = os.getenv("GROQ_API_KEYS", "").split(",")
-model_name = os.getenv("GROQ_LLM_MODEL")
-image_file_path = os.getenv("IMAGE_FILE_PATH")  # e.g. "/app/generated_charts"
-
-# Global locks for key rotation (chart endpoints)
-current_groq_chart_key_index = 0
-current_groq_chart_lock = threading.Lock()
-current_langchain_chart_key_index = 0
-current_langchain_chart_lock = threading.Lock()
-
-# Use a process pool to run CPU-bound chart generation
-process_executor = ProcessPoolExecutor(max_workers=2)
-
-# --- GROQ-BASED CHART GENERATION ---
-def groq_chart(csv_url: str, question: str):
-    """
-    Generate a chart using the groq-based method.
-    Modifications:
-      • No deletion of a shared cache file (avoid interference).
-      • After chart generation, close all matplotlib figures.
-      • Return the full path of the saved chart.
-    """
-    global current_groq_chart_key_index, current_groq_chart_lock
-    
-    for attempt in range(len(groq_api_keys)):
-        try:
-            # Instead of deleting a global cache file, you might later configure a per-request cache.
-            data = clean_data(csv_url)
-            with current_groq_chart_lock:
-                current_api_key = groq_api_keys[current_groq_chart_key_index]
-            
-            llm = ChatGroq(model=model_name, api_key=current_api_key)
-            
-            # Generate a unique filename and full path for the chart
-            chart_filename = f"chart_{uuid.uuid4().hex}.png"
-            chart_path = os.path.join("generated_charts", chart_filename)
-            
-            # Configure your dataframe tool (e.g. using SmartDataframe) to save charts.
-            # (Assuming your SmartDataframe uses these settings to save charts.)
-            from pandasai import SmartDataframe  # Import here if not already imported
-            df = SmartDataframe(
-                data,
-                config={
-                    'llm': llm,
-                    'save_charts': True,
-                    'open_charts': False,
-                    'save_charts_path': os.path.dirname(chart_path),
-                    'custom_chart_filename': chart_filename
-                }
-            )
-            
-            # Append any extra instructions if needed
-            instructions = """
-            - Ensure each value is clearly visible.
-            - Adjust font sizes, rotate labels if necessary.
-            - Use a colorblind-friendly palette.
-            - Arrange multiple charts in a grid if needed.
-            """
-            answer = df.chat(question + instructions)
-            
-            # Make sure to close figures so they don't conflict between processes
-            plt.close('all')
-            
-            # If process_answer indicates a problem, return a failure message.
-            if process_answer(answer):
-                return "Chart not generated"
-            # Return the chart path that was used for saving
-            return chart_path
-
-        except Exception as e:
-            error = str(e)
-            if "429" in error:
-                with current_groq_chart_lock:
-                    current_groq_chart_key_index = (current_groq_chart_key_index + 1) % len(groq_api_keys)
-            else:
-                print(f"Groq chart generation error: {error}")
-                return {"error": error}
-    
-    return {"error": "All API keys exhausted for chart generation"}
-
-
-# --- LANGCHAIN-BASED CHART GENERATION ---
-def langchain_csv_chart(csv_url: str, question: str, chart_required: bool):
-    """
-    Generate a chart using the langchain-based method.
-    Modifications:
-      • No shared deletion of cache.
-      • Close matplotlib figures after generation.
-      • Return a list of full chart file paths.
-    """
-    global current_langchain_chart_key_index, current_langchain_chart_lock
-    
-    data = clean_data(csv_url)
-
-    for attempt in range(len(groq_api_keys)):
-        try:
-            with current_langchain_chart_lock:
-                api_key = groq_api_keys[current_langchain_chart_key_index]
-                current_key = current_langchain_chart_key_index
-                current_langchain_chart_key_index = (current_langchain_chart_key_index + 1) % len(groq_api_keys)
-
-            llm = ChatGroq(model=model_name, api_key=api_key)
-            tool = PythonAstREPLTool(locals={
-                "df": data,
-                "pd": pd,
-                "np": np,
-                "plt": plt,
-                "sns": sns,
-                "matplotlib": matplotlib,
-                "uuid": uuid
-            })
-
-            agent = create_pandas_dataframe_agent(
-                llm,
-                data,
-                agent_type="openai-tools",
-                verbose=True,
-                allow_dangerous_code=True,
-                extra_tools=[tool],
-                return_intermediate_steps=True
-            )
-
-            result = agent.invoke({"input": _prompt_generator(question, True)})
-            output = result.get("output", "")
-
-            # Close figures to avoid interference
-            plt.close('all')
-
-            # Extract chart filenames (assuming extract_chart_filenames returns a list)
-            chart_files = extract_chart_filenames(output)
-            if len(chart_files) > 0:
-                # Return full paths (join with your image_file_path)
-                return [os.path.join(image_file_path, f) for f in chart_files]
-
-            if attempt < len(groq_api_keys) - 1:
-                print(f"Langchain chart error (key {current_key}): {output}")
-
-        except Exception as e:
-            print(f"Langchain chart error (key {current_key}): {str(e)}")
-    
-    return "Chart generation failed after all retries"
-
-
-# --- FASTAPI ENDPOINT FOR CHART GENERATION ---
-@app.post("/api/csv-chart")
-async def csv_chart(request: dict, authorization: str = Header(None)):
-    """
-    Endpoint for generating a chart from CSV data.
-    This endpoint uses a ProcessPoolExecutor to run the (CPU-bound) chart generation
-    functions in separate processes so that multiple requests can run in parallel.
-    """
-    # --- Authorization Check ---
-    if not authorization or not authorization.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="Authorization required")
-    
-    token = authorization.split(" ")[1]
-    if token != os.getenv("AUTH_TOKEN"):
-        raise HTTPException(status_code=403, detail="Invalid credentials")
-
-    try:
-        query = request.get("query", "")
-        csv_url = unquote(request.get("csv_url", ""))
-        
-        loop = asyncio.get_running_loop()
-        # First, try the langchain-based method if the question qualifies
-        if if_initial_chart_question(query):
-            langchain_result = await loop.run_in_executor(
-                process_executor, langchain_csv_chart, csv_url, query, True
-            )
-            print("Langchain chart result:", langchain_result)
-            if isinstance(langchain_result, list) and len(langchain_result) > 0:
-               return FileResponse(langchain_result[0], media_type="image/png")
-        
-        # Next, try the groq-based method
-        groq_result = await loop.run_in_executor(
-            process_executor, groq_chart, csv_url, query
-        )
-        print(f"Groq chart result: {groq_result}")
-        if isinstance(groq_result, str) and groq_result != "Chart not generated":
-            return FileResponse(groq_result, media_type="image/png")
-          
-        # Fallback: try langchain-based again
-        langchain_paths = await loop.run_in_executor(
-            process_executor, langchain_csv_chart, csv_url, query, True
-        )
-        print("Fallback langchain chart result:", langchain_paths)
-        if isinstance(langchain_paths, list) and len(langchain_paths) > 0:
-           return FileResponse(langchain_paths[0], media_type="image/png")
-        else:
-           return {"error": "All chart generation methods failed"}
-
-    except Exception as e:
-        print(f"Critical chart error: {str(e)}")
-        return {"error": "Internal system error"}
-