feat: add user-provided cost basis input for tax analysis

- Add interactive dataframe UI for entering purchase prices and dates
- Support flexible date formats via python-dateutil parser
- Track and display whether user data or simulated data is used
- Add 'Load Holdings' button to pre-populate dataframe from portfolio
- Handle pandas DataFrame with nan values correctly
- Add debug logging for dataframe parsing
- Update disclaimer message dynamically based on data source
- Fall back to simulated data (80% of current price) when not provided

Resolves issue where tax calculations always used simulated data
regardless of user settings.

README.md

@@ -45,7 +45,7 @@ This architecture demonstrates that agentic systems can be both transparent and
 
 **Demo Video**: [TODO: Add link to demo video (1-5 minutes)]
 
-**Team**: [TODO: Add HuggingFace username]
+**Solo, Username**: BrianIsaac
 
 ---
 

app.py

@@ -2463,7 +2463,31 @@ def create_interface() -> gr.Blocks:
                             label="Cost Basis Method",
                             info="Method for calculating gains/losses"
                         )
-                        tax_calculate_btn = gr.Button("Calculate Tax Impact", variant="primary")
+
+                    # Cost basis input section
+                    gr.Markdown("### Purchase Information")
+                    gr.Markdown(
+                        "Enter your purchase details for accurate tax calculations. "
+                        "Click 'Load Holdings' to pre-populate with current holdings, then fill in purchase prices and dates."
+                    )
+                    with gr.Row():
+                        tax_load_holdings_btn = gr.Button("Load Holdings", size="sm")
+                        gr.Markdown(
+                            "*Accepted date formats: 9/3/17, Sep 3, 2017, 2017-09-03, etc.*",
+                            elem_classes="text-muted"
+                        )
+
+                    tax_cost_basis_input = gr.Dataframe(
+                        headers=["Ticker", "Shares", "Purchase Price", "Purchase Date"],
+                        datatype=["str", "number", "number", "str"],
+                        col_count=(4, "fixed"),
+                        row_count=(5, "dynamic"),
+                        interactive=True,
+                        label="Cost Basis Information",
+                        value=[],
+                    )
+
+                    tax_calculate_btn = gr.Button("Calculate Tax Impact", variant="primary")
 
                     # Bottom row: Analysis output
                     tax_analysis_output = gr.Markdown("")
@@ -3448,8 +3472,45 @@ def create_interface() -> gr.Blocks:
                 history_page: gr.update(visible=True)
             }
 
-        def calculate_tax_impact(filing_status: str, annual_income: float, cost_basis_method: str):
-            """Calculate tax impact for current portfolio holdings."""
+        def load_tax_holdings():
+            """Load current portfolio holdings into the cost basis dataframe.
+
+            Returns:
+                List of lists with [ticker, shares, "", ""] for each holding.
+            """
+            global LAST_ANALYSIS_STATE
+
+            if not LAST_ANALYSIS_STATE or "holdings" not in LAST_ANALYSIS_STATE:
+                return []
+
+            holdings = LAST_ANALYSIS_STATE.get("holdings", [])
+            dataframe_data = []
+
+            for holding in holdings:
+                ticker = holding.get("ticker", "")
+                quantity = holding.get("quantity", 0)
+                if ticker and quantity > 0:
+                    dataframe_data.append([ticker, quantity, None, ""])
+
+            return dataframe_data
+
+        def calculate_tax_impact(
+            filing_status: str,
+            annual_income: float,
+            cost_basis_method: str,
+            cost_basis_data: list
+        ):
+            """Calculate tax impact for current portfolio holdings.
+
+            Args:
+                filing_status: Tax filing status
+                annual_income: Annual taxable income
+                cost_basis_method: Cost basis calculation method
+                cost_basis_data: Dataframe rows with ticker, shares, purchase_price, purchase_date
+
+            Returns:
+                Formatted markdown tax analysis report
+            """
             global LAST_ANALYSIS_STATE
 
             if not LAST_ANALYSIS_STATE or "holdings" not in LAST_ANALYSIS_STATE:
@@ -3462,11 +3523,58 @@ Use the "Analyse Portfolio" button to analyse your portfolio, then return here t
 
             try:
                 holdings = LAST_ANALYSIS_STATE.get("holdings", [])
+
+                # Parse cost basis dataframe into structured format
+                user_cost_basis = []
+
+                # Handle pandas DataFrame from Gradio
+                import pandas as pd
+                if isinstance(cost_basis_data, pd.DataFrame):
+                    logger.info(f"Received DataFrame with {len(cost_basis_data)} rows")
+                    if not cost_basis_data.empty:
+                        # Convert DataFrame to list of lists
+                        cost_basis_rows = cost_basis_data.values.tolist()
+                        logger.info(f"DataFrame data: {cost_basis_rows}")
+                    else:
+                        cost_basis_rows = []
+                        logger.info("DataFrame is empty")
+                elif cost_basis_data is not None:
+                    # Already a list
+                    cost_basis_rows = cost_basis_data
+                    logger.info(f"Received list with {len(cost_basis_rows)} rows")
+                else:
+                    cost_basis_rows = []
+                    logger.info("No cost basis data provided")
+
+                for row in cost_basis_rows:
+                    if len(row) >= 4:
+                        # Handle pandas nan values
+                        ticker_val = row[0]
+                        if pd.isna(ticker_val) or not str(ticker_val).strip():
+                            continue
+
+                        ticker = str(ticker_val).strip().upper()
+                        shares = None if pd.isna(row[1]) else row[1]
+                        purchase_price = None if pd.isna(row[2]) else row[2]
+                        purchase_date = "" if pd.isna(row[3]) else str(row[3]).strip()
+
+                        # Only include rows with meaningful data
+                        if ticker and purchase_price is not None and purchase_date:
+                            user_cost_basis.append({
+                                "ticker": ticker,
+                                "shares": shares,
+                                "purchase_price": purchase_price,
+                                "purchase_date": purchase_date,
+                            })
+
+                logger.info(f"Parsed {len(user_cost_basis)} valid cost basis entries: {user_cost_basis}")
+
                 report = create_tax_analysis(
                     holdings=holdings,
                     filing_status=filing_status,
                     annual_income=annual_income,
                     cost_basis_method=cost_basis_method,
+                    user_cost_basis=user_cost_basis if user_cost_basis else None,
                 )
                 return format_tax_analysis_output(report)
             except Exception as e:
@@ -3833,10 +3941,17 @@ Please try again with different parameters.
             outputs=[history_table_results, history_page_info_results]
         )
 
+        # Tax load holdings button
+        tax_load_holdings_btn.click(
+            load_tax_holdings,
+            inputs=[],
+            outputs=[tax_cost_basis_input]
+        )
+
         # Tax calculator button (Enhancement #5)
         tax_calculate_btn.click(
             calculate_tax_impact,
-            inputs=[tax_filing_status, tax_annual_income, tax_cost_basis_method],
+            inputs=[tax_filing_status, tax_annual_income, tax_cost_basis_method, tax_cost_basis_input],
             outputs=[tax_analysis_output]
         )
 

backend/tax/interface.py

@@ -8,6 +8,7 @@ from datetime import date
 from decimal import Decimal
 from typing import List, Dict, Any, Tuple, Optional
 import logging
+from dateutil import parser as date_parser
 
 from backend.tax.calculator import TaxCalculator
 from backend.tax.optimizer import TaxOptimizer
@@ -24,6 +25,7 @@ def create_tax_analysis(
     filing_status: str = "single",
     annual_income: float = 75000.0,
     cost_basis_method: str = "fifo",
+    user_cost_basis: Optional[List[Dict[str, Any]]] = None,
 ) -> Dict[str, Any]:
     """Create comprehensive tax analysis for portfolio holdings.
 
@@ -32,6 +34,7 @@ def create_tax_analysis(
         filing_status: Tax filing status (single, married_joint, married_separate, head_of_household)
         annual_income: Annual taxable income
         cost_basis_method: Cost basis method (fifo, lifo, hifo, average)
+        user_cost_basis: Optional user-provided cost basis data with ticker, shares, purchase_price, purchase_date
 
     Returns:
         Dictionary containing tax analysis results
@@ -62,8 +65,18 @@ def create_tax_analysis(
             tax_year=2024,
         )
 
-        # For demonstration, create sample tax lots from holdings
-        # In real implementation, this would come from transaction history
+        # Convert user cost basis to dictionary for easy lookup
+        user_basis_map = {}
+        if user_cost_basis:
+            for entry in user_cost_basis:
+                ticker = entry.get("ticker", "").strip().upper()
+                if ticker:
+                    user_basis_map[ticker] = entry
+
+        # Track whether we used any user-provided data
+        used_user_data = False
+
+        # Create tax lots from holdings using user data or simulated data
         current_prices = {}
         for holding in holdings:
             ticker = holding.get("ticker", "")
@@ -76,14 +89,53 @@ def create_tax_analysis(
             )
             current_prices[ticker] = Decimal(str(current_price))
 
-            # Create sample tax lot (assuming purchase at 20% below current price for demo)
-            # In real implementation, use actual transaction data
             quantity = Decimal(str(holding.get("quantity", 0)))
-            if quantity > 0:
-                # Simulate purchase at lower price to show potential gains
-                sample_cost_basis = current_price * Decimal("0.8")
-                acquisition_date = date.today().replace(year=date.today().year - 1)
+            if quantity <= 0:
+                continue
 
+            # Use user-provided cost basis if available
+            if ticker in user_basis_map:
+                user_entry = user_basis_map[ticker]
+                try:
+                    # Parse purchase price
+                    purchase_price = Decimal(str(user_entry.get("purchase_price", 0)))
+                    if purchase_price <= 0:
+                        raise ValueError("Invalid purchase price")
+
+                    # Parse purchase date
+                    date_str = user_entry.get("purchase_date", "")
+                    if isinstance(date_str, str) and date_str.strip():
+                        acquisition_date = date_parser.parse(date_str).date()
+                    else:
+                        raise ValueError("Invalid purchase date")
+
+                    # Use user-specified shares if available
+                    user_shares = user_entry.get("shares")
+                    if user_shares is not None:
+                        quantity = Decimal(str(user_shares))
+
+                    tax_calc.add_tax_lot(
+                        ticker=ticker,
+                        acquisition_date=acquisition_date,
+                        quantity=quantity,
+                        cost_basis_per_share=purchase_price,
+                    )
+                    used_user_data = True
+                except (ValueError, AttributeError) as e:
+                    logger.warning(f"Invalid user cost basis for {ticker}: {e}. Using simulated data.")
+                    # Fall back to simulated data
+                    sample_cost_basis = current_prices[ticker] * Decimal("0.8")
+                    acquisition_date = date.today().replace(year=date.today().year - 1)
+                    tax_calc.add_tax_lot(
+                        ticker=ticker,
+                        acquisition_date=acquisition_date,
+                        quantity=quantity,
+                        cost_basis_per_share=sample_cost_basis,
+                    )
+            else:
+                # Use simulated data (20% below current price for demonstration)
+                sample_cost_basis = current_prices[ticker] * Decimal("0.8")
+                acquisition_date = date.today().replace(year=date.today().year - 1)
                 tax_calc.add_tax_lot(
                     ticker=ticker,
                     acquisition_date=acquisition_date,
@@ -128,6 +180,7 @@ def create_tax_analysis(
             "filing_status": filing_status,
             "annual_income": annual_income,
             "cost_basis_method": cost_basis_method,
+            "used_user_data": used_user_data,
             "long_term_rate": float(lt_rate * 100),
             "short_term_rate": float(st_rate * 100),
             "total_unrealised_gains": float(total_unrealised_gains),
@@ -306,9 +359,21 @@ Commonly used for mutual funds and some ETFs.""",
 3. Review wash sale implications before selling and repurchasing
 4. Consider tax-efficient rebalancing strategies
 5. Consult your tax advisor before implementing any strategy
+"""
+
+    # Add disclaimer based on whether user data was used
+    if report.get('used_user_data', False):
+        md += """
+---
+
+**Data Source**: This analysis uses your provided purchase information for accurate tax calculations.
+"""
+    else:
+        md += """
+---
 
-*This analysis assumes current holdings were purchased at prices 20% below current market prices for demonstration purposes.
-For accurate analysis, provide actual transaction history including purchase dates and costs.*
+**Data Source**: This analysis assumes current holdings were purchased at prices 20% below current market prices for demonstration purposes.
+For accurate analysis, use the 'Load Holdings' button and enter your actual purchase prices and dates.
 """
 
     return md

pyproject.toml

@@ -60,6 +60,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
     "httpx>=0.25.0",
     "tenacity>=8.2.0",
+    "python-dateutil>=2.8.0",
     # Sentiment Analysis
     "vaderSentiment>=3.3.2",
     # Monitoring & Observability

uv.lock

@@ -3506,6 +3506,7 @@ dependencies = [
     { name = "pydantic-ai" },
     { name = "pypdf" },
     { name = "pyportfolioopt" },
+    { name = "python-dateutil" },
     { name = "python-dotenv" },
     { name = "pywavelets" },
     { name = "quantstats" },
@@ -3563,6 +3564,7 @@ requires-dist = [
     { name = "pydantic-ai", specifier = "==1.18.0" },
     { name = "pypdf", specifier = ">=3.17.0" },
     { name = "pyportfolioopt", specifier = ">=1.5.6" },
+    { name = "python-dateutil", specifier = ">=2.8.0" },
     { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "pywavelets", specifier = ">=1.4.1" },
     { name = "quantstats", specifier = ">=0.0.77" },