{"behavior":"degenerate_repetition","label_filter":null,"limit":10,"next_offset":37,"offset":27,"previous_offset":null,"rows":[{"assistant_initiates":false,"asst_text":"Khi thi\u1ebft l\u1eadp tr\u01b0\u1edbc khi xu\u1ea5t b\u1ea3n, th\u00f4ng tin n\u00e0o sau \u0111\u00e2y kh\u00f4ng c\u1ea7n thi\u1ebft ph\u1ea3i hi\u1ec3n th\u1ecb?","behavior":"degenerate_repetition","conversation_hash":"567d098cc017a17a15fea428c32194d6","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Vietnamese","model":"gpt-4o-2024-08-06","n_chars":233,"n_turns_in_conversation":1,"n_words":49,"source_row_offset":27,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:52 GMT","turn_id":"0144cf20df9e39e337afd689","turn_index":0,"user_text":"Ch\u1ec9 s\u1eeda l\u1ea1i \u0111\u1ecbnh d\u1ea1ng c\u00e2u h\u1ecfi v\u00e0 kh\u00f4ng b\u1ed5 sung g\u00ec th\u00eam\n\n    Khi thi\u1ebft l\u1eadp tr\u01b0\u1edbc khi xu\u1ea5t b\u1ea3n, th\u00f4ng tin n\u00e0o sau \u0111\u00e2y kh\u00f4ng c\u1ea7n thi\u1ebft ph\u1ea3i hi\u1ec3n th\u1ecb?"},{"assistant_initiates":false,"asst_text":"Certainly! To allow editing the benchmark symbol when modifying an existing portfolio, you'll need to update the section of your code that handles the **Edit Portfolio** functionality. Specifically, you'll add the benchmark selection inputs to the edit form, similar to how it's done when creating a new portfolio.\n\n### **1. Update the Edit Portfolio Form**\n\n**Locate the Section Handling Portfolio Editing:**\n\nFind the part of your code within the `Configure Portfolio` step where it checks if a portfolio is being edited:\n\n```python\nif st.session_state.edit_portfolio:\n    # Existing code for editing portfolio\n```\n\n**Replace This Section with the Updated Code Below:**\n\nThis updated code includes the benchmark selection inputs, allowing you to edit the benchmark symbol when modifying a portfolio.\n\n```python\nif st.session_state.edit_portfolio:\n    # Fetch the portfolio to be edited\n    portfolio_to_edit = next((p for p in st.session_state.portfolios if p['name'] == st.session_state.edit_portfolio), None)\n    if portfolio_to_edit:\n        # Pre-populate the form with existing data\n        name = st.text_input(\"\ud83d\udcdb Portfolio Name\", value=portfolio_to_edit['name'], help=\"Enter a unique name for your portfolio.\")\n        start_date_input, end_date_input = st.columns(2)\n        with start_date_input:\n            start_date_input = st.date_input(\n                \"\ud83d\udcc5 Start Date:\",\n                value=portfolio_to_edit['start_date'],\n                min_value=datetime(1900, 1, 1),\n                help=\"Choose the start date for backtesting.\"\n            )\n        with end_date_input:\n            end_date_input = st.date_input(\n                \"\ud83d\udcc5 End Date:\",\n                value=portfolio_to_edit['end_date'],\n                min_value=datetime(1900, 1, 1),\n                help=\"Choose the end date for backtesting.\"\n            )\n        rf_rate = st.number_input(\n            \"\ud83d\udcc8 Risk-Free Rate (%)\",\n            min_value=0.0,\n            max_value=10.0,\n            value=portfolio_to_edit['rf_rate'] * 100,\n            format=\"%.2f\",\n            help=\"Enter the risk-free rate as a percentage.\"\n        ) / 100\n        broker_fee = st.number_input(\n            \"\ud83d\udcb8 Broker Fee (%)\",\n            min_value=0.0,\n            max_value=10.0,\n            value=portfolio_to_edit['broker_fee'] * 100,\n            step=0.0001,\n            format=\"%.4f\",\n            help=\"Enter the broker fee as a percentage per transaction.\"\n        ) / 100\n        \n        st.markdown(\"#### \ud83d\udce6 Asset Allocation\")  \n        selected_assets_new = st.multiselect(\n            \"\ud83d\uddc2\ufe0f Select Assets:\",\n            options=asset_options,\n            default=[format_asset_option(ticker, tickers[tickers['Ticker'] == ticker]['Company Name'].values[0]) for ticker in portfolio_to_edit['selected']],\n            help=\"Choose the assets you want to include in your portfolio.\"\n        )\n        \n        selected_tickers_new = [option.split(' - ')[0] for option in selected_assets_new if ' - ' in option]\n        \n        if selected_tickers_new:\n            # Create a DataFrame for allocations\n            allocation_df = pd.DataFrame({\n                'Ticker': selected_tickers_new,\n                'Allocation (%)': [0.0] * len(selected_tickers_new)\n            })\n            \n            st.markdown(\"**Set Allocation Percentages:**\")\n            for idx, ticker in enumerate(selected_tickers_new):\n                allocation_df.at[idx, 'Allocation (%)'] = st.number_input(\n                    f\"\ud83d\udcca {ticker} Allocation (%)\",\n                    min_value=0.0,\n                    max_value=100.0,\n                    value=portfolio_to_edit['allocations'][portfolio_to_edit['selected'].index(ticker)] if ticker in portfolio_to_edit['selected'] else 0.0,\n                    step=0.1,\n                    format=\"%.2f\",\n                    key=f\"alloc_edit_{ticker}\",\n                    help=f\"Set the allocation percentage for {ticker}. The sum of all allocations must equal 100%.\"\n                )\n            \n            total_allocation_new = allocation_df['Allocation (%)'].sum()\n            st.markdown(f\"**\ud83e\uddee Total Allocation:** {total_allocation_new:.2f}%\")\n            \n            if not np.isclose(total_allocation_new, 100.0, atol=1e-2):\n                st.warning(\"\u26a0\ufe0f Allocations must sum to 100%. Please adjust the allocations.\")\n            \n            # Display Allocation Table\n            st.table(allocation_df)\n        else:\n            st.info(\"\ud83e\uddd0 Select assets to allocate your portfolio.\")\n        \n        st.markdown(\"#### \ud83c\udfe6 Benchmark Selection\")\n        benchmark_options = get_common_benchmarks(selected_tickers_new)\n        selected_benchmark = st.selectbox(\n            \"\ud83c\udfe6 Select Benchmark\",\n            options=list(benchmark_options.keys()),\n            index=list(benchmark_options.keys()).index(\"S&P 500\") if \"S&P 500\" in benchmark_options else 0,\n            key=\"edit_benchmark_select\",\n            help=\"Choose a benchmark that aligns with your portfolio's asset composition.\"\n        )\n        \n        if selected_benchmark == \"Custom\":\n            custom_benchmark = st.text_input(\n                \"\u270f\ufe0f Enter Custom Benchmark Symbol\",\n                placeholder=\"e.g., ^DJI, ^IXIC\",\n                value=portfolio_to_edit['benchmark_symbol'] if selected_benchmark == \"Custom\" else \"\",\n                help=\"Specify a custom benchmark symbol (e.g., ^DJI for Dow Jones Industrial Average).\"\n            )\n            benchmark_symbol = custom_benchmark if custom_benchmark else \"^GSPC\"  # Default to S&P 500 if empty\n        else:\n            benchmark_symbol = benchmark_options.get(selected_benchmark, '^GSPC')\n        \n        # Display the chosen benchmark symbol for confirmation\n        st.write(f\"**Selected Benchmark Symbol:** {benchmark_symbol}\")\n        \n        st.markdown(\"#### \ud83d\udd04 Rebalance Frequency\")\n        rebalance_freq = st.selectbox(\n            \"\ud83d\udd04 Rebalance Frequency\",\n            options=list(frequency_mapping.keys()),\n            index=list(frequency_mapping.keys()).index(\n                rebalance_freq_inverse_mapping.get(portfolio_to_edit['rebalance_freq'], 'Monthly')\n            ) if rebalance_freq_inverse_mapping.get(portfolio_to_edit['rebalance_freq'], 'Monthly') in frequency_mapping else 0,\n            help=\"Choose how often the portfolio should be rebalanced.\"\n        )\n        \n        # Submit Button\n        submit_button_label = \"\u2705 Update Portfolio\"\n        if st.button(submit_button_label):\n            # Validation\n            if not name:\n                st.error(\"\u274c Please provide a portfolio name.\")\n            elif not selected_assets_new:\n                st.error(\"\u274c Please select at least one asset.\")\n            elif selected_benchmark == \"Custom\" and not benchmark_symbol:\n                st.error(\"\u274c Please enter a custom benchmark symbol.\")\n            elif not np.isclose(total_allocation_new, 100.0, atol=1e-2):\n                st.error(f\"\u274c Allocations must sum to 100%. Currently sum to {total_allocation_new:.2f}%.\")\n            else:\n                allocations = allocation_df['Allocation (%)'].tolist()\n                \n                updated_portfolio = {\n                    'name': name,\n                    'start_date': pd.to_datetime(start_date_input),\n                    'end_date': pd.to_datetime(end_date_input),\n                    'rf_rate': rf_rate,\n                    'broker_fee': broker_fee,\n                    'benchmark_symbol': benchmark_symbol,\n                    'rebalance_freq': frequency_mapping.get(rebalance_freq, 'M'),\n                    'selected': selected_tickers_new,\n                    'allocations': allocations\n                }\n                \n                # Update existing portfolio\n                for idx, p in enumerate(st.session_state.portfolios):\n                    if p['name'] == st.session_state.edit_portfolio:\n                        st.session_state.portfolios[idx] = updated_portfolio\n                        break\n                st.success(f\"\ud83c\udf89 Portfolio '{name}' updated successfully!\")\n                st.session_state.edit_portfolio = None  # Reset edit mode\n                st.balloons()\n                st.rerun()\n    ```\n\n### **2. Explanation of the Changes**\n\n- **Benchmark Selection Added:**  \n  The updated code introduces a **Benchmark Selection** section within the edit form. This allows you to choose an existing benchmark from predefined options or enter a custom benchmark symbol.\n\n- **Pre-Populated Benchmark Values:**  \n  When editing, the benchmark selection will default to the portfolio's existing benchmark. If it's a custom benchmark, the custom symbol will be pre-filled in the text input.\n\n- **Validation Included:**  \n  The submission button now checks for valid benchmark inputs, ensuring that if \"Custom\" is selected, a custom symbol is provided.\n\n- **Rebalance Frequency Pre-Selection:**  \n  The rebalance frequency dropdown also pre-selects the current setting of the portfolio being edited.\n\n### **3. Ensure Benchmark is Updated Properly**\n\nMake sure that when the form is submitted, the `benchmark_symbol` in the `updated_portfolio` dictionary is correctly captured and saved. The updated code above handles this by assigning the selected or custom benchmark symbol to `'benchmark_symbol'`.\n\n### **4. Test the Changes**\n\nAfter updating the code:\n\n1. **Run the Streamlit App:**\n   ```bash\n   streamlit run portfolio_optimizer.py\n   ```\n\n2. **Edit an Existing Portfolio:**\n   - Navigate to the **Configure Portfolio** step.\n   - Select a portfolio to edit.\n   - You should now see the **Benchmark Selection** section where you can change the benchmark symbol.\n\n3. **Save Changes:**\n   - Adjust the benchmark as desired.\n   - Ensure allocations sum to 100%.\n   - Click **Update Portfolio** and verify that changes are saved correctly.\n\n### **5. Additional Tips**\n\n- **Unique Portfolio Names:** Ensure that when editing, the new portfolio name (if changed) remains unique to prevent conflicts.\n\n- **Benchmark Options:** Customize the `get_common_benchmarks` function if you want to include more benchmark options based on your asset selections.\n\n- **User Feedback:** The updated form provides real-time feedback on allocations and benchmark selections to guide users effectively.\n\nI hope this helps you enhance your Portfolio Optimizer app! If you have any more questions or need further assistance, feel free to ask.","behavior":"degenerate_repetition","conversation_hash":"305b9f481bd4a50f647487defa60e687","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"English","model":"o1-mini-2024-09-12","n_chars":186013,"n_turns_in_conversation":1,"n_words":14596,"source_row_offset":28,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:52 GMT","turn_id":"18b47f1b2e16481063bbf80c","turn_index":0,"user_text":"%%writefile portfolio_optimizer.py\nimport streamlit as st\nimport pandas as pd\nimport plotly.graph_objects as go\nimport numpy as np\nimport yfinance as yf\nimport statsmodels.api as sm\nimport datetime\nfrom datetime import datetime, timedelta\nfrom pandas_datareader import data as pdr\nimport plotly.express as px\nimport warnings, json, requests, copy\nfrom requests.adapters import HTTPAdapter\nfrom urllib3.util.retry import Retry\nfrom scipy.stats import skew, kurtosis, norm\nfrom joblib import Parallel, delayed\nfrom sklearn.linear_model import LinearRegression\nfrom statsmodels.stats.stattools import durbin_watson\nfrom functools import lru_cache, wraps\nfrom concurrent.futures import ProcessPoolExecutor\nfrom scipy.optimize import minimize\nfrom requests.packages.urllib3.exceptions import InsecureRequestWarning\n\nwarnings.filterwarnings('ignore')\n\n# ----------------------------\n# Frequency Mapping\n# ----------------------------\nfrequency_mapping = {\n    \"Daily\": \"D\",\n    \"Weekly\": \"W\",\n    \"Monthly\": \"M\",\n    \"Quarterly\": \"Q\",\n    \"Yearly\": \"Y\"\n}\n\n# Inverse mapping to get frequency name from code\nrebalance_freq_inverse_mapping = {v: k for k, v in frequency_mapping.items()}\n\nexample_portfolios = [\n                    {\n                        'name': \"Retirement Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*10)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^GSPC',\n                        'rebalance_freq': 'M',\n                        'selected': ['AAPL', 'MSFT', 'GOOGL', 'JPM', 'XOM'],\n                        'allocations': [20.0, 20.0, 20.0, 20.0, 20.0]\n                    },\n                    {\n                        'name': \"Tech-Heavy Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*5)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^IXIC',\n                        'rebalance_freq': 'M',\n                        'selected': ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'META'],\n                        'allocations': [25.0, 25.0, 20.0, 15.0, 15.0]\n                    },\n                    {\n                        'name': \"Balanced Risk-Return Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*7)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^GSPC',\n                        'rebalance_freq': 'M',\n                        'selected': ['AAPL', 'JNJ', 'V', 'PG', 'XOM'],\n                        'allocations': [20.0, 20.0, 20.0, 20.0, 20.0]\n                    },\n                    {\n                        'name': \"Income-Focused Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*7)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^DJI',\n                        'rebalance_freq': 'Q',\n                        'selected': ['PG', 'KO', 'JNJ', 'T', 'PFE'],\n                        'allocations': [20.0, 20.0, 20.0, 20.0, 20.0]\n                    },\n                    {\n                        'name': \"Growth-Oriented Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*3)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^IXIC',\n                        'rebalance_freq': 'M',\n                        'selected': ['TSLA', 'NVDA', 'AMD', 'META', 'NFLX'],\n                        'allocations': [30.0, 20.0, 20.0, 15.0, 15.0]\n                    },\n                    {\n                        'name': \"Value Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*10)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^DJI',\n                        'rebalance_freq': 'Q',\n                        'selected': ['KO', 'PFE', 'XOM', 'WMT', 'CVX'],\n                        'allocations': [20.0, 20.0, 20.0, 20.0, 20.0]\n                    },\n                    {\n                        'name': \"Dividend-Focused Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*7)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': 'DVY',  # Dividend Index\n                        'rebalance_freq': 'Q',\n                        'selected': ['T', 'VZ', 'PFE', 'KO', 'IBM'],\n                        'allocations': [20.0, 20.0, 20.0, 20.0, 20.0]\n                    },\n                    {\n                        'name': \"Global Diversification Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*5)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': 'ACWI',  # All Country World Index\n                        'rebalance_freq': 'M',\n                        'selected': ['AAPL', 'TSM', 'BABA', 'SAP', 'UL'],\n                        'allocations': [20.0, 20.0, 20.0, 20.0, 20.0]\n                    },\n                    {\n                        'name': \"High-Risk Growth Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*3)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': '^IXIC',\n                        'rebalance_freq': 'M',\n                        'selected': ['TSLA', 'ARKK', 'NVDA', 'SHOP', 'CRWD'],\n                        'allocations': [30.0, 20.0, 20.0, 15.0, 15.0]\n                    },\n                    {\n                        'name': \"Emerging Markets Portfolio\",\n                        'start_date': pd.to_datetime(datetime.today() - timedelta(days=365*5)),\n                        'end_date': pd.to_datetime(datetime.today()),\n                        'rf_rate': 0.02,\n                        'broker_fee': 0.0,\n                        'benchmark_symbol': 'EEM',  # Emerging Markets Index\n                        'rebalance_freq': 'M',\n                        'selected': ['BABA', 'TSM', 'PDD', 'INFY', 'VALE'],\n                        'allocations': [25.0, 25.0, 20.0, 15.0, 15.0]\n                    }\n                ]\n# ----------------------------\n# Global Settings and Configurations\n# ----------------------------\n\n# Suppress only the InsecureRequestWarning, if bypassing SSL\nwarnings.simplefilter('ignore', InsecureRequestWarning)\nrequests.packages.urllib3.disable_warnings()  # Use cautiously\n# ----------------------------\n# Global Theme Configuration\n# ----------------------------\nTHEME = 'plotly_dark'  # Options: 'plotly_dark', 'plotly_white', 'seaborn', etc.\n# ----------------------------\n# Global Plot Layout Configuration\n# ----------------------------\nFIG_HEIGHT = 600\nHOVERMODE = 'x unified'\n\n# Initialize Session State\ndefault_session_state = {\n    'portfolios': [],\n    'backtest_results': {},\n    'step': \"Configure Portfolio\",\n    'edit_portfolio': None,\n    'add_new_portfolio': False,\n    'default_config': {\n        'rf_rate': 0.02,\n        'broker_fee': 0.0,\n        'benchmark_symbol': '^GSPC'\n    }\n}\n\n# Use a single loop to set defaults\nfor key, value in default_session_state.items():\n    if key not in st.session_state:\n        st.session_state[key] = copy.deepcopy(value)\n\n# Initialize example portfolios if not already in session state\nif 'portfolios' not in st.session_state or not st.session_state.portfolios:\n    st.session_state.portfolios = copy.deepcopy(example_portfolios)\n\n# ----------------------------\n# Utility Decorators\n# ----------------------------\n\ndef handle_exceptions(func):\n    \"\"\"\n    Decorator to handle exceptions in Streamlit applications.\n    Displays errors using Streamlit's error message system.\n    \"\"\"\n    @wraps(func)\n    def wrapper(*args, **kwargs):\n        try:\n            return func(*args, **kwargs)\n        except Exception as e:\n            st.error(f\"Error in {func.__name__}: {e}\")\n            return None\n    return wrapper\n\n# ----------------------------\n# Helper Functions\n# ----------------------------\n\n@handle_exceptions\ndef get_company_name(ticker_df: pd.DataFrame, ticker: str) -> str:\n    \"\"\"\n    Retrieve the company name for a given ticker.\n\n    Parameters:\n    - ticker_df (pd.DataFrame): DataFrame containing 'Ticker' and 'Company Name' columns.\n    - ticker (str): Stock ticker symbol.\n\n    Returns:\n    - str: Company name or \"Unknown\" if not found.\n    \"\"\"\n    match = ticker_df[ticker_df['Ticker'] == ticker]\n    if not match.empty:\n        return match.iloc[0]['Company Name']\n    return \"Unknown\"\n\ndef format_asset_option(ticker: str, company_name: str) -> str:\n    \"\"\"\n    Format the asset option display string.\n\n    Parameters:\n    - ticker (str): Stock ticker symbol.\n    - company_name (str): Name of the company.\n\n    Returns:\n    - str: Formatted string combining ticker and company name.\n    \"\"\"\n    return f\"{ticker} - {company_name}\"\n\ndef handle_portfolio_data(portfolio, date_range=None):\n    \"\"\"\n    Helper function to download data and handle missing tickers.\n\n    Parameters:\n    - portfolio (dict): Portfolio details.\n    - date_range (tuple, optional): (start_date, end_date)\n\n    Returns:\n    - available_selected (list): Tickers with available data.\n    - missing_selected (set): Tickers missing data.\n    - price_data (pd.DataFrame): Adjusted close prices.\n    \"\"\"\n    start_date = date_range[0] if date_range else portfolio['start_date']\n    end_date = date_range[1] if date_range else portfolio['end_date']\n    price_data = download_data(portfolio['selected'], start_date, end_date)\n    if price_data.empty:\n        return [], set(portfolio['selected']), price_data\n    available_selected = [ticker for ticker in portfolio['selected'] if ticker in price_data.columns]\n    missing_selected = set(portfolio['selected']) - set(available_selected)\n    if missing_selected:\n        st.warning(f\"Excluded tickers with no data: {', '.join(missing_selected)}\")\n    return available_selected, missing_selected, price_data\n\ndef run_portfolio_comparison(comparison_type, portfolio1, portfolio2=None):\n        \"\"\"\n        Generalized function to run portfolio comparisons.\n\n        Parameters:\n        - comparison_type (str): \"vs_benchmark\" or \"vs_portfolio\"\n        - portfolio1 (dict): Primary portfolio.\n        - portfolio2 (dict, optional): Secondary portfolio for \"vs_portfolio\".\n\n        Returns:\n        - result (dict): Backtest results or error.\n        \"\"\"\n        try:\n            if comparison_type == \"vs_benchmark\":\n                available, missing, price_data = handle_portfolio_data(portfolio1)\n                if not available:\n                    return {\"error\": \"No valid tickers with available data.\"}\n                allocations = adjust_allocations([portfolio1['allocations'][portfolio1['selected'].index(t)] for t in available])\n                returns, cum_returns = backtest(\n                    weights=np.array(allocations) / 100,\n                    prices=price_data[available],\n                    rebalance_freq=portfolio1['rebalance_freq'],\n                    broker_fee=portfolio1['broker_fee']\n                )\n                if cum_returns.empty:\n                    return {\"error\": \"Cumulative returns are empty.\"}\n                # Benchmark processing...\n                benchmark_data = download_data(\n                    [portfolio1['benchmark_symbol']],\n                    portfolio1['start_date'].strftime('%Y-%m-%d'),\n                    portfolio1['end_date'].strftime('%Y-%m-%d')\n                )\n                if benchmark_data.empty:\n                    return {\"error\": \"Benchmark data could not be downloaded.\"}\n                \n                benchmark_returns, benchmark_cum_returns, benchmark_metrics = process_benchmark(benchmark_data, returns, portfolio1)\n                portfolio_metrics = calculate_metrics(returns, cum_returns, portfolio1['rf_rate'], benchmark_returns)\n                \n                # Compile backtest results\n                backtest_results = {\n                    'returns': returns,\n                    'cum_returns': cum_returns,\n                    'weights': allocations,\n                    'price_data': price_data[available],\n                    'metrics': portfolio_metrics,\n                    'benchmark_returns': benchmark_returns,\n                    'benchmark_cum_returns': benchmark_cum_returns,\n                    'benchmark_metrics': benchmark_metrics\n                }\n                \n                # **Added Return Statement**\n                return {\"backtest_results\": backtest_results}\n    \n            elif comparison_type == \"vs_portfolio\":\n                overlap_start = max(portfolio1['start_date'], portfolio2['start_date'])\n                overlap_end = min(portfolio1['end_date'], portfolio2['end_date'])\n                if overlap_start >= overlap_end:\n                    return {\"error\": \"No overlapping date ranges.\"}\n                available_a, missing_a, price_data_a = handle_portfolio_data(portfolio1, (overlap_start, overlap_end))\n                available_b, missing_b, price_data_b = handle_portfolio_data(portfolio2, (overlap_start, overlap_end))\n                if not available_a or not available_b:\n                    return {\"error\": \"One of the portfolios has no valid tickers with available data.\"}\n                allocations_a = adjust_allocations([portfolio1['allocations'][portfolio1['selected'].index(t)] for t in available_a])\n                allocations_b = adjust_allocations([portfolio2['allocations'][portfolio2['selected'].index(t)] for t in available_b])\n                returns_a, cum_returns_a = backtest(\n                    weights=np.array(allocations_a) / 100,\n                    prices=price_data_a[available_a],\n                    rebalance_freq=portfolio1['rebalance_freq'],\n                    broker_fee=portfolio1['broker_fee']\n                )\n                returns_b, cum_returns_b = backtest(\n                    weights=np.array(allocations_b) / 100,\n                    prices=price_data_b[available_b],\n                    rebalance_freq=portfolio2['rebalance_freq'],\n                    broker_fee=portfolio2['broker_fee']\n                )\n                if cum_returns_a.empty or cum_returns_b.empty:\n                    return {\"error\": \"One of the cumulative returns is empty.\"}\n                common_index = cum_returns_a.index.intersection(cum_returns_b.index)\n                if common_index.empty:\n                    return {\"error\": \"No overlapping dates after backtesting.\"}\n                metrics_a = calculate_metrics(returns_a.loc[common_index], cum_returns_a.loc[common_index], portfolio1['rf_rate'])\n                metrics_b = calculate_metrics(returns_b.loc[common_index], cum_returns_b.loc[common_index], portfolio2['rf_rate'])\n                backtest_results = {\n                    'returns_a': returns_a.loc[common_index],\n                    'cum_returns_a': cum_returns_a.loc[common_index],\n                    'weights_a': allocations_a,\n                    'price_data_a': price_data_a[available_a],\n                    'metrics_a': metrics_a,\n                    'returns_b': returns_b.loc[common_index],\n                    'cum_returns_b': cum_returns_b.loc[common_index],\n                    'weights_b': allocations_b,\n                    'price_data_b': price_data_b[available_b],\n                    'metrics_b': metrics_b,\n                    'benchmark_cum_returns': pd.Series(dtype=float)\n                }\n                return {\"backtest_results\": backtest_results}\n        except Exception as e:\n            return {\"error\": f\"An unexpected error occurred: {e}\"}\n\ndef adjust_allocations(allocations):\n    \"\"\"Adjust allocations to sum to 100% if necessary.\"\"\"\n    total = sum(allocations)\n    if not np.isclose(total, 100.0, atol=1e-4):\n        st.warning(\"Allocations do not sum to 100%. Adjusting allocations proportionally.\")\n        allocations = [a / total * 100 for a in allocations]\n    return allocations\n\ndef process_portfolio_allocations(portfolio, price_data):\n    \"\"\"Processes portfolio allocations and handles missing tickers.\"\"\"\n    available = [ticker for ticker in portfolio['selected'] if ticker in price_data.columns]\n    missing = set(portfolio['selected']) - set(available)\n    if missing:\n        st.warning(f\"Excluded tickers from '{portfolio['name']}': {', '.join(missing)}\")\n    if not available:\n        st.error(f\"No valid tickers for portfolio '{portfolio['name']}' in the overlapping period.\")\n        st.stop()\n    allocations = [portfolio['allocations'][i] for i, ticker in enumerate(portfolio['selected']) if ticker in available]\n    allocations = adjust_allocations(allocations)\n    return allocations, available, missing\n\ndef initialize_benchmark_metrics():\n    \"\"\"Initializes benchmark metrics when benchmark data is unavailable.\"\"\"\n    metrics = {metric: \"N/A\" for metric in [\n        'Start Balance', 'End Balance', 'Annualized Return (CAGR)', 'Best Year', 'Worst Year',\n        'Arithmetic Mean (Monthly)', 'Arithmetic Mean (Annualized)', 'Geometric Mean (Monthly)',\n        'Geometric Mean (Annualized)', 'Standard Deviation (Monthly)', 'Standard Deviation (Annualized)',\n        'Downside Deviation (Monthly)', 'Maximum Drawdown', 'Sharpe Ratio', 'Sortino Ratio',\n        'Gain/Loss Ratio', 'Skewness', 'Excess Kurtosis', 'Safe Withdrawal Rate',\n        'Perpetual Withdrawal Rate', 'Positive Periods', 'Benchmark Correlation', 'Beta',\n        'Alpha (annualized)', 'R2', 'Treynor Ratio', 'Calmar Ratio',\n        'Modigliani\u2013Modigliani Measure', 'Information Ratio', 'Tracking Error',\n        'Active Return', 'Upside Capture Ratio', 'Downside Capture Ratio'\n    ]}\n    return None, pd.Series(dtype=float), metrics\n\ndef process_benchmark(benchmark_data, returns, portfolio):\n    \"\"\"Processes benchmark data and calculates benchmark metrics.\"\"\"\n    benchmark_returns = benchmark_data[portfolio['benchmark_symbol']].pct_change().dropna()\n    benchmark_returns = benchmark_returns.reindex(returns.index, method='ffill').dropna()\n    common_index = returns.index.intersection(benchmark_returns.index)\n    if common_index.empty:\n        st.error(\"No overlapping dates between portfolio returns and benchmark returns after alignment.\")\n        st.stop()\n    returns_aligned = returns.loc[common_index]\n    cum_returns_aligned = (1 + benchmark_returns.loc[common_index]).cumprod()\n    benchmark_metrics = calculate_metrics(\n        benchmark_returns, cum_returns_aligned, portfolio['rf_rate'], None\n    )\n    return benchmark_returns, cum_returns_aligned, benchmark_metrics\n\ndef update_session_state(updates: dict):\n    \"\"\"\n    Helper function to update Streamlit session state.\n\n    Parameters:\n    - updates (dict): Dictionary of key-value pairs to update in session state.\n    \"\"\"\n    for key, value in updates.items():\n        st.session_state[key] = value\n\ndef display_backtest_results(results, comparison_type, portfolio1, portfolio2):\n    \"\"\"Displays the backtest results in the Streamlit app.\"\"\"\n    if comparison_type == \"Portfolio vs Benchmark\":\n        display_portfolio_vs_benchmark(results)\n    else:\n        display_portfolio_vs_portfolio(results, portfolio1, portfolio2)\n\ndef display_portfolio_vs_benchmark(results):\n    \"\"\"Displays results for Portfolio vs Benchmark comparison.\"\"\"\n    returns = results['returns']\n    cum_returns = results['cum_returns']\n    weights = results['weights']\n    price_data = results['price_data']\n    metrics = results['metrics']\n    benchmark_metrics = results['benchmark_metrics']\n    benchmark_cum_returns = results['benchmark_cum_returns']\n\n    # Key Metrics\n    st.markdown(\"### \ud83d\udd11 Key Metrics\")\n    key_metrics = {\n        'Annualized Return (CAGR)': metrics.get('Annualized Return (CAGR)', \"N/A\"),\n        'Sharpe Ratio': metrics.get('Sharpe Ratio', \"N/A\"),\n        'Maximum Drawdown': metrics.get('Maximum Drawdown', \"N/A\")\n    }\n    cols = st.columns(len(key_metrics))\n    for col, (metric, value) in zip(cols, key_metrics.items()):\n        col.metric(label=metric, value=value)\n\n    # Tabs for Organized Sections\n    tabs = st.tabs([\"Overview\", \"Performance Statistics\", \"Advanced Metrics\", \"Drawdowns\", \"Visualizations\"])\n\n    with tabs[0]:\n        st.header(\"\ud83d\udcc8 Portfolio Performance Overview\")\n        st.write(f\"**Portfolio Name:** {portfolio1}\")\n        st.write(f\"**Start Date:** {price_data.index.min().strftime('%Y-%m-%d')}\")\n        st.write(f\"**End Date:** {price_data.index.max().strftime('%Y-%m-%d')}\")\n        st.write(f\"**Benchmark:** {results.get('benchmark_symbol', 'N/A')}\")\n\n    with tabs[1]:\n        st.header(\"\ud83d\udcca Performance Statistics\")\n        st.subheader(\"\ud83d\udee0\ufe0f Basic Metrics\")\n        performance_df_stats = create_performance_stats_df(metrics, benchmark_metrics)\n        st.table(performance_df_stats)\n\n    with tabs[2]:\n        st.header(\"\ud83d\udccb Detail Comparisons\")\n        st.subheader(\"\ud83e\uddee Advanced Metrics\")\n        performance_df_advanced = create_advanced_metrics_df(metrics, benchmark_metrics)\n        st.table(performance_df_advanced)\n        # Add Explanation for \"N/A\" Metrics\n        st.write(\"\"\"\n        **\u2139\ufe0f Note:** Metrics marked as \"N/A\" indicate that they are specific to the portfolio and are not applicable to the benchmark. \n        This is because these metrics require individual portfolio analysis and do not apply to benchmark-only data.\n        \"\"\")\n        st.subheader(\"\ud83d\udd0d Risk Factor Attribution Analysis\")\n        perform_risk_factor_attribution(returns)\n\n    with tabs[3]:\n        st.header(\"\ud83d\udcc9 Detailed Drawdowns\")\n        display_drawdowns(cum_returns, benchmark_cum_returns)\n\n    with tabs[4]:\n        st.header(\"\ud83d\udcca Visualizations\")\n        display_visualizations(cum_returns, benchmark_cum_returns, returns, price_data, weights, metrics, benchmark_metrics)\n\n    update_session_state({\n        'backtest_results': results,\n        'show_proceed': True \n    })\n    st.success(\"Backtest completed!\")\n\ndef display_portfolio_vs_portfolio(results, portfolio1, portfolio2):\n    \"\"\"Displays results for Portfolio vs Portfolio comparison.\"\"\"\n    returns_a = results['returns_a']\n    cum_returns_a = results['cum_returns_a']\n    weights_a = results['weights_a']\n    price_data_a = results['price_data_a']\n    metrics_a = results['metrics_a']\n\n    returns_b = results['returns_b']\n    cum_returns_b = results['cum_returns_b']\n    weights_b = results['weights_b']\n    price_data_b = results['price_data_b']\n    metrics_b = results['metrics_b']\n\n    # Key Metrics with Additional Metrics\n    st.markdown(\"### \ud83d\udd11 Key Metrics\")\n    key_metrics = {\n        'Metric': [\n            'Annualized Return (CAGR)', \n            'Sharpe Ratio', \n            'Maximum Drawdown',\n            'Benchmark Correlation',\n            'Beta'\n        ],\n        portfolio1: [\n            metrics_a.get('Annualized Return (CAGR)', \"N/A\"),\n            metrics_a.get('Sharpe Ratio', \"N/A\"),\n            metrics_a.get('Maximum Drawdown', \"N/A\"),\n            metrics_a.get('Benchmark Correlation', \"N/A\"),\n            metrics_a.get('Beta', \"N/A\")\n        ],\n        portfolio2: [\n            metrics_b.get('Annualized Return (CAGR)', \"N/A\"),\n            metrics_b.get('Sharpe Ratio', \"N/A\"),\n            metrics_b.get('Maximum Drawdown', \"N/A\"),\n            metrics_b.get('Benchmark Correlation', \"N/A\"),\n            metrics_b.get('Beta', \"N/A\")\n        ]\n    }\n    metrics_df = pd.DataFrame(key_metrics)\n    metrics_df.set_index('Metric', inplace=True)\n    st.table(metrics_df)\n\n    # Tabs for Organized Sections with Enhanced Content\n    tabs = st.tabs([\"Overview\", \"Performance Statistics\", \"Advanced Metrics\", \"Drawdowns\", \"Visualizations\"])\n\n    with tabs[0]:\n        st.header(\"\ud83d\udcc8 Portfolio Performance Overview\")\n        st.write(f\"**Portfolio A Name:** {portfolio1}\")\n        st.write(f\"**Portfolio B Name:** {portfolio2}\")\n        st.write(f\"**Start Date:** {min(returns_a.index.min(), returns_b.index.min()).strftime('%Y-%m-%d')}\")\n        st.write(f\"**End Date:** {max(returns_a.index.max(), returns_b.index.max()).strftime('%Y-%m-%d')}\")\n        st.write(f\"**Benchmark Correlation:** {metrics_a.get('Benchmark Correlation', 'N/A')}\")\n        st.write(f\"**Beta of {portfolio1} relative to {portfolio2}:** {metrics_a.get('Beta', 'N/A')}\")\n\n    with tabs[1]:\n        st.header(\"\ud83d\udcca Performance Statistics\")\n        st.subheader(\"\ud83d\udee0\ufe0f Basic Metrics\")\n        performance_df_stats = create_performance_stats_df_portfolio_vs_portfolio(metrics_a, metrics_b, portfolio1, portfolio2)\n        st.table(performance_df_stats)\n\n    with tabs[2]:\n        st.header(\"\ud83d\udcc9 Advanced Metrics\")\n        performance_df_advanced = create_advanced_metrics_df_portfolio_vs_portfolio(metrics_a, metrics_b, portfolio1, portfolio2)\n        st.table(performance_df_advanced)\n        # Add Explanation for \"N/A\" Metrics\n        st.write(\"\"\"\n        **\u2139\ufe0f Note:** Metrics marked as \"N/A\" indicate that certain data was unavailable or not applicable \n        during the comparison between the two portfolios. Ensure both portfolios have sufficient data \n        to calculate all metrics.\n        \"\"\")\n\n    with tabs[3]:\n        st.header(\"\ud83d\udcc9 Drawdowns\")\n        st.markdown(\"### \ud83d\udcc9 Detailed Drawdowns for Both Portfolios\")\n        st.markdown(f\"#### \ud83d\udcc9 Drawdowns for {portfolio1}\")\n        drawdowns_a = get_drawdown_details(cum_returns_a)\n        if drawdowns_a:\n            st.table(pd.DataFrame(drawdowns_a))\n        else:\n            st.write(\"No drawdowns detected for this portfolio.\")\n\n        st.markdown(f\"#### \ud83d\udcc9 Drawdowns for {portfolio2}\")\n        drawdowns_b = get_drawdown_details(cum_returns_b)\n        if drawdowns_b:\n            st.table(pd.DataFrame(drawdowns_b))\n        else:\n            st.write(\"No drawdowns detected for this portfolio.\")\n\n    with tabs[4]:\n        st.header(\"\ud83d\udcca Visualizations\")\n        display_visualizations_portfolio_vs_portfolio(\n        cum_returns_a, cum_returns_b, returns_a, returns_b,\n        price_data_a, price_data_b, weights_a, weights_b,\n        portfolio1, portfolio2, metrics_a, metrics_b\n    )\n\n    # Store results\n    update_session_state({\n        'backtest_results': results,\n        'show_proceed': True\n    })\n    st.success(\"Backtest completed!\")\n\ndef create_performance_stats_df(metrics, benchmark_metrics):\n    \"\"\"Creates a DataFrame for performance statistics.\"\"\"\n    return pd.DataFrame({\n        'Metric': [\n            'Start Balance', 'End Balance', 'Annualized Return (CAGR)',\n            'Standard Deviation (Annualized)', 'Best Year', 'Worst Year',\n            'Maximum Drawdown', 'Sharpe Ratio', 'Sortino Ratio', 'Benchmark Correlation'\n        ],\n        'Portfolio': [\n            metrics.get('Start Balance', \"N/A\"),\n            metrics.get('End Balance', \"N/A\"),\n            metrics.get('Annualized Return (CAGR)', \"N/A\"),\n            metrics.get('Standard Deviation (Annualized)', \"N/A\"),\n            metrics.get('Best Year', \"N/A\"),\n            metrics.get('Worst Year', \"N/A\"),\n            metrics.get('Maximum Drawdown', \"N/A\"),\n            metrics.get('Sharpe Ratio', \"N/A\"),\n            metrics.get('Sortino Ratio', \"N/A\"),\n            metrics.get('Benchmark Correlation', \"N/A\")\n        ],\n        'Benchmark': [\n            benchmark_metrics.get('Start Balance', \"N/A\"),\n            benchmark_metrics.get('End Balance', \"N/A\"),\n            benchmark_metrics.get('Annualized Return (CAGR)', \"N/A\"),\n            benchmark_metrics.get('Standard Deviation (Annualized)', \"N/A\"),\n            benchmark_metrics.get('Best Year', \"N/A\"),\n            benchmark_metrics.get('Worst Year', \"N/A\"),\n            benchmark_metrics.get('Maximum Drawdown', \"N/A\"),\n            benchmark_metrics.get('Sharpe Ratio', \"N/A\"),\n            benchmark_metrics.get('Sortino Ratio', \"N/A\"),\n            benchmark_metrics.get('Benchmark Correlation', \"N/A\")\n        ]\n    }).set_index('Metric')\n\ndef create_advanced_metrics_df(metrics, benchmark_metrics):\n    \"\"\"Creates a DataFrame for advanced metrics.\"\"\"\n    return pd.DataFrame({\n        'Metric': list(metrics.keys()),\n        'Portfolio': list(metrics.values()),\n        'Benchmark': list(benchmark_metrics.values())\n    }).set_index('Metric')\n\ndef create_performance_stats_df_portfolio_vs_portfolio(metrics_a, metrics_b, portfolio1, portfolio2):\n    \"\"\"Creates a DataFrame for Portfolio vs Portfolio performance statistics.\"\"\"\n    return pd.DataFrame({\n        'Metric': [\n            'Start Balance', 'End Balance', 'Annualized Return (CAGR)',\n            'Standard Deviation (Annualized)', 'Best Year', 'Worst Year',\n            'Maximum Drawdown', 'Sharpe Ratio', 'Sortino Ratio', 'Benchmark Correlation'\n        ],\n        portfolio1: [\n            metrics_a.get('Start Balance', \"N/A\"),\n            metrics_a.get('End Balance', \"N/A\"),\n            metrics_a.get('Annualized Return (CAGR)', \"N/A\"),\n            metrics_a.get('Standard Deviation (Annualized)', \"N/A\"),\n            metrics_a.get('Best Year', \"N/A\"),\n            metrics_a.get('Worst Year', \"N/A\"),\n            metrics_a.get('Maximum Drawdown', \"N/A\"),\n            metrics_a.get('Sharpe Ratio', \"N/A\"),\n            metrics_a.get('Sortino Ratio', \"N/A\"),\n            metrics_a.get('Benchmark Correlation', \"N/A\")\n        ],\n        portfolio2: [\n            metrics_b.get('Start Balance', \"N/A\"),\n            metrics_b.get('End Balance', \"N/A\"),\n            metrics_b.get('Annualized Return (CAGR)', \"N/A\"),\n            metrics_b.get('Standard Deviation (Annualized)', \"N/A\"),\n            metrics_b.get('Best Year', \"N/A\"),\n            metrics_b.get('Worst Year', \"N/A\"),\n            metrics_b.get('Maximum Drawdown', \"N/A\"),\n            metrics_b.get('Sharpe Ratio', \"N/A\"),\n            metrics_b.get('Sortino Ratio', \"N/A\"),\n            metrics_b.get('Benchmark Correlation', \"N/A\")\n        ]\n    }).set_index('Metric')\n\ndef create_advanced_metrics_df_portfolio_vs_portfolio(metrics_a, metrics_b, portfolio1, portfolio2):\n    \"\"\"Creates a DataFrame for Portfolio vs Portfolio advanced metrics.\"\"\"\n    return pd.DataFrame({\n        'Metric': list(metrics_a.keys()),\n        portfolio1: list(metrics_a.values()),\n        portfolio2: list(metrics_b.values())\n    }).set_index('Metric')\n\ndef display_drawdowns(cum_returns, benchmark_cum_returns):\n    \"\"\"Displays drawdown details for portfolio and benchmark.\"\"\"\n    st.markdown(\"### \ud83d\udcc8 Drawdowns for Portfolio\")\n    portfolio_drawdowns = get_drawdown_details(cum_returns)\n    if portfolio_drawdowns:\n        st.table(pd.DataFrame(portfolio_drawdowns))\n    else:\n        st.write(\"No drawdowns detected for the portfolio.\")\n\n    if not benchmark_cum_returns.empty:\n        st.markdown(\"### \ud83d\udcc8 Drawdowns for Benchmark\")\n        benchmark_drawdowns = get_drawdown_details(benchmark_cum_returns)\n        if benchmark_drawdowns:\n            st.table(pd.DataFrame(benchmark_drawdowns))\n        else:\n            st.write(\"No drawdowns detected for the benchmark.\")\n    else:\n        st.write(\"Benchmark data not available for drawdown analysis.\")\n\ndef perform_risk_factor_attribution(returns):\n    \"\"\"Performs and displays risk factor attribution analysis.\"\"\"\n    start_date = returns.index.min().strftime('%Y-%m-%d')\n    end_date = returns.index.max().strftime('%Y-%m-%d')\n    factors = fetch_fama_french_factors(start_date, end_date)\n    if factors.empty:\n        st.write(\"Failed to retrieve factor data.\")\n        return\n    factors = factors.asfreq(returns.index.freq, method='ffill')\n    attribution, error = calculate_risk_factor_attribution(returns, factors)\n\n    if error:\n        st.error(error)\n        st.write(\"Risk factor attribution analysis is unavailable.\")\n    elif attribution.empty:\n        st.write(\"Risk factor attribution analysis is unavailable.\")\n    else:\n        st.write(\"Risk Factor Attribution:\")\n        st.table(attribution)\n        fig_attribution = px.bar(\n            attribution,\n            x='Factor',\n            y='Contribution (%)',\n            title='Risk Factor Attribution',\n            labels={'Contribution (%)': 'Contribution (%)'},\n            template=THEME\n        )\n        st.plotly_chart(fig_attribution, use_container_width=True)\n\ndef display_visualizations(cum_returns, benchmark_cum_returns, returns, price_data, weights, metrics, benchmark_metrics):\n    \"\"\"Displays an enhanced set of visualizations for Portfolio vs Benchmark with improved interactivity and aesthetics.\"\"\"\n    if not cum_returns.empty and not benchmark_cum_returns.empty:\n        plot_growth_comparison(cum_returns, benchmark_cum_returns, portfolio_name=\"Portfolio\", benchmark_name=\"Benchmark\")\n    else:\n        st.warning(\"Insufficient data to display Growth Comparison. Ensure both portfolio and benchmark have data.\")\n\n    plot_drawdown_comparison(\n        (cum_returns / cum_returns.expanding().max() - 1) * 100,\n        (benchmark_cum_returns / benchmark_cum_returns.expanding().max() - 1) * 100,\n        portfolio_name=\"Portfolio\",\n        benchmark_name=\"Benchmark\"\n    )\n\n    st.subheader(\"\ud83d\udcc8 Compound Annual Growth Rate (CAGR) Over Time\")\n    if st.session_state.selected_time_frames:\n        plot_cagr_over_time(cum_returns, time_frames=st.session_state.selected_time_frames)\n    else:\n        st.warning(\"Please select at least one time frame for CAGR.\")\n\n    st.subheader(\"\ud83d\udce6 Returns Distribution Box Plot\")\n    plot_box(returns)\n\n    st.subheader(\"\ud83d\udd25 Correlation Heatmap of Assets\")\n    plot_correlation_heatmap(price_data.pct_change().dropna())\n\n    st.subheader(\"\ud83d\udd0d Risk-Return Attribution Analysis\")\n    plot_risk_return_attribution(returns, weights)\n    \n    # **Corrected Rolling Beta Calculation**\n    st.subheader(\"\ud83d\udcc9 Rolling Beta Over Time\")\n    if not benchmark_cum_returns.empty:\n        # Align benchmark returns with portfolio returns\n        benchmark_returns = benchmark_cum_returns.pct_change().dropna().reindex(returns.index, method='ffill').dropna()\n        \n        # Calculate rolling covariance and variance\n        rolling_cov = returns.rolling(window=252).cov(benchmark_returns)\n        rolling_var = benchmark_returns.rolling(window=252).var()\n        \n        # Compute rolling beta\n        rolling_beta = rolling_cov / rolling_var\n        \n        # Align rolling_beta with returns\n        rolling_beta = rolling_beta.dropna()\n        \n        fig_rolling_beta = px.line(\n            rolling_beta,\n            title='Rolling Beta (1-Year Window)',\n            labels={'index': 'Date', 'value': 'Beta'},\n            template=THEME\n        )\n        st.plotly_chart(fig_rolling_beta, use_container_width=True)\n    else:\n        st.warning(\"Benchmark returns not available to plot Rolling Beta.\")\n\n    st.subheader(\"\ud83d\udd25 Cumulative Returns Heatmap\")\n    plot_cumulative_returns_heatmap(cum_returns)\n\n    st.subheader(\"\ud83e\udd67 Portfolio Allocation Pie Chart\")\n    plot_allocation_pie(weights, price_data.columns, title=\"\ud83e\udd67 Portfolio Allocation\", hover_info=\"percent+name\")\n\n    st.subheader(\"\ud83d\udcc9 Rolling Metrics\")\n    if st.session_state.selected_rolling_periods:\n        plot_rolling_metrics(returns, windows=st.session_state.selected_rolling_periods)\n    else:\n        st.warning(\"Please select at least one rolling period to display metrics.\")\n    # **Added: Rolling Sharpe Ratio Graph**\n    st.subheader(\"\ud83d\udcc8 Rolling Sharpe Ratio Over Time\")\n    if not benchmark_cum_returns.empty:\n        # Calculate rolling Sharpe Ratio\n        rolling_sharpe = (returns.rolling(window=252).mean() - st.session_state.default_config['rf_rate']) / returns.rolling(window=252).std()\n        rolling_sharpe = rolling_sharpe.dropna()\n        \n        fig_rolling_sharpe = px.line(\n            rolling_sharpe,\n            title='Rolling Sharpe Ratio (1-Year Window)',\n            labels={'index': 'Date', 'value': 'Sharpe Ratio'},\n            template=THEME\n        )\n        st.plotly_chart(fig_rolling_sharpe, use_container_width=True)\n    else:\n        st.warning(\"Benchmark returns not available to plot Rolling Sharpe Ratio.\")\n    st.markdown(\"### \ud83d\udca1 Recommendations\")\n    recommendations = generate_recommendations(\n        allocations=[alloc for alloc in weights if alloc > 0],\n        available_selected=price_data.columns\n    )\n    if recommendations:\n        for rec in recommendations:\n            st.markdown(f\"\u2022 {rec}\")\n    else:\n        st.success(\"\ud83c\udf89 Your portfolio allocations are well-balanced!\")\n\n    st.markdown(\"### \ud83d\udcdd Final Score\")\n    portfolio_score = calculate_final_score(metrics, benchmark_metrics)\n    st.metric(\"\ud83d\udcca Portfolio Score\", f\"{portfolio_score:.2f} / 100\")\n    # Add interpretation/comment similar to Risk Factor Attribution\n    st.markdown(\"\"\"\n    **\ud83d\udcd6 Interpretation:**\n    - The **Final Score** represents a comprehensive evaluation of your portfolio's performance based on selected metrics.\n    - A higher score indicates a better balance between risk and return, aligning with your investment objectives.\n    - Use this score to assess overall portfolio health and identify areas for improvement.\n    \"\"\")\n\ndef display_visualizations_portfolio_vs_portfolio(\n    cum_returns_a, cum_returns_b, returns_a, returns_b,\n    price_data_a, price_data_b, weights_a, weights_b,\n    portfolio1, portfolio2, metrics_a, metrics_b\n):\n    \"\"\"Displays various visualizations for Portfolio vs Portfolio.\"\"\"\n    # Growth Comparison\n    fig_growth = px.line(title='Growth Comparison')\n    fig_growth.add_scatter(x=cum_returns_a.index, y=cum_returns_a, mode='lines', name=portfolio1)\n    fig_growth.add_scatter(x=cum_returns_b.index, y=cum_returns_b, mode='lines', name=portfolio2)\n    st.plotly_chart(fig_growth, use_container_width=True)\n\n    # Drawdown Comparison\n    plot_drawdown_comparison(\n        (cum_returns_a / cum_returns_a.expanding().max() - 1) * 100,\n        (cum_returns_b / cum_returns_b.expanding().max() - 1) * 100\n    )\n\n    # Box Plot for Returns Distribution\n    st.subheader(\"\ud83d\udce6 Returns Distribution Box Plot\")\n    plot_box(returns_a, returns_b, portfolio1, portfolio2)\n\n    # Heatmap of Correlations Between Assets\n    st.subheader(\"\ud83d\udd25 Correlation Heatmap of Assets\")\n    plot_correlation_heatmap(price_data_a.pct_change().dropna())\n    plot_correlation_heatmap(price_data_b.pct_change().dropna())\n\n    # Portfolio Allocation Pie Chart\n    st.subheader(\"\ud83e\udd67 Portfolio Allocation Pie Chart\")\n    plot_allocation_pie(weights_a, price_data_a.columns, title=f\"{portfolio1} Allocation\", hover_info=\"percent+name\")\n    plot_allocation_pie(weights_b, price_data_b.columns, title=f\"{portfolio2} Allocation\", hover_info=\"percent+name\")\n\n    st.markdown(\"### \ud83d\udcdd Final Score\")\n    score_a = calculate_final_score(metrics_a, metrics_b)\n    score_b = calculate_final_score(metrics_b, metrics_a)\n    st.write(f\"**{portfolio1}:** {score_a:.2f} / 100\")\n    st.write(f\"**{portfolio2}:** {score_b:.2f} / 100\")\n\ndef plot_box(\n    returns, \n    title=\"Returns Distribution Box Plot\", \n    labels={\"Return\": \"Returns (%)\", \"Asset\": \"Asset\"}, \n    color_sequence=px.colors.qualitative.Bold,\n    multiple=False,\n    portfolio_names=None\n):\n    \"\"\"\n    Generic function to plot box plots for portfolio returns.\n\n    Parameters:\n    - returns (pd.DataFrame or pd.Series): Returns data.\n    - title (str): Title of the plot.\n    - labels (dict): Axis labels.\n    - color_sequence (list): Colors for the boxes.\n    - multiple (bool): If True, handle multiple portfolios.\n    - portfolio_names (list): Names of the portfolios for labeling.\n    \"\"\"\n    if isinstance(returns, pd.DataFrame):\n        if multiple and portfolio_names:\n            for i, col in enumerate(returns.columns):\n                fig = px.box(\n                    returns[[col]].reset_index(drop=True),\n                    y=col,\n                    title=f\"{title} for {portfolio_names[i]}\",\n                    labels=labels,\n                    points='all',\n                    template=THEME,\n                    color_discrete_sequence=[color_sequence[i % len(color_sequence)]]\n                )\n                fig.update_traces(boxmean='sd')\n                fig.update_layout(xaxis_title=\"Assets\", yaxis_title=labels.get('Return', 'Returns (%)'))\n                st.plotly_chart(fig, use_container_width=True)\n        else:\n            melted_returns = returns.reset_index().melt(id_vars=returns.index.name if returns.index.name else 'Date', var_name='Asset', value_name='Return')\n            fig = px.box(\n                melted_returns,\n                x='Asset',\n                y='Return',\n                title=title,\n                labels=labels,\n                points='all',\n                template=THEME,\n                color='Asset',\n                color_discrete_sequence=color_sequence\n            )\n    elif isinstance(returns, pd.Series):\n        fig = px.box(\n            returns.rename(\"Return\"),\n            y='Return',\n            title=title,\n            labels=labels,\n            points='all',\n            template=THEME,\n            color_discrete_sequence=['cyan']\n        )\n    else:\n        st.warning(\"Returns data is neither a DataFrame nor a Series.\")\n        return\n    \n    fig.update_traces(boxmean='sd')\n    fig.update_layout(\n        xaxis_title=labels.get(\"Asset\", \"Assets\"),\n        yaxis_title=labels.get(\"Return\", \"Returns (%)\"),\n        legend_title=\"Assets\"\n    )\n    st.plotly_chart(fig, use_container_width=True)\n    \n    st.markdown(\"\"\"\n        **\ud83d\udcd6 Interpretation:**\n        - **Boxes:** Represent the interquartile range (IQR) where the middle 50% of the data lies.\n        - **Median Line:** Indicates the median return.\n        - **Whiskers:** Extend to show the range of the data excluding outliers.\n        - **Outliers:** Individual points outside the whiskers represent atypical returns.\n        - **Box Mean (Shaded):** Shows the mean and standard deviation of returns.\n    \"\"\")\n\ndef plot_cumulative_returns_heatmap(cum_returns):\n    \"\"\"Plots the cumulative returns heatmap.\"\"\"\n    try:\n        cum_returns_normalized = cum_returns / cum_returns.max()\n        fig_heatmap = px.imshow(\n            cum_returns_normalized.to_frame().T,\n            labels=dict(x=\"Date\", y=\"Portfolio\", color=\"Normalized Cumulative Return\"),\n            title=\"Cumulative Returns Heatmap\",\n            aspect=\"auto\",\n            color_continuous_scale='Viridis',\n            template=THEME\n        )\n        st.plotly_chart(fig_heatmap, use_container_width=True)\n        st.markdown(\n            \"**Interpretation:** The heatmap visualizes the normalized cumulative returns over time, \"\n            \"allowing for an intuitive comparison of portfolio performance across different periods.\"\n        )\n    except Exception as e:\n        st.error(f\"Error plotting cumulative returns heatmap: {e}\")\n\ndef plot_returns_correlation_heatmap(price_data):\n    \"\"\"Plots the correlation heatmap of asset returns.\"\"\"\n    correlation_data = price_data.pct_change().dropna()\n    plot_correlation_heatmap(correlation_data)\n\ndef plot_correlation_heatmap(correlation_data):\n    \"\"\"Plots an enhanced correlation heatmap using Plotly with improved aesthetics.\"\"\"\n    if correlation_data.empty:\n        st.warning(\"No data available to plot correlation heatmap.\")\n        return\n    corr = correlation_data.corr()\n    fig_heatmap = px.imshow(\n        corr,\n        title=\"\ud83d\udcc8 Correlation Heatmap of Assets\",\n        labels=dict(x=\"Asset\", y=\"Asset\", color=\"Correlation\"),\n        color_continuous_scale='RdBu',\n        zmin=-1,\n        zmax=1,\n        text_auto=True,\n        aspect=\"auto\",\n        template=THEME\n    )\n    fig_heatmap.update_layout(\n        title_x=0.5,\n        xaxis_title=\"Assets\",\n        yaxis_title=\"Assets\"\n    )\n    fig_heatmap.update_traces(\n        hovertemplate=\"Asset1: %{x}<br>Asset2: %{y}<br>Correlation: %{z:.2f}<extra></extra>\"\n    )\n    st.plotly_chart(fig_heatmap, use_container_width=True)\n\ndef plot_growth_comparison(cum_returns, benchmark_cum_returns, portfolio_name='Portfolio', benchmark_name='Benchmark'):\n    \"\"\"Plots an enhanced growth comparison between portfolio and benchmark with improved interactivity.\"\"\"\n    fig_growth = px.line(\n        title='\ud83d\udcc8 Growth Comparison',\n        labels={'value': 'Cumulative Returns', 'index': 'Date'},\n        template=THEME\n    )\n    \n    fig_growth.add_scatter(\n        x=cum_returns.index,\n        y=cum_returns,\n        mode='lines',\n        name=portfolio_name,\n        line=dict(color='cyan', width=2)\n    )\n    fig_growth.add_scatter(\n        x=benchmark_cum_returns.index,\n        y=benchmark_cum_returns,\n        mode='lines',\n        name=benchmark_name,\n        line=dict(color='orange', width=2, dash='dash')\n    )\n    \n    fig_growth.update_layout(\n        hovermode='x unified',\n        xaxis=dict(showgrid=True),\n        yaxis=dict(showgrid=True),\n        legend=dict(title=\"Legend\", x=0.01, y=0.99),\n        height=600  # Added height parameter\n    )\n    \n    st.plotly_chart(fig_growth, use_container_width=True, height=600, config={'responsive': True})\n\ndef plot_drawdown_comparison(drawdown_portfolio: pd.Series, drawdown_benchmark: pd.Series, portfolio_name='Portfolio', benchmark_name='Benchmark') -> None:\n    \"\"\"Plots an enhanced drawdown comparison between portfolio and benchmark with improved visuals.\"\"\"\n    fig_drawdown = px.line(\n        title='\ud83d\udcc9 Drawdown Comparison',\n        labels={'value': 'Drawdown (%)', 'index': 'Date'},\n        template=THEME\n    )\n    fig_drawdown.add_scatter(\n        x=drawdown_portfolio.index,\n        y=drawdown_portfolio,\n        mode='lines',\n        name=portfolio_name,\n        line=dict(color='red', width=2)\n    )\n    if not drawdown_benchmark.empty:\n        fig_drawdown.add_scatter(\n            x=drawdown_benchmark.index,\n            y=drawdown_benchmark,\n            mode='lines',\n            name=benchmark_name,\n            line=dict(color='blue', width=2, dash='dash')\n        )\n    fig_drawdown.update_layout(\n        hovermode=HOVERMODE,\n        yaxis=dict(showgrid=True),\n        xaxis=dict(showgrid=True),\n        legend=dict(title=\"Legend\", x=0.01, y=0.99),\n        height=FIG_HEIGHT\n    )\n    fig_drawdown.update_traces(hovertemplate=\"Date: %{x}<br>Drawdown: %{y:.2f}%\")\n    st.plotly_chart(fig_drawdown, use_container_width=True, height=600, config={'responsive': True})\n\ndef plot_cagr_over_time(cum_returns, time_frames):\n    \"\"\"Plots CAGR over different time frames.\"\"\"\n    for frame in time_frames:\n        plot_cagr(cum_returns, frame)\n\ndef plot_allocation_pie(weights, assets, title, hover_info):\n    \"\"\"Plots the portfolio allocation pie chart.\"\"\"\n    fig_pie = px.pie(\n        names=assets,\n        values=weights,\n        title=title,\n        hover_data=[hover_info],\n        template=THEME\n    )\n    st.plotly_chart(fig_pie, use_container_width=True)\n\ndef plot_risk_return_attribution(returns, weights):\n    \"\"\"Plots the risk-return attribution analysis.\"\"\"\n    fig_rra = px.scatter(\n        x=returns.mean() * 252,\n        y=returns.std() * np.sqrt(252),\n        size=weights*100,\n        color=returns.mean() / returns.std(),\n        hover_name=returns.index,\n        title='Risk-Return Attribution',\n        labels={'x': 'Annualized Return', 'y': 'Annualized Risk (Std Dev)'},\n        template='plotly_dark',\n        size_max=60\n    )\n    st.plotly_chart(fig_rra, use_container_width=True)\n\ndef plot_rolling_metrics(returns, windows):\n    \"\"\"Plots rolling metrics based on selected window periods.\"\"\"\n    for window in windows:\n        rolling_mean = returns.rolling(window=window).mean()\n        rolling_std = returns.rolling(window=window).std()\n        fig = px.line(title=f'Rolling {window}-Day Mean and Std Dev')\n        fig.add_scatter(x=rolling_mean.index, y=rolling_mean, mode='lines', name='Rolling Mean')\n        fig.add_scatter(x=rolling_std.index, y=rolling_std, mode='lines', name='Rolling Std Dev')\n        st.plotly_chart(fig, use_container_width=True)\n\n@handle_exceptions\ndef calculate_risk_factor_attribution(returns: pd.Series, factors: pd.DataFrame, annualization_factor: int = 252) -> tuple:\n    \"\"\"\n    Decompose portfolio returns by risk factors using linear regression and provide\n    comments on the factor contributions.\n\n    Parameters:\n    - returns (pd.Series): Portfolio returns.\n    - factors (pd.DataFrame): DataFrame where each column represents a risk factor.\n    - annualization_factor (int): Annualization factor (252 for daily, 12 for monthly returns).\n\n    Returns:\n    - pd.DataFrame: Factor names, their contribution percentages, and explanatory comments.\n    - None: If an exception occurs, handled by the decorator.\n    \"\"\"\n    # Ensure returns has a name, or assign one if missing\n    if returns.name is None:\n        returns = returns.rename(\"Portfolio_Returns\")\n\n    # Convert returns to a DataFrame\n    returns = returns.to_frame()\n\n    # Ensure both returns and factors are in decimal format\n    if returns['Portfolio_Returns'].max() > 1:\n        returns /= 100\n\n    if factors.max().max() > 1:\n        factors /= 100\n\n    # Adjust returns to excess returns by subtracting RF (if it exists in factors)\n    if 'RF' in factors.columns:\n        returns['Portfolio_Returns'] -= factors['RF']\n        factors = factors.drop(columns=['RF'])\n\n    # Align the data using an inner join and drop any remaining NaN values\n    aligned_data = pd.merge(returns, factors, left_index=True, right_index=True, how='inner').dropna()\n\n    # Check that we have data after merging\n    if aligned_data.empty:\n        raise ValueError(\"No overlapping dates between returns and factors after dropping NaNs.\")\n\n    # Prepare X and y for regression\n    X = aligned_data[factors.columns]\n    X = sm.add_constant(X)  # Add intercept\n    y = aligned_data['Portfolio_Returns']\n\n    # Run the regression model\n    model = sm.OLS(y, X).fit()\n    coefficients = model.params.drop('const', errors='ignore')\n\n    # Calculate factor contributions (non-annualized)\n    factor_means = X.mean().drop('const', errors='ignore')\n    contributions = coefficients * factor_means\n\n    # Calculate total return\n    total_return = returns['Portfolio_Returns'].mean()\n\n    # Check if total_return is zero to avoid division by zero\n    if np.isclose(total_return, 0):\n        st.warning(\"Total portfolio return is zero. Cannot compute contribution percentages.\")\n        attribution_df = pd.DataFrame({\n            'Factor': contributions.index,\n            'Contribution (%)': [0.0] * len(contributions)\n        })\n    else:\n        # Calculate percentage contributions\n        attribution_df = pd.DataFrame({\n            'Factor': contributions.index,\n            'Contribution (%)': (contributions / total_return * 100).round(2)\n        })\n\n    # Remove the constant term if it exists\n    if 'const' in attribution_df['Factor'].values:\n        attribution_df = attribution_df[attribution_df['Factor'] != 'const']\n\n    # Use full names for factors\n    factor_full_names = {\n        'Mkt-RF': 'Market Risk Premium',\n        'SMB': 'Small Minus Big',\n        'HML': 'High Minus Low'\n    }\n    attribution_df['Factor'] = attribution_df['Factor'].replace(factor_full_names)\n\n    # Generate detailed comments based on factor contributions\n    comments = []\n    for _, row in attribution_df.iterrows():\n        factor_name = row['Factor']\n        contribution = row['Contribution (%)']\n\n        # Market Risk Premium (Mkt-RF) Analysis\n        if factor_name == 'Market Risk Premium':\n            if contribution > 75:\n                comments.append(f\"{factor_name} = {contribution}%: Extremely high sensitivity to market movements.\")\n            elif contribution > 50:\n                comments.append(f\"{factor_name} = {contribution}%: High sensitivity to overall market movements.\")\n            elif contribution > 30:\n                comments.append(f\"{factor_name} = {contribution}%: Notable sensitivity to market risk.\")\n            elif contribution > 10:\n                comments.append(f\"{factor_name} = {contribution}%: Moderate exposure to market risk.\")\n            else:\n                comments.append(f\"{factor_name} = {contribution}%: Low exposure to market risk.\")\n\n        # Small Minus Big (SMB) Analysis\n        elif factor_name == 'Small Minus Big':\n            if contribution > 5:\n                comments.append(f\"{factor_name} = {contribution}%: Strong tilt towards small-cap stocks.\")\n            elif contribution > 0:\n                comments.append(f\"{factor_name} = {contribution}%: Mild preference for small-cap stocks.\")\n            elif contribution > -5:\n                comments.append(f\"{factor_name} = {contribution}%: Slight tilt towards larger-cap stocks.\")\n            else:\n                comments.append(f\"{factor_name} = {contribution}%: Clear preference for large-cap stocks.\")\n\n        # High Minus Low (HML) Analysis\n        elif factor_name == 'High Minus Low':\n            if contribution > 5:\n                comments.append(f\"{factor_name} = {contribution}%: Strong tilt toward value stocks.\")\n            elif contribution > 0:\n                comments.append(f\"{factor_name} = {contribution}%: Slight positive tilt toward value stocks.\")\n            elif contribution > -5:\n                comments.append(f\"{factor_name} = {contribution}%: Minor negative tilt toward growth stocks.\")\n            else:\n                comments.append(f\"{factor_name} = {contribution}%: Clear preference for growth stocks.\")\n\n    # Add comments to the DataFrame\n    attribution_df['Comment'] = comments\n\n    return attribution_df, None\n\n@handle_exceptions\ndef fetch_fama_french_factors(start_date: str, end_date: str) -> pd.DataFrame:\n    \"\"\"\n    Fetch Fama-French daily factor data between specified dates.\n\n    Parameters:\n    - start_date (str): Start date in 'YYYY-MM-DD' format.\n    - end_date (str): End date in 'YYYY-MM-DD' format.\n\n    Returns:\n    - pd.DataFrame: DataFrame containing Fama-French factors.\n    \"\"\"\n    # [Function Implementation Remains Unchanged]\n    try:\n        # Fetch daily Fama-French factors\n        ff_data = pdr.get_data_famafrench('F-F_Research_Data_Factors_daily', start=start_date, end=end_date)\n        if not ff_data:\n            st.error(\"Fama-French data not found.\")\n            return pd.DataFrame()\n\n        factors = ff_data[0]\n        factors = factors.rename(columns=lambda x: x.strip())  # Remove any leading/trailing spaces\n        factors /= 100  # Convert percentage returns to decimal format\n\n        # Fill missing data by forward and backward filling\n        factors = factors.fillna(method='ffill').fillna(method='bfill')\n\n        # Check for necessary columns\n        required_columns = {'Mkt-RF', 'SMB', 'HML', 'RF'}\n        if not required_columns.issubset(factors.columns):\n            missing = required_columns - set(factors.columns)\n            st.error(f\"Missing factor columns: {', '.join(missing)}\")\n            return pd.DataFrame()\n\n        return factors\n    except Exception as e:\n        st.error(f\"Error fetching factor data: {e}\")\n        return pd.DataFrame()\n\n@handle_exceptions\ndef calculate_final_score(primary_metrics: dict, comparison_metrics: dict) -> float:\n    metrics_to_compare = [\n        'Annualized Return (CAGR)',\n        'Sharpe Ratio',\n        'Sortino Ratio',\n        'Treynor Ratio',\n        'Calmar Ratio',\n        'Alpha (annualized)',\n        'Information Ratio',\n        'Modigliani\u2013Modigliani Measure',\n        'Upside Capture Ratio',\n        'Gain/Loss Ratio'\n    ]\n    metric_weights = {\n        'Annualized Return (CAGR)': 15,\n        'Sharpe Ratio': 15,\n        'Sortino Ratio': 10,\n        'Treynor Ratio': 10,\n        'Calmar Ratio': 10,\n        'Alpha (annualized)': 10,\n        'Information Ratio': 10,\n        'Modigliani\u2013Modigliani Measure': 10,\n        'Upside Capture Ratio': 5,\n        'Gain/Loss Ratio': 5\n    }\n\n    score = 0\n    total = 0\n\n    for metric in metrics_to_compare:\n        primary = primary_metrics.get(metric, \"N/A\")\n        comparison = comparison_metrics.get(metric, \"N/A\")\n        if primary != \"N/A\" and comparison != \"N/A\":\n            try:\n                primary_val = float(primary.strip('%')) if '%' in primary else float(primary)\n                comparison_val = float(comparison.strip('%')) if '%' in comparison else float(comparison)\n                weight = metric_weights.get(metric, 1)\n                if comparison_val == 0:\n                    st.warning(f\"Comparison metric '{metric}' has a value of zero. Skipping this metric to avoid division by zero.\")\n                    continue\n                if primary_val > comparison_val:\n                    score += weight * (primary_val / comparison_val)\n                else:\n                    score += weight * (primary_val / comparison_val) * 0.5  # Partial credit\n                total += weight\n            except ValueError:\n                st.warning(f\"Invalid numeric conversion for metric '{metric}'. Skipping.\")\n                continue\n    return (score / total) * 100 if total > 0 else 0\n    \n@handle_exceptions\ndef plot_cagr_over_time(cum_returns: pd.Series, time_frames: list = ['Weekly', 'Monthly', 'Quarterly', 'Annually']) -> None:\n    \"\"\"\n    Plot CAGR over multiple time frames.\n\n    Parameters:\n    - cum_returns (pd.Series): Cumulative returns of the portfolio.\n    - time_frames (list): List of time frames to calculate CAGR.\n    \"\"\"\n    frequency_map = {\n        'Weekly': 'W',\n        'Monthly': 'M',\n        'Quarterly': 'Q',\n        'Annually': 'Y'\n    }\n    fig = go.Figure()\n    for tf in time_frames:\n        freq = frequency_map.get(tf)\n        if not freq:\n            continue\n        rolled = cum_returns.resample(freq).last()\n        if rolled.empty:\n            st.warning(f\"No data available for {tf} CAGR calculation.\")\n            continue\n        years = (rolled.index[-1] - rolled.index[0]).days / 365.25\n        if years <= 0:\n            st.warning(f\"Not enough data to calculate {tf} CAGR.\")\n            continue\n        cagr = (rolled / rolled.iloc[0]) ** (1/years) - 1\n        fig.add_trace(go.Scatter(x=rolled.index, y=cagr, mode='lines', name=f'{tf} CAGR'))\n    fig.update_layout(\n        title='CAGR Over Multiple Time Frames',\n        xaxis_title='Date',\n        yaxis_title='CAGR',\n        hovermode=HOVERMODE\n    )\n    st.plotly_chart(fig, use_container_width=True)\n\n@handle_exceptions\ndef backtest(weights: list, prices: pd.DataFrame, rebalance_freq: str = 'M', broker_fee: float = 0.0, debug: bool = False) -> tuple:\n    \"\"\"\n    Backtest the portfolio based on weights and price data.\n\n    Parameters:\n    - weights (list): Allocation weights for each asset.\n    - prices (pd.DataFrame): Adjusted closing prices of assets.\n    - rebalance_freq (str): Rebalancing frequency (e.g., 'D', 'W', 'M').\n    - broker_fee (float): Broker fee as a percentage.\n    - debug (bool): If True, prints debug information.\n\n    Returns:\n    - tuple: (portfolio_returns: pd.Series, cum_returns: pd.Series)\n    \"\"\"\n    try:\n        # Calculate returns and drop any NaN values\n        returns = prices.pct_change().dropna()\n        if returns.empty:\n            st.error(\"Returns data is empty after calculating percentage changes.\")\n            return pd.Series(dtype=float), pd.Series(dtype=float)\n\n        # Calculate portfolio returns\n        portfolio_returns = returns.dot(weights)\n        if not isinstance(portfolio_returns, pd.Series):\n            portfolio_returns = portfolio_returns.squeeze()\n\n        # Identify rebalancing dates\n        if rebalance_freq.upper() == 'D':\n            rebalance_dates = returns.index\n        else:\n            rebalance_dates = returns.resample(rebalance_freq.upper()).last().dropna().index\n\n        # Debug: Show rebalancing dates\n        if debug:\n            st.write(f\"Rebalancing Dates: {rebalance_dates.tolist()}\")\n\n        # Ensure rebalance_dates are in the portfolio_returns index\n        valid_rebalance_dates = rebalance_dates.intersection(portfolio_returns.index)\n        if debug:\n            st.write(f\"Valid Rebalancing Dates: {valid_rebalance_dates.tolist()}\")\n\n        # Apply broker fees on rebalancing dates\n        if not valid_rebalance_dates.empty:\n            portfolio_returns.loc[valid_rebalance_dates] -= broker_fee / 100  # Convert to decimal\n        else:\n            st.warning(\"No valid rebalancing dates found within the returns data.\")\n\n        # Calculate cumulative returns\n        cum_returns = (1 + portfolio_returns).cumprod()\n        if cum_returns.empty:\n            st.error(\"Cumulative returns are empty. Check the data and allocations.\")\n            return pd.Series(dtype=float), pd.Series(dtype=float)\n\n        # Debug: Show cumulative returns\n        if debug:\n            st.write(\"Cumulative Returns:\")\n            st.write(cum_returns)\n\n        return portfolio_returns, cum_returns\n    except Exception as e:\n        st.error(f\"Error during backtesting: {e}\")\n        return pd.Series(dtype=float), pd.Series(dtype=float)\n\ndef calculate_sharpe_ratio(returns: pd.Series, rf: float = 0.02) -> float:\n    \"\"\"\n    Calculate the Sharpe Ratio for a given set of returns.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - rf (float): Risk-free rate (default is 2%).\n\n    Returns:\n    - float: Sharpe Ratio.\n    \"\"\"\n    excess_return = returns.mean() * 252 - rf\n    std_dev = returns.std() * np.sqrt(252)\n    return excess_return / std_dev if std_dev != 0 else np.nan\n\ndef calculate_sortino_ratio(returns: pd.Series, rf: float = 0.02) -> float:\n    \"\"\"\n    Calculate the Sortino Ratio for a given set of returns.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - rf (float): Risk-free rate (default is 2%).\n\n    Returns:\n    - float: Sortino Ratio.\n    \"\"\"\n    excess_return = returns.mean() * 252 - rf\n    downside_std = returns[returns < 0].std() * np.sqrt(252)\n    return excess_return / downside_std if downside_std != 0 else np.nan\n\ndef calculate_treynor_ratio(returns: pd.Series, benchmark_returns: pd.Series, rf: float = 0.02) -> float:\n    \"\"\"\n    Calculate the Treynor Ratio for a given set of returns.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n    - rf (float): Risk-free rate (default is 2%).\n\n    Returns:\n    - float: Treynor Ratio.\n    \"\"\"\n    beta = calculate_beta(returns, benchmark_returns)\n    excess_return = returns.mean() * 252 - rf\n    return excess_return / beta if beta != 0 else np.nan\n\ndef calculate_calmar_ratio(returns: pd.Series, cum_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Calmar Ratio for a given set of returns.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - cum_returns (pd.Series): Cumulative returns of the portfolio.\n\n    Returns:\n    - float: Calmar Ratio.\n    \"\"\"\n    annual_return = returns.mean() * 252\n    max_dd = drawdown(cum_returns)\n    return annual_return / abs(max_dd) if max_dd != 0 else np.nan\n\ndef calculate_beta(returns: pd.Series, benchmark_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Beta of the portfolio relative to the benchmark.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n\n    Returns:\n    - float: Beta value.\n    \"\"\"\n    if returns.empty or benchmark_returns.empty:\n        return np.nan\n    covariance_matrix = np.cov(returns, benchmark_returns)\n    covariance = covariance_matrix[0, 1]\n    benchmark_variance = covariance_matrix[1, 1]\n    return covariance / benchmark_variance if benchmark_variance != 0 else np.nan\n\ndef calculate_alpha(returns: pd.Series, benchmark_returns: pd.Series, rf: float = 0.02) -> float:\n    \"\"\"\n    Calculate the Alpha of the portfolio relative to the benchmark.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n    - rf (float): Risk-free rate (default is 2%).\n\n    Returns:\n    - float: Alpha value.\n    \"\"\"\n    beta = calculate_beta(returns, benchmark_returns)\n    portfolio_return = returns.mean() * 252\n    benchmark_return = benchmark_returns.mean() * 252\n    return portfolio_return - (rf + beta * (benchmark_return - rf)) if not np.isnan(beta) else np.nan\n\ndef calculate_r_squared(returns: pd.Series, benchmark_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the R-squared of the portfolio relative to the benchmark.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n\n    Returns:\n    - float: R-squared value.\n    \"\"\"\n    if returns.empty or benchmark_returns.empty:\n        return np.nan\n    covariance = np.cov(returns, benchmark_returns)\n    var_port = covariance[0,0]\n    var_bench = covariance[1,1]\n    cov = covariance[0,1]\n    return (cov ** 2) / (var_port * var_bench) if var_port !=0 and var_bench !=0 else np.nan\n\ndef calculate_information_ratio(returns: pd.Series, benchmark_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Information Ratio of the portfolio relative to the benchmark.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n\n    Returns:\n    - float: Information Ratio.\n    \"\"\"\n    if returns.empty or benchmark_returns.empty:\n        return np.nan\n    active_return = (returns.mean() - benchmark_returns.mean()) * 252\n    tracking_error = calculate_tracking_error(returns, benchmark_returns)\n    return active_return / tracking_error if tracking_error != 0 else np.nan\n\ndef generate_recommendations(allocations: list, available_selected: list) -> list:\n    \"\"\"\n    Generate basic portfolio recommendations based on current allocations.\n\n    Parameters:\n    - allocations (list of float): Current allocation percentages.\n    - available_selected (list of str): List of selected asset tickers.\n\n    Returns:\n    - list of str: Recommendations.\n    \"\"\"\n    recommendations = []\n    max_alloc = max(allocations)\n    min_alloc = min(allocations)\n    total_alloc = sum(allocations)\n\n    if max_alloc > 40.0:\n        idx = allocations.index(max_alloc)\n        ticker = available_selected[idx]\n        recommendations.append(f\"\ud83d\udd39 Consider reducing the allocation to **{ticker}** since it constitutes **{max_alloc:.2f}%** of your portfolio.\")\n\n    if min_alloc < 5.0:\n        idx = allocations.index(min_alloc)\n        ticker = available_selected[idx]\n        recommendations.append(f\"\ud83d\udd38 Consider increasing the allocation to **{ticker}** to at least **5.00%** for better diversification.\")\n\n    if total_alloc < 100.0:\n        recommendations.append(\"\ud83d\udd39 Consider allocating the remaining funds to additional assets to reach a total of **100%**.\")\n\n    return recommendations\n\ndef get_common_benchmarks(selected_tickers: list) -> dict:\n    \"\"\"\n    Define benchmark suggestions based on asset sectors or indices.\n\n    Parameters:\n    - selected_tickers (list of str): List of selected asset tickers.\n\n    Returns:\n    - dict: Dictionary of benchmark names and their corresponding tickers.\n    \"\"\"\n    # Example benchmark sets\n    sp500 = {\"AAPL\", \"MSFT\", \"GOOGL\", \"AMZN\", \"META\", \"TSLA\"}  # Example S&P 500 tech companies\n    nasdaq_tech = {\"AAPL\", \"MSFT\", \"GOOGL\", \"AMZN\", \"META\", \"TSLA\", \"NVDA\", \"AMD\"}\n\n    selected_set = set(selected_tickers)\n\n    if selected_set.issubset(sp500):\n        return {\n            \"S&P 500\": \"^GSPC\",\n            \"Dow Jones Industrial Average\": \"^DJI\",\n            \"Russell 2000\": \"^RUT\",\n            \"Custom\": \"CUSTOM\"\n        }\n    elif selected_set.issubset(nasdaq_tech):\n        return {\n            \"NASDAQ Composite\": \"^IXIC\",\n            \"QQQ (Invesco QQQ ETF)\": \"QQQ\",\n            \"Custom\": \"CUSTOM\"\n        }\n    else:\n        return {\n            \"S&P 500\": \"^GSPC\",\n            \"NASDAQ Composite\": \"^IXIC\",\n            \"Dow Jones Industrial Average\": \"^DJI\",\n            \"Russell 2000\": \"^RUT\",\n            \"Custom\": \"CUSTOM\"\n        }\n\ndef calculate_tracking_error(returns: pd.Series, benchmark_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Tracking Error of the portfolio relative to the benchmark.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n\n    Returns:\n    - float: Tracking Error.\n    \"\"\"\n    if returns.empty or benchmark_returns.empty:\n        return np.nan\n    return np.std((returns - benchmark_returns)) * np.sqrt(252)\n\n@handle_exceptions\ndef calculate_performance_attribution(returns: pd.Series, weights: list) -> pd.DataFrame:\n    \"\"\"\n    Calculate performance attribution based on asset contributions.\n\n    Parameters:\n    - returns (pd.Series or pd.DataFrame): Returns of assets.\n    - weights (list): Allocation weights for each asset.\n\n    Returns:\n    - pd.DataFrame: DataFrame containing asset names and their contribution percentages.\n    \"\"\"\n    if isinstance(returns, pd.Series):\n        returns = returns.to_frame('Asset')  # Convert Series to DataFrame with a default column name\n\n    if len(weights) != len(returns.columns):\n        st.error(f\"Number of weights ({len(weights)}) does not match number of assets ({len(returns.columns)}).\")\n        return pd.DataFrame()\n\n    annual_returns = returns.mean() * 252\n    contributions = annual_returns * weights\n    attribution_df = pd.DataFrame({\n        'Asset': returns.columns,\n        'Contribution (%)': (contributions / contributions.sum() * 100).round(2)\n    }).sort_values(by='Contribution (%)', ascending=False)\n    return attribution_df\n\ndef calculate_active_return(returns: pd.Series, benchmark_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Active Return of the portfolio relative to the benchmark.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n\n    Returns:\n    - float: Active Return percentage.\n    \"\"\"\n    if returns.empty or benchmark_returns.empty:\n        return np.nan\n    return (returns.mean() - benchmark_returns.mean()) * 252 * 100\n\ndef calculate_gain_loss_ratio(returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Gain/Loss Ratio of the portfolio.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n\n    Returns:\n    - float: Gain/Loss Ratio.\n    \"\"\"\n    gains = returns[returns > 0].sum()\n    losses = -returns[returns < 0].sum()\n    return gains / losses if losses != 0 else np.nan\n\ndef drawdown(cum_returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Maximum Drawdown of the portfolio.\n\n    Parameters:\n    - cum_returns (pd.Series): Cumulative returns of the portfolio.\n\n    Returns:\n    - float: Maximum Drawdown value.\n    \"\"\"\n    if cum_returns.empty:\n        return np.nan\n    peak = cum_returns.expanding(min_periods=1).max()\n    dd = (cum_returns / peak) - 1\n    return dd.min()\n\ndef calculate_capture_ratio(returns: pd.Series, benchmark_returns: pd.Series, upside: bool = True) -> float:\n    \"\"\"\n    Calculate the Upside or Downside Capture Ratio.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n    - upside (bool): If True, calculates Upside Capture Ratio; otherwise, Downside.\n\n    Returns:\n    - float: Capture Ratio percentage.\n    \"\"\"\n    if returns.empty or benchmark_returns.empty:\n        return np.nan\n    mask = benchmark_returns > 0 if upside else benchmark_returns < 0\n    if mask.sum() == 0:\n        return np.nan\n    portfolio = returns[mask]\n    benchmark = benchmark_returns[mask]\n    return (portfolio.sum() / benchmark.sum()) * 100 if benchmark.sum() != 0 else np.nan\n\ndef calculate_safe_withdrawal_rate(returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Safe Withdrawal Rate based on portfolio returns.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n\n    Returns:\n    - float: Safe Withdrawal Rate percentage.\n    \"\"\"\n    if returns.empty:\n        return np.nan\n    return (returns.mean() / returns.std()) * 100\n\ndef calculate_perpetual_withdrawal_rate(returns: pd.Series) -> float:\n    \"\"\"\n    Calculate the Perpetual Withdrawal Rate based on portfolio returns.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n\n    Returns:\n    - float: Perpetual Withdrawal Rate percentage.\n    \"\"\"\n    if returns.empty:\n        return np.nan\n    return (returns.mean() / returns.std()) * 100\n\ndef calculate_positive_periods(returns: pd.Series) -> str:\n    \"\"\"\n    Calculate the number and percentage of positive return periods.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n\n    Returns:\n    - str: String describing positive periods.\n    \"\"\"\n    if returns.empty:\n        return \"N/A\"\n    positive = returns > 0\n    return f\"{positive.sum()} out of {len(returns)} ({(positive.sum()/len(returns))*100:.2f}%)\"\n\ndef calculate_modigliani_miller(returns: pd.Series, benchmark_returns: pd.Series, rf: float = 0.02) -> float:\n    \"\"\"\n    Calculate the Modigliani\u2013Modigliani Measure (M2).\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - benchmark_returns (pd.Series): Daily returns of the benchmark.\n    - rf (float): Risk-free rate (default is 2%).\n\n    Returns:\n    - float: M2 value.\n    \"\"\"\n    sharpe = calculate_sharpe_ratio(returns, rf)\n    alpha = calculate_alpha(returns, benchmark_returns, rf)\n    return alpha / sharpe if sharpe != 0 and not np.isnan(alpha) else np.nan\n\ndef get_drawdown_details(cum_returns: pd.Series) -> list:\n    \"\"\"\n    Generate detailed drawdown information.\n\n    Parameters:\n    - cum_returns (pd.Series): Cumulative returns of the portfolio.\n\n    Returns:\n    - list: List of dictionaries containing drawdown details.\n    \"\"\"\n    drawdowns = []\n    if cum_returns.empty:\n        return drawdowns\n    peak = cum_returns.iloc[0]\n    peak_date = cum_returns.index[0]\n    trough = cum_returns.iloc[0]\n    trough_date = cum_returns.index[0]\n    for date, value in cum_returns.items():\n        if value > peak:\n            if trough < peak:\n                recovery = cum_returns[cum_returns >= peak].loc[trough_date:]\n                if not recovery.empty:\n                    recovery_date = recovery.index[0]\n                    if recovery_date > trough_date:\n                        recovery_time = (recovery_date - trough_date).days\n                        underwater_period = (recovery_date - peak_date).days\n                        drawdowns.append({\n                            'Start': peak_date.strftime('%b %Y'),\n                            'End': trough_date.strftime('%b %Y'),\n                            'Length': f\"{(trough_date - peak_date).days // 30} months\",\n                            'Recovery By': recovery_date.strftime('%b %Y'),\n                            'Recovery Time': f\"{recovery_time // 30} months\",\n                            'Underwater Period': f\"{underwater_period // 30} months\",\n                            'Drawdown': f\"{((trough / peak) - 1) * 100:.2f}%\"\n                        })\n                    else:\n                        drawdowns.append({\n                            'Start': peak_date.strftime('%b %Y'),\n                            'End': trough_date.strftime('%b %Y'),\n                            'Length': f\"{(trough_date - peak_date).days // 30} months\",\n                            'Recovery By': \"Not Recovered\",\n                            'Recovery Time': \"N/A\",\n                            'Underwater Period': \"N/A\",\n                            'Drawdown': f\"{((trough / peak) - 1) * 100:.2f}%\"\n                        })\n            peak = value\n            peak_date = date\n            trough = value\n            trough_date = date\n        elif value < trough:\n            trough = value\n            trough_date = date\n    if trough < peak:\n        drawdowns.append({\n            'Start': peak_date.strftime('%b %Y'),\n            'End': trough_date.strftime('%b %Y'),\n            'Length': f\"{(trough_date - peak_date).days // 30} months\",\n            'Recovery By': \"Not Recovered\",\n            'Recovery Time': \"N/A\",\n            'Underwater Period': \"N/A\",\n            'Drawdown': f\"{((trough / peak) - 1) * 100:.2f}%\"\n        })\n    try:\n        drawdowns_sorted = sorted(drawdowns, key=lambda x: float(x['Drawdown'].strip('%')), reverse=False)\n    except:\n        drawdowns_sorted = []\n    drawdowns_sorted = drawdowns_sorted[:10]\n    for idx, dd in enumerate(drawdowns_sorted, start=1):\n        dd['Rank'] = idx\n    drawdowns_final = []\n    for dd in drawdowns_sorted:\n        drawdowns_final.append({\n            'Rank': dd['Rank'],\n            'Start': dd['Start'],\n            'End': dd['End'],\n            'Length': dd['Length'],\n            'Recovery By': dd['Recovery By'],\n            'Recovery Time': dd['Recovery Time'],\n            'Underwater Period': dd['Underwater Period'],\n            'Drawdown': dd['Drawdown']\n        })\n    return drawdowns_final\n\n@handle_exceptions\ndef optimize_portfolio(\n    returns: pd.DataFrame,\n    benchmark_returns: pd.Series = None,\n    objectives: list = ['sharpe'],\n    rf: float = 0.02,\n    max_weight: float = 1.0,\n    min_weight: float = 0.0,\n    target_return: float = None\n) -> np.ndarray:\n    \"\"\"\n    Optimize a portfolio based on specified objectives.\n\n    Parameters:\n    - returns (pd.DataFrame): Historical returns of assets.\n    - benchmark_returns (pd.Series, optional): Returns of the benchmark index.\n    - objectives (list): Objectives to optimize.\n        Options include 'sharpe', 'min_variance', 'max_return', 'min_drawdown', 'maximize_alpha', 'minimize_beta'.\n    - rf (float): Risk-free rate for alpha calculation.\n    - max_weight (float): Maximum weight per asset.\n    - min_weight (float): Minimum weight per asset.\n    - target_return (float, optional): Target return for the portfolio.\n\n    Returns:\n    - np.ndarray: Optimized asset weights or None if optimization fails.\n    \"\"\"\n    from scipy.optimize import minimize\n\n    def calculate_beta(portfolio_returns: pd.Series, benchmark_returns: pd.Series) -> float:\n        covariance = np.cov(portfolio_returns, benchmark_returns)\n        variance = covariance[1, 1]\n        return covariance[0, 1] / variance if variance != 0 else 0\n\n    def calculate_var(portfolio_returns: np.ndarray, confidence_level: float = 0.95) -> float:\n        return np.percentile(portfolio_returns, (1 - confidence_level) * 100)\n\n    def calculate_cvar(portfolio_returns: np.ndarray, confidence_level: float = 0.95) -> float:\n        var = calculate_var(portfolio_returns, confidence_level)\n        return portfolio_returns[portfolio_returns <= var].mean()\n\n    # Define individual objective functions\n    def sharpe_ratio(weights: np.ndarray) -> float:\n        portfolio_return = np.dot(returns.mean(), weights) * 252\n        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))\n        return -portfolio_return / portfolio_volatility if portfolio_volatility > 1e-6 else 0  # Negative for maximization\n\n    def min_variance(weights: np.ndarray) -> float:\n        return np.dot(weights.T, np.dot(returns.cov() * 252, weights))\n\n    def max_return(weights: np.ndarray) -> float:\n        return -np.dot(returns.mean(), weights) * 252  # Negative for maximization\n\n    def min_drawdown(weights: np.ndarray) -> float:\n        portfolio_returns = returns.dot(weights)\n        cvar = calculate_cvar(portfolio_returns, 0.95)\n        return cvar  # Minimizing CVaR as a proxy for drawdown\n\n    # Initialize list of objective functions\n    objective_functions = []\n\n    # Map objectives to functions\n    for obj in objectives:\n        if obj == 'sharpe':\n            objective_functions.append(sharpe_ratio)\n        elif obj == 'min_variance':\n            objective_functions.append(min_variance)\n        elif obj == 'max_return':\n            objective_functions.append(max_return)\n        elif obj == 'min_drawdown':\n            objective_functions.append(min_drawdown)\n        elif obj == 'maximize_alpha':\n            if benchmark_returns is None:\n                st.error(\"benchmark_returns must be provided for 'maximize_alpha' objective.\")\n                return None\n\n            benchmark_return = benchmark_returns.mean() * 252  # Assuming daily returns annualized\n\n            def maximize_alpha(weights: np.ndarray) -> float:\n                portfolio_return = np.dot(returns.mean(), weights) * 252\n                portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))\n                portfolio_returns = returns.dot(weights)\n                beta = calculate_beta(portfolio_returns, benchmark_returns)\n                alpha = portfolio_return - (rf + beta * (benchmark_return - rf))\n                return -alpha  # Negative for maximization\n\n            objective_functions.append(maximize_alpha)\n        elif obj == 'minimize_beta':\n            if benchmark_returns is None:\n                st.error(\"benchmark_returns must be provided for 'minimize_beta' objective.\")\n                return None\n\n            def minimize_beta(weights: np.ndarray) -> float:\n                portfolio_returns = returns.dot(weights)\n                beta = calculate_beta(portfolio_returns, benchmark_returns)\n                return beta\n\n            objective_functions.append(minimize_beta)\n        else:\n            st.error(f\"Invalid optimization objective: {obj}\")\n            return None\n\n    # Composite objective function: weighted sum of individual objectives\n    def composite_objective(weights: np.ndarray) -> float:\n        return sum(fn(weights) for fn in objective_functions)\n\n    # Define constraints\n    constraints = [\n        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},\n    ]\n\n    if target_return is not None:\n        def target_return_constraint(x: np.ndarray) -> float:\n            return np.dot(x, returns.mean()) * 252 - target_return\n        constraints.append({\n            'type': 'ineq',\n            'fun': target_return_constraint\n        })\n\n    # Define bounds for weights\n    bounds = tuple((min_weight, max_weight) for _ in range(returns.shape[1]))\n\n    # Initial guess (equally distributed weights)\n    initial_guess = np.array([1.0 / returns.shape[1]] * returns.shape[1])\n\n    # Perform optimization\n    result = minimize(\n        composite_objective,\n        initial_guess,\n        method='SLSQP',\n        bounds=bounds,\n        constraints=constraints\n    )\n\n    if result.success:\n        optimized_weights = result.x\n        portfolio_volatility = np.sqrt(np.dot(optimized_weights.T, np.dot(returns.cov() * 252, optimized_weights)))\n        portfolio_return = np.dot(returns.mean(), optimized_weights) * 252\n        sharpe_ratio_val = (portfolio_return - rf) / portfolio_volatility if portfolio_volatility > 0 else np.nan\n\n        if portfolio_volatility <= 1e-6:\n            st.error(\"Optimized portfolio has near-zero volatility. Optimization constraints may be too restrictive.\")\n            return None\n\n        # Store optimized results in session state\n        st.session_state.backtest_results['optimized_weights'] = optimized_weights\n        st.session_state.backtest_results['optimized_return'] = portfolio_return\n        st.session_state.backtest_results['optimized_volatility'] = portfolio_volatility\n        st.session_state.backtest_results['optimized_sharpe'] = sharpe_ratio_val\n\n        return optimized_weights\n    else:\n        st.error(\"Optimization failed. Try adjusting your constraints or target return.\")\n        return None\n\ndef monte_carlo_simulation(\n    returns: pd.DataFrame,\n    num_simulations: int = 1000,\n    periods: int = 252,\n    mean_returns: pd.Series = None,\n    cov_matrix: pd.DataFrame = None,\n    mean_reversion: bool = False,\n    mean_reversion_speed: float = 0.1,\n    long_term_mean: pd.Series = None,\n    time_varying_vol: bool = False,\n    vol_change_rate: float = 0.0,\n    stress_shocks: dict = None,\n    stress_period: int = None,\n    return_distribution: str = 'normal'\n) -> np.ndarray:\n    \"\"\"\n    Perform Monte Carlo simulations for portfolio returns.\n\n    Parameters:\n    - returns (pd.DataFrame): Historical returns of assets.\n    - num_simulations (int): Number of simulation paths.\n    - periods (int): Number of periods to simulate.\n    - mean_returns (pd.Series, optional): Mean returns of assets.\n    - cov_matrix (pd.DataFrame, optional): Covariance matrix of asset returns.\n    - mean_reversion (bool): If True, applies mean reversion.\n    - mean_reversion_speed (float): Speed of mean reversion.\n    - long_term_mean (pd.Series, optional): Long-term mean for mean reversion.\n    - time_varying_vol (bool): If True, allows volatility to change over time.\n    - vol_change_rate (float): Rate at which volatility changes.\n    - stress_shocks (dict, optional): Dict of shocks to apply at specified period.\n    - stress_period (int, optional): Period at which to apply stress shocks.\n    - return_distribution (str): Distribution type ('normal' or 'log-normal').\n\n    Returns:\n    - np.ndarray: Array of simulated cumulative returns.\n    \"\"\"\n    if mean_returns is None:\n        mean_returns = returns.mean()\n    if cov_matrix is None:\n        cov_matrix = returns.cov()\n\n    num_assets = returns.shape[1]\n    available_selected = returns.columns.tolist()\n\n    def simulate():\n        weights = np.random.random(num_assets)\n        weights /= np.sum(weights)\n        simulated_prices = [1]  # Initial price\n        current_mean = mean_returns.copy()\n        current_vol = np.sqrt(np.diag(cov_matrix))\n        for t in range(periods):\n            if mean_reversion and long_term_mean is not None:\n                current_mean += mean_reversion_speed * (long_term_mean - current_mean)\n            if time_varying_vol:\n                current_vol += vol_change_rate\n                current_vol = np.clip(current_vol, 0, None)  # Ensure volatility doesn't go negative\n\n            adjusted_cov_matrix = np.outer(current_vol, current_vol) * np.corrcoef(returns.T)\n            if return_distribution == 'log-normal':\n                simulated_returns = np.random.lognormal(mean=np.log(1 + current_mean), sigma=current_vol) - 1\n            else:\n                simulated_returns = np.random.multivariate_normal(current_mean, adjusted_cov_matrix)\n\n            # Apply stress shocks if applicable\n            if stress_shocks and t == stress_period:\n                for idx, ticker in enumerate(available_selected):\n                    simulated_returns[idx] += stress_shocks.get(ticker, 0)\n\n            portfolio_return = np.dot(simulated_returns, weights)\n            simulated_prices.append(simulated_prices[-1] * (1 + portfolio_return))\n        cumulative_return = simulated_prices[-1] - 1\n        return cumulative_return\n\n    portfolio_returns = Parallel(n_jobs=-1)(\n        delayed(simulate)() for _ in range(num_simulations)\n    )\n\n    return np.array(portfolio_returns)\n\n@handle_exceptions\ndef plot_efficient_frontier(returns: pd.DataFrame, num_portfolios: int = 1000, rf: float = 0.0, portfolio_name='Portfolio') -> None:\n    \"\"\"\n    Plot an enhanced Efficient Frontier with optimized portfolio marked.\n\n    Parameters:\n    - returns (pd.DataFrame): Historical returns of assets.\n    - num_portfolios (int): Number of portfolios to simulate.\n    - rf (float): Risk-free rate for Sharpe Ratio calculation.\n    - portfolio_name (str): Name of the portfolio being optimized.\n    \"\"\"\n    from scipy.optimize import minimize\n\n    num_assets = returns.shape[1]\n\n    def generate_portfolio_metrics(weights: np.ndarray) -> tuple:\n        portfolio_return = np.dot(returns.mean(), weights) * 252\n        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))\n        sharpe_ratio = (portfolio_return - rf) / portfolio_volatility if portfolio_volatility > 0 else 0\n        return portfolio_volatility, portfolio_return, sharpe_ratio\n\n    # Generate random portfolios\n    weights_list = np.random.dirichlet(np.ones(num_assets), num_portfolios)\n    portfolio_metrics = np.array([generate_portfolio_metrics(w) for w in weights_list])\n\n    # Filter out invalid portfolios\n    portfolio_metrics = portfolio_metrics[~np.isnan(portfolio_metrics).any(axis=1)]\n\n    if portfolio_metrics.size == 0:\n        st.warning(\"No valid portfolios to plot on the Efficient Frontier.\")\n        return\n\n    ef_df = pd.DataFrame({\n        'Std Dev': portfolio_metrics[:, 0],\n        'Return': portfolio_metrics[:, 1],\n        'Sharpe Ratio': portfolio_metrics[:, 2]\n    })\n    fig = px.scatter(\n        ef_df,\n        x='Std Dev',\n        y='Return',\n        color='Sharpe Ratio',\n        color_continuous_scale='Turbo',\n        title='\ud83d\udcc8 Efficient Frontier',\n        labels={\n            'Std Dev': 'Annualized Volatility (Std Dev)',\n            'Return': 'Annualized Return (%)',\n            'Sharpe Ratio': 'Sharpe Ratio'\n        },\n        hover_data={\n            'Sharpe Ratio': ':.2f',\n            'Std Dev': ':.2f',\n            'Return': ':.2f'\n        },\n        template=THEME\n    )\n\n    # Highlight the portfolio with the maximum Sharpe ratio\n    max_sharpe_idx = ef_df['Sharpe Ratio'].idxmax()\n    max_sharpe = ef_df.loc[max_sharpe_idx]\n    fig.add_trace(go.Scatter(\n        x=[max_sharpe['Std Dev']],\n        y=[max_sharpe['Return']],\n        mode='markers+text',\n        marker=dict(color='gold', size=12, symbol='star'),\n        name='Max Sharpe Ratio',\n        text=[\"Max Sharpe\"],\n        textposition=\"top center\",\n        hoverinfo='text'\n    ))\n    fig.add_annotation(\n        x=max_sharpe['Std Dev'],\n        y=max_sharpe['Return'],\n        text=\"Max Sharpe\",\n        showarrow=True,\n        arrowhead=1,\n        ax=0,\n        ay=-40\n    )\n\n    # Add optimized portfolio if available\n    optimized_weights = st.session_state.backtest_results.get('optimized_weights', None)\n    optimized_return = st.session_state.backtest_results.get('optimized_return', None)\n    optimized_volatility = st.session_state.backtest_results.get('optimized_volatility', None)\n    optimized_sharpe = st.session_state.backtest_results.get('optimized_sharpe', None)\n\n    if all(v is not None for v in [optimized_weights, optimized_return, optimized_volatility, optimized_sharpe]):\n        if optimized_volatility > 1e-6 and np.isfinite(optimized_sharpe):\n            fig.add_trace(go.Scatter(\n                x=[optimized_volatility],\n                y=[optimized_return],\n                mode='markers+text',\n                marker=dict(color='red', size=16, symbol='diamond'),\n                name=f'{portfolio_name} Optimized',\n                text=[\"Optimized\"],\n                textposition=\"top center\",\n                hoverinfo='text'\n            ))\n            fig.add_annotation(\n                x=optimized_volatility,\n                y=optimized_return,\n                text=\"Optimized\",\n                showarrow=True,\n                arrowhead=2,\n                ax=0,\n                ay=-50\n            )\n\n    fig.update_layout(\n        hovermode=HOVERMODE,\n        xaxis=dict(showgrid=True, title=dict(text='Annualized Volatility (Std Dev)')),\n        yaxis=dict(showgrid=True, title=dict(text='Annualized Return (%)')),\n        legend=dict(title=\"Portfolio\", x=0.01, y=0.99)\n    )\n    fig.update_traces(marker=dict(line=dict(width=1, color='DarkSlateGrey')), selector=dict(mode='markers'))\n    st.plotly_chart(fig, use_container_width=True, config={'responsive': True, 'scrollZoom': True})\n\n@handle_exceptions\ndef generate_portfolio(returns: pd.DataFrame, rf: float = 0.0) -> tuple:\n    \"\"\"\n    Generate a random portfolio and calculate its metrics.\n\n    Parameters:\n    - returns (pd.DataFrame): Historical returns of assets.\n    - rf (float): Risk-free rate for Sharpe Ratio calculation.\n\n    Returns:\n    - tuple: (volatility: float, return: float, sharpe_ratio: float)\n    \"\"\"\n    try:\n        weights = np.random.dirichlet(np.ones(returns.shape[1]))\n        portfolio_return = np.dot(returns.mean(), weights) * 252\n        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))\n        sharpe_ratio = (portfolio_return - rf) / portfolio_volatility if portfolio_volatility > 0 else 0\n        return portfolio_volatility, portfolio_return, sharpe_ratio\n    except Exception as e:\n        st.error(f\"Error generating portfolio: {e}\")\n        return np.nan, np.nan, np.nan  # Return NaNs to indicate failure\n\ndef plot_allocation_pie(weights: list, assets: list, title: str = '\ud83e\udd67 Portfolio Allocation', hover_info: str = \"percent+name\") -> None:\n    \"\"\"Plots the portfolio allocation pie chart.\"\"\"\n    allocation_df = pd.DataFrame({\n        'Asset': assets,\n        'Weight': weights\n    })\n\n    # Default to showing both percent and name in hover\n    hover_data = ['Weight'] if hover_info == \"percent+name\" else (\n        [] if hover_info == \"name\" else ['Weight']\n    )\n\n    fig = px.pie(\n        allocation_df,\n        names='Asset',\n        values='Weight',\n        title=title,\n        color='Asset',\n        color_discrete_sequence=px.colors.qualitative.Pastel,\n        hover_data=hover_data,\n        hole=0.3  # Donut chart appearance\n    )\n    \n    fig.update_traces(textposition='inside', textinfo='percent+label')\n    fig.update_layout(\n        uniformtext_minsize=12,\n        uniformtext_mode='hide',\n        legend_title=\"Assets\",\n        showlegend=True,\n        height=FIG_HEIGHT\n    )\n    \n    st.plotly_chart(fig, use_container_width=True, height=600, config={'responsive': True})\n\ndef plot_rolling_cagr(cum_returns: pd.Series, window: int = 252) -> None:\n    \"\"\"\n    Plot Rolling CAGR over a specified window.\n\n    Parameters:\n    - cum_returns (pd.Series): Cumulative returns of the portfolio.\n    - window (int): Window size for rolling CAGR calculation.\n    \"\"\"\n    try:\n        rolling_years = window / 252  # Assuming daily data\n        rolling_cagr = (cum_returns / cum_returns.shift(window)) ** (1 / rolling_years) - 1\n        fig = px.line(\n            rolling_cagr.dropna(),\n            title=f'Rolling {int(rolling_years)}-Year CAGR',\n            labels={'index': 'Date', 'value': 'Rolling CAGR'},\n            template=THEME\n        )\n        st.plotly_chart(fig, use_container_width=True)\n    except Exception as e:\n        st.error(f\"Error plotting rolling CAGR: {e}\")\n\n@handle_exceptions\ndef plot_rolling_metrics(returns: pd.Series, windows: list = [30, 90, 180, 252]) -> None:\n    \"\"\"\n    Plot rolling metrics (Volatility and Sharpe Ratio) over multiple windows.\n\n    Parameters:\n    - returns (pd.Series): Daily returns of the portfolio.\n    - windows (list): List of window sizes for rolling calculations.\n    \"\"\"\n    metrics = {}\n    for window in windows:\n        rolling_return = returns.rolling(window).mean() * 252\n        rolling_vol = returns.rolling(window).std() * np.sqrt(252)\n        rolling_sharpe = (rolling_return - 0.02) / rolling_vol\n        metrics[f'Rolling {window}-Day Volatility'] = rolling_vol\n        metrics[f'Rolling {window}-Day Sharpe Ratio'] = rolling_sharpe\n    fig = go.Figure()\n    for metric_name, metric_series in metrics.items():\n        fig.add_trace(go.Scatter(x=metric_series.index, y=metric_series, mode='lines', name=metric_name))\n    fig.update_layout(\n        title='Rolling Metrics Over User-Defined Periods',\n        xaxis_title='Date',\n        yaxis_title='Value',\n        hovermode='x unified',\n        template=THEME\n    )\n    st.plotly_chart(fig, use_container_width=True)\n\n@handle_exceptions\ndef plot_risk_return_attribution(returns: pd.Series, weights: list) -> None:\n    \"\"\"\n    Plot Risk-Return Attribution for the portfolio.\n\n    Parameters:\n    - returns (pd.Series or pd.DataFrame): Returns of assets.\n    - weights (list): Allocation weights for each asset.\n    \"\"\"\n    try:\n        if isinstance(returns, pd.Series):\n            asset_returns = returns.mean() * 252\n            asset_volatility = returns.std() * np.sqrt(252)\n            asset_contribution = weights[0] * asset_volatility if len(weights) > 0 else 0\n            hover_names = [returns.name] if returns.name else ['Asset']\n            x = [asset_volatility]\n            y = [asset_returns]\n            size = [asset_contribution]\n            color = [weights[0]]\n        else:\n            asset_returns = returns.mean() * 252\n            asset_volatility = returns.std() * np.sqrt(252)\n            asset_contribution = np.array(weights) * asset_volatility\n            hover_names = returns.columns.tolist()\n            x = asset_volatility.values\n            y = asset_returns.values\n            size = asset_contribution\n            color = weights\n\n        fig = px.scatter(\n            x=x,\n            y=y,\n            size=size,\n            color=color,\n            hover_name=hover_names,\n            title='Risk-Return Attribution',\n            labels={'x': 'Annualized Volatility', 'y': 'Annualized Return', 'color': 'Weight (%)'},\n            size_max=60,\n            color_continuous_scale='Viridis'\n        )\n        fig.update_layout(template='plotly_dark')\n        st.plotly_chart(fig, use_container_width=True)\n    except Exception as e:\n        st.error(f\"Error plotting risk-return attribution: {e}\")\n\ndef plot_var_cvar_distribution(portfolio_returns: np.ndarray, var: float, cvar: float) -> None:\n    \"\"\"\n    Plot the distribution of portfolio returns with VaR and CVaR lines.\n\n    Parameters:\n    - portfolio_returns (np.ndarray): Simulated portfolio returns.\n    - var (float): Value at Risk.\n    - cvar (float): Conditional Value at Risk.\n    \"\"\"\n    fig = px.histogram(portfolio_returns, nbins=50, title='Returns Distribution with VaR and CVaR',\n                       labels={'value': 'Returns', 'count': 'Frequency'})\n    fig.add_vline(x=var, line_dash=\"dash\", line_color=\"red\", annotation_text=f\"VaR: {var:.2f}\", annotation_position=\"top left\")\n    fig.add_vline(x=cvar, line_dash=\"dash\", line_color=\"blue\", annotation_text=f\"CVaR: {cvar:.2f}\", annotation_position=\"top left\")\n    st.plotly_chart(fig, use_container_width=True)\n\ndef plot_var_cvar_over_time(portfolio_returns: pd.Series, var: float, cvar: float) -> None:\n    \"\"\"\n    Plot cumulative returns with VaR and CVaR over time.\n\n    Parameters:\n    - portfolio_returns (pd.Series): Daily returns of the portfolio.\n    - var (float): Value at Risk.\n    - cvar (float): Conditional Value at Risk.\n    \"\"\"\n    cumulative_returns = (1 + portfolio_returns).cumprod()\n    fig = px.line(cumulative_returns, title='Cumulative Returns with VaR and CVaR Over Time', labels={'value': 'Cumulative Returns', 'index': 'Date'})\n    fig.add_hline(y=var, line_dash=\"dash\", line_color=\"red\", annotation_text=f\"VaR: {var:.2f}\", annotation_position=\"bottom right\")\n    fig.add_hline(y=cvar, line_dash=\"dash\", line_color=\"blue\", annotation_text=f\"CVaR: {cvar:.2f}\", annotation_position=\"bottom right\")\n    st.plotly_chart(fig, use_container_width=True)\n\ndef calculate_var(returns: np.ndarray, confidence_level: float = 0.95) -> float:\n    \"\"\"\n    Calculate Value at Risk (VaR) for a given set of returns.\n\n    Parameters:\n    - returns (np.ndarray): Portfolio returns.\n    - confidence_level (float): Confidence level for VaR.\n\n    Returns:\n    - float: VaR value.\n    \"\"\"\n    return np.percentile(returns, 100 * (1 - confidence_level))\n\ndef calculate_cvar(returns: np.ndarray, confidence_level: float = 0.95) -> float:\n    \"\"\"\n    Calculate Conditional Value at Risk (CVaR) for a given set of returns.\n\n    Parameters:\n    - returns (np.ndarray): Portfolio returns.\n    - confidence_level (float): Confidence level for CVaR.\n\n    Returns:\n    - float: CVaR value.\n    \"\"\"\n    var = calculate_var(returns, confidence_level)\n    return returns[returns <= var].mean()\n\n# ----------------------------\n# Caching Functions\n# ----------------------------\n\n@st.cache_data(show_spinner=False, persist=True)\ndef get_tickers() -> pd.DataFrame:\n    \"\"\"\n    Fetch and combine S&P 500 and NASDAQ-100 tickers from Wikipedia.\n\n    Returns:\n    - pd.DataFrame: DataFrame containing combined tickers and company names.\n    \"\"\"\n    try:\n        # Fetch S&P 500 companies\n        sp500_url = 'https://en.wikipedia.org/wiki/List_of_S%26P_500_companies'\n        sp500_response = requests.get(sp500_url, verify=False)\n        sp500_table = pd.read_html(sp500_response.text)[0]\n        sp500 = sp500_table[['Symbol', 'Security']].rename(columns={'Symbol': 'Ticker', 'Security': 'Company Name'})\n        sp500['Ticker'] = sp500['Ticker'].str.replace('.', '-', regex=False)\n\n        # Fetch NASDAQ-100 companies\n        nasdaq100_url = 'https://en.wikipedia.org/wiki/NASDAQ-100'\n        nasdaq100_response = requests.get(nasdaq100_url, verify=False)\n        nasdaq100_tables = pd.read_html(nasdaq100_response.text)\n\n        nasdaq100 = pd.DataFrame()\n        for table in nasdaq100_tables:\n            if 'Ticker' in table.columns and 'Company' in table.columns:\n                nasdaq100 = table[['Ticker', 'Company']].rename(columns={'Ticker': 'Ticker', 'Company': 'Company Name'})\n                nasdaq100['Ticker'] = nasdaq100['Ticker'].str.replace('.', '-', regex=False)\n                break\n\n        combined = pd.concat([sp500, nasdaq100], ignore_index=True)\n        combined = combined.drop_duplicates(subset=['Ticker'])\n        return combined.sort_values('Ticker').reset_index(drop=True)\n    except Exception as e:\n        st.error(f\"Error fetching tickers: {e}\")\n        return pd.DataFrame(columns=['Ticker', 'Company Name'])\n\n@st.cache_data(show_spinner=False, persist=True)\ndef download_data(tickers: list, start: str, end: str, retries: int = 3, backoff_factor: float = 0.3) -> pd.DataFrame:\n    \"\"\"\n    Download historical adjusted closing prices for specified tickers.\n\n    Parameters:\n    - tickers (list): List of ticker symbols.\n    - start (str): Start date in 'YYYY-MM-DD' format.\n    - end (str): End date in 'YYYY-MM-DD' format.\n    - retries (int): Number of retries for failed requests.\n    - backoff_factor (float): Backoff factor for retries.\n\n    Returns:\n    - pd.DataFrame: DataFrame containing adjusted closing prices.\n    \"\"\"\n    try:\n        # Configure retry strategy for requests (used by yfinance internally)\n        session = requests.Session()\n        retry = Retry(\n            total=retries,\n            read=retries,\n            connect=retries,\n            backoff_factor=backoff_factor,\n            status_forcelist=(500, 502, 504),\n        )\n        adapter = HTTPAdapter(max_retries=retry)\n        session.mount('http://', adapter)\n        session.mount('https://', adapter)\n\n        # Attempt to download data\n        data = yf.download(tickers, start=start, end=end, progress=False, session=session)['Adj Close']\n\n        # Handle potential empty data\n        if isinstance(data, pd.Series):\n            data = data.to_frame()\n        if data.empty:\n            st.warning(\"No price data available for the selected portfolio. Please check the ticker symbols and date range.\")\n            return pd.DataFrame()\n        if data.index.tz is not None:\n            data.index = data.index.tz_localize(None)\n\n        # Fill missing data\n        data = data.fillna(method='ffill').fillna(method='bfill')\n        if data.isnull().values.any():\n            st.warning(\"Data contains missing values after filling. Some calculations may be affected.\")\n        return data\n    except Exception as e:\n        st.error(f\"Error downloading data: {e}\")\n        return pd.DataFrame()\n\ndef calculate_metrics(\n    returns: pd.Series, \n    cum_returns: pd.Series, \n    rf: float = 0.02, \n    benchmark_returns: pd.Series = None\n) -> dict:\n    \"\"\"\n    Calculate comprehensive portfolio metrics, optionally relative to a benchmark.\n\n    Parameters:\n    - returns (pd.Series): Portfolio returns.\n    - cum_returns (pd.Series): Cumulative returns of the portfolio.\n    - rf (float): Risk-free rate.\n    - benchmark_returns (pd.Series, optional): Benchmark returns.\n\n    Returns:\n    - dict: Dictionary of calculated metrics.\n    \"\"\"\n    metrics = {}\n    metrics['Start Balance'] = \"$10,000.00\"\n    if not cum_returns.empty:\n        end_balance = 10000 * cum_returns.iloc[-1]\n        years = (cum_returns.index[-1] - cum_returns.index[0]).days / 365.25\n        cagr = (end_balance / 10000) ** (1 / years) - 1 if years > 0 else np.nan\n        metrics.update({\n            'End Balance': f\"${end_balance:,.2f}\",\n            'Annualized Return (CAGR)': f\"{cagr * 100:.2f}%\" if not np.isnan(cagr) else \"N/A\",\n            'Best Year': f\"{returns.resample('Y').apply(lambda x: (1 + x).prod() - 1).max() * 100:.2f}%\" if not returns.empty else \"N/A\",\n            'Worst Year': f\"{returns.resample('Y').apply(lambda x: (1 + x).prod() - 1).min() * 100:.2f}%\" if not returns.empty else \"N/A\",\n            'Arithmetic Mean (Monthly)': f\"{returns.mean() * 100:.2f}%\",\n            'Arithmetic Mean (Annualized)': f\"{returns.mean() * 252 * 100:.2f}%\",\n            'Geometric Mean (Monthly)': f\"{(np.exp(np.log1p(returns).mean()) - 1) * 100:.2f}%\",\n            'Geometric Mean (Annualized)': f\"{(np.exp(np.log1p(returns).mean() * 252) - 1) * 100:.2f}%\",\n            'Standard Deviation (Monthly)': f\"{returns.std() * 100:.2f}%\",\n            'Standard Deviation (Annualized)': f\"{returns.std() * np.sqrt(252) * 100:.2f}%\",\n            'Downside Deviation (Monthly)': f\"{returns[returns < 0].std() * 100:.2f}%\",\n            'Maximum Drawdown': f\"{drawdown(cum_returns) * 100:.2f}%\" if not cum_returns.empty else \"N/A\",\n            'Sharpe Ratio': f\"{calculate_sharpe_ratio(returns, rf):.2f}\" if not cum_returns.empty else \"N/A\",\n            'Sortino Ratio': f\"{calculate_sortino_ratio(returns, rf):.2f}\" if not cum_returns.empty else \"N/A\",\n            'Gain/Loss Ratio': f\"{calculate_gain_loss_ratio(returns):.2f}\" if not cum_returns.empty else \"N/A\",\n            'Skewness': f\"{skew(returns):.2f}\" if not returns.empty else \"N/A\",\n            'Excess Kurtosis': f\"{kurtosis(returns):.2f}\" if not returns.empty else \"N/A\",\n            'Safe Withdrawal Rate': f\"{calculate_safe_withdrawal_rate(returns):.6f}%\" if not returns.empty else \"N/A\",\n            'Perpetual Withdrawal Rate': f\"{calculate_perpetual_withdrawal_rate(returns):.6f}%\" if not returns.empty else \"N/A\",\n            'Positive Periods': calculate_positive_periods(returns) if not returns.empty else \"N/A\"\n        })\n    else:\n        # Assign \"N/A\" to all metrics if cum_returns is empty\n        metrics.update({\n            'End Balance': \"N/A\",\n            'Annualized Return (CAGR)': \"N/A\",\n            # ... all other metrics set to \"N/A\"\n        })\n    \n    if benchmark_returns is not None and not benchmark_returns.empty:\n        correlation = returns.corr(benchmark_returns)\n        beta = calculate_beta(returns, benchmark_returns)\n        alpha = calculate_alpha(returns, benchmark_returns, rf)\n        r2 = calculate_r_squared(returns, benchmark_returns)\n        treynor = calculate_treynor_ratio(returns, benchmark_returns, rf)\n        calmar = calculate_calmar_ratio(returns, cum_returns)\n        m2 = calculate_modigliani_miller(returns, benchmark_returns, rf)\n        info_ratio = calculate_information_ratio(returns, benchmark_returns)\n        tracking_error = calculate_tracking_error(returns, benchmark_returns)\n        active_return = calculate_active_return(returns, benchmark_returns)\n        upside_capture = calculate_capture_ratio(returns, benchmark_returns, upside=True)\n        downside_capture = calculate_capture_ratio(returns, benchmark_returns, upside=False)\n        \n        metrics.update({\n            'Benchmark Correlation': f\"{correlation:.2f}\" if not np.isnan(correlation) else \"N/A\",\n            'Beta': f\"{beta:.2f}\" if not np.isnan(beta) else \"N/A\",\n            'Alpha (annualized)': f\"{alpha * 100:.2f}%\" if not np.isnan(alpha) else \"N/A\",\n            'R2': f\"{r2 * 100:.2f}%\" if not np.isnan(r2) else \"N/A\",\n            'Treynor Ratio': f\"{treynor:.2f}\" if not np.isnan(treynor) else \"N/A\",\n            'Calmar Ratio': f\"{calmar:.2f}\" if not np.isnan(calmar) else \"N/A\",\n            'Modigliani\u2013Modigliani Measure': f\"{m2 * 100:.2f}%\" if not np.isnan(m2) else \"N/A\",\n            'Information Ratio': f\"{info_ratio:.2f}\" if not np.isnan(info_ratio) else \"N/A\",\n            'Tracking Error': f\"{tracking_error * 100:.2f}%\" if not np.isnan(tracking_error) else \"N/A\",\n            'Active Return': f\"{active_return:.2f}%\" if not np.isnan(active_return) else \"N/A\",\n            'Upside Capture Ratio': f\"{upside_capture:.2f}%\" if not np.isnan(upside_capture) else \"N/A\",\n            'Downside Capture Ratio': f\"{downside_capture:.2f}%\" if not np.isnan(downside_capture) else \"N/A\"\n        })\n    else:\n        # Assign \"N/A\" to all benchmark metrics\n        metrics.update({\n            'Benchmark Correlation': \"N/A\",\n            'Beta': \"N/A\",\n            'Alpha (annualized)': \"N/A\",\n            'R2': \"N/A\",\n            'Treynor Ratio': \"N/A\",\n            'Calmar Ratio': \"N/A\",\n            'Modigliani\u2013Modigliani Measure': \"N/A\",\n            'Information Ratio': \"N/A\",\n            'Tracking Error': \"N/A\",\n            'Active Return': \"N/A\",\n            'Upside Capture Ratio': \"N/A\",\n            'Downside Capture Ratio': \"N/A\"\n        })\n    \n    return metrics\n\n# ----------------------------\n# Additional Helper Functions\n# ----------------------------\n\n@handle_exceptions\ndef plot_efficient_frontier_comparison(\n    simulated_metrics: pd.DataFrame,\n    optimized_metrics: tuple\n) -> None:\n    \"\"\"\n    Plot Efficient Frontier and mark the optimized portfolio.\n\n    Parameters:\n    - simulated_metrics (pd.DataFrame): Simulated portfolio metrics.\n    - optimized_metrics (tuple): Metrics of the optimized portfolio.\n    \"\"\"\n    if simulated_metrics.empty:\n        st.warning(\"No simulated metrics available to plot.\")\n        return\n\n    fig = px.scatter(\n        simulated_metrics,\n        x='Std Dev',\n        y='Return',\n        color='Sharpe Ratio',\n        color_continuous_scale='Viridis',\n        title='Efficient Frontier',\n        labels={\n            'Std Dev': 'Annualized Volatility (Std Dev)',\n            'Return': 'Annualized Return',\n            'Sharpe Ratio': 'Sharpe Ratio'\n        },\n        hover_data={\n            'Sharpe Ratio': ':.2f',\n            'Std Dev': ':.2f',\n            'Return': ':.2f'\n        },\n        template=THEME\n    )\n\n    # Add optimized portfolio if available\n    if optimized_metrics:\n        vol, ret, sharpe = optimized_metrics\n        if vol > 0 and np.isfinite(sharpe):\n            fig.add_trace(go.Scatter(\n                x=[vol],\n                y=[ret],\n                mode='markers+text',\n                marker=dict(color='red', size=14, symbol='star'),\n                name='Optimized Portfolio',\n                text=[\"Optimized\"],\n                textposition=\"top center\",\n                hoverinfo='text'\n            ))\n            fig.add_annotation(\n                x=vol,\n                y=ret,\n                text=\"Optimized\",\n                showarrow=True,\n                arrowhead=2,\n                ax=0,\n                ay=-40\n            )\n\n    fig.update_layout(\n        hovermode='x unified',\n        xaxis=dict(rangeslider=dict(visible=True), type='linear'),\n    )\n    st.plotly_chart(fig, use_container_width=True, config={\n        'responsive': True,\n        'scrollZoom': True,\n        'displayModeBar': True\n    })\n\n# ----------------------------\n# End of Helper Functions\n# ----------------------------\n\n# ----------------------------\n# Streamlit Layout\n# ----------------------------\nst.set_page_config(page_title=\"\ud83c\udfaf Portfolio Optimizer\", layout=\"wide\")\n\n# Display loading spinner\nwith st.spinner(\"\ud83c\udfaf Portfolio Optimizer is loading, please be patient...\"):\n    # Simulate loading delay if necessary\n    pass\n\nnav_steps = [\n    {\"name\": \"Configure Portfolio\", \"icon\": \"\ud83d\udcc1\"},\n    {\"name\": \"Run Backtest\", \"icon\": \"\ud83d\udcca\"},\n    {\"name\": \"Optimize Portfolio\", \"icon\": \"\ud83d\udd27\"},\n    {\"name\": \"Monte Carlo Simulations\", \"icon\": \"\ud83d\udcc8\"},\n    {\"name\": \"Risk Analysis\", \"icon\": \"\u26a0\ufe0f\"}\n]\n\nwith st.sidebar:\n    st.header(\"\ud83d\udcc2 Navigation\")\n    # Create a list of (label, value) tuples for radio buttons\n    nav_options = [(f\"{step['icon']} {step['name']}\", step['name']) for step in nav_steps]\n    labels, values = zip(*nav_options)\n    \n    # Use radio buttons for direct navigation with a callback\n    def set_step():\n        selected_label = st.session_state.nav_radio  # Access the selected label from session_state\n        selected_idx = labels.index(selected_label)\n        st.session_state.step = values[selected_idx]\n    \n    selected_label = st.radio(\"Select a Step:\", options=labels, key=\"nav_radio\", on_change=set_step)\n\ncurrent_step = st.session_state.step\n\ntickers = get_tickers()\n# Define asset_options by formatting ticker symbols with company names\nasset_options = tickers.apply(\n    lambda row: format_asset_option(row['Ticker'], row['Company Name']), \n    axis=1\n).tolist()\n\nif current_step == \"Configure Portfolio\":\n    st.title(\"\ud83c\udfaf Portfolio Optimizer\")\n    \n    # Initialize show_proceed in session state\n    if 'show_proceed' not in st.session_state:\n        st.session_state.show_proceed = False\n        \n    # Define callback function to hide welcome message\n    def hide_welcome():\n        st.session_state.show_proceed = True\n        st.session_state.selected_subtab = \"\u2795 Create New Portfolio\"  # Set default tab\n\n    # Display onboarding message and button if not proceeded\n    if not st.session_state.show_proceed:\n        st.info(\"Welcome! Let's get you started with your first portfolio.\")\n        st.write(\"\"\"\n            1. **Configure your portfolio** by entering a name, start date, end date, and other details.\n            2. **Select the assets** you want to include and set their allocations.\n            3. **Run a backtest** to see how your portfolio performs.\n            4. **Compare your portfolio** with a benchmark or another portfolio.\n            5. **Explore the performance metrics** and visualizations.\n        \"\"\")\n        st.button(\"Got U, Let's Explore\", key=\"explore_button\", on_click=hide_welcome)\n    \n    # Show portfolio management interface if proceeded\n    elif st.session_state.show_proceed:\n        # Show existing portfolios if any\n        if st.session_state.portfolios:\n            st.subheader(\"\ud83d\udcc1 Manage Existing Portfolios\")\n            portfolio_names = [p['name'] for p in st.session_state.portfolios]\n            selected_portfolio = st.selectbox(\"\ud83d\udd0d Select a Portfolio\", portfolio_names, key=\"select_portfolio\")\n            \n            if selected_portfolio:\n                portfolio = next(p for p in st.session_state.portfolios if p['name'] == selected_portfolio)\n                \n                with st.expander(f\"\u2139\ufe0f Details for **{selected_portfolio}**\"):\n                    st.write(f\"**Start Date:** {portfolio['start_date'].strftime('%Y-%m-%d')}\")\n                    st.write(f\"**End Date:** {portfolio['end_date'].strftime('%Y-%m-%d')}\")\n                    st.write(f\"**Benchmark:** {portfolio['benchmark_symbol']}\")\n                    st.write(f\"**Rebalance Frequency:** {rebalance_freq_inverse_mapping.get(portfolio['rebalance_freq'], portfolio['rebalance_freq'])}\")\n                    st.write(\"**Allocations:**\")\n                    allocation_df = pd.DataFrame({\n                        'Ticker': portfolio['selected'],\n                        'Allocation (%)': portfolio['allocations']\n                    })\n                    st.table(allocation_df)\n                \n                # Action Buttons with Icons\n                action_col1, action_col2, action_col3 = st.columns(3)\n                \n                with action_col1:\n                    if st.button(f\"\ud83d\uddd1\ufe0f Delete {selected_portfolio}\", key=f\"delete_{selected_portfolio}\"):\n                        st.session_state.portfolios = [p for p in st.session_state.portfolios if p['name'] != selected_portfolio]\n                        st.success(f\"\u2705 Portfolio '{selected_portfolio}' deleted successfully.\")\n                        st.rerun()\n                \n                with action_col2:\n                    if st.button(f\"\u270f\ufe0f Edit {selected_portfolio}\", key=f\"edit_{selected_portfolio}\"):\n                        st.session_state.edit_portfolio = selected_portfolio\n                        st.rerun()\n                \n                with action_col3:\n                    if st.button(f\"\ud83d\udcc4 Duplicate {selected_portfolio}\", key=f\"duplicate_{selected_portfolio}\"):\n                        duplicated_portfolio = portfolio.copy()\n                        duplicated_portfolio['name'] = f\"{selected_portfolio}_Copy\"\n                        # Ensure the new name is unique\n                        if duplicated_portfolio['name'] in portfolio_names:\n                            counter = 1\n                            while f\"{selected_portfolio}_Copy{counter}\" in portfolio_names:\n                                counter += 1\n                            duplicated_portfolio['name'] = f\"{selected_portfolio}_Copy{counter}\"\n                        st.session_state.portfolios.append(duplicated_portfolio)\n                        st.success(f\"\ud83c\udf89 Portfolio '{duplicated_portfolio['name']}' duplicated successfully!\")\n                        st.rerun()\n        \n        st.markdown(\"---\")  # Separator line for clarity\n        \n        tabs_labels = [\"\u2795 Create New Portfolio\"]\n        tabs_portfolio = st.tabs(tabs_labels)\n\n        # Determine which tab to select based on session state\n        selected_idx = 0  # Default to first tab\n        if 'selected_subtab' not in st.session_state:\n            st.session_state.selected_subtab = tabs_labels[0]\n\n        with tabs_portfolio[selected_idx]:\n            if selected_idx == 0:\n                # Create New Portfolio Content\n                st.subheader(\"\u2795 Create a New Portfolio\" if not st.session_state.edit_portfolio else f\"\u270f\ufe0f Edit Portfolio: {st.session_state.edit_portfolio}\")\n\n                if st.session_state.edit_portfolio:\n                    # Fetch the portfolio to be edited\n                    portfolio_to_edit = next((p for p in st.session_state.portfolios if p['name'] == st.session_state.edit_portfolio), None)\n                    if portfolio_to_edit:\n                        # Pre-populate the form with existing data\n                        name = st.text_input(\"\ud83d\udcdb Portfolio Name\", value=portfolio_to_edit['name'], help=\"Enter a unique name for your portfolio.\")\n                        start_date_input = st.date_input(\n                            \"\ud83d\udcc5 Start Date:\",\n                            value=portfolio_to_edit['start_date'],\n                            min_value=datetime(1900, 1, 1),\n                            help=\"Choose the start date for backtesting.\"\n                        )\n                        end_date_input = st.date_input(\n                            \"\ud83d\udcc5 End Date:\",\n                            value=portfolio_to_edit['end_date'],\n                            min_value=datetime(1900, 1, 1),\n                            help=\"Choose the end date for backtesting.\"\n                        )\n                        rf_rate = st.number_input(\n                            \"\ud83d\udcc8 Risk-Free Rate (%)\",\n                            min_value=0.0,\n                            max_value=10.0,\n                            value=portfolio_to_edit['rf_rate'] * 100,\n                            format=\"%.2f\",\n                            help=\"Enter the risk-free rate as a percentage.\"\n                        ) / 100\n                        broker_fee = st.number_input(\n                            \"\ud83d\udcb8 Broker Fee (%)\",\n                            min_value=0.0,\n                            max_value=10.0,\n                            value=portfolio_to_edit['broker_fee'] * 100,\n                            step=0.0001,\n                            format=\"%.4f\",\n                            help=\"Enter the broker fee as a percentage per transaction.\"\n                        ) / 100\n                        selected_assets_new = [f\"{ticker} - {tickers[tickers['Ticker'] == ticker]['Company Name'].values[0]}\" for ticker in portfolio_to_edit['selected']]\n                    else:\n                        st.error(\"\u2705 No portfolio found to edit.\")\n                        st.stop()\n                else:\n                    # Default empty form for creating a new portfolio\n                    name = st.text_input(\"\ud83d\udcdb Portfolio Name\", help=\"Enter a unique name for your portfolio.\")\n                    start_date_input, end_date_input = st.columns(2)\n                    with start_date_input:\n                        start_date_input = st.date_input(\n                            \"\ud83d\udcc5 Start Date:\",\n                            value=datetime.today() - timedelta(days=365 * 15),\n                            min_value=datetime(1900, 1, 1),\n                            help=\"Choose the start date for backtesting.\"\n                        )\n                    with end_date_input:\n                        end_date_input = st.date_input(\n                            \"\ud83d\udcc5 End Date:\",\n                            value=datetime.today(),\n                            min_value=datetime(1900, 1, 1),\n                            help=\"Choose the end date for backtesting.\"\n                        )\n                    \n                    st.markdown(\"#### \ud83d\udcb0 Financial Settings\")\n                    rf_rate = st.number_input(\n                        \"\ud83d\udcc8 Risk-Free Rate (%)\",\n                        min_value=0.0,\n                        max_value=10.0,\n                        value=st.session_state.default_config['rf_rate'] * 100,\n                        format=\"%.2f\",\n                        help=\"Enter the risk-free rate as a percentage.\"\n                    ) / 100\n                    broker_fee = st.number_input(\n                        \"\ud83d\udcb8 Broker Fee (%)\",\n                        min_value=0.0,\n                        max_value=10.0,\n                        value=st.session_state.default_config['broker_fee'] * 100,\n                        step=0.0001,\n                        format=\"%.4f\",\n                        help=\"Enter the broker fee as a percentage per transaction.\"\n                    ) / 100\n                    # New Portfolio Form\n                    st.markdown(\"#### \ud83d\udce6 Asset Allocation\")  \n                    # Use the defined asset_options here\n                    selected_assets_new = st.multiselect(\n                        \"\ud83d\uddc2\ufe0f Select Assets:\",\n                        options=asset_options,  # Now defined\n                        default=[],\n                        help=\"Choose the assets you want to include in your portfolio.\"\n                        )\n                \n                selected_tickers_new = [option.split(' - ')[0] for option in selected_assets_new if ' - ' in option]\n                \n                if selected_tickers_new:\n                    # Create a DataFrame for allocations\n                    allocation_df = pd.DataFrame({\n                        'Ticker': selected_tickers_new,\n                        'Allocation (%)': [0.0] * len(selected_tickers_new)\n                    })\n                    \n                    st.markdown(\"**Set Allocation Percentages:**\")\n                    for idx, ticker in enumerate(selected_tickers_new):\n                        allocation_df.at[idx, 'Allocation (%)'] = st.number_input(\n                            f\"\ud83d\udcca {ticker} Allocation (%)\",\n                            min_value=0.0,\n                            max_value=100.0,\n                            value=allocation_df.at[idx, 'Allocation (%)'],\n                            step=0.1,\n                            format=\"%.2f\",\n                            key=f\"alloc_new_{ticker}\",\n                            help=f\"Set the allocation percentage for {ticker}. The sum of all allocations must equal 100%.\"\n                        )\n                    \n                    total_allocation_new = allocation_df['Allocation (%)'].sum()\n                    st.markdown(f\"**\ud83e\uddee Total Allocation:** {total_allocation_new:.2f}%\")\n                    \n                    if not np.isclose(total_allocation_new, 100.0, atol=1e-2):\n                        st.warning(\"\u26a0\ufe0f Allocations must sum to 100%. Please adjust the allocations.\")\n                    \n                    # Display Allocation Table\n                    st.table(allocation_df)\n                else:\n                    st.info(\"\ud83e\uddd0 Select assets to allocate your portfolio.\")\n                    \n                    st.markdown(\"#### \ud83c\udfe6 Benchmark Selection\")\n                    benchmark_options = get_common_benchmarks(selected_tickers_new)\n                    selected_benchmark = st.selectbox(\n                        \"\ud83c\udfe6 Select Benchmark\",\n                        options=list(benchmark_options.keys()),\n                        help=\"Choose a benchmark that aligns with your portfolio's asset composition.\"\n                    )\n\n                    # Initialize custom benchmark symbol\n                    if selected_benchmark == \"Custom\":\n                        custom_benchmark = st.text_input(\n                            \"\u270f\ufe0f Enter Custom Benchmark Symbol\",\n                            placeholder=\"e.g., ^DJI, ^IXIC\",\n                            help=\"Specify a custom benchmark symbol (e.g., ^DJI for Dow Jones Industrial Average).\"\n                        )\n                        # Use the custom benchmark if provided\n                        benchmark_symbol = custom_benchmark if custom_benchmark else \"^GSPC\"  # Default to S&P 500 if empty\n                    else:\n                        benchmark_symbol = benchmark_options.get(selected_benchmark, '^GSPC')\n\n                    # Display the chosen benchmark symbol for confirmation\n                    st.write(f\"**Selected Benchmark Symbol:** {benchmark_symbol}\")\n                \n                st.markdown(\"#### \ud83d\udd04 Rebalance Frequency\")\n                rebalance_freq = st.selectbox(\n                    \"\ud83d\udd04 Rebalance Frequency\",\n                    options=list(frequency_mapping.keys()),\n                    index=list(frequency_mapping.keys()).index('Monthly'),\n                    help=\"Choose how often the portfolio should be rebalanced.\"\n                )\n                # Submit Button\n                submit_button_label = \"\u2705 Update Portfolio\" if st.session_state.edit_portfolio else \"\u2705 Add Portfolio\"\n                if st.button(submit_button_label):\n                    # Validation\n                    if not name:\n                        st.error(\"\u274c Please provide a portfolio name.\")\n                    elif not selected_assets_new:\n                        st.error(\"\u274c Please select at least one asset.\")\n                    elif selected_benchmark == \"Custom\" and not benchmark_symbol:\n                        st.error(\"\u274c Please enter a custom benchmark symbol.\")\n                    elif not np.isclose(total_allocation_new, 100.0, atol=1e-2):\n                        st.error(f\"\u274c Allocations must sum to 100%. Currently sum to {total_allocation_new:.2f}%.\")\n                    else:\n                        allocations = allocation_df['Allocation (%)'].tolist()\n                        \n                        new_portfolio = {\n                            'name': name,\n                            'start_date': pd.to_datetime(start_date_input),\n                            'end_date': pd.to_datetime(end_date_input),\n                            'rf_rate': rf_rate,\n                            'broker_fee': broker_fee,\n                            'benchmark_symbol': benchmark_symbol,\n                            'rebalance_freq': frequency_mapping.get(rebalance_freq, 'M'),\n                            'selected': selected_tickers_new,\n                            'allocations': allocations\n                        }\n                        \n                        if st.session_state.edit_portfolio:\n                            # Update existing portfolio\n                            for idx, p in enumerate(st.session_state.portfolios):\n                                if p['name'] == st.session_state.edit_portfolio:\n                                    st.session_state.portfolios[idx] = new_portfolio\n                                    break\n                            st.success(f\"\ud83c\udf89 Portfolio '{name}' updated successfully!\")\n                            st.session_state.edit_portfolio = None  # Reset edit mode\n                        else:\n                            # Add as a new portfolio\n                            if name in [p['name'] for p in st.session_state.portfolios]:\n                                st.error(\"\u274c Portfolio name already exists. Please choose a unique name.\")\n                            else:\n                                st.session_state.portfolios.append(new_portfolio)\n                                st.success(f\"\ud83c\udf89 Portfolio '{name}' added successfully!\")\n                        \n                        st.balloons()\n                        st.rerun()\n    # ----------------------------\n    # Documentation\n    # ----------------------------\n    with st.expander(\"\ud83d\udcd6 Documentation\"):  \n        st.markdown(\"\"\"\n        ### Documentation\n\n        **Portfolio Configuration:**\n        - **Portfolio Name:** Enter a unique name for your portfolio.\n        - **Risk-Free Rate:** The theoretical return of an investment with zero risk, often based on government bonds.\n        - **Sharpe Ratio:** Measures the performance of an investment compared to a risk-free asset, after adjusting for its risk.\n            *Formula:* $$\\\\frac{R_p - R_f}{\\\\sigma_p}$$\n        - **VaR (Value at Risk):** Estimates the maximum potential loss over a specific time frame at a given confidence level.\n        - **CVaR (Conditional Value at Risk):** The expected loss exceeding the VaR, providing insight into tail risk.\n        - **Sortino Ratio:** Similar to the Sharpe Ratio but only penalizes downside volatility.\n            *Formula:* $$\\\\frac{R_p - R_f}{\\\\sigma_d}$$\n        - **Maximum Drawdown:** The largest peak-to-trough decline in the portfolio's value over a specific period.\n        - **Alpha:** Measures the active return on an investment compared to a market index.\n            *Formula:* $$R_p - [R_f + \\\\beta (R_m - R_f)]$$\n        - **Beta:** Indicates the volatility of an investment relative to the market.\n            *Formula:* $$\\\\beta = \\\\frac{Cov(R_p, R_m)}{Var(R_m)}$$\n        - **Information Ratio:** Measures portfolio returns beyond the returns of a benchmark, adjusted for the volatility of those returns.\n            *Formula:* $$\\\\frac{R_p - R_b}{TE}$$\n        - **Gain/Loss Ratio:** The ratio of total gains to total losses in the portfolio.\n        - **Modigliani\u2013Modigliani Measure (M\u00b2):** Adjusts the portfolio return to the risk of a benchmark, allowing for comparison.\n            *Formula:* $$M\u00b2 = \\\\text{Sharpe Ratio}_{\\\\text{Portfolio}} \\\\times \\\\sigma_{\\\\text{Benchmark}} + R_f$$\n        - **Tracking Error:** Measures the standard deviation of the difference between portfolio returns and benchmark returns.\n        - **Upside/Downside Capture Ratio:** Measures how well the portfolio captures the benchmark's positive and negative movements respectively.\n        - **Risk Factor Attribution:** Decomposes portfolio returns based on exposure to different risk factors like Momentum, Value, and Size.\n        - **Performance Attribution:** Breaks down portfolio performance by individual assets, showing each asset's contribution to overall returns.\n        - **Recommendation Engine:** Provides suggestions for portfolio adjustments to optimize performance based on current allocations and objectives.\n        \"\"\")\n\nif current_step == \"Run Backtest\":\n        st.title(\"\ud83d\udcca Run Backtest\")\n        if not st.session_state.portfolios:\n            st.warning(\"Please add at least one portfolio to run backtest.\")\n        else:\n            st.subheader(\"\ud83d\udd0d Select Portfolios to Compare\")\n            comparison_type = st.selectbox(\n                \"Comparison Type\",\n                [\"Portfolio vs Benchmark\", \"Portfolio vs Portfolio\"],\n                key=\"comparison_type\"\n            )\n\n            portfolio_names = [p['name'] for p in st.session_state.portfolios]\n\n            # Dynamic labels based on comparison_type\n            portfolio1_label = \"Select Portfolio\" if comparison_type == \"Portfolio vs Benchmark\" else \"Select First Portfolio\"\n            portfolio2_disabled = comparison_type == \"Portfolio vs Benchmark\"\n\n            portfolio1 = st.selectbox(\n                portfolio1_label,\n                portfolio_names,\n                key=\"p1\"\n            )\n\n            portfolio2 = st.selectbox(\n                \"Select Second Portfolio\",\n                portfolio_names,\n                key=\"p2\",\n                disabled=portfolio2_disabled\n            )\n\n            st.subheader(\"\u2699\ufe0f Visualization Settings\")\n            selected_time_frames = st.multiselect(\n                \"Select Time Frames for CAGR\",\n                options=['Weekly', 'Monthly', 'Quarterly', 'Annually'],\n                default=['Annually'],\n                key=\"selected_time_frames\",\n                help=\"Choose one or more time frames to view CAGR over different horizons.\"\n            )\n            selected_rolling_periods = st.multiselect(\n                \"Select Rolling Periods (Days)\",\n                options=[30, 90, 180, 252],\n                default=[252],\n                key=\"selected_rolling_periods\",\n                help=\"Choose one or more periods to view rolling metrics.\"\n            )\n\n            run = st.button(\"Run Backtest\")\n\n            if run:\n                with st.spinner(\"Running backtest...\"):\n                    if comparison_type == \"Portfolio vs Benchmark\":\n                        portfolio = next(p for p in st.session_state.portfolios if p['name'] == portfolio1)\n                        result = run_portfolio_comparison(\"vs_benchmark\", portfolio)\n                    else:\n                        if portfolio1 == portfolio2:\n                            st.error(\"Please select two different portfolios for comparison.\")\n                            st.stop()\n                        portfolio_a = next(p for p in st.session_state.portfolios if p['name'] == portfolio1)\n                        portfolio_b = next(p for p in st.session_state.portfolios if p['name'] == portfolio2)\n                        result = run_portfolio_comparison(\"vs_portfolio\", portfolio_a, portfolio_b)\n\n                    if result.get(\"error\"):\n                        st.error(result[\"error\"])\n                    else:\n                        backtest_results = result[\"backtest_results\"]\n                        display_backtest_results(backtest_results, comparison_type, portfolio1, portfolio2)\n\nif current_step == \"Optimize Portfolio\":\n    st.title(\"\ud83d\udd27 Optimize Portfolio\")\n    \n    if not st.session_state.portfolios:\n        st.warning(\"Please add at least one portfolio to optimize.\")\n    else:\n        portfolio_names = [p['name'] for p in st.session_state.portfolios]\n        selected_portfolio_name = st.selectbox(\"\ud83d\udcc1 Select Portfolio to Optimize\", portfolio_names)\n        portfolio = next(p for p in st.session_state.portfolios if p['name'] == selected_portfolio_name)\n        \n        # Download and prepare data\n        price_data = download_data(\n            portfolio['selected'],\n            portfolio['start_date'],\n            portfolio['end_date']\n        )\n        \n        if price_data.empty:\n            st.error(\"No price data available for the selected portfolio.\")\n        else:\n            available_selected = [ticker for ticker in portfolio['selected'] if ticker in price_data.columns]\n            missing_selected = list(set(portfolio['selected']) - set(available_selected))\n            if missing_selected:\n                st.warning(f\"Excluded tickers with no data: {', '.join(missing_selected)}\")\n            \n            if not available_selected:\n                st.error(\"No selected tickers have available data for the chosen date range.\")\n            else:\n                returns = price_data[available_selected].pct_change().dropna()\n                \n                st.header(\"\ud83d\ude80 Portfolio Optimization Settings\")\n                \n                # Constraints Section\n                with st.expander(\"\u2699\ufe0f Constraints\", expanded=True):\n                    constraints_col1, constraints_col2 = st.columns(2)\n                    \n                    with constraints_col1:\n                        max_weight = st.slider(\n                            \"\ud83d\udcc8 Maximum Weight per Asset (%)\",\n                            min_value=0.0,\n                            max_value=100.0,\n                            value=100.0,\n                            step=0.1,\n                            help=\"Set the maximum allocation percentage for any single asset.\"\n                        ) / 100  # Convert to decimal\n                \n                    with constraints_col2:\n                        min_weight = st.slider(\n                            \"\ud83d\udcc9 Minimum Weight per Asset (%)\",\n                            min_value=0.0,\n                            max_value=100.0,\n                            value=0.0,\n                            step=0.1,\n                            help=\"Set the minimum allocation percentage for any single asset.\"\n                        ) / 100  # Convert to decimal\n                \n                    # Validation: Ensure min_weight does not exceed max_weight\n                    if min_weight > max_weight:\n                        st.error(\"\u26a0\ufe0f **Minimum weight cannot exceed Maximum weight.** Please adjust your settings.\")\n                \n                # Objectives Section\n                with st.expander(\"\ud83c\udfaf Objectives\", expanded=True):\n                    objective_options = {\n                        \"Maximize Sharpe Ratio\": \"sharpe\",\n                        \"Minimize Variance\": \"min_variance\",\n                        \"Maximize Return\": \"max_return\",\n                        \"Minimize Drawdown\": \"min_drawdown\",\n                        \"Maximize Alpha\": \"maximize_alpha\",\n                        \"Minimize Beta\": \"minimize_beta\"\n                    }\n                    selected_objectives = st.multiselect(\n                        \"Select Optimization Objectives\",\n                        options=list(objective_options.keys()),\n                        default=[\"Maximize Sharpe Ratio\"],\n                        help=\"Choose one or more objectives to optimize your portfolio.\"\n                    )\n                    \n                    if not selected_objectives:\n                        st.warning(\"\u26a0\ufe0f Please select at least one optimization objective.\")\n                    \n                # Target Return Section\n                with st.expander(\"\ud83c\udfaf Target Return\", expanded=True):\n                    target_return = st.number_input(\n                        \"\ud83d\udcc8 Target Annual Return (%)\",\n                        min_value=0.0,\n                        max_value=100.0,\n                        value=10.0,\n                        step=0.1,\n                        help=\"Set the target annual return for portfolio optimization.\"\n                    ) / 100  # Convert to decimal\n                \n                # Optimization Trigger\n                if st.button(\"\u2705 Run Optimization\"):\n                    if not selected_objectives:\n                        st.error(\"\u274c Please select at least one optimization objective.\")\n                    else:\n                        # Map objectives to their internal codes\n                        objective_map = {v: k for k, v in objective_options.items()}\n                        objectives_selected = [objective_options[obj] for obj in selected_objectives]\n                        \n                        with st.spinner(\"\ud83e\uddee Optimizing portfolio...\"):\n                            # Fetch benchmark returns\n                            benchmark_symbol = portfolio['benchmark_symbol']\n                            benchmark_data = download_data([benchmark_symbol], portfolio['start_date'], portfolio['end_date'])\n                            \n                            if benchmark_data.empty:\n                                st.error(f\"Benchmark symbol '{benchmark_symbol}' does not have available data for the chosen period.\")\n                            else:\n                                benchmark_returns = benchmark_data[benchmark_symbol].pct_change().dropna()\n                                benchmark_returns = benchmark_returns.reindex(returns.index, method='ffill').dropna()\n    \n                                # Run optimization\n                                optimized_weights = optimize_portfolio(\n                                    returns,\n                                    benchmark_returns=benchmark_returns,\n                                    objectives=objectives_selected,\n                                    rf=portfolio['rf_rate'],\n                                    max_weight=max_weight,\n                                    min_weight=min_weight,\n                                    target_return=target_return\n                                )\n    \n                                if optimized_weights is not None:\n                                    # Ensure allocations sum to 100%\n                                    total_allocation = sum(optimized_weights)\n                                    if not np.isclose(total_allocation, 1.0, atol=1e-4):\n                                        st.warning(f\"\ud83d\udd04 Allocations sum to {total_allocation*100:.2f}%. Adjusting proportionally.\")\n                                        optimized_weights = [w / total_allocation for w in optimized_weights]\n                                    \n                                    # Display Optimized Weights\n                                    st.subheader(\"\ud83d\udcca Optimized Portfolio Allocation\")\n                                    weights_df = pd.DataFrame({\n                                        'Ticker': available_selected,\n                                        'Allocation (%)': [f\"{w*100:.2f}\" for w in optimized_weights]\n                                    })\n                                    st.table(weights_df)\n    \n                                    # Plot Allocation Pie Chart\n                                    plot_allocation_pie(\n                                        optimized_weights,\n                                        available_selected,\n                                        title=\"\ud83e\udd67 Optimized Allocation\",\n                                        hover_info=\"percent+name\"\n                                    )\n    \n                                    # Display Performance Metrics\n                                    st.subheader(\"\ud83d\udcc8 Optimized Portfolio Performance Metrics\")\n                                    optimized_return = np.dot(optimized_weights, returns.mean()) * 252\n                                    optimized_volatility = np.sqrt(np.dot(optimized_weights, np.dot(returns.cov() * 252, optimized_weights)))\n                                    optimized_sharpe = (optimized_return - portfolio['rf_rate']) / optimized_volatility if optimized_volatility > 0 else np.nan\n    \n                                    optimized_metrics = {\n                                        'Expected Annual Return (%)': f\"{optimized_return * 100:.2f}%\",\n                                        'Annualized Volatility (%)': f\"{optimized_volatility * 100:.2f}%\",\n                                        'Sharpe Ratio': f\"{optimized_sharpe:.2f}\"\n                                    }\n    \n                                    optimized_metrics_df = pd.DataFrame(list(optimized_metrics.items()), columns=['Metric', 'Value'])\n                                    st.table(optimized_metrics_df)\n    \n                                    # Store optimized weights and metrics in session state\n                                    st.session_state.backtest_results.update({\n                                        'optimized_weights': optimized_weights,\n                                        'optimized_return': optimized_return,\n                                        'optimized_volatility': optimized_volatility,\n                                        'optimized_sharpe': optimized_sharpe\n                                    })\n    \n                                    st.success(\"\ud83c\udf89 Portfolio optimization completed successfully!\")\n                                else:\n                                    st.error(\"\u274c Optimization did not return any weights.\")\n    #else:\n        #st.warning(\"Please add at least one portfolio to optimize.\")\n\nif current_step == \"Monte Carlo Simulations\":\n    st.title(\"\ud83d\udcc8 Monte Carlo Simulations\")\n    \n    if st.session_state.portfolios:\n        portfolio_names = [p['name'] for p in st.session_state.portfolios]\n        selected_portfolio = st.selectbox(\"\ud83d\udcc1 Select Portfolio for Simulation\", portfolio_names)\n        portfolio = next(p for p in st.session_state.portfolios if p['name'] == selected_portfolio)\n        \n        # Download and prepare data\n        price_data = download_data(\n            portfolio['selected'],\n            portfolio['start_date'],\n            portfolio['end_date']\n        )\n        \n        if price_data.empty:\n            st.error(\"No price data available for the selected portfolio.\")\n        else:\n            available_selected = [ticker for ticker in portfolio['selected'] if ticker in price_data.columns]\n            missing_selected = list(set(portfolio['selected']) - set(available_selected))\n            if missing_selected:\n                st.warning(f\"Excluded tickers with no data: {', '.join(missing_selected)}\")\n            \n            if not available_selected:\n                st.error(\"No selected tickers have available data for the chosen date range.\")\n            else:\n                returns = price_data[available_selected].pct_change().dropna()\n                \n                # Organize simulation settings and results into tabs\n                simulation_tabs = st.tabs([\"\ud83d\udd27 Settings\", \"\ud83d\udcca Results\"])\n                \n                # Settings Tab\n                with simulation_tabs[0]:\n                    st.header(\"\ud83d\udd27 Simulation Settings\")\n                    \n                    # Simulation Parameters\n                    sim_col1, sim_col2 = st.columns(2)\n                    \n                    with sim_col1:\n                        num_simulations = st.number_input(\n                            \"\ud83d\udd22 Number of Simulations\",\n                            min_value=100,\n                            max_value=10000,\n                            value=1000,\n                            step=100,\n                            help=\"Define how many simulation paths to generate.\"\n                        )\n                        periods = st.number_input(\n                            \"\ud83d\udcc6 Number of Periods\",\n                            min_value=1,\n                            max_value=252,\n                            value=252,\n                            step=1,\n                            help=\"Set the number of periods (e.g., days) for each simulation.\"\n                        )\n                    \n                    with sim_col2:\n                        return_distribution = st.selectbox(\n                            \"\ud83d\udcca Return Distribution\",\n                            options=[\"Normal\", \"Log-Normal\"],\n                            index=0,\n                            help=\"Choose the statistical distribution for asset returns.\"\n                        )\n                        enable_mean_reversion = st.checkbox(\"\ud83d\udd04 Enable Mean Reversion\", help=\"Implement mean reversion in simulated returns.\")\n                    \n                    # Mean Reversion Parameters\n                    if enable_mean_reversion:\n                        mr_col1, mr_col2 = st.columns(2)\n                        with mr_col1:\n                            mean_reversion_speed = st.slider(\n                                \"\u26a1 Mean Reversion Speed\",\n                                min_value=0.0,\n                                max_value=1.0,\n                                value=0.1,\n                                step=0.01,\n                                help=\"Adjust the speed at which returns revert to the mean.\"\n                            )\n                        with mr_col2:\n                            long_term_mean_input = st.number_input(\n                                \"\ud83d\udcc8 Long-term Mean Return (%)\",\n                                value=0.0,\n                                step=0.1,\n                                help=\"Set the target mean return for mean reversion.\"\n                            ) / 100  # Convert to decimal\n                \n                    # Time-Varying Volatility\n                    enable_time_varying_vol = st.checkbox(\"\ud83d\udcc9 Enable Time-Varying Volatility\", help=\"Allow volatility to change over time in simulations.\")\n                    if enable_time_varying_vol:\n                        vol_change_rate = st.slider(\n                            \"\ud83d\udcc8 Volatility Change Rate\",\n                            min_value=-0.5,\n                            max_value=0.5,\n                            value=0.0,\n                            step=0.01,\n                            help=\"Set the rate at which volatility changes each period.\"\n                        )\n                \n                    # Stress Testing\n                    st.subheader(\"\u26a0\ufe0f Stress Testing Parameters\")\n                    enable_stress_testing = st.checkbox(\"\u26a0\ufe0f Enable Stress Testing\")\n                    stress_shocks = {}\n                    if enable_stress_testing:\n                        selected_stress_assets = st.multiselect(\n                            \"\ud83d\udd0d Select Assets to Apply Stress Shocks\",\n                            options=available_selected,\n                            help=\"Choose assets to apply specific stress shocks.\"\n                        )\n                        for ticker in selected_stress_assets:\n                            shock = st.number_input(\n                                f\"\ud83d\udca5 Stress Shock to {ticker} (%)\",\n                                min_value=-100.0,\n                                max_value=100.0,\n                                value=0.0,\n                                step=0.1,\n                                help=f\"Define the percentage shock for {ticker}.\"\n                            ) / 100  # Convert to decimal\n                            stress_shocks[ticker] = shock\n                \n                    # Sensitivity Analysis (Optional)\n                    st.subheader(\"\ud83d\udd04 Sensitivity Analysis Parameters\")\n                    enable_sensitivity_analysis = st.checkbox(\"\ud83d\udd0e Enable Sensitivity Analysis\", help=\"Assess how changes in market factors affect portfolio risk.\")\n                    sensitivity_adjustments = {}\n                    if enable_sensitivity_analysis:\n                        sensitivity_col1, sensitivity_col2 = st.columns(2)\n                        with sensitivity_col1:\n                            interest_rate_change = st.number_input(\n                                \"\ud83d\udcb9 Change in Interest Rates (bps)\",\n                                value=0.0,\n                                step=0.1,\n                                help=\"Specify the change in interest rates in basis points.\"\n                            ) / 10000  # Convert to decimal\n                        with sensitivity_col2:\n                            inflation_rate_change = st.number_input(\n                                \"\ud83d\udcc8 Change in Inflation Rates (bps)\",\n                                value=0.0,\n                                step=0.1,\n                                help=\"Specify the change in inflation rates in basis points.\"\n                            ) / 10000  # Convert to decimal\n                        \n                        for ticker in available_selected:\n                            col_a, col_b = st.columns(2)\n                            with col_a:\n                                interest_sens = st.number_input(\n                                    f\"\ud83d\udcca Interest Rate Sensitivity for {ticker}\",\n                                    value=1.0,\n                                    step=0.1,\n                                    help=f\"Set sensitivity of {ticker} to interest rate changes.\"\n                                )\n                            with col_b:\n                                inflation_sens = st.number_input(\n                                    f\"\ud83d\udcca Inflation Rate Sensitivity for {ticker}\",\n                                    value=1.0,\n                                    step=0.1,\n                                    help=f\"Set sensitivity of {ticker} to inflation rate changes.\"\n                                )\n                            adjustment = interest_sens * interest_rate_change + inflation_sens * inflation_rate_change\n                            sensitivity_adjustments[ticker] = adjustment\n                \n                    # Simulation Trigger\n                    if st.button(\"\u2705 Run Simulations\"):\n                        with st.spinner(\"\ud83e\uddee Running Monte Carlo simulations...\"):\n                            simulated_returns = monte_carlo_simulation(\n                                returns=returns, \n                                num_simulations=int(num_simulations), \n                                periods=int(periods),\n                                mean_returns=returns.mean(), \n                                cov_matrix=returns.cov(),\n                                mean_reversion=enable_mean_reversion,\n                                mean_reversion_speed=mean_reversion_speed if enable_mean_reversion else 0.0,\n                                long_term_mean=np.full(len(available_selected), long_term_mean_input / 252) if enable_mean_reversion else None,\n                                time_varying_vol=enable_time_varying_vol,\n                                vol_change_rate=vol_change_rate if enable_time_varying_vol else 0.0,\n                                stress_shocks=stress_shocks if enable_stress_testing else {},\n                                return_distribution=return_distribution.lower()\n                            )\n                            st.session_state.simulated_returns = simulated_returns\n                            st.success(\"\ud83c\udf89 Simulations completed successfully!\")\n                \n                # Results Tab\n                with simulation_tabs[1]:\n                    if 'simulated_returns' in st.session_state:\n                        simulated_returns = st.session_state.simulated_returns\n                        st.header(\"\ud83d\udcca Simulation Results\")\n        \n                        # Descriptive Statistics\n                        st.subheader(\"\ud83d\udcc8 Descriptive Statistics\")\n                        st.write(pd.Series(simulated_returns).describe())\n        \n                        # Histogram\n                        st.subheader(\"\ud83d\udcca Returns Distribution\")\n                        fig_hist = px.histogram(\n                            simulated_returns,\n                            nbins=50,\n                            title='\ud83d\udcca Simulated Returns Distribution',\n                            labels={'value': 'Simulated Returns', 'count': 'Frequency'},\n                            template=THEME\n                        )\n                        st.plotly_chart(fig_hist, use_container_width=True)\n        \n                        # Cumulative Distribution Function (CDF)\n                        st.subheader(\"\ud83d\udcc9 Cumulative Distribution Function (CDF)\")\n                        fig_cdf = px.ecdf(\n                            simulated_returns,\n                            title='\ud83d\udcc9 Cumulative Distribution of Simulated Returns',\n                            labels={'value': 'Simulated Returns', 'cumcount': 'CDF'},\n                            template=THEME\n                        )\n                        st.plotly_chart(fig_cdf, use_container_width=True)\n        \n                        # Box Plot\n                        st.subheader(\"\ud83d\udce6 Box Plot of Simulated Returns\")\n                        fig_box = px.box(\n                            pd.DataFrame(simulated_returns, columns=['Returns']),\n                            y='Returns',\n                            title='\ud83d\udce6 Box Plot of Simulated Returns',\n                            template=THEME\n                        )\n                        st.plotly_chart(fig_box, use_container_width=True)\n        \n                        # Summary Statistics Table\n                        st.subheader(\"\ud83d\udcdd Summary Statistics\")\n                        summary_stats = pd.DataFrame({\n                            'Metric': ['Mean', 'Median', 'Standard Deviation', 'Minimum', 'Maximum'],\n                            'Value': [\n                                f\"{np.mean(simulated_returns):.4f}\",\n                                f\"{np.median(simulated_returns):.4f}\",\n                                f\"{np.std(simulated_returns):.4f}\",\n                                f\"{np.min(simulated_returns):.4f}\",\n                                f\"{np.max(simulated_returns):.4f}\"\n                            ]\n                        })\n                        st.table(summary_stats)\n        \n                        # Interpretation\n                        st.markdown(\"\"\"\n                        **\ud83d\udcd6 Interpretation:**\n                        - **Descriptive Statistics:** Provides an overview of the distribution of simulated portfolio returns.\n                        - **Histogram:** Visualizes the frequency distribution of returns.\n                        - **CDF:** Shows the probability that a return is less than or equal to a particular value.\n                        - **Box Plot:** Highlights the median, quartiles, and potential outliers in the return distribution.\n                        - **Summary Statistics:** Summarizes key metrics from the simulation runs.\n                        \"\"\")\n                    else:\n                        st.info(\"\ud83d\udd0d Run simulations to view results here.\")\n    #else:\n        #st.warning(\"Please add at least one portfolio to run Monte Carlo simulations.\")\n\n# Main Risk Analysis Section\nif current_step == \"Risk Analysis\":\n    st.title(\"\u26a0\ufe0f Risk Analysis\")\n    \n    if st.session_state.portfolios:\n        portfolio_names = [p['name'] for p in st.session_state.portfolios]\n        selected_portfolio = st.selectbox(\"\ud83d\udcc1 Select Portfolio for Risk Analysis\", portfolio_names)\n        portfolio = next(p for p in st.session_state.portfolios if p['name'] == selected_portfolio)\n        \n        # Download and prepare data\n        price_data = download_data(\n            portfolio['selected'],\n            portfolio['start_date'],\n            portfolio['end_date']\n        )\n        \n        if price_data.empty:\n            st.error(\"No price data available for the selected portfolio.\")\n        else:\n            available_selected = [ticker for ticker in portfolio['selected'] if ticker in price_data.columns]\n            missing_selected = list(set(portfolio['selected']) - set(available_selected))\n            if missing_selected:\n                st.warning(f\"Excluded tickers with no data: {', '.join(missing_selected)}\")\n            \n            if not available_selected:\n                st.error(\"No selected tickers have available data for the chosen date range.\")\n            else:\n                returns = price_data[available_selected].pct_change().dropna()\n                \n                # Organize risk analysis into tabs\n                risk_analysis_tabs = st.tabs([\"\ud83d\udcc9 Risk Metrics\", \"\ud83d\udcc8 Visualizations\", \"\ud83d\udee0\ufe0f Sensitivity Analysis\"])\n                \n                # Risk Metrics Tab\n                with risk_analysis_tabs[0]:\n                    st.header(\"\ud83d\udcc9 Risk Metrics\")\n                    \n                    # Risk Parameters\n                    risk_params_col1, risk_params_col2 = st.columns(2)\n                    \n                    with risk_params_col1:\n                        confidence_level = st.number_input(\n                            \"\ud83d\udd0d Confidence Level for VaR/CVaR (%)\",\n                            min_value=90.0,\n                            max_value=99.0,\n                            value=95.0,\n                            step=1.0,\n                            help=\"Set the confidence level for risk metrics like VaR and CVaR.\"\n                        ) / 100  # Convert to decimal\n                    \n                    with risk_params_col2:\n                        enable_stress_testing = st.checkbox(\"\u26a0\ufe0f Enable Stress Testing\", help=\"Apply specific shocks to assets to assess portfolio resilience.\")\n                    \n                    if enable_stress_testing:\n                        st.markdown(\"#### \u26a0\ufe0f Stress Testing Shocks\")\n                        stress_shocks = {}\n                        for ticker in available_selected:\n                            shock = st.number_input(\n                                f\"\ud83d\udca5 Stress Shock to {ticker} (%)\",\n                                min_value=-100.0,\n                                max_value=100.0,\n                                value=0.0,\n                                step=0.1,\n                                help=f\"Define the percentage shock for {ticker}.\"\n                            ) / 100  # Convert to decimal\n                            stress_shocks[ticker] = shock\n                        if not any(shock != 0 for shock in stress_shocks.values()):\n                            st.warning(\"\u26a0\ufe0f No stress shocks applied. Consider adding at least one to perform stress testing.\")\n                    \n                    # Sensitivity Analysis Inputs\n                    st.subheader(\"\ud83d\udd0e Sensitivity Analysis Parameters\")\n                    enable_sensitivity_analysis = st.checkbox(\"\ud83d\udd04 Enable Sensitivity Analysis\", help=\"Assess how changes in market factors affect portfolio risk.\")\n                    sensitivity_adjustments = {}\n                    if enable_sensitivity_analysis:\n                        sensitivity_col1, sensitivity_col2 = st.columns(2)\n                        with sensitivity_col1:\n                            interest_rate_change = st.number_input(\n                                \"\ud83d\udcb9 Change in Interest Rates (bps)\",\n                                value=0.0,\n                                step=0.1,\n                                help=\"Specify the change in interest rates in basis points.\"\n                            ) / 10000  # Convert to decimal\n                        with sensitivity_col2:\n                            inflation_rate_change = st.number_input(\n                                \"\ud83d\udcc8 Change in Inflation Rates (bps)\",\n                                value=0.0,\n                                step=0.1,\n                                help=\"Specify the change in inflation rates in basis points.\"\n                            ) / 10000  # Convert to decimal\n                        \n                        for ticker in available_selected:\n                            col_a, col_b = st.columns(2)\n                            with col_a:\n                                interest_sens = st.number_input(\n                                    f\"\ud83d\udcca Interest Rate Sensitivity for {ticker}\",\n                                    value=1.0,\n                                    step=0.1,\n                                    help=f\"Set sensitivity of {ticker} to interest rate changes.\"\n                                )\n                            with col_b:\n                                inflation_sens = st.number_input(\n                                    f\"\ud83d\udcca Inflation Rate Sensitivity for {ticker}\",\n                                    value=1.0,\n                                    step=0.1,\n                                    help=f\"Set sensitivity of {ticker} to inflation rate changes.\"\n                                )\n                            adjustment = interest_sens * interest_rate_change + inflation_sens * inflation_rate_change\n                            sensitivity_adjustments[ticker] = adjustment\n                \n                    # Calculate Risk Metrics Button\n                    if st.button(\"\ud83d\udcca Calculate Risk Metrics\"):\n                        with st.spinner(\"\ud83e\uddee Calculating risk metrics...\"):\n                            # Apply stress shocks if enabled\n                            portfolio_returns = returns.copy()\n                            if enable_stress_testing:\n                                for ticker, shock in stress_shocks.items():\n                                    portfolio_returns[ticker] += shock\n                            \n                            # Apply sensitivity adjustments if enabled\n                            if enable_sensitivity_analysis:\n                                for ticker, adjustment in sensitivity_adjustments.items():\n                                    portfolio_returns[ticker] += adjustment\n                            \n                            # Ensure no extreme negative returns\n                            portfolio_returns = portfolio_returns.clip(lower=-1.0)\n                            \n                            # Calculate weighted portfolio returns\n                            weights = np.array(portfolio['allocations']) / 100\n                            portfolio_returns = portfolio_returns.dot(weights)\n                            \n                            # Store in session state\n                            st.session_state.portfolio_returns = portfolio_returns\n                            \n                            # Calculate metrics\n                            cum_returns = (1 + portfolio_returns).cumprod()\n                            var = calculate_var(portfolio_returns, confidence_level)\n                            cvar = calculate_cvar(portfolio_returns, confidence_level)\n                            skewness = skew(portfolio_returns)\n                            kurt = kurtosis(portfolio_returns)\n                            annual_vol = portfolio_returns.std() * np.sqrt(252)\n                            max_drawdown_val = drawdown(cum_returns) * 100\n                            \n                            # Store metrics\n                            risk_metrics = {\n                                'Value at Risk (VaR)': f\"{var * 100:.2f}%\",\n                                'Conditional Value at Risk (CVaR)': f\"{cvar * 100:.2f}%\",\n                                'Skewness': f\"{skewness:.2f}\",\n                                'Kurtosis': f\"{kurt:.2f}\",\n                                'Annualized Volatility (%)': f\"{annual_vol * 100:.2f}%\",\n                                'Maximum Drawdown (%)': f\"{max_drawdown_val:.2f}%\"\n                            }\n                            \n                            st.session_state.risk_metrics = risk_metrics\n                            st.success(\"\u2705 Risk metrics calculated successfully!\")\n        \n                # Visualizations Tab\n                with risk_analysis_tabs[1]:\n                    st.header(\"\ud83d\udcc8 Risk Visualizations\")\n                    \n                    if 'risk_metrics' in st.session_state:\n                        var = st.session_state.risk_metrics.get('Value at Risk (VaR)', None)\n                        cvar = st.session_state.risk_metrics.get('Conditional Value at Risk (CVaR)', None)\n                        portfolio_returns_local = st.session_state.portfolio_returns\n                        cum_returns = (1 + portfolio_returns_local).cumprod()\n                        \n                        # VaR and CVaR Plot\n                        st.subheader(\"\ud83d\udcc9 Cumulative Returns with VaR and CVaR\")\n                        fig_cum = px.line(\n                            cum_returns,\n                            x=cum_returns.index,\n                            y=cum_returns,\n                            title='\ud83d\udcc9 Cumulative Returns Over Time',\n                            labels={'y': 'Cumulative Returns', 'x': 'Date'},\n                            template=THEME\n                        )\n                        if var is not None and cvar is not None:\n                            fig_cum.add_hline(\n                                y=1 + var,\n                                line_dash=\"dash\",\n                                line_color=\"red\",\n                                annotation_text=f\"VaR ({confidence_level*100:.0f}%): {var*100:.2f}%\",\n                                annotation_position=\"bottom right\"\n                            )\n                            fig_cum.add_hline(\n                                y=1 + cvar,\n                                line_dash=\"dash\",\n                                line_color=\"blue\",\n                                annotation_text=f\"CVaR ({confidence_level*100:.0f}%): {cvar*100:.2f}%\",\n                                annotation_position=\"bottom right\"\n                            )\n                        st.plotly_chart(fig_cum, use_container_width=True)\n                        \n                        # Returns Distribution with VaR and CVaR\n                        st.subheader(\"\ud83d\udcca Returns Distribution with VaR and CVaR\")\n                        fig_dist = px.histogram(\n                            portfolio_returns_local,\n                            nbins=50,\n                            title='\ud83d\udcca Simulated Returns Distribution',\n                            labels={'value': 'Returns', 'count': 'Frequency'},\n                            template=THEME\n                        )\n                        if var is not None and cvar is not None:\n                            fig_dist.add_vline(\n                                x=var,\n                                line_dash=\"dash\",\n                                line_color=\"red\",\n                                annotation_text=f\"VaR: {var*100:.2f}%\",\n                                annotation_position=\"top left\"\n                            )\n                            fig_dist.add_vline(\n                                x=cvar,\n                                line_dash=\"dash\",\n                                line_color=\"blue\",\n                                annotation_text=f\"CVaR: {cvar*100:.2f}%\",\n                                annotation_position=\"top left\"\n                            )\n                        st.plotly_chart(fig_dist, use_container_width=True)\n                        \n                        # Box Plot\n                        st.subheader(\"\ud83d\udce6 Box Plot of Portfolio Returns\")\n                        fig_box = px.box(\n                            pd.DataFrame(portfolio_returns_local, columns=['Returns']),\n                            y='Returns',\n                            title='\ud83d\udce6 Box Plot of Portfolio Returns',\n                            template=THEME\n                        )\n                        st.plotly_chart(fig_box, use_container_width=True)\n                        \n                        # Interpretation\n                        st.markdown(\"\"\"\n                        **\ud83d\udcd6 Interpretation:**\n                        - **VaR (Value at Risk):** Represents the maximum expected loss at the specified confidence level.\n                        - **CVaR (Conditional Value at Risk):** Indicates the average loss exceeding the VaR.\n                        - **Skewness:** Measures the asymmetry of the return distribution.\n                        - **Kurtosis:** Indicates the \"tailedness\" of the return distribution.\n                        - **Annualized Volatility:** Measures the dispersion of returns, indicating risk.\n                        - **Maximum Drawdown:** Shows the largest peak-to-trough decline, reflecting potential risk exposure.\n                        \"\"\")\n                    else:\n                        st.info(\"\ud83d\udd0d Calculate risk metrics to view visualizations.\")\n                \n                # Sensitivity Analysis Tab\n                with risk_analysis_tabs[2]:\n                    st.header(\"\ud83d\udee0\ufe0f Sensitivity Analysis\")\n                    \n                    if 'portfolio_returns' in st.session_state:\n                        portfolio_returns_local = st.session_state.portfolio_returns\n                        st.subheader(\"\ud83d\udcc8 Adjusted Returns Distribution\")\n                        fig_adj_returns = px.histogram(\n                            portfolio_returns_local,\n                            nbins=50,\n                            title='\ud83d\udcc8 Adjusted Portfolio Returns Distribution',\n                            labels={'value': 'Returns', 'count': 'Frequency'},\n                            template=THEME\n                        )\n                        st.plotly_chart(fig_adj_returns, use_container_width=True)\n                        \n                        st.subheader(\"\ud83d\udd04 Risk-Return Scatter Plot\")\n                        fig_risk_return = px.scatter(\n                            x=portfolio_returns_local.std() * np.sqrt(252),\n                            y=portfolio_returns_local.mean() * 252,\n                            size=[w * 100 for w in weights],\n                            color=[w * 100 for w in weights],\n                            hover_name=available_selected,\n                            title='\ud83d\udd04 Risk vs Return Scatter Plot',\n                            labels={'x': 'Annualized Volatility (Std Dev)', 'y': 'Annualized Return'},\n                            template=THEME\n                        )\n                        st.plotly_chart(fig_risk_return, use_container_width=True)\n                        \n                        # Interpretation\n                        st.markdown(\"\"\"\n                        **\ud83d\udcd6 Interpretation:**\n                        - **Adjusted Returns Distribution:** Reflects how stress shocks and sensitivity adjustments affect portfolio returns.\n                        - **Risk-Return Scatter Plot:** Visualizes the relationship between risk (volatility) and return for each asset in the portfolio.\n                        - **Size & Color Indicators:** Represent the allocation percentage, highlighting each asset's influence on the overall portfolio.\n                        \"\"\")\n                    else:\n                        st.info(\"\ud83d\udd0d Calculate risk metrics to perform sensitivity analysis.\")\n    #else:\n        #st.warning(\"Please add at least one portfolio to run risk analysis.\")\n\nwhen I am editing a portfolio, there isnt any place for me to edit its benchmark, fix it\nPlease review my code and identify specific sections that need editing. For each section, provide the full version of updated code that I can use to replace the old code. There's no need to show the full original code though\u2014just the revised version of each part. Keep the response concise and beginner-friendly.\u00a0Thank\u00a0you!"},{"assistant_initiates":false,"asst_text":"```json\n{\n    \"instruction\": \"\u5728\u4e00\u500b\u9060\u96e2\u6587\u660e\u7684\u71b1\u5e36\u53e2\u6797\u4e2d\uff0c\u50b3\u8aaa\u4e2d\u85cf\u8457\u4e00\u5ea7\u907a\u5931\u7684\u57ce\u5e02\uff0c\u64da\u8aaa\u90a3\u88e1\u5145\u6eff\u4e86\u7121\u6578\u7684\u5bf6\u85cf\u548c\u795e\u79d8\u7684\u53e4\u8001\u79d8\u8853\u3002\u4f60\u662f\u4e00\u540d\u71b1\u611b\u5192\u96aa\u7684\u63a2\u96aa\u5bb6\uff0c\u6c7a\u5b9a\u8e0f\u4e0a\u9019\u6b21\u5145\u6eff\u672a\u77e5\u548c\u6311\u6230\u7684\u65c5\u7a0b\u3002\u5f9e\u7a7f\u8d8a\u8302\u5bc6\u7684\u53e2\u6797\u5230\u6500\u767b\u96aa\u5cfb\u7684\u5c71\u8108\uff0c\u4f60\u5c07\u9762\u5c0d\u5404\u7a2e\u81ea\u7136\u7684\u8003\u9a57\uff0c\u9084\u8981\u5c0f\u5fc3\u53e2\u6797\u4e2d\u7684\u91ce\u751f\u52d5\u7269\u548c\u6f5b\u4f0f\u7684\u5371\u6a5f\u3002\u96a8\u8457\u65c5\u9014\u7684\u6df1\u5165\uff0c\u4f60\u767c\u73fe\u4e86\u4e00\u689d\u96b1\u79d8\u7684\u8def\u5f91\uff0c\u4f3c\u4e4e\u5c07\u4f60\u5f15\u5411\u50b3\u8aaa\u4e2d\u7684\u57ce\u5e02\u3002\u7136\u800c\uff0c\u4f60\u5fc5\u9808\u505a\u51fa\u95dc\u9375\u7684\u6c7a\u5b9a\u4f86\u514b\u670d\u524d\u65b9\u7684\u969c\u7919\uff0c\u624d\u80fd\u63ed\u958b\u9019\u88e1\u96b1\u85cf\u7684\u79d8\u5bc6\u7a76\u7adf\u662f\u5426\u503c\u5f97\u5192\u9019\u500b\u96aa\u3002\",\n    \"input\": \"\u8d70\u904e\u4e00\u7247\u8302\u5bc6\u7684\u8568\u985e\u690d\u7269\",\n    \"output\": \"\u4f60\u5c0f\u5fc3\u7ffc\u7ffc\u5730\u632a\u52d5\u8173\u6b65\uff0c\u907f\u958b\u5730\u9762\u6fd5\u6ed1\u7684\u82d4\u861a\u548c\u6f5b\u4f0f\u7684\u6606\u87f2\u3002\u5c31\u5728\u9019\u6642\uff0c\u4f60\u807d\u898b\u524d\u65b9\u7684\u6a39\u53e2\u4e2d\u50b3\u4f86\u5947\u7570\u7684\u8072\u97f3\u3002\u63a8\u958b\u8568\u985e\u690d\u7269\u7684\u8449\u5b50\uff0c\u4f60\u767c\u73fe\u4e00\u96bb\u8272\u5f69\u6591\u6595\u7684\u9ce5\u5152\u6b63\u7acb\u5728\u4e00\u584a\u5e03\u6eff\u82d4\u861a\u7684\u53e4\u8001\u77f3\u7891\u4e0a\uff0c\u77f3\u7891\u4f3c\u4e4e\u6307\u5f15\u8457\u4e00\u500b\u672a\u77e5\u7684\u65b9\u5411\u3002\"\n}\n```","behavior":"degenerate_repetition","conversation_hash":"d3f7b774e95be8f18590e6af28250299","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Chinese","model":"gpt-4o-2024-08-06","n_chars":616,"n_turns_in_conversation":1,"n_words":18,"source_row_offset":29,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:53 GMT","turn_id":"6287a80173b0a89562953e93","turn_index":0,"user_text":"random seed1489\uff0c \u6211\u60f3\u8981\u88fd\u4f5cAI Dungeon\u7684\u904a\u6232\uff0c\u8acb\u5e6b\u6211\u751f\u6210\u8cc7\u6599\u96c6\uff0c\u7bc4\u4f8b\u8cc7\u6599\u70ba\uff1a{'instruction': '...','input': '...','output': '...'}\uff0c\u4e3b\u984c\u70ba\u71b1\u5e36\u53e2\u6797\u5192\u96aa\u6545\u4e8b\uff0cinstruction\u8acb\u5beb\u6545\u4e8b\u7684\u5b8c\u6574\u5287\u60c5\u80cc\u666f\uff0c\u4e3b\u89d2\u4e0d\u8981\u6709\u540d\u5b57\uff0c\u76e1\u91cf\u7528\u4f60\uff0cinput\u70ba\u52d5\u4f5c(\u4e0d\u7528\u4e3b\u8a5e\uff0c\u8acb\u8d85\u904e\u4e94\u500b\u5b57)\u3001output\u70ba\u63a5\u4e0b\u4f86\u6545\u4e8b\u7684\u8b8a\u5316\uff0c1\u7b46\u5c31\u597d\uff0c\u6545\u4e8b\u5287\u60c5\u5167\u5bb9\u76e1\u91cf\u5728200\u5b57\u5167 \u8acb\u7528\u7e41\u9ad4\u4e2d\u6587\uff0c\u76f4\u63a5\u56de\u8986\u6211json"},{"assistant_initiates":false,"asst_text":"Waddleball \u2014 \u044d\u0442\u043e \u0431\u0435\u0441\u043f\u043b\u0430\u0442\u043d\u0430\u044f \u043e\u043d\u043b\u0430\u0439\u043d \u0430\u0440\u043a\u0430\u0434\u043d\u0430\u044f \u0438\u0433\u0440\u0430, \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u0435\u043d\u043d\u0430\u044f Armor Games. \u0412 \u044d\u0442\u043e\u0439 \u0443\u0432\u043b\u0435\u043a\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0439 \u0438\u0433\u0440\u0435 \u0432\u0430\u043c \u043f\u0440\u0435\u0434\u0441\u0442\u043e\u0438\u0442 \u0441\u0442\u0430\u0442\u044c \u043f\u0443\u0445\u043b\u044b\u043c \u0443\u0442\u043a\u043e\u0439 \u043f\u043e \u0438\u043c\u0435\u043d\u0438 Waddleduck. \u0412\u0430\u0448\u0430 \u0437\u0430\u0434\u0430\u0447\u0430 \u2014 \u043f\u0438\u043d\u0430\u0442\u044c \u043f\u0440\u0435\u0434\u043c\u0435\u0442\u044b \u0438 \u0441\u0442\u0440\u0435\u043c\u0438\u0442\u044c\u0441\u044f \u043a \u0442\u043e\u043c\u0443, \u0447\u0442\u043e\u0431\u044b \u0441\u0442\u0430\u0442\u044c \u0447\u0435\u043c\u043f\u0438\u043e\u043d\u043e\u043c! \u0412 Waddleball \u0432\u0430\u0441 \u0436\u0434\u0435\u0442 \u0448\u0435\u0441\u0442\u044c \u043c\u0438\u043d\u0438-\u0438\u0433\u0440, \u0432 \u043a\u043e\u0442\u043e\u0440\u044b\u0445 \u043d\u0443\u0436\u043d\u043e \u043f\u0440\u043e\u044f\u0432\u0438\u0442\u044c \u0441\u0432\u043e\u0435 \u043c\u0430\u0441\u0442\u0435\u0440\u0441\u0442\u0432\u043e: \u043f\u0438\u043d\u0430\u0442\u044c \u043a\u0440\u043e\u0442\u043e\u0432, \u043d\u0430\u0441\u0442\u0443\u043f\u0430\u0442\u044c \u043d\u0430 \u043f\u043b\u0438\u0442\u043a\u0438 \u0438 \u0443\u043d\u0438\u0447\u0442\u043e\u0436\u0430\u0442\u044c \u0430\u0441\u0442\u0435\u0440\u043e\u0438\u0434\u044b. \u041a\u0440\u043e\u043c\u0435 \u0442\u043e\u0433\u043e, \u0435\u0441\u043b\u0438 \u0432\u044b \u0438\u0449\u0435\u0442\u0435 \u0431\u043e\u043b\u0435\u0435 \u0441\u043f\u043e\u043a\u043e\u0439\u043d\u043e\u0435 \u0437\u0430\u043d\u044f\u0442\u0438\u0435, \u0438\u0433\u0440\u0430 \u043f\u0440\u0435\u0434\u043b\u0430\u0433\u0430\u0435\u0442 \u0440\u0435\u0436\u0438\u043c \u0441\u0432\u043e\u0431\u043e\u0434\u043d\u043e\u0439 \u0438\u0433\u0440\u044b, \u0433\u0434\u0435 \u0432\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u043f\u0440\u043e\u0441\u0442\u043e \u0440\u0430\u0441\u0441\u043b\u0430\u0431\u0438\u0442\u044c\u0441\u044f \u0438 \u043f\u043e\u043f\u0438\u043d\u0430\u0442\u044c \u043c\u044f\u0447\u0438\u043a\u0438. \u0418\u0433\u0440\u0430 \u043d\u0435 \u043e\u0433\u0440\u0430\u043d\u0438\u0447\u0438\u0432\u0430\u0435\u0442\u0441\u044f \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u043d\u044b\u043c \u0436\u0430\u043d\u0440\u043e\u043c, \u043d\u043e \u0441\u043e\u0447\u0435\u0442\u0430\u0435\u0442 \u0432 \u0441\u0435\u0431\u0435 \u044d\u043b\u0435\u043c\u0435\u043d\u0442\u044b \u0430\u0440\u043a\u0430\u0434\u044b, \u043a\u0430\u0437\u0443\u0430\u043b\u044c\u043d\u043e\u0439 \u0438\u0433\u0440\u044b \u0438 \u044d\u043a\u0448\u0435\u043d\u0430, \u0447\u0442\u043e \u0434\u0435\u043b\u0430\u0435\u0442 \u0435\u0435 \u0438\u043d\u0442\u0435\u0440\u0435\u0441\u043d\u043e\u0439 \u0438 \u0440\u0430\u0437\u043d\u043e\u043e\u0431\u0440\u0430\u0437\u043d\u043e\u0439 \u0434\u043b\u044f \u0438\u0433\u0440\u043e\u043a\u043e\u0432 \u0432\u0441\u0435\u0445 \u0432\u043e\u0437\u0440\u0430\u0441\u0442\u043e\u0432.","behavior":"degenerate_repetition","conversation_hash":"3f4d1e752dd2af7318bd1dcc81c2c851","conversation_redacted":false,"conversation_toxic":false,"country":"","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"English","model":"gpt-4o-2024-08-06","n_chars":1354,"n_turns_in_conversation":1,"n_words":200,"source_row_offset":30,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:53 GMT","turn_id":"cb80e238a0955a4036ad4903","turn_index":0,"user_text":"\u0422\u044b \u2014 \u044d\u043a\u0441\u043f\u0435\u0440\u0442 \u043f\u043e \u0438\u0433\u0440\u0430\u043c. \u0423 \u0442\u0435\u0431\u044f \u0435\u0441\u0442\u044c \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f \u043e \u0438\u0433\u0440\u0435 \u0441 \u0440\u0430\u0437\u043d\u044b\u0445 \u0441\u0430\u0439\u0442\u043e\u0432 \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435 JSON, id - \u0443\u043d\u0438\u043a\u0430\u043b\u044c\u043d\u044b\u0439 \u043d\u043e\u043c\u0435\u0440, name - \u043c\u0430\u0441\u0441\u0438\u0432 \u0438\u043c\u0435\u043d \u0438\u0433\u0440\u044b, description - \u043c\u0430\u0441\u0441\u0438\u0432 \u043e\u043f\u0438\u0441\u0430\u043d\u0438\u0439 \u0438\u0433\u0440\u044b, genre - \u043c\u0430\u0441\u0441\u0438\u0432 \u0436\u0430\u043d\u0440\u043e\u0432. \u0422\u0432\u043e\u044f \u0437\u0430\u0434\u0430\u0447\u0430 \u043d\u0430\u043f\u0438\u0441\u0430\u0442\u044c \u0431\u043e\u043b\u044c\u0448\u043e\u0435 \u043e\u043f\u0438\u0441\u0430\u043d\u0438\u0435 \u043d\u0430 \u043e\u0441\u043d\u043e\u0432\u0435 \u0434\u0430\u043d\u043d\u043e\u0439 \u0442\u0435\u0431\u0435 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438, \u0442\u0430\u043a \u0447\u0442\u043e \u0431\u044b \u043e\u043d\u043e \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u043b\u0430 \u0432\u0441\u044e \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044e \u0431\u0435\u0437 \u0434\u0443\u0431\u043b\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f.  ```{\"_id\":\"1\",\"name\":[\"waddleball\"],\"description\":[\"waddleball, a free online arcade game brought to you by armor games. be a chubby waddleduck! kick stuff! become a champion! prove your mettle in 6 minigames by booting moles, stomping on tiles and destroying asteroids! or, relax in free-play mode and kick some balls around.\"],\"genre\":[]}```"},{"assistant_initiates":false,"asst_text":"Gi\u00e1 tr\u1ecb c\u1ee7a a, b l\u00e0 bao nhi\u00eau khi th\u1ef1c hi\u1ec7n l\u1ec7nh f(2, 5)?\n\n```python\na, b = 0, 1\n\ndef f(a, b):\n    a = a * b\n    b = b // 2\n    return a + b\n```","behavior":"degenerate_repetition","conversation_hash":"91c7f8540e5dd5842e80e649c482854e","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Vietnamese","model":"gpt-4o-2024-08-06","n_chars":344,"n_turns_in_conversation":1,"n_words":89,"source_row_offset":31,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:54 GMT","turn_id":"5d9ab2db1b5345caaa78b467","turn_index":0,"user_text":"Ch\u1ec9 s\u1eeda l\u1ea1i \u0111\u1ecbnh d\u1ea1ng c\u00e2u h\u1ecfi v\u00e0 kh\u00f4ng b\u1ed5 sung g\u00ec th\u00eam\n\n     Gi\u00e1 tr\u1ecb c\u1ee7a a, b l\u00e0 bao nhi\u00eau khi th\u1ef1c hi\u1ec7n l\u1ec7nh f(2, 5)\r\n\r\n>>> a, b = 0, 1\r\n\r\n>>> def f(a, b):\r\n\r\na = a * b\r\n\r\nb = b // 2\r\n\r\nreturn a + b"},{"assistant_initiates":false,"asst_text":"Trong danh s\u00e1ch A, l\u1ef1a ch\u1ecdn n\u00e0o li\u00ean quan \u0111\u1ebfn m\u1ed9t khoa C\u00f4ng ngh\u1ec7 th\u00f4ng tin c\u00f3 ch\u01b0\u01a1ng tr\u00ecnh li\u00ean k\u1ebft v\u1edbi n\u01b0\u1edbc ngo\u00e0i?","behavior":"degenerate_repetition","conversation_hash":"7a4faba764a6e926965f7300a26b8763","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Vietnamese","model":"gpt-4o-2024-08-06","n_chars":291,"n_turns_in_conversation":1,"n_words":61,"source_row_offset":32,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:56 GMT","turn_id":"19147c563698fa6266ec5fb0","turn_index":0,"user_text":"Ch\u1ec9 s\u1eeda l\u1ea1i \u0111\u1ecbnh d\u1ea1ng c\u00e2u h\u1ecfi v\u00e0 kh\u00f4ng b\u1ed5 sung g\u00ec th\u00eam\n\n    Trong danh s\u00e1ch A, l\u1ef1a ch\u1ecdn n\u00e0o li\u00ean quan \u0111\u1ebfn m\u1ed9t khoa C\u00f4ng ngh\u1ec7 th\u00f4ng tin c\u00f3 ch\u01b0\u01a1ng tr\u00ecnh li\u00ean k\u1ebft v\u1edbi n\u01b0\u1edbc ngo\u00e0i?"},{"assistant_initiates":false,"asst_text":"```json\n{\n  \"Model1\": {\n    \"SemanticRelevance\": 9,\n    \"DetailAccuracy\": 8,\n    \"TerminologyCorrectness\": 9,\n    \"CoherenceAndStructure\": 9,\n    \"RelevanceToTheQuestion\": 10\n  },\n  \"Model2\": {\n    \"SemanticRelevance\": 9,\n    \"DetailAccuracy\": 9,\n    \"TerminologyCorrectness\": 10,\n    \"CoherenceAndStructure\": 9,\n    \"RelevanceToTheQuestion\": 10\n  }\n}\n```","behavior":"degenerate_repetition","conversation_hash":"8f41714e5dbfd517786bd97732264910","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Russian","model":"gpt-4o-2024-08-06","n_chars":3946,"n_turns_in_conversation":1,"n_words":529,"source_row_offset":33,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:57 GMT","turn_id":"c05cc1f8d6e51da8da69b86e","turn_index":0,"user_text":"\u0422\u044b - \u044d\u043a\u0441\u043f\u0435\u0440\u0442 \u043f\u043e \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0435 1\u0421:\u0411\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0438\u044f 8 (\u0440\u0435\u0434. 3.0). \n\u042f \u0431\u0443\u0434\u0443 \u043f\u0440\u0435\u0434\u043e\u0441\u0442\u0430\u0432\u043b\u044f\u0442\u044c \u0442\u0435\u0431\u0435 \u043e\u0434\u0438\u043d \u0432\u043e\u043f\u0440\u043e\u0441, \u044d\u0442\u0430\u043b\u043e\u043d\u043d\u044b\u0439 \u043e\u0442\u0432\u0435\u0442, \u0438 \u0434\u0432\u0430 \u043e\u0442\u0432\u0435\u0442\u0430 \u043e\u0442 \u0434\u0432\u0443\u0445 \u0440\u0430\u0437\u043d\u044b\u0445 \u043c\u043e\u0434\u0435\u043b\u0435\u0439. \u0422\u0432\u043e\u044f \u0437\u0430\u0434\u0430\u0447\u0430 \u2013 \u043e\u0446\u0435\u043d\u0438\u0442\u044c \u043e\u0442\u0432\u0435\u0442\u044b \u043e\u0442 \u043c\u043e\u0434\u0435\u043b\u0435\u0439 \u043f\u043e \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u043c \u043a\u0440\u0438\u0442\u0435\u0440\u0438\u044f\u043c:\n\n1. \u0421\u043c\u044b\u0441\u043b\u043e\u0432\u0430\u044f \u0440\u0435\u043b\u0435\u0432\u0430\u043d\u0442\u043d\u043e\u0441\u0442\u044c (\u0441\u0435\u043c\u0430\u043d\u0442\u0438\u0447\u0435\u0441\u043a\u043e\u0435 \u0441\u0445\u043e\u0434\u0441\u0442\u0432\u043e): \u041d\u0430\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u043a\u0430\u0436\u0434\u044b\u0439 \u0438\u0437 \u043e\u0442\u0432\u0435\u0442\u043e\u0432 \u0431\u043b\u0438\u0437\u043e\u043a \u043a \u044d\u0442\u0430\u043b\u043e\u043d\u0443 \u043f\u043e \u0441\u043c\u044b\u0441\u043b\u0443.\n2. \u0422\u043e\u0447\u043d\u043e\u0441\u0442\u044c \u0434\u0435\u0442\u0430\u043b\u0435\u0439: \u041d\u0430\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u043e \u0438 \u043f\u043e\u043b\u043d\u043e\u0441\u0442\u044c\u044e \u043a\u0430\u0436\u0434\u044b\u0439 \u043e\u0442\u0432\u0435\u0442 \u043e\u0442\u0440\u0430\u0436\u0430\u0435\u0442 \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u0435 \u0444\u0430\u043a\u0442\u044b \u0438 \u0430\u0441\u043f\u0435\u043a\u0442\u044b, \u0443\u043a\u0430\u0437\u0430\u043d\u043d\u044b\u0435 \u0432 \u044d\u0442\u0430\u043b\u043e\u043d\u0435.\n3. \u0421\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0438\u0435 \u043a\u043b\u044e\u0447\u0435\u0432\u043e\u0439 \u0442\u0435\u0440\u043c\u0438\u043d\u043e\u043b\u043e\u0433\u0438\u0438: \u041d\u0430\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0442\u043e\u0447\u043d\u043e \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u043d\u044b \u0442\u0435\u0440\u043c\u0438\u043d\u044b \u0438 \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u0435 \u0441\u043b\u043e\u0432\u0430.\n4. \u0421\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u0430 \u0438 \u043b\u043e\u0433\u0438\u043a\u0430 \u043e\u0442\u0432\u0435\u0442\u0430: \u041d\u0430\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u043b\u043e\u0433\u0438\u0447\u043d\u043e \u0438 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e \u043f\u043e\u0441\u0442\u0440\u043e\u0435\u043d \u043e\u0442\u0432\u0435\u0442.\n5. \u0420\u0435\u043b\u0435\u0432\u0430\u043d\u0442\u043d\u043e\u0441\u0442\u044c \u0432\u043e\u043f\u0440\u043e\u0441\u0443: \u041d\u0430\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u043e\u0442\u0432\u0435\u0442 \u0442\u043e\u0447\u043d\u043e \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u043c\u0443 \u0432\u043e\u043f\u0440\u043e\u0441\u0443 \u0438 \u043d\u0435 \u043e\u0442\u043a\u043b\u043e\u043d\u044f\u0435\u0442\u0441\u044f \u043e\u0442 \u0442\u0435\u043c\u044b.\n\n\u0412\u044b\u0432\u043e\u0434\u0438 \u0442\u043e\u043b\u044c\u043a\u043e \u0446\u0438\u0444\u0440\u044b \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435 JSON, \u043d\u0435 \u043d\u0443\u0436\u043d\u043e \u043a\u043e\u043c\u043c\u0435\u043d\u0442\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442.\n\u041e\u0446\u0435\u043d\u0438\u0432\u0430\u0439 \u043a\u0430\u0436\u0434\u044b\u0439 \u043a\u0440\u0438\u0442\u0435\u0440\u0438\u0439 \u0434\u043b\u044f \u043e\u0431\u0435\u0438\u0445 \u043c\u043e\u0434\u0435\u043b\u0435\u0439 \u043f\u043e \u0448\u043a\u0430\u043b\u0435 \u043e\u0442 1 \u0434\u043e 10 \u0438 \u0432\u044b\u0432\u043e\u0434\u0438 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442 \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435 JSON.\n\n\u041f\u0440\u0438\u043c\u0435\u0440:\n{\n  \"Model1\": {\n    \"SemanticRelevance\": 1,\n    \"DetailAccuracy\": 1,\n    \"TerminologyCorrectness\": 1,\n    \"CoherenceAndStructure\": 1,\n    \"RelevanceToTheQuestion\": 1\n  },\n  \"Model2\": {\n    \"SemanticRelevance\": 1,\n    \"DetailAccuracy\": 1,\n    \"TerminologyCorrectness\": 1,\n    \"CoherenceAndStructure\": 1,\n    \"RelevanceToTheQuestion\": 1\n  }\n}\n\n\u0412\u043e\u043f\u0440\u043e\u0441: \n{\u041a\u0430\u043a \u0432 \u043f\u043b\u0430\u043d\u0435 \u0441\u0447\u0435\u0442\u043e\u0432 \u043d\u0430\u0439\u0442\u0438 \u043d\u0443\u0436\u043d\u044b\u0439 \u0441\u0447\u0435\u0442?}\n\n\u042d\u0442\u0430\u043b\u043e\u043d\u043d\u044b\u0439 \u043e\u0442\u0432\u0435\u0442: \n{\u0420\u0430\u0437\u0434\u0435\u043b: \u0413\u043b\u0430\u0432\u043d\u043e\u0435 \u2013 \u041f\u043b\u0430\u043d \u0441\u0447\u0435\u0442\u043e\u0432 .\n  1. \u0412 \u0441\u043f\u0438\u0441\u043a\u0435 \"\u041f\u043b\u0430\u043d \u0441\u0447\u0435\u0442\u043e\u0432 \u0431\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0441\u043a\u043e\u0433\u043e \u0443\u0447\u0435\u0442\u0430\" \u0432 \u043f\u043e\u043b\u0435 \"\u041f\u043e\u0438\u0441\u043a\" \u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043b\u044e\u0431\u0443\u044e \u0447\u0430\u0441\u0442\u044c \u043d\u0430\u0438\u043c\u0435\u043d\u043e\u0432\u0430\u043d\u0438\u044f \u0441\u0447\u0435\u0442\u0430 \u0438\u043b\u0438 \u0435\u0433\u043e \u043d\u043e\u043c\u0435\u0440 (\u0431\u0435\u0437 \u0442\u043e\u0447\u0435\u043a), \u043d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, 9001 .\n  2. \u041f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0430 \u043e\u0442\u0431\u0435\u0440\u0435\u0442 \u0438\u0437 \u0441\u043f\u0438\u0441\u043a\u0430 \u0441\u0447\u0435\u0442\u0430 \u0441 \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0438\u043c\u0438 \u0434\u0430\u043d\u043d\u044b\u043c\u0438.\n  3. \u0427\u0442\u043e\u0431\u044b \u0441\u043d\u044f\u0442\u044c \u043e\u0442\u0431\u043e\u0440, \u043e\u0447\u0438\u0441\u0442\u0438\u0442\u0435 \u043f\u043e\u043b\u0435 \u043f\u043e \u043a\u043d\u043e\u043f\u043a\u0435 \u0441\u043f\u0440\u0430\u0432\u0430 \"\u0445\" .\n}\n\n\u041e\u0442\u0432\u0435\u0442 \u041c\u043e\u0434\u0435\u043b\u0438 1: \n{\u041a\u0430\u043a \u0432 \u043f\u043b\u0430\u043d\u0435 \u0441\u0447\u0435\u0442\u043e\u0432 \u043d\u0430\u0439\u0442\u0438 \u043d\u0443\u0436\u043d\u044b\u0439 \u0441\u0447\u0435\u0442?\n- \u0412 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0435 \"1\u0421:\u0411\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0438\u044f 8\" (\u0440\u0435\u0434. 3.0) \u0434\u043b\u044f \u0442\u043e\u0433\u043e, \u0447\u0442\u043e\u0431\u044b \u043d\u0430\u0439\u0442\u0438 \u043d\u0443\u0436\u043d\u044b\u0439 \u0441\u0447\u0435\u0442 \u0432 \u043f\u043b\u0430\u043d\u0435 \u0441\u0447\u0435\u0442\u043e\u0432, \u0432\u044b\u043f\u043e\u043b\u043d\u0438\u0442\u0435 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u044f:\n  1. \u041f\u0435\u0440\u0435\u0439\u0434\u0438\u0442\u0435 \u0432 \u0440\u0430\u0437\u0434\u0435\u043b \"\u0413\u043b\u0430\u0432\u043d\u043e\u0435\" \u0438 \u0432\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u043f\u0443\u043d\u043a\u0442 \"\u041f\u043b\u0430\u043d \u0441\u0447\u0435\u0442\u043e\u0432\".\n  2. \u0412 \u043e\u0442\u043a\u0440\u044b\u0432\u0448\u0435\u043c\u0441\u044f \u0438\u043d\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u0435 \u0432\u044b \u0443\u0432\u0438\u0434\u0438\u0442\u0435 \u043f\u043e\u043b\u043d\u044b\u0439 \u043f\u0435\u0440\u0435\u0447\u0435\u043d\u044c \u0432\u0441\u0435\u0445 \u0434\u043e\u0441\u0442\u0443\u043f\u043d\u044b\u0445 \u0441\u0447\u0435\u0442\u043e\u0432. \u0414\u043b\u044f \u0431\u044b\u0441\u0442\u0440\u043e\u0433\u043e \u043f\u043e\u0438\u0441\u043a\u0430 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0439\u0442\u0435 \u043f\u043e\u043b\u0435 \"\u041f\u043e\u0438\u0441\u043a\", \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u043e\u0435 \u0432 \u0432\u0435\u0440\u0445\u043d\u0435\u0439 \u0447\u0430\u0441\u0442\u0438 \u0438\u043d\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u0430.\n  3. \u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0432 \u044d\u0442\u043e \u043f\u043e\u043b\u0435 \u043b\u044e\u0431\u0443\u044e \u0447\u0430\u0441\u0442\u044c \u043d\u0430\u0438\u043c\u0435\u043d\u043e\u0432\u0430\u043d\u0438\u044f \u0441\u0447\u0435\u0442\u0430 \u0438\u043b\u0438 \u0435\u0433\u043e \u043d\u043e\u043c\u0435\u0440 (\u0431\u0435\u0437 \u0442\u043e\u0447\u0435\u043a), \u043d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, 9001. \u041f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0430 \u0430\u0432\u0442\u043e\u043c\u0430\u0442\u0438\u0447\u0435\u0441\u043a\u0438 \u043e\u0442\u0431\u0435\u0440\u0435\u0442 \u0438\u0437 \u0441\u043f\u0438\u0441\u043a\u0430 \u0442\u0435 \u0441\u0447\u0435\u0442\u0430, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0442 \u0432\u0432\u0435\u0434\u0435\u043d\u043d\u044b\u043c \u0434\u0430\u043d\u043d\u044b\u043c.\n  4. \u0415\u0441\u043b\u0438 \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043f\u0440\u043e\u0441\u043c\u043e\u0442\u0440\u0435\u0442\u044c \u0434\u0435\u0442\u0430\u043b\u044c\u043d\u0443\u044e \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044e \u043e \u043a\u043e\u043d\u043a\u0440\u0435\u0442\u043d\u043e\u043c \u0441\u0447\u0435\u0442\u0435, \u0432\u044b\u0434\u0435\u043b\u0438\u0442\u0435 \u0435\u0433\u043e \u0432 \u0441\u043f\u0438\u0441\u043a\u0435 \u0438 \u0432\u043e\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0439\u0442\u0435\u0441\u044c \u043a\u043d\u043e\u043f\u043a\u043e\u0439 \"\u0414\u043e\u043f\u043e\u043b\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u0430\u044f \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u044f\". \u042d\u0442\u043e \u043e\u0442\u043a\u0440\u043e\u0435\u0442 \u0444\u043e\u0440\u043c\u0443, \u0433\u0434\u0435 \u043c\u043e\u0436\u043d\u043e \u0431\u0443\u0434\u0435\u0442 \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u043f\u043e\u0434\u0440\u043e\u0431\u043d\u043e\u0441\u0442\u0438 \u043e \u0441\u0447\u0435\u0442\u0435.\n\n\u042d\u0442\u043e\u0442 \u043f\u0440\u043e\u0446\u0435\u0441\u0441 \u043f\u043e\u0437\u0432\u043e\u043b\u044f\u0435\u0442 \u044d\u0444\u0444\u0435\u043a\u0442\u0438\u0432\u043d\u043e \u043d\u0430\u0445\u043e\u0434\u0438\u0442\u044c \u0438 \u0443\u043f\u0440\u0430\u0432\u043b\u044f\u0442\u044c \u0441\u0447\u0435\u0442\u0430\u043c\u0438 \u0432 \"1\u0421:\u0411\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0438\u0438 8\" (\u0440\u0435\u0434. 3.0), \u0447\u0442\u043e \u0437\u043d\u0430\u0447\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u043e\u0431\u043b\u0435\u0433\u0447\u0430\u0435\u0442 \u0440\u0430\u0431\u043e\u0442\u0443 \u0431\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0430 \u0441 \u043f\u043b\u0430\u043d\u043e\u043c \u0441\u0447\u0435\u0442\u043e\u0432.}\n\n\u041e\u0442\u0432\u0435\u0442 \u041c\u043e\u0434\u0435\u043b\u0438 2: \n{\u041a\u0430\u043a \u0432 \u043f\u043b\u0430\u043d\u0435 \u0441\u0447\u0435\u0442\u043e\u0432 \u043d\u0430\u0439\u0442\u0438 \u043d\u0443\u0436\u043d\u044b\u0439 \u0441\u0447\u0435\u0442?\n- \u0412 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0435 \"1\u0421:\u0411\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0438\u044f 8\" (\u0440\u0435\u0434. 3.0) \u0434\u043b\u044f \u0442\u043e\u0433\u043e, \u0447\u0442\u043e\u0431\u044b \u043d\u0430\u0439\u0442\u0438 \u043d\u0443\u0436\u043d\u044b\u0439 \u0441\u0447\u0435\u0442 \u0432 \u043f\u043b\u0430\u043d\u0435 \u0441\u0447\u0435\u0442\u043e\u0432 \u0431\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0441\u043a\u043e\u0433\u043e \u0443\u0447\u0435\u0442\u0430, \u0432\u044b\u043f\u043e\u043b\u043d\u0438\u0442\u0435 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u0448\u0430\u0433\u0438:\n  1. \u041f\u0435\u0440\u0435\u0439\u0434\u0438\u0442\u0435 \u0432 \u0440\u0430\u0437\u0434\u0435\u043b \"\u0413\u043b\u0430\u0432\u043d\u043e\u0435\" \u0438 \u0432\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u043f\u0443\u043d\u043a\u0442 \"\u041f\u043b\u0430\u043d \u0441\u0447\u0435\u0442\u043e\u0432\".\n  2. \u0412 \u043e\u0442\u043a\u0440\u044b\u0432\u0448\u0435\u043c\u0441\u044f \u0441\u043f\u0438\u0441\u043a\u0435 \"\u041f\u043b\u0430\u043d \u0441\u0447\u0435\u0442\u043e\u0432 \u0431\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0441\u043a\u043e\u0433\u043e \u0443\u0447\u0435\u0442\u0430\" \u043d\u0430\u0439\u0434\u0438\u0442\u0435 \u043f\u043e\u043b\u0435 \"\u041f\u043e\u0438\u0441\u043a\".\n  3. \u0412 \u044d\u0442\u043e \u043f\u043e\u043b\u0435 \u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043b\u044e\u0431\u0443\u044e \u0447\u0430\u0441\u0442\u044c \u043d\u0430\u0438\u043c\u0435\u043d\u043e\u0432\u0430\u043d\u0438\u044f \u0441\u0447\u0435\u0442\u0430 \u0438\u043b\u0438 \u0435\u0433\u043e \u043d\u043e\u043c\u0435\u0440 \u0431\u0435\u0437 \u0442\u043e\u0447\u0435\u043a (\u043d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, 9001). \u041f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0430 \u043e\u0442\u0431\u0435\u0440\u0435\u0442 \u0438\u0437 \u0441\u043f\u0438\u0441\u043a\u0430 \u0441\u0447\u0435\u0442\u0430 \u0441 \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0438\u043c\u0438 \u0434\u0430\u043d\u043d\u044b\u043c\u0438.\n  4. \u0415\u0441\u043b\u0438 \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043f\u0440\u043e\u0441\u043c\u043e\u0442\u0440\u0435\u0442\u044c \u0432\u0441\u0435 \u0441\u0447\u0435\u0442\u0430, \u043e\u0447\u0438\u0441\u0442\u0438\u0442\u0435 \u043f\u043e\u043b\u0435 \u043f\u043e \u043a\u043d\u043e\u043f\u043a\u0435 \u0441\u043f\u0440\u0430\u0432\u0430.\n  5. \u0414\u043b\u044f \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u0438\u044f \u0431\u043e\u043b\u0435\u0435 \u0434\u0435\u0442\u0430\u043b\u044c\u043d\u043e\u0439 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u0438 \u043e \u0432\u044b\u0431\u0440\u0430\u043d\u043d\u043e\u043c \u0441\u0447\u0435\u0442\u0435 \u043c\u043e\u0436\u043d\u043e \u043f\u0435\u0440\u0435\u0439\u0442\u0438 \u043f\u043e \u0441\u0441\u044b\u043b\u043a\u0435 \u0441\u043f\u0440\u0430\u0432\u0430 \u043e\u0442 \u043d\u0435\u0433\u043e \u0438\u043b\u0438 \u043e\u0442\u043a\u0440\u044b\u0442\u044c \u043f\u0435\u0447\u0430\u0442\u043d\u0443\u044e \u0444\u043e\u0440\u043c\u0443 \u0441\u0447\u0435\u0442\u0430 \u0447\u0435\u0440\u0435\u0437 \u043a\u043d\u043e\u043f\u043a\u0443 \"\u0420\u0435\u0435\u0441\u0442\u0440\".\n\n\u0422\u0430\u043a\u0438\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c, \u043f\u0440\u043e\u0446\u0435\u0441\u0441 \u043f\u043e\u0438\u0441\u043a\u0430 \u0441\u0447\u0435\u0442\u0430 \u0432 \u043f\u043b\u0430\u043d\u0435 \u0441\u0447\u0435\u0442\u043e\u0432 \u0432 \"1\u0421:\u0411\u0443\u0445\u0433\u0430\u043b\u0442\u0435\u0440\u0438\u044f 8\" (\u0440\u0435\u0434. 3.0) \u043e\u0441\u0443\u0449\u0435\u0441\u0442\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0431\u044b\u0441\u0442\u0440\u043e \u0438 \u0443\u0434\u043e\u0431\u043d\u043e \u0431\u043b\u0430\u0433\u043e\u0434\u0430\u0440\u044f \u0444\u0443\u043d\u043a\u0446\u0438\u043e\u043d\u0430\u043b\u0443 \u0438\u043d\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u0430 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u044b.}\n\n\u041e\u0446\u0435\u043d\u0438 \u043e\u0431\u0430 \u043e\u0442\u0432\u0435\u0442\u0430 \u043f\u043e \u0432\u044b\u0448\u0435\u043e\u043f\u0438\u0441\u0430\u043d\u043d\u044b\u043c \u043a\u0440\u0438\u0442\u0435\u0440\u0438\u044f\u043c \u0438 \u043f\u0440\u0435\u0434\u043e\u0441\u0442\u0430\u0432\u044c \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442 \u0432 \u0444\u043e\u0440\u043c\u0430\u0442\u0435 JSON.\n"},{"assistant_initiates":false,"asst_text":"T\u00f9y ch\u1ecdn n\u00e0o d\u01b0\u1edbi \u0111\u00e2y kh\u00f4ng c\u00f3 trong h\u1ed9p tho\u1ea1i \"Edit Carousel\" c\u1ee7a \"Image Carousel\"?","behavior":"degenerate_repetition","conversation_hash":"d7ab4899859fc79d2d7f84ae2bb37899","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Vietnamese","model":"gpt-4o-2024-08-06","n_chars":225,"n_turns_in_conversation":1,"n_words":43,"source_row_offset":34,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:22:58 GMT","turn_id":"1fff7bfdc26c4cf59c41e478","turn_index":0,"user_text":"Ch\u1ec9 s\u1eeda l\u1ea1i \u0111\u1ecbnh d\u1ea1ng c\u00e2u h\u1ecfi v\u00e0 kh\u00f4ng b\u1ed5 sung g\u00ec th\u00eam\n\n    T\u00f9y ch\u1ecdn n\u00e0o d\u01b0\u1edbi \u0111\u00e2y kh\u00f4ng c\u00f3 trong h\u1ed9p tho\u1ea1i Edit carousel c\u1ee7a Image carousel?"},{"assistant_initiates":false,"asst_text":"Khi n\u00e0o b\u1ea1n n\u00ean xu\u1ea5t b\u1ea3n website d\u01b0\u1edbi d\u1ea1ng t\u1ec7p tin HTML v\u00e0 l\u01b0u v\u00e0o th\u01b0 m\u1ee5c trong m\u00e1y t\u00ednh?","behavior":"degenerate_repetition","conversation_hash":"56be0130bd8a3c8a4ce83d2c6e75d857","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Vietnamese","model":"gpt-4o-2024-08-06","n_chars":241,"n_turns_in_conversation":1,"n_words":53,"source_row_offset":35,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:23:00 GMT","turn_id":"d6c3288a7b170fe2b2ae75a6","turn_index":0,"user_text":"Ch\u1ec9 s\u1eeda l\u1ea1i \u0111\u1ecbnh d\u1ea1ng c\u00e2u h\u1ecfi v\u00e0 kh\u00f4ng b\u1ed5 sung g\u00ec th\u00eam\n\n    Khi n\u00e0o b\u1ea1n n\u00ean xu\u1ea5t b\u1ea3n website d\u01b0\u1edbi d\u1ea1ng t\u1ec7p tin HTML v\u00e0 l\u01b0u v\u00e0o th\u01b0 m\u1ee5c trong m\u00e1y t\u00ednh?"},{"assistant_initiates":false,"asst_text":"Cho bi\u1ebft k\u1ebft qu\u1ea3 sau khi th\u1ef1c hi\u1ec7n \u0111o\u1ea1n ch\u01b0\u01a1ng tr\u00ecnh sau:\n\n```python\nma = [19, 2, 25, 4, 8, 99, 111, 12]\nma.sort()\nma.append([1, 2])\nprint(ma)\n```","behavior":"degenerate_repetition","conversation_hash":"ecdc3b2b16edb01afaf08fffb297f5de","conversation_redacted":false,"conversation_toxic":false,"country":"United States","empty_output":false,"evidence_codes":[],"label":"absent","label_present":false,"label_qualified":false,"label_source":"Final dense release","language":"Vietnamese","model":"gpt-4o-2024-08-06","n_chars":335,"n_turns_in_conversation":1,"n_words":64,"source_row_offset":36,"source_shard":"turns-00044.parquet","timestamp":"Mon, 04 Nov 2024 03:23:02 GMT","turn_id":"4fdc32ee9da9f2c8f192df6f","turn_index":0,"user_text":"Ch\u1ec9 s\u1eeda l\u1ea1i \u0111\u1ecbnh d\u1ea1ng c\u00e2u h\u1ecfi v\u00e0 kh\u00f4ng b\u1ed5 sung g\u00ec th\u00eam\n\n    Cho bi\u1ebft k\u1ebft qu\u1ea3 sau khi th\u1ef1c hi\u1ec7n \u0111o\u1ea1n ch\u01b0\u01a1ng tr\u00ecnh sau: ma=[19, 2, 25, 4, 8, 99, 111, 12] ma.sort() ma.append([1,2]) print(ma)"}],"shard":{"index":44,"name":"turns-00044.parquet","rows":44850}}