Clean up code: Remove commented duplicate code, fix category filtering logic, improve exception handling

app/smart_recommendation.py

@@ -274,7 +274,7 @@ class SmartBudgetRecommender:
             else:
                 try:
                     category_doc = self.db.categories.find_one({"_id": ObjectId(category_id)})
-                except:
+                except (ValueError, TypeError):
                     category_doc = self.db.categories.find_one({"_id": category_id})
             
             if category_doc:
@@ -315,41 +315,28 @@ class SmartBudgetRecommender:
         try:
             query_str = {"createdBy": user_id}
             budgets_str = list(self.db.budgets.find(query_str))
-<<<<<<< HEAD
             print(f"Pattern 2 (createdBy string): Found {len(budgets_str)} budgets")
             if budgets_str:
                 budgets.extend(budgets_str)
         except Exception as e:
             print(f"Pattern 2 failed: {e}")
-=======
-            if budgets_str:
-                budgets.extend(budgets_str)
-        except Exception:
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
             pass
         
         # Pattern 3: Try with user_id field (alternative field name) - no status filter
         try:
             query_userid = {"user_id": user_id}
             budgets_userid = list(self.db.budgets.find(query_userid))
-<<<<<<< HEAD
             print(f"Pattern 3 (user_id string): Found {len(budgets_userid)} budgets")
             if budgets_userid:
                 budgets.extend(budgets_userid)
         except Exception as e:
             print(f"Pattern 3 failed: {e}")
-=======
-            if budgets_userid:
-                budgets.extend(budgets_userid)
-        except Exception:
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
             pass
         
         # Pattern 4: Try ObjectId with user_id field - no status filter
         try:
             query_objid_userid = {"user_id": ObjectId(user_id)}
             budgets_objid_userid = list(self.db.budgets.find(query_objid_userid))
-<<<<<<< HEAD
             print(f"Pattern 4 (user_id ObjectId): Found {len(budgets_objid_userid)} budgets")
             if budgets_objid_userid:
                 budgets.extend(budgets_objid_userid)
@@ -382,11 +369,6 @@ class SmartBudgetRecommender:
                 budgets.append(budget_by_id_str)
         except Exception as e:
             print(f"Pattern 6 failed: {e}")
-=======
-            if budgets_objid_userid:
-                budgets.extend(budgets_objid_userid)
-        except Exception:
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
             pass
         
         # Remove duplicates based on _id
@@ -402,15 +384,12 @@ class SmartBudgetRecommender:
 
         if not budgets:
             print(f"No budgets found for user_id: {user_id}")
-<<<<<<< HEAD
             print(f"Tried all query patterns. Checking sample budget structure...")
             # Get a sample budget to see the structure
             sample = self.db.budgets.find_one()
             if sample:
                 print(f"Sample budget structure - createdBy type: {type(sample.get('createdBy')).__name__}, value: {sample.get('createdBy')}")
                 print(f"Sample budget has user_id field: {'user_id' in sample}")
-=======
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
             return {}
 
         print(f"Found {len(budgets)} budgets for user_id: {user_id}")
@@ -428,17 +407,12 @@ class SmartBudgetRecommender:
                     
                     # Get headCategory ID and amounts
                     head_cat_id = head_cat.get("headCategory")
-<<<<<<< HEAD
                     try:
                         head_cat_max = float(head_cat.get("maxAmount", 0) or 0)
                         head_cat_spend = float(head_cat.get("spendAmount", 0) or 0)
                     except (ValueError, TypeError):
                         head_cat_max = 0
                         head_cat_spend = 0
-=======
-                    head_cat_max = float(head_cat.get("maxAmount", 0) or 0)
-                    head_cat_spend = float(head_cat.get("spendAmount", 0) or 0)
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
                     
                     # Process nested categories within headCategory
                     nested_categories = head_cat.get("categories", [])
@@ -448,7 +422,6 @@ class SmartBudgetRecommender:
                                 continue
                             
                             nested_cat_id = nested_cat.get("category")
-<<<<<<< HEAD
                             try:
                                 nested_cat_max = float(nested_cat.get("maxAmount", 0) or 0)
                                 nested_cat_spend = float(nested_cat.get("spendAmount", 0) or 0)
@@ -459,14 +432,6 @@ class SmartBudgetRecommender:
                             
                             # Only include categories with limits (must have maxAmount > 0)
                             if nested_cat_max > 0:
-=======
-                            nested_cat_max = float(nested_cat.get("maxAmount", 0) or 0)
-                            nested_cat_spend = float(nested_cat.get("spendAmount", 0) or 0)
-                            spend_limit_type = nested_cat.get("spendLimitType", "NO_LIMIT")
-                            
-                            # Only include categories with limits (maxAmount > 0 or spendLimitType != "NO_LIMIT")
-                            if nested_cat_max > 0 or (spend_limit_type != "NO_LIMIT" and nested_cat_spend > 0):
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
                                 # Look up actual category name
                                 nested_category_name = self._get_category_name(nested_cat_id)
                                 nested_base_amount = nested_cat_spend if nested_cat_spend > 0 else nested_cat_max
@@ -518,7 +483,6 @@ class SmartBudgetRecommender:
                 budget_name = b.get("category") or b.get("title") or "Uncategorized"
 
             # Derive a base amount from WalletSync fields
-<<<<<<< HEAD
             try:
                 max_amount = float(b.get("maxAmount", 0) or b.get("max_amount", 0) or b.get("amount", 0) or 0)
                 spend_amount = float(b.get("spendAmount", 0) or b.get("spend_amount", 0) or b.get("spent", 0) or 0)
@@ -527,11 +491,6 @@ class SmartBudgetRecommender:
                 max_amount = 0
                 spend_amount = 0
                 budget_amount = 0
-=======
-            max_amount = float(b.get("maxAmount", 0) or b.get("max_amount", 0) or b.get("amount", 0) or 0)
-            spend_amount = float(b.get("spendAmount", 0) or b.get("spend_amount", 0) or b.get("spent", 0) or 0)
-            budget_amount = float(b.get("budget", 0) or b.get("budgetAmount", 0) or 0)
->>>>>>> fa62699d4d97bb637c5b2d83906f22ae98ede56a
 
             # Priority: spendAmount > maxAmount > budgetAmount > budget
             if spend_amount > 0:
@@ -618,359 +577,4 @@ class SmartBudgetRecommender:
             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
-
+            return None