csv Data

app.py

@@ -1183,4 +1183,321 @@ async def trial_yearsphere_data(request: Request):
     return {
         "months": months_out,
         "current_month_index": current_idx,
-    }
+    }
+
+
+
+
+@app.post("/csv/chart_data")
+async def csv_chart_data(request: Request):
+    """Chart data from user-uploaded CSV transactions."""
+    from plaid_client import get_chart_data_from_csv
+    body = await request.json()
+    transactions = body.get("transactions", [])
+    return get_chart_data_from_csv(transactions)
+ 
+ 
+@app.post("/csv/recurring")
+async def csv_recurring(request: Request):
+    """Recurring pattern detection from user-uploaded CSV transactions."""
+    from plaid_client import get_recurring_from_csv
+    body = await request.json()
+    transactions = body.get("transactions", [])
+    return get_recurring_from_csv(transactions)
+ 
+ 
+@app.post("/csv/chat/stream")
+async def csv_chat_stream(request: Request):
+    """Chat with AI using CSV-uploaded transactions as context."""
+    from plaid_client import get_snapshot_from_csv
+    
+    body = await request.json()
+    message = body.get("message", "")
+    transactions = body.get("transactions", [])
+    csv_user_id = f"csv-{request.client.host}"
+    
+    financial_context = get_snapshot_from_csv(transactions)
+    
+    def generate():
+        for token in stream_answer(message, csv_user_id, financial_context=financial_context):
+            yield f"data: {json.dumps({'chunk': token})}\n\n"
+        yield "data: [DONE]\n\n"
+    
+    return StreamingResponse(generate(), media_type="text/event-stream")
+ 
+ 
+@app.post("/csv/reset")
+async def csv_reset(request: Request):
+    """Reset chat history for CSV mode."""
+    csv_user_id = f"csv-{request.client.host}"
+    reset_history(csv_user_id)
+    return {"status": "reset"}
+ 
+ 
+@app.post("/csv/prescription/diagnose")
+async def csv_prescription_diagnose(request: Request):
+    """Streaming diagnosis using CSV transaction context."""
+    from plaid_client import get_snapshot_from_csv
+    
+    body = await request.json()
+    prescription_type = body.get("type", "account")
+    prescription_name = body.get("name", "")
+    prescription_amount = body.get("amount", 0)
+    prescription_details = body.get("details", "")
+    follow_up_question = body.get("question", "")
+    transactions = body.get("transactions", [])
+    
+    csv_user_id = f"csv-{request.client.host}"
+    financial_context = get_snapshot_from_csv(transactions)
+    
+    if follow_up_question:
+        prompt = f"""The user previously asked you to diagnose their {prescription_type}: "{prescription_name}" ({prescription_details}, currently ${prescription_amount:.2f}).
+ 
+They're now asking a follow-up question: "{follow_up_question}"
+ 
+Answer their question directly, keeping the same calm, doctor-patient tone. Reference the specific prescription details where relevant."""
+    else:
+        prompt = f"""The user just handed you their {prescription_type} for a check-up: "{prescription_name}" ({prescription_details}, currently ${prescription_amount:.2f}).
+ 
+Give a warm, doctor-patient style diagnosis that covers:
+ 
+1. **What it is** — a plain-language description of this {prescription_type}
+2. **The amount** — acknowledge the current amount without judgment
+3. **How it looks** — is this amount healthy, concerning, or somewhere in between? Be honest but calm.
+4. **Recent history** — mention what you can observe from their recent activity
+5. **What could go better** — 1-2 specific, actionable suggestions (only if genuinely useful)
+6. **Reassurance** — even if there's room to improve, name what's going right. If the account is in good shape, celebrate it warmly.
+ 
+Keep the tone calm, non-judgmental, and specific to this {prescription_type}. Don't lecture. Don't use words like "leak" or "spike." Speak like a doctor who cares about the patient, not a financial advisor trying to upsell them.
+ 
+Under 200 words. Use markdown headers (**bold**) for each section. Keep sections short — 1-2 sentences each.
+ 
+CRITICAL: Respond with prose only. Do NOT include [CHART_DATA]...[/CHART_DATA] blocks, JSON, code fences, or any structured data."""
+    
+    def generate():
+        for token in stream_answer(prompt, csv_user_id, financial_context=financial_context):
+            yield f"data: {json.dumps({'chunk': token})}\n\n"
+        yield "data: [DONE]\n\n"
+    
+    return StreamingResponse(generate(), media_type="text/event-stream")
+ 
+ 
+@app.post("/csv/prescription/activity")
+async def csv_prescription_activity(request: Request):
+    """Activity data for the pulse chart from CSV transactions."""
+    body = await request.json()
+    transactions = body.get("transactions", [])
+    
+    # Reuse the same activity aggregation logic as trial mode
+    # Group transactions by day, count events
+    from collections import defaultdict
+    from datetime import date, timedelta
+    
+    end_date = date.today()
+    start_date = end_date - timedelta(days=90)
+    
+    daily_activity = defaultdict(lambda: {'count': 0, 'total_expense': 0, 'total_income': 0})
+    
+    for txn in transactions:
+        txn_date_str = txn.get('date', '')
+        try:
+            txn_date = date.fromisoformat(txn_date_str)
+        except (ValueError, TypeError):
+            continue
+        
+        if txn_date < start_date or txn_date > end_date:
+            continue
+        
+        amount = txn.get('amount', 0)
+        category = txn.get('personal_finance_category', {}).get('primary', '')
+        
+        # Skip transfers to avoid double-counting
+        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
+            continue
+        
+        key = txn_date.isoformat()
+        daily_activity[key]['count'] += 1
+        if amount > 0:
+            daily_activity[key]['total_expense'] += amount
+        else:
+            daily_activity[key]['total_income'] += abs(amount)
+    
+    # Build activity array
+    activity = []
+    current = start_date
+    while current <= end_date:
+        key = current.isoformat()
+        data = daily_activity.get(key, {'count': 0, 'total_expense': 0, 'total_income': 0})
+        activity.append({
+            'date': key,
+            'value': round(data['total_expense'] + data['total_income'], 2),
+            'count': data['count'],
+            'is_income': data['total_income'] > data['total_expense'],
+        })
+        current += timedelta(days=1)
+    
+    return {
+        'activity': activity,
+        'total_events': sum(a['count'] for a in activity),
+    }
+ 
+ 
+@app.post("/csv/cashflow/data")
+async def csv_cashflow_data(request: Request):
+    """Cash flow bubble data from CSV transactions."""
+    body = await request.json()
+    transactions = body.get("transactions", [])
+    
+    from collections import defaultdict
+    from datetime import date, timedelta
+    
+    end_date = date.today()
+    start_date = end_date - timedelta(days=30)
+    
+    # Aggregate by category
+    category_totals = defaultdict(lambda: {'total': 0, 'count': 0, 'merchants': defaultdict(float)})
+    income_total = 0
+    expense_total = 0
+    
+    for txn in transactions:
+        txn_date_str = txn.get('date', '')
+        try:
+            txn_date = date.fromisoformat(txn_date_str)
+        except (ValueError, TypeError):
+            continue
+        
+        if txn_date < start_date or txn_date > end_date:
+            continue
+        
+        amount = txn.get('amount', 0)
+        name = txn.get('name', 'Unknown')
+        category = txn.get('personal_finance_category', {}).get('primary', 'GENERAL_MERCHANDISE')
+        
+        # Skip transfers
+        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
+            continue
+        
+        if amount < 0:
+            income_total += abs(amount)
+        else:
+            expense_total += amount
+            category_totals[category]['total'] += amount
+            category_totals[category]['count'] += 1
+            category_totals[category]['merchants'][name] += amount
+    
+    # Build categories array with merchants
+    categories = []
+    for cat, data in category_totals.items():
+        merchants = [
+            {'name': m_name, 'amount': round(m_amount, 2)}
+            for m_name, m_amount in sorted(data['merchants'].items(), key=lambda x: -x[1])[:10]
+        ]
+        categories.append({
+            'category': cat,
+            'total': round(data['total'], 2),
+            'count': data['count'],
+            'merchants': merchants,
+        })
+    
+    categories.sort(key=lambda x: -x['total'])
+    
+    return {
+        'categories': categories,
+        'income_total': round(income_total, 2),
+        'expense_total': round(expense_total, 2),
+        'remaining': round(income_total - expense_total, 2),
+    }
+ 
+ 
+@app.post("/csv/cashflow/opinion")
+async def csv_cashflow_opinion(request: Request):
+    """AI opinion on cash flow, using CSV transaction context."""
+    from plaid_client import get_snapshot_from_csv
+    
+    body = await request.json()
+    transactions = body.get("transactions", [])
+    category_focus = body.get("category", None)
+    
+    csv_user_id = f"csv-{request.client.host}"
+    financial_context = get_snapshot_from_csv(transactions)
+    
+    if category_focus:
+        prompt = f"""The user is looking at their spending in the "{category_focus}" category. Give them a brief, warm perspective on it.
+ 
+Focus on:
+- What patterns you see in this category
+- Whether the amount feels reasonable given their overall picture
+- One specific observation (not a lecture)
+ 
+Keep it under 150 words. Calm, non-judgmental tone. No lists — just conversational prose."""
+    else:
+        prompt = """Give the user a brief overview of their cash flow this month. 
+ 
+Cover:
+- Overall picture (income vs. expenses)  
+- The category that stands out most
+- One thing worth noticing (not a lecture, not advice unless it's genuinely useful)
+ 
+Keep it under 200 words. Warm, doctor-patient tone. Prose only, no lists."""
+    
+    def generate():
+        for token in stream_answer(prompt, csv_user_id, financial_context=financial_context):
+            yield f"data: {json.dumps({'chunk': token})}\n\n"
+        yield "data: [DONE]\n\n"
+    
+    return StreamingResponse(generate(), media_type="text/event-stream")
+ 
+ 
+@app.post("/csv/yearsphere/data")
+async def csv_yearsphere_data(request: Request):
+    """Year sphere data from CSV transactions."""
+    body = await request.json()
+    transactions = body.get("transactions", [])
+    
+    from collections import defaultdict
+    from datetime import date
+    
+    # Group by month
+    monthly = defaultdict(lambda: {'income': 0, 'expenses': 0, 'transactions': []})
+    
+    for txn in transactions:
+        txn_date_str = txn.get('date', '')
+        try:
+            txn_date = date.fromisoformat(txn_date_str)
+        except (ValueError, TypeError):
+            continue
+        
+        month_key = f"{txn_date.year}-{txn_date.month:02d}"
+        amount = txn.get('amount', 0)
+        category = txn.get('personal_finance_category', {}).get('primary', '')
+        
+        # Skip transfers
+        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
+            continue
+        
+        if amount < 0:
+            monthly[month_key]['income'] += abs(amount)
+        else:
+            monthly[month_key]['expenses'] += amount
+        
+        monthly[month_key]['transactions'].append({
+            'date': txn_date_str,
+            'name': txn.get('name', ''),
+            'amount': amount,
+            'category': category,
+        })
+    
+    # Build months array
+    months = []
+    for month_key in sorted(monthly.keys()):
+        data = monthly[month_key]
+        months.append({
+            'month': month_key,
+            'income': round(data['income'], 2),
+            'expenses': round(data['expenses'], 2),
+            'net': round(data['income'] - data['expenses'], 2),
+            'transaction_count': len(data['transactions']),
+            'top_transactions': sorted(data['transactions'], key=lambda x: abs(x['amount']), reverse=True)[:5],
+        })
+    
+    return {'months': months}

plaid_client.py

@@ -618,4 +618,104 @@ def get_recurring_from_fixtures() -> dict:
             'recurring_income': [],
             'projected_events': [],
             'analysis_period': None,
-        }
+        }
+
+
+
+def _build_synthetic_balances_from_transactions(transactions: list) -> dict:
+    """
+    CSV mode: infer account balances from transaction history.
+    We don't have real balances (CSV doesn't include them), so we estimate:
+    - For each account_id in the transactions, sum credits - debits to get an inferred balance
+    - Use latest transaction as reference point
+    
+    Returns a Plaid-shaped response so downstream formatters work unchanged.
+    """
+    from collections import defaultdict
+    
+    account_totals = defaultdict(float)
+    account_names = {}
+    latest_dates = {}
+    
+    for txn in transactions:
+        acc_id = txn.get('account_id', 'csv_account_default')
+        amount = txn.get('amount', 0)
+        # Plaid convention: positive = expense (money out), negative = income (money in)
+        # So current balance = sum of (-amount) = money in minus money out
+        account_totals[acc_id] += (-amount)
+        
+        # Track a display name — use account_id or default
+        if acc_id not in account_names:
+            account_names[acc_id] = f"Uploaded Account {acc_id[-4:]}" if len(acc_id) > 4 else "Uploaded Account"
+        
+        # Track latest date
+        txn_date = txn.get('date', '')
+        if acc_id not in latest_dates or txn_date > latest_dates[acc_id]:
+            latest_dates[acc_id] = txn_date
+    
+    # Build a Plaid-shaped accounts response
+    accounts = []
+    for acc_id, running_total in account_totals.items():
+        accounts.append({
+            'account_id': acc_id,
+            'name': account_names[acc_id],
+            'subtype': 'checking',  # assume chequing for CSV uploads
+            'balances': {
+                'current': round(running_total, 2),
+                'available': round(running_total, 2),
+                'limit': None,
+            }
+        })
+    
+    if not accounts:
+        # Fallback: single generic account
+        accounts.append({
+            'account_id': 'csv_account_default',
+            'name': 'Uploaded Account',
+            'subtype': 'checking',
+            'balances': {'current': 0, 'available': 0, 'limit': None}
+        })
+    
+    return {'accounts': accounts}
+ 
+ 
+def get_snapshot_from_csv(transactions: list) -> str:
+    """CSV mode: build financial snapshot from user-uploaded transactions."""
+    try:
+        balances = _build_synthetic_balances_from_transactions(transactions)
+        balance_text = _format_balances(balances)
+        transaction_text = _format_transactions(transactions)
+        return f"{balance_text}\n\n{transaction_text}"
+    except Exception as e:
+        print(f"CSV snapshot error: {e}", flush=True)
+        return "NO_BANK_DATA"
+ 
+ 
+def get_chart_data_from_csv(transactions: list) -> dict:
+    """CSV mode: build chart data from user-uploaded transactions."""
+    end_date = date.today()
+    start_date = end_date.replace(day=1)
+    try:
+        balances = _build_synthetic_balances_from_transactions(transactions)
+        return _build_chart_data(balances, transactions, start_date, end_date)
+    except Exception as e:
+        print(f"CSV chart_data error: {e}", flush=True)
+        return {"burndown": [], "income_total": 0, "expense_total": 0, "accounts": []}
+ 
+ 
+def get_recurring_from_csv(transactions: list) -> dict:
+    """CSV mode: detect recurring patterns from user-uploaded transactions."""
+    end_date = date.today()
+    start_date = end_date - timedelta(days=180)
+    try:
+        return _detect_recurring(transactions, start_date, end_date)
+    except Exception as e:
+        print(f"CSV recurring error: {e}", flush=True)
+        return {
+            'recurring_expenses': [],
+            'recurring_income': [],
+            'projected_events': [],
+            'analysis_period': None,
+        }
+ 
+