blank image issue on multiple req

controller.py

@@ -307,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
-            })
+#     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
+#             )
 
-            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", "")
 
-            result = agent.invoke({"input": _prompt_generator(question, True)})
-            output = result.get("output", "")
+#             # Verify chart file creation
+#             chart_files = extract_chart_filenames(output)
+#             if len(chart_files) > 0:
+#                 return chart_files
 
-            # Verify chart file creation
-            chart_files = extract_chart_filenames(output)
-            if len(chart_files) > 0:
-                return chart_files
+#             if attempt < len(groq_api_keys) - 1:
+#                 print(f"Langchain chart error (key {current_key}): {output}")
 
-            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)}")
+#         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"}
     
     
     
@@ -568,3 +568,231 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         
 
         
+
+
+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()
+
+# Environment variables and configuration
+import os
+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"}
+