diff --git "a/Stock_Benchmark Analysis copy 2.ipynb" "b/Stock_Benchmark Analysis copy 2.ipynb" new file mode 100644--- /dev/null +++ "b/Stock_Benchmark Analysis copy 2.ipynb" @@ -0,0 +1,3608 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "811bdabd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/3907943495.py:4: DtypeWarning: Columns (11,13,23,24,75,76,79,80,83,84,90) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " df = pd.read_csv('unique_companies.csv')\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Load the CSV file\n", + "df = pd.read_csv('unique_companies.csv')\n", + "\n", + "# Apply the filter\n", + "filtered_df = df[\n", + " (df['GicSubIndustry'].isin(['Copper', 'Diversified Metals & Mining'])) |\n", + " (df['Industry'] == 'Copper')\n", + "]\n", + "\n", + "# Further filter to rows where 'Industry' is 'Other Industrial Metals & Mining' or 'Copper'\n", + "final_df = filtered_df[filtered_df['Industry'].isin(['Other Industrial Metals & Mining', 'Copper'])]\n", + "\n", + "# Save the result to a new CSV if needed\n", + "final_df.to_csv('unique_companies_copper.csv', index=False)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7a7c854a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ticker transformation complete. Saved as unique_companies_copper_updated.csv\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Read the CSV\n", + "df = pd.read_csv(\"unique_companies_copper.csv\")\n", + "\n", + "# Mapping dictionary\n", + "mapping = {\n", + " \"US\": \"\",\n", + " \"LSE\": \".L\",\n", + " \"STU\": \".SG\",\n", + " \"KO\": \".KS\",\n", + " \"WAR\": \".WA\",\n", + " \"SHG\": \".SS\",\n", + " \"NSE\": \".NS\",\n", + " \"AU\": \".AX\",\n", + " \"JSE\": \".JO\",\n", + " \"KLSE\": \".KL\",\n", + " \"SHE\": \".SZ\"\n", + "}\n", + "\n", + "def convert_ticker(ticker):\n", + " try:\n", + " base, suffix = ticker.split(\".\")\n", + " if suffix in mapping:\n", + " return base + mapping[suffix]\n", + " else:\n", + " return ticker # leave unchanged if no match\n", + " except ValueError:\n", + " return ticker # in case ticker doesn't contain \".\"\n", + " \n", + "# Apply transformation\n", + "df[\"PrimaryTicker\"] = df[\"PrimaryTicker\"].apply(convert_ticker)\n", + "\n", + "# Save the updated CSV\n", + "df.to_csv(\"unique_companies_copper_updated.csv\", index=False)\n", + "\n", + "print(\"Ticker transformation complete. Saved as unique_companies_copper_updated.csv\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "261ce11e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1830 tickers (including HG=F).\n", + "Downloading batch 1: 50 tickers\n", + "Downloading batch 2: 50 tickers\n", + "Downloading batch 3: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['5RJ.F']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 4: 50 tickers\n", + "Downloading batch 5: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['ACLHF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 6: 50 tickers\n", + "Downloading batch 7: 50 tickers\n", + "Downloading batch 8: 50 tickers\n", + "Downloading batch 9: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2 Failed downloads:\n", + "['BR0.F', 'BMOOD']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 10: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['C0O.F']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 11: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2 Failed downloads:\n", + "['CMETF', 'CMDRF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 12: 50 tickers\n", + "Downloading batch 13: 50 tickers\n", + "Downloading batch 14: 50 tickers\n", + "Downloading batch 15: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2 Failed downloads:\n", + "['ERW.AX', 'EROSF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 16: 50 tickers\n", + "Downloading batch 17: 50 tickers\n", + "Downloading batch 18: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['GRFX']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 19: 50 tickers\n", + "Downloading batch 20: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['JRV.V']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 21: 50 tickers\n", + "Downloading batch 22: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['LLI.AX']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 23: 50 tickers\n", + "Downloading batch 24: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['MLYF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 25: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2 Failed downloads:\n", + "['NALA.TA', 'NGLD.F']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 26: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "3 Failed downloads:\n", + "['NSMCF', 'NOCRF', 'NVLIF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 27: 50 tickers\n", + "Downloading batch 28: 50 tickers\n", + "Downloading batch 29: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['RCZRF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 30: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['RLL.AX']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 31: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['SIE.V']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 32: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['SMCDF']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 33: 50 tickers\n", + "Downloading batch 34: 50 tickers\n", + "Downloading batch 35: 50 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2 Failed downloads:\n", + "['VLV.V', 'V6Y.F']: YFPricesMissingError('possibly delisted; no price data found (period=6y) (Yahoo error = \"No data found, symbol may be delisted\")')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading batch 36: 50 tickers\n", + "Downloading batch 37: 30 tickers\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['5RJ.F']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Repairing via single-ticker fetch: ['5RJ.F', 'ACLHF', 'BMOOD', 'BR0.F', 'C0O.F', 'CMDRF', 'CMETF', 'EROSF', 'ERW.AX', 'GRFX', 'JRV.V', 'LLI.AX', 'MLYF', 'NALA.TA', 'NGLD.F', 'NOCRF', 'NSMCF', 'NVLIF', 'RCZRF', 'RLL.AX', 'SIE.V', 'SMCDF', 'V6Y.F', 'VLV.V']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "1 Failed download:\n", + "['ACLHF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['BMOOD']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['BR0.F']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['C0O.F']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['CMDRF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['CMETF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['EROSF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['ERW.AX']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['GRFX']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['JRV.V']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['LLI.AX']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['MLYF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['NALA.TA']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['NGLD.F']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['NOCRF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['NSMCF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['NVLIF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['RCZRF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['RLL.AX']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['SIE.V']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['SMCDF']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['V6Y.F']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n", + "\n", + "1 Failed download:\n", + "['VLV.V']: YFRateLimitError('Too Many Requests. Rate limited. Try after a while.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dropping tickers with no usable data: ['5RJ.F', 'ACLHF', 'BMOOD', 'BR0.F', 'C0O.F', 'CMDRF', 'CMETF', 'EROSF', 'ERW.AX', 'GRFX', 'JRV.V', 'LLI.AX', 'MLYF', 'NALA.TA', 'NGLD.F', 'NOCRF', 'NSMCF', 'NVLIF', 'RCZRF', 'RLL.AX', 'SIE.V', 'SMCDF', 'V6Y.F', 'VLV.V']\n", + "df_prices shape: (1570, 1806)\n", + "Columns: ['HG=F', '000060.SZ', '000426.SZ', '000603.SZ', '000630.SZ', '000657.SZ', '000737.SZ', '000751.SZ', '000758.SZ', '000762.SZ', '000795.SZ', '000878.SZ', '000960.SZ', '000962.SZ', '000969.SZ', '002114.SZ', '002149.SZ', '002155.SZ', '002171.SZ', '002203.SZ', '002378.SZ', '002428.SZ', '002716.SZ', '002738.SZ', '002842.SZ', '002978.SZ', '005810.KS', '00D0.F', '010130.KS', '08W.F', '0CM.F', '0ED.F', '0N4.F', '0PA.F', '0WL.F', '0XX.F', '14S.F', '1AJ2.F', '1D4.F', '1JWA.F', '1K4.F', '1MC.AX', '1OI.F', '1QV.F', '1RR1.F', '1SN.L', '1SZ.F', '1TG.F', '1TT0.F', '1VU0.F', '2009.TW', '20MICRONS.NS', '2220.F', '22Q0.F', '26A1.F', '2CC2.F', '2DK.F', '2I7.F', '2IK.F', '2JCA.F', '2NZ.F', '2QD0.F', '2QPA.F', '2REA.F', '2SO0.F', '2XM.F', '300618.SZ', '300697.SZ', '300930.SZ', '301026.SZ', '301219.SZ', '301511.SZ', '30Z.F', '30Z0.F', '31WN.F', '338B.F', '33X1.F', '34S0.F', '37N.F', '381.F', '39G.F', '3B4.F', '3F9.F', '3FL.F', '3FNA.F', '3FR0.F', '3GE.F', '3GRE.F', '3JC0.F', '3N4.SG', '3NY1.F', '3PM.F', '3S7.F', '3WQ0.F', '40A.F', '432.F', '47GA.F', '48U0.F', '4989.TW', '4A0.F', '4AP.F', '4U50.F', '4V9.F', '4W0.F', '4XH.F', '4XJ.F', '4YW.F', '5298.KL', '540.F', '55D.F', '5E8.F', '5EG.F', '5FG.F', '5GE2.F', '5HR.F', '5IP.F', '5KG0.F', '5KP.F', '5N91.F', '5P0.F', '5PE.F', '5PMA.F', '5V8.F', '600111.SS', '600255.SS', '600259.SS', '600331.SS', '600338.SS', '600362.SS', '600392.SS', '600456.SS', '600490.SS', '600497.SS', '600531.SS', '600549.SS', '600711.SS', '600961.SS', '601020.SS', '601061.SS', '601121.SS', '601137.SS', '601168.SS', '601212.SS', '601609.SS', '601958.SS', '603124.SS', '603132.SS', '603399.SS', '603799.SS', '603979.SS', '603993.SS', '64O.F', '688102.SS', '688231.SS', '688388.SS', '6AY.F', '6D71.F', '6E9.F', '6GS.F', '6ND1.F', '6Q5.F', '6S3A.F', '6TH.MU', '77C.F', '7C6A.F', '7CX.F', '7GI.F', '7JL.F', '7KO.F', '7LY0.F', '7S50.F', '7UE.F', '7WV.F', '7WW.F', '7Y2.F', '7Z00.F', '862.F', '87K.F', '8AMA.F', '8BY1.F', '8CD1.F', '8CHA.F', '8EE.F', '8GCA.F', '8L10.F', '8N6.F', '8OH.F', '8XJ.F', '90AA.F', '92G.MU', '97E0.F', '97G0.F', '9927.TW', '9CM0.F', '9D00.F', '9ED.F', '9EU.F', '9IA.F', '9PZ.F', '9S70.F', '9SC.F', '9TI.F', 'A1G.AX', 'A1S.F', 'A2R.F', 'AABB', 'AAGFF', 'AAL.L', 'AB-H.V', 'ABAT', 'ABCFF', 'ABEPF', 'ABRMF', 'ABZ.V', 'ACMDY', 'ACNE', 'ACP.AX', 'ACRL', 'ADBRF', 'ADC.AX', 'ADMLF', 'ADT1.L', 'ADTLF', 'ADV.AX', 'ADXDF', 'AEV.AX', 'AFM.V', 'AFMJF', 'AFP.L', 'AFR.V', 'AGR.AX', 'AGREF', 'AGXPF', 'AGY.AX', 'AHG.F', 'AHN.AX', 'AHR.V', 'AHS.F', 'AIS.AX', 'AIV.AX', 'AKN.AX', 'AKO.AX', 'AL9.F', 'ALB.AX', 'ALBA.L', 'ALBAF', 'ALEEF', 'ALI0.F', 'ALL.L', 'ALLIF', 'ALM.AX', 'ALMTF', 'ALR.AX', 'ALT.V', 'ALTAF', 'ALTPF', 'AM7.AX', 'AMC.TO', 'AMD.AX', 'AME.V', 'AMG.AS', 'AMI.AX', 'AMLM', 'AMN.AX', 'AMR.V', 'AMRRY', 'AMSLF', 'AMVMF', 'AMYZF', 'ANDMF', 'ANFGF', 'ANGCF', 'ANLBF', 'ANSNF', 'ANX.AX', 'AOA.AX', 'AON.AX', 'APC.AX', 'APCOF', 'APH.JO', 'AQD.AX', 'AQX.AX', 'AR1.AX', 'AR3.AX', 'ARAAF', 'ARAFF', 'ARB3.F', 'ARCM.L', 'ARCT.ST', 'ARD.AX', 'ARDDF', 'ARDNF', 'ARENTERP.NS', 'ARI.JO', 'ARIZF', 'ARJN.V', 'ARJNF', 'ARK.L', 'ARN.AX', 'ARR.AX', 'ARREF', 'ARRRF', 'ARS.L', 'ARSMF', 'ARSRF', 'ARTTF', 'ARU.AX', 'ARXRF', 'ARYMF', 'ASCU.TO', 'ASCUF', 'ASE.AX', 'ASHAPURMIN.NS', 'ASHXF', 'ASKE', 'ASMMF', 'ASN.AX', 'ATBHF', 'ATCMF', 'ATCUF', 'ATM.L', 'ATMMF', 'ATN.L', 'ATOM.V', 'ATOXF', 'ATR.AX', 'ATUSF', 'ATVVF', 'ATY.F', 'ATYM.L', 'AU31.F', 'AU5.F', 'AUE.AX', 'AUG.AX', 'AUMC', 'AUMTF', 'AUN1.F', 'AUR-H.V', 'AUR.AX', 'AURWF', 'AUSDF', 'AUZ.AX', 'AVL.AX', 'AVL.TO', 'AVLNF', 'AVPMF', 'AVRTF', 'AVX.V', 'AW1.AX', 'AWLIF', 'AWMLF', 'AX8.AX', 'AXN.AX', 'AXO.V', 'AXREF', 'AXVEF', 'AYM.L', 'AYT.AX', 'AZ3.F', 'AZ9.AX', 'AZI.AX', 'AZL.AX', 'AZLAF', 'AZM.V', 'AZMCF', 'AZMTF', 'AZZTF', 'B.V', 'B4T0.F', 'B9S.F', 'BAG.V', 'BAJFF', 'BAL-H.V', 'BAPA.F', 'BATXF', 'BBBMF', 'BCA.AX', 'BCMRF', 'BCU.V', 'BCUFF', 'BCW1.F', 'BDD.F', 'BDNNY', 'BDRGF', 'BELMF', 'BEM.L', 'BENZF', 'BER-H.V', 'BFGFF', 'BHAGYANGR.NS', 'BHL.L', 'BHLIF', 'BHP', 'BHP.AX', 'BHPN.MX', 'BHSIF', 'BITTF', 'BJ4.F', 'BKI.TO', 'BKM.V', 'BKMNF', 'BKT.AX', 'BKTPF', 'BLIDF', 'BLLYF', 'BLNMF', 'BLSTF', 'BLTH', 'BM.V', 'BM8.AX', 'BMG.AX', 'BML.AX', 'BMM.AX', 'BMM.V', 'BMOOF', 'BMTLF', 'BMVVF', 'BNTRF', 'BNZ.AX', 'BOA.AX', 'BOCA.V', 'BOL.ST', 'BONE.V', 'BORK', 'BOTX.ST', 'BP60.F', 'BRES.L', 'BRGC', 'BRIOF', 'BRKCF', 'BRL-H.V', 'BRMS.JK', 'BRTN.F', 'BRUZF', 'BRVRF', 'BRVVF', 'BRYGF', 'BSG0.F', 'BSHVF', 'BSSMF', 'BTRMF', 'BTRYF', 'BUR.AX', 'BUR.F', 'BUS.AX', 'BUX.AX', 'BVLDF', 'BVR.AX', 'BWJ0.F', 'BWNAF', 'BWR.V', 'BYDMF', 'BYH.AX', 'BZDLF', 'C1Z.F', 'C29.AX', 'C2U.F', 'C3F.F', 'C5C.F', 'C730.F', 'C7A.AX', 'CAEN', 'CAML.L', 'CAMLF', 'CAMZF', 'CAPFF', 'CASXF', 'CATTF', 'CAULF', 'CAV.AX', 'CAXA.F', 'CAXPF', 'CB82.F', 'CBA.V', 'CBBHF', 'CBBLF', 'CBE.AX', 'CBEEF', 'CBI.V', 'CBRSF', 'CBULF', 'CC9.AX', 'CCCFF', 'CCD.V', 'CCE.V', 'CCEDF', 'CCOB', 'CCOOF', 'CCWOF', 'CCY.F', 'CDBDF', 'CDBMF', 'CDL.L', 'CDMNF', 'CEO-H.V', 'CFV0.F', 'CGMLF', 'CHF.L', 'CHKMF', 'CHR.AX', 'CHW.AX', 'CHZQ', 'CLA.AX', 'CLA.L', 'CLE.AX', 'CLGMF', 'CLLXF', 'CLRSF', 'CLZ.AX', 'CMCLF', 'CMD.AX', 'CMET.L', 'CMG.AX', 'CMIM', 'CMLGF', 'CMO-H.V', 'CMO.AX', 'CMP', 'CMRZF', 'CMTNF', 'CNIKF', 'CNJ.AX', 'CNMTF', 'CNOBF', 'CNRSF', 'CNSUF', 'CNTO', 'CNX.V', 'COD.AX', 'CODMF', 'COH.F', 'COMCF', 'CONE.V', 'CONXF', 'COPAF', 'COPR', 'COSAF', 'CPAU.V', 'CPCPF', 'CPEFF', 'CPER.V', 'CPFXF', 'CPM.AX', 'CPN.AX', 'CPO.AX', 'CPORF', 'CPPKF', 'CPPMF', 'CPR.JO', 'CPYCF', 'CR1.AX', 'CR9.AX', 'CRB.AX', 'CRD.V', 'CRECF', 'CREQF', 'CRGP', 'CRI.V', 'CRICF', 'CRML', 'CRS.AX', 'CRSTF', 'CRTM.L', 'CRUCF', 'CS.TO', 'CSC.AX', 'CSCCF', 'CSRNF', 'CST.AX', 'CTJHY', 'CTL.L', 'CTLHF', 'CTN.V', 'CTTZF', 'CTXDF', 'CUAUF', 'CUBEXTUB.NS', 'CUF.AX', 'CUIRF', 'CUL.AX', 'CUSN.L', 'CUU.V', 'CVKMD.IS', 'CVLB.F', 'CVV.AX', 'CVVRF', 'CWA0.F', 'CWX.AX', 'CXOXF', 'CXXMF', 'CYDVF', 'CYGGF', 'CYLYF', 'CYM.AX', 'CYPMF', 'CZN.AX', 'CZR.F', 'D6V1.F', 'D860.F', 'DAL.AX', 'DANR', 'DAUGF', 'DBGF', 'DBLVF', 'DCNNF', 'DECXF', 'DES.AX', 'DETRF', 'DFMTF', 'DFPP.F', 'DFU.F', 'DFXN.F', 'DFYA.F', 'DGV2.F', 'DIAH', 'DJ5.F', 'DKFT.JK', 'DKM.AX', 'DKN.F', 'DLM.AX', 'DLPRF', 'DM1.AX', 'DMDD', 'DME.AX', 'DMM.AX', 'DMNKF', 'DMX.V', 'DMXCF', 'DRE.AX', 'DRR.AX', 'DRRSF', 'DRX.AX', 'DTWOF', 'DUVNF', 'DVP.AX', 'DW8.F', 'DWMNF', 'DY6.AX', 'DYM.AX', 'E06A.F', 'E25.AX', 'E2E1.F', 'E7Q.F', 'E9E.F', 'EAM.V', 'EB8.F', 'EB9.F', 'EBM.F', 'ECGFF', 'ECOR.TO', 'ECORF', 'ECRAF', 'EDDY.V', 'EDDYF', 'EE1.AX', 'EEL.AX', 'EELFF', 'EEMMF', 'EFF.V', 'EFRMF', 'EG1.AX', 'EGDFF', 'EGM.V', 'EGMMF', 'EGPLF', 'EGR.AX', 'EK7C.F', 'EKWX', 'ELBM', 'ELECF', 'ELMTF', 'ELT.AX', 'ELTLF', 'EM2.AX', 'EMC.AX', 'EMGDF', 'EMH.AX', 'EMHLF', 'EMOTF', 'EMT.AX', 'EMTRF', 'EMU.AX', 'EMUCA.AX', 'EMX', 'ENR.AX', 'ENRG.V', 'ENV.AX', 'EO0.F', 'EON.V', 'EOXFF', 'EP.V', 'EPL.V', 'EQR.AX', 'ER70.F', 'ERA.PA', 'ERD.TO', 'ERDCF', 'ERMAF', 'ERMAY', 'ERO', 'ERR.F', 'ERVFF', 'ESKYF', 'ESPN.V', 'ESR.AX', 'ESVNF', 'ESXMF', 'ETL.V', 'ETM.AX', 'ETPHF', 'ETRUF', 'EUEMF', 'EULIF', 'EUMNF', 'EUR.AX', 'EUUNF', 'EUZ.L', 'EV1.AX', 'EVG.AX', 'EVGUF', 'EVKRF', 'EVNIF', 'EVR.AX', 'EVX.V', 'F12.F', 'F5J0.F', 'F7E1.F', 'FAR.L', 'FBM.AX', 'FCLIF', 'FCM.L', 'FCSMF', 'FCX', 'FCXO34.SA', 'FDY.TO', 'FEERF', 'FEXXF', 'FFM.AX', 'FG1.F', 'FIN.AX', 'FKC0.F', 'FKM.V', 'FKMCF', 'FL1.AX', 'FLM1.F', 'FLMCF', 'FLMTF', 'FMCXF', 'FMK.F', 'FNCJF', 'FNICF', 'FPMB.F', 'FPOCF', 'FPRGF', 'FQVLF', 'FRACF', 'FRB.AX', 'FRG.L', 'FRMA', 'FRPMF', 'FRSPF', 'FSUGY', 'FSUMF', 'FSVEF', 'FSY.TO', 'FTJ.V', 'FTMDF', 'FUR.F', 'FURY', 'FUSEF', 'FUST', 'FVJ.F', 'FWEDF', 'FWL.SG', 'FX8.F', 'FXRVF', 'FYIRF', 'G12.F', 'G4U.F', 'G6A.F', 'G6D2.F', 'G6M.AX', 'G7PA.F', 'G88.AX', 'GAL.AX', 'GALOF', 'GAR-H.V', 'GARWF', 'GBBGF', 'GBDX', 'GBE.AX', 'GBEI', 'GBLEF', 'GBMIF', 'GCCFF', 'GCRCF', 'GCRIF', 'GCUMF', 'GCXXF', 'GDLNF', 'GDMIF', 'GDQMF', 'GDSKF', 'GDTRF', 'GELEF', 'GELGF', 'GEM.OL', 'GEN.AX', 'GENM.TO', 'GENMF', 'GEODF', 'GERFF', 'GES.AX', 'GESI', 'GFM.L', 'GG7.SG', 'GGI.V', 'GGIFF', 'GGTHF', 'GHVNF', 'GIGA.V', 'GIGGF', 'GJST', 'GL1.AX', 'GLATF', 'GLBXF', 'GLCNF', 'GLIIF', 'GLIOF', 'GLKIF', 'GLN.AX', 'GLNCY', 'GLNLF', 'GLR.L', 'GMA.V', 'GMBXF', 'GMWA.F', 'GMX.TO', 'GNG.AX', 'GNG.V', 'GNHRF', 'GNRGF', 'GNTOF', 'GOCOF', 'GODZF', 'GOJ1.F', 'GOLXF', 'GOMRF', 'GORAF', 'GPHOF', 'GPMTF', 'GPPRF', 'GQMLF', 'GR.V', 'GRCMF', 'GRD.V', 'GRDAF', 'GRE.AX', 'GRK.F', 'GRLRF', 'GRLVF', 'GROC.L', 'GRSLF', 'GRX.AX', 'GRX.L', 'GSCCF', 'GSCU.L', 'GSM', 'GSML', 'GSR.F', 'GSS.V', 'GSSRF', 'GT1.AX', 'GTC.V', 'GTCDF', 'GTE.AX', 'GTMLF', 'GWMGF', 'GWMO.L', 'GWRRF', 'GZDIF', 'H3N.F', 'H6F.F', 'HANCF', 'HANNF', 'HAS.AX', 'HBKRF', 'HBM', 'HBM.TO', 'HCH.V', 'HDG0.F', 'HDRSF', 'HECOF', 'HF2.F', 'HGGCF', 'HGO.AX', 'HGO.F', 'HHLKF', 'HHSRF', 'HI.V', 'HILL.JK', 'HIN.MU', 'HINDCOPPER.NS', 'HINDZINC.NS', 'HIO.AX', 'HLGVF', 'HLX.AX', 'HNCUF', 'HOR.AX', 'HPQ.V', 'HPQFF', 'HPYCF', 'HRE.AX', 'HREEF', 'HRFEF', 'HSRMF', 'HT9.F', 'HTM.AX', 'HTRC', 'HUSIF', 'HVY.AX', 'HZLIF', 'HZNM', 'IBATF', 'IBC-H.V', 'ICG.AX', 'ID4.F', 'IDZ1.F', 'IE', 'IE.TO', 'IFSH.JK', 'IG6.AX', 'IGFFF', 'IGO.AX', 'IHB1.F', 'IHS.F', 'IIDDY', 'ILHMF', 'ILI.V', 'ILKAF', 'ILKAY', 'ILU.AX', 'IMA.AX', 'IMC.F', 'IMC.L', 'IMI.AX', 'IMIMF', 'IMPEXFERRO.NS', 'IMTCF', 'INCO.JK', 'INF.AX', 'INR.AX', 'INTR.V', 'INUMF', 'IONGF', 'IONR', 'IPMLF', 'IPOAF', 'IPT.AX', 'IPX', 'IPX.AX', 'ITM.AX', 'ITMIF', 'IVPAF', 'IVR.AX', 'IXRRF', 'IYAA.F', 'J0G.F', 'J1Q0.F', 'JAN.L', 'JAV.AX', 'JBY.AX', 'JD1.F', 'JGRRF', 'JI4.F', 'JIX.F', 'JLL.AX', 'JLRRF', 'JMS.AX', 'JMXXF', 'JNDAF', 'JNOMF', 'JORFF', 'JR1.F', 'JR9.F', 'JUBPF', 'JUGRF', 'JXMNF', 'JZRIF', 'K2I.F', 'K4L.F', 'KAV.L', 'KCC.V', 'KCCFF', 'KDM.F', 'KDNC.L', 'KEN.L', 'KGH.WA', 'KGHPF', 'KGLLF', 'KLDCF', 'KLI.AX', 'KMGLF', 'KMR.L', 'KMRPF', 'KNG.AX', 'KNGRF', 'KNI.AX', 'KOD.L', 'KOGMF', 'KOR.AX', 'KOZAA.IS', 'KP1.F', 'KP10.F', 'KP2.L', 'KRS.L', 'KTR.V', 'KVGOF', 'KWGBF', 'L1M.AX', 'L3L2.F', 'LA.V', 'LAC', 'LANRF', 'LAR', 'LBNKF', 'LBSR', 'LCE.V', 'LCGMF', 'LEG.AX', 'LEL.AX', 'LEMIF', 'LEX.AX', 'LEXTF', 'LGM.AX', 'LGO', 'LGU.F', 'LI.V', 'LIF.F', 'LIFFF', 'LILIF', 'LIN.AX', 'LINRF', 'LIRC.TO', 'LIS.V', 'LISMF', 'LITM', 'LITOF', 'LITRF', 'LITSF', 'LKE.AX', 'LKMNF', 'LKY1.F', 'LLKKF', 'LLL.AX', 'LLLAF', 'LM1.AX', 'LM8.AX', 'LMG.AX', 'LML.AX', 'LMRMF', 'LMSQF', 'LND.L', 'LNDLF', 'LNR.AX', 'LOMEF', 'LOT.AX', 'LPD.AX', 'LPDNF', 'LPM.AX', 'LQK2.F', 'LQRCF', 'LR8.F', 'LRA.V', 'LRAXF', 'LRD.AX', 'LSA.AX', 'LSANF', 'LSLCF', 'LTH.V', 'LTHCF', 'LTHIF', 'LTMCF', 'LTRBF', 'LTSRF', 'LTUM', 'LUCMF', 'LUNMF', 'LXENF', 'LYC.AX', 'LYIC.F', 'LYK.AX', 'LYSCF', 'LYSDY', 'LZ61.F', 'LZM', 'M0G.F', 'M0LY.F', 'M1C1.F', 'M1W.F', 'M24.AX', 'M2R.AX', 'MAC.AX', 'MACQF', 'MAH.AX', 'MALRF', 'MALRY', 'MANVF', 'MARI.TO', 'MARIF', 'MARVF', 'MAU.AX', 'MAXXF', 'MAZ-H.V', 'MCHHF', 'MCL.NS', 'MCREF', 'MDI.TO', 'MDKA.JK', 'MDMN', 'MDNGF', 'MDSQF', 'MEDAF', 'MEEEF', 'MEG.AX', 'MERKO.AT', 'MET1.L', 'MFRVF', 'MGA.AX', 'MGCV', 'MGL.AX', 'MGMNF', 'MGPHF', 'MGT.AX', 'MGU.AX', 'MGXMF', 'MHIFF', 'MHK.AX', 'MIDLF', 'MIMTF', 'MIN.AX', 'MINE.V', 'MIO.AX', 'MJDLF', 'MKNGF', 'MKR.V', 'MKRIF', 'MLG.AX', 'MLGAF', 'MLGCF', 'MLKKF', 'MLLOF', 'MLN.F', 'MLPNF', 'MLSUM.PA', 'MLX.AX', 'MLXEF', 'MLYCF', 'MLZAM.PA', 'MMILF', 'MMLTF', 'MMMKF', 'MNMRF', 'MNXMF', 'MNXXF', 'MOLYMET.SN', 'MOON.V', 'MP', 'MQM.V', 'MQMIF', 'MQR.AX', 'MRD.AX', 'MREYF', 'MRF.JO', 'MRL.AX', 'MRQ.AX', 'MRR.AX', 'MRRDF', 'MSMGF', 'MSV.AX', 'MT1.F', 'MTAL', 'MTB.AX', 'MTBMF', 'MTC.AX', 'MTH.AX', 'MTJ3.F', 'MTLFF', 'MTLI', 'MTRN', 'MTS.V', 'MTU.JO', 'MUNMF', 'MURCF', 'MURMF', 'MXB0.F', 'MXTRF', 'MYRLF', 'MYRUF', 'N3EN.F', 'N6D.F', 'N8HP.F', 'N9SA.F', 'NAK', 'NATUF', 'NB', 'NBLC.V', 'NBM.V', 'NBMFF', 'NBMLF', 'NBRFF', 'NBTRF', 'NBYCF', 'NC1.AX', 'NC3.F', 'NCFFF', 'NCKL.JK', 'NCPCF', 'NDMCF', 'NE0.F', 'NEV.V', 'NEXA', 'NFM.AX', 'NGLOY', 'NGPHF', 'NGX.AX', 'NGXLF', 'NGXXF', 'NIC.AX', 'NICL.JK', 'NICLF', 'NICMF', 'NICN.V', 'NICOF', 'NILA', 'NILIF', 'NIM.AX', 'NIO.ST', 'NIOBW', 'NIOCF', 'NKGFF', 'NKLXF', 'NLGCF', 'NLIBF', 'NLPXF', 'NM5.F', 'NM9A.F', 'NMG', 'NMNZF', 'NMR.AX', 'NMREF', 'NMTLF', 'NNL.AX', 'NNX.V', 'NOAL.V', 'NOM.OL', 'NOURF', 'NPTH', 'NQMLF', 'NRGYF', 'NRHI', 'NRN.V', 'NRRMF', 'NRVTF', 'NRX.AX', 'NSHRF', 'NSRCF', 'NTCPF', 'NTM.AX', 'NTU.AX', 'NU0.F', 'NVA', 'NVA.AX', 'NVLHF', 'NVRA.F', 'NVSGF', 'NWC.AX', 'NWCBF', 'NWCCF', 'NWPG', 'NWX.V', 'NWXPF', 'NXGM', 'NYM.AX', 'NYR.BR', 'NYRSY', 'NZN.V', 'NZP.V', 'O08.F', 'O2R2.F', 'OARFF', 'OBGRF', 'OC.V', 'OCKA.F', 'OCN.AX', 'OD6.AX', 'ODX-H.V', 'OGD.TO', 'OLY.AX', 'OM.V', 'OM1.AX', 'OMH.AX', 'OMHLF', 'OMZNF', 'ORESF', 'ORISSAMINE.NS', 'ORMNF', 'ORN.JO', 'ORQ1.F', 'OTMN', 'OTS-H.V', 'OU5A.F', 'OUW0.F', 'OW3.F', 'OWRDF', 'P4G.F', 'P77.F', 'PAANF', 'PAT.AX', 'PBL.AX', 'PBMLF', 'PCRCF', 'PE&OLES.MX', 'PE.V', 'PEIMF', 'PEK.AX', 'PEMC.V', 'PEMIF', 'PEMSF', 'PEX.AX', 'PFE.AX', 'PFFOF', 'PGE.V', 'PGEZF', 'PGP.V', 'PGPGF', 'PGX.V', 'PGXFF', 'PGZ.V', 'PGZFF', 'PHO.AX', 'PIHN', 'PILBF', 'PIM.AX', 'PJXRF', 'PKREF', 'PLL', 'PLLTL', 'PLN.AX', 'PLS.AX', 'PLSR.V', 'PLY.V', 'PLYFF', 'PMAM3.SA', 'PMDRF', 'PMETF', 'PML.V', 'PMMCF', 'PMOMF', 'PMYLF', 'PNGM', 'PNN.AX', 'PNPNF', 'PNTZF', 'PNX.F', 'POD.AX', 'POROF', 'POW.L', 'PPZRF', 'PR1.AX', 'PRCK', 'PRE.L', 'PREM.L', 'PRMMF', 'PRMNF', 'PRN.AX', 'PSC.AX', 'PSGR', 'PSL.AX', 'PSRHF', 'PTNDY', 'PTRO.JK', 'PUCOBRE.SN', 'PUR.AX', 'PURE.JK', 'PUTKF', 'PUTKY', 'PVT.AX', 'PWCRF', 'PWMCF', 'PWRLF', 'PWRMF', 'PX0.F', 'PXC.L', 'PXCLF', 'PXMFF', 'PXX.AX', 'PXXXF', 'PYV.F', 'Q.V', 'QCCUF', 'QFB.F', 'QGL.AX', 'QMCQF', 'QNBMF', 'QNICF', 'QQREF', 'QR20.F', 'QUEXF', 'QURI.V', 'QXR.AX', 'QZMRF', 'R1EA.F', 'R2FA.F', 'R2TA.F', 'R8L.F', 'R9GA.F', 'RADR', 'RAJMET.NS', 'RAREF', 'RARMF', 'RATHF', 'RBMTF', 'RBWRF', 'RCKTF', 'RDM.AX', 'RDS.AX', 'RDTMF', 'RE8.F', 'REB.DU', 'REC.AX', 'RECHF', 'REE.AX', 'REE.V', 'REEEF', 'REEMF', 'REMRF', 'REZZF', 'RFC4.F', 'RFLXF', 'RFXRF', 'RGLSF', 'RGM-H.V', 'RGVNF', 'RIE.AX', 'RIGMF', 'RIO', 'RIO.AX', 'RIO.BA', 'RIO.L', 'RKMSF', 'RKR.V', 'RLC.AX', 'RM9.F', 'RMESF', 'RMI.AX', 'RMNXF', 'RNU.AX', 'RNX.AX', 'ROYIF', 'RR1.F', 'RRMLF', 'RRR.AX', 'RRR.L', 'RTNTF', 'RTR.AX', 'RTRFF', 'RTTGF', 'RVT.AX', 'RXF.F', 'RYOOF', 'RZT.F', 'S0G.F', 'S2R.AX', 'S32.AX', 'S32.L', 'S35A.F', 'S5M.F', 'S5WA.F', 'S6Q1.F', 'S8QN.F', 'SAGARDEEP.NS', 'SAGGF', 'SAIDF', 'SAL.F', 'SALT.V', 'SAM.TO', 'SAMMF', 'SAO.V', 'SARKY.IS', 'SAU.TO', 'SAV.F', 'SAVNF', 'SBR.AX', 'SBWFF', 'SCCFF', 'SCCO', 'SCLTF', 'SCVFF', 'SCYYF', 'SCZ.V', 'SEHKF', 'SER.AX', 'SFR.AX', 'SFRRF', 'SFX.AX', 'SGA.AX', 'SGML', 'SGPTF', 'SGQ.AX', 'SGZ.V', 'SHCMF', 'SHERF', 'SHL.V', 'SHN.AX', 'SHP.AX', 'SIERF', 'SILEF', 'SJRNF', 'SKE', 'SKKRF', 'SKP.V', 'SLB.AX', 'SLCO', 'SLGGF', 'SLI', 'SLMFF', 'SLMLF', 'SLROF', 'SLS.AX', 'SLSDF', 'SLTFF', 'SLVDF', 'SLZ.AX', 'SLZNF', 'SMC.TO', 'SMDZF', 'SME.V', 'SMM.AX', 'SMMYY', 'SMRVF', 'SMTSF', 'SNLGF', 'SNTAF', 'SOUHY', 'SPC.V', 'SPCNF', 'SPNRF', 'SPQ.AX', 'SQH.F', 'SQX.AX', 'SRAFF', 'SRCAF', 'SRCGF', 'SRCX', 'SRGMF', 'SRGXF', 'SRHYY', 'SRKZF', 'SRLZF', 'SRN.AX', 'SRQRF', 'SRR0.F', 'SRSLF', 'SRSN', 'SRSR', 'SRZ.AX', 'SS5.F', 'SSEBF', 'SSYRF', 'STACF', 'STGDF', 'STHFF', 'STKXF', 'STLNF', 'STMNF', 'STRPF', 'STS.V', 'STSBF', 'STTSY', 'STUD.V', 'STUV.V', 'STXPF', 'SUH.AX', 'SUIFF', 'SULMF', 'SVBL', 'SVMFF', 'SVML.L', 'SVMLF', 'SVY.AX', 'SWNLF', 'SXOOF', 'SYA.AX', 'SYAXF', 'SYHBF', 'SZ71.F', 'T4W.F', 'T5MB.F', 'T62.F', 'T7Y1.F', 'TAOFF', 'TASEF', 'TCVNF', 'TDG.V', 'TEA.V', 'TECK', 'TECK-A.TO', 'TELHF', 'TEM.AX', 'TFM.V', 'TG50.F', 'TG6.AX', 'TGB', 'TGN.AX', 'TGOLF', 'THORF', 'THR.AX', 'THSGF', 'THURF', 'TI.TO', 'TIH1.F', 'TIMCF', 'TIMNF', 'TINO', 'TINS.JK', 'TKM.AX', 'TKO.L', 'TKRFF', 'TLGRF', 'TLOFF', 'TM1.L', 'TMASF', 'TMC', 'TMCWW', 'TMD0.F', 'TMET.V', 'TMG.AX', 'TMGLF', 'TMQ', 'TMRC', 'TMRFF', 'TMS.AX', 'TMSA.F', 'TNC.AX', 'TNGZF', 'TNR.V', 'TNREF', 'TNTMF', 'TOEYF', 'TON.AX', 'TORVF', 'TR3.F', 'TRBMF', 'TRCTF', 'TREVQ', 'TRKUF', 'TROUF', 'TRRCF', 'TRRGF', 'TRRXF', 'TTEXF', 'TTIRF', 'TTLXF', 'TTSRF', 'TUN.L', 'TVCCF', 'TVER', 'TVIPF', 'TVN.AX', 'TWO.V', 'TWOSF', 'TWRFF', 'TYM.L', 'TZN.AX', 'U40.F', 'U7N1.F', 'U9V.MU', 'UAMY', 'UD7C.F', 'UDE0.F', 'UH7A.F', 'UKI.F', 'ULTHF', 'ULTXF', 'UMR.L', 'UPCO', 'URANF', 'URCFF', 'UREKF', 'UREQF', 'URPLF', 'USAR', 'USCUF', 'USGO', 'USGOW', 'USHAF', 'USREF', 'UURAF', 'UUSAF', 'V44.F', 'V5W.F', 'V8V.F', 'VANAF', 'VAND.V', 'VANTF', 'VAR.AX', 'VBAMF', 'VC1.F', 'VCT.V', 'VCUFF', 'VCVVF', 'VDO-H.V', 'VDOMF', 'VDTAF', 'VEDL.NS', 'VERT.V', 'VHM.AX', 'VLT.V', 'VLTLF', 'VLTMF', 'VM3.F', 'VML.AX', 'VMXXF', 'VOP.F', 'VOY0.F', 'VR8.AX', 'VRBFF', 'VRC.AX', 'VRCFF', 'VRCV', 'VRRCF', 'VRX.AX', 'VTMLF', 'VTMXF', 'VUL.AX', 'VUL.F', 'VUL.V', 'VULMF', 'VULNF', 'VZLA', 'W2F.F', 'W5E.F', 'WA1.AX', 'WA8.AX', 'WAK.AX', 'WALRF', 'WAORF', 'WARAF', 'WCUFF', 'WDFCF', 'WDGNF', 'WESMF', 'WEZ.JO', 'WHY.V', 'WIN.AX', 'WKT.AX', 'WLFFF', 'WMK.V', 'WML.V', 'WMLLF', 'WMNNF', 'WN9.F', 'WOLV', 'WR1.AX', 'WRC.F', 'WRE1.F', 'WRN', 'WRSLF', 'WSZWF', 'WTCRF', 'WTCZF', 'WX0.F', 'WYX.AX', 'X0V.F', 'X28.F', 'XCPT', 'XJC.F', 'XPL', 'XT3B.F', 'XTC.AX', 'XTERF', 'XTPT', 'XVALO.MC', 'XXIX.V', 'Y0L.F', 'Y33.F', 'YAR.AX', 'YBB.F', 'YORKF', 'YT1.F', 'YWRLF', 'Z25.F', 'ZBNI.V', 'ZBNIF', 'ZCB.F', 'ZCC-H.V', 'ZE0.F', 'ZEO.AX', 'ZMI.AX', 'ZNC.AX', 'ZNCXF', 'ZNWD.L', 'ZNWLF', 'ZYR1.F', 'ZZZOF']\n", + "Saved to 'df_prices.csv'.\n" + ] + } + ], + "source": [ + "# ------------------------------------------------------------\n", + "# Build df_prices.csv for HG=F + tickers in unique_companies_copper.csv\n", + "# • period=\"5y\" (more reliable than start/end for some venues)\n", + "# • Prefer 'Adj Close', fallback to 'Close'\n", + "# • Re-download single tickers that are all-NaN in batch (e.g., 2IK.F)\n", + "# ------------------------------------------------------------\n", + "# pip install yfinance pandas\n", + "\n", + "import pandas as pd\n", + "import yfinance as yf\n", + "\n", + "CSV_PATH = \"unique_companies_copper_updated.csv\"\n", + "TICKER_COL = \"PrimaryTicker\"\n", + "UNDERLYING = \"HG=F\"\n", + "BATCH_SIZE = 50\n", + "OUT_CSV = \"df_prices.csv\"\n", + "\n", + "# --- Read tickers ---\n", + "tickers = (\n", + " pd.read_csv(CSV_PATH, usecols=[TICKER_COL])[TICKER_COL]\n", + " .dropna().astype(str).str.strip().str.upper().tolist()\n", + ")\n", + "tickers = sorted(set(tickers))\n", + "if UNDERLYING not in tickers:\n", + " tickers = [UNDERLYING] + tickers\n", + "\n", + "print(f\"Found {len(tickers)} tickers (including {UNDERLYING}).\")\n", + "\n", + "def _extract_adj_or_close(df_multi: pd.DataFrame) -> tuple[pd.DataFrame, list[str]]:\n", + " \"\"\"From yfinance multi-ticker frame, prefer 'Adj Close', else 'Close' per ticker.\"\"\"\n", + " if not isinstance(df_multi.columns, pd.MultiIndex):\n", + " raise ValueError(\"Expected MultiIndex columns for multi-ticker download.\")\n", + " fields = set(df_multi.columns.get_level_values(-1))\n", + " adj = df_multi.xs(\"Adj Close\", axis=1, level=-1, drop_level=True) if \"Adj Close\" in fields else pd.DataFrame(index=df_multi.index)\n", + " clo = df_multi.xs(\"Close\", axis=1, level=-1, drop_level=True) if \"Close\" in fields else pd.DataFrame(index=df_multi.index)\n", + "\n", + " cols = sorted(set(adj.columns).union(clo.columns))\n", + " out = pd.DataFrame(index=df_multi.index, columns=cols, dtype=\"float64\")\n", + " used_close = []\n", + "\n", + " for t in cols:\n", + " a = adj[t] if t in adj.columns else None\n", + " c = clo[t] if t in clo.columns else None\n", + " if a is not None and not a.dropna().empty:\n", + " out[t] = a\n", + " elif c is not None and not c.dropna().empty:\n", + " out[t] = c\n", + " used_close.append(t)\n", + " return out, used_close\n", + "\n", + "def _download_batch(batch):\n", + " df = yf.download(\n", + " tickers=batch,\n", + " period=\"6y\",\n", + " interval=\"1d\",\n", + " auto_adjust=False,\n", + " actions=False,\n", + " progress=False,\n", + " group_by=\"ticker\",\n", + " threads=True\n", + " )\n", + " if isinstance(df.columns, pd.MultiIndex):\n", + " return _extract_adj_or_close(df)\n", + " else:\n", + " # Single-ticker shape\n", + " tkr = batch[0]\n", + " adj = df.get(\"Adj Close\")\n", + " clo = df.get(\"Close\")\n", + " used_close = []\n", + " if adj is not None and not adj.dropna().empty:\n", + " out = adj.rename(tkr).to_frame()\n", + " elif clo is not None and not clo.dropna().empty:\n", + " out = clo.rename(tkr).to_frame()\n", + " used_close.append(tkr)\n", + " else:\n", + " out = pd.DataFrame(index=df.index, columns=[tkr], dtype=\"float64\")\n", + " return out, used_close\n", + "\n", + "def _download_single(tkr: str) -> pd.Series:\n", + " \"\"\"Single-ticker repair path; prefer Adj Close, else Close.\"\"\"\n", + " df = yf.download(\n", + " tickers=tkr,\n", + " period=\"5y\",\n", + " interval=\"1d\",\n", + " auto_adjust=False,\n", + " actions=False,\n", + " progress=False\n", + " )\n", + " s = df.get(\"Adj Close\")\n", + " if s is None or s.dropna().empty:\n", + " s = df.get(\"Close\")\n", + " if s is None:\n", + " return pd.Series(dtype=\"float64\", name=tkr)\n", + " return s.rename(tkr)\n", + "\n", + "# --- Batch download + merge ---\n", + "frames, used_close_all = [], []\n", + "for i in range(0, len(tickers), BATCH_SIZE):\n", + " batch = tickers[i:i+BATCH_SIZE]\n", + " print(f\"Downloading batch {i//BATCH_SIZE + 1}: {len(batch)} tickers\")\n", + " part, used_close = _download_batch(batch)\n", + " frames.append(part)\n", + " used_close_all.extend(used_close)\n", + "\n", + "df_prices = pd.concat(frames, axis=1)\n", + "df_prices = df_prices.loc[:, ~df_prices.columns.duplicated()].sort_index()\n", + "\n", + "# --- Repair tickers that are NaN-only or missing after batch ---\n", + "to_repair = [t for t in tickers if (t in df_prices.columns and df_prices[t].dropna().empty) or (t not in df_prices.columns)]\n", + "to_repair = sorted(set(to_repair))\n", + "if to_repair:\n", + " print(f\"Repairing via single-ticker fetch: {to_repair}\")\n", + " for t in to_repair:\n", + " s = _download_single(t)\n", + " if not s.dropna().empty:\n", + " df_prices = df_prices.reindex(df_prices.index.union(s.index)).sort_index()\n", + " df_prices[t] = s.reindex(df_prices.index)\n", + "\n", + "# --- Order columns; drop all-NaN tickers ---\n", + "ordered_cols = [UNDERLYING] + [t for t in tickers if t != UNDERLYING and t in df_prices.columns]\n", + "df_prices = df_prices.reindex(columns=ordered_cols)\n", + "all_nan_cols = [c for c in df_prices.columns if df_prices[c].dropna().empty]\n", + "if all_nan_cols:\n", + " print(f\"Dropping tickers with no usable data: {all_nan_cols}\")\n", + " df_prices = df_prices.drop(columns=all_nan_cols)\n", + "\n", + "# --- Report fallback usage ---\n", + "used_close_all = sorted(set([t for t in used_close_all if t in df_prices.columns]))\n", + "if used_close_all:\n", + " print(f\"Used 'Close' fallback for: {used_close_all}\")\n", + "\n", + "print(\"df_prices shape:\", df_prices.shape)\n", + "print(\"Columns:\", list(df_prices.columns))\n", + "\n", + "# --- Save ---\n", + "df_prices.to_csv(OUT_CSV, index_label=\"Date\", float_format=\"%.6f\")\n", + "print(f\"Saved to '{OUT_CSV}'.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "11079562", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Missing % by ticker ===\n", + " missing_pct\n", + "NIOBW 99.936306\n", + "PWMCF 99.936306\n", + "USGOW 99.936306\n", + "SSEBF 99.936306\n", + "MEDAF 98.216561\n", + "... ...\n", + "MLSUM.PA 1.974522\n", + "NYR.BR 1.974522\n", + "AMG.AS 1.974522\n", + "ERA.PA 1.910828\n", + "MLZAM.PA 1.910828\n", + "\n", + "[1806 rows x 1 columns]\n", + "\n", + "Dropping 555 tickers (> 10% missing): ['NIOBW', 'PWMCF', 'USGOW', 'SSEBF', 'MEDAF', 'AXO.V', 'BMOOF', 'APCOF', '603124.SS', 'LEXTF', 'MRD.AX', 'RECHF', 'NFM.AX', 'WAORF', 'GGTHF', 'WESMF', 'NKGFF', 'RCKTF', 'DETRF', 'AMRRY', 'LIFFF', 'ASCUF', 'NGXXF', 'PMETF', 'EMU.AX', 'NVA', '1MC.AX', 'EMH.AX', 'CSC.AX', 'IMTCF', 'ASE.AX', 'CWA0.F', 'MAC.AX', 'AWLIF', 'CPPMF', 'C7A.AX', 'PSRHF', 'JGRRF', 'CC9.AX', 'SRSLF', 'LAC', 'VMXXF', 'PLN.AX', 'DMXCF', '301511.SZ', 'NGXLF', 'JBY.AX', 'PLSR.V', 'SRQRF', 'MET1.L', 'USAR', 'Y0L.F', 'HNCUF', 'UREKF', 'TRRCF', 'CHW.AX', 'DY6.AX', 'LITSF', 'COSAF', 'HZLIF', 'NLIBF', 'FRSPF', 'NGX.AX', 'LITRF', 'NCKL.JK', 'EUEMF', 'FCLIF', 'ITMIF', 'CYGGF', 'SGPTF', 'VANAF', 'CNRSF', 'CPR.JO', '601061.SS', 'HILL.JK', 'USGO', 'CVKMD.IS', 'MYRUF', '601121.SS', 'EG1.AX', 'PRMMF', 'LM1.AX', 'NB', 'EELFF', 'LIRC.TO', 'LOMEF', 'FLMCF', 'NOAL.V', 'CTLHF', 'TMGLF', 'SQX.AX', 'MAXXF', 'QNBMF', 'CLA.L', 'VBAMF', 'HTM.AX', 'ADC.AX', 'DYM.AX', 'LTSRF', 'CYPMF', 'VHM.AX', 'H3N.F', 'WRSLF', '9EU.F', 'DES.AX', 'AWMLF', 'CRICF', 'RVT.AX', 'PAT.AX', 'BAPA.F', 'MGMNF', '7JL.F', 'L1M.AX', 'GLNLF', 'GNRGF', 'GTMLF', 'MEEEF', 'Y33.F', 'JR1.F', '862.F', 'WX0.F', 'RFLXF', 'JR9.F', 'UMR.L', 'LML.AX', '381.F', 'ATN.L', 'ANDMF', 'BUS.AX', 'VAND.V', 'CPORF', '48U0.F', 'HT9.F', 'CMG.AX', 'BYDMF', 'WARAF', 'STLNF', 'GRDAF', 'JI4.F', 'CMTNF', '7KO.F', 'FLM1.F', '688231.SS', 'LLLAF', 'X28.F', 'QURI.V', 'HRE.AX', 'ALEEF', '8CD1.F', 'SVMLF', 'LINRF', 'HF2.F', 'EVNIF', 'NICN.V', 'PMOMF', 'PWRLF', 'FCM.L', 'WN9.F', '5P0.F', 'CDBDF', '8L10.F', 'LTHCF', 'SGA.AX', 'IONR', 'IE', 'EO0.F', '2220.F', 'IE.TO', 'MGA.AX', 'OCN.AX', 'IPX', '30Z0.F', 'USREF', 'LLL.AX', 'OD6.AX', 'KNG.AX', 'UUSAF', 'ZNWLF', '0PA.F', 'VLTMF', 'NNL.AX', 'TG6.AX', 'BVR.AX', 'LBNKF', 'CDMNF', '9D00.F', 'CPCPF', 'GBMIF', 'FRPMF', 'KEN.L', 'SNTAF', '301219.SZ', '688102.SS', 'SLS.AX', 'UKI.F', 'JNDAF', 'LPM.AX', 'PR1.AX', 'INUMF', 'CODMF', 'NYM.AX', 'P77.F', 'CSCCF', 'TR3.F', '1SN.L', 'ESPN.V', '603132.SS', 'LRD.AX', 'IG6.AX', 'GDTRF', 'ER70.F', 'PIM.AX', 'CTL.L', 'SLB.AX', 'ABRMF', 'OM1.AX', '9TI.F', 'CHKMF', 'BHLIF', 'CRML', 'NICOF', 'P4G.F', 'KLI.AX', 'WA1.AX', 'VZLA', '4V9.F', 'CMO.AX', '7LY0.F', 'ZBNIF', 'CPER.V', 'TRCTF', 'NC1.AX', 'NU0.F', 'HCH.V', 'ARAAF', 'GRE.AX', 'IMI.AX', '4XJ.F', 'JD1.F', 'GSCU.L', 'K2I.F', 'GRLRF', 'LZM', 'SVML.L', 'AW1.AX', 'TTLXF', 'E9E.F', 'HUSIF', 'J1Q0.F', 'YT1.F', 'QNICF', 'GELEF', 'WDGNF', 'WR1.AX', 'MNMRF', 'PBL.AX', 'LITM', 'NVLHF', 'Q.V', 'ASCU.TO', 'NIM.AX', 'H6F.F', 'CPM.AX', 'TM1.L', 'EV1.AX', 'FRG.L', 'LTRBF', 'GT1.AX', 'RTRFF', '8OH.F', 'ALLIF', 'AR1.AX', 'C29.AX', 'MMILF', '1QV.F', 'AUE.AX', 'JZRIF', '3FR0.F', '0ED.F', 'CCOOF', 'VCUFF', 'TUN.L', 'LYK.AX', 'ITM.AX', 'MANVF', 'BTRMF', '97E0.F', '540.F', 'REC.AX', '7CX.F', 'JNOMF', 'M0LY.F', '87K.F', 'GROC.L', 'DAL.AX', 'MTAL', 'EULIF', '97G0.F', 'RRR.AX', 'TMCWW', 'WIN.AX', 'NICL.JK', '9ED.F', 'TMC', 'CAMLF', '301026.SZ', 'NBTRF', 'HVY.AX', 'LGM.AX', 'CPO.AX', 'BMVVF', 'TAOFF', 'KNI.AX', 'ZBNI.V', 'SAGGF', 'TCVNF', '5298.KL', 'PFE.AX', 'HECOF', 'ORQ1.F', 'ALI0.F', 'BHL.L', 'CAPFF', 'WCUFF', 'BMM.AX', 'AGXPF', 'SPCNF', 'CHR.AX', 'ESXMF', 'BUR.AX', 'CRI.V', 'SCVFF', 'FNICF', 'REMRF', 'AR3.AX', 'VM3.F', 'AM7.AX', '7UE.F', 'SNLGF', 'LM8.AX', 'ANSNF', 'ECGFF', 'ADTLF', '7S50.F', 'CDL.L', 'AFP.L', 'ORMNF', 'EMTRF', '7Z00.F', 'LEL.AX', 'GCRCF', 'F5J0.F', '6Q5.F', '2QD0.F', 'IXRRF', 'GL1.AX', 'IDZ1.F', 'BCA.AX', 'MLG.AX', 'NBLC.V', 'ALB.AX', 'SS5.F', 'TMRFF', 'CR9.AX', 'HSRMF', '7GI.F', 'BWJ0.F', 'LTH.V', 'HANCF', 'ESVNF', '5IP.F', 'MREYF', 'GEM.OL', '300930.SZ', 'FYIRF', 'MLPNF', 'YORKF', 'NRRMF', 'FRB.AX', 'SPC.V', 'THORF', '9PZ.F', 'NM5.F', 'REEEF', 'IIDDY', 'GEN.AX', '7Y2.F', '3WQ0.F', 'LANRF', 'RBWRF', '8BY1.F', 'ZE0.F', '2SO0.F', 'ELMTF', 'BELMF', 'TRKUF', 'CATTF', 'CUSN.L', 'DLPRF', '5PE.F', 'M24.AX', 'LPDNF', 'KLDCF', 'W2F.F', 'AZLAF', 'GSCCF', 'NICLF', 'PCRCF', 'GLIOF', 'ARRRF', 'IONGF', 'ULTHF', 'PWRMF', 'RKMSF', 'TMASF', 'SEHKF', 'LTMCF', 'EVGUF', 'CCWOF', 'AUMC', 'CPPKF', 'BENZF', 'SKKRF', 'NRVTF', 'EMHLF', 'QQREF', 'BBBMF', 'ALTPF', 'QCCUF', 'MTLFF', 'TRBMF', 'AZZTF', 'MNXXF', 'EUMNF', 'TTSRF', 'GESI', 'EEMMF', 'ADBRF', 'SYHBF', 'HANNF', 'GENMF', 'THSGF', 'ELBM', 'PNPNF', 'GPPRF', 'AZMCF', 'TIMCF', '2IK.F', 'NMG', 'JUGRF', 'EVKRF', 'DFMTF', 'GRSLF', 'LISMF', 'SLGGF', 'RGLSF', 'GHVNF', 'HPQFF', 'STKXF', 'BRKCF', 'GIGGF', 'IBATF', 'CMET.L', '1VU0.F', 'ARDNF', 'TTIRF', '7WW.F', 'ZYR1.F', 'KP10.F', 'ALBAF', '3JC0.F', 'BNZ.AX', 'EMGDF', 'MTBMF', 'DM1.AX', 'AKO.AX', 'EGMMF', '0WL.F', 'VULNF', '40A.F', 'HGO.F', 'SAVNF', 'WAK.AX', 'CPN.AX', '8XJ.F', 'MHK.AX', 'MKNGF', 'NMR.AX', 'TNC.AX', 'BM8.AX', 'JLRRF', 'COD.AX', 'MEG.AX', 'BTRYF', 'DRR.AX', 'SSYRF', 'M2R.AX', 'E06A.F', '77C.F', 'ELECF', 'PMYLF', 'USHAF', 'EMOTF', 'CRSTF', 'G6D2.F', 'ASMMF', 'CRTM.L', 'BATXF', '4YW.F', 'UDE0.F', 'GMWA.F', '30Z.F', 'GCXXF', 'ETRUF', 'GOLXF', 'SLVDF', 'WALRF', 'NBRFF', 'SULMF', 'ARDDF', 'VTMXF', 'WRE1.F', '5HR.F', '5KG0.F', 'CNIKF', 'EBM.F', 'STXPF', 'CLRSF', 'VOY0.F', '601609.SS', 'PRE.L', '002978.SZ', 'MP', '2REA.F', 'JLL.AX', '4XH.F', 'NDMCF', 'BLSTF', 'NICMF', '4W0.F', 'ERR.F', '4U50.F', 'GLIIF', 'N6D.F', 'IFSH.JK', 'ORESF', '5EG.F', 'DCNNF', 'KVGOF', 'CST.AX', 'IMIMF', '1OI.F', 'CBE.AX', 'SMM.AX', 'PURE.JK']\n", + "\n", + "Shapes:\n", + "Before: (1570, 1806) After: (1570, 1251)\n", + "Saved to 'df_prices_final.csv'.\n" + ] + } + ], + "source": [ + "# ------------------------------------------------------------\n", + "# Load df_prices.csv, compute missing % per ticker,\n", + "# drop columns with >50% missing, save df_prices_final.csv\n", + "# ------------------------------------------------------------\n", + "import pandas as pd\n", + "\n", + "IN_CSV = \"df_prices.csv\"\n", + "OUT_CSV = \"df_prices_final.csv\"\n", + "THRESH = 10.0 # percent\n", + "\n", + "df_prices = pd.read_csv(IN_CSV, parse_dates=[\"Date\"], index_col=\"Date\")\n", + "\n", + "# Missing % over the full DataFrame index\n", + "missing_pct = df_prices.isna().mean() * 100.0\n", + "report = (\n", + " pd.DataFrame({\"missing_pct\": missing_pct})\n", + " .sort_values(\"missing_pct\", ascending=False)\n", + ")\n", + "print(\"=== Missing % by ticker ===\")\n", + "print(report)\n", + "\n", + "# Drop tickers with >50% missing\n", + "to_drop = report.index[report[\"missing_pct\"] > THRESH].tolist()\n", + "print(f\"\\nDropping {len(to_drop)} tickers (> {THRESH:.0f}% missing): {to_drop}\")\n", + "\n", + "df_prices_final = df_prices.drop(columns=to_drop, errors=\"ignore\")\n", + "\n", + "print(\"\\nShapes:\")\n", + "print(\"Before:\", df_prices.shape, \"After:\", df_prices_final.shape)\n", + "\n", + "df_prices_final.to_csv(OUT_CSV, index_label=\"Date\", float_format=\"%.6f\")\n", + "print(f\"Saved to '{OUT_CSV}'.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8dc7673c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved clean, rectangular prices to 'df_prices_final.csv' with shape (1409, 1251).\n" + ] + } + ], + "source": [ + "# ------------------------------------------------------------\n", + "# Clean df_prices_final: common window + bfill→ffill + final NA drop\n", + "# Input : df_prices_final.csv (your current file with some missing)\n", + "# Output: df_prices_final.csv (overwritten, rectangular, NA-free)\n", + "# ------------------------------------------------------------\n", + "import pandas as pd\n", + "\n", + "IN_CSV = \"df_prices_final.csv\"\n", + "OUT_CSV = \"df_prices_final.csv\" # overwrite in place\n", + "\n", + "df = pd.read_csv(IN_CSV, parse_dates=[\"Date\"], index_col=\"Date\").sort_index()\n", + "\n", + "# 1) Common window (everyone has started and not yet delisted)\n", + "first_valid = df.apply(pd.Series.first_valid_index)\n", + "last_valid = df.apply(pd.Series.last_valid_index)\n", + "\n", + "common_start = max(first_valid.dropna())\n", + "common_end = min(last_valid.dropna())\n", + "\n", + "df = df.loc[common_start:common_end].copy()\n", + "\n", + "# 2) Business-day index to harmonize calendars\n", + "bidx = pd.date_range(df.index.min(), df.index.max(), freq=\"B\")\n", + "df = df.reindex(bidx)\n", + "\n", + "# 3) Fill:\n", + "# - Backfill once to seed the first business day for tickers closed on common_start\n", + "# - Forward-fill for holiday gaps etc.\n", + "df = df.bfill(limit=None).ffill(limit=None)\n", + "\n", + "# 4) Final sanity check: drop any rare rows still containing NA\n", + "before_rows = df.shape[0]\n", + "df = df.dropna(how=\"any\")\n", + "after_rows = df.shape[0]\n", + "if before_rows != after_rows:\n", + " print(f\"Dropped {before_rows - after_rows} rows that still had NAs after filling.\")\n", + "\n", + "# 5) Save\n", + "df.to_csv(OUT_CSV, index_label=\"Date\", float_format=\"%.6f\")\n", + "print(f\"Saved clean, rectangular prices to '{OUT_CSV}' with shape {df.shape}.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "c5f250f5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/pandas/core/internals/blocks.py:395: RuntimeWarning: invalid value encountered in log\n", + " result = func(self.values, **kwargs)\n", + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:3065: RuntimeWarning: invalid value encountered in divide\n", + " c /= stddev[:, None]\n", + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:3066: RuntimeWarning: invalid value encountered in divide\n", + " c /= stddev[None, :]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Saved corr_beta.csv, excess_summary.csv (with corr_to_copper & |corr|>0.5 in labels)\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import statsmodels.api as sm\n", + "\n", + "# ---------- PARAMETERS ----------\n", + "IN_CSV = \"df_prices_final.csv\" # prices, Date index\n", + "BENCH = \"HG=F\" # underlying metal\n", + "FREQ = \"W-FRI\" # 'D' for daily or 'W-FRI'\n", + "ROLL_WINDOW = None # 26 weeks ≈ 6 months; set None to skip\n", + "USE_LOG_RET = True # True = log-returns, False = pct-change\n", + "ALPHA_T_CUT = 0.0 # |t| threshold for alpha significance\n", + "SHARPE_CUT = 0.0 # >0 required for outperform label\n", + "\n", + "# Annualisation factor\n", + "PER_YEAR = 52 if FREQ.startswith(\"W\") else 252\n", + "\n", + "# ---------- LOAD PRICES ----------\n", + "px = (pd.read_csv(IN_CSV, parse_dates=[\"Date\"], index_col=\"Date\")\n", + " .sort_index())\n", + "assert BENCH in px.columns, f\"{BENCH} not found in columns.\"\n", + "\n", + "# Optional resample (weekly smooths roll/holiday noise)\n", + "if FREQ != \"D\":\n", + " px = px.resample(FREQ).last()\n", + "\n", + "# ---------- RETURNS ----------\n", + "rets = np.log(px).diff() if USE_LOG_RET else px.pct_change()\n", + "rets = rets.dropna(how=\"all\")\n", + "\n", + "bench = rets[BENCH]\n", + "stocks = [c for c in rets.columns if c != BENCH]\n", + "\n", + "# ---------- 1) CORRELATION & BETA ----------\n", + "corr = rets[stocks].corrwith(bench) # Series: index=ticker\n", + "var_b = bench.var(ddof=1)\n", + "beta = rets[stocks].apply(lambda s: s.cov(bench)) / var_b\n", + "\n", + "corr_beta = (pd.DataFrame({\"corr_to_copper\": corr,\n", + " \"beta_to_copper\": beta})\n", + " .sort_values(\"corr_to_copper\", ascending=False))\n", + "corr_beta.index.name = \"ticker\"\n", + "corr_beta.to_csv(\"corr_beta.csv\", float_format=\"%.6f\")\n", + "\n", + "# Keep maps for reuse in excess_summary\n", + "corr_map = corr.to_dict()\n", + "beta_map = beta.to_dict()\n", + "\n", + "# ---------- OPTIONAL ROLLING CORRELATION ----------\n", + "if ROLL_WINDOW:\n", + " rolling_long = (\n", + " rets[stocks]\n", + " .rolling(ROLL_WINDOW)\n", + " .corr(bench) # wide: Date × tickers\n", + " .stack() # -> Series with MultiIndex (Date, ticker)\n", + " .rename(\"rolling_corr\")\n", + " .rename_axis([\"Date\", \"ticker\"])\n", + " .reset_index()\n", + " .dropna(subset=[\"rolling_corr\"])\n", + " )\n", + " rolling_long.to_csv(\"rolling_corr_long.csv\",\n", + " index=False, float_format=\"%.6f\")\n", + "\n", + "# ---------- 2) β-HEDGED EXCESS & SELECTION ----------\n", + "def _nw_lags(freq: str) -> int:\n", + " return 4 if freq.startswith(\"W\") else 21 # ≈1 month of obs\n", + "\n", + "hac_lags = _nw_lags(FREQ)\n", + "\n", + "rows = []\n", + "for s in stocks:\n", + " # align & drop NA\n", + " df_xy = rets[[s, BENCH]].dropna()\n", + " if df_xy.empty:\n", + " continue\n", + "\n", + " y = df_xy[s]\n", + " X = sm.add_constant(df_xy[BENCH])\n", + " model = sm.OLS(y, X).fit(\n", + " cov_type=\"HAC\",\n", + " cov_kwds={\"maxlags\": hac_lags}\n", + " )\n", + "\n", + " alpha = model.params[\"const\"]\n", + " beta_i = model.params[BENCH]\n", + " t_alpha = model.tvalues[\"const\"]\n", + " alpha_ann = alpha * PER_YEAR\n", + "\n", + " # β-hedged excess series\n", + " r_excess = y - beta_i * df_xy[BENCH]\n", + " mu, sd = r_excess.mean(), r_excess.std(ddof=1)\n", + " hedged_sharpe = (mu / sd) * np.sqrt(PER_YEAR) if sd > 0 else np.nan\n", + " cum_excess_beta_log = r_excess.cumsum().iloc[-1]\n", + "\n", + " # Simple 1× copper cumulative log excess\n", + " cum_excess_1x_log = y.cumsum().iloc[-1] - df_xy[BENCH].cumsum().iloc[-1]\n", + "\n", + " # Label (added constraint: |corr_to_copper| > 0.5)\n", + " corr_val = corr_map.get(s, np.nan)\n", + " if (\n", + " (alpha_ann > 0)\n", + " and (t_alpha > ALPHA_T_CUT)\n", + " and (hedged_sharpe > SHARPE_CUT)\n", + " and (abs(corr_val) > 0.4)\n", + " ):\n", + " label = \"Outperform\"\n", + " elif (\n", + " (alpha_ann < 0)\n", + " and (t_alpha < -ALPHA_T_CUT)\n", + " and (hedged_sharpe < -SHARPE_CUT)\n", + " and (abs(corr_val) > 0.4)\n", + " ):\n", + " label = \"Underperform\"\n", + " else:\n", + " label = \"Neutral\"\n", + "\n", + " rows.append({\n", + " \"ticker\": s,\n", + " \"corr_to_copper\": corr_val,\n", + " \"beta_to_copper\": beta_map.get(s, np.nan),\n", + " \"alpha_ann\": alpha_ann,\n", + " \"t_alpha\": t_alpha,\n", + " \"hedged_sharpe\": hedged_sharpe,\n", + " \"cum_excess_beta_log\": cum_excess_beta_log,\n", + " \"cum_excess_1x_log\": cum_excess_1x_log,\n", + " \"label\": label\n", + " })\n", + "\n", + "excess_summary = (pd.DataFrame(rows)\n", + " .set_index(\"ticker\")\n", + " .sort_values([\"label\", \"alpha_ann\", \"hedged_sharpe\"],\n", + " ascending=[True, False, False]))\n", + "excess_summary.to_csv(\"excess_summary.csv\", float_format=\"%.6f\")\n", + "\n", + "print(\"✓ Saved corr_beta.csv,\",\n", + " \"rolling_corr_long.csv,\" if ROLL_WINDOW else \"\",\n", + " \"excess_summary.csv (with corr_to_copper & |corr|>0.5 in labels)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8cdec19b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/pandas/core/internals/blocks.py:395: RuntimeWarning: invalid value encountered in log\n", + " result = func(self.values, **kwargs)\n", + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:3065: RuntimeWarning: invalid value encountered in divide\n", + " c /= stddev[:, None]\n", + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:3066: RuntimeWarning: invalid value encountered in divide\n", + " c /= stddev[None, :]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Saved corr_beta.csv, excess_summary.csv (with corr_to_copper)\n" + ] + } + ], + "source": [ + "# ============================================================\n", + "# Copper-linked stocks vs COMEX copper (HG=F)\n", + "# • Correlation & beta\n", + "# • Rolling correlation\n", + "# • β-hedged alpha / excess-return summary\n", + "# Outputs:\n", + "# corr_beta.csv, rolling_corr_long.csv, excess_summary.csv\n", + "# (excess_summary.csv now includes corr_to_copper)\n", + "# ============================================================\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import statsmodels.api as sm\n", + "\n", + "# ---------- PARAMETERS ----------\n", + "IN_CSV = \"df_prices_final.csv\" # prices, Date index\n", + "BENCH = \"HG=F\" # underlying metal\n", + "FREQ = \"W-FRI\" # 'D' for daily or 'W-FRI'\n", + "ROLL_WINDOW = None # 26 weeks ≈ 6 months; set None to skip\n", + "USE_LOG_RET = True # True = log-returns, False = pct-change\n", + "ALPHA_T_CUT = 0.9 # |t| threshold for alpha significance\n", + "SHARPE_CUT = 0.0 # >0 required for outperform label\n", + "\n", + "# Annualisation factor\n", + "PER_YEAR = 52 if FREQ.startswith(\"W\") else 252\n", + "\n", + "# ---------- LOAD PRICES ----------\n", + "px = (pd.read_csv(IN_CSV, parse_dates=[\"Date\"], index_col=\"Date\")\n", + " .sort_index())\n", + "assert BENCH in px.columns, f\"{BENCH} not found in columns.\"\n", + "\n", + "# Optional resample (weekly smooths roll/holiday noise)\n", + "if FREQ != \"D\":\n", + " px = px.resample(FREQ).last()\n", + "\n", + "# ---------- RETURNS ----------\n", + "rets = np.log(px).diff() if USE_LOG_RET else px.pct_change()\n", + "rets = rets.dropna(how=\"all\")\n", + "\n", + "bench = rets[BENCH]\n", + "stocks = [c for c in rets.columns if c != BENCH]\n", + "\n", + "# ---------- 1) CORRELATION & BETA ----------\n", + "corr = rets[stocks].corrwith(bench) # Series: index=ticker\n", + "var_b = bench.var(ddof=1)\n", + "beta = rets[stocks].apply(lambda s: s.cov(bench)) / var_b\n", + "\n", + "corr_beta = (pd.DataFrame({\"corr_to_copper\": corr,\n", + " \"beta_to_copper\": beta})\n", + " .sort_values(\"corr_to_copper\", ascending=False))\n", + "corr_beta.index.name = \"ticker\"\n", + "corr_beta.to_csv(\"corr_beta.csv\", float_format=\"%.6f\")\n", + "\n", + "# Keep maps for reuse in excess_summary\n", + "corr_map = corr.to_dict()\n", + "beta_map = beta.to_dict()\n", + "\n", + "# ---------- OPTIONAL ROLLING CORRELATION ----------\n", + "if ROLL_WINDOW:\n", + " rolling_long = (\n", + " rets[stocks]\n", + " .rolling(ROLL_WINDOW)\n", + " .corr(bench) # wide: Date × tickers\n", + " .stack() # -> Series with MultiIndex (Date, ticker)\n", + " .rename(\"rolling_corr\")\n", + " .rename_axis([\"Date\", \"ticker\"])\n", + " .reset_index()\n", + " .dropna(subset=[\"rolling_corr\"])\n", + " )\n", + " rolling_long.to_csv(\"rolling_corr_long.csv\",\n", + " index=False, float_format=\"%.6f\")\n", + "\n", + "# ---------- 2) β-HEDGED EXCESS & SELECTION ----------\n", + "def _nw_lags(freq: str) -> int:\n", + " return 4 if freq.startswith(\"W\") else 21 # ≈1 month of obs\n", + "\n", + "hac_lags = _nw_lags(FREQ)\n", + "\n", + "rows = []\n", + "for s in stocks:\n", + " # align & drop NA\n", + " df_xy = rets[[s, BENCH]].dropna()\n", + " if df_xy.empty:\n", + " continue\n", + "\n", + " y = df_xy[s]\n", + " X = sm.add_constant(df_xy[BENCH])\n", + " model = sm.OLS(y, X).fit(\n", + " cov_type=\"HAC\",\n", + " cov_kwds={\"maxlags\": hac_lags}\n", + " )\n", + "\n", + " alpha = model.params[\"const\"]\n", + " beta_i = model.params[BENCH]\n", + " t_alpha = model.tvalues[\"const\"]\n", + " alpha_ann = alpha * PER_YEAR\n", + "\n", + " # β-hedged excess series\n", + " r_excess = y - beta_i * df_xy[BENCH]\n", + " mu, sd = r_excess.mean(), r_excess.std(ddof=1)\n", + " hedged_sharpe = (mu / sd) * np.sqrt(PER_YEAR) if sd > 0 else np.nan\n", + " cum_excess_beta_log = r_excess.cumsum().iloc[-1]\n", + "\n", + " # Simple 1× copper cumulative log excess\n", + " cum_excess_1x_log = y.cumsum().iloc[-1] - df_xy[BENCH].cumsum().iloc[-1]\n", + "\n", + " # Label\n", + " if (alpha_ann > 0) and (t_alpha > ALPHA_T_CUT) and (hedged_sharpe > SHARPE_CUT):\n", + " label = \"Outperform\"\n", + " elif (alpha_ann < 0) and (t_alpha < -ALPHA_T_CUT) and (hedged_sharpe < -SHARPE_CUT):\n", + " label = \"Underperform\"\n", + " else:\n", + " label = \"Neutral\"\n", + "\n", + " rows.append({\n", + " \"ticker\": s,\n", + " \"corr_to_copper\": corr_map.get(s, np.nan), # <-- added\n", + " \"beta_to_copper\": beta_map.get(s, np.nan), # keep for consistency\n", + " \"alpha_ann\": alpha_ann,\n", + " \"t_alpha\": t_alpha,\n", + " \"hedged_sharpe\": hedged_sharpe,\n", + " \"cum_excess_beta_log\": cum_excess_beta_log,\n", + " \"cum_excess_1x_log\": cum_excess_1x_log,\n", + " \"label\": label\n", + " })\n", + "\n", + "excess_summary = (pd.DataFrame(rows)\n", + " .set_index(\"ticker\")\n", + " .sort_values([\"label\", \"alpha_ann\", \"hedged_sharpe\"],\n", + " ascending=[True, False, False]))\n", + "excess_summary.to_csv(\"excess_summary.csv\", float_format=\"%.6f\")\n", + "\n", + "print(\"✓ Saved corr_beta.csv,\",\n", + " \"rolling_corr_long.csv,\" if ROLL_WINDOW else \"\",\n", + " \"excess_summary.csv (with corr_to_copper)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "13fb4bda", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 44 outperformers; price matrix shape: (1409, 44)\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Load prices and labels\n", + "prices = pd.read_csv(\"df_prices_final.csv\", parse_dates=[\"Date\"], index_col=\"Date\")\n", + "labels = pd.read_csv(\"excess_summary.csv\", index_col=0)\n", + "\n", + "# Select tickers labeled as OUTPERFORM (case-insensitive)\n", + "op_tickers = (\n", + " labels.assign(_lab=labels[\"label\"].astype(str).str.upper())\n", + " .query(\"_lab == 'OUTPERFORM'\")\n", + " .index.tolist()\n", + ")\n", + "\n", + "# Keep only those tickers that exist in the price matrix\n", + "op_tickers = [t for t in op_tickers if t in prices.columns]\n", + "\n", + "# Slice prices → new DataFrame\n", + "outperforming_stocks = prices.loc[:, op_tickers].copy()\n", + "\n", + "print(f\"Found {len(op_tickers)} outperformers; price matrix shape: {outperforming_stocks.shape}\")\n", + "\n", + "# Optional: include the benchmark column too\n", + "# outperforming_with_bench = prices.loc[:, ['HG=F'] + op_tickers].copy()\n", + "\n", + "# Save to CSV (optional)\n", + "outperforming_stocks.to_csv(\"outperforming_stocks.csv\", index_label=\"Date\", float_format=\"%.6f\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "7fdc653f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing PYV.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:264: FutureWarning: The default fill_method='pad' in Series.pct_change is deprecated and will be removed in a future version. Either fill in any non-leading NA values prior to calling pct_change or specify 'fill_method=None' to not fill NA values.\n", + " df[\"Debt_Growth_Pct\"] = total_debt.pct_change()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing JIX.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing OUW0.F ...\n", + "Processing CS.TO ...\n", + "Processing 603979.SS ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing TKO.L ...\n", + "Processing RE8.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing FVJ.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing SKE ...\n", + "Processing FCXO34.SA ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing PILBF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing 2009.TW ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing ARREF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing LYSDY ...\n", + "Processing PRMNF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:265: FutureWarning: The default fill_method='pad' in Series.pct_change is deprecated and will be removed in a future version. Either fill in any non-leading NA values prior to calling pct_change or specify 'fill_method=None' to not fill NA values.\n", + " df[\"Capex_Growth_Pct\"] = capex_pos.pct_change()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing TGB ...\n", + "Processing LYSCF ...\n", + "Processing 601168.SS ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing FSUGY ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing TECK-A.TO ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing ATUSF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing FPMB.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing FCX ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing IPMLF ...\n", + "Processing ATYM.L ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing FG1.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing SCCO ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing IYAA.F ...\n", + "Processing ANFGF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing SFR.AX ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing FSUMF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing RTNTF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing TECK ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing CMCLF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing 603993.SS ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing IVPAF ...\n", + "Processing OCKA.F ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing BHP.AX ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing HBM.TO ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing RIO.AX ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing GMBXF ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing 000630.SZ ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing MIN.AX ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing HBM ...\n", + "\n", + "✓ Saved copper_outperformers_financials.csv with 211 rows.\n", + "Note: If some tickers still have blank Dividends/Capex, FMP/Yahoo may not cover that listing;\n", + " try the primary listing symbol in fmp_try_symbols() or map ADRs to locals.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/1873914036.py:192: FutureWarning: 'A-DEC' is deprecated and will be removed in a future version, please use 'YE-DEC' instead.\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "\"\"\"\n", + "Build combined financial dataset for 44 outperformers\n", + "- Input : outperforming_stocks.csv (first col=Date, next columns=tickers)\n", + "- Output: copper_outperformers_financials.csv (one row per Ticker x FiscalPeriodEnd)\n", + "\n", + "Raw fields:\n", + " Total_Debt, Long_Term_Debt, Short_Current_Debt, Shareholders_Equity,\n", + " Cash, Retained_Earnings, Dividends_Paid, Capex_raw (usually negative), Capex_pos (abs)\n", + "\n", + "Derived fields:\n", + " Debt_to_Equity, LT_Debt_Share, Delta_Debt, Delta_Capex_pos,\n", + " Debt_Growth_Pct, Capex_Growth_Pct, Debt_Financed_Capex_Share\n", + "\"\"\"\n", + "\n", + "import os\n", + "import time\n", + "import requests\n", + "import pandas as pd\n", + "import numpy as np\n", + "import yfinance as yf\n", + "from typing import List, Tuple\n", + "\n", + "# ==============================\n", + "# CONFIG\n", + "# ==============================\n", + "INPUT_CSV = \"outperforming_stocks.csv\"\n", + "OUTPUT_CSV = \"copper_outperformers_financials.csv\"\n", + "\n", + "# Your FMP API key (provided)\n", + "FMP_API_KEY = os.environ.get(\"FMP_API_KEY\", \"Ij8othylV4h1m3G3NwIWF6lhO4edov0K\")\n", + "\n", + "# Align calendar-year series (e.g., dividends events) to fiscal via nearest match (max ~6.5 months)\n", + "NEAREST_TOLERANCE = pd.Timedelta(\"200D\")\n", + "\n", + "# Be polite to FMP (free tier ~5 calls/min)\n", + "FMP_SLEEP_SEC = 0.3\n", + "\n", + "\n", + "# ==============================\n", + "# HELPERS\n", + "# ==============================\n", + "def first_row(df: pd.DataFrame, labels: List[str]) -> pd.Series:\n", + " \"\"\"Return the first available row among possible labels, else empty Series.\"\"\"\n", + " if df is None or df.empty:\n", + " return pd.Series(dtype=float)\n", + " for lb in labels:\n", + " if lb in df.index:\n", + " return df.loc[lb]\n", + " return pd.Series(dtype=float)\n", + "\n", + "def to_datetime_cols(df: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"Ensure columns are DatetimeIndex (fiscal period ends).\"\"\"\n", + " if df is None or df.empty:\n", + " return df\n", + " out = df.copy()\n", + " try:\n", + " out.columns = pd.to_datetime(out.columns)\n", + " except Exception:\n", + " out.columns = pd.to_datetime([pd.to_datetime(c, errors=\"coerce\") for c in out.columns])\n", + " return out\n", + "\n", + "def fmp_try_symbols(ticker: str) -> List[str]:\n", + " \"\"\"\n", + " Generate fallback symbol variants for FMP:\n", + " - Original tk\n", + " - Base without suffix (e.g., 'RIO.L' -> 'RIO')\n", + " - Replace '.' with '-' (some APIs prefer hyphens)\n", + " \"\"\"\n", + " cands = [ticker]\n", + " if \".\" in ticker:\n", + " base = ticker.split(\".\")[0]\n", + " cands.append(base)\n", + " cands.append(ticker.replace(\".\", \"-\"))\n", + " # de-duplicate while keeping order\n", + " seen = set()\n", + " uniq = []\n", + " for s in cands:\n", + " if s not in seen:\n", + " uniq.append(s); seen.add(s)\n", + " return uniq\n", + "\n", + "def fmp_get_json(url: str, params: dict) -> list:\n", + " r = requests.get(url, params=params, timeout=20)\n", + " r.raise_for_status()\n", + " data = r.json()\n", + " return data if isinstance(data, list) else data\n", + "\n", + "def fmp_capex_series(ticker: str, api_key: str, limit: int = 16) -> pd.Series:\n", + " \"\"\"\n", + " Capex from FMP cash-flow endpoint (annual).\n", + " Tries multiple symbol variants and column names. Returns ascending Series by fiscal date.\n", + " \"\"\"\n", + " if not api_key:\n", + " return pd.Series(dtype=float)\n", + " for tk in fmp_try_symbols(ticker):\n", + " try:\n", + " url = f\"https://financialmodelingprep.com/api/v3/cash-flow-statement/{tk}\"\n", + " params = {\"apikey\": api_key, \"limit\": limit}\n", + " data = fmp_get_json(url, params)\n", + " if not data:\n", + " continue\n", + " df = pd.DataFrame(data)\n", + " if \"date\" not in df.columns:\n", + " continue\n", + " col = next((c for c in [\n", + " \"capitalExpenditure\",\n", + " \"investmentsInPropertyPlantAndEquipment\",\n", + " \"capitalExpenditureFixedAssets\"\n", + " ] if c in df.columns), None)\n", + " if col is None:\n", + " continue\n", + " s = pd.Series(df[col].values, index=pd.to_datetime(df[\"date\"])).sort_index()\n", + " time.sleep(FMP_SLEEP_SEC)\n", + " if not s.empty:\n", + " return s\n", + " except Exception:\n", + " continue\n", + " return pd.Series(dtype=float)\n", + "\n", + "def yf_capex_series(t: yf.Ticker) -> pd.Series:\n", + " \"\"\"Capex from Yahoo cash flow (annual). Returns Series indexed by fiscal period ends.\"\"\"\n", + " try:\n", + " cf = t.cashflow\n", + " s = first_row(cf, [\"Capital Expenditures\", \"Capital Expenditure\"])\n", + " return s if not s.empty else pd.Series(dtype=float)\n", + " except Exception:\n", + " return pd.Series(dtype=float)\n", + "\n", + "def fmp_dividends_cashflow_series(ticker: str, api_key: str, limit: int = 16) -> pd.Series:\n", + " \"\"\"\n", + " FMP cash-flow: 'dividendsPaid' (or 'dividendsPayments'), negative outflow -> flip to +paid.\n", + " Indexed by fiscal 'date', ascending.\n", + " \"\"\"\n", + " if not api_key:\n", + " return pd.Series(dtype=float)\n", + " for tk in fmp_try_symbols(ticker):\n", + " try:\n", + " url = f\"https://financialmodelingprep.com/api/v3/cash-flow-statement/{tk}\"\n", + " params = {\"apikey\": api_key, \"limit\": limit}\n", + " data = fmp_get_json(url, params)\n", + " if not data:\n", + " continue\n", + " df = pd.DataFrame(data)\n", + " col = next((c for c in [\"dividendsPaid\", \"dividendsPayments\"] if c in df.columns), None)\n", + " if col is None or \"date\" not in df.columns:\n", + " continue\n", + " s = pd.Series(df[col].values, index=pd.to_datetime(df[\"date\"])).sort_index()\n", + " s = (-s) # make positive amount paid\n", + " time.sleep(FMP_SLEEP_SEC)\n", + " if not s.empty:\n", + " return s\n", + " except Exception:\n", + " continue\n", + " return pd.Series(dtype=float)\n", + "\n", + "def fmp_dividends_events_series(ticker: str, api_key: str, limit_years: int = 20) -> pd.Series:\n", + " \"\"\"\n", + " FMP stock dividend events endpoint. Sum to calendar years (Dec 31). Returns ascending Series.\n", + " \"\"\"\n", + " if not api_key:\n", + " return pd.Series(dtype=float)\n", + " for tk in fmp_try_symbols(ticker):\n", + " try:\n", + " url = f\"https://financialmodelingprep.com/api/v3/historical-price-full/stock_dividend/{tk}\"\n", + " params = {\"apikey\": api_key}\n", + " r = requests.get(url, params=params, timeout=20)\n", + " r.raise_for_status()\n", + " data = r.json()\n", + " hist = data.get(\"historical\", [])\n", + " if not hist:\n", + " continue\n", + " df = pd.DataFrame(hist)\n", + " if \"date\" not in df.columns or \"dividend\" not in df.columns:\n", + " continue\n", + " df[\"date\"] = pd.to_datetime(df[\"date\"])\n", + " s = df.set_index(\"date\")[\"dividend\"].resample(\"A-DEC\").sum().sort_index()\n", + " if limit_years:\n", + " s = s.iloc[-limit_years:]\n", + " time.sleep(FMP_SLEEP_SEC)\n", + " if not s.empty:\n", + " return s\n", + " except Exception:\n", + " continue\n", + " return pd.Series(dtype=float)\n", + "\n", + "def yf_dividends_annual_series(t: yf.Ticker) -> pd.Series:\n", + " \"\"\"Yahoo corporate actions -> annual (calendar).\"\"\"\n", + " try:\n", + " div = t.dividends\n", + " if div is not None and not div.empty:\n", + " return div.resample(\"A-DEC\").sum().sort_index()\n", + " except Exception:\n", + " pass\n", + " return pd.Series(dtype=float)\n", + "\n", + "def yf_dividends_cashflow_series(t: yf.Ticker) -> pd.Series:\n", + " \"\"\"Yahoo cash-flow row -> annual (fiscal), negative outflow -> +paid.\"\"\"\n", + " try:\n", + " cf = t.cashflow\n", + " s = first_row(cf, [\"Cash Dividends Paid\", \"Dividends Paid\", \"Cash Dividends Paid By Company\"])\n", + " if s is not None and not s.empty:\n", + " s = (-s).copy()\n", + " s.index = pd.to_datetime(s.index)\n", + " return s.sort_index()\n", + " except Exception:\n", + " pass\n", + " return pd.Series(dtype=float)\n", + "\n", + "def best_dividends_series(tk: str, t: yf.Ticker, api_key: str) -> Tuple[pd.Series, str]:\n", + " \"\"\"\n", + " Try multiple sources in order; return (Series, source_tag).\n", + " Preference:\n", + " 1) FMP cash-flow (fiscal)\n", + " 2) FMP events (calendar)\n", + " 3) Yahoo actions (calendar)\n", + " 4) Yahoo cash-flow (fiscal)\n", + " \"\"\"\n", + " s = fmp_dividends_cashflow_series(tk, api_key)\n", + " if not s.empty:\n", + " return s, \"fmp_cashflow\"\n", + " s = fmp_dividends_events_series(tk, api_key)\n", + " if not s.empty:\n", + " return s, \"fmp_events\"\n", + " s = yf_dividends_annual_series(t)\n", + " if not s.empty:\n", + " return s, \"yf_actions\"\n", + " s = yf_dividends_cashflow_series(t)\n", + " if not s.empty:\n", + " return s, \"yf_cashflow\"\n", + " return pd.Series(dtype=float), \"none\"\n", + "\n", + "def safe_add(a: pd.Series, b: pd.Series) -> pd.Series:\n", + " if a is None or a.empty:\n", + " return b\n", + " if b is None or b.empty:\n", + " return a\n", + " return a.add(b, fill_value=0)\n", + "\n", + "def compute_derivatives(per_ticker_df: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"\n", + " Robust derivations that tolerate missing columns.\n", + " \"\"\"\n", + " df = per_ticker_df.sort_index().copy()\n", + "\n", + " def col(name):\n", + " if name in df.columns:\n", + " return df[name]\n", + " else:\n", + " return pd.Series(index=df.index, dtype=float)\n", + "\n", + " total_debt = col(\"Total_Debt\")\n", + " equity = col(\"Shareholders_Equity\")\n", + " lt_debt = col(\"Long_Term_Debt\")\n", + " capex_pos = col(\"Capex_pos\")\n", + "\n", + " # Ratios\n", + " df[\"Debt_to_Equity\"] = total_debt / equity.replace(0, np.nan)\n", + " df[\"LT_Debt_Share\"] = lt_debt / total_debt.replace(0, np.nan)\n", + "\n", + " # Levels -> Deltas & growth (YoY)\n", + " df[\"Delta_Debt\"] = total_debt.diff()\n", + " df[\"Delta_Capex_pos\"] = capex_pos.diff()\n", + " df[\"Debt_Growth_Pct\"] = total_debt.pct_change()\n", + " df[\"Capex_Growth_Pct\"] = capex_pos.pct_change()\n", + "\n", + " # Debt-financed Capex share (only when ΔCapex_pos > 0)\n", + " df[\"Debt_Financed_Capex_Share\"] = np.where(\n", + " (df[\"Delta_Capex_pos\"] > 0) & df[\"Delta_Capex_pos\"].notna(),\n", + " df[\"Delta_Debt\"] / df[\"Delta_Capex_pos\"],\n", + " np.nan\n", + " )\n", + " return df\n", + "\n", + "\n", + "# ==============================\n", + "# MAIN\n", + "# ==============================\n", + "def main():\n", + " # 1) Read tickers (skip first column 'Date')\n", + " px = pd.read_csv(INPUT_CSV)\n", + " tickers = [c for c in px.columns if c != \"Date\"]\n", + " if not tickers:\n", + " raise ValueError(\"No tickers found in outperforming_stocks.csv (columns after 'Date').\")\n", + "\n", + " all_rows = []\n", + "\n", + " for tk in tickers:\n", + " print(f\"Processing {tk} ...\")\n", + " t = yf.Ticker(tk)\n", + "\n", + " # --- Yahoo balance sheet & fiscal dates ---\n", + " try:\n", + " bs = t.balance_sheet\n", + " except Exception:\n", + " bs = pd.DataFrame()\n", + " bs = to_datetime_cols(bs)\n", + " fiscal_cols = [] if bs is None or bs.empty else list(bs.columns)\n", + "\n", + " # --- Core rows from Yahoo ---\n", + " long_term_debt = first_row(bs, [\"Long Term Debt\"])\n", + " short_debt = first_row(bs, [\"Short Long Term Debt\", \"Current Debt\", \"Short Term Debt\"])\n", + " total_debt = first_row(bs, [\"Total Debt\"])\n", + " if total_debt.empty:\n", + " total_debt = safe_add(long_term_debt, short_debt)\n", + "\n", + " equity = first_row(bs, [\n", + " \"Total Stockholder Equity\",\n", + " \"Total Equity Gross Minority Interest\",\n", + " \"Stockholders Equity\",\n", + " \"Ordinary Shares\" # loose fallback\n", + " ])\n", + " cash = first_row(bs, [\"Cash\", \"Cash And Cash Equivalents\"])\n", + " retained = first_row(bs, [\"Retained Earnings\"])\n", + "\n", + " # --- Capex: FMP primary, Yahoo fallback ---\n", + " capex_fmp = fmp_capex_series(tk, FMP_API_KEY, limit=16)\n", + " capex_yf = yf_capex_series(t)\n", + " capex = capex_fmp if not capex_fmp.empty else capex_yf\n", + "\n", + " # --- Build fiscal index to align everything ---\n", + " if not fiscal_cols:\n", + " candidates = [s for s in [total_debt, equity, cash, retained, capex] if not s.empty]\n", + " if not candidates:\n", + " print(f\" ⚠ Skipping {tk}: no data available.\")\n", + " continue\n", + " union_idx = pd.Index(sorted(set().union(*[pd.to_datetime(c.index) for c in candidates])))\n", + " fiscal_index = pd.DatetimeIndex(union_idx)\n", + " else:\n", + " fiscal_index = pd.DatetimeIndex(fiscal_cols)\n", + "\n", + " def align_to_fiscal(s: pd.Series) -> pd.Series:\n", + " if s is None or s.empty:\n", + " return pd.Series(index=fiscal_index, dtype=float)\n", + " # try exact alignment\n", + " try:\n", + " return s.reindex(fiscal_index)\n", + " except Exception:\n", + " pass\n", + " # nearest with tolerance\n", + " try:\n", + " return s.reindex(fiscal_index, method=\"nearest\", tolerance=NEAREST_TOLERANCE)\n", + " except Exception:\n", + " return s.reindex(fiscal_index)\n", + "\n", + " total_debt_a = align_to_fiscal(total_debt)\n", + " long_debt_a = align_to_fiscal(long_term_debt)\n", + " short_debt_a = align_to_fiscal(short_debt)\n", + " equity_a = align_to_fiscal(equity)\n", + " cash_a = align_to_fiscal(cash)\n", + " retained_a = align_to_fiscal(retained)\n", + "\n", + " # --- Dividends: try multiple sources, then align to fiscal ---\n", + " div_series, div_src = best_dividends_series(tk, t, FMP_API_KEY)\n", + " dividends_a = align_to_fiscal(div_series)\n", + "\n", + " # --- Capex (raw usually negative), plus positive-spend ---\n", + " capex_a = align_to_fiscal(capex)\n", + " capex_pos_a = capex_a.abs()\n", + "\n", + " # --- Build per-ticker frame (index = fiscal period end) ---\n", + " per = pd.DataFrame({\n", + " \"Total_Debt\": total_debt_a,\n", + " \"Long_Term_Debt\": long_debt_a,\n", + " \"Short_Current_Debt\": short_debt_a,\n", + " \"Shareholders_Equity\": equity_a,\n", + " \"Cash\": cash_a,\n", + " \"Retained_Earnings\": retained_a,\n", + " \"Dividends_Paid\": dividends_a,\n", + " \"Capex_raw\": capex_a, # negative outflow\n", + " \"Capex_pos\": capex_pos_a # positive spend\n", + " })\n", + "\n", + " # Ensure core columns exist even if all NaN (avoid KeyError downstream)\n", + " CORE_COLS = [\n", + " \"Total_Debt\", \"Long_Term_Debt\", \"Short_Current_Debt\",\n", + " \"Shareholders_Equity\", \"Cash\", \"Retained_Earnings\",\n", + " \"Dividends_Paid\", \"Capex_raw\", \"Capex_pos\"\n", + " ]\n", + " for c in CORE_COLS:\n", + " if c not in per.columns:\n", + " per[c] = pd.Series(index=per.index, dtype=float)\n", + "\n", + " # --- Derived metrics for Task 1 & 2 ---\n", + " per = compute_derivatives(per)\n", + "\n", + " # --- Stack for long table ---\n", + " per = per.reset_index().rename(columns={\"index\": \"FiscalPeriodEnd\"})\n", + " per.insert(0, \"Ticker\", tk)\n", + " all_rows.append(per)\n", + "\n", + " if not all_rows:\n", + " raise RuntimeError(\"No data collected. Check tickers and API coverage.\")\n", + "\n", + " combined = pd.concat(all_rows, axis=0, ignore_index=True)\n", + " combined = combined.sort_values([\"Ticker\", \"FiscalPeriodEnd\"]).reset_index(drop=True)\n", + " combined.to_csv(OUTPUT_CSV, index=False, float_format=\"%.6f\")\n", + "\n", + " print(f\"\\n✓ Saved {OUTPUT_CSV} with {len(combined)} rows.\")\n", + " print(\"Note: If some tickers still have blank Dividends/Capex, FMP/Yahoo may not cover that listing;\")\n", + " print(\" try the primary listing symbol in fmp_try_symbols() or map ADRs to locals.\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "7c34df62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Saved task1_behavioral_scores.csv and task1_behavioral_shortlist.csv\n", + " Task1_Behavior_Score Ideal_Flag\n", + "Ticker \n", + "ATUSF 1.366295 True\n", + "2009.TW 0.998314 True\n", + "PILBF 0.899130 False\n", + "IYAA.F 0.644812 False\n", + "IVPAF 0.644812 False\n", + "FVJ.F 0.361688 False\n", + "FSUMF 0.361688 False\n", + "FSUGY 0.361688 False\n", + "LYSCF 0.322783 True\n", + "LYSDY 0.322783 True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.py:1214: RuntimeWarning: Mean of empty slice\n", + " return np.nanmean(a, axis, out=out, keepdims=keepdims)\n", + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.py:1214: RuntimeWarning: Mean of empty slice\n", + " return np.nanmean(a, axis, out=out, keepdims=keepdims)\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/873942107.py:144: RuntimeWarning: All-NaN slice encountered\n", + " dfs_med = np.nanmedian(g[\"Delta_Debt\"] / denom)\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/873942107.py:147: RuntimeWarning: All-NaN slice encountered\n", + " debt_to_capex_lvl_med = np.nanmedian(g[\"Delta_Debt\"] / g[\"Capex_pos\"].replace(0, np.nan))\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/873942107.py:193: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " scores = fin.groupby(\"Ticker\", as_index=False).apply(summarize_company).reset_index(drop=True).set_index(\"Ticker\")\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "\"\"\"\n", + "Task 1 — Debt-focused behavioral analysis with **equal-by-aspect** weighting.\n", + "\n", + "Inputs (must exist in the working directory):\n", + " - copper_outperformers_financials.csv (Ticker, FiscalPeriodEnd, and metrics from your pipeline)\n", + " - outperforming_stocks.csv (Date + 44 tickers of prices for the same names)\n", + "\n", + "Outputs:\n", + " - task1_behavioral_scores.csv (all metrics + Behavior Score + Ideal_Flag)\n", + " - task1_behavioral_shortlist.csv (sorted by Behavior Score, for review)\n", + "\n", + "What the Behavior Score measures (4 aspects, equal weight by aspect):\n", + " 1) Prudence .............. low leverage now, falling leverage trend, low ΔDebt relative to Capex level\n", + " 2) Capex financing ....... capex not mostly debt-financed, healthier LT-debt mix\n", + " 3) Growth & reinvestment . capex growth, retained earnings growth (proxy for reinvestment)\n", + " 4) Behavior vs stock ..... D/E falls when stock is up; ΔCapex rises when stock is up\n", + "\n", + "Each aspect gets equal weight **for that company** (if it has at least one usable signal);\n", + "within an aspect, weight is split equally across available signals (NaN-robust).\n", + "\"\"\"\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# --------------------------\n", + "# Config\n", + "# --------------------------\n", + "FIN_PATH = \"copper_outperformers_financials.csv\"\n", + "PX_PATH = \"outperforming_stocks.csv\"\n", + "\n", + "N_YEARS_LOOKBACK = 5 # use the last N fiscal periods per ticker\n", + "MIN_OBS_FOR_BETA = 3 # minimum paired observations to compute beta/corr\n", + "PRICE_ALIGN_TOL_DAYS = 30 # align stock prices to fiscal dates within ±30 days\n", + "\n", + "\n", + "# --------------------------\n", + "# Helpers\n", + "# --------------------------\n", + "def zscore(s: pd.Series) -> pd.Series:\n", + " s = s.astype(float)\n", + " mu = s.mean(skipna=True)\n", + " sd = s.std(skipna=True, ddof=1)\n", + " if sd == 0 or np.isnan(sd):\n", + " return pd.Series(np.nan, index=s.index)\n", + " return (s - mu) / sd\n", + "\n", + "def slope_per_year(dates: pd.Series, y: pd.Series) -> float:\n", + " \"\"\"OLS slope of y vs time, annualized (per year).\"\"\"\n", + " df = pd.DataFrame({\"t\": dates, \"y\": y}).dropna()\n", + " if df.shape[0] < 2 or df[\"t\"].nunique() < 2:\n", + " return np.nan\n", + " x = df[\"t\"].map(pd.Timestamp.toordinal).to_numpy(dtype=float)\n", + " yv = df[\"y\"].to_numpy(dtype=float)\n", + " try:\n", + " b1_per_day = np.polyfit(x, yv, 1)[0]\n", + " return b1_per_day * 365.0\n", + " except Exception:\n", + " return np.nan\n", + "\n", + "def align_stock_returns_to_fiscal(px: pd.Series, fiscal_dates: pd.DatetimeIndex, tol_days=30) -> pd.Series:\n", + " \"\"\"\n", + " For a price series (indexed by Date), find nearest price to each fiscal date (±tol_days),\n", + " then compute period-over-period returns aligned to fiscal dates.\n", + " \"\"\"\n", + " p = px.dropna()\n", + " if p.size < 2:\n", + " return pd.Series(index=fiscal_dates, dtype=float)\n", + "\n", + " aligned_vals = []\n", + " aligned_idx = []\n", + " tol = pd.Timedelta(days=tol_days)\n", + "\n", + " for d in fiscal_dates:\n", + " # nearest index (absolute difference)\n", + " try:\n", + " i_near = (p.index - d).abs().argmin()\n", + " near_date = p.index[i_near]\n", + " if abs(near_date - d) <= tol:\n", + " aligned_idx.append(d)\n", + " aligned_vals.append(p.loc[near_date])\n", + " except Exception:\n", + " pass\n", + "\n", + " if len(aligned_idx) < 2:\n", + " return pd.Series(index=fiscal_dates, dtype=float)\n", + "\n", + " s = pd.Series(aligned_vals, index=pd.DatetimeIndex(aligned_idx)).sort_index()\n", + " r = s.pct_change()\n", + " return r.reindex(fiscal_dates)\n", + "\n", + "\n", + "# --------------------------\n", + "# Load data\n", + "# --------------------------\n", + "fin = pd.read_csv(FIN_PATH, parse_dates=[\"FiscalPeriodEnd\"]).sort_values([\"Ticker\", \"FiscalPeriodEnd\"])\n", + "px = pd.read_csv(PX_PATH, parse_dates=[\"Date\"]).set_index(\"Date\").sort_index()\n", + "\n", + "# Ensure needed columns exist (if missing in CSV, create as NaN)\n", + "need_cols = [\n", + " \"Total_Debt\", \"Long_Term_Debt\", \"Short_Current_Debt\", \"Shareholders_Equity\",\n", + " \"Cash\", \"Retained_Earnings\", \"Dividends_Paid\", \"Capex_raw\", \"Capex_pos\",\n", + " \"Debt_to_Equity\", \"LT_Debt_Share\", \"Delta_Debt\", \"Delta_Capex_pos\",\n", + " \"Debt_Growth_Pct\", \"Capex_Growth_Pct\", \"Debt_Financed_Capex_Share\"\n", + "]\n", + "for c in need_cols:\n", + " if c not in fin.columns:\n", + " fin[c] = np.nan\n", + "\n", + "\n", + "# --------------------------\n", + "# Summarize per ticker\n", + "# --------------------------\n", + "def summarize_company(g: pd.DataFrame) -> pd.Series:\n", + " g = g.sort_values(\"FiscalPeriodEnd\").tail(N_YEARS_LOOKBACK)\n", + " if g.empty:\n", + " return pd.Series(dtype=float)\n", + "\n", + " last = g.iloc[-1]\n", + " dates = g[\"FiscalPeriodEnd\"]\n", + "\n", + " # Latest leverage & mix\n", + " latest_de = last.get(\"Debt_to_Equity\", np.nan)\n", + "\n", + " # Prefer existing LT_Debt_Share column; if missing, compute from last row\n", + " latest_total_debt = last.get(\"Total_Debt\", np.nan)\n", + " latest_lt_debt = last.get(\"Long_Term_Debt\", np.nan)\n", + " if pd.notna(last.get(\"LT_Debt_Share\", np.nan)):\n", + " lt_share = last.get(\"LT_Debt_Share\", np.nan)\n", + " else:\n", + " lt_share = (latest_lt_debt / latest_total_debt) if pd.notna(latest_total_debt) and latest_total_debt != 0 else np.nan\n", + "\n", + " # Trends / growth\n", + " de_slope = slope_per_year(dates, g[\"Debt_to_Equity\"])\n", + " capex_g_avg = g[\"Capex_Growth_Pct\"].mean(skipna=True)\n", + " debt_g_avg = g[\"Debt_Growth_Pct\"].mean(skipna=True)\n", + " re_g_avg = g[\"Retained_Earnings\"].pct_change().mean(skipna=True)\n", + "\n", + " # Financing of capex\n", + " dfs_med = g[\"Debt_Financed_Capex_Share\"].median(skipna=True)\n", + " if np.isnan(dfs_med):\n", + " # Robust fallback: median of ΔDebt / ΔCapex_pos where ΔCapex_pos > 0\n", + " denom = g[\"Delta_Capex_pos\"].replace(0, np.nan)\n", + " dfs_med = np.nanmedian(g[\"Delta_Debt\"] / denom)\n", + "\n", + " # Guardrail: ΔDebt relative to Capex level\n", + " debt_to_capex_lvl_med = np.nanmedian(g[\"Delta_Debt\"] / g[\"Capex_pos\"].replace(0, np.nan))\n", + "\n", + " # Behavior vs stock\n", + " tk = g[\"Ticker\"].iloc[0]\n", + " stock_ret = align_stock_returns_to_fiscal(px[tk] if tk in px.columns else pd.Series(dtype=float),\n", + " g[\"FiscalPeriodEnd\"],\n", + " tol_days=PRICE_ALIGN_TOL_DAYS)\n", + "\n", + " # β(D/E on stock returns): regression y = a + b * r_stock\n", + " de_on_ret_beta = np.nan\n", + " df_beta = pd.concat([g.set_index(\"FiscalPeriodEnd\")[\"Debt_to_Equity\"], stock_ret], axis=1).dropna()\n", + " if df_beta.shape[0] >= MIN_OBS_FOR_BETA:\n", + " try:\n", + " X = np.vstack([np.ones(len(df_beta)), df_beta.iloc[:, 1].values]).T\n", + " y = df_beta.iloc[:, 0].values\n", + " b = np.linalg.lstsq(X, y, rcond=None)[0]\n", + " de_on_ret_beta = b[1]\n", + " except Exception:\n", + " de_on_ret_beta = np.nan\n", + "\n", + " # corr(stock returns, ΔCapex)\n", + " capex_corr = np.nan\n", + " if stock_ret.notna().sum() >= MIN_OBS_FOR_BETA and g[\"Delta_Capex_pos\"].notna().sum() >= MIN_OBS_FOR_BETA:\n", + " capex_corr = pd.concat([stock_ret, g.set_index(\"FiscalPeriodEnd\")[\"Delta_Capex_pos\"]], axis=1).corr().iloc[0, 1]\n", + "\n", + " return pd.Series({\n", + " # Levels / mix\n", + " \"Latest_Debt_to_Equity\": latest_de,\n", + " \"Latest_LT_Debt_Share\": lt_share,\n", + "\n", + " # Growth & trends\n", + " \"Capex_Growth_Avg\": capex_g_avg,\n", + " \"Debt_Growth_Avg\": debt_g_avg,\n", + " \"RE_Growth_Avg\": re_g_avg,\n", + " \"DE_Slope_per_year\": de_slope,\n", + "\n", + " # Financing of capex\n", + " \"Debt_Financed_Capex_Share_med\": dfs_med,\n", + " \"Debt_to_CapexLevel_med\": debt_to_capex_lvl_med,\n", + "\n", + " # Behavior vs stock\n", + " \"DE_beta_on_StockRet\": de_on_ret_beta,\n", + " \"Capex_vs_StockRet_corr\": capex_corr,\n", + " })\n", + "\n", + "\n", + "scores = fin.groupby(\"Ticker\", as_index=False).apply(summarize_company).reset_index(drop=True).set_index(\"Ticker\")\n", + "\n", + "\n", + "# --------------------------\n", + "# Z-scores for each signal\n", + "# --------------------------\n", + "Z = pd.DataFrame(index=scores.index)\n", + "\n", + "# Prudence\n", + "Z[\"z_low_DE\"] = -zscore(scores[\"Latest_Debt_to_Equity\"]) # lower D/E better\n", + "Z[\"z_falling_DE\"] = -zscore(scores[\"DE_Slope_per_year\"]) # more negative slope better\n", + "Z[\"z_low_debt_to_capex\"]= -zscore(scores[\"Debt_to_CapexLevel_med\"]) # lower ΔDebt / Capex level better\n", + "\n", + "# Capex financing quality\n", + "Z[\"z_low_debt_fin_share\"] = -zscore(scores[\"Debt_Financed_Capex_Share_med\"]) # lower better\n", + "Z[\"z_LT_share\"] = zscore(scores[\"Latest_LT_Debt_Share\"]) # higher better\n", + "\n", + "# Growth & reinvestment\n", + "Z[\"z_capex_growth\"] = zscore(scores[\"Capex_Growth_Avg\"]) # higher better\n", + "Z[\"z_RE_growth\"] = zscore(scores[\"RE_Growth_Avg\"]) # higher better\n", + "\n", + "# Behavior vs stock\n", + "Z[\"z_DE_beta_stock\"] = -zscore(scores[\"DE_beta_on_StockRet\"]) # more negative better\n", + "Z[\"z_capex_vs_stock\"] = zscore(scores[\"Capex_vs_StockRet_corr\"]) # more positive better\n", + "\n", + "\n", + "# --------------------------\n", + "# Equal-by-aspect weighting (NaN-robust)\n", + "# --------------------------\n", + "aspects = {\n", + " \"prudence\": [\"z_low_DE\", \"z_falling_DE\", \"z_low_debt_to_capex\"],\n", + " \"capex_financing\": [\"z_low_debt_fin_share\", \"z_LT_share\"],\n", + " \"growth_reinvest\": [\"z_capex_growth\", \"z_RE_growth\"],\n", + " \"stock_behavior\": [\"z_DE_beta_stock\", \"z_capex_vs_stock\"],\n", + "}\n", + "\n", + "# Availability mask per component\n", + "A = ~Z.isna()\n", + "\n", + "# Which aspects have at least one available component for each ticker?\n", + "aspect_has_data = pd.DataFrame({a: A[cols].any(axis=1) for a, cols in aspects.items()})\n", + "\n", + "# Equal weight across available aspects (each gets 1 / #available_aspects)\n", + "n_aspects = aspect_has_data.sum(axis=1).replace(0, np.nan)\n", + "aspect_w = aspect_has_data.div(n_aspects, axis=0) # per-row aspect weights\n", + "\n", + "# Within each aspect, split that aspect’s weight equally among its available components\n", + "component_w = pd.DataFrame(0.0, index=Z.index, columns=Z.columns)\n", + "for a, cols in aspects.items():\n", + " if not cols:\n", + " continue\n", + " n_comp = A[cols].sum(axis=1).replace(0, np.nan) # available components in this aspect per row\n", + " per_comp_w = A[cols].div(n_comp, axis=0).mul(aspect_w[a], axis=0) # (aspect weight) / (#available comps)\n", + " component_w[cols] = per_comp_w\n", + "\n", + "# Final Behavior Score\n", + "scores[\"Task1_Behavior_Score\"] = (Z.fillna(0) * component_w.fillna(0)).sum(axis=1)\n", + "\n", + "\n", + "# --------------------------\n", + "# Aspect-level Ideal flag\n", + "# Pass ≥3 of 4 aspects (only counting aspects with data)\n", + "# --------------------------\n", + "# Base boolean checks\n", + "checks = pd.DataFrame(index=scores.index)\n", + "checks[\"low_DE_now\"] = scores[\"Latest_Debt_to_Equity\"] < np.nanmedian(scores[\"Latest_Debt_to_Equity\"])\n", + "checks[\"falling_DE\"] = scores[\"DE_Slope_per_year\"] < 0\n", + "checks[\"capex_growing\"] = scores[\"Capex_Growth_Avg\"] > 0\n", + "checks[\"prudent_fin_share\"] = (scores[\"Debt_Financed_Capex_Share_med\"] < 0.6)\n", + "checks[\"low_debt_to_capex\"] = (scores[\"Debt_to_CapexLevel_med\"] < np.nanmedian(scores[\"Debt_to_CapexLevel_med\"]))\n", + "checks[\"LT_share_ok\"] = scores[\"Latest_LT_Debt_Share\"] > np.nanmedian(scores[\"Latest_LT_Debt_Share\"])\n", + "checks[\"DE_drops_when_stock_up\"] = scores[\"DE_beta_on_StockRet\"] < 0\n", + "checks[\"capex_moves_with_stock\"] = scores[\"Capex_vs_StockRet_corr\"] > 0\n", + "\n", + "# Map checks to aspects\n", + "aspect_checks = {\n", + " \"prudence\": [\"low_DE_now\", \"falling_DE\", \"low_debt_to_capex\"], # require >=2 of these\n", + " \"capex_financing\": [\"prudent_fin_share\", \"LT_share_ok\"], # require >=1\n", + " \"growth_reinvest\": [\"capex_growing\"], # require >=1 (RE growth optional if you add it)\n", + " \"stock_behavior\": [\"DE_drops_when_stock_up\", \"capex_moves_with_stock\"]# require all available\n", + "}\n", + "\n", + "def _aspect_pass_for_row(row: pd.Series, names, mode: str):\n", + " vals = row[names]\n", + " avail = vals.notna()\n", + " if not avail.any():\n", + " return np.nan\n", + " trues = vals.fillna(False).sum()\n", + " total = avail.sum()\n", + " if mode == \"at_least_2\":\n", + " return trues >= min(2, total)\n", + " if mode == \"at_least_1\":\n", + " return trues >= 1\n", + " if mode == \"all_available\":\n", + " return trues == total\n", + " return False\n", + "\n", + "aspect_pass_df = pd.DataFrame(index=scores.index)\n", + "aspect_pass_df[\"prudence\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"prudence\"], \"at_least_2\"), axis=1)\n", + "aspect_pass_df[\"capex_financing\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"capex_financing\"], \"at_least_1\"), axis=1)\n", + "aspect_pass_df[\"growth_reinvest\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"growth_reinvest\"], \"at_least_1\"), axis=1)\n", + "aspect_pass_df[\"stock_behavior\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"stock_behavior\"], \"all_available\"), axis=1)\n", + "\n", + "n_avail_aspects = aspect_pass_df.notna().sum(axis=1)\n", + "n_pass_aspects = aspect_pass_df.fillna(False).sum(axis=1)\n", + "scores[\"Ideal_Flag\"] = (n_avail_aspects >= 3) & (n_pass_aspects >= 3)\n", + "\n", + "\n", + "# --------------------------\n", + "# Save outputs\n", + "# --------------------------\n", + "scores.reset_index().to_csv(\"task1_behavioral_scores.csv\", index=False, float_format=\"%.6f\")\n", + "scores.reset_index().sort_values(\"Task1_Behavior_Score\", ascending=False)\\\n", + " .to_csv(\"task1_behavioral_shortlist.csv\", index=False, float_format=\"%.6f\")\n", + "\n", + "print(\"✓ Saved task1_behavioral_scores.csv and task1_behavioral_shortlist.csv\")\n", + "print(scores.sort_values(\"Task1_Behavior_Score\", ascending=False).head(10)[\n", + " [\"Task1_Behavior_Score\", \"Ideal_Flag\"]\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "3d274752", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Saved task1_behavioral_scores.csv and task1_behavioral_shortlist.csv\n", + " Task1_Behavior_Score Ideal_Flag DE_beta_on_StockRet \\\n", + "Ticker \n", + "ATUSF 1.147166 True 0.036891 \n", + "2009.TW 0.887607 True -0.163638 \n", + "PILBF 0.551326 False -0.017556 \n", + "IVPAF 0.529693 True -0.089586 \n", + "HBM 0.502202 True -0.475345 \n", + "HBM.TO 0.494770 True -0.437697 \n", + "OCKA.F 0.487074 True -0.413293 \n", + "IYAA.F 0.476700 False -0.196286 \n", + "FVJ.F 0.438831 False -0.112566 \n", + "FSUGY 0.437584 False -0.091859 \n", + "\n", + " Capex_vs_StockRet_corr \n", + "Ticker \n", + "ATUSF 0.998645 \n", + "2009.TW 0.599495 \n", + "PILBF -0.594953 \n", + "IVPAF 0.231537 \n", + "HBM 0.919314 \n", + "HBM.TO 0.968417 \n", + "OCKA.F 0.983136 \n", + "IYAA.F -0.347706 \n", + "FVJ.F 0.896529 \n", + "FSUGY 0.940414 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.py:1214: RuntimeWarning: Mean of empty slice\n", + " return np.nanmean(a, axis, out=out, keepdims=keepdims)\n", + "/Users/yanzhe0329/Desktop/Stock Selection/Stock_Benchmark Analysis copy/.venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.py:1214: RuntimeWarning: Mean of empty slice\n", + " return np.nanmean(a, axis, out=out, keepdims=keepdims)\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/4292568386.py:135: RuntimeWarning: All-NaN slice encountered\n", + " dfs_med = np.nanmedian(g[\"Delta_Debt\"] / denom)\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/4292568386.py:136: RuntimeWarning: All-NaN slice encountered\n", + " debt_to_capex_lvl_med = np.nanmedian(g[\"Delta_Debt\"] / g[\"Capex_pos\"].replace(0, np.nan))\n", + "/var/folders/6b/p92_dgbd07ldpbpq29vbpd_m0000gn/T/ipykernel_66700/4292568386.py:177: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " scores = fin.groupby(\"Ticker\", as_index=False).apply(summarize_company).reset_index(drop=True).set_index(\"Ticker\")\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "\"\"\"\n", + "Task 1 — Debt-focused behavioral analysis with equal-by-aspect weighting.\n", + "Robust fix: align stock prices to fiscal dates with ±90d window (prefer prior date).\n", + "\n", + "Inputs:\n", + " - copper_outperformers_financials.csv\n", + " - outperforming_stocks.csv (Date + tickers)\n", + "\n", + "Outputs:\n", + " - task1_behavioral_scores.csv\n", + " - task1_behavioral_shortlist.csv\n", + "\"\"\"\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# --------------------------\n", + "# Config\n", + "# --------------------------\n", + "FIN_PATH = \"copper_outperformers_financials.csv\"\n", + "PX_PATH = \"outperforming_stocks.csv\"\n", + "\n", + "N_YEARS_LOOKBACK = 5 # use last N fiscal periods\n", + "MIN_OBS_FOR_BETA = 3 # min paired obs for beta/corr\n", + "PRICE_ALIGN_TOL_D = 90 # days tolerance for aligning prices to fiscal dates\n", + "\n", + "# --------------------------\n", + "# Helpers\n", + "# --------------------------\n", + "def zscore(s: pd.Series) -> pd.Series:\n", + " s = s.astype(float)\n", + " mu = s.mean(skipna=True)\n", + " sd = s.std(skipna=True, ddof=1)\n", + " if not np.isfinite(sd) or sd == 0:\n", + " return pd.Series(np.nan, index=s.index)\n", + " return (s - mu) / sd\n", + "\n", + "def slope_per_year(dates: pd.Series, y: pd.Series) -> float:\n", + " df = pd.DataFrame({\"t\": dates, \"y\": y}).dropna()\n", + " if df.shape[0] < 2 or df[\"t\"].nunique() < 2:\n", + " return np.nan\n", + " x = df[\"t\"].map(pd.Timestamp.toordinal).to_numpy(float)\n", + " yv = df[\"y\"].to_numpy(float)\n", + " try:\n", + " return np.polyfit(x, yv, 1)[0] * 365.0\n", + " except Exception:\n", + " return np.nan\n", + "\n", + "def nearest_price_level(p: pd.Series, d: pd.Timestamp, tol_days: int) -> float:\n", + " \"\"\"\n", + " Prefer last price on/before d within tol; else first after d within tol; else NaN.\n", + " \"\"\"\n", + " if p.empty:\n", + " return np.nan\n", + " tol = pd.Timedelta(days=tol_days)\n", + " # last on/before\n", + " before = p.loc[:d]\n", + " if not before.empty:\n", + " dt = d - before.index[-1]\n", + " if dt <= tol:\n", + " return float(before.iloc[-1])\n", + " # first after\n", + " after = p.loc[d:]\n", + " if not after.empty:\n", + " dt = after.index[0] - d\n", + " if dt <= tol:\n", + " return float(after.iloc[0])\n", + " return np.nan\n", + "\n", + "def annual_returns_aligned(p: pd.Series, fiscal_dates: pd.DatetimeIndex, tol_days: int) -> pd.Series:\n", + " \"\"\"\n", + " Build a price level at each fiscal date using nearest_price_level, then compute YoY returns.\n", + " Returns Series indexed by fiscal_dates.\n", + " \"\"\"\n", + " if p is None or p.empty:\n", + " return pd.Series(index=fiscal_dates, dtype=float)\n", + " levels = []\n", + " idx = []\n", + " for d in fiscal_dates:\n", + " val = nearest_price_level(p, pd.Timestamp(d), tol_days)\n", + " if np.isfinite(val):\n", + " levels.append(val); idx.append(pd.Timestamp(d))\n", + " if len(idx) < 2:\n", + " return pd.Series(index=fiscal_dates, dtype=float)\n", + " s = pd.Series(levels, index=pd.DatetimeIndex(idx)).sort_index()\n", + " r = s.pct_change()\n", + " return r.reindex(fiscal_dates)\n", + "\n", + "# --------------------------\n", + "# Load data\n", + "# --------------------------\n", + "fin = pd.read_csv(FIN_PATH, parse_dates=[\"FiscalPeriodEnd\"]).sort_values([\"Ticker\",\"FiscalPeriodEnd\"])\n", + "px = pd.read_csv(PX_PATH, parse_dates=[\"Date\"]).set_index(\"Date\").sort_index()\n", + "\n", + "need_cols = [\n", + " \"Total_Debt\",\"Long_Term_Debt\",\"Short_Current_Debt\",\"Shareholders_Equity\",\n", + " \"Cash\",\"Retained_Earnings\",\"Dividends_Paid\",\"Capex_raw\",\"Capex_pos\",\n", + " \"Debt_to_Equity\",\"LT_Debt_Share\",\"Delta_Debt\",\"Delta_Capex_pos\",\n", + " \"Debt_Growth_Pct\",\"Capex_Growth_Pct\",\"Debt_Financed_Capex_Share\"\n", + "]\n", + "for c in need_cols:\n", + " if c not in fin.columns:\n", + " fin[c] = np.nan\n", + "\n", + "# --------------------------\n", + "# Per-ticker summary\n", + "# --------------------------\n", + "def summarize_company(g: pd.DataFrame) -> pd.Series:\n", + " g = g.sort_values(\"FiscalPeriodEnd\").tail(N_YEARS_LOOKBACK)\n", + " if g.empty:\n", + " return pd.Series(dtype=float)\n", + "\n", + " last = g.iloc[-1]\n", + " dates = g[\"FiscalPeriodEnd\"]\n", + "\n", + " # Latest leverage & mix\n", + " latest_de = last.get(\"Debt_to_Equity\", np.nan)\n", + " latest_total_debt = last.get(\"Total_Debt\", np.nan)\n", + " latest_lt_debt = last.get(\"Long_Term_Debt\", np.nan)\n", + " lt_share = last.get(\"LT_Debt_Share\", np.nan)\n", + " if pd.isna(lt_share):\n", + " lt_share = (latest_lt_debt / latest_total_debt) if pd.notna(latest_total_debt) and latest_total_debt != 0 else np.nan\n", + "\n", + " # Trends / growth\n", + " de_slope = slope_per_year(dates, g[\"Debt_to_Equity\"])\n", + " capex_g_avg = g[\"Capex_Growth_Pct\"].mean(skipna=True)\n", + " debt_g_avg = g[\"Debt_Growth_Pct\"].mean(skipna=True)\n", + " re_g_avg = g[\"Retained_Earnings\"].pct_change().mean(skipna=True)\n", + "\n", + " # Financing of capex\n", + " dfs_med = g[\"Debt_Financed_Capex_Share\"].median(skipna=True)\n", + " if np.isnan(dfs_med):\n", + " denom = g[\"Delta_Capex_pos\"].replace(0, np.nan)\n", + " dfs_med = np.nanmedian(g[\"Delta_Debt\"] / denom)\n", + " debt_to_capex_lvl_med = np.nanmedian(g[\"Delta_Debt\"] / g[\"Capex_pos\"].replace(0, np.nan))\n", + "\n", + " # Behavior vs stock (robust alignment)\n", + " tk = g[\"Ticker\"].iloc[0]\n", + " if tk in px.columns:\n", + " r_stock = annual_returns_aligned(px[tk], g[\"FiscalPeriodEnd\"], tol_days=PRICE_ALIGN_TOL_D)\n", + " else:\n", + " r_stock = pd.Series(index=g[\"FiscalPeriodEnd\"], dtype=float)\n", + "\n", + " # β(D/E on stock returns)\n", + " de_on_ret_beta = np.nan\n", + " df_beta = pd.concat([g.set_index(\"FiscalPeriodEnd\")[\"Debt_to_Equity\"], r_stock], axis=1).dropna()\n", + " if df_beta.shape[0] >= MIN_OBS_FOR_BETA:\n", + " try:\n", + " X = np.vstack([np.ones(len(df_beta)), df_beta.iloc[:,1].values]).T\n", + " y = df_beta.iloc[:,0].values\n", + " b = np.linalg.lstsq(X, y, rcond=None)[0]\n", + " de_on_ret_beta = float(b[1])\n", + " except Exception:\n", + " de_on_ret_beta = np.nan\n", + "\n", + " # corr(stock returns, ΔCapex)\n", + " capex_corr = np.nan\n", + " delta_capex = g.set_index(\"FiscalPeriodEnd\")[\"Delta_Capex_pos\"]\n", + " paired = pd.concat([r_stock, delta_capex], axis=1).dropna()\n", + " if paired.shape[0] >= MIN_OBS_FOR_BETA:\n", + " capex_corr = paired.corr().iloc[0,1]\n", + "\n", + " return pd.Series({\n", + " \"Latest_Debt_to_Equity\": latest_de,\n", + " \"Latest_LT_Debt_Share\": lt_share,\n", + " \"Capex_Growth_Avg\": capex_g_avg,\n", + " \"Debt_Growth_Avg\": debt_g_avg,\n", + " \"RE_Growth_Avg\": re_g_avg,\n", + " \"DE_Slope_per_year\": de_slope,\n", + " \"Debt_Financed_Capex_Share_med\": dfs_med,\n", + " \"Debt_to_CapexLevel_med\": debt_to_capex_lvl_med,\n", + " \"DE_beta_on_StockRet\": de_on_ret_beta,\n", + " \"Capex_vs_StockRet_corr\": capex_corr,\n", + " })\n", + "\n", + "scores = fin.groupby(\"Ticker\", as_index=False).apply(summarize_company).reset_index(drop=True).set_index(\"Ticker\")\n", + "\n", + "# --------------------------\n", + "# Z-scores (signals)\n", + "# --------------------------\n", + "Z = pd.DataFrame(index=scores.index)\n", + "# Prudence\n", + "Z[\"z_low_DE\"] = -zscore(scores[\"Latest_Debt_to_Equity\"])\n", + "Z[\"z_falling_DE\"] = -zscore(scores[\"DE_Slope_per_year\"])\n", + "Z[\"z_low_debt_to_capex\"] = -zscore(scores[\"Debt_to_CapexLevel_med\"])\n", + "# Capex financing quality\n", + "Z[\"z_low_debt_fin_share\"]= -zscore(scores[\"Debt_Financed_Capex_Share_med\"])\n", + "Z[\"z_LT_share\"] = zscore(scores[\"Latest_LT_Debt_Share\"])\n", + "# Growth & reinvestment\n", + "Z[\"z_capex_growth\"] = zscore(scores[\"Capex_Growth_Avg\"])\n", + "Z[\"z_RE_growth\"] = zscore(scores[\"RE_Growth_Avg\"])\n", + "# Behavior vs stock\n", + "Z[\"z_DE_beta_stock\"] = -zscore(scores[\"DE_beta_on_StockRet\"])\n", + "Z[\"z_capex_vs_stock\"] = zscore(scores[\"Capex_vs_StockRet_corr\"])\n", + "\n", + "# --------------------------\n", + "# Equal-by-aspect weighting (NaN-robust)\n", + "# --------------------------\n", + "aspects = {\n", + " \"prudence\": [\"z_low_DE\", \"z_falling_DE\", \"z_low_debt_to_capex\"],\n", + " \"capex_financing\": [\"z_low_debt_fin_share\", \"z_LT_share\"],\n", + " \"growth_reinvest\": [\"z_capex_growth\", \"z_RE_growth\"],\n", + " \"stock_behavior\": [\"z_DE_beta_stock\", \"z_capex_vs_stock\"],\n", + "}\n", + "A = ~Z.isna()\n", + "aspect_has_data = pd.DataFrame({a: A[cols].any(axis=1) for a, cols in aspects.items()})\n", + "n_aspects = aspect_has_data.sum(axis=1).replace(0, np.nan)\n", + "aspect_w = aspect_has_data.div(n_aspects, axis=0)\n", + "\n", + "component_w = pd.DataFrame(0.0, index=Z.index, columns=Z.columns)\n", + "for a, cols in aspects.items():\n", + " if not cols: continue\n", + " n_comp = A[cols].sum(axis=1).replace(0, np.nan)\n", + " per_comp_w = A[cols].div(n_comp, axis=0).mul(aspect_w[a], axis=0)\n", + " component_w[cols] = per_comp_w\n", + "\n", + "scores[\"Task1_Behavior_Score\"] = (Z.fillna(0) * component_w.fillna(0)).sum(axis=1)\n", + "\n", + "# --------------------------\n", + "# Aspect-level Ideal flag (≥3 of 4 aspects)\n", + "# --------------------------\n", + "checks = pd.DataFrame(index=scores.index)\n", + "checks[\"low_DE_now\"] = scores[\"Latest_Debt_to_Equity\"] < np.nanmedian(scores[\"Latest_Debt_to_Equity\"])\n", + "checks[\"falling_DE\"] = scores[\"DE_Slope_per_year\"] < 0\n", + "checks[\"capex_growing\"] = scores[\"Capex_Growth_Avg\"] > 0\n", + "checks[\"prudent_fin_share\"] = (scores[\"Debt_Financed_Capex_Share_med\"] < 0.6)\n", + "checks[\"low_debt_to_capex\"] = (scores[\"Debt_to_CapexLevel_med\"] < np.nanmedian(scores[\"Debt_to_CapexLevel_med\"]))\n", + "checks[\"LT_share_ok\"] = scores[\"Latest_LT_Debt_Share\"] > np.nanmedian(scores[\"Latest_LT_Debt_Share\"])\n", + "checks[\"DE_drops_when_stock_up\"] = scores[\"DE_beta_on_StockRet\"] < 0\n", + "checks[\"capex_moves_with_stock\"] = scores[\"Capex_vs_StockRet_corr\"] > 0\n", + "\n", + "aspect_checks = {\n", + " \"prudence\": [\"low_DE_now\", \"falling_DE\", \"low_debt_to_capex\"], # ≥2\n", + " \"capex_financing\": [\"prudent_fin_share\", \"LT_share_ok\"], # ≥1\n", + " \"growth_reinvest\": [\"capex_growing\"], # ≥1\n", + " \"stock_behavior\": [\"DE_drops_when_stock_up\", \"capex_moves_with_stock\"] # all available\n", + "}\n", + "\n", + "def _aspect_pass_for_row(row: pd.Series, names, mode: str):\n", + " vals = row[names]\n", + " avail = vals.notna()\n", + " if not avail.any():\n", + " return np.nan\n", + " trues = vals.fillna(False).sum()\n", + " total = avail.sum()\n", + " if mode == \"at_least_2\":\n", + " return trues >= min(2, total)\n", + " if mode == \"at_least_1\":\n", + " return trues >= 1\n", + " if mode == \"all_available\":\n", + " return trues == total\n", + " return False\n", + "\n", + "aspect_pass_df = pd.DataFrame(index=scores.index)\n", + "aspect_pass_df[\"prudence\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"prudence\"], \"at_least_2\"), axis=1)\n", + "aspect_pass_df[\"capex_financing\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"capex_financing\"], \"at_least_1\"), axis=1)\n", + "aspect_pass_df[\"growth_reinvest\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"growth_reinvest\"], \"at_least_1\"), axis=1)\n", + "aspect_pass_df[\"stock_behavior\"] = checks.apply(lambda r: _aspect_pass_for_row(r, aspect_checks[\"stock_behavior\"], \"all_available\"), axis=1)\n", + "\n", + "n_avail_aspects = aspect_pass_df.notna().sum(axis=1)\n", + "n_pass_aspects = aspect_pass_df.fillna(False).sum(axis=1)\n", + "scores[\"Ideal_Flag\"] = (n_avail_aspects >= 3) & (n_pass_aspects >= 3)\n", + "\n", + "# --------------------------\n", + "# Save\n", + "# --------------------------\n", + "scores.reset_index().to_csv(\"task1_behavioral_scores.csv\", index=False, float_format=\"%.6f\")\n", + "scores.reset_index().sort_values(\"Task1_Behavior_Score\", ascending=False)\\\n", + " .to_csv(\"task1_behavioral_shortlist.csv\", index=False, float_format=\"%.6f\")\n", + "\n", + "print(\"✓ Saved task1_behavioral_scores.csv and task1_behavioral_shortlist.csv\")\n", + "print(scores.sort_values(\"Task1_Behavior_Score\", ascending=False).head(10)[\n", + " [\"Task1_Behavior_Score\", \"Ideal_Flag\", \"DE_beta_on_StockRet\", \"Capex_vs_StockRet_corr\"]\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "b85075be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Task 2 Equity Portfolio — Diagnostics ===\n", + "OPT_DEBT_MODE: DE_CAP\n", + "Weighted Avg D/E: 0.352 (cap: 0.352, 60th pct)\n", + "Portfolio DFS (weighted avg): 1.123 (target >= 0.60)\n", + "Weight in high-DFS names: 0.500 (target >= 0.50)\n", + "Names in portfolio: 10 / 34\n", + "\n", + "✓ Saved task2_equity_portfolio_allocation.csv, task2_equity_inputs_snapshot.csv, task2_equity_diagnostics.txt\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "\"\"\"\n", + "Task 2 (reinterpreted) — Optimize a STOCK portfolio's expected return\n", + "subject to portfolio-level DEBT constraints and \"capex mainly debt-financed\" preference.\n", + "\n", + "Inputs (must exist in working directory):\n", + " - copper_outperformers_financials.csv (long table from your pipeline)\n", + " - outperforming_stocks.csv (Date + ticker columns with prices)\n", + "\n", + "Outputs:\n", + " - task2_equity_portfolio_allocation.csv\n", + " - task2_equity_inputs_snapshot.csv\n", + " - task2_equity_diagnostics.txt\n", + "\n", + "Notes:\n", + " - Choose OPT_DEBT_MODE = \"DE_CAP\" (cap portfolio-weighted avg D/E) or \"DEBT_BUDGET_USD\" (cap total issuer debt dollars)\n", + " - Uses trailing equity CAGR as expected return proxy (RET_YEARS)\n", + " - Enforces \"capex mainly debt-financed\" via:\n", + " (a) portfolio DFS floor (weighted avg DFS >= PORTFOLIO_DFS_MIN), and\n", + " (b) minimum weight in high-DFS names (>= MIN_WEIGHT_HIGH_DFS)\n", + " - If SciPy is unavailable, uses a greedy fallback (fixed here; no 'nonlocal' usage).\n", + "\"\"\"\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "# Optional linear program solver; falls back to greedy if not available\n", + "try:\n", + " from scipy.optimize import linprog\n", + " SCIPY_OK = True\n", + "except Exception:\n", + " SCIPY_OK = False\n", + "\n", + "import yfinance as yf\n", + "\n", + "FIN_CSV = \"copper_outperformers_financials.csv\"\n", + "PX_CSV = \"outperforming_stocks.csv\"\n", + "\n", + "# --------------------------\n", + "# Tunables\n", + "# --------------------------\n", + "# Expected return proxy\n", + "RET_YEARS = 3 # trailing CAGR horizon; fallback to 1 if needed\n", + "\n", + "# Portfolio constraints\n", + "MAX_NAME_WEIGHT = 0.12 # per-name cap (fraction of portfolio)\n", + "OPT_DEBT_MODE = \"DE_CAP\" # \"DE_CAP\" or \"DEBT_BUDGET_USD\"\n", + "\n", + "# If OPT_DEBT_MODE == \"DE_CAP\": (scale-invariant)\n", + "DE_AVG_PCTL_CAP = 60 # cap weighted avg D/E at this cross-sectional percentile\n", + "\n", + "# If OPT_DEBT_MODE == \"DEBT_BUDGET_USD\": (dollar cap)\n", + "EQUITY_BUDGET_USD = 100_000_000.0 # dollars invested in equity\n", + "DEBT_BUDGET_USD = 2_000_000_000.0 # cap on sum_i (w_i * EQUITY_BUDGET * TotalDebt_i)\n", + "\n", + "# \"Capex mainly debt-financed\"\n", + "PORTFOLIO_DFS_MIN = 0.60 # weighted average DFS must be >= this\n", + "HIGH_DFS_THRESH = 0.60 # threshold for high-DFS bucket\n", + "MIN_WEIGHT_HIGH_DFS = 0.50 # at least this fraction in high-DFS names\n", + "\n", + "# Industry normalization gates (optional)\n", + "APPLY_INDUSTRY_GATES = True\n", + "IND_GATES = {\n", + " \"Debt_to_Equity_pctl_max\": 90, # drop if above 90th pct within industry\n", + " \"Debt_Growth_Pct_pctl_max\": 90\n", + "}\n", + "\n", + "# --------------------------\n", + "# Helpers\n", + "# --------------------------\n", + "def trailing_cagr(prices: pd.Series, years=3):\n", + " p = prices.dropna()\n", + " if p.size < 2:\n", + " return np.nan\n", + " end = p.index.max()\n", + " start_cut = end - pd.DateOffset(years=years)\n", + " p0 = p.loc[:start_cut].iloc[-1] if (p.index <= start_cut).any() else p.iloc[0]\n", + " p1 = p.iloc[-1]\n", + " if p0 <= 0 or p1 <= 0:\n", + " return np.nan\n", + " return (p1 / p0) ** (1.0 / max(years, 1e-6)) - 1.0\n", + "\n", + "def latest_non_na(s: pd.Series):\n", + " s = s.dropna()\n", + " return s.iloc[-1] if not s.empty else np.nan\n", + "\n", + "def industry_for_tickers(tickers):\n", + " out = {}\n", + " for tk in tickers:\n", + " try:\n", + " info = yf.Ticker(tk).get_info() # .info may be deprecated in some yfinance versions\n", + " out[tk] = info.get(\"industry\") or info.get(\"sector\") or \"Unknown\"\n", + " except Exception:\n", + " out[tk] = \"Unknown\"\n", + " return out\n", + "\n", + "def group_percentile(series, groups, p):\n", + " return series.groupby(groups).transform(lambda s: np.nanpercentile(s.dropna(), p) if s.notna().any() else np.nan)\n", + "\n", + "# --------------------------\n", + "# Load data\n", + "# --------------------------\n", + "fin = pd.read_csv(FIN_CSV, parse_dates=[\"FiscalPeriodEnd\"]).sort_values([\"Ticker\",\"FiscalPeriodEnd\"])\n", + "px = pd.read_csv(PX_CSV, parse_dates=[\"Date\"]).set_index(\"Date\").sort_index()\n", + "\n", + "# Ensure needed columns exist\n", + "need = [\"Total_Debt\",\"Debt_to_Equity\",\"Debt_Financed_Capex_Share\",\n", + " \"Capex_Growth_Pct\",\"Debt_Growth_Pct\"]\n", + "for c in need:\n", + " if c not in fin.columns:\n", + " fin[c] = np.nan\n", + "\n", + "# --------------------------\n", + "# Issuer snapshot (latest levels + average growth metrics)\n", + "# --------------------------\n", + "snap = (fin.sort_values(\"FiscalPeriodEnd\")\n", + " .groupby(\"Ticker\")\n", + " .agg(Total_Debt=(\"Total_Debt\", latest_non_na),\n", + " Debt_to_Equity=(\"Debt_to_Equity\", latest_non_na),\n", + " Debt_Financed_Capex_Share=(\"Debt_Financed_Capex_Share\",\n", + " lambda s: s.dropna().median() if s.notna().any() else np.nan),\n", + " Capex_Growth_Pct=(\"Capex_Growth_Pct\", lambda s: s.mean(skipna=True)),\n", + " Debt_Growth_Pct=(\"Debt_Growth_Pct\", lambda s: s.mean(skipna=True))\n", + " ))\n", + "\n", + "# Expected returns from price history\n", + "def exp_ret(tk):\n", + " if tk not in px.columns:\n", + " return np.nan\n", + " r3 = trailing_cagr(px[tk], years=RET_YEARS)\n", + " return r3 if np.isfinite(r3) else trailing_cagr(px[tk], years=1)\n", + "\n", + "snap[\"Exp_Return\"] = [exp_ret(tk) for tk in snap.index]\n", + "\n", + "# Industry tags and optional gates\n", + "ind_map = industry_for_tickers(snap.index)\n", + "snap[\"Industry\"] = [ind_map.get(tk, \"Unknown\") for tk in snap.index]\n", + "\n", + "if APPLY_INDUSTRY_GATES:\n", + " for col, pctl in IND_GATES.items():\n", + " metric = col.replace(\"_pctl_max\",\"\")\n", + " if metric in snap.columns and pctl is not None:\n", + " thr = group_percentile(snap[metric], snap[\"Industry\"], pctl)\n", + " snap = snap[(snap[metric].isna()) | (snap[metric] <= thr)]\n", + "\n", + "# Keep feasible names\n", + "opt = snap.dropna(subset=[\"Exp_Return\",\"Debt_to_Equity\",\"Debt_Financed_Capex_Share\"]).copy()\n", + "if opt.empty:\n", + " raise RuntimeError(\"No tickers have Exp_Return, D/E, and DFS available for optimization.\")\n", + "\n", + "# DFS bucket\n", + "opt[\"is_high_DFS\"] = (opt[\"Debt_Financed_Capex_Share\"] >= HIGH_DFS_THRESH).astype(float)\n", + "\n", + "# --------------------------\n", + "# Build optimization problem\n", + "# --------------------------\n", + "tickers = opt.index.to_list()\n", + "mu = opt[\"Exp_Return\"].to_numpy()\n", + "DE = opt[\"Debt_to_Equity\"].to_numpy()\n", + "DFS = opt[\"Debt_Financed_Capex_Share\"].to_numpy()\n", + "HIGH = opt[\"is_high_DFS\"].to_numpy()\n", + "n = len(tickers)\n", + "\n", + "# Equality: sum w_i = 1\n", + "A_eq = np.ones((1, n))\n", + "b_eq = np.array([1.0], dtype=float)\n", + "\n", + "# Inequalities\n", + "A_ub_list = []\n", + "b_ub_list = []\n", + "\n", + "# Per-name cap: w_i <= MAX_NAME_WEIGHT\n", + "A_ub_list.extend(np.eye(n))\n", + "b_ub_list.extend([MAX_NAME_WEIGHT] * n)\n", + "\n", + "# Debt constraint\n", + "if OPT_DEBT_MODE.upper() == \"DE_CAP\":\n", + " # cap weighted average D/E at DE_AVG_PCTL_CAP percentile\n", + " DE_cap = np.nanpercentile(opt[\"Debt_to_Equity\"].dropna(), DE_AVG_PCTL_CAP)\n", + " A_ub_list.append(DE) # sum w_i * DE_i <= DE_cap\n", + " b_ub_list.append(DE_cap)\n", + "elif OPT_DEBT_MODE.upper() == \"DEBT_BUDGET_USD\":\n", + " # sum (w_i * EQUITY_BUDGET_USD) * Total_Debt_i <= DEBT_BUDGET_USD\n", + " TD = opt[\"Total_Debt\"].fillna(0.0).to_numpy()\n", + " A_ub_list.append(TD) # divide both sides by EQUITY_BUDGET_USD\n", + " b_ub_list.append(DEBT_BUDGET_USD / EQUITY_BUDGET_USD)\n", + "else:\n", + " raise ValueError(\"OPT_DEBT_MODE must be 'DE_CAP' or 'DEBT_BUDGET_USD'.\")\n", + "\n", + "# DFS floor: sum w_i * DFS_i >= PORTFOLIO_DFS_MIN → -sum w_i * DFS_i <= -PORTFOLIO_DFS_MIN\n", + "if np.isfinite(PORTFOLIO_DFS_MIN) and PORTFOLIO_DFS_MIN > 0:\n", + " A_ub_list.append(-DFS)\n", + " b_ub_list.append(-PORTFOLIO_DFS_MIN)\n", + "\n", + "# High-DFS weight floor: sum w_i * 1{high} >= MIN_WEIGHT_HIGH_DFS → -sum w_i * HIGH_i <= -MIN_WEIGHT_HIGH_DFS\n", + "if np.isfinite(MIN_WEIGHT_HIGH_DFS) and MIN_WEIGHT_HIGH_DFS > 0:\n", + " A_ub_list.append(-HIGH)\n", + " b_ub_list.append(-MIN_WEIGHT_HIGH_DFS)\n", + "\n", + "A_ub = np.vstack(A_ub_list)\n", + "b_ub = np.array(b_ub_list, dtype=float)\n", + "bounds = [(0.0, MAX_NAME_WEIGHT) for _ in range(n)]\n", + "\n", + "# --------------------------\n", + "# Solve (LP if available; greedy fallback otherwise)\n", + "# --------------------------\n", + "if SCIPY_OK:\n", + " res = linprog(c=-mu, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq,\n", + " bounds=bounds, method=\"highs\")\n", + " use_lp = res.success\n", + "else:\n", + " use_lp = False\n", + "\n", + "if not use_lp:\n", + " # Greedy fallback: satisfy DFS floors first, then fill by return under caps (no 'nonlocal')\n", + " w = np.zeros(n, dtype=float)\n", + "\n", + " def fill_floor(w_arr: np.ndarray, mask: np.ndarray, target: float) -> np.ndarray:\n", + " \"\"\"Ensure sum(w * mask) >= target by topping up best candidates under caps.\"\"\"\n", + " if target <= 0:\n", + " return w_arr\n", + " achieved = float(w_arr @ mask)\n", + " remaining = target - achieved\n", + " if remaining <= 1e-12:\n", + " return w_arr\n", + " idxs = np.where(mask > 0)[0]\n", + " order = idxs[np.argsort(-mu[idxs])] # prefer higher expected return\n", + " for i in order:\n", + " if remaining <= 0:\n", + " break\n", + " cap_left = MAX_NAME_WEIGHT - w_arr[i]\n", + " if cap_left <= 0:\n", + " continue\n", + " add = min(cap_left, remaining)\n", + " if add > 0:\n", + " w_arr[i] += add\n", + " remaining -= add\n", + " return w_arr\n", + "\n", + " # 1) Floor on weight in high-DFS names\n", + " if np.isfinite(MIN_WEIGHT_HIGH_DFS) and MIN_WEIGHT_HIGH_DFS > 0:\n", + " w = fill_floor(w, HIGH, MIN_WEIGHT_HIGH_DFS)\n", + "\n", + " # 2) Portfolio DFS floor: push weight toward names with high (DFS * mu)\n", + " if np.isfinite(PORTFOLIO_DFS_MIN) and PORTFOLIO_DFS_MIN > 0:\n", + " deficit = PORTFOLIO_DFS_MIN - float(w @ DFS)\n", + " if deficit > 1e-12:\n", + " order = np.argsort(-(DFS * mu)) # prefer high DFS and high return\n", + " for i in order:\n", + " if deficit <= 1e-12:\n", + " break\n", + " if DFS[i] <= 0:\n", + " continue\n", + " cap_left = MAX_NAME_WEIGHT - w[i]\n", + " if cap_left <= 0:\n", + " continue\n", + " needed = deficit / max(DFS[i], 1e-9)\n", + " add = min(cap_left, needed)\n", + " if add > 0:\n", + " w[i] += add\n", + " deficit = PORTFOLIO_DFS_MIN - float(w @ DFS)\n", + "\n", + " # 3) Fill remaining weight purely by expected return\n", + " rem = 1.0 - w.sum()\n", + " if rem > 1e-9:\n", + " order = np.argsort(-mu)\n", + " for i in order:\n", + " if rem <= 0:\n", + " break\n", + " cap_left = MAX_NAME_WEIGHT - w[i]\n", + " if cap_left <= 0:\n", + " continue\n", + " add = min(cap_left, rem)\n", + " if add > 0:\n", + " w[i] += add\n", + " rem -= add\n", + "\n", + " # Package result like linprog\n", + " class _Res: pass\n", + " res = _Res(); res.x = w\n", + "\n", + "# Normalize in case of tiny numerical drift\n", + "w = pd.Series(res.x, index=tickers, name=\"Weight\")\n", + "w = w.clip(lower=0.0, upper=MAX_NAME_WEIGHT)\n", + "w = w / w.sum()\n", + "\n", + "# --------------------------\n", + "# Diagnostics & save\n", + "# --------------------------\n", + "weighted_DE = float(np.nansum(w.to_numpy() * DE))\n", + "weighted_DFS = float(np.nansum(w.to_numpy() * DFS))\n", + "high_share = float(np.nansum(w.to_numpy() * HIGH))\n", + "\n", + "implied_debt_usd = np.nan\n", + "if OPT_DEBT_MODE.upper() == \"DEBT_BUDGET_USD\":\n", + " TD = opt[\"Total_Debt\"].fillna(0.0).to_numpy()\n", + " implied_debt_usd = float(np.nansum(w.to_numpy() * TD) * EQUITY_BUDGET_USD)\n", + "\n", + "out = pd.DataFrame({\n", + " \"Ticker\": tickers,\n", + " \"Weight\": w.values,\n", + " \"Exp_Return\": mu,\n", + " \"Debt_to_Equity\": DE,\n", + " \"Debt_Financed_Capex_Share\": DFS,\n", + " \"High_DFS_flag\": (DFS >= HIGH_DFS_THRESH).astype(int),\n", + " \"Total_Debt\": opt[\"Total_Debt\"].to_numpy(),\n", + " \"Industry\": opt[\"Industry\"].to_numpy()\n", + "}).sort_values(\"Weight\", ascending=False)\n", + "\n", + "snap_to_save = opt.reset_index()\n", + "out.to_csv(\"task2_equity_portfolio_allocation.csv\", index=False, float_format=\"%.6f\")\n", + "snap_to_save.to_csv(\"task2_equity_inputs_snapshot.csv\", index=False, float_format=\"%.6f\")\n", + "\n", + "diag_lines = []\n", + "diag_lines.append(f\"OPT_DEBT_MODE: {OPT_DEBT_MODE}\")\n", + "if OPT_DEBT_MODE.upper() == \"DE_CAP\":\n", + " de_cap_val = np.nanpercentile(opt['Debt_to_Equity'].dropna(), DE_AVG_PCTL_CAP)\n", + " diag_lines.append(f\"Weighted Avg D/E: {weighted_DE:.3f} (cap: {de_cap_val:.3f}, {DE_AVG_PCTL_CAP}th pct)\")\n", + "else:\n", + " diag_lines.append(f\"Equity Budget (USD): {EQUITY_BUDGET_USD:,.0f}\")\n", + " diag_lines.append(f\"Implied Debt Exposure (USD): {implied_debt_usd:,.0f} (cap: {DEBT_BUDGET_USD:,.0f})\")\n", + "diag_lines.append(f\"Portfolio DFS (weighted avg): {weighted_DFS:.3f} (target >= {PORTFOLIO_DFS_MIN:.2f})\")\n", + "diag_lines.append(f\"Weight in high-DFS names: {high_share:.3f} (target >= {MIN_WEIGHT_HIGH_DFS:.2f})\")\n", + "diag_lines.append(f\"Names in portfolio: {(w > 1e-6).sum()} / {len(w)}\")\n", + "\n", + "print(\"\\n=== Task 2 Equity Portfolio — Diagnostics ===\")\n", + "for line in diag_lines:\n", + " print(line)\n", + "\n", + "Path(\"task2_equity_diagnostics.txt\").write_text(\"\\n\".join(diag_lines))\n", + "print(\"\\n✓ Saved task2_equity_portfolio_allocation.csv, task2_equity_inputs_snapshot.csv, task2_equity_diagnostics.txt\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "420631b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Portfolio Performance Summary ===\n", + " Start End PeriodsPerYear Total_Return CAGR Ann_Vol Sharpe Max_Drawdown Obs Freq RF_Annual\n", + "2020-01-20 2025-06-11 252 6.132665 0.421388 0.319802 1.260158 -0.529606 1408 D 0.0\n", + "\n", + "Saved:\n", + " - task2_equity_perf_summary.csv\n", + " - task2_equity_nav.csv\n", + " - task2_equity_rolling_sharpe.csv\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "\"\"\"\n", + "Evaluate Task 2 equity portfolio performance (static weights).\n", + "Inputs:\n", + " - task2_equity_portfolio_allocation.csv (columns: Ticker, Weight, ...)\n", + " - outperforming_stocks.csv (Date + ticker columns with prices)\n", + "Outputs:\n", + " - task2_equity_perf_summary.csv\n", + " - task2_equity_nav.csv\n", + " - task2_equity_rolling_sharpe.csv\n", + "\"\"\"\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# ------------------ CONFIG ------------------\n", + "WEIGHTS_CSV = \"task2_equity_portfolio_allocation.csv\"\n", + "PRICES_CSV = \"outperforming_stocks.csv\"\n", + "\n", + "# Optional evaluation window (ISO dates or None to use full overlap)\n", + "START_DATE = None # e.g., \"2022-01-01\"\n", + "END_DATE = None\n", + "\n", + "# Frequency: 'D' for daily, 'W-FRI' for weekly (Friday)\n", + "FREQ = \"D\"\n", + "\n", + "# Annual risk-free rate for Sharpe (set to 0.0 if unknown)\n", + "RISK_FREE_ANNUAL = 0.00\n", + "\n", + "# --------------------------------------------\n", + "\n", + "def periods_per_year(freq: str) -> int:\n", + " return 52 if freq.startswith(\"W\") else 252\n", + "\n", + "def to_period_returns(px: pd.DataFrame, freq: str) -> pd.DataFrame:\n", + " if freq == \"D\":\n", + " return px.pct_change()\n", + " else:\n", + " # last price of each period (e.g., Friday) then pct_change\n", + " return px.resample(freq).last().pct_change()\n", + "\n", + "def max_drawdown(nav: pd.Series) -> float:\n", + " rolling_max = nav.cummax()\n", + " dd = nav / rolling_max - 1.0\n", + " return float(dd.min())\n", + "\n", + "def annualize_return(mean_period_ret: float, ppy: int) -> float:\n", + " # If you want geometric CAGR from equity curve, we’ll compute that separately.\n", + " return mean_period_ret * ppy\n", + "\n", + "def cagr_from_nav(nav: pd.Series, ppy: int) -> float:\n", + " nav = nav.dropna()\n", + " if nav.empty:\n", + " return np.nan\n", + " T = len(nav) / ppy\n", + " if nav.iloc[0] <= 0:\n", + " return np.nan\n", + " return nav.iloc[-1] ** (1.0 / max(T, 1e-9)) - 1.0\n", + "\n", + "def annualized_vol(std_period_ret: float, ppy: int) -> float:\n", + " return std_period_ret * np.sqrt(ppy)\n", + "\n", + "def rolling_sharpe(returns: pd.Series, window: int, ppy: int, rf_annual: float) -> pd.Series:\n", + " rf_period = rf_annual / ppy\n", + " ex = returns - rf_period\n", + " roll_mean = ex.rolling(window).mean()\n", + " roll_std = returns.rolling(window).std(ddof=1)\n", + " rs = (roll_mean / roll_std) * np.sqrt(ppy)\n", + " return rs\n", + "\n", + "# ---------- Load data ----------\n", + "weights_df = pd.read_csv(WEIGHTS_CSV)\n", + "px = pd.read_csv(PRICES_CSV, parse_dates=[\"Date\"]).set_index(\"Date\").sort_index()\n", + "\n", + "# Keep only tickers with positive weights and present in prices\n", + "w = weights_df.set_index(\"Ticker\")[\"Weight\"].astype(float)\n", + "w = w[w > 0]\n", + "avail = [tk for tk in w.index if tk in px.columns]\n", + "missing = sorted(set(w.index) - set(avail))\n", + "if missing:\n", + " print(f\"Warning: dropping {len(missing)} tickers not found in price file: {missing[:5]}{'...' if len(missing)>5 else ''}\")\n", + "w = w.loc[avail]\n", + "w = w / w.sum() # re-normalize to 1 after any drops\n", + "\n", + "# Subset price matrix to portfolio names\n", + "px_sub = px[avail].copy()\n", + "\n", + "# Optional date window\n", + "if START_DATE:\n", + " px_sub = px_sub.loc[pd.Timestamp(START_DATE):]\n", + "if END_DATE:\n", + " px_sub = px_sub.loc[:pd.Timestamp(END_DATE)]\n", + "\n", + "# Compute period returns\n", + "rets_asset = to_period_returns(px_sub, FREQ)\n", + "# Drop initial NaNs and any all-NaN rows\n", + "rets_asset = rets_asset.dropna(how=\"all\")\n", + "\n", + "# Align weights to columns and compute portfolio returns (static weights)\n", + "w = w.reindex(rets_asset.columns).fillna(0.0)\n", + "port_ret = (rets_asset * w).sum(axis=1)\n", + "\n", + "# Build equity curve (start at 1.0)\n", + "nav = (1.0 + port_ret.fillna(0)).cumprod()\n", + "\n", + "# Metrics\n", + "PPY = periods_per_year(FREQ)\n", + "rf_period = RISK_FREE_ANNUAL / PPY\n", + "excess = port_ret - rf_period\n", + "\n", + "mean_period = port_ret.mean()\n", + "std_period = port_ret.std(ddof=1)\n", + "\n", + "cagr = cagr_from_nav(nav, PPY) # geometric\n", + "ann_vol = annualized_vol(std_period, PPY)\n", + "sharpe = (excess.mean() / std_period) * np.sqrt(PPY) if std_period > 0 else np.nan\n", + "tot_return = float(nav.iloc[-1] - 1.0)\n", + "mdd = max_drawdown(nav)\n", + "\n", + "summary = pd.DataFrame([{\n", + " \"Start\": nav.index.min(),\n", + " \"End\": nav.index.max(),\n", + " \"PeriodsPerYear\": PPY,\n", + " \"Total_Return\": tot_return,\n", + " \"CAGR\": cagr,\n", + " \"Ann_Vol\": ann_vol,\n", + " \"Sharpe\": sharpe,\n", + " \"Max_Drawdown\": mdd,\n", + " \"Obs\": int(port_ret.dropna().shape[0]),\n", + " \"Freq\": FREQ,\n", + " \"RF_Annual\": RISK_FREE_ANNUAL\n", + "}])\n", + "\n", + "# Rolling Sharpe (about 6 months for daily, 26 weeks for weekly)\n", + "roll_win = 126 if FREQ == \"D\" else 26\n", + "rolling_sh = rolling_sharpe(port_ret, roll_win, PPY, RISK_FREE_ANNUAL)\n", + "\n", + "# Save outputs\n", + "summary.to_csv(\"task2_equity_perf_summary.csv\", index=False, float_format=\"%.6f\")\n", + "nav.rename(\"NAV\").to_csv(\"task2_equity_nav.csv\", header=True)\n", + "rolling_sh.rename(\"Rolling_Sharpe\").to_csv(\"task2_equity_rolling_sharpe.csv\", header=True)\n", + "\n", + "print(\"\\n=== Portfolio Performance Summary ===\")\n", + "print(summary.to_string(index=False))\n", + "\n", + "print(\"\\nSaved:\")\n", + "print(\" - task2_equity_perf_summary.csv\")\n", + "print(\" - task2_equity_nav.csv\")\n", + "print(\" - task2_equity_rolling_sharpe.csv\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "eabd3717", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Performance (aligned window) ===\n", + " Name Start End Total_Return CAGR Ann_Vol Sharpe Max_Drawdown Obs\n", + "Portfolio 2020-01-21 2025-06-11 6.132665 0.439910 0.326600 1.305427 -0.520011 1357\n", + " HG=F 2020-01-21 2025-06-11 0.672822 0.100183 0.247592 0.528868 -0.348651 1357\n", + "\n", + "Saved:\n", + " - task2_equity_nav_vs_HG.png\n", + " - task2_equity_vs_HG_metrics.csv\n", + " - task2_equity_nav.csv\n", + " - task2_equity_rolling_sharpe.csv\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "\"\"\"\n", + "Compare portfolio equity curve vs underlying (HG=F) and report metrics.\n", + "\n", + "Inputs:\n", + " - task2_equity_portfolio_allocation.csv (columns: Ticker, Weight, ...)\n", + " - outperforming_stocks.csv (Date + ticker columns with prices)\n", + "\n", + "Outputs:\n", + " - task2_equity_nav_vs_HG.png\n", + " - task2_equity_vs_HG_metrics.csv\n", + " - task2_equity_nav.csv\n", + " - task2_equity_rolling_sharpe.csv\n", + "\"\"\"\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import yfinance as yf\n", + "from pathlib import Path\n", + "\n", + "# ------------------ CONFIG ------------------\n", + "WEIGHTS_CSV = \"task2_equity_portfolio_allocation.csv\"\n", + "PRICES_CSV = \"outperforming_stocks.csv\"\n", + "\n", + "# Optional evaluation window\n", + "START_DATE = None # e.g., \"2020-01-01\"\n", + "END_DATE = None\n", + "\n", + "# Frequency: 'D' (daily) or 'W-FRI' (weekly, Friday close)\n", + "FREQ = \"D\"\n", + "\n", + "# Annual risk-free rate for Sharpe\n", + "RISK_FREE_ANNUAL = 0.00\n", + "\n", + "# Ticker for underlying copper\n", + "UNDERLYING = \"HG=F\"\n", + "\n", + "# ------------------ HELPERS ------------------\n", + "def periods_per_year(freq: str) -> int:\n", + " return 52 if freq.startswith(\"W\") else 252\n", + "\n", + "def resample_prices(px: pd.DataFrame, freq: str) -> pd.DataFrame:\n", + " return px if freq == \"D\" else px.resample(freq).last()\n", + "\n", + "def to_returns(px: pd.DataFrame, freq: str) -> pd.DataFrame:\n", + " pxr = resample_prices(px, freq)\n", + " return pxr.pct_change()\n", + "\n", + "def max_drawdown(nav: pd.Series) -> float:\n", + " peak = nav.cummax()\n", + " dd = nav / peak - 1.0\n", + " return float(dd.min())\n", + "\n", + "def cagr_from_nav(nav: pd.Series, ppy: int) -> float:\n", + " nav = nav.dropna()\n", + " if nav.empty or nav.iloc[0] <= 0:\n", + " return np.nan\n", + " T_years = len(nav) / ppy\n", + " return nav.iloc[-1] ** (1.0 / max(T_years, 1e-9)) - 1.0\n", + "\n", + "def perf_summary(name: str, nav: pd.Series, rets: pd.Series, ppy: int, rf_annual: float) -> dict:\n", + " rf_period = rf_annual / ppy\n", + " ex = rets - rf_period\n", + " mu_p = rets.mean()\n", + " sd_p = rets.std(ddof=1)\n", + " return {\n", + " \"Name\": name,\n", + " \"Start\": nav.index.min(),\n", + " \"End\": nav.index.max(),\n", + " \"Total_Return\": float(nav.iloc[-1] - 1.0),\n", + " \"CAGR\": float(cagr_from_nav(nav, ppy)),\n", + " \"Ann_Vol\": float(sd_p * np.sqrt(ppy)) if np.isfinite(sd_p) else np.nan,\n", + " \"Sharpe\": float((ex.mean() / sd_p) * np.sqrt(ppy)) if (sd_p and sd_p > 0) else np.nan,\n", + " \"Max_Drawdown\": float(max_drawdown(nav)),\n", + " \"Obs\": int(rets.dropna().shape[0]),\n", + " }\n", + "\n", + "def strip_tz_index(obj):\n", + " \"\"\"Return a copy with tz removed from DatetimeIndex (works for Series/DataFrame).\"\"\"\n", + " out = obj.copy()\n", + " if isinstance(out.index, pd.DatetimeIndex) and out.index.tz is not None:\n", + " # Remove timezone (UTC→naive). tz_localize(None) drops tz; tz_convert(None) also works.\n", + " out.index = out.index.tz_localize(None)\n", + " return out\n", + "\n", + "# ------------------ LOAD DATA ------------------\n", + "weights_df = pd.read_csv(WEIGHTS_CSV)\n", + "px_all = pd.read_csv(PRICES_CSV, parse_dates=[\"Date\"]).set_index(\"Date\").sort_index()\n", + "px_all = strip_tz_index(px_all)\n", + "\n", + "# Align date window\n", + "if START_DATE:\n", + " px_all = px_all.loc[pd.Timestamp(START_DATE):]\n", + "if END_DATE:\n", + " px_all = px_all.loc[:pd.Timestamp(END_DATE)]\n", + "\n", + "# Portfolio weights (drop tickers not in price file, then renormalize)\n", + "w = (weights_df.set_index(\"Ticker\")[\"Weight\"]\n", + " .astype(float)\n", + " .loc[lambda s: s > 0])\n", + "\n", + "present = [tk for tk in w.index if tk in px_all.columns]\n", + "if set(present) != set(w.index):\n", + " missing = sorted(set(w.index) - set(present))\n", + " if missing:\n", + " print(f\"⚠️ Dropping {len(missing)} tickers not found in prices: {missing[:6]}{'...' if len(missing) > 6 else ''}\")\n", + "w = w.loc[present]\n", + "w = w / w.sum()\n", + "\n", + "# Subset prices to portfolio names\n", + "px_port = px_all[present].copy()\n", + "\n", + "# ------------------ PORTFOLIO RETURNS & NAV ------------------\n", + "asset_rets = to_returns(px_port, FREQ).dropna(how=\"all\")\n", + "# Ensure weight vector aligns to returns columns\n", + "w = w.reindex(asset_rets.columns).fillna(0.0)\n", + "port_rets = (asset_rets * w).sum(axis=1).dropna()\n", + "nav_port = (1.0 + port_rets).cumprod().rename(\"Portfolio_NAV\")\n", + "nav_port = strip_tz_index(nav_port)\n", + "\n", + "# ------------------ UNDERLYING (HG=F) ------------------\n", + "# If HG=F exists in px_all, use it; else fetch via yfinance over the same window\n", + "if UNDERLYING in px_all.columns:\n", + " px_under = px_all[[UNDERLYING]].copy()\n", + "else:\n", + " # Fetch with yfinance for the overlapping window\n", + " if not asset_rets.empty:\n", + " start = asset_rets.index.min() - pd.Timedelta(days=5)\n", + " end = asset_rets.index.max() + pd.Timedelta(days=5)\n", + " else:\n", + " start = None; end = None\n", + " raw = yf.Ticker(UNDERLYING).history(start=start, end=end, auto_adjust=False)\n", + " if raw.empty:\n", + " raise RuntimeError(f\"Could not fetch {UNDERLYING} from yfinance.\")\n", + " px_under = raw[[\"Close\"]].rename(columns={\"Close\": UNDERLYING})\n", + " px_under.index.name = \"Date\"\n", + "\n", + "px_under = px_under.sort_index()\n", + "px_under = strip_tz_index(px_under)\n", + "\n", + "if START_DATE:\n", + " px_under = px_under.loc[pd.Timestamp(START_DATE):]\n", + "if END_DATE:\n", + " px_under = px_under.loc[:pd.Timestamp(END_DATE)]\n", + "\n", + "under_rets = to_returns(px_under, FREQ)[UNDERLYING].dropna()\n", + "nav_under = (1.0 + under_rets).cumprod().rename(\"HG=F_NAV\")\n", + "nav_under = strip_tz_index(nav_under)\n", + "\n", + "# ------------------ ALIGN & METRICS ------------------\n", + "# Align NAVs to common dates for plotting/metrics (both tz-naive now)\n", + "nav_df = pd.concat([nav_port, nav_under], axis=1).dropna()\n", + "nav_df.to_csv(\"task2_equity_nav.csv\")\n", + "\n", + "PPY = periods_per_year(FREQ)\n", + "port_aligned_rets = nav_df[\"Portfolio_NAV\"].pct_change().dropna()\n", + "under_aligned_rets = nav_df[\"HG=F_NAV\"].pct_change().dropna()\n", + "\n", + "# Metrics for both (aligned window)\n", + "m_port = perf_summary(\"Portfolio\", nav_df[\"Portfolio_NAV\"], port_aligned_rets, PPY, RISK_FREE_ANNUAL)\n", + "m_under = perf_summary(\"HG=F\", nav_df[\"HG=F_NAV\"], under_aligned_rets, PPY, RISK_FREE_ANNUAL)\n", + "\n", + "metrics_df = pd.DataFrame([m_port, m_under])\n", + "metrics_df.to_csv(\"task2_equity_vs_HG_metrics.csv\", index=False, float_format=\"%.6f\")\n", + "\n", + "# ------------------ ROLLING SHARPE (portfolio) ------------------\n", + "roll_win = 126 if FREQ == \"D\" else 26\n", + "rf_period = RISK_FREE_ANNUAL / PPY\n", + "port_excess = port_aligned_rets - rf_period\n", + "rolling_sharpe = (port_excess.rolling(roll_win).mean() / port_aligned_rets.rolling(roll_win).std(ddof=1)) * np.sqrt(PPY)\n", + "rolling_sharpe.rename(\"Rolling_Sharpe\").to_csv(\"task2_equity_rolling_sharpe.csv\", header=True)\n", + "\n", + "# ------------------ PLOT ------------------\n", + "plt.figure(figsize=(10, 6))\n", + "nav_df.plot(ax=plt.gca()) # both NAV lines normalized to 1\n", + "plt.title(\"Equity Curve: Portfolio vs HG=F\")\n", + "plt.xlabel(\"Date\")\n", + "plt.ylabel(\"NAV (start = 1.0)\")\n", + "plt.legend(loc=\"best\")\n", + "plt.tight_layout()\n", + "plt.savefig(\"task2_equity_nav_vs_HG.png\", dpi=150)\n", + "plt.close()\n", + "\n", + "# ------------------ PRINT SUMMARY ------------------\n", + "print(\"\\n=== Performance (aligned window) ===\")\n", + "print(metrics_df.to_string(index=False))\n", + "\n", + "print(\"\\nSaved:\")\n", + "print(\" - task2_equity_nav_vs_HG.png\")\n", + "print(\" - task2_equity_vs_HG_metrics.csv\")\n", + "print(\" - task2_equity_nav.csv\")\n", + "print(\" - task2_equity_rolling_sharpe.csv\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "07ba9a96", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Comparison equity curve: IVPAF vs HG=F (Copper Futures)\n", + "# Requires: yfinance, pandas, matplotlib\n", + "# pip install yfinance pandas matplotlib\n", + "\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from datetime import datetime, date\n", + "import yfinance as yf\n", + "\n", + "START = \"2020-01-01\"\n", + "END = date.today().strftime(\"%Y-%m-%d\") # today's date\n", + "\n", + "tickers = [\"IVPAF\", \"HG=F\"]\n", + "\n", + "# Download Adj Close; auto_adjust=True gives adjusted prices\n", + "data = yf.download(\n", + " tickers=tickers,\n", + " start=START,\n", + " end=END,\n", + " auto_adjust=True,\n", + " progress=False\n", + ")[\"Close\"] # yfinance returns \"Close\" when auto_adjust=True\n", + "\n", + "# If a single column comes back (edge case), make it a DataFrame\n", + "if isinstance(data, pd.Series):\n", + " data = data.to_frame()\n", + "\n", + "# Align both series on the same calendar and fill short gaps (e.g., different holidays)\n", + "# Limit forward-fill to a few days to avoid smoothing long missing periods\n", + "aligned = (\n", + " data.reindex(pd.date_range(START, END, freq=\"D\"))\n", + " .ffill(limit=5)\n", + " .dropna(subset=[\"IVPAF\", \"HG=F\"], how=\"any\")\n", + ")\n", + "\n", + "# Normalize to 1.0 at the first common date\n", + "norm = aligned / aligned.iloc[0]\n", + "\n", + "# Plot (single axes, no specific colors/styles)\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(norm.index, norm[\"IVPAF\"], label=\"IVPAF (norm.)\")\n", + "plt.plot(norm.index, norm[\"HG=F\"], label=\"HG=F (Copper futures, norm.)\")\n", + "plt.title(\"Normalized Equity Curves: IVPAF vs HG=F (from 2020-01-01)\")\n", + "plt.xlabel(\"Date\")\n", + "plt.ylabel(\"Value (Start = 1.0)\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}