Update main.py

main.py

@@ -1,3 +1,4 @@
+# app.py
 from langchain_google_genai import ChatGoogleGenerativeAI
 import pandas as pd
 import os
@@ -6,346 +7,300 @@ from flask import Flask, request, jsonify
 from flask_cors import CORS, cross_origin
 import logging
 from dotenv import load_dotenv
-from pandasai import SmartDatalake
 from pandasai import SmartDataframe
 from pandasai.responses.response_parser import ResponseParser
-from langchain.prompts import PromptTemplate
-from langchain.chains import LLMChain
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 import matplotlib.pyplot as plt
 import google.generativeai as genai
 import uuid
 import base64
-from io import BytesIO
 import requests
-import urllib.parse  # Added for URL encoding
+import urllib.parse
+import json
+import re
 
 load_dotenv()
 
 app = Flask(__name__)
-cors = CORS(app)
+CORS(app)
 
-# Set up logging configuration
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+# --- Logging Configuration (Preserved) ---
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# --- PRESERVED RESPONSE PARSER ---
+# Your original FlaskResponse class, ensuring no regressions in PandasAI functionality.
 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"):
-            try:
-                buf = io.BytesIO()
-                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:
-                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.
+            buf = io.BytesIO()
+            val.savefig(buf, format="png")
+            buf.seek(0)
+            return f"data:image/png;base64,{base64.b64encode(buf.read()).decode('utf-8')}"
         if isinstance(val, str) and os.path.isfile(os.path.join(val)):
-            image_path = os.path.join(val)
-            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")
+            with open(os.path.join(val), "rb") as file:
+                return f"data:image/png;base64,{base64.b64encode(file.read()).decode('utf-8')}"
         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"])
 
-
+# --- AI Model Initialization (Preserved) ---
 logger.info("Initializing models...")
-
 gemini_api_key = os.getenv('Gemini')
-if not gemini_api_key:
-    logger.error("Gemini API key not found in environment variables")
-    raise ValueError("Gemini API key is required")
-
-logger.info("Setting up ChatGoogleGenerativeAI...")
-# --- Model name reverted to your original specification ---
+if not gemini_api_key: raise ValueError("Gemini API key is required.")
 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 = {"temperature": 0.2, "top_p": 0.95, "max_output_tokens": 5000}
+model = genai.GenerativeModel(model_name="gemini-2.0-flash-lite-001", generation_config=generation_config)
+logger.info("AI Models initialized.")
 
-generation_config = {
-  "temperature": 0.2,
-  "top_p": 0.95,
-  "max_output_tokens": 5000,
-}
+user_defined_path = os.path.join("/exports/charts", str(uuid.uuid4()))
+logger.info(f"Chart export path set to: {user_defined_path}")
 
-# --- Model name reverted to your original specification ---
-model = genai.GenerativeModel(
-  model_name="gemini-2.0-flash-lite-001",
-  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}")
+# --- TIER 2: COMPREHENSIVE KPI ENGINE (For Intelligent Fallback) ---
+class IrisReportEngine:
+    def __init__(self, transactions_data: list, llm_instance):
+        self.llm = llm_instance
+        self.df = self._load_and_prepare_data(transactions_data)
+        self.currency = self._get_primary_currency()
+
+    def _load_and_prepare_data(self, transactions: list) -> pd.DataFrame:
+        if not transactions: return pd.DataFrame()
+        df = pd.DataFrame(transactions)
+        numeric_cols = ['Units_Sold', 'Unit_Cost_Price', 'Amount']
+        for col in numeric_cols:
+            df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
+        df['datetime'] = pd.to_datetime(df['Date'] + ' ' + df['Time'], errors='coerce', utc=True)
+        df.dropna(subset=['datetime'], inplace=True)
+        df['DayOfWeek'] = df['datetime'].dt.day_name()
+        df['HourOfDay'] = df['datetime'].dt.hour
+        sales_df = df[df['Transaction_Type'].str.lower() == 'sale'].copy()
+        sales_df['Revenue'] = sales_df['Amount']
+        sales_df['CostOfGoods'] = sales_df['Unit_Cost_Price'] * sales_df['Units_Sold']
+        sales_df['GrossProfit'] = sales_df['Revenue'] - sales_df['CostOfGoods']
+        return sales_df
+
+    def _get_primary_currency(self) -> str:
+        return self.df['Currency'].mode()[0] if not self.df.empty and 'Currency' in self.df.columns and not self.df['Currency'].mode().empty else "USD"
+
+    def _get_comparison_timeframes(self) -> tuple[pd.DataFrame, pd.DataFrame, str]:
+        """Returns data for current week, previous week, and a label."""
+        now = datetime.now(timezone.utc)
+        end_of_current_week = now.replace(hour=23, minute=59, second=59)
+        start_of_current_week = (end_of_current_week - timedelta(days=now.weekday())).replace(hour=0, minute=0, second=0)
+        end_of_previous_week = start_of_current_week - timedelta(seconds=1)
+        start_of_previous_week = (end_of_previous_week - timedelta(days=6)).replace(hour=0, minute=0, second=0)
+        
+        current_period_df = self.df[(self.df['datetime'] >= start_of_current_week) & (self.df['datetime'] <= end_of_current_week)]
+        previous_period_df = self.df[(self.df['datetime'] >= start_of_previous_week) & (self.df['datetime'] <= end_of_previous_week)]
+        
+        return current_period_df, previous_period_df, "This Week vs. Last Week"
+
+    def _calculate_headline_kpis(self, current_df, previous_df):
+        current_revenue = current_df['Revenue'].sum()
+        previous_revenue = previous_df['Revenue'].sum()
+        current_profit = current_df['GrossProfit'].sum()
+        previous_profit = previous_df['GrossProfit'].sum()
+
+        def calc_change(current, previous):
+            if previous == 0: return "+100%" if current > 0 else "0.0%"
+            change = ((current - previous) / previous) * 100
+            return f"{change:+.1f}%"
+
+        return {
+            "Total Revenue": f"{self.currency} {current_revenue:,.2f} ({calc_change(current_revenue, previous_revenue)})",
+            "Gross Profit": f"{self.currency} {current_profit:,.2f} ({calc_change(current_profit, previous_profit)})",
+            "Transactions": f"{current_df['Invoice_Number'].nunique()} ({calc_change(current_df['Invoice_Number'].nunique(), previous_df['Invoice_Number'].nunique())})"
+        }
+
+    def get_business_intelligence_briefing(self) -> dict:
+        if self.df.empty: return {"Status": "No sales data available to generate a briefing."}
+        
+        current_df, previous_df, summary_period = self._get_comparison_timeframes()
+        if current_df.empty: return {"Status": f"No sales data was found for the current period ({summary_period})."}
 
-# --- REFACTORED Endpoint for chat ---
+        # --- KPI Calculations ---
+        headline_kpis = self._calculate_headline_kpis(current_df, previous_df)
+        
+        baskets = current_df.groupby('Invoice_Number').agg(BasketProfit=('GrossProfit', 'sum'), ItemsPerBasket=('Units_Sold', 'sum'))
+        
+        products_by_profit = current_df.groupby('Product')['GrossProfit'].sum()
+        products_by_units = current_df.groupby('Product')['Units_Sold'].sum()
+        
+        tellers_by_profit = current_df.groupby('Teller_Username')['GrossProfit'].sum()
+        
+        profit_by_hour = current_df.groupby('HourOfDay')['GrossProfit'].sum()
+
+        # --- BUG FIX: Handle single-entity cases ---
+        product_intelligence = {}
+        if len(products_by_profit) > 1:
+            product_intelligence = {
+                "Best in Class (Most Profitable)": products_by_profit.idxmax(),
+                "Workhorse (Most Units Sold)": products_by_units.idxmax(),
+                "Underperformer (Least Profitable)": products_by_profit[products_by_profit > 0].idxmin() if not products_by_profit[products_by_profit > 0].empty else "N/A"
+            }
+        elif not products_by_profit.empty:
+            product_intelligence = {"Only Product Sold": products_by_profit.index[0]}
+            
+        staff_intelligence = {}
+        if len(tellers_by_profit) > 1:
+            staff_intelligence = {"Top Performing Teller (by Profit)": tellers_by_profit.idxmax()}
+        elif not tellers_by_profit.empty:
+            staff_intelligence = {"Only Teller": tellers_by_profit.index[0]}
+
+
+        return {
+            "Summary Period": summary_period,
+            "Performance Snapshot (vs. Prior Period)": headline_kpis,
+            "Basket Analysis": {
+                "Average Profit per Basket": f"{self.currency} {baskets['BasketProfit'].mean():,.2f}",
+                "Average Items per Basket": f"{baskets['ItemsPerBasket'].mean():,.1f}"
+            },
+            "Product Intelligence": product_intelligence,
+            "Staff & Operations": {
+                **staff_intelligence,
+                "Most Profitable Hour": f"{profit_by_hour.idxmax()}:00" if not profit_by_hour.empty else "N/A"
+            }
+        }
+
+    def synthesize_fallback_response(self, briefing: dict, user_question: str) -> str:
+        fallback_prompt = f"""
+        You are Iris, an expert business data analyst. Your primary role is to provide intelligent insights and help the user with their business.
+        You were unable to process a complex user query. Do not mention the error. Instead, gracefully pivot by presenting a "Business Intelligence Briefing".
+        Structure your response with clear markdown headings for each section of the briefing data.
+        Crucially, interpret the data in the "Performance Snapshot" - highlight the percentage changes as indicators of trends (e.g., "Revenue is up by 15.2%...").
+
+        using the business data also provide insight and suggest improvements and ideas where necessary.
+        
+        User's Original Question: "{user_question}"
+        Business Intelligence Briefing Data: {json.dumps(briefing, indent=2, ensure_ascii=False)}
+        """
+        response = self.llm.invoke(fallback_prompt)
+        return response.content if hasattr(response, 'content') else str(response)
+
+# --- REFACTORED /chat Endpoint with Correct Tiered Logic ---
 @app.route("/chat", methods=["POST"])
 @cross_origin()
 def bot():
     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
+        # 1. Request Validation and Data Fetching
         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:
-            logger.error("Missing required parameters")
-            return jsonify({"error": "Missing 'profile_id' or 'user_question' in request."}), 400
+        if not profile_id or not user_question: return jsonify({"error": "Missing 'profile_id' or 'user_question'."}), 400
 
-        logger.info(f"Processing request for profile_id: {profile_id}")
-        logger.info(f"User question: {user_question}")
-
-        # 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}")
-
-        # Fetch data from the external API
         API_URL = "https://irisplustech.com/public/api/business/profile/user/get-recent-transactions-v2"
-        payload = {'profile_id': encoded_profile_id}
-        
-        logger.info(f"Making API call to: {API_URL}")
-        logger.debug(f"API payload: {payload}")
+        response = requests.post(API_URL, data={'profile_id': urllib.parse.quote_plus(str(profile_id))}, timeout=30)
+        response.raise_for_status()
+        transactions = response.json().get("transactions")
+        if not transactions: return jsonify({"answer": "No transaction data was found for this profile."})
 
+        # --- TIER 1 (DEFAULT): PANDASAI FIRST ---
         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...")
+            logger.info("Attempting to answer with Tier 1 (PandasAI)...")
             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}")
+            
+            # START: PRESERVED PANDASAI IMPLEMENTATION
+            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
+            })
             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))}")
+            # ROBUSTNESS CHECK: Actively inspect the answer for soft failures.
+            is_failure = False
+            if answer is None:
+                is_failure = True
+                logger.warning("PandasAI returned None. Triggering fallback.")
+            if isinstance(answer, str):
+                fail_strings = ["i am sorry", "i cannot answer", "an error occurred", "unable to answer"]
+                if any(s in answer.lower() for s in fail_strings):
+                    is_failure = True
+                    logger.warning(f"PandasAI returned a failure string: '{answer}'. Triggering fallback.")
             
-            # 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
-
+            if not is_failure:
+                logger.info("Successfully answered with Tier 1 (PandasAI).")
+                formatted_answer = str(answer)
+                if isinstance(answer, pd.DataFrame): formatted_answer = answer.to_html()
+                elif isinstance(answer, plt.Figure):
+                    buf = io.BytesIO()
+                    answer.savefig(buf, format="png")
+                    formatted_answer = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode('utf-8')}"
+                return jsonify({"answer": formatted_answer})
+
+        except Exception as e:
+            logger.warning(f"Tier 1 (PandasAI) failed with exception: '{e}'. Proceeding to Tier 2 Fallback.")
+        
+        # --- TIER 2 (GRACEFUL FALLBACK): COMPREHENSIVE KPI ANALYST ---
+        logger.info("Executing Tier 2 Fallback: IrisReportEngine.")
+        engine = IrisReportEngine(transactions_data=transactions, llm_instance=llm)
+        briefing = engine.get_business_intelligence_briefing()
+        fallback_answer = engine.synthesize_fallback_response(briefing, user_question)
+        return jsonify({"answer": fallback_answer})
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"API connection error: {e}")
+        return jsonify({"error": "Could not connect to the transaction API.", "details": str(e)}), 503
     except Exception as e:
-        logger.exception("An unexpected error occurred in /chat endpoint")
+        # TIER 3 (FINAL SAFETY NET)
+        logger.exception("A critical unexpected error occurred in /chat endpoint")
         return jsonify({"error": "An unexpected server error occurred.", "details": str(e)}), 500
 
-
-# Reports endpoint
+# --- UNCHANGED ENDPOINTS ---
 @app.route("/report", methods=["POST"])
 @cross_origin()
 def busines_report():
     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 = """
-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)
-
-        logger.info("Sending request to generative model for report...")
+        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.\ndata:\n" + str(json_data)
         response = model.generate_content(prompt)
-        report = response.text
-        logger.info(f"Generated report length: {len(report)}")
-
-        return jsonify(str(report))
-        
+        return jsonify(str(response.text))
     except Exception as e:
         logger.exception("Error in /report endpoint")
         return jsonify({"error": "Failed to generate report.", "details": str(e)}), 500
 
-
-# Marketing endpoint
 @app.route("/marketing", methods=["POST"])
 @cross_origin()
 def marketing():
     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 = """
-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)
-
-        logger.info("Sending request to generative model for marketing strategy...")
+        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:\n" + str(json_data)
         response = model.generate_content(prompt)
-        report = response.text
-        logger.info(f"Generated marketing strategy length: {len(report)}")
-
-        return jsonify(str(report))
-        
+        return jsonify(str(response.text))
     except Exception as e:
         logger.exception("Error in /marketing endpoint")
         return jsonify({"error": "Failed to generate marketing strategy.", "details": str(e)}), 500
 
-
-# Notifications endpoint
 @app.route("/notify", methods=["POST"])
 @cross_origin()
 def notifications():
     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 = """
-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)
-
-        logger.info("Sending request to generative model for notifications...")
+        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.\n" + str(json_data)
         response = model.generate_content(prompt)
-        report = response.text
-        logger.info(f"Generated notification content length: {len(report)}")
-
-        return jsonify(str(report))
-        
+        return jsonify(str(response.text))
     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)