yf_stock_picker_p1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "12eb3879-88e6-4d0d-82c6-d8617d9e9886",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "f8ab961b-4341-4874-a804-a9a5ed3272ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read stocks\n",
    "import yfinance as yf\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "# To read external property file\n",
    "from jproperties import Properties"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "750f98d8-a244-464f-84a9-69a1d6759aa1",
   "metadata": {},
   "source": [
    "## Load External Configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "bd5eb68b-e7fd-428f-a1e5-de3d7ab98741",
   "metadata": {},
   "outputs": [],
   "source": [
    "configs = Properties()\n",
    "\n",
    "with open('config/yf_stock_picker_p1.properties', 'rb') as config_file:\n",
    "     configs.load(config_file)\n",
    "\n",
    "SYMBOLS = configs.get('SYMBOLS').data.split(',') \n",
    "TICKER = configs.get('TICKER').data\n",
    "METRICS = configs.get('METRICS').data.split(',')\n",
    "WEIGHTS = configs.get('WEIGHTS').data.split(',')\n",
    "\n",
    "# Convert weights to integers\n",
    "WEIGHTS = [int(i) for i in WEIGHTS]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa88826-0325-4885-9b96-eb5881be7dc7",
   "metadata": {},
   "source": [
    "## Data Frame to collect metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "19a2698e-9ca6-48e5-acbb-a5565ea4da9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# DF to collect key metrics\n",
    "key_metrics_df = pd.DataFrame()\n",
    "# DF to collect exclusions\n",
    "key_metrics_ex_df = pd.DataFrame()\n",
    "# Initialize list with empty dictionaries. This collects raw metrics data for each metric\n",
    "raw_metrics = [{} for sub in range(len(METRICS))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "538dccca-0954-4531-bec8-621483cd7800",
   "metadata": {},
   "source": [
    "## Utility method to compute Opearting Margin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "5db726f5-a08f-478a-8df7-6f9587f286f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computes operating margin\n",
    "# ticker - ticker symbol to calculate operating income\n",
    "def compute_om(ticker):\n",
    "    income_stmt_df = ticker.income_stmt\n",
    "    # Check to see whether Operating Income exists in the income statement first\n",
    "    if 'Operating Income' in income_stmt_df.index:\n",
    "        op_income = income_stmt_df.loc['Operating Income'][0]\n",
    "        tot_revenue = income_stmt_df.loc['Total Revenue'][0]\n",
    "        op_margin = op_income/tot_revenue\n",
    "    else:\n",
    "        # No 'Operating Income' found, use the margin taion from the info section\n",
    "        op_margin = ticker.info['operatingMargins']\n",
    "    return op_margin"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "012ea034-d76f-4cfa-b6bc-0db43e89735a",
   "metadata": {},
   "source": [
    "## Utility method to return the ranking position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "54d52d81-ca81-4b8b-b352-6a504bed85db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns the ranking;  -1 if the given ticker is not found in the metric\n",
    "# raw_dict - dictionary of values to rank; dictionary -> symbol, value\n",
    "# order - True for descending order or False for ascending\n",
    "def get_ranking(raw_dict, order, ticker):\n",
    "    # Rank the dictionary values in ascending/descending order\n",
    "    ranked_dict = dict(sorted(raw_dict.items(), key=lambda item: item[1], reverse=order))\n",
    "    \n",
    "    if TICKER in ranked_dict:\n",
    "        return (list(ranked_dict).index(ticker) + 1)\n",
    "    # No ranking found, due to a metric is not found with the ticker\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03cdc465-a86e-4399-a49d-a4105d83ba56",
   "metadata": {},
   "source": [
    "## Utility method to return a key metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "c1692198-db64-4e73-a355-fcb42de400c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns a key metric row to add it to the DF\n",
    "# metrict_dict - a metric dictionary -> symbol, value\n",
    "# metric_name - name of the metric\n",
    "# order - order for ranking, default is True, i.e., descending\n",
    "def get_key_metrics_row(metric_dict, metric_name, order=True):\n",
    "    # Get the ranking\n",
    "    ranking = get_ranking(metric_dict, order, TICKER)\n",
    "    if ranking == -1:\n",
    "        return {'Metric':metric_name, 'Value':'NA', 'Ranking':'NA'}    \n",
    "    return {'Metric':metric_name, 'Value':metric_dict[TICKER], 'Ranking':f'{(ranking)}/{len(metric_dict)}'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b7555d-265f-4d54-8e93-03c240e2c74d",
   "metadata": {},
   "source": [
    "## Collect Key Metrics data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "15a887ed-a7c0-4410-afe9-9b587fbeb47a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "for symbol in SYMBOLS:\n",
    "    ticker = yf.Ticker(symbol)\n",
    "    # Calculate Operating Margin and convert it to percentage\n",
    "    raw_metrics[0][symbol] = round((compute_om(ticker) * 100), 2)\n",
    "\n",
    "    # Dividend Yield -> Check to see whether the dividend yield exists for the symbol\n",
    "    if 'dividendYield' in ticker.info:\n",
    "        raw_metrics[1][symbol] = round((ticker.info['dividendYield'] * 100), 2)\n",
    "    else:\n",
    "        new_row = {'Symbol':symbol, 'Metric':METRICS[1], 'Reason':'Missing Dividend Yield'}\n",
    "        key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "\n",
    "    # Dividend Cover -> Check to see whether the dividend rate exists for the symbol\n",
    "    if 'dividendRate' in ticker.info:\n",
    "        raw_metrics[2][symbol] = round((ticker.info['trailingEps']/ticker.info['dividendRate']), 2)\n",
    "    else:\n",
    "        new_row = {'Symbol':symbol, 'Metric':METRICS[2], 'Reason':'Missing Dividend Rate'}\n",
    "        key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "\n",
    "    # Debt/EBITDA; check it whether total debt exists in income statement\n",
    "    if 'Total Debt' in ticker.balance_sheet.index:\n",
    "        debt_to_ebitda = round((ticker.balance_sheet.loc['Total Debt'][0]/ticker.income_stmt.loc['EBITDA'][0]), 2)\n",
    "        # We only take into ccount with positive ratios or else they will impact rankings\n",
    "        if debt_to_ebitda >= 0:\n",
    "            raw_metrics[3][symbol] = debt_to_ebitda\n",
    "        else:\n",
    "            new_row = {'Symbol':symbol, 'Metric':METRICS[3], 'Reason':'Negative Debt/EBITDA ratio'}\n",
    "            key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "    else:\n",
    "        new_row = {'Symbol':symbol, 'Metric':METRICS[3], 'Reason':'Missing Total Debt'}\n",
    "        key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "\n",
    "    # Fwd P/E -> Check to see whether the Fwd P/E exists for the symbol\n",
    "    if 'forwardPE' in ticker.info:\n",
    "        fwd_pe = ticker.info['forwardPE']\n",
    "        if  fwd_pe >= 0:\n",
    "            raw_metrics[4][symbol] = round(fwd_pe, 2)\n",
    "        else:\n",
    "            new_row = {'Symbol':symbol, 'Metric':METRICS[4], 'Reason':'Negaive Forward P/E ratio'}\n",
    "            key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)        \n",
    "    else:\n",
    "        new_row = {'Symbol':symbol, 'Metric':METRICS[4], 'Reason':'Missing Forward P/E ratio'}\n",
    "        key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "    \n",
    "    # PEG Ration -> Check to see whether the PEG ration exists for the symbol\n",
    "    if 'pegRatio' in ticker.info:\n",
    "        peg_ratio = ticker.info['pegRatio']\n",
    "        if peg_ratio >= 0:\n",
    "            raw_metrics[5][symbol] = peg_ratio\n",
    "        else:\n",
    "            new_row = {'Symbol':symbol, 'Metric':METRICS[5], 'Reason':'Negaive PEG ratio'}\n",
    "            key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)                    \n",
    "    else:\n",
    "        new_row = {'Symbol':symbol, 'Metric':METRICS[5], 'Reason':'Missing PEG Ratio'}\n",
    "        key_metrics_ex_df = pd.concat([key_metrics_ex_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c54f14a8-9bb0-4fce-852f-84a019159bd0",
   "metadata": {},
   "source": [
    "## Set Key Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "69113082-8705-4737-8380-933a2aede1d8",
   "metadata": {},
   "outputs": [
    {
     "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>Metric</th>\n",
       "      <th>Value</th>\n",
       "      <th>Ranking</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Operating Margin</td>\n",
       "      <td>-3.57</td>\n",
       "      <td>15/18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Dividend Yield</td>\n",
       "      <td>NA</td>\n",
       "      <td>NA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Dividend Cover</td>\n",
       "      <td>NA</td>\n",
       "      <td>NA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Debt/EBITDA</td>\n",
       "      <td>22.86</td>\n",
       "      <td>15/16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>P/E ratio</td>\n",
       "      <td>32.49</td>\n",
       "      <td>12/17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>PEG ratio</td>\n",
       "      <td>1.29</td>\n",
       "      <td>4/16</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Metric  Value Ranking\n",
       "0  Operating Margin  -3.57   15/18\n",
       "1    Dividend Yield     NA      NA\n",
       "2    Dividend Cover     NA      NA\n",
       "3       Debt/EBITDA  22.86   15/16\n",
       "4         P/E ratio  32.49   12/17\n",
       "5         PEG ratio   1.29    4/16"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for pos in range(len(METRICS)):\n",
    "    if (pos >= 3):\n",
    "        # Ranking is on ascending order (lower the better)\n",
    "        new_row = get_key_metrics_row(raw_metrics[pos], METRICS[pos], False)\n",
    "    else:\n",
    "        new_row = get_key_metrics_row(raw_metrics[pos], METRICS[pos])\n",
    "    key_metrics_df = pd.concat([key_metrics_df, pd.DataFrame([new_row])], ignore_index=True)\n",
    "key_metrics_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1e3abc8-5678-42dc-b419-cd99db009e5f",
   "metadata": {},
   "source": [
    "## Display Key Metrics Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "debc3f98-2473-499c-be0f-6088598426bf",
   "metadata": {},
   "outputs": [
    {
     "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>Symbol</th>\n",
       "      <th>Metric</th>\n",
       "      <th>Reason</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CDNS</td>\n",
       "      <td>Dividend Yield</td>\n",
       "      <td>Missing Dividend Yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CDNS</td>\n",
       "      <td>Dividend Cover</td>\n",
       "      <td>Missing Dividend Rate</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>WDAY</td>\n",
       "      <td>Dividend Yield</td>\n",
       "      <td>Missing Dividend Yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>WDAY</td>\n",
       "      <td>Dividend Cover</td>\n",
       "      <td>Missing Dividend Rate</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>TEAM</td>\n",
       "      <td>Dividend Yield</td>\n",
       "      <td>Missing Dividend Yield</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Symbol          Metric                  Reason\n",
       "0   CDNS  Dividend Yield  Missing Dividend Yield\n",
       "1   CDNS  Dividend Cover   Missing Dividend Rate\n",
       "2   WDAY  Dividend Yield  Missing Dividend Yield\n",
       "3   WDAY  Dividend Cover   Missing Dividend Rate\n",
       "4   TEAM  Dividend Yield  Missing Dividend Yield"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_metrics_ex_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "449a032a-e1d7-4aae-b30e-41416ed07e87",
   "metadata": {},
   "source": [
    "## Calculate the Score for each metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "cda4460f-bca2-4c54-a6b3-e613da888764",
   "metadata": {},
   "outputs": [
    {
     "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>Metric</th>\n",
       "      <th>Value</th>\n",
       "      <th>Ranking</th>\n",
       "      <th>Score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Operating Margin</td>\n",
       "      <td>-3.57</td>\n",
       "      <td>15/18</td>\n",
       "      <td>0.22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Dividend Yield</td>\n",
       "      <td>NA</td>\n",
       "      <td>NA</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Dividend Cover</td>\n",
       "      <td>NA</td>\n",
       "      <td>NA</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Debt/EBITDA</td>\n",
       "      <td>22.86</td>\n",
       "      <td>15/16</td>\n",
       "      <td>0.12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>P/E ratio</td>\n",
       "      <td>32.49</td>\n",
       "      <td>12/17</td>\n",
       "      <td>0.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>PEG ratio</td>\n",
       "      <td>1.29</td>\n",
       "      <td>4/16</td>\n",
       "      <td>0.81</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Metric  Value Ranking  Score\n",
       "0  Operating Margin  -3.57   15/18   0.22\n",
       "1    Dividend Yield     NA      NA   0.00\n",
       "2    Dividend Cover     NA      NA   0.00\n",
       "3       Debt/EBITDA  22.86   15/16   0.12\n",
       "4         P/E ratio  32.49   12/17   0.35\n",
       "5         PEG ratio   1.29    4/16   0.81"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score = []\n",
    "for index, row in key_metrics_df.iterrows():\n",
    "    if row['Ranking'] == 'NA':\n",
    "        score.append(0.0)\n",
    "        continue\n",
    "    rank, total = tuple(map(int, row['Ranking'].split('/')))\n",
    "    score.append(round(((total - rank) + 1)/total,2))\n",
    "key_metrics_df['Score'] = score\n",
    "key_metrics_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a030d68-3b7c-4b4f-9d58-7de9ad58f885",
   "metadata": {},
   "source": [
    "## Calculate the final score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "7e70df34-f466-439a-b806-9692fde1f45d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score for WDAY is 2.5 out of 10\n"
     ]
    }
   ],
   "source": [
    "# Normalize the score out of 10\n",
    "ticker_score = round(((((key_metrics_df['Score'] * WEIGHTS).sum())/sum(WEIGHTS)) * 10), 2)\n",
    "print(f'Score for {TICKER} is {ticker_score} out of 10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c66d483f-b773-4002-b336-d071d4db8577",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}