added gemini too

orchestrator_functions.py

@@ -343,71 +343,71 @@ def langchain_csv_chart(csv_url: str, question: str, chart_required: bool):
 
 
 
-async def csv_chart(csv_url: str, query: str):
-    """
-    Generate a chart based on the provided CSV URL and query.
-    Parameters:
-    - csv_url (str): The URL of the CSV file.
-    - query (str): The query for generating the chart.
-    Returns:
-    - dict: A dictionary containing the generated chart image URL.
-    Example:
-    - csv_url: "https://example.com/data.csv"
-    - query: "Generate a bar chart showing sales by region."
-    Returns:
-    - dict: {"image_url": "https://example.com/chart.png"}.
-
-    """
+# async def csv_chart(csv_url: str, query: str):
+#     """
+#     Generate a chart based on the provided CSV URL and query.
+#     Parameters:
+#     - csv_url (str): The URL of the CSV file.
+#     - query (str): The query for generating the chart.
+#     Returns:
+#     - dict: A dictionary containing the generated chart image URL.
+#     Example:
+#     - csv_url: "https://example.com/data.csv"
+#     - query: "Generate a bar chart showing sales by region."
+#     Returns:
+#     - dict: {"image_url": "https://example.com/chart.png"}.
+
+#     """
     
-    try:
-        # First try Groq-based chart generation
-        try:
-            groq_result = await asyncio.to_thread(groq_chart, csv_url, query)
-            print(f"Generated Chart (Groq): {groq_result}")
+#     try:
+#         # First try Groq-based chart generation
+#         try:
+#             groq_result = await asyncio.to_thread(groq_chart, csv_url, query)
+#             print(f"Generated Chart (Groq): {groq_result}")
             
-            if groq_result != 'Chart not generated':
-                unique_file_name = f'{str(uuid.uuid4())}.png'
-                image_public_url = await upload_image_to_supabase(groq_result, unique_file_name)
-                print(f"Image uploaded to Supabase: {image_public_url}")
-                return {"image_url": image_public_url}
+#             if groq_result != 'Chart not generated':
+#                 unique_file_name = f'{str(uuid.uuid4())}.png'
+#                 image_public_url = await upload_image_to_supabase(groq_result, unique_file_name)
+#                 print(f"Image uploaded to Supabase: {image_public_url}")
+#                 return {"image_url": image_public_url}
                 
-        except Exception as groq_error:
-            print(f"Groq chart generation failed, falling back to Langchain: {str(groq_error)}")
+#         except Exception as groq_error:
+#             print(f"Groq chart generation failed, falling back to Langchain: {str(groq_error)}")
 
-        # Fallback to Langchain if Groq fails
-        try:
-            langchain_paths = await asyncio.to_thread(langchain_csv_chart, csv_url, query, True)
-            print("Fallback langchain chart result:", langchain_paths)
+#         # Fallback to Langchain if Groq fails
+#         try:
+#             langchain_paths = await asyncio.to_thread(langchain_csv_chart, csv_url, query, True)
+#             print("Fallback langchain chart result:", langchain_paths)
             
-            if isinstance(langchain_paths, list) and len(langchain_paths) > 0:
-                unique_file_name = f'{str(uuid.uuid4())}.png'
-                print("Uploading the chart to supabase...")
-                image_public_url = await upload_image_to_supabase(langchain_paths[0], unique_file_name)
-                print("Image uploaded to Supabase and Image URL is... ", image_public_url)
-                return {"image_url": image_public_url}
+#             if isinstance(langchain_paths, list) and len(langchain_paths) > 0:
+#                 unique_file_name = f'{str(uuid.uuid4())}.png'
+#                 print("Uploading the chart to supabase...")
+#                 image_public_url = await upload_image_to_supabase(langchain_paths[0], unique_file_name)
+#                 print("Image uploaded to Supabase and Image URL is... ", image_public_url)
+#                 return {"image_url": image_public_url}
                 
-        except Exception as langchain_error:
-            print(f"Langchain chart generation also failed: {str(langchain_error)}")
-            try:
-                # Last resort: Try with the gemini langchain agent
-                print("Trying with the gemini langchain agent...")
-                lc_gemini_chart_result = await asyncio.to_thread(langchain_gemini_csv_handler, csv_url, query, True)
-                if lc_gemini_chart_result is not None:
-                    clean_path = lc_gemini_chart_result.strip()
-                    unique_file_name = f'{str(uuid.uuid4())}.png'
-                    print("Uploading the chart to supabase...")
-                    image_public_url = await upload_image_to_supabase(clean_path, unique_file_name)
-                    print("Image uploaded to Supabase and Image URL is... ", image_public_url)
-                    return {"image_url": image_public_url}
-            except Exception as gemini_error:
-                print(f"Gemini Langchain chart generation also failed: {str(gemini_error)}")
-
-        # If both methods fail
-        return {"error": "Could not generate the chart, please try again."}
-
-    except Exception as e:
-        print(f"Critical chart error: {str(e)}")
-        return {"error": "Internal system error"}
+#         except Exception as langchain_error:
+#             print(f"Langchain chart generation also failed: {str(langchain_error)}")
+#             try:
+#                 # Last resort: Try with the gemini langchain agent
+#                 print("Trying with the gemini langchain agent...")
+#                 lc_gemini_chart_result = await asyncio.to_thread(langchain_gemini_csv_handler, csv_url, query, True)
+#                 if lc_gemini_chart_result is not None:
+#                     clean_path = lc_gemini_chart_result.strip()
+#                     unique_file_name = f'{str(uuid.uuid4())}.png'
+#                     print("Uploading the chart to supabase...")
+#                     image_public_url = await upload_image_to_supabase(clean_path, unique_file_name)
+#                     print("Image uploaded to Supabase and Image URL is... ", image_public_url)
+#                     return {"image_url": image_public_url}
+#             except Exception as gemini_error:
+#                 print(f"Gemini Langchain chart generation also failed: {str(gemini_error)}")
+
+#         # If both methods fail
+#         return {"error": "Could not generate the chart, please try again."}
+
+#     except Exception as e:
+#         print(f"Critical chart error: {str(e)}")
+#         return {"error": "Internal system error"}
     
     
     
@@ -416,62 +416,228 @@ async def csv_chart(csv_url: str, query: str):
 
 
 
+# async def csv_chat(csv_url: str, query: str):
+#     """
+#     Generate a response based on the provided CSV URL and query.
+#     Parameters:
+#     - csv_url (str): The URL of the CSV file.
+#     - query (str): The query for generating the response.
+#     Returns:
+#     - dict: A dictionary containing the generated response.
+#     Example:
+#     - csv_url: "https://example.com/data.csv"
+#     - query: "What is the total sales for the year 2022?"
+#     Returns:
+#     - dict: {"answer": "The total sales for 2022 is $100,000."}.
+#     """
+#     try:
+#         updated_query = f"{query} and Do not show any charts or graphs."
+        
+#         # Process with Groq first
+#         try:
+#             groq_answer = await asyncio.to_thread(groq_chat, csv_url, updated_query)
+#             print("groq_answer:", groq_answer)
+            
+#             if process_answer(groq_answer) == "Empty response received." or groq_answer == None:
+#                 return {"answer": "Sorry, I couldn't find relevant data..."}
+            
+#             if process_answer(groq_answer) or groq_answer == None:
+#                 raise Exception("Groq response not usable, falling back to LangChain")
+            
+#             return {"answer": jsonable_encoder(groq_answer)}
+            
+#         except Exception as groq_error:
+#             print(f"Groq error, falling back to LangChain: {str(groq_error)}")
+            
+#             # Process with LangChain if Groq fails
+#             try:
+#                 lang_answer = await asyncio.to_thread(
+#                     langchain_csv_chat, csv_url, query, False
+#                 )
+#                 if not process_answer(lang_answer):
+#                     return {"answer": jsonable_encoder(lang_answer)}
+#                 return {"answer": "Sorry, I couldn't find relevant data..."}
+#             except Exception as langchain_error:
+#                 print(f"LangChain processing error: {str(langchain_error)}")
+                
+#                 # last resort: Try with the gemini langchain agent
+#                 try:
+#                     gemini_answer = await asyncio.to_thread(
+#                         langchain_gemini_csv_handler, csv_url, query, False
+#                     )
+#                     if not process_answer(gemini_answer):
+#                         return {"answer": jsonable_encoder(gemini_answer)}
+#                     return {"answer": "Sorry, I couldn't find relevant data..."}
+#                 except Exception as gemini_error:
+#                     print(f"Gemini Langchain processing error: {str(gemini_error)}")
+#                     return {"answer": "error"}
+                
+#     except Exception as e:
+#         print(f"Error processing request: {str(e)}")
+#         return {"answer": "error"}
+
+
+
+
+
+
+
+####################################### Start with lc_gemini #######################################
+
+
 async def csv_chat(csv_url: str, query: str):
     """
     Generate a response based on the provided CSV URL and query.
+    Prioritizes LangChain-Gemini, then LangChain-Groq, and finally raw Groq as fallback.
+    
     Parameters:
     - csv_url (str): The URL of the CSV file.
     - query (str): The query for generating the response.
+    
     Returns:
     - dict: A dictionary containing the generated response.
+    
     Example:
     - csv_url: "https://example.com/data.csv"
     - query: "What is the total sales for the year 2022?"
     Returns:
-    - dict: {"answer": "The total sales for 2022 is $100,000."}.
+    - dict: {"answer": "The total sales for 2022 is $100,000."}
     """
     try:
         updated_query = f"{query} and Do not show any charts or graphs."
         
-        # Process with Groq first
+        # --- 1. First Attempt: LangChain Gemini ---
         try:
-            groq_answer = await asyncio.to_thread(groq_chat, csv_url, updated_query)
-            print("groq_answer:", groq_answer)
+            gemini_answer = await asyncio.to_thread(
+                langchain_gemini_csv_handler, csv_url, updated_query, False
+            )
+            print("LangChain-Gemini answer:", gemini_answer)
             
-            if process_answer(groq_answer) == "Empty response received." or groq_answer == None:
-                return {"answer": "Sorry, I couldn't find relevant data..."}
+            if not process_answer(gemini_answer) or gemini_answer is None:
+                return {"answer": jsonable_encoder(gemini_answer)}
             
-            if process_answer(groq_answer) or groq_answer == None:
-                raise Exception("Groq response not usable, falling back to LangChain")
+            raise Exception("LangChain-Gemini response not usable, falling back to LangChain-Groq")
             
-            return {"answer": jsonable_encoder(groq_answer)}
+        except Exception as gemini_error:
+            print(f"LangChain-Gemini error: {str(gemini_error)}")
             
-        except Exception as groq_error:
-            print(f"Groq error, falling back to LangChain: {str(groq_error)}")
-            
-            # Process with LangChain if Groq fails
+            # --- 2. Second Attempt: LangChain Groq ---
             try:
-                lang_answer = await asyncio.to_thread(
-                    langchain_csv_chat, csv_url, query, False
+                lang_groq_answer = await asyncio.to_thread(
+                    langchain_csv_chat, csv_url, updated_query, False
                 )
-                if not process_answer(lang_answer):
-                    return {"answer": jsonable_encoder(lang_answer)}
-                return {"answer": "Sorry, I couldn't find relevant data..."}
-            except Exception as langchain_error:
-                print(f"LangChain processing error: {str(langchain_error)}")
+                print("LangChain-Groq answer:", lang_groq_answer)
+                
+                if not process_answer(lang_groq_answer):
+                    return {"answer": jsonable_encoder(lang_groq_answer)}
                 
-                # last resort: Try with the gemini langchain agent
+                raise Exception("LangChain-Groq response not usable, falling back to raw Groq")
+                
+            except Exception as lang_groq_error:
+                print(f"LangChain-Groq error: {str(lang_groq_error)}")
+                
+                # --- 3. Final Attempt: Raw Groq Chat ---
                 try:
-                    gemini_answer = await asyncio.to_thread(
-                        langchain_gemini_csv_handler, csv_url, query, False
-                    )
-                    if not process_answer(gemini_answer):
-                        return {"answer": jsonable_encoder(gemini_answer)}
-                    return {"answer": "Sorry, I couldn't find relevant data..."}
-                except Exception as gemini_error:
-                    print(f"Gemini Langchain processing error: {str(gemini_error)}")
+                    raw_groq_answer = await asyncio.to_thread(groq_chat, csv_url, updated_query)
+                    print("Raw Groq answer:", raw_groq_answer)
+                    
+                    if process_answer(raw_groq_answer) == "Empty response received." or raw_groq_answer is None:
+                        return {"answer": "Sorry, I couldn't find relevant data..."}
+                    
+                    if process_answer(raw_groq_answer):
+                        raise Exception("All fallbacks exhausted")
+                    
+                    return {"answer": jsonable_encoder(raw_groq_answer)}
+                    
+                except Exception as raw_groq_error:
+                    print(f"Raw Groq error: {str(raw_groq_error)}")
                     return {"answer": "error"}
                 
     except Exception as e:
-        print(f"Error processing request: {str(e)}")
-        return {"answer": "error"}
+        print(f"Unexpected error: {str(e)}")
+        return {"answer": "error"}
+
+
+
+
+
+
+
+
+async def csv_chart(csv_url: str, query: str):
+    """
+    Generate a chart based on the provided CSV URL and query.
+    Prioritizes raw Groq, then LangChain Gemini, and finally LangChain Groq as fallback.
+    
+    Parameters:
+    - csv_url (str): The URL of the CSV file.
+    - query (str): The query for generating the chart.
+    
+    Returns:
+    - dict: A dictionary containing either:
+        - {"image_url": "https://example.com/chart.png"} on success, or
+        - {"error": "error message"} on failure
+    
+    Example:
+    - csv_url: "https://example.com/data.csv"
+    - query: "Show sales trends as a line chart"
+    Returns:
+    - dict: {"image_url": "https://storage.example.com/chart_uuid.png"}
+    """
+    
+    async def upload_and_return(image_path: str) -> dict:
+        """Helper function to handle image uploads"""
+        unique_name = f'{uuid.uuid4()}.png'
+        public_url = await upload_image_to_supabase(image_path, unique_name)
+        print(f"Uploaded chart: {public_url}")
+        return {"image_url": public_url}
+
+    try:
+        # --- 1. First Attempt: Raw Groq ---
+        try:
+            groq_result = await asyncio.to_thread(groq_chart, csv_url, query)
+            print(f"Raw Groq chart result:", groq_result)
+            
+            if groq_result and groq_result != 'Chart not generated':
+                return await upload_and_return(groq_result)
+                
+            raise Exception("Raw Groq failed to generate chart")
+            
+        except Exception as groq_error:
+            print(f"Raw Groq failed ({str(groq_error)}), trying LangChain Gemini...")
+
+            # --- 2. Second Attempt: LangChain Gemini ---
+            try:
+                gemini_result = await asyncio.to_thread(
+                    langchain_gemini_csv_handler, csv_url, query, True
+                )
+                print("LangChain Gemini chart result:", gemini_result)
+                
+                if gemini_result:
+                    clean_path = gemini_result.strip()
+                    return await upload_and_return(clean_path)
+                    
+                raise Exception("LangChain Gemini returned empty result")
+                
+            except Exception as gemini_error:
+                print(f"LangChain Gemini failed ({str(gemini_error)}), trying LangChain Groq...")
+
+                # --- 3. Final Attempt: LangChain Groq ---
+                try:
+                    lc_groq_paths = await asyncio.to_thread(
+                        langchain_csv_chart, csv_url, query, True
+                    )
+                    print("LangChain Groq chart result:", lc_groq_paths)
+                    
+                    if isinstance(lc_groq_paths, list) and lc_groq_paths:
+                        return await upload_and_return(lc_groq_paths[0])
+                        
+                    return {"error": "All chart generation methods failed"}
+                    
+                except Exception as lc_groq_error:
+                    print(f"LangChain Groq failed: {str(lc_groq_error)}")
+                    return {"error": "Could not generate chart"}
+
+    except Exception as e:
+        print(f"Critical error: {str(e)}")
+        return {"error": "Internal system error"}