2. group_trends_trading_strategy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "36ee7fa9",
   "metadata": {},
   "source": [
    "# Identyfing group trends and forming a strategy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "59d84367",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import pandas_datareader as pdr \n",
    "import yfinance as yf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as st\n",
    "import seaborn as sns\n",
    "import networkx as nx\n",
    "import datetime\n",
    "from scipy.stats import pearsonr\n",
    "from trading_functions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "08fbc1ba",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# These are determined, highly correlated groups\n",
    "link_threshold = 0.6\n",
    "frequency_threshold = 0.5\n",
    "draw = True\n",
    "separate_groups  = find_correlation_groups(time_window_splits,price_df_train,link_threshold,frequency_threshold ,draw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecdd8277",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load ticker symbols from a CSV file into a DataFrame.\n",
    "ticker_df = pd.read_csv('nasdaq_screener_1686671592339.csv')\n",
    "\n",
    "# Extract the 'Symbol' column from the DataFrame and convert it to a list of ticker symbols.\n",
    "tickers = list(ticker_df['Symbol'].values)\n",
    "\n",
    "# Limit the list of tickers to the first 500 for manageability or computational efficiency.\n",
    "tickers = tickers[0:500]\n",
    "\n",
    "# Define the start and end dates for the training period of the trading strategy.\n",
    "training_start_date = \"2010-01-03\"\n",
    "training_end_date = \"2021-01-01\"\n",
    "\n",
    "# Define the start and end dates for the first testing period of the trading strategy.\n",
    "testing_start_date = '2021-01-03'\n",
    "testing_end_date = '2023-04-01'\n",
    "\n",
    "# Retrieve price and daily returns data for training period using a predefined list of tickers and date range.\n",
    "price_df_test,daily_returns_df_test = get_data(tickers,testing_start_date,testing_end_date )\n",
    "tot_days_test = len(price_df_test)\n",
    "print('Total number of testing days is', tot_days_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6d21f3a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the number of time windows to split the data into for analyzing correlations and performance.\n",
    "n_time_windows = 100\n",
    "\n",
    "# A boolean flag to indicate whether the size of the time windows is fixed (True) or should be calculated dynamically (False).\n",
    "size_boolean = True\n",
    "\n",
    "# If time window sizes are fixed, this sets the size of each time window.\n",
    "chosen_time_window_size = 30\n",
    "\n",
    "# Calculate the total number of days in the training dataset.\n",
    "tot_days = len(price_df_train)\n",
    "\n",
    "# Split the total days into time windows based on the number of windows and size settings defined above.\n",
    "time_window_splits, time_window_size = split_time_windows(tot_days, n_time_windows, chosen_time_window_size, size_boolean)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "75c515d7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def find_dropout_candidates(price_df, time_window_splits_test, drop_out_threshold, separate_groups):\n",
    "    \"\"\"\n",
    "    Identifies potential dropout candidates among assets based on a correlation threshold within specified time windows.\n",
    "    \n",
    "    Args:\n",
    "        price_df (DataFrame): A DataFrame containing price data for various assets.\n",
    "        time_window_splits_test (list): A list of indices representing the start and end of each time window for testing.\n",
    "        drop_out_threshold (float): The threshold below which an asset is considered a dropout candidate due to low correlation.\n",
    "        separate_groups (list): A list of lists, where each inner list contains assets considered part of the same group.\n",
    "\n",
    "    Returns:\n",
    "        dict: A dictionary containing the correlation pairs for each time window, keyed by time window index.\n",
    "    \"\"\"\n",
    "    # Initialize dictionary to hold correlation matrices for each time window\n",
    "    corr_test_df_dict = {}\n",
    "    for i in range(1, len(time_window_splits_test)):\n",
    "        # Calculate and store the correlation matrix for each time window\n",
    "        corr_test_df_dict[i] = price_df.iloc[time_window_splits_test[i-1]:time_window_splits_test[i], :].corr()\n",
    "\n",
    "    # Extract asset tickers from the correlation matrix\n",
    "    asset_ticker_list = list(corr_test_df_dict[1].columns)\n",
    "    # Initialize dictionary to store correlations for all pairs of assets in each time window\n",
    "    correlation_pairs_test_dict = {}\n",
    "    for time_window_index in corr_test_df_dict:\n",
    "        correlation_pairs_test_dict[time_window_index] = {}\n",
    "        for ticker_1 in asset_ticker_list:\n",
    "            for ticker_2 in asset_ticker_list:\n",
    "                if ticker_1 != ticker_2:  # Ensure we're not comparing the same asset\n",
    "                    # Store the correlation value between each pair of assets\n",
    "                    correlation_pairs_test_dict[time_window_index][(ticker_1, ticker_2)] = corr_test_df_dict[time_window_index].loc[ticker_1, ticker_2]\n",
    "\n",
    "    # Prepare to check pairs within the same group for potential dropouts\n",
    "    pairs_to_check = {}\n",
    "    for group in separate_groups:\n",
    "        pairs_to_check[tuple(group)] = []\n",
    "        for i in group:\n",
    "            for j in group:\n",
    "                if j != i:  # Ensure we're not comparing the same asset\n",
    "                    # Append each unique pair of assets within the group\n",
    "                    pairs_to_check[tuple(group)].append((i, j))\n",
    "    \n",
    "    return correlation_pairs_test_dict,pairs_to_check\n",
    "\n",
    "def choose_dropout_candidates(price_df,time_window_splits_test,correlation_pairs_test_dict, separate_groups, drop_out_threshold, pairs_to_check):\n",
    "    \"\"\"\n",
    "    This function analyzes correlation data between pairs of assets within specified groups \n",
    "    over various time windows to identify potential dropout candidates. A dropout candidate \n",
    "    is defined as an asset whose correlation with others in its group falls below a specified \n",
    "    threshold, indicating a significant change in its behavior relative to the group.\n",
    "    \n",
    "    Args:\n",
    "        correlation_pairs_test_dict (dict): Dictionary where keys are time window indices and \n",
    "            values are dictionaries of asset pairs and their corresponding correlation values.\n",
    "        separate_groups (list of lists): Each inner list contains assets considered to be in \n",
    "            the same group for correlation analysis.\n",
    "        drop_out_threshold (float): The correlation value below which an asset is considered \n",
    "            a dropout candidate.\n",
    "        pairs_to_check (dict): Precomputed pairs of assets within each group to check for \n",
    "            dropouts, keyed by group.\n",
    "\n",
    "    Returns:\n",
    "        tuple: A tuple containing two dictionaries. The first dictionary maps time window \n",
    "            indices to potential dropout candidates within each group. The second dictionary \n",
    "            contains the chosen dropout candidates after further analysis.\n",
    "    \"\"\"\n",
    "  # Initialize dictionaries to track dropout candidates and chosen dropouts.\n",
    "    drop_out_candidates_dict = {}\n",
    "    drop_out_chosen_dict = {}\n",
    "\n",
    "    # Iterate through all but the last time window.\n",
    "    for time_window_index in list(correlation_pairs_test_dict.keys())[:-1]:\n",
    "        dropout_not_found = False\n",
    "        drop_out_candidates_dict[time_window_index] = {}\n",
    "        \n",
    "        # Check each group for potential dropouts.\n",
    "        for group in separate_groups:\n",
    "            N = len(group)\n",
    "            drop_out_candidates_dict[time_window_index][tuple(group)] = {}\n",
    "            \n",
    "            # Iterate through pairs to check within the current group.\n",
    "            for pair in pairs_to_check[tuple(group)]:\n",
    "                corr = correlation_pairs_test_dict[time_window_index][pair]\n",
    "                \n",
    "                # If correlation falls below the threshold, mark the asset pair as dropout candidates.\n",
    "                if corr <= drop_out_threshold:\n",
    "                    for asset in pair:\n",
    "                        # Update count, accounting for potential double-counting.\n",
    "                        drop_out_candidates_dict[time_window_index][tuple(group)].setdefault(asset, 0)\n",
    "                        drop_out_candidates_dict[time_window_index][tuple(group)][asset] += (1/2)/len(pairs_to_check[tuple(group)])\n",
    "            \n",
    "            # Determine the asset with the worst (highest) dropout score if any dropouts were found.\n",
    "            if drop_out_candidates_dict[time_window_index][tuple(group)]:\n",
    "                worst_dropout = sorted(drop_out_candidates_dict[time_window_index][tuple(group)].items(), key=lambda x: x[1])[-1][0]\n",
    "                \n",
    "                # If the worst dropout score meets the threshold, select this asset as a dropout.\n",
    "                if drop_out_candidates_dict[time_window_index][tuple(group)][worst_dropout] >= drop_out_threshold:\n",
    "                    drop_out_chosen_dict[time_window_index] = {\n",
    "                        'asset': worst_dropout,\n",
    "                        'group': group,\n",
    "                        'time_window_index': time_window_index\n",
    "                    }\n",
    "                else:\n",
    "                    dropout_not_found = True\n",
    "\n",
    "        # Skip further analysis if no dropouts were found or if a dropout was not confirmed.\n",
    "        if dropout_not_found:\n",
    "            continue\n",
    "        \n",
    "        # Prepare data slices for current and next time windows to analyze price trends.\n",
    "        start_day, end_day = time_window_splits_test[time_window_index-1]-1, time_window_splits_test[time_window_index]-1\n",
    "        start_day_next, end_day_next = time_window_splits_test[time_window_index], time_window_splits_test[time_window_index+1]\n",
    "        drop_out_asset = drop_out_chosen_dict[time_window_index]['asset']\n",
    "        group = drop_out_chosen_dict[time_window_index]['group']\n",
    "        \n",
    "        # Slice price DataFrame for the current and next time windows.\n",
    "        price_time_window = price_df.iloc[start_day:end_day, :].copy()\n",
    "        price_time_window_next = price_df.iloc[start_day_next:end_day_next, :].copy()\n",
    "        \n",
    "        # Calculate price trend changes for the dropout asset in current and next time windows.\n",
    "        drop_out_chosen_dict[time_window_index]['trend_change_asset'] = (price_time_window[drop_out_asset].values[-1] - price_time_window[drop_out_asset].values[0]) / price_time_window[drop_out_asset].values[0]\n",
    "        drop_out_chosen_dict[time_window_index]['trend_change_asset_next'] = (price_time_window_next[drop_out_asset].values[-1] - price_time_window_next[drop_out_asset].values[0]) / price_time_window_next[drop_out_asset].values[0]\n",
    "        \n",
    "        # Determine the trend direction for the dropout asset.\n",
    "        drop_out_chosen_dict[time_window_index]['trend_sign_asset'] = 'positive' if drop_out_chosen_dict[time_window_index]['trend_change_asset'] >= 0 else 'negative'\n",
    "        \n",
    "        # Record starting and ending prices for the dropout asset.\n",
    "        drop_out_chosen_dict[time_window_index]['starting_price_asset'] = price_time_window[drop_out_asset].values[0]\n",
    "        drop_out_chosen_dict[time_window_index]['ending_price_asset'] = price_time_window[drop_out_asset].values[-1]\n",
    "        drop_out_chosen_dict[time_window_index]['ending_date_asset'] = price_time_window.index[-1]\n",
    "        drop_out_chosen_dict[time_window_index]['opening_price_asset'] = price_df.iloc[start_day, :][drop_out_asset].copy()\n",
    "        drop_out_chosen_dict[time_window_index]['opening_date_asset'] = price_time_window.index[-1] + datetime.timedelta(days=1)\n",
    "        \n",
    "        # Analyze price trend changes for the rest of the group.\n",
    "        group_change_list, group_change_next_list = [], []\n",
    "        for asset in group:\n",
    "            if asset != drop_out_asset:\n",
    "                prct_change = (price_time_window[asset].values[-1] - price_time_window[asset].values[0]) / price_time_window[asset].values[0]\n",
    "                prct_change_next = (price_time_window_next[asset].values[-1] - price_time_window_next[asset].values[0]) / price_time_window_next[asset].values[0]\n",
    "                group_change_list.append(prct_change)\n",
    "                group_change_next_list.append(prct_change_next)\n",
    "        \n",
    "        # Calculate and record the average trend change for the group, excluding the dropout asset.\n",
    "        drop_out_chosen_dict[time_window_index]['trend_change_group'] = np.mean(group_change_list)\n",
    "        drop_out_chosen_dict[time_window_index]['trend_change_group_next'] = np.mean(group_change_next_list)\n",
    "        drop_out_chosen_dict[time_window_index]['trend_sign_group'] = 'positive' if drop_out_chosen_dict[time_window_index]['trend_change_group'] >= 0 else 'negative'\n",
    "    \n",
    "    return drop_out_chosen_dict\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "64932788",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This should be an optimized correlation threshold\n",
    "drop_out_threshold = 0.4\n",
    "link_loss_threshold = 0.0\n",
    "correlation_pairs_test_dict,pairs_to_check = find_dropout_candidates(price_df_test,time_window_splits_test,drop_out_threshold,separate_groups)\n",
    "drop_out_chosen_dict =  choose_dropout_candidates(price_df_test,,time_window_splits_test,correlation_pairs_test_dict, separate_groups, drop_out_threshold, pairs_to_check)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cade2c2",
   "metadata": {},
   "source": [
    "## Taking positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "0182262a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_signals(price_df, time_window_splits_test, drop_out_threshold, link_loss_threshold, initial_capital, investment_parameter,separate_groups):\n",
    "    \"\"\"\n",
    "    Creates trading signals based on the analysis of dropout candidates and their correlations within given time windows.\n",
    "    \n",
    "    Args:\n",
    "        price_df (DataFrame): DataFrame containing price data for assets.\n",
    "        time_window_splits_test (list): Indices marking the start and end of each time window for analysis.\n",
    "        drop_out_threshold (float): Threshold for considering an asset as a dropout candidate based on correlation.\n",
    "        link_loss_threshold (float): Not used in this function, but typically for further analysis or filtering.\n",
    "        initial_capital (float): The initial amount of capital available for investment.\n",
    "        investment_parameter (float): Parameter to adjust the amount of capital allocated to each trade.\n",
    "    \n",
    "    Returns:\n",
    "        tuple: A tuple containing the dictionary of signals and the updated capital after making all trades.\n",
    "    \"\"\"\n",
    "    # Analyze price data to find dropout candidates and their correlation pairs\n",
    "    correlation_pairs_test_dict,pairs_to_check = find_dropout_candidates(price_df,time_window_splits_test,drop_out_threshold,separate_groups)\n",
    "    drop_out_chosen_dict =  choose_dropout_candidates(price_df,correlation_pairs_test_dict, separate_groups, drop_out_threshold, pairs_to_check)\n",
    "    signals_dictionary = {}\n",
    "    current_capital = initial_capital\n",
    "\n",
    "    # Iterate through each chosen dropout to generate investment signals\n",
    "    for position_index in list(drop_out_chosen_dict.keys()):\n",
    "        time_window_index = drop_out_chosen_dict[position_index]['time_window_index']\n",
    "        asset = drop_out_chosen_dict[position_index]['asset']\n",
    "        group = drop_out_chosen_dict[position_index]['group']\n",
    "        date = drop_out_chosen_dict[position_index]['opening_date_asset']\n",
    "\n",
    "        # Only proceed if the opening date is within the data range\n",
    "        if date < price_df.index[-1]:\n",
    "            # Calculate the difference in trend change between the group and the asset\n",
    "            group_asset_change = drop_out_chosen_dict[position_index]['trend_change_group'] - drop_out_chosen_dict[position_index]['trend_change_asset']\n",
    "            group_asset_change_abs = abs(group_asset_change)\n",
    "            # Determine investment amount based on the absolute change\n",
    "            money_to_spend = investment_parameter * current_capital * group_asset_change_abs\n",
    "            current_capital -= money_to_spend  # Update current capital\n",
    "            price = drop_out_chosen_dict[position_index]['opening_price_asset']\n",
    "            volume = int(np.floor(money_to_spend / price))  # Calculate volume to trade\n",
    "\n",
    "            # Decide position based on the sign of the group asset change\n",
    "            position = 'long' if group_asset_change_abs > 0 else 'short'\n",
    "            signals_dictionary[position_index] = {'asset': asset, 'group': group, 'open_volume': volume, 'open_price': price, 'open_date': date, 'position': position}\n",
    "\n",
    "    # Set a fixed time delta for closing positions\n",
    "    closing_time_delta = 30\n",
    "\n",
    "    # Close positions and update capital based on closing prices\n",
    "    for position_index in list(signals_dictionary.keys()):\n",
    "        asset = signals_dictionary[position_index]['asset']\n",
    "        closing_date = signals_dictionary[position_index]['open_date'] + datetime.timedelta(days=closing_time_delta)\n",
    "        # Ensure the closing date does not exceed the last date in the data\n",
    "        closing_date = min(closing_date, price_df.index[-1])\n",
    "        signals_dictionary[position_index]['close_date'] = closing_date\n",
    "        \n",
    "        # Fetch the closing price for the asset\n",
    "        closing_price = price_df.loc[closing_date, asset] if closing_date in price_df.index else price_df.loc[price_df.index[-1], asset]\n",
    "        signals_dictionary[position_index]['close_price'] = closing_price\n",
    "        signals_dictionary[position_index]['close_volume'] = signals_dictionary[position_index]['open_volume']\n",
    "        # Update capital based on the closing transaction\n",
    "        current_capital += closing_price * signals_dictionary[position_index]['close_volume']\n",
    "\n",
    "    return signals_dictionary, current_capital\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "7f2434e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_capital = 1000000\n",
    "investment_parameter = 0.2\n",
    "link_loss_threshold = 0\n",
    "drop_out_threshold = 0.8\n",
    "long_short_parameter = 0\n",
    "signals_dictionary,current_capital=  create_signals(price_df_test,time_window_splits_test,drop_out_threshold,link_loss_threshold,initial_capital,investment_parameter,separate_groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "fa32e3d3",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# An example of a position being taken\n",
    "signal_index = 1\n",
    "asset = signals_dictionary[signal_index ]['asset']\n",
    "group = signals_dictionary[signal_index ]['group']\n",
    "position = signals_dictionary[signal_index ]['position']\n",
    "group = [x for x in group if x != asset]\n",
    "open_date = signals_dictionary[signal_index ]['open_date']\n",
    "close_date = signals_dictionary[signal_index ]['close_date']\n",
    "asset_df = price_df_test[signals_dictionary[signal_index]['asset']].copy()\n",
    "asset_df = asset_df[(asset_df.index > open_date -  datetime.timedelta(90)) & (asset_df.index <close_date +  datetime.timedelta(90))]\n",
    "group_df = price_df_test[group].copy()\n",
    "group_df = group_df[(group_df.index > open_date -  datetime.timedelta(90)) & (group_df.index <close_date +  datetime.timedelta(90))]\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(asset_df.index,asset_df,label='Drop out asset: ' + asset + ' | Position: ' + position)\n",
    "plt.plot(group_df.index,group_df)\n",
    "plt.xticks(rotation=45,fontsize=16)\n",
    "plt.axvline(open_date,color='black',linestyle='--',label='Open date: ' + str(open_date))\n",
    "plt.axvline(close_date,color='red',linestyle='--',label='Close date: ' + str(close_date))\n",
    "plt.ylabel('Closing price ($)',fontsize=16)\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e44f61ec",
   "metadata": {},
   "source": [
    "# Strategy performance analysis\n",
    "Introducting functions and metrics for analysis of the strategy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "f5be99a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def price_difference_analysis(signals_dictionary, parameters_dictionary, plot):\n",
    "    \"\"\"\n",
    "    Analyze and calculate the cumulative price difference from trading signals, optionally plotting the results.\n",
    "\n",
    "    This function calculates the cumulative profit or loss for a series of trading positions based on open and close prices,\n",
    "    and the volume of each trade. It supports both 'long' and 'short' positions. The cumulative profit or loss is calculated\n",
    "    for each position, and if plotting is enabled, it will display a scatter plot of profits or losses over close dates.\n",
    "\n",
    "    Parameters:\n",
    "    - signals_dictionary (dict): A dictionary containing trading signals. Each key represents a position index, and\n",
    "      its value is another dictionary with details of the trade, including 'position' (long or short), 'open_price',\n",
    "      'close_price', 'open_volume', and 'close_date'.\n",
    "    - parameters_dictionary (dict): A dictionary containing parameters for analysis. Currently unused in the function.\n",
    "    - plot (bool): A boolean indicating whether to plot the cumulative price difference results.\n",
    "\n",
    "    Returns:\n",
    "    - float: The final cumulative price difference across all trading positions.\n",
    "    \"\"\"\n",
    "    # Initialize a dictionary to hold the cumulative price difference for each close date.\n",
    "    price_difference_cumul_dict = {}\n",
    "    cumulative_price_diff = 0  # Initialize cumulative price difference.\n",
    "\n",
    "    # Iterate over each position in the signals dictionary.\n",
    "    for position_index in list(signals_dictionary.keys()):\n",
    "        # Extract details of the current position from the signals dictionary.\n",
    "        position = signals_dictionary[position_index]['position']\n",
    "        close_date = signals_dictionary[position_index]['close_date']\n",
    "        volume = signals_dictionary[position_index]['open_volume']  # The volume of the position.\n",
    "\n",
    "        # Calculate the price difference for long positions.\n",
    "        if position == 'long':\n",
    "            open_price = signals_dictionary[position_index]['open_price']\n",
    "            close_price = signals_dictionary[position_index]['close_price']\n",
    "            cumulative_price_diff += close_price - open_price  # Update cumulative difference.\n",
    "            price_difference_cumul_dict[close_date] = cumulative_price_diff * volume\n",
    "\n",
    "        # Calculate the price difference for short positions.\n",
    "        elif position == 'short':\n",
    "            open_price = signals_dictionary[position_index]['open_price']\n",
    "            close_price = signals_dictionary[position_index]['close_price']\n",
    "            cumulative_price_diff += - (close_price - open_price)  # Update cumulative difference.\n",
    "            price_difference_cumul_dict[close_date] = cumulative_price_diff * volume\n",
    "            \n",
    "    # Plot the results if requested.\n",
    "    if plot:\n",
    "        plt.scatter(price_difference_cumul_dict.keys(), price_difference_cumul_dict.values())\n",
    "        plt.xlabel('Close date')  # X-axis label.\n",
    "        plt.ylabel('Profit ($)')  # Y-axis label.\n",
    "        plt.xticks(rotation=45)  # Rotate x-axis labels for better readability.\n",
    "\n",
    "    return cumulative_price_diff  # Return the cumulative price difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "c803b27a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_portfolio(signals_dictionary, start_date, end_date):\n",
    "    \"\"\"\n",
    "    Generates a timeseries portfolio analysis based on trading signals within a specified date range.\n",
    "\n",
    "    This function processes trading signals to create a portfolio timeseries analysis, tracking the balance, long value,\n",
    "    short value, and total value of the portfolio over time. It accounts for opening and closing trades based on the\n",
    "    signals provided and calculates the portfolio's value accordingly.\n",
    "\n",
    "    Parameters:\n",
    "    - signals_dictionary (dict): A dictionary where each key is a position index and each value is a dictionary\n",
    "      containing the details of the trade (asset, position, open_date, close_date, open_price, open_volume).\n",
    "    - start_date (str): The start date for the analysis in YYYY-MM-DD format.\n",
    "    - end_date (str): The end date for the analysis in YYYY-MM-DD format.\n",
    "\n",
    "    Returns:\n",
    "    - DataFrame: A pandas DataFrame indexed by date, with columns for balance, long value, short value, and total value.\n",
    "    \"\"\"\n",
    "    # Extract unique asset tickers from the signals dictionary.\n",
    "    ticks = [signals_dictionary[i]['asset'] for i in signals_dictionary]\n",
    "    ticks = list(set(ticks))  # Remove duplicates.\n",
    "\n",
    "    # Retrieve price and change data for the assets over the specified date range.\n",
    "    price_data, change_data = get_data(ticks, start_date, end_date)\n",
    "\n",
    "    # Create a DataFrame to track portfolio values over the date range.\n",
    "    date_range = pd.date_range(start_date, end_date)\n",
    "    portfolio = pd.DataFrame(index=date_range)\n",
    "    portfolio['balance'] = 0\n",
    "    portfolio['long value'] = 0\n",
    "    portfolio['short value'] = 0\n",
    "    last_price_long, last_price_short = 0, 0 \n",
    "    cash = initial_capital  # Initialize cash with the initial capital (variable not defined in snippet).\n",
    "    open_positions = []  # Track open positions.\n",
    "    \n",
    "    for t in date_range:\n",
    "        buy, sell = [], []\n",
    "\n",
    "        # Determine which positions to buy or sell based on the date.\n",
    "        for position_index in signals_dictionary:\n",
    "            if signals_dictionary[position_index]['close_date'] == t:\n",
    "                sell.append(position_index)\n",
    "            if signals_dictionary[position_index]['open_date'] == t:\n",
    "                buy.append(position_index)\n",
    "\n",
    "        # Update cash and balance for days with no buy/sell activity.\n",
    "        if len(buy) == 0 and len(sell) == 0:\n",
    "            portfolio.loc[t, 'balance'] = cash\n",
    "\n",
    "        # Process buy and sell signals.\n",
    "        for b in buy:\n",
    "            position = signals_dictionary[b]['position']\n",
    "            volume = signals_dictionary[b]['open_volume']\n",
    "            open_price = signals_dictionary[b]['open_price']\n",
    "\n",
    "            if position == 'long':\n",
    "                cash -= open_price * volume\n",
    "                open_positions.append(b)\n",
    "            elif position == 'short':\n",
    "                cash += open_price * volume\n",
    "                open_positions.append(b)\n",
    "\n",
    "            portfolio.loc[t, 'balance'] = cash\n",
    "\n",
    "        for s in sell:\n",
    "            position = signals_dictionary[s]['position']\n",
    "            volume = signals_dictionary[s]['open_volume']\n",
    "            close_price = signals_dictionary[s]['close_price']\n",
    "\n",
    "            if position == 'long':\n",
    "                cash += close_price * volume\n",
    "                open_positions.remove(s)\n",
    "            elif position == 'short':\n",
    "                cash -= close_price * volume\n",
    "                open_positions.remove(s)\n",
    "\n",
    "            portfolio.loc[t, 'balance'] = cash\n",
    "        \n",
    "        # Calculate the value of open long and short positions.\n",
    "        if open_positions:\n",
    "            long_value, short_value = 0, 0\n",
    "            for l in open_positions:\n",
    "                asset = signals_dictionary[l]['asset']\n",
    "                volume = signals_dictionary[l]['open_volume']\n",
    "\n",
    "                if signals_dictionary[l]['position'] == 'long':\n",
    "                    last_price_long = price_data.loc[t, asset] if t in price_data.index else last_price_long\n",
    "                    long_value += last_price_long * volume\n",
    "                    portfolio.loc[t, 'long value'] = long_value\n",
    "\n",
    "                elif signals_dictionary[l]['position'] == 'short':\n",
    "                    last_price_short = price_data.loc[t, asset] if t in price_data.index else last_price_short\n",
    "                    short_value += last_price_short * volume\n",
    "                    portfolio.loc[t, 'short value'] = short_value\n",
    "\n",
    "    # Calculate total portfolio value.\n",
    "    portfolio['total_value'] = portfolio['balance'] + portfolio['long value'] + portfolio['short value']\n",
    "    \n",
    "    return portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "51459820",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 5\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "2021-01-04 00:00:00 2021-01-03 00:00:00\n",
      "2023-03-31 00:00:00 2023-04-01 00:00:00\n",
      "1 5\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "2021-01-04 00:00:00 2021-01-03 00:00:00\n",
      "2023-03-31 00:00:00 2023-04-01 00:00:00\n",
      "2 5\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "2021-01-04 00:00:00 2021-01-03 00:00:00\n",
      "2023-03-31 00:00:00 2023-04-01 00:00:00\n",
      "3 5\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "2021-01-04 00:00:00 2021-01-03 00:00:00\n",
      "2023-03-31 00:00:00 2023-04-01 00:00:00\n",
      "4 5\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "2021-01-04 00:00:00 2021-01-03 00:00:00\n",
      "2023-03-31 00:00:00 2023-04-01 00:00:00\n",
      "Index(['ABCB', 'BANR', 'AROW', 'AVT', 'BANF'], dtype='object')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>balance</th>\n",
       "      <th>long value</th>\n",
       "      <th>short value</th>\n",
       "      <th>total_value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-01-03</th>\n",
       "      <td>1000000.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1000000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-04</th>\n",
       "      <td>1000000.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1000000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-05</th>\n",
       "      <td>1000000.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1000000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-06</th>\n",
       "      <td>1000000.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1000000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-07</th>\n",
       "      <td>1000000.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1000000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-03-28</th>\n",
       "      <td>981957.360634</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>981957.360634</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-03-29</th>\n",
       "      <td>981957.360634</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>981957.360634</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-03-30</th>\n",
       "      <td>981957.360634</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>981957.360634</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-03-31</th>\n",
       "      <td>981957.360634</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>981957.360634</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-04-01</th>\n",
       "      <td>981957.360634</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>981957.360634</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>819 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                   balance  long value  short value     total_value\n",
       "2021-01-03  1000000.000000         0.0            0  1000000.000000\n",
       "2021-01-04  1000000.000000         0.0            0  1000000.000000\n",
       "2021-01-05  1000000.000000         0.0            0  1000000.000000\n",
       "2021-01-06  1000000.000000         0.0            0  1000000.000000\n",
       "2021-01-07  1000000.000000         0.0            0  1000000.000000\n",
       "...                    ...         ...          ...             ...\n",
       "2023-03-28   981957.360634         0.0            0   981957.360634\n",
       "2023-03-29   981957.360634         0.0            0   981957.360634\n",
       "2023-03-30   981957.360634         0.0            0   981957.360634\n",
       "2023-03-31   981957.360634         0.0            0   981957.360634\n",
       "2023-04-01   981957.360634         0.0            0   981957.360634\n",
       "\n",
       "[819 rows x 4 columns]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "balance_df=create_portfolio(signals_dictionary,testing_start_date,testing_end_date,initial_capital)\n",
    "balance_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "ac0b254d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "p=balance_df['total_value']\n",
    "p.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "37637ead",
   "metadata": {},
   "outputs": [],
   "source": [
    "def risk_free_capital_gain(number_of_days, annual_risk_free_rate, starting_value):\n",
    "    \"\"\"\n",
    "    Calculate the risk-free capital gain over a given number of days.\n",
    "\n",
    "    This function calculates the gain from an investment at a risk-free rate over a specified\n",
    "    number of days. The risk-free rate is assumed to be annual, and the calculation adjusts\n",
    "    it to reflect the period based on the number of days provided. The function returns the\n",
    "    gain in terms of the increase in value over the starting value, not the final amount.\n",
    "\n",
    "    Parameters:\n",
    "    - number_of_days (int): The number of days over which the capital gain is calculated.\n",
    "    - annual_risk_free_rate (float): The annual risk-free rate of return, expressed as a decimal\n",
    "      (e.g., 0.05 for 5%).\n",
    "    - starting_value (float): The initial value of the investment.\n",
    "\n",
    "    Returns:\n",
    "    - float: The gain on the starting value after the specified number of days, calculated at the\n",
    "      risk-free rate. This is the difference between the final value and the starting value.\n",
    "    \"\"\"\n",
    "    # Calculate the final value of the investment after the specified number of days\n",
    "    # at the given annual risk-free rate, then subtract the starting value to get the gain.\n",
    "    final_value = (annual_risk_free_rate + 1) ** (number_of_days / 365) * starting_value\n",
    "    return final_value - starting_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "a8163de1",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def strategy_metrics(balance_df, annual_risk_free_rate):\n",
    "    \"\"\"\n",
    "    Calculate and return key performance metrics for a trading strategy compared to a risk-free investment.\n",
    "\n",
    "    This function computes the total return, total return versus a risk-free investment, and the Sharpe ratio\n",
    "    for a given trading strategy's performance. It uses a balance DataFrame with a 'total_value' column representing\n",
    "    the portfolio's value over time, and an annual risk-free rate for comparison.\n",
    "\n",
    "    Parameters:\n",
    "    - balance_df (DataFrame): A pandas DataFrame with an index of dates and a 'total_value' column representing\n",
    "      the daily total value of the portfolio.\n",
    "    - annual_risk_free_rate (float): The annual risk-free rate of return, expressed as a decimal.\n",
    "\n",
    "    Returns:\n",
    "    - dict: A dictionary containing the number of days the strategy was run, the total return of the strategy,\n",
    "      the total return of the strategy versus a risk-free investment, and the Sharpe ratio.\n",
    "    \"\"\"\n",
    "    # Initial setup: extract starting values and prepare lists for balance tracking.\n",
    "    initial_capital = balance_df['total_value'].iloc[0]\n",
    "    date_list = list(balance_df.index)\n",
    "    balance_list = [initial_capital]\n",
    "    risk_free_balance_list = [initial_capital]\n",
    "\n",
    "    # Iterate over each date, updating the current balance and the equivalent risk-free balance.\n",
    "    for date in date_list:\n",
    "        current_balance = balance_df['total_value'].loc[date]\n",
    "        # Calculate next day's risk-free balance based on the last value in the list.\n",
    "        risk_free_balance_list.append(risk_free_capital_gain(1, annual_risk_free_rate, risk_free_balance_list[-1]))\n",
    "        balance_list.append(current_balance)\n",
    "\n",
    "    # Prepare date index for the new DataFrame, starting from the day before the first recorded date.\n",
    "    zeroth_date = date_list[0] - datetime.timedelta(days=1)\n",
    "    new_date_list = [zeroth_date] + date_list  # Prepend the starting date.\n",
    "\n",
    "    # Construct the balance DataFrame with daily returns calculated.\n",
    "    balance_df = pd.DataFrame({'balance': balance_list}, index=new_date_list)\n",
    "    balance_df['balance_shift'] = balance_df['balance'].shift(1)  # Shift for return calculation.\n",
    "    balance_df = balance_df.dropna()  # Remove the first row with NaN.\n",
    "    balance_df['daily_returns'] = (balance_df['balance'] - balance_df['balance_shift']) / balance_df['balance_shift']\n",
    "\n",
    "    # Similarly, construct the risk-free balance DataFrame.\n",
    "    risk_free_balance_df = pd.DataFrame({'risk_free_balance': risk_free_balance_list}, index=new_date_list)\n",
    "    risk_free_balance_df['risk_free_balance_shift'] = risk_free_balance_df['risk_free_balance'].shift(1)\n",
    "    risk_free_balance_df = risk_free_balance_df.dropna()\n",
    "    risk_free_balance_df['risk_free_daily_returns'] = (\n",
    "        risk_free_balance_df['risk_free_balance'] - risk_free_balance_df['risk_free_balance_shift']\n",
    "    ) / risk_free_balance_df['risk_free_balance_shift']\n",
    "\n",
    "    # Calculate total return, total return versus risk-free, and the Sharpe ratio if daily returns' standard deviation is positive.\n",
    "    total_return = (balance_df['balance'].iloc[-1] - initial_capital) / initial_capital\n",
    "    total_return_vs_risk_free = (balance_df['balance'].iloc[-1] - risk_free_balance_list[-1]) / risk_free_balance_list[-1]\n",
    "    if balance_df['daily_returns'].std() > 0:\n",
    "        sharpe_ratio = (\n",
    "            balance_df['daily_returns'].mean() - risk_free_balance_df['risk_free_daily_returns'].mean()\n",
    "        ) / balance_df['daily_returns'].std()\n",
    "    else:\n",
    "        sharpe_ratio = np.nan\n",
    "\n",
    "    # Compile and return the metrics in a dictionary.\n",
    "    metrics = {\n",
    "        'number_of_days': len(date_list),\n",
    "        'total_return': total_return,\n",
    "        'total_return_vs_risk_free': total_return_vs_risk_free,\n",
    "        'sharpe_ratio': sharpe_ratio\n",
    "    }\n",
    "\n",
    "    return metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "edb017de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'number_of_days': 819,\n",
       " 'total_return': -0.0180426393661499,\n",
       " 'total_return_vs_risk_free': -0.028970680312917742,\n",
       " 'sharpe_ratio': -0.07318617034308068}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "annual_risk_free_rate = 0.005\n",
    "strategy_metrics(balance_df,annual_risk_free_rate )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}