Team_09_Assignment (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec2ddc47",
   "metadata": {},
   "outputs": [],
   "source": [
    "#These are the libraries you can use.  You may add any libraries directy related to threading if this is a direction\n",
    "#you wish to go (this is not from the course, so it's entirely on you if you wish to use threading).  Any\n",
    "#further libraries you wish to use you must email me, james@uwaterloo.ca, for permission.\n",
    "\n",
    "from IPython.display import display, Math, Latex\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import numpy_financial as npf\n",
    "import yfinance as yf\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c688afd8",
   "metadata": {},
   "source": [
    "## Group Assignment\n",
    "### Team Number: 09\n",
    "### Team Member Names: Jacob, William, Michael\n",
    "### Team Strategy Chosen: Market Beat "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff5abea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constants\n",
    "start_date = \"2023-10-01\"\n",
    "end_date = \"2024-09-30\"\n",
    "min_volume = 100000\n",
    "# Load tickers from CSV\n",
    "tickers = pd.read_csv('Tickers_Example.csv', header=None)\n",
    "tickers_list = tickers[0].tolist()\n",
    "\n",
    "# Function to validate tickers\n",
    "def validate_tickers(tickers, start_date, end_date):\n",
    "    \n",
    "    # Download data for all tickers\n",
    "    all_data = yf.download(tickers, start=start_date, end=end_date, group_by='ticker', auto_adjust=True)\n",
    "    \n",
    "    valid_tickers = []\n",
    "    \n",
    "    for ticker in tickers:\n",
    "        try:\n",
    "            # Access individual ticker data\n",
    "            ticker_data = all_data[ticker]\n",
    "            ticker_data.index = pd.to_datetime(ticker_data.index)\n",
    "            \n",
    "            # Resample to monthly and count trading days\n",
    "            month_day_count = ticker_data['Volume'].resample('ME').count()\n",
    "            valid_months = month_day_count[month_day_count >= 18]  # Months with at least 18 trading days\n",
    "            \n",
    "            # Filter the data for valid months\n",
    "            ticker_data = ticker_data[ticker_data.index.to_period('M').isin(valid_months.index.to_period('M'))]\n",
    "            \n",
    "            # Check currency and average volume\n",
    "            ticker_obj = yf.Ticker(ticker)\n",
    "            average_volume = ticker_data['Volume'].mean()\n",
    "            if ticker_obj.fast_info['currency'] in ['CAD', 'USD'] and average_volume >= min_volume:\n",
    "                valid_tickers.append(ticker)\n",
    "        except Exception as e:\n",
    "            print(f\"Error processing ticker {ticker}: {e}\")\n",
    "    \n",
    "    return valid_tickers\n",
    "\n",
    "# Validate tickers\n",
    "valid_tickers = validate_tickers(tickers_list, start_date, end_date)\n",
    "\n",
    "# Printing the DataFrame\n",
    "valid_tickers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d683d99e",
   "metadata": {},
   "outputs": [],
   "source": [
    "rating_list = []\n",
    "\n",
    "for ticker in valid_tickers:\n",
    "    try:\n",
    "        # Get the ticker object and fetch data\n",
    "        Ticker = yf.Ticker(ticker)\n",
    "        info = Ticker.info\n",
    "        \n",
    "        # Getting Beta\n",
    "        beta = info.get('beta')\n",
    "\n",
    "        # Get the historical data\n",
    "        hist = Ticker.history(period=\"1y\", interval=\"1d\")\n",
    "\n",
    "        # Drop rows with missing 'Close' prices\n",
    "        if 'Close' in hist.columns:\n",
    "            hist = hist.dropna(subset=['Close'])\n",
    "        else:\n",
    "            raise ValueError(f\"Missing 'Close' column for ticker {ticker}\")\n",
    "\n",
    "        # Check if the cleaned data is still non-empty\n",
    "        if not hist.empty:\n",
    "            \n",
    "            # Calculate standard deviation, Sharpe ratio\n",
    "            std = hist['Close'].std()\n",
    "            avg_daily_returns = hist['Close'].pct_change().mean()\n",
    "            expected_return = (1 + avg_daily_returns) ** 252 - 1\n",
    "            sharpe = ((expected_return - 0.04) / std) * 100\n",
    "            \n",
    "        else:\n",
    "            # If no data remains after dropping missing rows, set to None\n",
    "            std = None\n",
    "            sharpe = None\n",
    "\n",
    "        # Append results to the beta list\n",
    "        rating_list.append([ticker, beta, std, sharpe])\n",
    "    except Exception as e:\n",
    "        print(f\"Error processing ticker {ticker}: {e}\")\n",
    "        continue\n",
    "\n",
    "# Create a DataFrame\n",
    "calculation_df = pd.DataFrame(rating_list, columns=['Ticker', 'Beta', 'Standard Deviation', 'Sharpe']).set_index('Ticker')\n",
    "\n",
    "# Remove rows with missing values\n",
    "calculation_df = calculation_df.dropna()\n",
    "\n",
    "# Compute the sum of Beta, Standard Deviation, and Sharpe\n",
    "beta_sum = calculation_df['Beta'].sum()\n",
    "std_sum = calculation_df['Standard Deviation'].sum()\n",
    "sharpe_sum = calculation_df['Sharpe'].sum()\n",
    "\n",
    "# Calculate the Rating\n",
    "calculation_df['Rating'] = (\n",
    "    (calculation_df['Beta'] / beta_sum) * 0.4 +\n",
    "    (calculation_df['Standard Deviation'] / std_sum) * 0.2 +\n",
    "    (calculation_df['Sharpe'] / sharpe_sum) * 0.4)\n",
    "\n",
    "# Sort by Rating in descending order and keep only the top 12 rows\n",
    "sorted_df = calculation_df.sort_values(by='Rating', ascending=False).head(12)\n",
    "\n",
    "# Printing the sorted DataFrame\n",
    "sorted_df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcb6ba1a",
   "metadata": {},
   "source": [
    "The overall strategy exhibited by the portfolio is based on that of momentum investing, in which stocks which have increased in value over a recent period are invested in. This approach is based on the premise that stocks which have recently performed well are likely to continue their upwards trajectory. Despite its inherent risk, the strategy is frequently used by existing algorithmic trading models. \n",
    "\n",
    "After filtering out stocks that don't meet the given requirements, key properties on each one are computed. First, the beta of the stock, which measures volatility relative to the market, is retrieved, as well as the stock's standard deviation. Sharpe Ratio, a comparison of return relative to risk, is also calculated. For calculating Sharpe ratio, risk-free returns were estimated at 4%; this was based on the benchmark yield of a 10-year Canadian government bond, which as of November 2024 was around 3.3%. The 4% figure was used to prioritize stocks with high expected returns.\n",
    "\n",
    "A few strict requirements are imposed on stocks in order for them to be considered for the final portfolio. First, tickers with a beta value below 1 were eliminated, in order to eliminate low-volatility stocks that might not align with the goal of maximizing returns. Second, tickers with a negative Sharpe ratio are removed, effectively eliminating any stock with an expected return below 4%. This ensures that all selected stocks trend upwards and exhibit positive momentum. \n",
    "\n",
    "For stocks which meet these requirements, Beta, standard deviation, and Sharpe ratio are all weighed at 40%, 20%, and 40% respectively and summed up to provide an overall rating for each stock. To achieve this, all three properties are standardized relative to the rest of the stocks in portfolio in order to provide for a balanced rating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35c9700c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fetch market cap data using yfinance\n",
    "market_caps = []\n",
    "for ticker in sorted_df.index:\n",
    "    market_caps.append(yf.Ticker(ticker).info['marketCap'])\n",
    "sorted_df['Market Cap'] = market_caps\n",
    "\n",
    "\n",
    "\n",
    "# Normalize the ratings to a 0-1 scale\n",
    "sorted_df['Normalized Rating'] = (sorted_df['Rating'] - sorted_df['Rating'].min()) / (sorted_df['Rating'].max() - sorted_df['Rating'].min())\n",
    "\n",
    "# Normalize market cap to a 0-1 scale\n",
    "sorted_df['Normalized Market Cap'] = (sorted_df['Market Cap'] - sorted_df['Market Cap'].min()) / (sorted_df['Market Cap'].max() - sorted_df['Market Cap'].min())\n",
    "\n",
    "# Calculate the combined weight: 70% rating, 30% market cap\n",
    "sorted_df['Ultimate Rating'] = 0.7 * sorted_df['Normalized Rating'] + 0.3 * sorted_df['Normalized Market Cap']\n",
    "\n",
    "\n",
    "# Calculate initial weighting based on our ultimate rating (disregarding constraints)\n",
    "sorted_df['Initial Weight'] = sorted_df['Ultimate Rating']/sorted_df['Ultimate Rating'].sum()\n",
    "\n",
    "\n",
    "# The constraints as listed in assignment\n",
    "min_weight = 100/(2*len(sorted_df))/100\n",
    "max_weight = 0.15\n",
    "\n",
    "# Redistributing weights until they satisfy\n",
    "while True:\n",
    "    \n",
    "    # All tickers that are above weigh limit, are set to the upper weight limit, all that are below, are set to the lower weight limit\n",
    "    sorted_df['Adjusted Weight'] = np.clip(sorted_df['Initial Weight'], min_weight, max_weight)\n",
    "\n",
    "\n",
    "    # Check if total weight sums up to 1\n",
    "    total_weight = sorted_df['Adjusted Weight'].sum()\n",
    "    remaining_weight = 1 - total_weight\n",
    "\n",
    "    # If remaining weight is 0 then stop because all tickers are finished weighing\n",
    "    if abs(remaining_weight) == 0:\n",
    "        break\n",
    "\n",
    "    # Get all tickers that are below upper weght limit\n",
    "    below_max = sorted_df['Adjusted Weight'] < max_weight\n",
    "    total_below_max = sorted_df.loc[below_max, 'Adjusted Weight'].sum()\n",
    "\n",
    "    \n",
    "    # Check if there are any stocks with Adjusted Weight below the maximum allowed weight\n",
    "    if total_below_max > 0:\n",
    "        \n",
    "    # Calculate how much weight to redistribute to each stock with weight below max_weight\n",
    "    # Proportionally distribute the remaining weight based on the current adjusted weight of each stock\n",
    "        redistribution = remaining_weight * (sorted_df.loc[below_max, 'Adjusted Weight'] / total_below_max)\n",
    "    \n",
    "    # Add the calculated redistribution amount to the Initial Weight of each stock\n",
    "    # This increases the weight of each eligible stock proportionally\n",
    "        sorted_df.loc[below_max, 'Initial Weight'] += redistribution\n",
    "    else:\n",
    "        break  # No stocks available to redistribute\n",
    "\n",
    "# Ensure weights sum to 1\n",
    "sorted_df['Final Weight'] = sorted_df['Adjusted Weight'] / sorted_df['Adjusted Weight'].sum()\n",
    "\n",
    "# Display results\n",
    "print(f\"The summed up weight is {sorted_df['Final Weight'].sum()}\")\n",
    "sorted_df[['Rating', 'Final Weight']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a54c097a",
   "metadata": {},
   "source": [
    "\n",
    "One last variable is introduced in order to create a final rating. Market capitalization, the total value of a company's outstanding shares on the stock market, is standardized to be in the range of 0 to 1 and weighted at 30% of the final rating (thereby reducing the actual weights of the previous variables). Generally, higher market-cap companies enjoy greater financial security and are less speculative in nature, making their historical performance a more reliable metric. This factor was introduced in order to add a measure of stability to the portfolio without sacrificing significant profitability. \n",
    "\n",
    "Although it may seem precarious or incomprehensive to base each stock's rating on only four criteria, the strength of the formula is ultimately derived from its simplicity. By focusing on a few critical metrics rather than overfitting the model with too many variables, the formula ensures that weight is only given to impactful factors and statistical noise is averted. \n",
    "\n",
    "After each stock has been given its final rating, its weight in the portolfio is based on the proportion of its rating to the combined rating of the top twelve stocks, although the final weight also takes into account the upper and lower limits on the proportion of each stock in the portfolio.\n",
    "\n",
    "The decision to only include the top twelve stocks wasn't taken lightly. However, prioritizing concentration over diversification was necessary in order to ensure that the porfolio's capital was allocated solely to high-potential investments. Although diversified portfolios experience less risk, gains are often diluted by low-performing stocks. This occurence was observable in assignment 3, in which the inclusion of sectors outside of the tech industry (which is known for high risk and growth potential) greatly reduced the overall returns of a portfolio. The benefits of concetrated portfolios have been emphasized by renowned investors such as Warren Buffet, who explained his rationale with the following analogy: \"If you have Lebron James on your team, don't take him out of the game just to make room for someone else… It's crazy to put money into your 20th choice rather than your first choice.\" Transaction fees are also lowered, although this benefit is more marginal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3289ec6",
   "metadata": {},
   "outputs": [],
   "source": [
    "buy_date = '2024-11-22'\n",
    "\n",
    "# Creating the Final DataFrame\n",
    "Portfolio_Final = pd.DataFrame()\n",
    "Portfolio_Final['Ticker'] = sorted_df.index\n",
    "Portfolio_Final.index = Portfolio_Final.index + 1 # Adjusting the index\n",
    "\n",
    "# Empty arrays to add to the Final Portfolio later on\n",
    "currency = []\n",
    "price = []\n",
    "weight = []\n",
    "money = 1000000\n",
    "shares = []\n",
    "\n",
    "# Getting the exchange rate\n",
    "exchangeRate = yf.Ticker('USDCAD=x').history(start=buy_date)['Close']\n",
    "\n",
    "for ticker in Portfolio_Final['Ticker']:\n",
    "    ticker_obj = yf.Ticker(ticker)\n",
    "    \n",
    "    # Adjusting stock prices to CAD\n",
    "    if ticker_obj.fast_info['currency'] == 'USD':\n",
    "        ticker_price = ticker_obj.history(start=buy_date)['Close'].iloc[0] * exchangeRate.iloc[0]\n",
    "    else:\n",
    "        ticker_price = ticker_obj.history(start=buy_date)['Close'].iloc[0]\n",
    "        \n",
    "    # Price\n",
    "    price.append(ticker_price)\n",
    "    \n",
    "    # Adjusting for Fees\n",
    "    moneyAllocated = sorted_df.loc[ticker, 'Final Weight'] * money\n",
    "    buy_price = ticker_price\n",
    "    quantity = moneyAllocated / buy_price\n",
    "    if quantity > 3950:\n",
    "        fee = 3.95\n",
    "    else:\n",
    "        fee = quantity * 0.001\n",
    "    \n",
    "    # Number of Shares\n",
    "    actualQuantity = (moneyAllocated - fee) / buy_price\n",
    "\n",
    "    # Shares\n",
    "    shares.append(actualQuantity)\n",
    "    \n",
    "    # Currency\n",
    "    currency.append(ticker_obj.fast_info['currency'])\n",
    "\n",
    "# Adding everything to the Final Portfolio\n",
    "Portfolio_Final['Price'] = price\n",
    "Portfolio_Final['Currency'] = currency\n",
    "Portfolio_Final['Shares'] = shares\n",
    "Portfolio_Final['Value'] = Portfolio_Final['Shares']*Portfolio_Final['Price']\n",
    "Portfolio_Final['Weight'] = sorted_df['Final Weight'].values\n",
    "\n",
    "print(\"The final portfolio's value is $\" + str(Portfolio_Final['Value'].sum()) + \" CAD after fees.\")\n",
    "print(\"The total portfolio weight is \" + str(Portfolio_Final['Weight'].sum()*100) +\"%\")\n",
    "\n",
    "Portfolio_Final\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2abda91",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Outputting the Final Portfolio to CSV\n",
    "Stocks_Final = pd.concat([Portfolio_Final['Ticker'], Portfolio_Final['Shares']], axis=1)\n",
    "Stocks_Final.to_csv('Stocks_Group_09.csv', index=False)\n",
    "\n",
    "\n",
    "## Displaying Final DataFrame\n",
    "Stocks_Final"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4acaf232",
   "metadata": {},
   "source": [
    "## Contribution Declaration\n",
    "\n",
    "The following team members made a meaningful contribution to this assignment:\n",
    "\n",
    "Insert Names Here: Jacob, William, Michael"
   ]
  }
 ],
 "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.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}