Resolve merge conflicts - keep latest improvements

app/main.py

@@ -215,3 +215,134 @@ if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)
 
+
+
+
+
+# from fastapi import FastAPI, HTTPException, Depends
+# from fastapi.middleware.cors import CORSMiddleware
+# from pymongo import MongoClient
+# from pymongo.errors import ConnectionFailure
+# import os
+# from typing import List, Optional
+# from datetime import datetime, timedelta
+# from app.models import BudgetRecommendation, Expense, Budget, CategoryExpense
+# from app.smart_recommendation import SmartBudgetRecommender
+
+# app = FastAPI(title="Smart Budget Recommendation API", version="1.0.0")
+
+# # CORS middleware
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # MongoDB connection - Get from environment variable (set as secret in Hugging Face)
+# MONGODB_URI = os.getenv("MONGODB_URI")
+# if not MONGODB_URI:
+#     raise ValueError("MONGODB_URI environment variable is required. Please set it in Hugging Face secrets.")
+
+# try:
+#     client = MongoClient(MONGODB_URI)
+#     db = client.expense
+#     # Test connection
+#     client.admin.command('ping')
+#     print("Successfully connected to MongoDB")
+# except ConnectionFailure as e:
+#     print(f"Failed to connect to MongoDB: {e}")
+#     raise
+
+# # Initialize Smart Budget Recommender
+# recommender = SmartBudgetRecommender(db)
+
+# @app.get("/")
+# async def root():
+#     return {"message": "Smart Budget Recommendation API", "status": "running"}
+
+# @app.get("/health")
+# async def health_check():
+#     try:
+#         client.admin.command('ping')
+#         return {"status": "healthy", "database": "connected"}
+#     except Exception as e:
+#         return {"status": "unhealthy", "error": str(e)}
+
+# @app.post("/expenses", response_model=dict)
+# async def create_expense(expense: Expense):
+#     """
+#     Disabled: this service does not create expenses.
+
+#     All expenses should be created by the main WalletSync app and stored
+#     directly in MongoDB. This API only reads existing data for analytics.
+#     """
+#     raise HTTPException(
+#         status_code=405,
+#         detail="Creating expenses is disabled. Use the main WalletSync app to add expenses.",
+#     )
+
+# @app.get("/expenses", response_model=List[Expense])
+# async def get_expenses(user_id: str, limit: int = 100):
+#     """Get expenses for a user"""
+#     expenses = list(db.expenses.find({"user_id": user_id}).sort("date", -1).limit(limit))
+#     for expense in expenses:
+#         expense["id"] = str(expense["_id"])
+#         del expense["_id"]
+#     return expenses
+
+# @app.post("/budgets", response_model=dict)
+# async def create_budget(budget: Budget):
+#     """
+#     Disabled: this service does not create budgets.
+
+#     All budgets should be created by the main WalletSync app and stored
+#     directly in MongoDB. This API only reads existing data for analytics.
+#     """
+#     raise HTTPException(
+#         status_code=405,
+#         detail="Creating budgets is disabled. Use the main WalletSync app to add budgets.",
+#     )
+
+# @app.get("/budgets", response_model=List[Budget])
+# async def get_budgets(user_id: str):
+#     """Get budgets for a user"""
+#     budgets = list(db.budgets.find({"user_id": user_id}))
+#     for budget in budgets:
+#         budget["id"] = str(budget["_id"])
+#         del budget["_id"]
+#     return budgets
+
+# @app.get("/recommendations/{user_id}", response_model=List[BudgetRecommendation])
+# async def get_budget_recommendations(user_id: str, month: Optional[int] = None, year: Optional[int] = None):
+#     """
+#     Get smart budget recommendations for a user based on past spending behavior.
+    
+#     Example response:
+#     {
+#         "category": "Groceries",
+#         "average_expense": 3800,
+#         "recommended_budget": 4000,
+#         "reason": "Your average monthly grocery expense is Rs.3,800. We suggest setting your budget to Rs.4,000 for next month."
+#     }
+#     """
+#     if not month or not year:
+#         # Default to next month
+#         next_month = datetime.now().replace(day=1) + timedelta(days=32)
+#         month = next_month.month
+#         year = next_month.year
+    
+#     recommendations = recommender.get_recommendations(user_id, month, year)
+#     return recommendations
+
+# @app.get("/category-expenses/{user_id}", response_model=List[CategoryExpense])
+# async def get_category_expenses(user_id: str, months: int = 3):
+#     """Get average expenses by category for the past N months"""
+#     category_expenses = recommender.get_category_averages(user_id, months)
+#     return category_expenses
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)
+

app/smart_recommendation.py

@@ -315,28 +315,41 @@ 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)
@@ -369,6 +382,11 @@ 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
@@ -384,12 +402,15 @@ 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}")
@@ -407,12 +428,17 @@ 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", [])
@@ -422,6 +448,7 @@ 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)
@@ -432,6 +459,14 @@ 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
@@ -483,6 +518,7 @@ 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)
@@ -491,6 +527,11 @@ 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:
@@ -579,3 +620,357 @@ class SmartBudgetRecommender:
             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
+