Update app/smart_recommendation.py

app/smart_recommendation.py

@@ -109,8 +109,18 @@ class SmartBudgetRecommender:
             amount = expense.get("amount", 0)
             date = expense.get("date")
             
+            # Handle date conversion - skip if date is None or invalid
+            if date is None:
+                continue
+            
             if isinstance(date, str):
-                date = datetime.fromisoformat(date.replace('Z', '+00:00'))
+                try:
+                    date = datetime.fromisoformat(date.replace('Z', '+00:00'))
+                except (ValueError, AttributeError):
+                    continue
+            elif not isinstance(date, datetime):
+                # If date is not a string or datetime, skip this expense
+                continue
             
             category_data[category]["total"] += amount
             category_data[category]["count"] += 1
@@ -330,24 +340,381 @@ class SmartBudgetRecommender:
 
         try:
             response = requests.post(
-                "https://api.openai.com/v1/responses",
+                "https://api.openai.com/v1/chat/completions",
                 headers={
                     "Authorization": f"Bearer {OPENAI_API_KEY}",
                     "Content-Type": "application/json",
                 },
                 json={
-                    "model": "gpt-4.1-mini",
-                    "input": prompt,
+                    "model": "gpt-4o-mini",
+                    "messages": [
+                        {"role": "user", "content": prompt}
+                    ],
                     "temperature": 0.1,
                     "response_format": {"type": "json_object"},
                 },
                 timeout=30,
             )
             response.raise_for_status()
-            data = response.json()
-            content = data["output"][0]["content"][0]["text"]
+            response_data = response.json()
+            content = response_data["choices"][0]["message"]["content"]
             return json.loads(content)
         except Exception as exc:
             print(f"OpenAI recommendation error for {category}: {exc}")
             return None
 
+
+
+# import json
+# import math
+# import os
+# from collections import defaultdict
+# from datetime import datetime, timedelta
+# from typing import Dict, List
+
+# import requests
+# from dotenv import load_dotenv
+# from bson import ObjectId
+
+# from app.models import BudgetRecommendation, CategoryExpense
+
+# load_dotenv()
+# OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+# class SmartBudgetRecommender:
+#     """
+#     Smart Budget Recommendation Engine
+    
+#     Analyzes past spending behavior and recommends personalized budgets
+#     for each category based on historical data.
+#     """
+    
+#     def __init__(self, db):
+#         self.db = db
+    
+#     def get_recommendations(self, user_id: str, month: int, year: int) -> List[BudgetRecommendation]:
+#         """
+#         Get budget recommendations for all categories based on past behavior.
+        
+#         Args:
+#             user_id: User identifier
+#             month: Target month (1-12)
+#             year: Target year
+            
+#         Returns:
+#             List of budget recommendations for each category
+#         """
+#         # 1) Try to build stats from existing budgets for this user (createdBy)
+#         category_data = self._get_category_stats_from_budgets(user_id, month, year)
+
+#         # 2) If there are no budgets, fall back to expenses history
+#         if not category_data:
+#             end_date = datetime(year, month, 1) - timedelta(days=1)
+#             start_date = end_date - timedelta(days=180)  # ~6 months
+
+#             expenses = list(
+#                 self.db.expenses.find(
+#                     {
+#                         "user_id": user_id,
+#                         "date": {"$gte": start_date, "$lte": end_date},
+#                         "type": "expense",
+#                     }
+#                 )
+#             )
+
+#             if not expenses:
+#                 return []
+
+#             # Group expenses by category and calculate monthly averages
+#             category_data = self._calculate_category_statistics(
+#                 expenses, start_date, end_date
+#             )
+        
+#         recommendations: List[BudgetRecommendation] = []
+
+#         for category, data in category_data.items():
+#             avg_expense = data["average_monthly"]
+#             confidence = self._calculate_confidence(data)
+
+#             # 1) Try OpenAI first (primary source of recommendation)
+#             ai_result = self._get_ai_recommendation(category, data, avg_expense)
+#             if ai_result:
+#                 recommended_budget = ai_result.get("recommended_budget")
+#                 reason = ai_result.get("reason")
+#                 action = ai_result.get("action")
+#             else:
+#                 # 2) Fallback to rule-based recommendation
+#                 recommended_budget = self._calculate_recommended_budget(avg_expense, data)
+#                 reason = self._generate_reason(category, avg_expense, recommended_budget)
+#                 action = None
+
+#             recommendations.append(BudgetRecommendation(
+#                 category=category,
+#                 average_expense=round(avg_expense, 2),
+#                 recommended_budget=round(recommended_budget or 0, 2),
+#                 reason=reason,
+#                 confidence=confidence,
+#                 action=action
+#             ))
+        
+#         # Sort by average expense (highest first)
+#         recommendations.sort(key=lambda x: x.average_expense, reverse=True)
+        
+#         return recommendations
+    
+#     def _calculate_category_statistics(self, expenses: List[Dict], start_date: datetime, end_date: datetime) -> Dict:
+#         """Calculate statistics for each category"""
+#         category_data = defaultdict(lambda: {
+#             "total": 0,
+#             "count": 0,
+#             "months": set(),
+#             "monthly_totals": defaultdict(float)
+#         })
+        
+#         for expense in expenses:
+#             category = expense.get("category", "Uncategorized")
+#             amount = expense.get("amount", 0)
+#             date = expense.get("date")
+            
+#             if isinstance(date, str):
+#                 date = datetime.fromisoformat(date.replace('Z', '+00:00'))
+            
+#             category_data[category]["total"] += amount
+#             category_data[category]["count"] += 1
+            
+#             # Track monthly totals
+#             month_key = (date.year, date.month)
+#             category_data[category]["months"].add(month_key)
+#             category_data[category]["monthly_totals"][month_key] += amount
+        
+#         # Calculate averages
+#         result = {}
+#         for category, data in category_data.items():
+#             num_months = len(data["months"]) or 1
+#             avg_monthly = data["total"] / num_months
+            
+#             # Calculate standard deviation for variability
+#             monthly_values = list(data["monthly_totals"].values())
+#             if len(monthly_values) > 1:
+#                 mean = sum(monthly_values) / len(monthly_values)
+#                 variance = sum((x - mean) ** 2 for x in monthly_values) / len(monthly_values)
+#                 std_dev = math.sqrt(variance)
+#             else:
+#                 std_dev = 0
+            
+#             result[category] = {
+#                 "average_monthly": avg_monthly,
+#                 "total": data["total"],
+#                 "count": data["count"],
+#                 "months_analyzed": num_months,
+#                 "std_dev": std_dev,
+#                 "monthly_values": monthly_values
+#             }
+        
+#         return result
+    
+#     def _calculate_recommended_budget(self, avg_expense: float, data: Dict) -> float:
+#         """
+#         Calculate recommended budget based on average expense.
+        
+#         Strategy:
+#         - Base: Average monthly expense
+#         - Add 5% buffer for variability
+#         - Round to nearest 100 for cleaner numbers
+#         """
+#         # Add 5% buffer to handle variability
+#         buffer = avg_expense * 0.05
+        
+#         # If there's high variability (std_dev > 20% of mean), add more buffer
+#         if data["std_dev"] > 0:
+#             coefficient_of_variation = data["std_dev"] / avg_expense if avg_expense > 0 else 0
+#             if coefficient_of_variation > 0.2:
+#                 buffer = avg_expense * 0.10  # 10% buffer for high variability
+        
+#         recommended = avg_expense + buffer
+        
+#         # Round to nearest 100 for cleaner budget numbers
+#         recommended = round(recommended / 100) * 100
+        
+#         # Ensure minimum of 100 if there was any expense
+#         if recommended < 100 and avg_expense > 0:
+#             recommended = 100
+        
+#         return recommended
+    
+#     def _calculate_confidence(self, data: Dict) -> float:
+#         """
+#         Calculate confidence score (0-1) based on data quality.
+        
+#         Factors:
+#         - Number of months analyzed (more = higher confidence)
+#         - Number of transactions (more = higher confidence)
+#         - Consistency of spending (lower std_dev = higher confidence)
+#         """
+#         months_score = min(data["months_analyzed"] / 6, 1.0)  # Max at 6 months
+#         count_score = min(data["count"] / 10, 1.0)  # Max at 10 transactions
+        
+#         # Consistency score (inverse of coefficient of variation)
+#         if data["average_monthly"] > 0:
+#             cv = data["std_dev"] / data["average_monthly"]
+#             consistency_score = max(0, 1 - min(cv, 1.0))  # Lower CV = higher score
+#         else:
+#             consistency_score = 0.5
+        
+#         # Weighted average
+#         confidence = (months_score * 0.4 + count_score * 0.3 + consistency_score * 0.3)
+        
+#         return round(confidence, 2)
+    
+#     def _generate_reason(self, category: str, avg_expense: float, recommended_budget: float) -> str:
+#         """Generate human-readable reason for the recommendation"""
+#         # Format amounts with currency symbol
+#         avg_formatted = f"Rs.{avg_expense:,.0f}"
+#         budget_formatted = f"Rs.{recommended_budget:,.0f}"
+        
+#         if recommended_budget > avg_expense:
+#             buffer = recommended_budget - avg_expense
+#             buffer_pct = (buffer / avg_expense * 100) if avg_expense > 0 else 0
+#             return (
+#                 f"Your average monthly {category.lower()} expense is {avg_formatted}. "
+#                 f"We suggest setting your budget to {budget_formatted} for next month "
+#                 f"(includes a {buffer_pct:.0f}% buffer for variability)."
+#             )
+#         else:
+#             return (
+#                 f"Your average monthly {category.lower()} expense is {avg_formatted}. "
+#                 f"We recommend a budget of {budget_formatted} for next month."
+#             )
+    
+#     def get_category_averages(self, user_id: str, months: int = 3) -> List[CategoryExpense]:
+#         """Get average expenses by category for the past N months"""
+#         end_date = datetime.now()
+#         start_date = end_date - timedelta(days=months * 30)
+        
+#         expenses = list(self.db.expenses.find({
+#             "user_id": user_id,
+#             "date": {"$gte": start_date, "$lte": end_date},
+#             "type": "expense"
+#         }))
+        
+#         if not expenses:
+#             return []
+        
+#         category_data = self._calculate_category_statistics(expenses, start_date, end_date)
+        
+#         result = []
+#         for category, data in category_data.items():
+#             result.append(CategoryExpense(
+#                 category=category,
+#                 average_monthly_expense=round(data["average_monthly"], 2),
+#                 total_expenses=data["count"],
+#                 months_analyzed=data["months_analyzed"]
+#             ))
+        
+#         result.sort(key=lambda x: x.average_monthly_expense, reverse=True)
+#         return result
+
+#     def _get_category_stats_from_budgets(
+#         self, user_id: str, month: int, year: int
+#     ) -> Dict:
+#         """
+#         Build category stats from existing budgets for this user.
+
+#         We treat each budget document (e.g. \"Office Maintenance\", \"LOGICGO\")
+#         as a spending category and derive an \"average\" from its amounts.
+#         """
+#         # createdBy is stored as ObjectId in WalletSync, while user_id is a string.
+#         # Try to cast to ObjectId; if it fails, fall back to matching the raw string.
+#         query: Dict = {"status": "OPEN"}
+#         try:
+#             query["createdBy"] = ObjectId(user_id)
+#         except Exception:
+#             query["createdBy"] = user_id
+
+#         budgets = list(self.db.budgets.find(query))
+
+#         if not budgets:
+#             return {}
+
+#         result: Dict[str, Dict] = {}
+#         for b in budgets:
+#             # Use budget \"name\" as category label
+#             category = b.get("name", "Uncategorized")
+
+#             # Derive a base amount from WalletSync fields
+#             max_amount = float(b.get("maxAmount", 0) or 0)
+#             spend_amount = float(b.get("spendAmount", 0) or 0)
+
+#             # If there is recorded spend, use that as \"average\"; otherwise maxAmount
+#             base_amount = spend_amount if spend_amount > 0 else max_amount
+#             if base_amount <= 0:
+#                 continue
+
+#             if category not in result:
+#                 result[category] = {
+#                     "average_monthly": base_amount,
+#                     "total": base_amount,
+#                     "count": 1,
+#                     "months_analyzed": 1,
+#                     "std_dev": 0.0,
+#                     "monthly_values": [base_amount],
+#                 }
+#             else:
+#                 # If multiple budgets per category, average them
+#                 result[category]["total"] += base_amount
+#                 result[category]["count"] += 1
+#                 result[category]["months_analyzed"] = result[category]["count"]
+#                 result[category]["average_monthly"] = (
+#                     result[category]["total"] / result[category]["count"]
+#                 )
+#                 result[category]["monthly_values"].append(base_amount)
+
+#         return result
+
+#     def _get_ai_recommendation(self, category: str, data: Dict, avg_expense: float):
+#         """Use OpenAI to refine the budget recommendation."""
+#         if not OPENAI_API_KEY:
+#             return None
+
+#         history = ", ".join(f"{value:.0f}" for value in data["monthly_values"])
+#         summary = (
+#             f"Category: {category}\n"
+#             f"Monthly totals: [{history}]\n"
+#             f"Average spend: {avg_expense:.2f}\n"
+#             f"Std deviation: {data['std_dev']:.2f}\n"
+#             f"Months observed: {data['months_analyzed']}\n"
+#         )
+
+#         prompt = (
+#             "You are an Indian personal finance coach. "
+#             "Given the user's spending history, decide whether to increase, decrease, "
+#             "or keep the upcoming month's budget and provide a short explanation. "
+#             "Respond strictly as JSON with the following keys:\n"
+#             '{ "recommended_budget": number, "action": "increase|decrease|keep", "reason": "string" }.\n'
+#             "Use rupees for all amounts.\n\n"
+#             f"{summary}"
+#         )
+
+#         try:
+#             response = requests.post(
+#                 "https://api.openai.com/v1/responses",
+#                 headers={
+#                     "Authorization": f"Bearer {OPENAI_API_KEY}",
+#                     "Content-Type": "application/json",
+#                 },
+#                 json={
+#                     "model": "gpt-4.1-mini",
+#                     "input": prompt,
+#                     "temperature": 0.1,
+#                     "response_format": {"type": "json_object"},
+#                 },
+#                 timeout=30,
+#             )
+#             response.raise_for_status()
+#             data = response.json()
+#             content = data["output"][0]["content"][0]["text"]
+#             return json.loads(content)
+#         except Exception as exc:
+#             print(f"OpenAI recommendation error for {category}: {exc}")
+#             return None
+