Why fear when every bad thing happens only to you

controller.py

@@ -1,5 +1,6 @@
 # Import necessary modules
 from concurrent.futures import ProcessPoolExecutor
+import logging
 import os
 import asyncio
 import threading
@@ -34,9 +35,13 @@ matplotlib.use('Agg')
 # Initialize FastAPI app
 app = FastAPI()
 
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Initialize the ProcessPoolExecutor
 max_cpus = os.cpu_count()
-print("Available CPUs:", max_cpus)
+logger.info(f"Max CPUs: {max_cpus}")
 
 # Ensure the cache directory exists
 os.makedirs("/app/cache", exist_ok=True)
@@ -93,12 +98,12 @@ async def root():
 async def basic_csv_data(request: CsvUrlRequest):
     try:
         decoded_url = unquote(request.csv_url)
-        print(f"Fetching CSV data from URL: {decoded_url}")
+        logger.info(f"Fetching CSV data from URL: {decoded_url}")
         csv_data = csv_service.get_csv_basic_info(decoded_url)    
-        print(f"CSV data fetched successfully: {csv_data}")
+        logger.info(f"CSV data fetched successfully: {csv_data}")
         return {"data": csv_data}
     except Exception as e:
-        print(f"Error while fetching CSV data: {e}")
+        logger.error(f"Error while fetching CSV data: {e}")
         raise HTTPException(status_code=400, detail=f"Failed to retrieve CSV data: {str(e)}")
 
 
@@ -121,7 +126,7 @@ async def get_image(request: ImageRequest, authorization: str = Header(None)):
         image_file_path = request.image_path
         return FileResponse(image_file_path, media_type="image/png")
     except Exception as e:
-        print(f"Error: {e}")
+        logger.error(f"Error: {e}")
         return {"answer": "error"}
         
 
@@ -130,11 +135,11 @@ async def get_image(request: ImageRequest, authorization: str = Header(None)):
 async def get_csv_data(request: CsvUrlRequest):
     try:
         decoded_url = unquote(request.csv_url)
-        # print(f"Fetching CSV data from URL: {decoded_url}")
+        logger.info(f"Fetching CSV data from URL: {decoded_url}")
         csv_data = csv_service.generate_csv_data(decoded_url)        
         return csv_data
     except Exception as e:
-        # print(f"Error while fetching CSV data: {e}")
+        logger.error(f"Error while fetching CSV data: {e}")
         raise HTTPException(status_code=400, detail=f"Failed to retrieve CSV data: {str(e)}")
 
  
@@ -250,7 +255,7 @@ def langchain_csv_chat(csv_url: str, question: str, chart_required: bool):
             return result.get("output")
 
         except Exception as e:
-            print(f"Error with key index {current_key}: {str(e)}")
+            logger.error(f"Error with key index {current_key}: {str(e)}")
 
     return {"error": "All API keys exhausted"}
 
@@ -274,12 +279,12 @@ async def csv_chat(request: Dict, authorization: str = Header(None)):
             answer = await asyncio.to_thread(
                 langchain_csv_chat, decoded_url, query, False
             )
-            print("langchain_answer:", answer)
+            logger.info("langchain_answer:", answer)
             return {"answer": jsonable_encoder(answer)}
 
         # Process with groq_chat first
         groq_answer = await asyncio.to_thread(groq_chat, decoded_url, query)
-        print("groq_answer:", groq_answer)
+        logger.info("groq_answer:", groq_answer)
         
         if process_answer(groq_answer) == "Empty response received.":
             return {"answer": "Sorry, I couldn't find relevant data..."}
@@ -295,7 +300,7 @@ async def csv_chat(request: Dict, authorization: str = Header(None)):
         return {"answer": jsonable_encoder(groq_answer)}
 
     except Exception as e:
-        print(f"Error processing request: {str(e)}")
+        logger.error(f"Error processing request: {str(e)}")
         return {"answer": "error"}
 
 def handle_out_of_range_float(value):
@@ -386,7 +391,7 @@ def groq_chart(csv_url: str, question: str):
                 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}")
+                logger.error(f"Chart generation error: {error}")
                 return {"error": error}
     
     return {"error": "All API keys exhausted for chart generation"}
@@ -721,10 +726,10 @@ def langchain_csv_chart(csv_url: str, question: str, chart_required: bool):
                 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}")
+                logger.info(f"Langchain chart error (key {current_key}): {output}")
 
         except Exception as e:
-            print(f"Langchain chart error (key {current_key}): {str(e)}")
+            logger.error(f"Langchain chart error (key {current_key}): {str(e)}")
     
     return "Chart generation failed after all retries"
 
@@ -755,7 +760,7 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
             langchain_result = await loop.run_in_executor(
                 process_executor, langchain_csv_chart, csv_url, query, True
             )
-            print("Langchain chart result:", langchain_result)
+            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")
         
@@ -763,7 +768,7 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         groq_result = await loop.run_in_executor(
             process_executor, groq_chart, csv_url, query
         )
-        print(f"Groq chart result: {groq_result}")
+        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")
           
@@ -771,13 +776,13 @@ async def csv_chart(request: dict, authorization: str = Header(None)):
         langchain_paths = await loop.run_in_executor(
             process_executor, langchain_csv_chart, csv_url, query, True
         )
-        print("Fallback langchain chart result:", langchain_paths)
+        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")
         else:
            return {"error": "All chart generation methods failed"}
 
     except Exception as e:
-        print(f"Critical chart error: {str(e)}")
+        logger.error(f"Critical chart error: {str(e)}")
         return {"error": "Internal system error"}