portfolio_analysis_dashboard.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import os\n",
    "import re\n",
    "import math\n",
    "from datetime import datetime, timedelta, time\n",
    "from collections import defaultdict\n",
    "from decimal import Decimal\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "from plotly.io import to_html\n",
    "\n",
    "import yfinance as yf\n",
    "\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "from transaction_history_processor import PortfolioHistory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_closest_date(dates, target_date):\n",
    "    target_date = pd.to_datetime(target_date)\n",
    "    dates = pd.to_datetime(dates)\n",
    "    closest_date = min(dates, key=lambda x: abs(x - target_date))\n",
    "    return closest_date.strftime('%Y-%m-%d')\n",
    "\n",
    "NOTEBOOK_DATE = None  # Set to None to use the latest date by default\n",
    "\n",
    "# To set a specific date, uncomment and modify the following line:\n",
    "# NOTEBOOK_DATE = \"2023-12-19\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if not os.path.exists('portfolio_history.json'):\n",
    "\n",
    "print(\"Generating / updating portfolio_history.json...\")\n",
    "portfolio_history = PortfolioHistory()\n",
    "portfolio_history.process_transaction_history(\n",
    "    input_file='transaction_history.json',\n",
    "    save_output=True,\n",
    "    output_file='portfolio_history.json'\n",
    ")\n",
    "print(\"portfolio_history.json has been generated / updated.\")\n",
    "\n",
    "with open('portfolio_history.json', 'r') as f:\n",
    "    data = json.load(f)\n",
    "    sectors = data['sectors']\n",
    "    portfolio_data = data['portfolios']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adjust NOTEBOOK_DATE if it's set but not available in the data\n",
    "if NOTEBOOK_DATE:\n",
    "    available_dates = sorted(portfolio_data.keys())\n",
    "    if NOTEBOOK_DATE not in available_dates:\n",
    "        closest_date = find_closest_date(available_dates, NOTEBOOK_DATE)\n",
    "        print(f\"No data available for {\n",
    "              NOTEBOOK_DATE}. Using closest available date: {closest_date}\")\n",
    "        NOTEBOOK_DATE = closest_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_portfolio_data(portfolio_data, date=None, sort_by='Symbol', ascending=True):\n",
    "    date = NOTEBOOK_DATE or date or max(portfolio_data.keys())\n",
    "    if date not in portfolio_data:\n",
    "        raise ValueError(f\"No data available for date: {date}\")\n",
    "\n",
    "    data = portfolio_data[date]\n",
    "    holdings_data = process_holdings(data['holdings'])\n",
    "\n",
    "    df = pd.DataFrame(holdings_data)\n",
    "    df = df.sort_values(by=sort_by, ascending=ascending)\n",
    "\n",
    "    closed_positions_df = process_closed_positions(data['closed_positions'])\n",
    "    partially_sold_positions_df = process_partially_sold_positions(\n",
    "        data['partially_sold_positions'])\n",
    "\n",
    "    return {\n",
    "        'date': date,\n",
    "        'holdings': df,\n",
    "        'summary': data['summary'],\n",
    "        'closed_positions': closed_positions_df,\n",
    "        'partially_sold_positions': partially_sold_positions_df,\n",
    "    }\n",
    "\n",
    "def process_holdings(holdings):\n",
    "    return [\n",
    "        {\n",
    "            'Symbol': symbol,\n",
    "            'Quantity': round(float(info['quantity']), 2),\n",
    "            'Avg Cost': round(float(info['average_cost']), 2),\n",
    "            'Market Price': round(float(info['market_price']), 2),\n",
    "            'Total Cost': round(float(info['cost_basis']), 2),\n",
    "            'Market Value': round(float(info['market_value']), 2),\n",
    "            'Profit/Loss': f\"${float(info['unrealized_pnl']):,.2f} ({float(info['unrealized_return'])*100:.2f}%)\",\n",
    "            'Daily Change': f\"${float(info['daily_change']):,.2f} ({float(info['daily_return'])*100:.2f}%)\"\n",
    "        }\n",
    "        for symbol, info in holdings.items()\n",
    "    ]\n",
    "\n",
    "def process_closed_positions(closed_positions):\n",
    "    df = pd.DataFrame(closed_positions).T.reset_index()\n",
    "    df.columns = ['Symbol', 'Close Date', 'Quantity',\n",
    "                  'Cost Basis', 'Profit/Loss', 'Return']\n",
    "    df['Profit/Loss'] = df['Profit/Loss'].apply(\n",
    "        lambda x: f\"${float(x):,.2f}\")\n",
    "    df['Return'] = df['Return'].apply(\n",
    "        lambda x: f\"{float(x)*100:.2f}%\")  # Multiply by 100 here\n",
    "    return df\n",
    "\n",
    "def process_partially_sold_positions(partially_sold_positions):\n",
    "    df = pd.DataFrame(partially_sold_positions).T.reset_index()\n",
    "    df.columns = ['Symbol', 'Last Sell Date', 'Quantity',\n",
    "                  'Cost Basis', 'Profit/Loss', 'Return']\n",
    "    df['Profit/Loss'] = df['Profit/Loss'].apply(\n",
    "        lambda x: f\"${float(x):,.2f}\")\n",
    "    df['Return'] = df['Return'].apply(\n",
    "        lambda x: f\"{float(x)*100:.2f}%\")  # Multiply by 100 here\n",
    "    return df\n",
    "\n",
    "def display_portfolio_analysis(processed_data):\n",
    "    date = processed_data['date']\n",
    "    df = processed_data['holdings']\n",
    "    summary = processed_data['summary']\n",
    "    closed_positions_df = processed_data['closed_positions']\n",
    "    partially_sold_positions_df = processed_data['partially_sold_positions']\n",
    "\n",
    "    # Display holdings\n",
    "    display(HTML(f\"<h2>Portfolio Status as of {date}</h2>\"))\n",
    "    display(HTML(df.to_html(index=False, classes='dataframe')))\n",
    "\n",
    "    # Display summary\n",
    "    print(\"\\nPortfolio Summary:\")\n",
    "    print_summary_item(\"Cash\", summary['cash'])\n",
    "    print_summary_item(\"Total Value\", summary['total_value'])\n",
    "    print_summary_item(\"Total Market Value\", summary['total_market_value'])\n",
    "    print_summary_item(\"Total Deposits\", summary['total_deposits'])\n",
    "\n",
    "    # Display Unrealized Gain/Loss with percentage\n",
    "    # total_unrealized_pnl = summary['total_unrealized_pnl']\n",
    "    # total_unrealized_return = summary['total_unrealized_return']\n",
    "    # print(f\"Unrealized Profit/Loss: ${float(total_unrealized_pnl)\n",
    "    #       :,.2f} ({float(total_unrealized_return)*100:.2f}%)\")\n",
    "\n",
    "    # total_realized_pnl = summary['total_realized_pnl']\n",
    "    # total_realized_return = summary['total_realized_return']\n",
    "    # print(f\"Realized Profit/Loss: ${float(total_realized_pnl)\n",
    "    #       :,.2f} ({float(total_realized_return)*100:.2f}%)\")\n",
    "    \n",
    "    total_pnl = float(summary['total_value']) - \\\n",
    "        float(summary['total_deposits'])\n",
    "    total_return = total_pnl / float(summary['total_deposits'])\n",
    "    print(f\"Total Profit/Loss: ${total_pnl:,.2f} ({total_return*100:.2f}%)\")\n",
    "\n",
    "    # Display daily gain\n",
    "    daily_gain_loss = summary['total_daily_change']\n",
    "    daily_return = summary['total_daily_return']\n",
    "    print(f\"Daily Gain: ${float(daily_gain_loss)\n",
    "          :,.2f} ({float(daily_return)*100:.2f}%)\")\n",
    "    \n",
    "    # Display closed positions\n",
    "    print(\"\\nClosed Positions:\")\n",
    "    display(HTML(closed_positions_df.to_html(index=False, classes='dataframe')))\n",
    "\n",
    "    # Display partially sold positions\n",
    "    print(\"\\nPartially Sold Positions:\")\n",
    "    display(HTML(partially_sold_positions_df.to_html(\n",
    "        index=False, classes='dataframe')))\n",
    "\n",
    "def print_summary_item(label, value, is_percentage=False):\n",
    "    if is_percentage:\n",
    "        print(f\"{label}: {float(value)*100:.2f}%\")\n",
    "    else:\n",
    "        print(f\"{label}: ${float(value):,.2f}\")\n",
    "\n",
    "\n",
    "# Example usage:\n",
    "\n",
    "# processed_data = process_portfolio_data(portfolio_data, date=\"2024-03-21\")\n",
    "processed_data = process_portfolio_data(portfolio_data)\n",
    "\n",
    "display_portfolio_analysis(processed_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_stock_proportions(portfolio_data, date=None, show_values=True, main_threshold=3.0):\n",
    "    date = NOTEBOOK_DATE or date or max(portfolio_data.keys())\n",
    "    if date not in portfolio_data:\n",
    "        raise ValueError(f\"No data available for date: {date}\")\n",
    "\n",
    "    holdings = portfolio_data[date]['holdings']\n",
    "    labels = list(holdings.keys())\n",
    "    values = [float(data['market_value']) for data in holdings.values()]\n",
    "\n",
    "    total = sum(values)\n",
    "    percentages = [(value / total) * 100 for value in values]\n",
    "\n",
    "    main_holdings = list(zip(labels, values, percentages))\n",
    "    main_holdings.sort(key=lambda x: x[2], reverse=True)\n",
    "\n",
    "    other_holdings = [h for h in main_holdings if h[2] < main_threshold]\n",
    "    if len(other_holdings) > 1:\n",
    "        others_value = sum(v for _, v, _ in other_holdings)\n",
    "        others_percentage = sum(p for _, _, p in other_holdings)\n",
    "        other_symbols_info = \"<br>\".join(f\"<span style='font-family: monospace;'>{l:<5}\\t{\n",
    "                                         p:>6.2f}%</span>\" for l, _, p in other_holdings)\n",
    "        main_holdings = [h for h in main_holdings if h[2] >=\n",
    "                         main_threshold] + [(\"Others\", others_value, others_percentage)]\n",
    "\n",
    "    main_labels, main_values, main_percentages = zip(*main_holdings)\n",
    "\n",
    "    # Create custom hover text\n",
    "    hover_text = [f\"{label}<br>${value:,.2f}<br>{percentage:.2f}%\" for label,\n",
    "                  value, percentage in zip(main_labels, main_values, main_percentages)]\n",
    "    if \"Others\" in main_labels:\n",
    "        others_index = main_labels.index(\"Others\")\n",
    "        hover_text[others_index] += f\"<br><br>{other_symbols_info}\"\n",
    "\n",
    "    fig = go.Figure(data=[go.Pie(labels=main_labels,\n",
    "                                 values=main_percentages,\n",
    "                                 textinfo='label+percent',\n",
    "                                 hovertext=hover_text,\n",
    "                                 hoverinfo='text')])\n",
    "\n",
    "    fig.update_layout(\n",
    "        title=f'Stock Proportions by Value on {date}',\n",
    "        showlegend=True,\n",
    "        legend=dict(title=\"Holdings\")\n",
    "    )\n",
    "\n",
    "    if show_values:\n",
    "        fig.update_traces(\n",
    "            text=[f'${value:,.2f}' for value in main_values], textposition='inside')\n",
    "\n",
    "    return fig\n",
    "\n",
    "\n",
    "# Example usage:\n",
    "# plot_stock_proportions(portfolio_data, date=\"2024-04-10\", show_values=False)\n",
    "plot_stock_proportions(portfolio_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_sector_proportions(portfolio_data, sectors, date=None, max_label_length=15):\n",
    "    date = NOTEBOOK_DATE or date or max(portfolio_data.keys())\n",
    "    if date not in portfolio_data:\n",
    "        raise ValueError(f\"No data available for date: {date}\")\n",
    "\n",
    "    holdings = portfolio_data[date]['holdings']\n",
    "    sector_values = defaultdict(float)\n",
    "    total_value = 0\n",
    "\n",
    "    for symbol, data in holdings.items():\n",
    "        sector = sectors.get(symbol, 'ETF')\n",
    "        market_value = float(data['market_value'])\n",
    "        sector_values[sector] += market_value\n",
    "        total_value += market_value\n",
    "\n",
    "    labels = list(sector_values.keys())\n",
    "    sizes = list(sector_values.values())\n",
    "    percentages = [value / total_value * 100 for value in sizes]\n",
    "\n",
    "    # Wrap long labels\n",
    "    wrapped_labels = [wrap_label(label, max_label_length) for label in labels]\n",
    "\n",
    "    hover_text = [f\"{sector}<br>${value:,.2f}<br>{percentage:.2f}%\"\n",
    "                  for sector, value, percentage in zip(labels, sizes, percentages)]\n",
    "\n",
    "    fig = go.Figure(data=[go.Pie(\n",
    "        labels=wrapped_labels,\n",
    "        values=sizes,\n",
    "        text=[f'${value:,.2f}' for value in sizes],\n",
    "        hovertext=hover_text,\n",
    "        hoverinfo='text',\n",
    "        textinfo='label+percent'\n",
    "    )])\n",
    "\n",
    "    fig.update_layout(\n",
    "        title=f'Sector Proportions on {date}',\n",
    "        showlegend=True,\n",
    "        legend=dict(title=\"Sectors\")\n",
    "    )\n",
    "\n",
    "    return fig\n",
    "\n",
    "\n",
    "def wrap_label(label, max_length):\n",
    "    if len(label) <= max_length:\n",
    "        return label\n",
    "\n",
    "    # Find the last space before max_length\n",
    "    split_index = label.rfind(' ', 0, max_length)\n",
    "    if split_index == -1:  # If no space found, split at max_length\n",
    "        split_index = max_length\n",
    "\n",
    "    return f\"{label[:split_index]}<br>{label[split_index:].strip()}\"\n",
    "\n",
    "# Example usage:\n",
    "# plot_sector_proportions(portfolio_data, sectors, date=\"2024-04-10\")\n",
    "plot_sector_proportions(portfolio_data, sectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_portfolio_growth(portfolio_data, end_date=None):\n",
    "    dates = sorted(portfolio_data.keys())\n",
    "\n",
    "    end_date = NOTEBOOK_DATE or end_date or max(portfolio_data.keys())\n",
    "    if end_date is None:\n",
    "        end_date = dates[-1]\n",
    "    else:\n",
    "        end_date = str(end_date)\n",
    "        if end_date not in dates:\n",
    "            raise ValueError(f\"No data available for date: {end_date}\")\n",
    "\n",
    "    start_date = pd.to_datetime(dates[0])\n",
    "    dates = [d for d in dates if pd.to_datetime(\n",
    "        d) >= start_date and pd.to_datetime(d) <= pd.to_datetime(end_date)]\n",
    "\n",
    "    df_plot = pd.DataFrame({\n",
    "        'Date': pd.to_datetime(dates),\n",
    "        'Total Market Value': [float(portfolio_data[d]['summary']['total_market_value']) for d in dates],\n",
    "        'Cash': [float(portfolio_data[d]['summary']['cash']) for d in dates],\n",
    "        'Unrealized P/L': [float(portfolio_data[d]['summary']['total_unrealized_pnl']) for d in dates],\n",
    "        'Realized P/L': [float(portfolio_data[d]['summary']['total_realized_pnl']) for d in dates],\n",
    "        'Total P/L': [float(portfolio_data[d]['summary']['total_value']) - float(portfolio_data[d]['summary']['total_deposits']) for d in dates],\n",
    "        'Daily P/L': [float(portfolio_data[d]['summary']['total_daily_change']) for d in dates],\n",
    "        'Unrealized Return (%)': [float(portfolio_data[d]['summary']['total_unrealized_return']) * 100 for d in dates],\n",
    "        'Realized Return (%)': [float(portfolio_data[d]['summary']['total_realized_return']) * 100 for d in dates],\n",
    "        'Total Return (%)': [(float(portfolio_data[d]['summary']['total_value']) - float(portfolio_data[d]['summary']['total_deposits'])) / float(portfolio_data[d]['summary']['total_deposits']) * 100 for d in dates],\n",
    "        'Daily Return (%)': [float(portfolio_data[d]['summary']['total_daily_return']) * 100 for d in dates],\n",
    "    })\n",
    "\n",
    "    returns = calculate_returns(df_plot, pd.to_datetime(end_date))\n",
    "\n",
    "    fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n",
    "\n",
    "    # Add traces in the desired order\n",
    "    # add_realized_pl_trace(fig, df_plot)\n",
    "    # add_unrealized_pl_trace(fig, df_plot)\n",
    "    # add_unrealized_return_trace(fig, df_plot)\n",
    "    add_total_return_trace(fig, df_plot)\n",
    "    add_sp500_return_trace(fig, df_plot)\n",
    "    add_total_market_value_trace(fig, df_plot)\n",
    "\n",
    "    add_performance_annotation(fig, returns)\n",
    "\n",
    "    fig.update_layout(\n",
    "        title={'text': f'Portfolio Performance as of {end_date}<br>',\n",
    "               'xanchor': 'left',\n",
    "               'yanchor': 'top'},\n",
    "        xaxis_title='Date',\n",
    "        hovermode='x unified',\n",
    "        showlegend=True,\n",
    "        xaxis=dict(\n",
    "            rangeslider=dict(visible=False),\n",
    "            rangeselector=dict(\n",
    "                buttons=get_range_selector_buttons(df_plot)\n",
    "            )\n",
    "        ),\n",
    "        margin=dict(t=120),\n",
    "        barmode='stack'\n",
    "    )\n",
    "\n",
    "    fig.update_yaxes(title_text=\"Return (%)\",\n",
    "                     ticksuffix='%', secondary_y=False)\n",
    "    fig.update_yaxes(title_text=\"Value ($)\", tickprefix='$', secondary_y=True)\n",
    "\n",
    "    return fig\n",
    "\n",
    "def calculate_returns(df_plot, latest_date):\n",
    "    returns = {}\n",
    "    periods = [('1D', 1), ('1W', 7), ('1M', 30), ('3M', 90),\n",
    "               ('6M', 180), ('YTD', None), ('1Y', 365), ('Max', None)]\n",
    "\n",
    "    for period, days in periods:\n",
    "        if period == '1D':\n",
    "            # Use the daily return directly for 1D\n",
    "            returns[period] = df_plot[df_plot['Date'] ==\n",
    "                                      latest_date]['Daily Return (%)'].values[0]\n",
    "        elif period == 'YTD':\n",
    "            start_date = pd.Timestamp(year=latest_date.year, month=1, day=1)\n",
    "        elif period == 'Max':\n",
    "            start_date = df_plot['Date'].min()\n",
    "        else:\n",
    "            start_date = latest_date - pd.Timedelta(days=days)\n",
    "\n",
    "        if period != '1D' and start_date >= df_plot['Date'].min():\n",
    "            returns[period] = df_plot[df_plot['Date'] == latest_date]['Total Return (%)'].values[0] - \\\n",
    "                df_plot[df_plot['Date'] >=\n",
    "                        start_date]['Total Return (%)'].iloc[0]\n",
    "\n",
    "    return returns\n",
    "\n",
    "\n",
    "def add_total_market_value_trace(fig, df_plot):\n",
    "    fig.add_trace(\n",
    "        go.Scatter(x=df_plot['Date'], y=df_plot['Total Market Value'].round(2),\n",
    "                   line=dict(color='green', width=2), name='Market Value', visible=True,\n",
    "                   hovertemplate='$%{y:,.2f}\\t(Cash: $%{customdata:,.2f})',\n",
    "                   customdata=df_plot['Cash'].round(2)),\n",
    "        secondary_y=True\n",
    "    )\n",
    "\n",
    "def add_total_return_trace(fig, df_plot):\n",
    "    fig.add_trace(\n",
    "        go.Scatter(x=df_plot['Date'], y=df_plot['Total Return (%)'].round(2),\n",
    "                   fill='tozeroy',\n",
    "                   fillcolor='rgba(255,0,0,0.2)',\n",
    "                   line=dict(color='red', width=2), name='Total Return',\n",
    "                   hovertemplate='%{y:.2f}%\\t(P/L: %{customdata:.2f})',\n",
    "                   customdata=df_plot['Total P/L'].round(2), visible=True),\n",
    "        secondary_y=False\n",
    "    )\n",
    "\n",
    "# def add_unrealized_return_trace(fig, df_plot):\n",
    "#     fig.add_trace(\n",
    "#         go.Scatter(x=df_plot['Date'], y=df_plot['Unrealized Return (%)'].round(2), fill='tozeroy',\n",
    "#                    fillcolor='rgba(255,0,0,0.2)', line=dict(color='red', width=2), name='Unr. Return',\n",
    "#                    hovertemplate='%{y:.2f}%\\t(Daily: %{customdata:.2f}%)',\n",
    "#                    customdata=df_plot['Daily Return (%)'].round(2), visible=True),\n",
    "#         secondary_y=False\n",
    "#     )\n",
    "\n",
    "def add_unrealized_pl_trace(fig, df_plot):\n",
    "    fig.add_trace(\n",
    "        go.Bar(x=df_plot['Date'], y=df_plot['Unrealized P/L'].round(2), name='Unr. P/L',\n",
    "               marker_color='gray', opacity=0.9,\n",
    "               hovertemplate='$%{y:.2f} (Daily: $%{customdata:.2f})',\n",
    "               customdata=df_plot['Daily P/L'].round(2)),\n",
    "        secondary_y=True\n",
    "    )\n",
    "\n",
    "def add_realized_pl_trace(fig, df_plot):\n",
    "    fig.add_trace(\n",
    "        go.Bar(x=df_plot['Date'], y=df_plot['Realized P/L'].round(2), name='Realized P/L',\n",
    "               marker_color='black', opacity=0.9,\n",
    "               hovertemplate='$%{y:.2f}'),\n",
    "        secondary_y=True\n",
    "    )\n",
    "\n",
    "\n",
    "def add_sp500_return_trace(fig, df_plot):\n",
    "    sp500_data = fetch_sp500_data(df_plot['Date'].min(), df_plot['Date'].max())\n",
    "    sp500_performance = (\n",
    "        (sp500_data['Close'] - sp500_data['Close'].iloc[0]) / sp500_data['Close'].iloc[0]) * 100\n",
    "    fig.add_trace(\n",
    "        go.Scatter(x=sp500_data.index, y=sp500_performance.round(2), line=dict(color='blue', width=2),\n",
    "                   name='S&P 500 Return', visible=True,\n",
    "                   hovertemplate='S&P 500 Return: %{y:.2f}%<extra></extra>'),\n",
    "        secondary_y=False\n",
    "    )\n",
    "\n",
    "\n",
    "def add_performance_annotation(fig, returns):\n",
    "    performance_text = \"Portfolio Return:<br>\"\n",
    "    for i, (period, value) in enumerate(returns.items()):\n",
    "        if i % 2 == 0 and i != 0:\n",
    "            performance_text += \"<br>\"\n",
    "        color = 'green' if value >= 0 else 'red'\n",
    "        sign = '+' if value > 0 else ('-' if value < 0 else ' ')\n",
    "        formatted_value = f\"{sign}{abs(value):6.2f}%\"\n",
    "        performance_text += f\"<span style='display: inline-block; width: 70px;'>{\n",
    "            period:>3}: <span style='color: {color};'>{formatted_value:>9}</span></span>\"\n",
    "        if i % 2 == 0 and i != len(returns) - 1:\n",
    "            performance_text += \" | \"\n",
    "\n",
    "    fig.add_annotation(\n",
    "        x=1, y=1.05, xref='paper', yref='paper', text=performance_text, showarrow=False,\n",
    "        font=dict(size=10, family=\"monospace\"), align='left', xanchor='right', yanchor='bottom',\n",
    "        bgcolor='rgba(255,255,255,0.8)', bordercolor='rgba(0,0,0,0.5)', borderwidth=1, borderpad=4\n",
    "    )\n",
    "\n",
    "def get_range_selector_buttons(df_plot):\n",
    "    start_date = df_plot['Date'].min()\n",
    "    end_date = df_plot['Date'].max()\n",
    "    date_range = end_date - start_date\n",
    "\n",
    "    buttons = []\n",
    "\n",
    "    if date_range >= timedelta(days=7):\n",
    "        buttons.append(\n",
    "            dict(count=7, label=\"1W\", step=\"day\", stepmode=\"backward\"))\n",
    "\n",
    "    if date_range >= timedelta(days=30):\n",
    "        buttons.append(\n",
    "            dict(count=1, label=\"1M\", step=\"month\", stepmode=\"backward\"))\n",
    "\n",
    "    if date_range >= timedelta(days=90):\n",
    "        buttons.append(\n",
    "            dict(count=3, label=\"3M\", step=\"month\", stepmode=\"backward\"))\n",
    "\n",
    "    if date_range >= timedelta(days=180):\n",
    "        buttons.append(\n",
    "            dict(count=6, label=\"6M\", step=\"month\", stepmode=\"backward\"))\n",
    "\n",
    "    if end_date.year > start_date.year:\n",
    "        buttons.append(dict(count=1, label=\"YTD\",\n",
    "                       step=\"year\", stepmode=\"todate\"))\n",
    "\n",
    "    if date_range >= timedelta(days=365):\n",
    "        buttons.append(\n",
    "            dict(count=1, label=\"1Y\", step=\"year\", stepmode=\"backward\"))\n",
    "\n",
    "    buttons.append(dict(step=\"all\", label=\"MAX\"))\n",
    "\n",
    "    return buttons\n",
    "\n",
    "\n",
    "def fetch_sp500_data(start_date, end_date):\n",
    "    end_date = pd.to_datetime(end_date) + timedelta(days=1)\n",
    "    sp500 = yf.Ticker(\"^GSPC\")\n",
    "    sp500_data = sp500.history(start=start_date, end=end_date)\n",
    "    return sp500_data[['Close']]\n",
    "\n",
    "# Example usage:\n",
    "# To plot for the latest date:\n",
    "# plot_portfolio_growth(portfolio_data)\n",
    "\n",
    "# To plot for a specific date:\n",
    "# plot_portfolio_growth(portfolio_data, end_date=\"2024-03-15\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_portfolio_growth(portfolio_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_asset_allocation_over_time(portfolio_data, sort_by='percentage', end_date=None):\n",
    "    dates = sorted(portfolio_data.keys())\n",
    "\n",
    "    end_date = NOTEBOOK_DATE or end_date or max(portfolio_data.keys())\n",
    "    if end_date is None:\n",
    "        end_date = dates[-1]\n",
    "    else:\n",
    "        end_date = str(end_date)\n",
    "        if end_date not in dates:\n",
    "            raise ValueError(f\"No data available for date: {end_date}\")\n",
    "\n",
    "    # Filter dates to include only up to the end_date\n",
    "    dates = [date for date in dates if date <= end_date]\n",
    "\n",
    "    latest_date = end_date\n",
    "    active_stocks = get_active_stocks(portfolio_data[latest_date]['holdings'])\n",
    "    data = calculate_asset_proportions(portfolio_data, dates, active_stocks)\n",
    "\n",
    "    fig = go.Figure()\n",
    "    add_asset_traces(fig, dates, data, portfolio_data, sort_by)\n",
    "    update_layout(fig, sort_by, latest_date)\n",
    "\n",
    "    # Set x-axis range\n",
    "    fig.update_xaxes(range=[dates[0], latest_date])\n",
    "\n",
    "    return fig\n",
    "\n",
    "\n",
    "def get_active_stocks(latest_holdings):\n",
    "    return [stock for stock, info in latest_holdings.items()\n",
    "            if float(info['market_value']) > 0]\n",
    "\n",
    "\n",
    "def calculate_asset_proportions(portfolio_data, dates, active_stocks):\n",
    "    data = {stock: [] for stock in active_stocks}\n",
    "    data['Cash'] = []\n",
    "\n",
    "    for date in dates:\n",
    "        holdings = portfolio_data[date]['holdings']\n",
    "        valid_holdings = {stock: info for stock, info in holdings.items()\n",
    "                          if not math.isnan(float(info['market_value']))}\n",
    "\n",
    "        cash = float(portfolio_data[date]['summary']['cash'])\n",
    "        total_value = sum(float(info['market_value'])\n",
    "                          for info in valid_holdings.values()) + cash\n",
    "\n",
    "        for stock in active_stocks:\n",
    "            if stock in valid_holdings:\n",
    "                value = float(valid_holdings[stock]['market_value'])\n",
    "                proportion = (value / total_value) * \\\n",
    "                    100 if total_value > 0 else 0\n",
    "            else:\n",
    "                proportion = 0\n",
    "            data[stock].append(proportion)\n",
    "\n",
    "        cash_proportion = (cash / total_value) * 100 if total_value > 0 else 0\n",
    "        data['Cash'].append(cash_proportion)\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "def add_asset_traces(fig, dates, data, portfolio_data, sort_by):\n",
    "    if sort_by == 'date':\n",
    "        sorted_stocks = sort_by_add_date(portfolio_data, data.keys())\n",
    "    else:  # sort_by == 'percentage'\n",
    "        sorted_stocks = sort_by_percentage(data)\n",
    "\n",
    "    # Remove Cash from sorted_stocks if it's there\n",
    "    sorted_stocks = [stock for stock in sorted_stocks if stock != 'Cash']\n",
    "\n",
    "    # Add traces in reverse order, with Cash always at the end (top of the stack)\n",
    "    for stock in reversed(sorted_stocks):\n",
    "        add_trace(fig, dates, data, stock)\n",
    "\n",
    "    # Always add Cash last (it will appear at the top)\n",
    "    add_trace(fig, dates, data, 'Cash', '#FFD700')\n",
    "\n",
    "\n",
    "def sort_by_add_date(portfolio_data, stocks):\n",
    "    first_appearance = {}\n",
    "    for date in sorted(portfolio_data.keys()):\n",
    "        for stock in stocks:\n",
    "            if stock not in first_appearance and stock != 'Cash':\n",
    "                if stock in portfolio_data[date]['holdings']:\n",
    "                    first_appearance[stock] = date\n",
    "    return sorted(first_appearance, key=first_appearance.get)\n",
    "\n",
    "\n",
    "def sort_by_percentage(data):\n",
    "    latest_percentages = {stock: values[-1]\n",
    "                          for stock, values in data.items() if stock != 'Cash'}\n",
    "    return sorted(latest_percentages, key=latest_percentages.get, reverse=True)\n",
    "\n",
    "\n",
    "def add_trace(fig, dates, data, stock, color=None):\n",
    "    proportions = data[stock]\n",
    "    hover_text = [f\"{stock}: {proportion:.2f}%\" if not math.isnan(proportion)\n",
    "                  else f\"{stock}: N/A\" for proportion in proportions]\n",
    "\n",
    "    fig.add_trace(go.Scatter(\n",
    "        x=dates,\n",
    "        y=proportions,\n",
    "        mode='lines',\n",
    "        stackgroup='one',\n",
    "        name=stock,\n",
    "        hoverinfo='text',\n",
    "        text=hover_text,\n",
    "        line=dict(color=color) if color else dict(),\n",
    "    ))\n",
    "\n",
    "\n",
    "def update_layout(fig, sort_by, latest_date):\n",
    "    title = 'Asset Allocation Over Time (Sorted by {}) as of {}'.format(\n",
    "        'Latest Percentage' if sort_by == 'percentage' else 'Add Date',\n",
    "        latest_date\n",
    "    )\n",
    "    fig.update_layout(\n",
    "        title=title,\n",
    "        xaxis_title='Date',\n",
    "        yaxis=dict(\n",
    "            title='Proportion',\n",
    "            tickformat='.0%',\n",
    "            range=[0, 100],\n",
    "            tickvals=[0, 20, 40, 60, 80, 100],\n",
    "            ticktext=['0%', '20%', '40%', '60%', '80%', '100%']\n",
    "        ),\n",
    "        legend_title='Assets',\n",
    "        hovermode='x unified'\n",
    "    )\n",
    "\n",
    "\n",
    "# Usage examples:\n",
    "# Default (latest date)\n",
    "plot_asset_allocation_over_time(portfolio_data)\n",
    "\n",
    "# Specific date\n",
    "# fig = plot_asset_allocation_over_time(portfolio_data, end_date=\"2024-03-15\")\n",
    "# fig.show()\n",
    "\n",
    "# Sort by add date\n",
    "# fig = plot_asset_allocation_over_time(portfolio_data, sort_by='date')\n",
    "# fig.show()\n",
    "\n",
    "# Specific date and sort by add date\n",
    "# fig = plot_asset_allocation_over_time(portfolio_data, sort_by='date', end_date=\"2024-03-15\")\n",
    "# fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_html_report(report_date=None):\n",
    "    dates = sorted(portfolio_data.keys())\n",
    "    \n",
    "    report_date = NOTEBOOK_DATE or report_date or max(portfolio_data.keys())\n",
    "    if report_date is None:\n",
    "        report_date = dates[-1]  # Use the latest date by default\n",
    "    else:\n",
    "        report_date = str(report_date)  # Ensure the date is a string\n",
    "        if report_date not in dates:\n",
    "            raise ValueError(f\"No data available for date: {report_date}\")\n",
    "\n",
    "    stock_proportions_plot = plot_stock_proportions(\n",
    "        portfolio_data, report_date)\n",
    "    sector_proportions_plot = plot_sector_proportions(\n",
    "        portfolio_data, sectors, report_date)\n",
    "    portfolio_growth_plot = plot_portfolio_growth(\n",
    "        portfolio_data, end_date=report_date)\n",
    "    asset_allocation_over_time_plot = plot_asset_allocation_over_time(\n",
    "        portfolio_data, end_date=report_date)\n",
    "\n",
    "    for plot in [stock_proportions_plot, sector_proportions_plot, portfolio_growth_plot, asset_allocation_over_time_plot]:\n",
    "        plot.update_layout(font=dict(family=\"monospace\", weight='bold'))\n",
    "\n",
    "    report_data = portfolio_data[report_date]\n",
    "    summary = report_data['summary']\n",
    "    holdings = report_data['holdings']\n",
    "    closed_positions = report_data['closed_positions']\n",
    "    partially_sold_positions = report_data['partially_sold_positions']\n",
    "\n",
    "    # Function to safely convert string to float\n",
    "    def safe_float(value):\n",
    "        try:\n",
    "            return float(value)\n",
    "        except (ValueError, TypeError):\n",
    "            return 0.0\n",
    "\n",
    "    # Function to format currency values\n",
    "    def format_currency(value):\n",
    "        return f\"${safe_float(value):,.2f}\"\n",
    "\n",
    "    # Function to format percentage values\n",
    "    def format_percentage(value):\n",
    "        return f\"{safe_float(value) * 100:.2f}%\"\n",
    "\n",
    "    # Function to combine PNL and return\n",
    "    def combine_pnl_return(pnl, ret):\n",
    "        return f\"{format_currency(pnl)} ({format_percentage(ret)})\"\n",
    "\n",
    "    # Process holdings\n",
    "    holdings_df = pd.DataFrame(holdings).T.reset_index()\n",
    "    holdings_df.columns = ['Symbol', 'Quantity', 'Cost Basis', 'Avg Cost', 'Market Price',\n",
    "                           'Market Value', 'Profit/Loss', 'Return', 'Daily Change', 'Daily Return']\n",
    "\n",
    "    # Apply formatting to numeric columns\n",
    "    for col in ['Quantity', 'Cost Basis', 'Avg Cost', 'Market Price', 'Market Value']:\n",
    "        holdings_df[col] = holdings_df[col].apply(lambda x: f\"{safe_float(x):.2f}\")\n",
    "\n",
    "    holdings_df['Profit/Loss'] = holdings_df.apply(\n",
    "        lambda row: combine_pnl_return(row['Profit/Loss'], row['Return']), axis=1)\n",
    "    holdings_df['Daily Change'] = holdings_df.apply(\n",
    "        lambda row: combine_pnl_return(row['Daily Change'], row['Daily Return']), axis=1)\n",
    "    holdings_df = holdings_df.drop(columns=['Return', 'Daily Return'])\n",
    "\n",
    "    # Process closed positions\n",
    "    closed_positions_df = pd.DataFrame(closed_positions).T.reset_index()\n",
    "    closed_positions_df.columns = [\n",
    "        'Symbol', 'Close Date', 'Quantity', 'Cost Basis', 'Profit/Loss', 'Return']\n",
    "\n",
    "    # Apply formatting to numeric columns\n",
    "    for col in ['Quantity', 'Cost Basis']:\n",
    "        closed_positions_df[col] = closed_positions_df[col].apply(lambda x: f\"{safe_float(x):.2f}\")\n",
    "\n",
    "    closed_positions_df['Profit/Loss'] = closed_positions_df.apply(\n",
    "        lambda row: combine_pnl_return(row['Profit/Loss'], row['Return']), axis=1)\n",
    "    closed_positions_df = closed_positions_df.drop(columns=['Return'])\n",
    "\n",
    "    # Process partially sold positions\n",
    "    partially_sold_positions_df = pd.DataFrame(partially_sold_positions).T.reset_index()\n",
    "    partially_sold_positions_df.columns = [\n",
    "        'Symbol', 'Last Sell Date', 'Quantity', 'Cost Basis', 'Profit/Loss', 'Return']\n",
    "\n",
    "    # Apply formatting to numeric columns\n",
    "    for col in ['Quantity', 'Cost Basis']:\n",
    "        partially_sold_positions_df[col] = partially_sold_positions_df[col].apply(lambda x: f\"{safe_float(x):.2f}\")\n",
    "\n",
    "    partially_sold_positions_df['Profit/Loss'] = partially_sold_positions_df.apply(\n",
    "        lambda row: combine_pnl_return(row['Profit/Loss'], row['Return']), axis=1)\n",
    "    partially_sold_positions_df = partially_sold_positions_df.drop(columns=['Return'])\n",
    "\n",
    "    # Format date columns\n",
    "    date_columns = ['Close Date', 'Last Sell Date']\n",
    "    for df in [closed_positions_df, partially_sold_positions_df]:\n",
    "        for col in date_columns:\n",
    "            if col in df.columns:\n",
    "                df[col] = pd.to_datetime(df[col]).dt.strftime('%Y-%m-%d')\n",
    "\n",
    "    portfolio_table = holdings_df.to_html(index=False, classes='dataframe')\n",
    "    closed_positions_table = closed_positions_df.to_html(index=False, classes='dataframe')\n",
    "    partially_sold_positions_table = partially_sold_positions_df.to_html(index=False, classes='dataframe')\n",
    "\n",
    "    total_pnl = float(summary['total_value']) - \\\n",
    "            float(summary['total_deposits'])\n",
    "    total_return = total_pnl / float(summary['total_deposits'])\n",
    "\n",
    "    format_dict = {\n",
    "        'date': report_date,\n",
    "        'portfolio_table': portfolio_table,\n",
    "        'portfolio_growth_plot': to_html(portfolio_growth_plot, full_html=False, include_plotlyjs=False, config={'responsive': True}),\n",
    "        'stock_proportions_plot': to_html(stock_proportions_plot, full_html=False, include_plotlyjs=False, config={'responsive': True}),\n",
    "        'sector_proportions_plot': to_html(sector_proportions_plot, full_html=False, include_plotlyjs=False, config={'responsive': True}),\n",
    "        'asset_allocation_over_time_plot': to_html(asset_allocation_over_time_plot, full_html=False, include_plotlyjs=False, config={'responsive': True}),\n",
    "        'date_options': ' '.join(f'<option value=\"{date}\">{date}</option>' for date in dates),\n",
    "        'cash': format_currency(summary['cash']),\n",
    "        'total_value': format_currency(summary['total_value']),\n",
    "        'total_market_value': format_currency(summary['total_market_value']),\n",
    "        'total_pnl': combine_pnl_return(total_pnl, total_return),\n",
    "        'unrealized_pnl': combine_pnl_return(summary['total_unrealized_pnl'], summary['total_unrealized_return']),\n",
    "        'daily_change': combine_pnl_return(summary['total_daily_change'], summary['total_daily_return']),\n",
    "        'total_realized_pnl': combine_pnl_return(summary['total_realized_pnl'], summary['total_realized_return']),\n",
    "        'total_deposits': format_currency(summary['total_deposits']),\n",
    "        'closed_positions_table': closed_positions_table,\n",
    "        'partially_sold_positions_table': partially_sold_positions_table,\n",
    "    }\n",
    "\n",
    "    template_path = 'reports/templates/portfolio_report_template.html'\n",
    "    with open(template_path, 'r') as template_file:\n",
    "        html_template = template_file.read()\n",
    "\n",
    "    css_path = 'reports/templates/portfolio_report_styles.css'\n",
    "    with open(css_path, 'r') as css_file:\n",
    "        css_content = css_file.read()\n",
    "\n",
    "    css_content_escaped = css_content.replace('{', '{{').replace('}', '}}')\n",
    "    html_template = html_template.replace('/* CSS_PLACEHOLDER */', css_content_escaped)\n",
    "    html_template = re.sub(r'\\{\\s*(\\w+)\\s*\\}', r'{\\1}', html_template)\n",
    "    html_content = html_template.format(**format_dict)\n",
    "\n",
    "    os.makedirs('reports', exist_ok=True)\n",
    "    \n",
    "    if report_date == max(portfolio_data.keys()):\n",
    "        filename = f'portfolio_report_latest.html'\n",
    "    else:\n",
    "        filename = f'portfolio_report_{report_date}.html'\n",
    "    with open(os.path.join('reports', filename), 'w') as f:\n",
    "        f.write(html_content)\n",
    "\n",
    "    print(f\"HTML report generated: reports/{filename}\")\n",
    "\n",
    "# Usage examples:\n",
    "# Generate report for the latest date\n",
    "generate_html_report()\n",
    "\n",
    "# Generate report for a specific date\n",
    "# generate_html_report(\"2024-03-15\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}