Update main.py

main.py

@@ -17,23 +17,31 @@ import google.generativeai as genai
 import uuid
 import base64
 from io import BytesIO
-import requests # Added for making API calls
+import requests
+import urllib.parse  # Added for URL encoding
 
 load_dotenv()
 
 app = Flask(__name__)
 cors = CORS(app)
 
-
+# Set up logging configuration
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 class FlaskResponse(ResponseParser):
     def __init__(self, context):
         super().__init__(context)
 
     def format_dataframe(self, result):
+        logger.debug("Formatting dataframe result")
         return result["value"].to_html()
 
     def format_plot(self, result):
+        logger.debug("Formatting plot result")
         val = result["value"]
         # If val is a matplotlib figure, handle it accordingly.
         if hasattr(val, "savefig"):
@@ -42,32 +50,42 @@ class FlaskResponse(ResponseParser):
                 val.savefig(buf, format="png")
                 buf.seek(0)
                 image_base64 = base64.b64encode(buf.read()).decode("utf-8")
+                logger.debug("Successfully converted matplotlib figure to base64")
                 return f"data:image/png;base64,{image_base64}"
             except Exception as e:
-                print("Error processing figure:", e)
+                logger.error(f"Error processing figure: {e}")
                 return str(val)
         # If val is a string and is a valid file path, read and encode it.
         if isinstance(val, str) and os.path.isfile(os.path.join(val)):
             image_path = os.path.join(val)
-            print("My image path:", image_path)
+            logger.debug(f"Processing image path: {image_path}")
             with open(image_path, "rb") as file:
                 data = file.read()
             base64_data = base64.b64encode(data).decode("utf-8")
+            logger.debug("Successfully converted image file to base64")
             return f"data:image/png;base64,{base64_data}"
         # Fallback: return as a string.
+        logger.debug("Returning plot result as string")
         return str(val)
 
     def format_other(self, result):
+        logger.debug("Formatting other result type")
         # For non-image responses, simply return the value as a string.
         return str(result["value"])
 
 
+logger.info("Initializing models...")
+
 gemini_api_key = os.getenv('Gemini')
-# --- Model name reverted to your original specification ---
-llm = ChatGoogleGenerativeAI(api_key=gemini_api_key, model='gemini-2.0-flash-thinking-exp', temperature=0.1)
+if not gemini_api_key:
+    logger.error("Gemini API key not found in environment variables")
+    raise ValueError("Gemini API key is required")
 
-gemini_api_key = os.environ['Gemini']
+logger.info("Setting up ChatGoogleGenerativeAI...")
+# --- Model name reverted to your original specification ---
+llm = ChatGoogleGenerativeAI(api_key=gemini_api_key, model='gemini-2.0-flash', temperature=0.1)
 
+logger.info("Configuring genai...")
 genai.configure(api_key=gemini_api_key)
 
 generation_config = {
@@ -82,99 +100,163 @@ model = genai.GenerativeModel(
   generation_config=generation_config,
 )
 
-
 guid = uuid.uuid4()
 new_filename = f"{guid}"
 user_defined_path = os.path.join("/exports/charts", new_filename)
-
+logger.info(f"Chart export path set to: {user_defined_path}")
 
 # --- REFACTORED Endpoint for chat ---
 @app.route("/chat", methods=["POST"])
 @cross_origin()
 def bot():
-    # Retrieve parameters from the request
-    profile_id = request.json.get("profile_id")
-    user_question = request.json.get("user_question")
+    logger.info("=== Starting /chat endpoint ===")
+    
+    try:
+        # Log the incoming request
+        logger.debug(f"Request headers: {dict(request.headers)}")
+        logger.debug(f"Request data: {request.get_data()}")
+        
+        # Retrieve parameters from the request
+        request_json = request.get_json()
+        logger.debug(f"Parsed JSON: {request_json}")
+        
+        if not request_json:
+            logger.error("No JSON data in request")
+            return jsonify({"error": "No JSON data provided in request."}), 400
+        
+        profile_id = request_json.get("profile_id")
+        user_question = request_json.get("user_question")
+        
+        logger.info(f"Extracted profile_id: {profile_id}")
+        logger.info(f"Extracted user_question: {user_question}")
 
-    if not profile_id or not user_question:
-        return jsonify({"error": "Missing 'profile_id' or 'user_question' in request."}), 400
+        if not profile_id or not user_question:
+            logger.error("Missing required parameters")
+            return jsonify({"error": "Missing 'profile_id' or 'user_question' in request."}), 400
 
-    print(f"Received request for profile_id: {profile_id}")
-    print(f"User question: {user_question}")
+        logger.info(f"Processing request for profile_id: {profile_id}")
+        logger.info(f"User question: {user_question}")
 
-    # Fetch data from the external API
-    API_URL = "https://irisplustech.com/public/api4/business/profile/user/get-recent-transactions-v2"
-    payload = {'profile_id': profile_id}
+        # URL encode the profile_id
+        encoded_profile_id = urllib.parse.quote_plus(str(profile_id))
+        logger.info(f"URL encoded profile_id: {encoded_profile_id}")
 
-    try:
-        response = requests.post(API_URL, data=payload)
-        # Check if the request was successful
-        if response.status_code != 200:
-            return jsonify({
-                "error": "Failed to fetch data from the transaction API.",
-                "status_code": response.status_code,
-                "details": response.text
-            }), 502 # Bad Gateway
-
-        api_data = response.json()
-        
-        # Check for API-level errors
-        if api_data.get("error"):
-            return jsonify({
-                "error": "Transaction API returned an error.",
-                "message": api_data.get("message", "No message provided.")
-            }), 400
-
-        transactions = api_data.get("transactions")
-        if transactions is None or not isinstance(transactions, list):
-             return jsonify({"error": "Invalid data format from transaction API. 'transactions' key is missing or not a list."}), 500
+        # Fetch data from the external API
+        API_URL = "https://irisplustech.com/public/api4/business/profile/user/get-recent-transactions-v2"
+        payload = {'profile_id': encoded_profile_id}
         
-        if not transactions:
-            return jsonify({"answer": "No transaction data was found for this profile. I can't answer any questions."})
-
-        # Convert the transaction data into a dataframe
-        df = pd.DataFrame(transactions)
-        print("Columns in dataframe:", list(df.columns))
-
-        # Create a SmartDataframe instance using your configuration.
-        pandas_agent = SmartDataframe(
-            df,
-            config={
-                "llm": llm,
-                "response_parser": FlaskResponse,
-                "custom_whitelisted_dependencies": [
-                    "os", "io", "sys", "chr", "glob",
-                    "b64decoder", "collections", "geopy",
-                    "geopandas", "wordcloud", "builtins"
-                ],
-                "security": "none", "save_charts_path": user_defined_path, 
-                "save_charts": False, "enable_cache": False, "conversational":True
-            }
-        )
-
-        # Get the answer from the agent
-        answer = pandas_agent.chat(user_question)
-
-        # Process the answer based on its type
-        formatted_answer = None
-        if isinstance(answer, pd.DataFrame):
-            formatted_answer = answer.to_html()
-        elif isinstance(answer, plt.Figure):
-            buf = io.BytesIO()
-            answer.savefig(buf, format="png")
-            buf.seek(0)
-            image_base64 = base64.b64encode(buf.read()).decode("utf-8")
-            formatted_answer = f"data:image/png;base64,{image_base64}"
-        else:
-            formatted_answer = str(answer)
-        
-        # Return the formatted answer as JSON.
-        return jsonify({"answer": formatted_answer})
+        logger.info(f"Making API call to: {API_URL}")
+        logger.debug(f"API payload: {payload}")
+
+        try:
+            logger.info("Sending POST request to transaction API...")
+            response = requests.post(API_URL, data=payload, timeout=30)
+            logger.info(f"API response status code: {response.status_code}")
+            logger.debug(f"API response headers: {dict(response.headers)}")
+            
+            # Check if the request was successful
+            if response.status_code != 200:
+                logger.error(f"API request failed with status {response.status_code}")
+                logger.error(f"API response text: {response.text}")
+                return jsonify({
+                    "error": "Failed to fetch data from the transaction API.",
+                    "status_code": response.status_code,
+                    "details": response.text
+                }), 502 # Bad Gateway
+
+            logger.info("API request successful, parsing JSON response...")
+            api_data = response.json()
+            logger.debug(f"API response data keys: {list(api_data.keys()) if isinstance(api_data, dict) else 'Not a dict'}")
+            
+            # Check for API-level errors
+            if api_data.get("error"):
+                logger.error(f"API returned error: {api_data.get('message', 'No message')}")
+                return jsonify({
+                    "error": "Transaction API returned an error.",
+                    "message": api_data.get("message", "No message provided.")
+                }), 400
+
+            transactions = api_data.get("transactions")
+            logger.info(f"Transactions data type: {type(transactions)}")
+            logger.info(f"Number of transactions: {len(transactions) if isinstance(transactions, list) else 'N/A'}")
+            
+            if transactions is None or not isinstance(transactions, list):
+                logger.error("Invalid transactions data format")
+                return jsonify({"error": "Invalid data format from transaction API. 'transactions' key is missing or not a list."}), 500
+            
+            if not transactions:
+                logger.warning("No transactions found for profile")
+                return jsonify({"answer": "No transaction data was found for this profile. I can't answer any questions."})
+
+            # Convert the transaction data into a dataframe
+            logger.info("Converting transactions to DataFrame...")
+            df = pd.DataFrame(transactions)
+            logger.info(f"DataFrame shape: {df.shape}")
+            logger.info(f"DataFrame columns: {list(df.columns)}")
+            logger.debug(f"DataFrame head:\n{df.head()}")
+
+            # Create a SmartDataframe instance using your configuration.
+            logger.info("Creating SmartDataframe instance...")
+            pandas_agent = SmartDataframe(
+                df,
+                config={
+                    "llm": llm,
+                    "response_parser": FlaskResponse,
+                    "custom_whitelisted_dependencies": [
+                        "os", "io", "sys", "chr", "glob",
+                        "b64decoder", "collections", "geopy",
+                        "geopandas", "wordcloud", "builtins"
+                    ],
+                    "security": "none", "save_charts_path": user_defined_path, 
+                    "save_charts": False, "enable_cache": False, "conversational":True
+                }
+            )
+            logger.info("SmartDataframe created successfully")
+
+            # Get the answer from the agent
+            logger.info(f"Sending question to pandas agent: {user_question}")
+            answer = pandas_agent.chat(user_question)
+            logger.info(f"Received answer from agent, type: {type(answer)}")
+            logger.debug(f"Raw answer: {str(answer)[:500]}...")  # Log first 500 chars
+
+            # Process the answer based on its type
+            logger.info("Processing answer for response format...")
+            formatted_answer = None
+            if isinstance(answer, pd.DataFrame):
+                logger.info("Answer is DataFrame, converting to HTML")
+                formatted_answer = answer.to_html()
+            elif isinstance(answer, plt.Figure):
+                logger.info("Answer is matplotlib Figure, converting to base64")
+                buf = io.BytesIO()
+                answer.savefig(buf, format="png")
+                buf.seek(0)
+                image_base64 = base64.b64encode(buf.read()).decode("utf-8")
+                formatted_answer = f"data:image/png;base64,{image_base64}"
+            else:
+                logger.info("Answer is other type, converting to string")
+                formatted_answer = str(answer)
+            
+            logger.info(f"Formatted answer length: {len(str(formatted_answer))}")
+            
+            # Return the formatted answer as JSON.
+            logger.info("Returning successful response")
+            return jsonify({"answer": formatted_answer})
+
+        except requests.exceptions.Timeout as e:
+            logger.error(f"API request timeout: {e}")
+            return jsonify({"error": "Transaction API request timed out.", "details": str(e)}), 504
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"API connection error: {e}")
+            return jsonify({"error": "Could not connect to the transaction API.", "details": str(e)}), 503
+        except requests.exceptions.RequestException as e:
+            logger.error(f"API request exception: {e}")
+            return jsonify({"error": "Could not connect to the transaction API.", "details": str(e)}), 500
+        except ValueError as e:
+            logger.error(f"JSON parsing error: {e}")
+            return jsonify({"error": "Invalid JSON response from transaction API.", "details": str(e)}), 502
 
-    except requests.exceptions.RequestException as e:
-        return jsonify({"error": "Could not connect to the transaction API.", "details": str(e)}), 500
     except Exception as e:
-        logging.exception("An unexpected error occurred in /chat endpoint")
+        logger.exception("An unexpected error occurred in /chat endpoint")
         return jsonify({"error": "An unexpected server error occurred.", "details": str(e)}), 500
 
 
@@ -182,56 +264,88 @@ def bot():
 @app.route("/report", methods=["POST"])
 @cross_origin()
 def busines_report():
-    json_data = request.json.get("json_data")
+    logger.info("=== Starting /report endpoint ===")
+    
+    try:
+        request_json = request.get_json()
+        json_data = request_json.get("json_data") if request_json else None
+        
+        logger.info(f"Processing report request with data length: {len(str(json_data)) if json_data else 0}")
 
-    prompt = """
+        prompt = """
 You are Quantilytix business analyst. Analyze the following data and generate a comprehensive and insightful business report, including appropriate key perfomance indicators and recommendations Use markdown formatting and tables where necessary. only return the report and nothing else.
 data:
 """  +  str(json_data)
 
-    
-    response = model.generate_content(prompt)
-    report = response.text
+        logger.info("Sending request to generative model for report...")
+        response = model.generate_content(prompt)
+        report = response.text
+        logger.info(f"Generated report length: {len(report)}")
 
+        return jsonify(str(report))
+        
+    except Exception as e:
+        logger.exception("Error in /report endpoint")
+        return jsonify({"error": "Failed to generate report.", "details": str(e)}), 500
 
-    return jsonify(str(report))
 
-# MArketing
+# Marketing endpoint
 @app.route("/marketing", methods=["POST"])
 @cross_origin()
 def marketing():
-    json_data = request.json.get("json_data")
+    logger.info("=== Starting /marketing endpoint ===")
+    
+    try:
+        request_json = request.get_json()
+        json_data = request_json.get("json_data") if request_json else None
+        
+        logger.info(f"Processing marketing request with data length: {len(str(json_data)) if json_data else 0}")
 
-    prompt = """
+        prompt = """
 You are an Quantilytix Marketing Specialist. Analyze the following data and generate a comprehensive marketing strategy, Only return the marketing strategy. be very creative:
 """  +  str(json_data)
 
-    
-    response = model.generate_content(prompt)
-    report = response.text
+        logger.info("Sending request to generative model for marketing strategy...")
+        response = model.generate_content(prompt)
+        report = response.text
+        logger.info(f"Generated marketing strategy length: {len(report)}")
 
+        return jsonify(str(report))
+        
+    except Exception as e:
+        logger.exception("Error in /marketing endpoint")
+        return jsonify({"error": "Failed to generate marketing strategy.", "details": str(e)}), 500
 
-    return jsonify(str(report))
 
-# Business Plan endpoint REMOVED
-    
-#Notificatiions
+# Notifications endpoint
 @app.route("/notify", methods=["POST"])
 @cross_origin()
 def notifications():
-    json_data = request.json.get("json_data")
+    logger.info("=== Starting /notify endpoint ===")
+    
+    try:
+        request_json = request.get_json()
+        json_data = request_json.get("json_data") if request_json else None
+        
+        logger.info(f"Processing notification request with data length: {len(str(json_data)) if json_data else 0}")
 
-    prompt = """
+        prompt = """
 You are Quantilytix business analyst. Write a very brief analysis and marketing tips using this business data. your output should be suitable for a notification dashboard so no quips.
 """  +  str(json_data)
 
-    
-    response = model.generate_content(prompt)
-    report = response.text
-
+        logger.info("Sending request to generative model for notifications...")
+        response = model.generate_content(prompt)
+        report = response.text
+        logger.info(f"Generated notification content length: {len(report)}")
 
-    return jsonify(str(report))
+        return jsonify(str(report))
+        
+    except Exception as e:
+        logger.exception("Error in /notify endpoint")
+        return jsonify({"error": "Failed to generate notification content.", "details": str(e)}), 500
 
 
 if __name__ == "__main__":
+    logger.info("Starting Flask application...")
+    logger.info("Application will run on host=0.0.0.0, port=7860, debug=True")
     app.run(debug=True, host="0.0.0.0", port=7860)