use supabase

controller.py

@@ -26,6 +26,7 @@ import matplotlib.pyplot as plt
 import matplotlib
 import seaborn as sns
 from intitial_q_handler import if_initial_chart_question, if_initial_chat_question
+from supabase_service import upload_image_to_supabase
 from util_service import _prompt_generator, process_answer
 from fastapi.middleware.cors import CORSMiddleware
 import matplotlib
@@ -128,7 +129,12 @@ async def get_image(request: ImageRequest, authorization: str = Header(None)):
 
     try:
         image_file_path = request.image_path
-        return FileResponse(image_file_path, media_type="image/png")
+        unique_file_name =f'{str(uuid.uuid4())}.png'
+        logger.info("Uploading the chart to supabase...")
+        image_public_url = await upload_image_to_supabase(f"{image_file_path}", unique_file_name)
+        logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
+        return {"image_url": image_public_url}
+        # return FileResponse(image_file_path, media_type="image/png")
     except Exception as e:
         logger.error(f"Error: {e}")
         return {"answer": "error"}
@@ -789,7 +795,12 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
             )
             logger.info("Langchain chart result:", langchain_result)
             if isinstance(langchain_result, list) and len(langchain_result) > 0:
-               return FileResponse(langchain_result[0], media_type="image/png")
+                unique_file_name =f'{str(uuid.uuid4())}.png'
+                logger.info("Uploading the chart to supabase...")
+                image_public_url = await upload_image_to_supabase(f"{langchain_result[0]}", unique_file_name)
+                logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
+                return {"image_url": image_public_url}
+               # return FileResponse(langchain_result[0], media_type="image/png")
         
         # Next, try the groq-based method
         groq_result = await loop.run_in_executor(
@@ -797,7 +808,12 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         )
         logger.info(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")
+            unique_file_name =f'{str(uuid.uuid4())}.png'
+            logger.info("Uploading the chart to supabase...")
+            image_public_url = await upload_image_to_supabase(f"{groq_result}", unique_file_name)
+            logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
+            return {"image_url": image_public_url}
+            # return FileResponse(groq_result, media_type="image/png")
           
         # Fallback: try langchain-based again
         logger.error("Groq chart generation failed, trying langchain....")
@@ -806,7 +822,12 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         )
         logger.info("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")
+           unique_file_name =f'{str(uuid.uuid4())}.png'
+           logger.info("Uploading the chart to supabase...")
+           image_public_url = await upload_image_to_supabase(f"{langchain_paths[0]}", unique_file_name)
+           logger.info("Image uploaded to Supabase and Image URL is... ", {image_public_url})
+           return {"image_url": image_public_url}
+           # return FileResponse(langchain_paths[0], media_type="image/png")
         else:
            logger.error("All chart generation methods failed")
            return {"answer": "error"}

requirements.txt

@@ -12,4 +12,5 @@ langchain_experimental==0.3.3
 tabulate==0.9.0
 gradio>=4.0.0
 google-generativeai==0.8.3
-langchain-google-genai==2.0.7
+langchain-google-genai==2.0.7
+supabase==2.13.0

rethink_gemini_agents/gemini_langchain_service.py

@@ -1,205 +0,0 @@
-import os
-import re
-import uuid
-from langchain_google_genai import ChatGoogleGenerativeAI
-import pandas as pd
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_experimental.tools import PythonAstREPLTool
-from langchain_experimental.agents import create_pandas_dataframe_agent
-from dotenv import load_dotenv
-import numpy as np
-import matplotlib.pyplot as plt
-import matplotlib
-import seaborn as sns
-
-
-# Set the backend for matplotlib to 'Agg' to avoid GUI issues
-matplotlib.use('Agg')
-
-load_dotenv()
-model_name = os.getenv("GOOGLE_GENERATIVE_AI_MODEL_LANGCHAIN_AGENT")
-google_api_keys = os.getenv("GOOGLE_GENERATIVE_AI_API_KEYS").split(",")
-current_key_index = 0  # Global index for API keys
-
-
-def _prompt_generator(question: str, chart_required: bool):
-
-    chat_prompt = f"""You are a senior data analyst working with CSV data. Adhere strictly to the following guidelines:  
-
-                         1. **Data Verification:** Always inspect the data with `.sample(5).to_dict()` before performing any analysis.  
-                         2. **Data Integrity:** Ensure proper handling of null values to maintain accuracy and reliability.  
-                         3. **Communication:** Provide concise, professional, and well-structured responses.
-                         4. Avoid including any internal processing details or references to the methods used to generate your response (ex: based on the tool call, using the function -> These types of phrases.)
-
-                         **Query:** {question}  
-         
-                    """               
-        
-    chart_prompt = f"""You are a senior data analyst working with CSV data. Follow these rules STRICTLY:
-
-                       1. Generate ONE unique identifier FIRST using: unique_id = uuid.uuid4().hex
-                       2. Visualization requirements:
-                       - Adjust font sizes, rotate labels (45° if needed), truncate for readability
-                       - Figure size: (12, 6)
-                       - Descriptive titles (fontsize=14)
-                       - Colorblind-friendly palettes
-                       3. File handling rules:
-                       - Create MAXIMUM 2 charts if absolutely necessary
-                       - For multiple charts:
-                           * Arrange in grid format (2x1 vertical layout preferred)
-                           * Use SAME unique_id with suffixes: 
-                           - f"{{unique_id}}_1.png"
-                           - f"{{unique_id}}_2.png"
-                       - Save EXCLUSIVELY to "generated_charts" folder
-                       - File naming: f"chart_{{unique_id}}.png" (for single chart)
-                       4. FINAL OUTPUT MUST BE:
-                       - For single chart: f"generated_charts/chart_{{unique_id}}.png"
-                       - For multiple charts: f"generated_charts/chart_{{unique_id}}.png" (combined grid image)
-                       - ONLY return this full path string, nothing else
-
-                       **Query:** {question}
-
-                       IMPORTANT: 
-                       - Generate the unique_id FIRST before any operations
-                       - Use THE SAME unique_id throughout entire process
-                       - NEVER generate new UUIDs after initial creation
-                       - Return EXACT filepath string of the final saved chart
-                       """
-
-        
-    if chart_required:
-        return ChatPromptTemplate.from_template(chart_prompt)
-    else:
-        return ChatPromptTemplate.from_template(chat_prompt)
-
-
-
-def langchain_gemini_csv_chat(csv_url: str, question: str, chart_required: bool):
-    global current_key_index
-
-    data = pd.read_csv(csv_url)
-    # Try each API key until a successful response is generated or keys run out
-    attempts = 0
-    total_keys = len(google_api_keys)
-    while attempts < total_keys:
-        try:
-            # Select the current API key
-            api_key = google_api_keys[current_key_index]
-            print(f"Using API key index {current_key_index}")
-
-            # Initialize the LLM with the current API key
-            llm = ChatGoogleGenerativeAI(model=model_name, api_key=api_key)
-
-            # Prepare the Python REPL tool with the dataframe and necessary libraries
-            tool = PythonAstREPLTool(locals={
-                "df": data,
-                "pd": pd,
-                "np": np,
-                "plt": plt,  # Ensure plt is available
-                "sns": sns,
-                "matplotlib": matplotlib,
-                "uuid": uuid,
-            })
-
-            # Create the pandas agent with the provided tools and settings
-            agent = create_pandas_dataframe_agent(
-                llm,
-                data,
-                agent_type="openai-tools",
-                verbose=True,
-                allow_dangerous_code=True,
-                extra_tools=[tool],
-                return_intermediate_steps=True
-            )
-
-            chat_prompt = _prompt_generator(question, chart_required)
-            # Attempt to invoke the agent with the question
-            result = agent.invoke({"input": chat_prompt})
-            # If successful, return the output
-            return result.get("output")
-        
-        except Exception as e:
-            # Log the error along with the current API key index
-            print(f"Error using API key index {current_key_index}: {e}")
-
-            # Move to the next API key
-            current_key_index += 1
-            attempts += 1
-
-            # If all keys have been exhausted, exit the loop
-            if current_key_index >= total_keys:
-                print("All API keys have been exhausted.")
-                return None
-
-
-
-
-def langchain_gemini_csv_chart(csv_url: str, question: str, chart_required: bool):
-    global current_key_index
-    data = pd.read_csv(csv_url)
-    
-    # Try each API key until a successful response is generated or keys run out
-    attempts = 0
-    total_keys = len(google_api_keys)
-    while attempts < total_keys:
-        try:
-            # Select the current API key
-            api_key = google_api_keys[current_key_index]
-            print(f"Using API key index {current_key_index}")
-
-            # Initialize the LLM with the current API key
-            llm = ChatGoogleGenerativeAI(model=model_name, api_key=api_key)
-
-            # Prepare the Python REPL tool with the dataframe and necessary libraries
-            tool = PythonAstREPLTool(locals={
-                "df": data,
-                "pd": pd,
-                "np": np,
-                "plt": plt,  # Ensure plt is available
-                "sns": sns,
-                "matplotlib": matplotlib
-            })
-
-            # Create the pandas agent with the provided tools and settings
-            agent = create_pandas_dataframe_agent(
-                llm,
-                data,
-                agent_type="openai-tools",
-                verbose=True,
-                allow_dangerous_code=True,
-                extra_tools=[tool],
-                return_intermediate_steps=True
-            )
-
-            chart_prompt = _prompt_generator(question, chart_required)
-            # Attempt to invoke the agent with the question
-            result = agent.invoke({"input": chart_prompt})
-            # If successful, return the output
-            return result.get("output")
-        
-        except Exception as e:
-            # Log the error along with the current API key index
-            print(f"Error using API key index {current_key_index}: {e}")
-
-            # Move to the next API key
-            current_key_index += 1
-            attempts += 1
-
-            # If all keys have been exhausted, exit the loop
-            if current_key_index >= total_keys:
-                print("All API keys have been exhausted.")
-                return None
-
-
-
-
-
-
-
-# Example usage:
-if __name__ == "__main__":
-    csv_url = "./documents/titanic.csv"
-    question = "Create a pie chart of males vs females"
-    output = langchain_gemini_csv_chat(csv_url, question, True)
-    print("Agent output:", output)
-   

rethink_gemini_agents/rethink_chart.py

@@ -1,266 +0,0 @@
-import pandas as pd
-import re
-import os
-import uuid
-import logging
-from io import StringIO
-import sys
-import traceback
-from typing import Optional, Dict, Any, List
-from pydantic import BaseModel, Field
-from google.generativeai import GenerativeModel, configure
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-API_KEYS = os.getenv("GOOGLE_GENERATIVE_AI_API_KEYS", "").split(",")
-MODEL_NAME = os.getenv("GOOGLE_GENERATIVE_AI_MODEL")
-
-# Set up non-interactive matplotlib backend
-os.environ['MPLBACKEND'] = 'agg'
-import matplotlib.pyplot as plt
-plt.show = lambda: None  # Monkey patch to disable display
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler('api_key_rotation.log'), logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-class GeminiKeyManager:
-    """Manage multiple Gemini API keys with failover"""
-    
-    def __init__(self, api_keys: List[str]):
-        self.original_keys = api_keys.copy()
-        self.available_keys = api_keys.copy()
-        self.active_key = None
-        self.failed_keys = {}
-        
-    def configure(self) -> bool:
-        """Try to configure API with available keys"""
-        while self.available_keys:
-            key = self.available_keys.pop(0)
-            try:
-                configure(api_key=key)
-                self.active_key = key
-                logger.info(f"Successfully configured with key: {self._mask_key(key)}")
-                return True
-            except Exception as e:
-                self.failed_keys[key] = str(e)
-                logger.error(f"Key failed: {self._mask_key(key)}. Error: {str(e)}")
-                
-        logger.critical("All API keys failed to configure")
-        return False
-    
-    def _mask_key(self, key: str) -> str:
-        return f"{key[:8]}...{key[-4:]}" if key else ""
-
-class PythonREPL:
-    """Secure Python REPL with non-interactive plotting"""
-    
-    def __init__(self, df: pd.DataFrame):
-        self.df = df
-        self.local_env = {
-            "pd": pd,
-            "df": self.df.copy(),
-            "plt": plt,
-            "os": os,
-            "uuid": uuid,
-            "plt": plt
-        }
-        os.makedirs('generated_charts', exist_ok=True)
-        
-    def execute(self, code: str) -> Dict[str, Any]:
-        old_stdout = sys.stdout
-        sys.stdout = mystdout = StringIO()
-        
-        try:
-            # Ensure figure closure and non-interactive mode
-            code = f"""
-import matplotlib.pyplot as plt
-plt.switch_backend('agg')
-{code}
-plt.close('all')
-            """
-            exec(code, self.local_env)
-            self.df = self.local_env.get('df', self.df)
-            error = False
-        except Exception as e:
-            error_msg = traceback.format_exc()
-            error = True
-        finally:
-            sys.stdout = old_stdout
-            
-        return {
-            "output": mystdout.getvalue(),
-            "error": error,
-            "error_message": error_msg if error else None,
-            "df": self.local_env.get('df', self.df)
-        }
-
-class RethinkAgent(BaseModel):
-    df: pd.DataFrame
-    max_retries: int = Field(default=5, ge=1)
-    gemini_model: Optional[GenerativeModel] = None
-    current_retry: int = Field(default=0, ge=0)
-    repl: Optional[PythonREPL] = None
-    key_manager: Optional[GeminiKeyManager] = None
-    
-    class Config:
-        arbitrary_types_allowed = True
-        
-    def _extract_code(self, response: str) -> str:
-        code_match = re.search(r'```python(.*?)```', response, re.DOTALL)
-        return code_match.group(1).strip() if code_match else response.strip()
-    
-    def _generate_initial_prompt(self, query: str) -> str:
-        columns = "\n".join(self.df.columns)
-        return f"""
-        Generate Python code to analyze this DataFrame with columns:
-        {columns}
-        
-        Query: {query}
-        
-        Requirements:
-        1. Save visualizations to 'generated_charts/' with UUID filename
-        2. Use plt.savefig() with format='png'
-        3. No plt.show() calls allowed
-        4. After saving each chart, print exactly: CHART_SAVED: generated_charts/{{uuid}}.png
-        5. Start with 'import pandas as pd'
-        6. The DataFrame is available as 'df'
-        7. Wrap code in ```python``` blocks
-        """
-    
-    def _generate_retry_prompt(self, query: str, error: str, code: str) -> str:
-        return f"""
-        Previous code failed with error:
-        {error}
-        
-        Revise this code:
-        {code}
-        
-        New requirements:
-        1. Fix the error
-        2. Ensure plots are saved to generated_charts/
-        3. After saving each chart, print exactly: CHART_SAVED: generated_charts/{{uuid}}.png
-        4. No figure display
-        5. Complete query: {query}
-        
-        Explain the error first, then show corrected code in ```python``` blocks
-        """
-    
-    def initialize_model(self, api_keys: List[str]) -> bool:
-        """Initialize Gemini model with key rotation"""
-        self.key_manager = GeminiKeyManager(api_keys)
-        if not self.key_manager.configure():
-            raise RuntimeError("All API keys failed to initialize")
-        
-        try:
-            self.gemini_model = GenerativeModel(MODEL_NAME)
-            return True
-        except Exception as e:
-            logger.error(f"Model initialization failed: {str(e)}")
-            return False
-    
-    def generate_code(self, query: str, error: Optional[str] = None, previous_code: Optional[str] = None) -> str:
-        if error:
-            prompt = self._generate_retry_prompt(query, error, previous_code)
-        else:
-            prompt = self._generate_initial_prompt(query)
-            
-        try:
-            response = self.gemini_model.generate_content(prompt)
-            return self._extract_code(response.text)
-        except Exception as e:
-            logger.error(f"API call failed: {str(e)}")
-            if self.key_manager.available_keys:
-                logger.info("Attempting key rotation...")
-                if self.key_manager.configure():
-                    self.gemini_model = GenerativeModel(MODEL_NAME)
-                    return self.generate_code(query, error, previous_code)
-            raise
-    
-    def execute_query(self, query: str) -> str:
-        self.repl = PythonREPL(self.df)
-        error = None
-        previous_code = None
-        
-        while self.current_retry < self.max_retries:
-            try:
-                code = self.generate_code(query, error, previous_code)
-                result = self.repl.execute(code)
-                
-                if result["error"]:
-                    self.current_retry += 1
-                    error = result["error_message"]
-                    previous_code = code
-                    logger.warning(f"Retry {self.current_retry}/{self.max_retries}...")
-                else:
-                    self.df = result["df"]
-                    return result["output"]
-            except Exception as e:
-                logger.error(f"Critical failure: {str(e)}")
-                return f"System error: {str(e)}"
-        
-        return f"Failed after {self.max_retries} attempts. Last error: {error}"
-
-
-
-def gemini_llm_chart(csv_url: str, query: str) -> str:
-    df = pd.read_csv(csv_url)
-    
-    agent = RethinkAgent(df=df)
-    if not agent.initialize_model(API_KEYS):
-        print("Failed to initialize model with provided keys")
-        exit(1)
-        
-    result = agent.execute_query(query)
-    print("\nAnalysis Result:")
-    print(result)
-    
-    if isinstance(result, str):
-     result = result.strip()  # Remove any leading/trailing spaces or newlines
-
-     match = re.search(r'CHART_SAVED:\s*(\S+)', result)
-
-     if match:
-        chart_path = match.group(1)
-        print("Chart Path:", chart_path)
-        return chart_path
-     else:
-        print("Chart path not found")
-        return "Chart path not found"
-    else:
-     print("Unexpected result format:", type(result))
-     return "Chart path not found"
-
-
-
-# Usage Example
-# if __name__ == "__main__":
-#     df = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv')
-    
-#     agent = RethinkAgent(df=df)
-#     if not agent.initialize_model(API_KEYS):
-#         print("Failed to initialize model with provided keys")
-#         exit(1)
-        
-#     result = agent.execute_query("Create a scatter plot of total_bill vs tip with kernel density estimate")
-#     print("\nAnalysis Result:")
-#     print(result)
-    
-#     if isinstance(result, str):
-#      result = result.strip()  # Remove any leading/trailing spaces or newlines
-
-#      match = re.search(r'CHART_SAVED:\s*(\S+)', result)
-
-#      if match:
-#         chart_path = match.group(1)
-#         print("Chart Path:", chart_path)
-#      else:
-#         print("Chart path not found")
-#     else:
-#      print("Unexpected result format:", type(result))

rethink_gemini_agents/rethink_chat.py

@@ -1,259 +0,0 @@
-import pandas as pd
-import re
-import os
-import uuid
-import logging
-from io import StringIO
-import sys
-import traceback
-from typing import Optional, Dict, Any, List
-from pydantic import BaseModel, Field
-from google.generativeai import GenerativeModel, configure
-from dotenv import load_dotenv
-import seaborn as sns
-from csv_service import clean_data
-from util_service import handle_out_of_range_float
-
-pd.set_option('display.max_columns', None)  # Show all columns
-pd.set_option('display.max_rows', None)     # Show all rows
-pd.set_option('display.max_colwidth', None)   # Do not truncate cell content
-
-# Load environment variables from .env file
-load_dotenv()
-
-API_KEYS = os.getenv("GOOGLE_GENERATIVE_AI_API_KEYS", "").split(",")
-MODEL_NAME = os.getenv("GOOGLE_GENERATIVE_AI_MODEL")
-
-# Set up non-interactive matplotlib backend
-os.environ['MPLBACKEND'] = 'agg'
-import matplotlib.pyplot as plt
-plt.show = lambda: None  # Monkey patch to disable display
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler('api_key_rotation.log'), logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-class GeminiKeyManager:
-    """Manage multiple Gemini API keys with failover"""
-    
-    def __init__(self, api_keys: List[str]):
-        self.original_keys = api_keys.copy()
-        self.available_keys = api_keys.copy()
-        self.active_key = None
-        self.failed_keys = {}
-        
-    def configure(self) -> bool:
-        """Try to configure API with available keys"""
-        while self.available_keys:
-            key = self.available_keys.pop(0)
-            try:
-                configure(api_key=key)
-                self.active_key = key
-                logger.info(f"Successfully configured with key: {self._mask_key(key)}")
-                return True
-            except Exception as e:
-                self.failed_keys[key] = str(e)
-                logger.error(f"Key failed: {self._mask_key(key)}. Error: {str(e)}")
-                
-        logger.critical("All API keys failed to configure")
-        return False
-    
-    def _mask_key(self, key: str) -> str:
-        return f"{key[:8]}...{key[-4:]}" if key else ""
-
-class PythonREPL:
-    """Secure Python REPL with non-interactive plotting"""
-    
-    def __init__(self, df: pd.DataFrame):
-        self.df = df
-        self.local_env = {
-            "pd": pd,
-            "df": self.df.copy(),
-            "plt": plt,
-            "os": os,
-            "uuid": uuid,
-            "plt": plt,
-            "sns": sns,
-        }
-        os.makedirs('generated_charts', exist_ok=True)
-        
-    def execute(self, code: str) -> Dict[str, Any]:
-        old_stdout = sys.stdout
-        sys.stdout = mystdout = StringIO()
-        
-        try:
-            # Ensure figure closure and non-interactive mode
-            code = f"""
-import matplotlib.pyplot as plt
-plt.switch_backend('agg')
-{code}
-plt.close('all')
-            """
-            exec(code, self.local_env)
-            self.df = self.local_env.get('df', self.df)
-            error = False
-        except Exception as e:
-            error_msg = traceback.format_exc()
-            error = True
-        finally:
-            sys.stdout = old_stdout
-            
-        return {
-            "output": mystdout.getvalue(),
-            "error": error,
-            "error_message": error_msg if error else None,
-            "df": self.local_env.get('df', self.df)
-        }
-
-class RethinkAgent(BaseModel):
-    df: pd.DataFrame
-    max_retries: int = Field(default=5, ge=1)
-    gemini_model: Optional[GenerativeModel] = None
-    current_retry: int = Field(default=0, ge=0)
-    repl: Optional[PythonREPL] = None
-    key_manager: Optional[GeminiKeyManager] = None
-    
-    class Config:
-        arbitrary_types_allowed = True
-        
-    def _extract_code(self, response: str) -> str:
-        code_match = re.search(r'```python(.*?)```', response, re.DOTALL)
-        return code_match.group(1).strip() if code_match else response.strip()
-    
-    def _generate_initial_prompt(self, query: str) -> str:
-        columns = "\n".join(self.df.columns)
-        return f"""
-        You are a data analyst assistant. Generate Python code to analyze this DataFrame with columns:
-        {columns}
-        
-        Query: {query}
-        
-        Requirements:
-        1. Use print() to show results
-        2. Start with 'import pandas as pd'
-        3. The DataFrame is available as 'df'
-        4. Wrap code in ```python``` blocks
-        """
-    
-    def _generate_retry_prompt(self, query: str, error: str, code: str) -> str:
-        return f"""
-        Previous code failed with error:
-        {error}
-        
-        Failed code:
-        {code}
-        
-        Revise the code to fix the error and complete this query:
-        {query}
-        
-        Requirements:
-        1. Explain the error first
-        2. Show corrected code in ```python``` blocks
-        """
-    
-    def initialize_model(self, api_keys: List[str]) -> bool:
-        """Initialize Gemini model with key rotation"""
-        self.key_manager = GeminiKeyManager(api_keys)
-        if not self.key_manager.configure():
-            raise RuntimeError("All API keys failed to initialize")
-        
-        try:
-            self.gemini_model = GenerativeModel(MODEL_NAME)
-            return True
-        except Exception as e:
-            logger.error(f"Model initialization failed: {str(e)}")
-            return False
-    
-    def generate_code(self, query: str, error: Optional[str] = None, previous_code: Optional[str] = None) -> str:
-        if error:
-            prompt = self._generate_retry_prompt(query, error, previous_code)
-        else:
-            prompt = self._generate_initial_prompt(query)
-            
-        try:
-            response = self.gemini_model.generate_content(prompt)
-            return self._extract_code(response.text)
-        except Exception as e:
-            logger.error(f"API call failed: {str(e)}")
-            if self.key_manager.available_keys:
-                logger.info("Attempting key rotation...")
-                if self.key_manager.configure():
-                    self.gemini_model = GenerativeModel(MODEL_NAME)
-                    return self.generate_code(query, error, previous_code)
-            raise
-    
-    def execute_query(self, query: str) -> str:
-        self.repl = PythonREPL(self.df)
-        error = None
-        previous_code = None
-        
-        while self.current_retry < self.max_retries:
-            try:
-                code = self.generate_code(query, error, previous_code)
-                result = self.repl.execute(code)
-                
-                if result["error"]:
-                    self.current_retry += 1
-                    error = result["error_message"]
-                    previous_code = code
-                    logger.warning(f"Retry {self.current_retry}/{self.max_retries}...")
-                else:
-                    self.df = result["df"]
-                    return result["output"]
-            except Exception as e:
-                logger.error(f"Critical failure: {str(e)}")
-                return f"System error: {str(e)}"
-        
-        return f"Failed after {self.max_retries} attempts. Last error: {error}"
-
-
-def gemini_llm_chat(csv_url: str, query: str) -> str:
-    
-    try:
-    # Assuming clean_data and RethinkAgent are defined elsewhere
-     df = clean_data(csv_url)
-     agent = RethinkAgent(df=df)
-    
-     # Assuming API_KEYS is defined elsewhere
-     if not agent.initialize_model(API_KEYS):
-         print("Failed to initialize model with provided keys")
-         exit(1)
-
-     result = agent.execute_query(query)
-    
-     # Process different response types
-     if isinstance(result, pd.DataFrame):
-         processed = result.apply(handle_out_of_range_float).to_dict(orient="records")
-     elif isinstance(result, pd.Series):
-        processed = result.apply(handle_out_of_range_float).to_dict()
-     elif isinstance(result, list):
-         processed = [handle_out_of_range_float(item) for item in result]
-     elif isinstance(result, dict):
-         processed = {k: handle_out_of_range_float(v) for k, v in result.items()}
-     else:
-         processed = {"answer": str(handle_out_of_range_float(result))}
-
-     logger.info(f"gemini processed result: {processed}")
-     return processed
-    except Exception as e:
-        logger.error(f"Error in gemini_llm_chat: {str(e)}")
-        return None
-
-# uvicorn controller:app --host localhost --port 8000 --reload
-
-# Usage Example
-# if __name__ == "__main__":
-#     df = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv')
-    
-#     agent = RethinkAgent(df=df)
-#     if not agent.initialize_model(API_KEYS):
-#         print("Failed to initialize model with provided keys")
-#         exit(1)
-        
-#     result = agent.execute_query("How many rows and cols r there and what r their names?")
-#     print("\nAnalysis Result:")
-#     print(result)

supabase_service.py

@@ -0,0 +1,42 @@
+import os
+from supabase import create_client, Client
+
+# Replace with your Supabase URL and API key
+SUPABASE_URL: str = os.getenv("SUPABASE_URL")
+SUPABASE_KEY: str = os.getenv("SUPABASE_KEY")
+
+# Initialize the Supabase client
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# Define the bucket name (you can create one in the Supabase Storage section)
+BUCKET_NAME = "csvcharts"
+
+async def upload_image_to_supabase(file_path: str, file_name: str) -> str:
+    """
+    Uploads an image to Supabase Storage and returns the public URL.
+    
+    :param file_path: Path to the image file on your local machine.
+    :param file_name: Name to save the file as in Supabase Storage.
+    :return: Public URL of the uploaded image.
+    """
+    # Check if the file exists
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file {file_path} does not exist.")
+
+    # Read the file in binary mode
+    with open(file_path, "rb") as f:
+        file_data = f.read()
+
+    # Upload the file to Supabase Storage
+    try:
+        res = supabase.storage.from_(BUCKET_NAME).upload(file_name, file_data)
+        print("Upload response:", res)  # Debugging: Print the response
+    except Exception as e:
+        raise Exception(f"Failed to upload file: {e}")
+
+    # Get the public URL of the uploaded file
+    public_url = supabase.storage.from_(BUCKET_NAME).get_public_url(file_name)
+    print("Public URL:", public_url)  # Debugging: Print the public URL
+
+    return public_url
+