first commit

.gitignore

@@ -0,0 +1 @@
+.ipynb_checkpoints

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[theme]
+base="dark"

README.md

@@ -1,12 +1 @@
----
-title: CryptoTester
-emoji: 🐢
-colorFrom: purple
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.9.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
+This is the README file for the crypto port project.

aggrid_viewer.py

@@ -0,0 +1,238 @@
+import streamlit as st
+import plotly.express as px
+from datetime import date, timedelta
+from data_creator import create_market_cap_dict, gen_rebased_df, ids2names_dict, names2ids_dict, create_assets, gen_symbols, create_histories_df, create_unix_dates, create_returns_df, create_rebased_df, date_range
+from plot_creator import get_pre_selected_idx, write_coins, write_coins_custom, write_bespoke_coins, create_comparison_df, load_images, gen_performance_ag_df, add_drawdown
+from port_creator import gen_all_returns, markowitz_weights_dict, uniform_weights_dict, ids_with_histories, uniform, create_port_rtns, markowitz_weights, create_weights_df
+from risk_metrics import max_drawdown
+from st_aggrid import AgGrid, GridOptionsBuilder
+from persist import persist, load_widget_state
+
+load_widget_state()
+
+st.markdown(
+  """
+  <style>
+
+.css-1xsoh1l {
+    font-size: 0px;
+}
+.css-1xsoh1l{
+  color: rgb(120 190 33);
+}
+.css-jhf39w {
+  color: rgba(120, 190, 33, 1);
+}
+.css-jv3mmh {
+  background-color: rgb(120, 190, 33);
+}
+  </style>
+  """,
+  unsafe_allow_html = True
+)
+
+# load start and end dates for investment analysis
+lookback_years = 5 # max date range for backtest will be: lookback_years - 1
+start_date = date.today() - timedelta(365)
+end_date = date.today()
+
+if 'start_date' not in st.session_state:
+  st.session_state.start_date = start_date
+  st.session_state.end_date = end_date
+
+if 'max_coins' not in st.session_state:
+  st.session_state.max_coins = 10
+
+if 'start_id' not in st.session_state:
+  st.session_state.start_id = 1
+
+# Pull down histories from coincap, and create dataframes for historic prices,
+# returns and rebased cumulative price; histories_df, returns_df, and
+# rebased_df, respectively.
+assets_json = create_assets(total_coins=50)
+symbols, names, coin_ids = gen_symbols(assets_json)
+ids2symbols = ids2names_dict(coin_ids, symbols)
+ids2names_dict=ids2names_dict(coin_ids, names)
+names2ids_dict = names2ids_dict(names, coin_ids)
+market_cap_dict = create_market_cap_dict(assets_json)
+start_unix, end_unix = create_unix_dates(today=date.today(), lookback_years=lookback_years)
+histories_df = create_histories_df(coin_ids, start_unix, end_unix)
+
+# Create list of coin ids with full hisoties over the backtest period
+ids_with_histories = ids_with_histories(histories_df,
+  st.session_state.start_date, st.session_state.end_date)
+names_with_histories = list(map(ids2names_dict.get, ids_with_histories))
+
+
+def change_date_range():
+  st.session_state.start_date = st.session_state.myslider[0]
+  st.session_state.end_date = st.session_state.myslider[1]
+
+# calculate weghts for the uniform and markowitz pfs
+uniform_weights_dict = uniform_weights_dict(ids_with_histories[:st.session_state.max_coins])
+#markowitz_weights_dict = markowitz_weights_dict(histories_df,
+#  st.session_state.start_date ,ids_with_histories[:max_coins], analysis_days=365)
+strategy_dict = {'Uniform': uniform_weights_dict}#, 'Markowitz':markowitz_weights_dict}
+
+if "strategy_dict" not in st.session_state:
+  st.session_state.strategy_dict=strategy_dict
+
+if 'selected_assets' not in st.session_state:
+  st.session_state.selected_assets = ["Uniform"]
+
+with st.sidebar:
+  st.subheader("Portfolio weights viewer")
+  portfolio_type = st.selectbox(
+  'Select portfolio strategy',
+  ['Create your own'] + (list(st.session_state.strategy_dict.keys())),
+  index = st.session_state.start_id
+  )
+
+
+if st.checkbox("Explain this"):
+  st.subheader("What's this all about then, eh?")
+  st.write('''
+  The app allows you to construct your own portfolios of crypto currencies and view their
+  historic performance alongside the performance of individual crypto
+  currencies over an investment period of your choosing.
+
+  To view the assets and weights comprising a particular portfolio select the
+  portfolio of interest in the 'Select portfolio strategy' dropdown (a uniform
+  portfolio for the top ten largest coins has been automatically created for you
+  to start with).
+
+  To create your own portfolio:
+
+  1. Select 'Create your own' in the 'select portfolio strategy' dropdown;
+  2. Select the maximum number of coins in your portfolio;
+  3. Select the relative weights for each of these assets;
+  4. Choose a name for your portfolio and click add portfolio;
+  5. Click update viewer;
+
+  You can sort and filter the performance metrics table on each of the columns.
+
+  To add an asset to the performance chart, select the corresponding select box.
+  ''')
+
+# Add select slider to allow
+date_list = date_range(end_date,lookback_years-1)
+start_port_date, end_port_date = st.select_slider(
+     'Select backtest date range',
+     key="myslider",
+     options=date_list,
+     #value=(date.today() - timedelta(365), date.today()),
+     value = (st.session_state.start_date, st.session_state.end_date),
+     on_change=change_date_range
+     )
+
+
+# Move the definition of strategy_dict to about the potfolio_type selectbox
+# This will require that you define max_coins in session state,a dn the
+# have the max_coins number_input update the max coins session state.
+#  = 10 and let it be
+
+
+# calculate returns for the portfolios and add to it the  rebased df for assets
+# with hisories. This is the new returns_df
+rebased_df = gen_rebased_df(histories_df, ids_with_histories,
+  st.session_state.start_date, st.session_state.end_date)
+
+all_returns_df = gen_all_returns(rebased_df, ids_with_histories,st.session_state.strategy_dict)
+
+def write_something():
+  st.write("")
+
+def rerun_aggrid():
+  st.session_state.selected_indexes = selected_indexes
+  st.session_state.performance_ag_df = gen_performance_ag_df(all_returns_df, market_cap_dict,
+  st.session_state.strategy_dict)
+  st.header('ran')
+
+if portfolio_type == 'Create your own':
+  with st.sidebar:
+    st.session_state.max_coins = st.number_input(
+    "Maximum number of coins in portfolio",
+    min_value=1,
+    max_value=20,
+    value=10,
+    help='''
+    Coins will be added to your "investment set" in order of largest market cap.
+
+    The "investment set" is the group of assets from which your portfolio is
+    constructed. Depending on the portfolio strategy you choose, not all of the
+    assets in your investment set will be included in your portfolio.
+
+    '''
+    )
+    st.markdown("Bespoke portfolio weights (relative):" , unsafe_allow_html=False)
+    bespoke_weights = write_coins_custom(names_with_histories[:st.session_state.max_coins])
+    #bespoke_weights = write_bespoke_coins(names_with_histories[:st.session_state.max_coins])
+    bespoke_cols = st.columns(2)
+    bespoke_cols[0].write(" ")
+    bespoke_cols[0].write(" ")
+    add_bespoke = bespoke_cols[0].button("Add portfolio", key='bespoke_button')
+    bespoke_name = bespoke_cols[1].text_input("Choose portfolio name")
+    if add_bespoke:
+      if bespoke_name=="" or bespoke_name in all_returns_df.columns:
+        st.warning("Please give your portfolio a unique name")
+      else:
+        beskpoke_weights_dict={}
+        for i, wt in enumerate(bespoke_weights):
+          beskpoke_weights_dict[coin_ids[i]] = wt
+        st.session_state.strategy_dict[bespoke_name] = beskpoke_weights_dict
+        st.session_state.start_id = len(st.session_state.strategy_dict)
+        #st.session_state.selected_assets.append(bespoke_name)
+        st.success("Porfolio added, update viewer to see results")
+        #st.button('Update viewer', on_click = change_date_range)
+        st.button('Update viewer', on_click = rerun_aggrid)
+        #st.button('Update viewer', on_click = st.experimental_rerun())
+    #st.write(st.session_state.strategy_dict)
+else:
+  non_zero_coins = [key for key in st.session_state.strategy_dict[portfolio_type].keys() if st.session_state.strategy_dict[portfolio_type][key]>0]
+  with st.sidebar:
+    st.markdown(portfolio_type + " portfolio weights (%):" , unsafe_allow_html=False)
+    write_coins(non_zero_coins, st.session_state.strategy_dict[portfolio_type], ids2names_dict)
+
+st.session_state.performance_ag_df = gen_performance_ag_df(all_returns_df, market_cap_dict,
+  st.session_state.strategy_dict)
+
+if 'selected_assets' not in st.session_state:
+  st.session_state.selected_assets = ["Uniform"]
+
+selected_indexes = []
+for asset in st.session_state.selected_assets:
+  try:
+    selected_indexes.append(list(st.session_state.performance_ag_df['Asset']).index(asset))
+  except:
+    pass
+
+if 'selected_indexes' not in st.session_state:
+  st.session_state.selected_indexes = selected_indexes
+
+gb = GridOptionsBuilder.from_dataframe(st.session_state.performance_ag_df)
+gb.configure_selection('multiple', use_checkbox=True,
+  pre_selected_rows = st.session_state.selected_indexes)
+gridOptions = gb.build()
+
+st.subheader("Performance metrics")
+grid_response = AgGrid(st.session_state.performance_ag_df, gridOptions=gridOptions,
+  data_return_mode = 'FILTERED', allow_unsafe_jscode=True, height = 200,
+  update_mode='MODEL_CHANGED', key = persist("aggrid")) # MANUAL SELECTION_CHANGED MODEL_CHANGED, VALUE_CHANGED
+
+selected_assets = []
+for row in grid_response['selected_rows']:
+  selected_assets.append(row['Asset'])
+st.session_state.selected_assets = selected_assets
+
+
+
+#selected_indexes = []
+#for asset in st.session_state.selected_assets:
+#  selected_indexes.append(list(performance_ag_df['Asset']).index(asset))
+
+chart_df = create_comparison_df(all_returns_df, st.session_state.selected_assets)
+
+fig = px.line(chart_df, x=chart_df.index, y='Value (USD)', color='Asset')
+
+st.subheader("Performance chart")
+st.write(fig)

app.py

@@ -0,0 +1,14 @@
+import streamlit as st
+from streamlit_custom_slider import st_custom_slider
+from streamlit_custom_slider import st_range_slider
+
+v_custom = st_custom_slider('Hello world', 0, 100, 50, key="slider1")
+st.write(v_custom)
+
+# Add a range slider
+v_custom_range = st_range_slider('Hello world', 0, 100, (20, 60), key="slider2")
+st.write(v_custom_range)
+
+cols = st.columns(2)
+with cols[0]:
+  st_range_slider('Hello world', 0, 100, (20, 60), key="slider3")

cbpro.ipynb

@@ -0,0 +1,573 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "167330a4-9cfe-4e11-a3e5-9b788e710b07",
+   "metadata": {},
+   "source": [
+    "!conda activate cbpro"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d5b44fe7-a66c-4708-9d70-9df144e000bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d665ee3b-259c-4733-af10-d7dc4e91bbcd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cbpro"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b0d24761-fcca-4526-ad2c-4fadaaab3320",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting pandas\n",
+      "  Downloading pandas-1.4.2-cp39-cp39-macosx_10_9_x86_64.whl (11.1 MB)\n",
+      "\u001b[K     |████████████████████████████████| 11.1 MB 3.0 MB/s eta 0:00:01\n",
+      "\u001b[?25hRequirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/site-packages (from pandas) (2022.1)\n",
+      "Collecting numpy>=1.18.5\n",
+      "  Downloading numpy-1.22.3-cp39-cp39-macosx_10_14_x86_64.whl (17.6 MB)\n",
+      "\u001b[K     |████████████████████████████████| 17.6 MB 25.2 MB/s eta 0:00:01\n",
+      "\u001b[?25hRequirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.9/site-packages (from pandas) (2.8.2)\n",
+      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/site-packages (from python-dateutil>=2.8.1->pandas) (1.10.0)\n",
+      "Installing collected packages: numpy, pandas\n",
+      "Successfully installed numpy-1.22.3 pandas-1.4.2\n",
+      "\u001b[33mWARNING: You are using pip version 21.1.1; however, version 22.0.4 is available.\n",
+      "You should consider upgrading via the '/usr/local/opt/python@3.9/bin/python3.9 -m pip install --upgrade pip' command.\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "#!pip3 install pandas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6d1cec56-82d3-4915-b271-765bbe767bc2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>468</th>\n",
+       "      <th>469</th>\n",
+       "      <th>470</th>\n",
+       "      <th>471</th>\n",
+       "      <th>472</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>id</th>\n",
+       "      <td>XRP-BTC</td>\n",
+       "      <td>XRP-USD</td>\n",
+       "      <td>GNT-USDC</td>\n",
+       "      <td>XRP-GBP</td>\n",
+       "      <td>XRP-EUR</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>base_currency</th>\n",
+       "      <td>XRP</td>\n",
+       "      <td>XRP</td>\n",
+       "      <td>GNT</td>\n",
+       "      <td>XRP</td>\n",
+       "      <td>XRP</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>quote_currency</th>\n",
+       "      <td>BTC</td>\n",
+       "      <td>USD</td>\n",
+       "      <td>USDC</td>\n",
+       "      <td>GBP</td>\n",
+       "      <td>EUR</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>base_min_size</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>base_max_size</th>\n",
+       "      <td>500000</td>\n",
+       "      <td>500000</td>\n",
+       "      <td>490000</td>\n",
+       "      <td>500000</td>\n",
+       "      <td>500000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>quote_increment</th>\n",
+       "      <td>0.00000001</td>\n",
+       "      <td>0.0001</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>0.0001</td>\n",
+       "      <td>0.0001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>base_increment</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>0.000001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>display_name</th>\n",
+       "      <td>XRP/BTC</td>\n",
+       "      <td>XRP/USD</td>\n",
+       "      <td>GNT/USDC</td>\n",
+       "      <td>XRP/GBP</td>\n",
+       "      <td>XRP/EUR</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min_market_funds</th>\n",
+       "      <td>0.001</td>\n",
+       "      <td>10</td>\n",
+       "      <td>1</td>\n",
+       "      <td>10</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max_market_funds</th>\n",
+       "      <td>30</td>\n",
+       "      <td>100000</td>\n",
+       "      <td>200000</td>\n",
+       "      <td>100000</td>\n",
+       "      <td>100000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>margin_enabled</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>fx_stablecoin</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max_slippage_percentage</th>\n",
+       "      <td>0.10000000</td>\n",
+       "      <td>0.10000000</td>\n",
+       "      <td>0.03000000</td>\n",
+       "      <td>0.10000000</td>\n",
+       "      <td>0.10000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>post_only</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>limit_only</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>cancel_only</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>trading_disabled</th>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>status</th>\n",
+       "      <td>delisted</td>\n",
+       "      <td>delisted</td>\n",
+       "      <td>delisted</td>\n",
+       "      <td>delisted</td>\n",
+       "      <td>delisted</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>status_message</th>\n",
+       "      <td></td>\n",
+       "      <td></td>\n",
+       "      <td></td>\n",
+       "      <td></td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>auction_mode</th>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                468         469         470         471  \\\n",
+       "id                          XRP-BTC     XRP-USD    GNT-USDC     XRP-GBP   \n",
+       "base_currency                   XRP         XRP         GNT         XRP   \n",
+       "quote_currency                  BTC         USD        USDC         GBP   \n",
+       "base_min_size                     1           1           1           1   \n",
+       "base_max_size                500000      500000      490000      500000   \n",
+       "quote_increment          0.00000001      0.0001    0.000001      0.0001   \n",
+       "base_increment                    1    0.000001           1    0.000001   \n",
+       "display_name                XRP/BTC     XRP/USD    GNT/USDC     XRP/GBP   \n",
+       "min_market_funds              0.001          10           1          10   \n",
+       "max_market_funds                 30      100000      200000      100000   \n",
+       "margin_enabled                False       False       False       False   \n",
+       "fx_stablecoin                 False       False       False       False   \n",
+       "max_slippage_percentage  0.10000000  0.10000000  0.03000000  0.10000000   \n",
+       "post_only                     False       False       False       False   \n",
+       "limit_only                    False       False       False       False   \n",
+       "cancel_only                   False       False       False       False   \n",
+       "trading_disabled               True        True        True        True   \n",
+       "status                     delisted    delisted    delisted    delisted   \n",
+       "status_message                                                            \n",
+       "auction_mode                  False       False       False       False   \n",
+       "\n",
+       "                                472  \n",
+       "id                          XRP-EUR  \n",
+       "base_currency                   XRP  \n",
+       "quote_currency                  EUR  \n",
+       "base_min_size                     1  \n",
+       "base_max_size                500000  \n",
+       "quote_increment              0.0001  \n",
+       "base_increment             0.000001  \n",
+       "display_name                XRP/EUR  \n",
+       "min_market_funds                 10  \n",
+       "max_market_funds             100000  \n",
+       "margin_enabled                False  \n",
+       "fx_stablecoin                 False  \n",
+       "max_slippage_percentage  0.10000000  \n",
+       "post_only                     False  \n",
+       "limit_only                    False  \n",
+       "cancel_only                   False  \n",
+       "trading_disabled               True  \n",
+       "status                     delisted  \n",
+       "status_message                       \n",
+       "auction_mode                  False  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import cbpro\n",
+    "import pandas as pd\n",
+    "c = cbpro.PublicClient()\n",
+    "\n",
+    "data = pd.DataFrame(c.get_products())\n",
+    "data.tail().T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6092a61b-2f80-414a-87ae-8ca248a9ac82",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'bids': [['38240.18', '0.00193719', 1]],\n",
+       " 'asks': [['38242.79', '0.62685639', 2]],\n",
+       " 'sequence': 36891016647,\n",
+       " 'auction_mode': False,\n",
+       " 'auction': None}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "c.get_product_order_book('BTC-USD')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "5e076bd8-498a-4570-8682-2f890db06a4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "historical = pd.DataFrame(c.get_product_historic_rates(product_id='ETH-USD', granularity=3600*24))\n",
+    "historical.columns= [\"Date\",\"Open\",\"High\",\"Low\",\"Close\",\"Volume\"]\n",
+    "historical['Date'] = pd.to_datetime(historical['Date'], unit='s')\n",
+    "historical.set_index('Date', inplace=True)\n",
+    "historical.sort_values(by='Date', ascending=True, inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "bf77ca3a-93d9-48c0-b29e-3c5c7cf93f59",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(300, 5)"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "historical.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "561ea595-3858-40f3-9803-d6d07d114105",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Open</th>\n",
+       "      <th>High</th>\n",
+       "      <th>Low</th>\n",
+       "      <th>Close</th>\n",
+       "      <th>Volume</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2021-07-05</th>\n",
+       "      <td>2160.00</td>\n",
+       "      <td>2324.44</td>\n",
+       "      <td>2323.27</td>\n",
+       "      <td>2197.34</td>\n",
+       "      <td>156103.936222</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-07-06</th>\n",
+       "      <td>2195.02</td>\n",
+       "      <td>2350.00</td>\n",
+       "      <td>2197.34</td>\n",
+       "      <td>2321.84</td>\n",
+       "      <td>165693.467204</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-07-07</th>\n",
+       "      <td>2294.16</td>\n",
+       "      <td>2411.19</td>\n",
+       "      <td>2322.20</td>\n",
+       "      <td>2316.82</td>\n",
+       "      <td>159702.044084</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-07-08</th>\n",
+       "      <td>2084.00</td>\n",
+       "      <td>2325.46</td>\n",
+       "      <td>2317.64</td>\n",
+       "      <td>2116.95</td>\n",
+       "      <td>223830.003713</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-07-09</th>\n",
+       "      <td>2050.00</td>\n",
+       "      <td>2189.28</td>\n",
+       "      <td>2116.30</td>\n",
+       "      <td>2147.38</td>\n",
+       "      <td>190883.326179</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-04-26</th>\n",
+       "      <td>2766.77</td>\n",
+       "      <td>3038.60</td>\n",
+       "      <td>3007.24</td>\n",
+       "      <td>2809.26</td>\n",
+       "      <td>191167.431854</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-04-27</th>\n",
+       "      <td>2794.23</td>\n",
+       "      <td>2920.00</td>\n",
+       "      <td>2809.50</td>\n",
+       "      <td>2889.78</td>\n",
+       "      <td>172782.717618</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-04-28</th>\n",
+       "      <td>2853.83</td>\n",
+       "      <td>2980.36</td>\n",
+       "      <td>2889.78</td>\n",
+       "      <td>2935.91</td>\n",
+       "      <td>167061.012721</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-04-29</th>\n",
+       "      <td>2775.51</td>\n",
+       "      <td>2946.68</td>\n",
+       "      <td>2935.97</td>\n",
+       "      <td>2816.94</td>\n",
+       "      <td>204389.174778</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-04-30</th>\n",
+       "      <td>2768.64</td>\n",
+       "      <td>2842.08</td>\n",
+       "      <td>2816.77</td>\n",
+       "      <td>2791.04</td>\n",
+       "      <td>70115.714811</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>300 rows × 5 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "               Open     High      Low    Close         Volume\n",
+       "Date                                                         \n",
+       "2021-07-05  2160.00  2324.44  2323.27  2197.34  156103.936222\n",
+       "2021-07-06  2195.02  2350.00  2197.34  2321.84  165693.467204\n",
+       "2021-07-07  2294.16  2411.19  2322.20  2316.82  159702.044084\n",
+       "2021-07-08  2084.00  2325.46  2317.64  2116.95  223830.003713\n",
+       "2021-07-09  2050.00  2189.28  2116.30  2147.38  190883.326179\n",
+       "...             ...      ...      ...      ...            ...\n",
+       "2022-04-26  2766.77  3038.60  3007.24  2809.26  191167.431854\n",
+       "2022-04-27  2794.23  2920.00  2809.50  2889.78  172782.717618\n",
+       "2022-04-28  2853.83  2980.36  2889.78  2935.91  167061.012721\n",
+       "2022-04-29  2775.51  2946.68  2935.97  2816.94  204389.174778\n",
+       "2022-04-30  2768.64  2842.08  2816.77  2791.04   70115.714811\n",
+       "\n",
+       "[300 rows x 5 columns]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "historical"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c340ff84-d379-42e3-b791-e9076bcd439e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cryptoTester.py

@@ -0,0 +1,281 @@
+import streamlit as st
+import plotly.express as px
+from datetime import date, timedelta
+from data_creator import create_market_cap_dict, gen_rebased_df, ids2names_dict, names2ids_dict, create_assets, gen_symbols, create_histories_df, create_unix_dates, create_returns_df, create_rebased_df, date_range
+from plot_creator import write_coins, write_coins_custom, create_chart_df, load_images, gen_performance_df, add_drawdown
+from port_creator import gen_all_returns, markowitz_weights_dict, uniform_weights_dict, ids_with_histories, uniform, create_port_rtns, markowitz_weights, create_weights_df
+from risk_metrics import max_drawdown
+
+
+st.markdown(
+  """
+  <style>
+
+.css-1xsoh1l {
+    font-size: 0px;
+}
+.css-1xsoh1l{
+  color: rgb(120 190 33);
+}
+.css-jhf39w {
+  color: rgba(120, 190, 33, 1);
+}
+.css-jv3mmh {
+  background-color: rgb(120, 190, 33);
+}
+  </style>
+  """,
+  unsafe_allow_html = True
+)
+
+# load start and end dates for investment analysis
+lookback_years = 5 # max date range for backtest will be: lookback_years - 1
+start_date = date.today() - timedelta(365)
+end_date = date.today()
+
+if 'start_date' not in st.session_state:
+  st.session_state.start_date = start_date
+  st.session_state.end_date = end_date
+
+if 'max_coins' not in st.session_state:
+  st.session_state.max_coins = 8
+
+if 'start_id' not in st.session_state:
+  st.session_state.start_id = 1 # this is the id of the selected portfolio.
+
+# Pull down histories from coincap, and create dataframes for historic prices,
+# returns and rebased cumulative price; histories_df, returns_df, and
+# rebased_df, respectively.
+assets_json = create_assets(total_coins=50)
+symbols, names, coin_ids = gen_symbols(assets_json)
+ids2symbols = ids2names_dict(coin_ids, symbols)
+ids2names_dict=ids2names_dict(coin_ids, names)
+names2ids_dict = names2ids_dict(names, coin_ids)
+market_cap_dict = create_market_cap_dict(assets_json)
+start_unix, end_unix = create_unix_dates(today=date.today(), lookback_years=lookback_years)
+histories_df = create_histories_df(coin_ids, start_unix, end_unix)
+
+# Create list of coin ids with full hisoties over the backtest period
+ids_with_histories = ids_with_histories(histories_df,
+  st.session_state.start_date, st.session_state.end_date)
+names_with_histories = list(map(ids2names_dict.get, ids_with_histories))
+
+def change_date_range():
+  st.session_state.start_date = st.session_state.myslider[0]
+  st.session_state.end_date = st.session_state.myslider[1]
+
+st.write('''
+N.B. This app is in Beta, it will be buggy and some of the calculations may be
+  erroneous. **It is deeeeeefinitely not investment advice**.
+''', unsafe_allow_html = True)
+with st.expander("Explain this app 🤔"):
+  st.subheader("What's this all about then, eh?")
+  st.write('''
+
+  This app allows you to graph the historic performance of a portfolio of
+  your choosing against an individual coin of your choosing. You can
+  compare the historic performance of all available assets (portfolios and coins)
+  in the overview table at the bottom of the page.
+
+  The 'Portfolio vs coin' chart displays the historic performance of the selected
+  portfolio and coin for the selected date range, rebased to $1 at the start
+  date.
+
+  To switch focus between the selected portfolio and coin, use the radio buttons
+  above the graph. For the asset under focus the "maximum drawdown" is drawn
+  on the graph (this is the maximum loss the asset suffered over the selected
+  period). A high level view of the performance of the asset under focus is also
+  given inside the 'Asset performance' expander.
+
+  The 'Overview of performance section' sets out performance metrics for all of
+  the portfolios and coins over the selected investment period. The table can
+  be sorted based on the metric of interest.
+
+  There are two pre-defined portfolio construction strategies, but you can also
+  define your own allocation using the 'Create your own' option in the 'Select
+  portfolio strategy' dropdown box in the sidebar.
+
+  Pre-defined portfolios:
+  - Uniform - An equal propotion of your initial investment is allocated to each coin in the 'investment set' (i.e. the total number of coins available for investment).
+  - Markowitz - Your initial investment is allocated to each coin to achieve the portfolio with the highest sharpe ratio in the 365 day period prior to the investment start date. For some date ranges and investment sets, the optimiser used in the background of this app cannot find an optimal solution in which case the Markowitz weights will not be updated and you will see a warning at the top of the screen. I have used the default settings in the PyPortfolioOpt python package to construct this portfolio.
+
+  To select how many coins you would like in your investment set use the
+  'Maximum number of coins in portfolio' inside the 'Portfolio construction
+  settings' expander.
+
+  To adjust the date range for the portfolio backtest using the slider
+  widget.
+
+  To create your own portfolio:
+
+  1. Select 'Create your own' in the 'Select portfolio strategy' dropdown;
+  2. Select the maximum number of coins in your portfolio;
+  3. Select the relative weights for each of these assets;
+  4. Choose a name for your portfolio and click add portfolio;
+  5. Click the 'Update viewer' button.
+
+  The data for this app has been generated using the coincap api and is updated
+  every day to include the previous day's closing prices.
+
+  ''')
+
+# Add select slider to allow
+date_list = date_range(end_date,lookback_years-1)
+start_port_date, end_port_date = st.select_slider(
+     'Select date range (max 4 years)',
+     key="myslider",
+     options=date_list,
+     #value=(date.today() - timedelta(365), date.today()),
+     value = (st.session_state.start_date, st.session_state.end_date),
+     on_change=change_date_range
+     )
+
+with st.sidebar:
+  st.subheader("Select a coin and a portfolio to compare on the graph")
+  with st.expander("Portfolio construction settings", expanded = False):
+    st.session_state.max_coins = st.number_input(
+      "Maximum number of coins in portfolio",
+      min_value=1,
+      max_value=50,
+      value=8,
+      key='max_coin_selector',
+      help='''
+      Coins will be added to your "investment set" in order of largest market cap.
+
+      The "investment set" is the group of assets from which your portfolio is
+      constructed. Depending on the portfolio strategy you choose, not all of the
+      assets in your investment set will be included in your portfolio.
+
+      '''
+    )
+
+# calculate weghts for the uniform and markowitz pfs
+uniform_weights = uniform_weights_dict(ids_with_histories[:int(st.session_state.max_coins)])
+update_Markowitz = True
+try:
+  markowitz_weights = markowitz_weights_dict(histories_df,
+    st.session_state.start_date ,ids_with_histories[:int(st.session_state.max_coins)], analysis_days=365)
+except:
+  update_Markowitz = False
+  st.warning('Markowitz weights could not be updated for this date range')
+
+if 'strategy_dict' not in st.session_state:
+  st.session_state.strategy_dict = {'Uniform': uniform_weights, 'Markowitz':markowitz_weights}
+else:
+  st.session_state.strategy_dict['Uniform'] = uniform_weights
+  if update_Markowitz == True:
+    st.session_state.strategy_dict['Markowitz'] = markowitz_weights
+
+#if "strategy_dict" not in st.session_state:
+#  st.session_state.strategy_dict=strategy_dict
+
+with st.sidebar:
+  selected_coin = st.selectbox(
+  'Select coin',
+  names_with_histories
+  )
+  portfolio_type = st.selectbox(
+  'Select portfolio strategy',
+  ['Create your own'] + (list(st.session_state.strategy_dict.keys())),
+  index = st.session_state.start_id
+  )
+
+
+
+
+
+
+# calculate returns for the portfolios and add to it the  rebased df for assets
+# with hisories. This is the new returns_df
+rebased_df = gen_rebased_df(histories_df, ids_with_histories,
+  st.session_state.start_date, st.session_state.end_date)
+
+all_returns_df = gen_all_returns(rebased_df, ids_with_histories, st.session_state.strategy_dict)
+
+if portfolio_type != 'Create your own':
+  st.session_state.portfolio_type = portfolio_type
+
+st.subheader("Portfolio vs coin")
+focus=st.radio("Focus on",("Portfolio 📉","Coin 📈"))
+
+chart_df = create_chart_df(all_returns_df, st.session_state.portfolio_type, names2ids_dict[selected_coin])
+
+fig = px.line(chart_df, x=chart_df.index, y='Value (USD)', color='Asset')
+if focus == "Portfolio 📉":
+  fig, port_dd, port_dd_start, port_dd_end = add_drawdown(fig, all_returns_df, st.session_state.portfolio_type)
+else:
+  fig, coin_dd, coin_dd_start, coin_dd_end = add_drawdown(fig, all_returns_df, names2ids_dict[selected_coin])
+
+st.write(fig)
+
+with st.expander("Asset performance"):
+  if focus == "Portfolio 📉":
+    st.subheader("{} portfolio performance".format(st.session_state.portfolio_type))
+
+    cols = st.columns([1,3])
+    outlay = cols[0].number_input('Initial $ amount', min_value=0, value=1000,
+      step=1)
+    final_amount = outlay*all_returns_df[st.session_state.portfolio_type][-1]
+    max_loss=outlay*port_dd
+
+    with cols[1]:
+      st.markdown('''For an initial investment of **${:,}**'''.format(int(outlay)), unsafe_allow_html = True)
+      st.markdown('''You would have ended up with **${:,}**'''.format(int(final_amount)), unsafe_allow_html = True)
+      st.markdown('''You would have suffered a maximum loss of **{:.0f}%** of your portfolio value
+      between **{}** and **{}**'''.format(port_dd*100, port_dd_start, port_dd_end), unsafe_allow_html = True)
+  else:
+    st.subheader("{} coin performance".format(selected_coin))
+
+    cols = st.columns([1,3])
+    outlay = cols[0].number_input('Initial $ amount', min_value=0, value=1000,
+      step=1)
+    final_amount = outlay*all_returns_df[names2ids_dict[selected_coin]][-1]
+    max_loss=outlay*coin_dd
+
+    with cols[1]:
+      st.markdown('''For an initial investment of **${:,}**'''.format(int(outlay)), unsafe_allow_html = True)
+      st.markdown('''You would have ended up with **${:,}**'''.format(int(final_amount)), unsafe_allow_html = True)
+      st.markdown('''You would have suffered a maximum loss of **{:.0f}%** of your investment value
+      between **{}** and **{}**'''.format(coin_dd*100, coin_dd_start, coin_dd_end), unsafe_allow_html = True)
+
+non_zero_coins = [key for key in st.session_state.strategy_dict[st.session_state.portfolio_type].keys() if st.session_state.strategy_dict[st.session_state.portfolio_type][key]>0]
+
+with st.sidebar:
+  if portfolio_type == 'Create your own':
+    st.markdown("Bespoke portfolio weights (relative):" , unsafe_allow_html=False)
+    bespoke_weights = write_coins_custom(names_with_histories[:int(st.session_state.max_coins)])
+    #bespoke_weights = write_bespoke_coins(names_with_histories[:st.session_state.max_coins])
+    bespoke_cols = st.columns(2)
+    bespoke_cols[0].write(" ")
+    bespoke_cols[0].write(" ")
+    add_bespoke = bespoke_cols[0].button("Add portfolio", key='bespoke_button')
+    bespoke_name = bespoke_cols[1].text_input("Choose portfolio name")
+    if add_bespoke:
+      if bespoke_name=="" or bespoke_name in all_returns_df.columns:
+        st.warning("Please give your portfolio a unique name")
+      else:
+        beskpoke_weights_dict={}
+        for i, wt in enumerate(bespoke_weights):
+          beskpoke_weights_dict[coin_ids[i]] = wt
+        st.session_state.strategy_dict[bespoke_name] = beskpoke_weights_dict
+        st.session_state.start_id = len(st.session_state.strategy_dict)
+        #st.session_state.selected_assets.append(bespoke_name)
+        st.success("Porfolio added, update viewer to see results")
+        st.button('Update viewer', on_click = change_date_range)
+        #st.button('Update viewer', on_click = change_date_range)
+  else:
+    st.markdown(st.session_state.portfolio_type + " portfolio weights (%):" , unsafe_allow_html=False)
+    write_coins(non_zero_coins, st.session_state.strategy_dict[st.session_state.portfolio_type], ids2names_dict)
+
+performance_df = gen_performance_df(all_returns_df, market_cap_dict, st.session_state.strategy_dict)
+
+
+st.subheader("Overview of performance of all available assets")
+st.dataframe(performance_df.style.background_gradient(cmap='Greens',
+  subset=['Risk / return', 'Total return %'])
+  .background_gradient(cmap='Reds',
+  subset=['Annual vol', 'Max loss %']).format("{:,.2f}",
+  subset=['Risk / return', 'Total return %', 'Annual vol',
+  'Max loss %']).format("{:,.0f}", subset=['Market cap $M']))
+
+

crypto_viewer.py

@@ -0,0 +1,314 @@
+import streamlit as st
+import requests
+import json
+import plotly.express as px
+import pandas as pd
+import datetime as dt
+from risk_metrics import annual_return, absolute_return, annual_vol, max_drawdown
+try:
+    from PIL import Image
+except ImportError:
+    import Image
+import numpy as np
+
+st.markdown(
+  """
+  <style>
+
+.css-1inwz65 {
+    font-size: 0px;
+}
+  </style>
+  """,
+  unsafe_allow_html = True
+)
+
+def load_data(limit='10'):
+  '''
+  Returns a dictionary with data for each of the top 'limit' cypto currencies
+  ranked by market cap. The data is generated by querying the coincap API
+  /assets endpoint. See coincap documentation for more info:
+  https://docs.coincap.io/
+
+  Parameters:
+    limit (str): The number of crypto coins that you want to return data for.
+      Ranked in order of market cap.
+
+  Returns:
+    (dict): A dictionary object of data.
+
+  '''
+  url = "https://api.coincap.io/v2/assets"
+  # N.B. here adampt the params dict to only request what you need
+  payload={'limit': limit}
+  headers = {}
+  return requests.request("GET", url, params=payload, headers=headers).json()
+
+def load_histories(ids_list):
+  url = "http://api.coincap.io/v2/assets/{}/history?interval=d1"
+
+  payload={}
+  headers = {}
+
+  histories_dict = {}
+  for id in ids_list:
+      response_histories = requests.request("GET", url.format(id), headers=headers, data=payload)
+      histories_json = response_histories.json()
+      histories_dict[id] = histories_json['data']
+  return histories_dict
+
+
+def gen_symbols(assets_json):
+  symbols_list = []
+  names_list = []
+  ids_list =[]
+  for dict in assets_json['data']:
+    symbols_list.append(dict['symbol'])
+    names_list.append(dict['name'])
+    ids_list.append(dict['id'])
+  return symbols_list, names_list, ids_list
+
+def write_symbols(symbols_list):
+    cols = st.columns(len(symbols_list))
+    for i, symbol in enumerate(symbols_list):
+      col = cols[i]
+      col.image(f'logos/{symbol}.png',width=40)
+      globals()[st.session_state.names[i]] = col.checkbox(symbol, value = 0)
+      #col.checkbox(symbol, st.image(f'logos/{symbol}.png',width=40))
+
+if "assets_json" not in st.session_state:
+  st.session_state.assets_json = load_data()
+  symbols, names, ids = gen_symbols(st.session_state.assets_json)
+  st.session_state.symbols = symbols
+  st.session_state.names = names
+  st.session_state.ids = ids
+  st.session_state.histories = load_histories(ids)
+  id_symbol_map = {}
+  for i, id in enumerate(ids):
+    id_symbol_map[id]=symbols[i]
+  st.session_state.id_symbol_map = id_symbol_map
+
+
+
+#write_symbols(st.session_state.symbols)
+symbols_list = st.session_state.symbols
+names_list = st.session_state.names
+ids_list = st.session_state.ids
+asset_json = st.session_state.assets_json
+histories_dict = st.session_state.histories
+id_symbol_map = st.session_state.id_symbol_map
+
+def date_conv(date):
+    return dt.datetime.strptime(date, '%Y-%m-%d')
+price_histories_df = pd.DataFrame(columns=['coin','date','price'])
+return_histories_df = pd.DataFrame(columns=['coin','date','price'])
+for id in ids_list:
+    price=[]
+    date=[]
+    for observation in histories_dict[id]:
+        date.append(date_conv(observation['date'][0:10]))
+        #date.append(observation['time'])
+        price.append(float(observation['priceUsd']))
+    price_df = pd.DataFrame({"coin": id, "date":date, "price": price})
+    price_histories_df = pd.concat([price_histories_df, price_df])
+    returns = [float(b) / float(a) for b,a in zip(price[1:], price[:-1])]
+    returns_df = pd.DataFrame({"coin": id, "date":date[1:], "price": returns})
+    return_histories_df = pd.concat([return_histories_df, returns_df])
+
+
+
+start_date = dt.date.today()-dt.timedelta(360)
+rebased_prices_df = pd.DataFrame(columns=['coin','date','price','rebased_price'])
+for id in ids_list:
+    temp_rebase_df = return_histories_df[(return_histories_df['date']>=pd.Timestamp(start_date))
+                                         & (return_histories_df['coin']==id)]
+    rebased_price=[1]
+    for i in range(1,len(temp_rebase_df)):
+        rebased_price.append(temp_rebase_df['price'].iloc[i]*rebased_price[i-1])
+    temp_rebase_df['rebased_price']=rebased_price
+    rebased_prices_df = pd.concat([rebased_prices_df, temp_rebase_df])
+
+fig2 = px.line(rebased_prices_df, x="date", y="rebased_price", color="coin")
+st.write(fig2)
+cols = st.columns(len(symbols_list))
+checkboxes=[]
+
+def write_coins(id_symbol_map, n_cols=5):
+  n_coins = len(id_symbol_map)
+  n_rows = 1 + n_coins // int(n_cols)
+
+  rows = [st.container() for _ in range(n_rows)]
+  cols_per_row = [r.columns(n_cols) for r in rows]
+  cols = [column for row in cols_per_row for column in row]
+
+  #cols = st.columns(n_coins)
+  #checkboxes=[]
+  for i, id in enumerate(id_symbol_map):
+    cols[i].image('logos/{}.png'.format(id_symbol_map[id]),width=40)
+    globals()[st.session_state.names[i]] = cols[i].checkbox("include", value = 1, key=id)
+    globals()["slider_"+ids_list[i]] = cols[i].slider(id, min_value=0, max_value=100, value=50, key=id)
+    checkboxes.append(globals()[st.session_state.names[i]])
+
+write_coins(id_symbol_map)
+
+
+
+#for i, symbol in enumerate(symbols_list):
+#  col = cols[i]
+#  col.image(f'logos/{symbol}.png',width=40)
+#  globals()[st.session_state.names[i]] = col.checkbox(symbol, value = 1)
+#  checkboxes.append(globals()[st.session_state.names[i]])
+
+
+
+
+
+
+#if any(checkboxes):
+#  checked_ids=[]
+#  cols2 = st.columns(sum(checkboxes))
+#  j=0
+#  for i, value in enumerate(checkboxes):
+#    if value==1:
+#      checked_ids.append(ids_list[i])
+#      col2=cols2[j]
+#      col2.image(f'logos/{symbols_list[i]}.png',width=20)
+#      j+=1
+
+def create_grid(top_left, bottom_right):
+    num_rows=3
+    num_cols=7
+    col_positions = np.linspace(top_left[0], bottom_right[0], num=num_cols)
+    row_positions = np.linspace(top_left[1], bottom_right[1], num=num_rows)
+    return [(int(col_positions[i]),int(row_positions[j])) for j in range(num_rows) for  i in range(num_cols)]
+
+# These are the coordinates of the top left and bottom right of the cart image
+# given it's curent size. You need to change these if you change the size of the
+# cart
+top_left=[300,300]
+bottom_right=[650, 450]
+
+grid = create_grid(top_left, bottom_right)
+
+def add_logo(background, symbol, position, size=(70,70)):
+    bg = Image.open(background)
+    fg = Image.open("logos/{}.png".format(symbol))
+
+    bg = bg.convert("RGBA")
+    fg = fg.convert("RGBA")
+
+    # Resize logo
+    fg_resized = fg.resize(size)
+
+    # Overlay logo onto background at position
+    bg.paste(fg_resized,box=position,mask=fg_resized)
+
+    # Save result
+    bg.save(background)
+
+
+
+cart_cols = st.columns([3,2])
+
+
+
+if any(checkboxes):
+  checked_ids=[]
+  for i, value in enumerate(checkboxes):
+    if value==1:
+      checked_ids.append(ids_list[i])
+      #cart_cols[1].image(f'logos/{symbols_list[i]}.png',width=20)
+      #cart_cols[2].slider(ids_list[i],min_value=0, max_value=100, value=50)
+
+
+# change the below to make it run only if checked_ids ecists - i.e. wrap it up oin a function
+original = Image.open("images/cart.png")
+original.save('images/background.png')
+position_ids = [round(x) for x in np.linspace(0, len(grid)-1, num=len(checked_ids))]
+for i, id in enumerate(checked_ids):
+  size = tuple([int(num * globals()["slider_"+id]/50)  for num in (70,70)])
+
+  add_logo('images/background.png', id_symbol_map[id], grid[position_ids[i]], size=size)
+
+weights=[]
+for id in checked_ids:
+  weights.append(globals()["slider_"+id])
+sum_weights = sum(weights)
+weights = [weight/sum_weights for weight in weights]
+
+weights_df = pd.DataFrame({'ids':checked_ids, 'weights': weights, 'portfolio': 'port_1'})
+pie_fig = px.pie(weights_df, values='weights', names='ids')
+pie_fig.update_layout(showlegend=False)
+
+bar_fig = px.bar(weights_df, x="portfolio", y="weights", color="ids", width=200)
+bar_fig.update_layout(showlegend=False)
+
+cart_cols[0].image('images/background.png', width=400)
+cart_cols[1].write(bar_fig)
+gen_port = st.button('Generate portfolio return')
+
+metrics_dict= {'annual_return' : "Return (annualised)", 'absolute_return': "Return over period",
+ 'annual_vol': 'Annual volatility', 'max_drawdown': 'Max loss'}
+
+def write_metrics(prices, *metrics):
+  for metric in metrics:
+    cols = st.columns(2)
+    if metric.__name__ == 'max_drawdown':
+      cols[0].write(metrics_dict[metric.__name__] +': ')
+      cols[1].write('{:.2%}'.format(metric(prices)[0]))
+    else:
+      cols[0].write(metrics_dict[metric.__name__] +': ')
+      cols[1].write('{:.2%}'.format(metric(prices)))
+
+if gen_port:
+  # adjust weight calculation to read in from globals()["slider_"+ids_list[i]]
+  #weights = [1/len(checked_ids)]*len(checked_ids)
+  portfolio_dict={checked_ids[i]:weights[i] for i in range(len(checked_ids))}
+  start_date = dt.date.today()-dt.timedelta(360)
+  weighted_prices_df = pd.DataFrame(columns=['coin','date','price','weighted_price'])
+  for id in checked_ids:
+    temp_weight_df = return_histories_df[(return_histories_df['date']>=pd.Timestamp(start_date))
+                                        & (return_histories_df['coin']==id)]
+    weighted_price=[portfolio_dict[id]]
+    for i in range(1,len(temp_weight_df)):
+      weighted_price.append(temp_weight_df['price'].iloc[i]*weighted_price[i-1])
+    temp_weight_df['weighted_price']=weighted_price
+    weighted_prices_df = pd.concat([weighted_prices_df, temp_weight_df])
+  date_list = [start_date + dt.timedelta(days=x) for x in range(360)]
+  port_returns=[]
+  for date in date_list:
+    port_returns.append(weighted_prices_df['weighted_price'][weighted_prices_df['date']==pd.Timestamp(date)].sum())
+  port_returns_df = pd.DataFrame({'date':date_list, 'price': port_returns})
+  prices = port_returns_df['price']
+  max_dd, start_idx, end_idx = max_drawdown(prices)
+  start_dt = port_returns_df['date'].iloc[start_idx]
+  end_dt = port_returns_df['date'].iloc[end_idx]
+  fig3 = px.line(port_returns_df, x="date", y="price")
+  fig3.add_vline(x=start_dt, line_width=1, line_color="red")
+  fig3.add_vline(x=end_dt, line_width=1, line_color="red")
+  fig3.add_vrect(x0=start_dt, x1=end_dt, line_width=0, fillcolor="red", opacity=0.05, annotation_text="max loss ")
+  st.write(fig3)
+
+  st.title("Risk metrics")
+  write_metrics(prices, absolute_return, annual_return, annual_vol, max_drawdown)
+
+
+
+
+
+  #for i, symbol in enumerate(symbols_list):
+  #  col2 = cols2[i]
+  #  col.image(f'logos/{symbol}.png',width=40)
+  #price_subset_df = price_histories_df[price_histories_df['coin'].isin(checked_ids)]
+  #rebased_subset_df = rebased_prices_df[rebased_prices_df['coin'].isin(checked_ids)]
+  #fig1 = px.line(price_subset_df, x="date", y="price", color="coin")
+  #st.write(fig1)
+  #fig2 = px.line(rebased_subset_df, x="date", y="rebased_price", color="coin")
+  #st.write(fig2)
+
+
+
+
+
+
+

data_creator.py

@@ -0,0 +1,150 @@
+import requests
+from datetime import date, timedelta, datetime
+import time
+import pandas as pd
+from os.path import exists
+import streamlit as st
+
+@st.cache(persist=True)
+def create_assets(total_coins=50):
+  '''
+  A function to retrieve info about the largest total_coins number of
+  cryptocurrencies, ranked by market cap, generated by a call to coincap assets
+  api.
+  '''
+  url = "https://api.coincap.io/v2/assets"
+
+  # N.B. here adampt the params dict to only request what you need
+  payload={'limit': total_coins}
+  headers = {}
+
+  assets_json = requests.request("GET", url, params=payload, headers=headers).json()
+  return assets_json
+
+@st.cache(persist=True)
+def gen_symbols(assets_json):
+  '''
+  Function to generate three lists: symbols, names and ids, from the result of
+  a call to the coincap assets api, assets_json.
+  '''
+  symbols_list = []
+  names_list = []
+  ids_list =[]
+  for dict in assets_json['data']:
+    symbols_list.append(dict['symbol'])
+    names_list.append(dict['name'])
+    ids_list.append(dict['id'])
+  return symbols_list, names_list, ids_list
+
+@st.cache(persist=True, show_spinner=False)
+def create_market_cap_dict(assets_json):
+  market_cap_dict = {}
+  for asset_dict in assets_json['data']:
+    market_cap_dict[asset_dict['id']] = int(float(asset_dict['marketCapUsd']))
+  return market_cap_dict
+
+def load_histories(coin_ids, start, end):
+  '''
+  Function to load daily historic prices for all crypto currencies in the
+  coin_ids list within the time period defined by the interval [start, end].
+  '''
+  url = "http://api.coincap.io/v2/assets/{}/history"
+
+  payload={'interval':'d1', 'start':start, 'end':end}
+  headers = {}
+
+  histories_dict = {}
+  for id in coin_ids:
+    response_histories = requests.request("GET", url.format(id), headers=headers, params=payload)
+    histories_json = response_histories.json()
+    histories_dict[id] = histories_json['data']
+  return histories_dict
+
+@st.cache(persist=True, show_spinner=False)
+def date_conv(date):
+  '''
+  Function to convert string to datetime.date.
+  '''
+  return datetime.strptime(date, '%Y-%m-%d').date()
+
+@st.cache(persist=True)
+def create_unix_dates(today=date.today(), lookback_years = 5):
+  '''
+  A function to create start_unix and end_unix times in UNIX time in milliseconds
+  '''
+  start_datetime = today-timedelta(365*lookback_years)
+  start_unix = int(time.mktime(start_datetime.timetuple()) * 1000)
+  end_unix = int(time.mktime(date.today().timetuple()) * 1000)
+  return start_unix, end_unix
+
+@st.cache(persist=True, show_spinner=False)
+def create_histories_df(coin_ids, start_unix, end_unix):
+  '''
+  A function to create a dataframe of historical prices for all of the
+  crypto currencies in the coin_ids=ids list, over a period defined by the
+  interval [start_unix, end_unix].
+  N.B. This code uses the data for bitcoin as the first dataframe on which
+  other temp_df are outer joined from the right. This is because bitcoin
+  has the longest history.
+  '''
+  print('Downloading data from coincap.io, may take several minutes...')
+
+  # download histories from coincap.io
+  with st.spinner("You're the first user today so asset histories are being updated. May take several minutes."):
+    histories_dict = load_histories(coin_ids, start_unix, end_unix)
+
+  # convert all dates in histories_dict to python datetime.date objects and remove 'time' key
+  for id in coin_ids:
+    for dict in histories_dict[id]:
+      dict.pop('time')
+      dict['priceUsd']=float(dict['priceUsd'])
+      dict['date'] = date_conv(dict['date'][0:10])
+
+  # convert histories_dict to pd.DataFrame
+  histories_df = pd.json_normalize(histories_dict['bitcoin'])
+  histories_df = histories_df.set_index('date', drop=True)
+  for id in [x for x in coin_ids if x != "bitcoin"]:
+    temp_df = pd.json_normalize(histories_dict[id])
+    temp_df = temp_df.set_index('date', drop=True)
+    histories_df = histories_df.merge(temp_df, how='outer',  left_index=True, right_index=True)
+
+  histories_df.columns = coin_ids
+  return histories_df
+
+# N.B. allow_output_mutation set to True because in create_rebased_df I am
+# deliberately chaning the value returns_df[start_date:start_date] to 0
+# however I want the cahced value to remain unchanged so that if I rebase to a
+# different start_date we go back to the orrignal returns_df.
+@st.cache(persist=True, show_spinner=False, allow_output_mutation=True)
+def create_returns_df(histories_df):
+  return histories_df.pct_change(1)
+
+@st.cache(persist=True, show_spinner=False)
+def create_rebased_df(returns_df, start_date, end_date):
+  returns_df[start_date:start_date]=0
+  return (1 + returns_df[start_date:end_date]).cumprod()
+
+@st.cache(persist=True, show_spinner=False)
+def date_range(end_date, lookback_years):
+  return [end_date - timedelta(x) for x in range(365 * lookback_years)][::-1]
+
+@st.cache(persist=True, show_spinner=False)
+def ids2names_dict(coin_ids, names):
+  ids2names_dict={}
+  for i, id in enumerate(coin_ids):
+    ids2names_dict[id] = names[i]
+  return ids2names_dict
+
+@st.cache(persist=True, show_spinner=False)
+def names2ids_dict(names, coin_ids):
+  names2ids_dict={}
+  for i, name in enumerate(names):
+    names2ids_dict[name] = coin_ids[i]
+  return names2ids_dict
+
+@st.cache(persist=True, show_spinner=False)
+def gen_rebased_df(histories_df, ids_with_histories, start_date, end_date):
+  returns_df = histories_df[ids_with_histories].pct_change(1)
+  returns_df[start_date:start_date]=0
+  return (1 + returns_df[start_date:end_date]).cumprod()
+

frontpage.py

@@ -0,0 +1,211 @@
+
+
+#-------------------
+# Imports
+#-------------------
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objs as go
+import plotly.io as pio
+from bs4 import BeautifulSoup
+import requests
+from datetime import datetime
+
+# today's date
+today = datetime.today().strftime('%d %B %Y')
+
+st.set_page_config(layout="wide")
+
+
+#-------------------
+# Web scraping Yahoo Finance
+#-------------------
+dic = {}
+url = 'https://finance.yahoo.com/cryptocurrencies?offset=0&count=100'
+soup = BeautifulSoup(requests.get(url).text)
+
+# store values in separate lists and then in a dictionary
+for listing in soup.find_all('div', attrs={'id':'fin-scr-res-table'}):
+    symbol_list = []
+    name_list = []
+    price_list = []
+    change_list = []
+    mcap_list = []
+for symbol in listing.find_all('td', attrs={'aria-label':'Symbol'}):
+    symbol_list.append(symbol.text)
+    dic['Symbol'] = symbol_list
+for name in listing.find_all('td', attrs={'aria-label':'Name'}):
+    name_list.append(name.text)
+    dic['Name'] = name_list
+for price in listing.find_all('td', attrs={'aria-label':'Price (Intraday)'}):
+    price_list.append(price.text)
+    dic['Price'] = price_list
+for change in listing.find_all('td', attrs={'aria-label':'% Change'}):
+    change_list.append(change.text)
+    dic['% Change'] = change_list
+for mcap in listing.find_all('td', attrs={'aria-label':'Market Cap'}):
+    mcap_list.append(mcap.text)
+    dic['Market Cap'] = mcap_list
+
+# create a dataframe from dictionary
+df_scrape = pd.DataFrame(dic)
+df_scrape.Symbol = df_scrape.Symbol.str.replace('-USD','')
+df_scrape.Name = df_scrape.Name.str.replace(' USD','')
+dic1 = dict(zip(df_scrape.Symbol,df_scrape.Name))
+
+
+#-------------------
+# Streamlit Sidebar
+#-------------------
+fiat = ['USD','EUR','GBP']
+tokens = df_scrape.Symbol.values
+
+# filters selectbox
+st.sidebar.title("Filters")
+select_token = st.sidebar.selectbox('Tokens', tokens)
+select_fiat = st.sidebar.selectbox('Fiat', fiat)
+
+# special expander objects
+st.sidebar.markdown('***')
+with st.sidebar.expander('Help'):
+    st.markdown('''
+                    - Select token and fiat of your choice.
+                    - Interactive plots can be zoomed or hovered to retrieve more info.
+                    - Plots can be downloaded using Plotly tools.''')
+
+with st.sidebar.expander('Sources'):
+    st.markdown('''
+    - Python Libraries: yfinance, BeautifulSoup, Plotly, Pandas, Streamlit
+    - Prices: https://finance.yahoo.com
+    - Logos: https://cryptologos.cc/
+    ''')
+
+
+st.write("Dashboard adapted from https://github.com/rohithteja/the-crypto-dashboard")
+#-------------------
+# Add crypto logo and name
+#-------------------
+col1, col2 = st.columns([1,10])
+with col1:
+    try:
+        st.image(f'logos/{select_token}.png',width=70)
+    except:
+        pass
+with col2:
+    st.markdown(f'''## {dic1[select_token]}''')
+
+
+#-------------------
+# Candlestick chart with moving averages
+#-------------------
+st.markdown('''
+- The following is an interactive Candlestick chart for the price fluctuations over the past 5 years.
+- Simple moving averages were computed for 20, 50 and 100 day frequencies.
+- Aids in trading strategy and to better interpret the price fluctuations.''')
+
+# download 5 year crypto prices from Yahoo Finance
+df = yf.download(tickers=f'{select_token}-{select_fiat}', period = '5y', interval = '1d')
+
+# compute moving averages
+df['MA100'] = df.Close.rolling(100).mean()
+df['MA50'] = df.Close.rolling(50).mean()
+df['MA20'] = df.Close.rolling(20).mean()
+
+# Plotly candlestick chart
+fig = go.Figure(data=
+                [go.Candlestick(x=df.index,
+                                open=df.Open,
+                                high=df.High,
+                                low=df.Low,
+                                close=df.Close,
+                                name=f'{select_token}'),
+                go.Scatter(x=df.index, y=df.MA20,
+                            line=dict(color='yellow',width=1),name='MA20'),
+                go.Scatter(x=df.index, y=df.MA50,
+                            line=dict(color='green',width=1),name='MA50'),
+                go.Scatter(x=df.index, y=df.MA100,
+                            line=dict(color='red',width=1),name='MA100')])
+
+fig.update_layout(go.Layout(xaxis = {'showgrid': False},
+                  yaxis = {'showgrid': False}),
+                  title=f'{dic1[select_token]} Price Fluctuation with Moving Averages',
+                    yaxis_title=f'Price ({select_fiat})',
+                    xaxis_rangeslider_visible=False)
+
+st.plotly_chart(fig, use_container_width=True)
+
+#-------------------
+# Line Chart with daily trends
+#-------------------
+st.markdown('## Daily Trends')
+st.markdown(f'''
+- Line graph below shows the price fluctuation of {dic1[select_token]} every minute for today's date ({today}).
+- The data is automatically updated for the current day.
+- The horizontal line shows the current day's open price.
+- Green portion indicates the price greater than open price and red for lower.
+''')
+
+# download daily crypto prices from Yahoo Finance
+df = yf.download(tickers=f'{select_token}-{select_fiat}', period = '1d', interval = '1m')
+
+# Plotly line chart
+fig = go.Figure()
+fig.add_scattergl(x=df.index, y=df.Close,
+                  line={'color': 'green'},name='Up trend')
+fig.add_scattergl(x=df.index, y=df.Close.where(df.Close <= df.Open[0]),
+                  line={'color': 'red'},name='Down trend')
+fig.add_hline(y=df.Open[0])
+fig.update_layout(go.Layout(xaxis = {'showgrid': False},
+                  yaxis = {'showgrid': False}),
+                  title=f'{dic1[select_token]} Daily Trends in Comparison to Open Price',
+                    yaxis_title=f'Price ({select_fiat})',template='plotly_dark',
+                    xaxis_rangeslider_visible=False)
+st.plotly_chart(fig, use_container_width=True)
+
+#-------------------
+# Table showing top 25 cryptos
+#-------------------
+st.markdown('## Top 25 Cryptocurrency Prices and Stats')
+st.markdown('''
+- Realtime price changes (in USD).
+- Values updated every few minutes.
+- Colour coded column indicates the increase or decrease in price.
+''')
+
+# create table from webscraped data
+df_scrape = df_scrape.rename(columns={'Symbol':'Token'})
+df_scrape['% Change'] = df_scrape['% Change'].str.replace('%','').str.replace(',','').astype(float)
+
+df_scrape["color"] = df_scrape["% Change"].map(lambda x:'red' if x<0 else 'green')
+cols_to_show = ['Name','Token', 'Price', '% Change', 'Market Cap']
+
+# to change color of "% change" column
+fill_color = []
+n = len(df_scrape)
+for col in cols_to_show:
+    if col!='% Change':
+        fill_color.append(['black']*n)
+    else:
+        fill_color.append(df_scrape["color"].to_list())
+
+# Plotly Table
+data=[go.Table(columnwidth = [20,15,15,15,15],
+                header=dict(values=[f"<b>{col}</b>" for col in cols_to_show],
+                font=dict(color='white', size=20),
+                height=30,
+                line_color='black',
+                fill_color='dimgrey',
+                align=['left','left', 'right','right','right']),
+                cells=dict(values=df_scrape[cols_to_show].values.T,
+               fill_color=fill_color,
+               font=dict(color='white', size=20),
+               height=30,
+               line_color='black',
+               align=['left','left', 'right','right','right']))]
+
+fig = go.Figure(data=data)
+fig.update_layout(go.Layout(xaxis = {'showgrid': False},
+                  yaxis = {'showgrid': False}))
+st.plotly_chart(fig, use_container_width=True)

performance analysis.ipynb

@@ -0,0 +1,1206 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "00769472-1fe0-4010-8a2f-248e5154fc92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "import json\n",
+    "import plotly.graph_objs as go\n",
+    "import plotly.express as px\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import time\n",
+    "from datetime import date, timedelta, datetime\n",
+    "from pypfopt import EfficientFrontier # nb pypfopt is shorthand for the package pyportfolioopt\n",
+    "from pypfopt import risk_models\n",
+    "from pypfopt import expected_returns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "ca4202a4-9a1b-4046-9bc6-d03568b26e5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_assets(total_coins=100):\n",
+    "  '''\n",
+    "  A function to retrieve info about the largest total_coins number of\n",
+    "  cryptocurrencies, ranked by market cap, generated by a call to coincap assets\n",
+    "  api.\n",
+    "  '''\n",
+    "  url = \"https://api.coincap.io/v2/assets\"\n",
+    "\n",
+    "  # N.B. here adampt the params dict to only request what you need\n",
+    "  payload={'limit': total_coins}\n",
+    "  headers = {}\n",
+    "\n",
+    "  assets_json = requests.request(\"GET\", url, params=payload, headers=headers).json()\n",
+    "  return assets_json\n",
+    "\n",
+    "def gen_symbols(assets_json):\n",
+    "  '''\n",
+    "  Function to generate three lists: symbols, names and ids, from the result of\n",
+    "  a call to the coincap assets api, assets_json.\n",
+    "  '''\n",
+    "  symbols_list = []\n",
+    "  names_list = []\n",
+    "  ids_list =[]\n",
+    "  for dict in assets_json['data']:\n",
+    "    symbols_list.append(dict['symbol'])\n",
+    "    names_list.append(dict['name'])\n",
+    "    ids_list.append(dict['id'])\n",
+    "  return symbols_list, names_list, ids_list\n",
+    "\n",
+    "def load_histories(coin_ids, start, end):\n",
+    "  '''\n",
+    "  Function to load daily historic prices for all crypto currencies in the\n",
+    "  coin_ids list within the time period defined by the interval [start, end].\n",
+    "  '''\n",
+    "  url = \"http://api.coincap.io/v2/assets/{}/history\"\n",
+    "\n",
+    "  payload={'interval':'d1', 'start':start, 'end':end}\n",
+    "  headers = {}\n",
+    "\n",
+    "  histories_dict = {}\n",
+    "  for id in coin_ids:\n",
+    "    response_histories = requests.request(\"GET\", url.format(id), headers=headers, params=payload)\n",
+    "    histories_json = response_histories.json()\n",
+    "    histories_dict[id] = histories_json['data']\n",
+    "  return histories_dict\n",
+    "\n",
+    "def create_unix_dates(today=date.today(), lookback_years = 5):\n",
+    "  '''\n",
+    "  A function to create start_unix and end_unix times in UNIX time in milliseconds\n",
+    "  '''\n",
+    "  start_datetime = today-timedelta(365*lookback_years)\n",
+    "  start_unix = int(time.mktime(start_datetime.timetuple()) * 1000)\n",
+    "  end_unix = int(time.mktime(date.today().timetuple()) * 1000)\n",
+    "  return start_unix, end_unix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "8f806ff9-d219-4935-b2fa-142409796951",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assets_json = create_assets(total_coins=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "eb3ac8a0-24ee-4cfb-b410-2bc4792e7485",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "symbols, names, coin_ids = gen_symbols(assets_json)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "9b4f9e03-5f5d-4c35-b515-3ed956191603",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_unix, end_unix = create_unix_dates(today=date.today(), lookback_years=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "c4c15661-17fb-420c-bce1-0850066ab683",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url = \"http://api.coincap.io/v2/assets/{}/history\"\n",
+    "\n",
+    "payload={'interval':'d1', 'start':start_unix, 'end':end_unix}\n",
+    "headers = {}\n",
+    "\n",
+    "histories_dict = {}\n",
+    "for id in coin_ids:\n",
+    "    response_histories = requests.request(\"GET\", url.format(id), headers=headers, params=payload)\n",
+    "    histories_json = response_histories.json()\n",
+    "    histories_dict[id] = histories_json['data']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "de780763-c0ad-4c82-acd0-f279d46e54d3",
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "ename": "JSONDecodeError",
+     "evalue": "Expecting value: line 1 column 1 (char 0)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mJSONDecodeError\u001b[0m                           Traceback (most recent call last)",
+      "\u001b[0;32m/var/folders/ff/pmf9d5156jz_pr_s8ybs3x780000gn/T/ipykernel_63357/1421263752.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhistories_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mload_histories\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoin_ids\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_unix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend_unix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m/var/folders/ff/pmf9d5156jz_pr_s8ybs3x780000gn/T/ipykernel_63357/437834857.py\u001b[0m in \u001b[0;36mload_histories\u001b[0;34m(coin_ids, start, end)\u001b[0m\n\u001b[1;32m     41\u001b[0m   \u001b[0;32mfor\u001b[0m \u001b[0mid\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcoin_ids\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0mresponse_histories\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrequests\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"GET\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mheaders\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpayload\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m     \u001b[0mhistories_json\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresponse_histories\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjson\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     44\u001b[0m     \u001b[0mhistories_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhistories_json\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'data'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mhistories_dict\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.9/site-packages/requests/models.py\u001b[0m in \u001b[0;36mjson\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m    864\u001b[0m                     \u001b[0;31m# used.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    865\u001b[0m                     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 866\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mcomplexjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloads\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    867\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    868\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/Cellar/python@3.9/3.9.5/Frameworks/Python.framework/Versions/3.9/lib/python3.9/json/__init__.py\u001b[0m in \u001b[0;36mloads\u001b[0;34m(s, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)\u001b[0m\n\u001b[1;32m    344\u001b[0m             \u001b[0mparse_int\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mparse_float\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m             parse_constant is None and object_pairs_hook is None and not kw):\n\u001b[0;32m--> 346\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_default_decoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    347\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    348\u001b[0m         \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mJSONDecoder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/Cellar/python@3.9/3.9.5/Frameworks/Python.framework/Versions/3.9/lib/python3.9/json/decoder.py\u001b[0m in \u001b[0;36mdecode\u001b[0;34m(self, s, _w)\u001b[0m\n\u001b[1;32m    335\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    336\u001b[0m         \"\"\"\n\u001b[0;32m--> 337\u001b[0;31m         \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraw_decode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_w\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    338\u001b[0m         \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_w\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    339\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/Cellar/python@3.9/3.9.5/Frameworks/Python.framework/Versions/3.9/lib/python3.9/json/decoder.py\u001b[0m in \u001b[0;36mraw_decode\u001b[0;34m(self, s, idx)\u001b[0m\n\u001b[1;32m    353\u001b[0m             \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscan_once\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    354\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 355\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mJSONDecodeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Expecting value\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    356\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mJSONDecodeError\u001b[0m: Expecting value: line 1 column 1 (char 0)"
+     ]
+    }
+   ],
+   "source": [
+    "histories_dict = load_histories(coin_ids, start_unix, end_unix)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c687db6d-bfd8-4e43-9e7a-b03923eed314",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def date_conv(date):\n",
+    "    return datetime.strptime(date, '%Y-%m-%d')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8a6a3771-f0f0-41dc-b34b-e9f5cd403dc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories_df= pd.read_csv('histories.csv')\n",
+    "histories_df['date'] = list(map(date_conv,histories_df['date']))\n",
+    "histories_df = histories_df.set_index('date')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "93ccd49c-55d4-4984-a768-2d1d961adf7c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def ids_with_histories(histories_df, start_date, end_date):\n",
+    "  investment_df = histories_df[start_date:end_date]\n",
+    "  investment_df.dropna(axis=1, inplace=True) # drop cols with any NaN values\n",
+    "  return investment_df.columns\n",
+    "\n",
+    "def uniform_weights_dict(ids_with_histories):\n",
+    "  weight = 1/len(ids_with_histories)\n",
+    "  uniform_weights_dict = {}\n",
+    "  for id in ids_with_histories:\n",
+    "    uniform_weights_dict[id] = weight\n",
+    "  return uniform_weights_dict\n",
+    "\n",
+    "\n",
+    "def markowitz_weights_dict(histories_df,start_port_date,ids_with_histories, analysis_days=365):\n",
+    "  start_analysis_date = start_port_date - timedelta(analysis_days)\n",
+    "  analysis_df = histories_df[start_analysis_date:start_port_date][ids_with_histories]\n",
+    "\n",
+    "  # Calculate expected returns and sample covariance\n",
+    "  mu = expected_returns.mean_historical_return(analysis_df)\n",
+    "  S = risk_models.sample_cov(analysis_df)\n",
+    "  # Optimize for maximal Sharpe ratio\n",
+    "  attempts=0\n",
+    "  while attempts < 10:\n",
+    "    try:\n",
+    "      ef = EfficientFrontier(mu, S, weight_bounds=(0, 1))\n",
+    "      ef.max_sharpe()\n",
+    "      break\n",
+    "    except Exception as e:\n",
+    "      attempts += 1\n",
+    "  try:\n",
+    "    cleaned_weights = ef.clean_weights()\n",
+    "  except Exception as e:\n",
+    "    print(\"Could not find optimal solution, try changing optimisation constraints or investment set\")\n",
+    "  return cleaned_weights\n",
+    "\n",
+    "\n",
+    "def gen_port_rtns(rebased_df, weights_dict):\n",
+    "  return rebased_df[list(weights_dict.keys())].dot(list(weights_dict.values()))\n",
+    "\n",
+    "def gen_rebased_df(histories_df, ids_with_histories, start_date, end_date):\n",
+    "  returns_df = histories_df[ids_with_histories].pct_change(1)\n",
+    "  returns_df[start_date:start_date]=0\n",
+    "  return (1 + returns_df[start_date:end_date]).cumprod()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6092ed85-0472-447d-90e5-ab0e357d1a5f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/ff/pmf9d5156jz_pr_s8ybs3x780000gn/T/ipykernel_63357/2151836904.py:3: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  investment_df.dropna(axis=1, inplace=True) # drop cols with any NaN values\n"
+     ]
+    }
+   ],
+   "source": [
+    "lookback_years = 5\n",
+    "start_date = date.today() - timedelta(365)\n",
+    "end_date = date.today()\n",
+    "ids_with_histories = ids_with_histories(histories_df,\n",
+    "  start_date, end_date)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6044aecd-752f-4097-8598-2ca9b1693c2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "uniform_weights_dict = uniform_weights_dict(ids_with_histories[:10])\n",
+    "markowitz_weights_dict = markowitz_weights_dict(histories_df,\n",
+    "  start_date ,ids_with_histories[:10], analysis_days=365)\n",
+    "rebased_df = gen_rebased_df(histories_df, ids_with_histories,\n",
+    "  start_date, end_date)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0741b8f0-32f5-411a-a412-f40320297ef2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gen_all_returns(rebased_df, ids_with_histories,uniform_weights_dict,\n",
+    "  markowitz_weights_dict):\n",
+    "  '''\n",
+    "  A function to generate returns for all portfolios and all coins with full\n",
+    "  histories over the backtest period, rebased to the start of the backtest\n",
+    "  period.\n",
+    "  '''\n",
+    "  uniform_returns = gen_port_rtns(rebased_df, uniform_weights_dict)\n",
+    "  uniform_returns.name = \"Uniform\"\n",
+    "  markowitz_returns = gen_port_rtns(rebased_df, markowitz_weights_dict)\n",
+    "  markowitz_returns.name = \"Markowitz\"\n",
+    "  port_returns = uniform_returns.to_frame().join(markowitz_returns)\n",
+    "  return port_returns.join(rebased_df[ids_with_histories])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "0b67f3d3-ae6f-4d8e-b52c-1c4c7c18d662",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_returns_df = gen_all_returns(rebased_df, ids_with_histories,uniform_weights_dict,\n",
+    "  markowitz_weights_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7dd39fac-3015-4024-a045-04f8a273ffec",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Uniform</th>\n",
+       "      <th>Markowitz</th>\n",
+       "      <th>bitcoin</th>\n",
+       "      <th>ethereum</th>\n",
+       "      <th>tether</th>\n",
+       "      <th>usd-coin</th>\n",
+       "      <th>binance-coin</th>\n",
+       "      <th>xrp</th>\n",
+       "      <th>binance-usd</th>\n",
+       "      <th>cardano</th>\n",
+       "      <th>...</th>\n",
+       "      <th>arweave</th>\n",
+       "      <th>compound</th>\n",
+       "      <th>kava</th>\n",
+       "      <th>holo</th>\n",
+       "      <th>gatetoken</th>\n",
+       "      <th>fei-protocol</th>\n",
+       "      <th>kyber-network</th>\n",
+       "      <th>qtum</th>\n",
+       "      <th>bancor</th>\n",
+       "      <th>1inch</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2021-05-24</th>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-25</th>\n",
+       "      <td>1.057165</td>\n",
+       "      <td>1.015792</td>\n",
+       "      <td>1.035396</td>\n",
+       "      <td>1.104084</td>\n",
+       "      <td>1.004346</td>\n",
+       "      <td>1.008332</td>\n",
+       "      <td>1.117736</td>\n",
+       "      <td>1.141806</td>\n",
+       "      <td>1.004241</td>\n",
+       "      <td>1.067167</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.015432</td>\n",
+       "      <td>1.051228</td>\n",
+       "      <td>1.084118</td>\n",
+       "      <td>1.231873</td>\n",
+       "      <td>1.106947</td>\n",
+       "      <td>1.004524</td>\n",
+       "      <td>1.037904</td>\n",
+       "      <td>1.264676</td>\n",
+       "      <td>1.078122</td>\n",
+       "      <td>1.064602</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-26</th>\n",
+       "      <td>1.103699</td>\n",
+       "      <td>1.018414</td>\n",
+       "      <td>1.059262</td>\n",
+       "      <td>1.182178</td>\n",
+       "      <td>0.998764</td>\n",
+       "      <td>0.998087</td>\n",
+       "      <td>1.211152</td>\n",
+       "      <td>1.172456</td>\n",
+       "      <td>0.998892</td>\n",
+       "      <td>1.180429</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.157293</td>\n",
+       "      <td>1.142980</td>\n",
+       "      <td>1.216742</td>\n",
+       "      <td>1.508202</td>\n",
+       "      <td>1.167414</td>\n",
+       "      <td>1.001874</td>\n",
+       "      <td>1.153683</td>\n",
+       "      <td>1.288506</td>\n",
+       "      <td>1.173015</td>\n",
+       "      <td>1.220068</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-27</th>\n",
+       "      <td>1.094057</td>\n",
+       "      <td>1.016329</td>\n",
+       "      <td>1.047055</td>\n",
+       "      <td>1.171337</td>\n",
+       "      <td>0.998721</td>\n",
+       "      <td>0.997785</td>\n",
+       "      <td>1.209819</td>\n",
+       "      <td>1.151604</td>\n",
+       "      <td>0.998899</td>\n",
+       "      <td>1.166563</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.159935</td>\n",
+       "      <td>1.114319</td>\n",
+       "      <td>1.253248</td>\n",
+       "      <td>1.432746</td>\n",
+       "      <td>1.155625</td>\n",
+       "      <td>0.999451</td>\n",
+       "      <td>1.178437</td>\n",
+       "      <td>1.424998</td>\n",
+       "      <td>1.192224</td>\n",
+       "      <td>1.226486</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-28</th>\n",
+       "      <td>1.035221</td>\n",
+       "      <td>1.005436</td>\n",
+       "      <td>0.988150</td>\n",
+       "      <td>1.081310</td>\n",
+       "      <td>0.998400</td>\n",
+       "      <td>0.997946</td>\n",
+       "      <td>1.118547</td>\n",
+       "      <td>1.055065</td>\n",
+       "      <td>0.998932</td>\n",
+       "      <td>1.070248</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.011761</td>\n",
+       "      <td>1.007871</td>\n",
+       "      <td>1.218521</td>\n",
+       "      <td>1.269149</td>\n",
+       "      <td>1.053198</td>\n",
+       "      <td>0.994776</td>\n",
+       "      <td>1.072810</td>\n",
+       "      <td>1.336266</td>\n",
+       "      <td>1.095105</td>\n",
+       "      <td>1.125980</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 87 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "             Uniform  Markowitz   bitcoin  ethereum    tether  usd-coin  \\\n",
+       "date                                                                      \n",
+       "2021-05-24  1.000000   1.000000  1.000000  1.000000  1.000000  1.000000   \n",
+       "2021-05-25  1.057165   1.015792  1.035396  1.104084  1.004346  1.008332   \n",
+       "2021-05-26  1.103699   1.018414  1.059262  1.182178  0.998764  0.998087   \n",
+       "2021-05-27  1.094057   1.016329  1.047055  1.171337  0.998721  0.997785   \n",
+       "2021-05-28  1.035221   1.005436  0.988150  1.081310  0.998400  0.997946   \n",
+       "\n",
+       "            binance-coin       xrp  binance-usd   cardano  ...   arweave  \\\n",
+       "date                                                       ...             \n",
+       "2021-05-24      1.000000  1.000000     1.000000  1.000000  ...  1.000000   \n",
+       "2021-05-25      1.117736  1.141806     1.004241  1.067167  ...  1.015432   \n",
+       "2021-05-26      1.211152  1.172456     0.998892  1.180429  ...  1.157293   \n",
+       "2021-05-27      1.209819  1.151604     0.998899  1.166563  ...  1.159935   \n",
+       "2021-05-28      1.118547  1.055065     0.998932  1.070248  ...  1.011761   \n",
+       "\n",
+       "            compound      kava      holo  gatetoken  fei-protocol  \\\n",
+       "date                                                                \n",
+       "2021-05-24  1.000000  1.000000  1.000000   1.000000      1.000000   \n",
+       "2021-05-25  1.051228  1.084118  1.231873   1.106947      1.004524   \n",
+       "2021-05-26  1.142980  1.216742  1.508202   1.167414      1.001874   \n",
+       "2021-05-27  1.114319  1.253248  1.432746   1.155625      0.999451   \n",
+       "2021-05-28  1.007871  1.218521  1.269149   1.053198      0.994776   \n",
+       "\n",
+       "            kyber-network      qtum    bancor     1inch  \n",
+       "date                                                     \n",
+       "2021-05-24       1.000000  1.000000  1.000000  1.000000  \n",
+       "2021-05-25       1.037904  1.264676  1.078122  1.064602  \n",
+       "2021-05-26       1.153683  1.288506  1.173015  1.220068  \n",
+       "2021-05-27       1.178437  1.424998  1.192224  1.226486  \n",
+       "2021-05-28       1.072810  1.336266  1.095105  1.125980  \n",
+       "\n",
+       "[5 rows x 87 columns]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all_returns_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "ebe9263f-1a3f-4dc8-ba19-732b83d30e50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def absolute_return(prices):\n",
+    "  'a function to calculate the absolute return given a daily price series'\n",
+    "  abs_rtn = ((prices.iloc[-1]/prices[0])-1)\n",
+    "  return abs_rtn\n",
+    "\n",
+    "def annual_return(prices):\n",
+    "  'a function to calculate the annualised return given a daily price series'\n",
+    "  abs_rtn = absolute_return(prices)\n",
+    "  annual_rnt = (pow((abs_rtn/100)+1, 365/len(prices))-1)*100\n",
+    "  return annual_rnt\n",
+    "\n",
+    "def max_drawdown(prices):\n",
+    "  '''\n",
+    "  A function to calculate the max drawdown for a given price series \"prices\"\n",
+    "  as well as the index of the start of the max drawdown period, \"start_idx\"\n",
+    "  and the index of end of the max drawdwon period, \"end index\"\n",
+    "  '''\n",
+    "  if type(prices)==type(pd.Series(dtype='object')):\n",
+    "      prices = prices.values\n",
+    "  end_idx = np.argmax(np.maximum.accumulate(prices) - prices) # end of the period\n",
+    "  start_idx = np.argmax(prices[:end_idx]) # start of period\n",
+    "  max_dd = (prices[start_idx]-prices[end_idx])/prices[start_idx]\n",
+    "  return max_dd, start_idx, end_idx\n",
+    "\n",
+    "def annual_vol(prices):\n",
+    "  '''\n",
+    "  A function to calculate the annuaised volatility of a price series assuming\n",
+    "  cryptos trade 365 days a year\n",
+    "  '''\n",
+    "  return prices.pct_change().std()*(365**0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "c7cfd009-dbe6-4afe-86a8-9706beb1f351",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 38.2 ms, sys: 22.1 ms, total: 60.3 ms\n",
+      "Wall time: 677 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time \n",
+    "\n",
+    "url = \"https://api.coincap.io/v2/assets\"\n",
+    "\n",
+    "# N.B. here adampt the params dict to only request what you need\n",
+    "payload={'limit': '100'}\n",
+    "headers = {}\n",
+    "\n",
+    "response_assets = requests.request(\"GET\", url, params=payload, headers=headers)\n",
+    "assets_json = response_assets.json()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "9f8abf03-8214-498d-8cd1-778f77ff308e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "market_cap_dict = {}\n",
+    "for asset_dict in assets_json['data']:\n",
+    "    market_cap_dict[asset_dict['id']] = int(float(asset_dict['marketCapUsd']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "68a777da-401f-41cb-8485-688bd3d6df70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assets = all_returns_df.columns\n",
+    "performance_df = pd.DataFrame(index = assets)\n",
+    "performance_df['Type'] = [\"Portfolio\" if x in ['Uniform','Markowitz'] else \"Coin\" for x in assets]\n",
+    "abs_return = all_returns_df.apply(absolute_return)\n",
+    "ann_vol = all_returns_df.apply(annual_vol)\n",
+    "drawdown_triples = all_returns_df.apply(max_drawdown)\n",
+    "sharpe = abs_return.divide(ann_vol)\n",
+    "market_caps=[]\n",
+    "for asset in assets:\n",
+    "    try:\n",
+    "        market_caps.append(int(market_cap_dict[asset]))\n",
+    "    except:\n",
+    "        market_caps.append(0)\n",
+    "performance_df['Risk adjusted return'] = sharpe *100\n",
+    "performance_df['Return over period'] = abs_return * 100\n",
+    "performance_df['Annual volatility'] = ann_vol *100\n",
+    "performance_df['Max loss'] = drawdown_triples.iloc[0] *100\n",
+    "performance_df['Market cap'] = market_caps"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "3bf84fd6-795b-4e06-b82b-bdf4e0714224",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Risk adjusted return</th>\n",
+       "      <th>Return over period</th>\n",
+       "      <th>Annual volatility</th>\n",
+       "      <th>Max loss</th>\n",
+       "      <th>Market cap</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Uniform</th>\n",
+       "      <td>Portfolio</td>\n",
+       "      <td>-22.24</td>\n",
+       "      <td>-12.20</td>\n",
+       "      <td>54.84</td>\n",
+       "      <td>62.39</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Markowitz</th>\n",
+       "      <td>Portfolio</td>\n",
+       "      <td>-32.44</td>\n",
+       "      <td>-4.10</td>\n",
+       "      <td>12.65</td>\n",
+       "      <td>20.49</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>bitcoin</th>\n",
+       "      <td>Coin</td>\n",
+       "      <td>-32.53</td>\n",
+       "      <td>-18.42</td>\n",
+       "      <td>56.61</td>\n",
+       "      <td>57.98</td>\n",
+       "      <td>564237420636</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ethereum</th>\n",
+       "      <td>Coin</td>\n",
+       "      <td>-18.21</td>\n",
+       "      <td>-12.59</td>\n",
+       "      <td>69.11</td>\n",
+       "      <td>59.35</td>\n",
+       "      <td>238817158476</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>tether</th>\n",
+       "      <td>Coin</td>\n",
+       "      <td>-20.42</td>\n",
+       "      <td>-0.35</td>\n",
+       "      <td>1.74</td>\n",
+       "      <td>1.38</td>\n",
+       "      <td>73268815333</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                Type  Risk adjusted return  Return over period  \\\n",
+       "Uniform    Portfolio                -22.24              -12.20   \n",
+       "Markowitz  Portfolio                -32.44               -4.10   \n",
+       "bitcoin         Coin                -32.53              -18.42   \n",
+       "ethereum        Coin                -18.21              -12.59   \n",
+       "tether          Coin                -20.42               -0.35   \n",
+       "\n",
+       "           Annual volatility  Max loss    Market cap  \n",
+       "Uniform                54.84     62.39             0  \n",
+       "Markowitz              12.65     20.49             0  \n",
+       "bitcoin                56.61     57.98  564237420636  \n",
+       "ethereum               69.11     59.35  238817158476  \n",
+       "tether                  1.74      1.38   73268815333  "
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "performance_df.round(2).head()\n",
+    "                                 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "62360da2-742f-418d-b071-2f9256855341",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "market_caps=[]\n",
+    "for asset in assets:\n",
+    "    try:\n",
+    "        market_caps.append(int(market_cap_dict[asset]))\n",
+    "    except:\n",
+    "        market_caps.append(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "id": "8c4e6c8b-5496-4ea7-b599-370fab33f4e1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "['Uniform', 'bitcoin'] is not in list",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m/var/folders/ff/pmf9d5156jz_pr_s8ybs3x780000gn/T/ipykernel_63357/545937437.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mall_returns_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Uniform'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'bitcoin'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m: ['Uniform', 'bitcoin'] is not in list"
+     ]
+    }
+   ],
+   "source": [
+    "list(all_returns_df.columns).index(['Uniform','bitcoin'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "id": "4c8bdb96-620f-418d-8d76-3cb7d633168c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N = [i for i in range(len(all_returns_df.columns)) if all_returns_df.columns[i] in ['Uniform','bitcoin']]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "id": "f21e4471-a78d-42d9-8d44-782a36b80931",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 2]"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "N"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "id": "6cce98be-4c73-4b2b-98d2-4f995e3be60f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dic={'a':1, 'b':2}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "id": "37c4c19f-21ec-4817-a142-cde2b767a179",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (1228105859.py, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  File \u001b[0;32m\"/var/folders/ff/pmf9d5156jz_pr_s8ybs3x780000gn/T/ipykernel_63357/1228105859.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    for temp in del dic['a']:\u001b[0m\n\u001b[0m                ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "for temp in del dic['a']:\n",
+    "    print('yes')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "id": "72199468-c241-4550-9686-c4349c7c0734",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "del dic['b']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "id": "09e95fe9-5000-419e-be53-686ca0e88a12",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 104,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dic)!=0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "id": "46b8e046-810c-4284-be8b-fb24fcf46588",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "strategy_dict = {'Uniform': {'a':2}, 'Markowitz':{'b':3}}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "id": "770e265a-d31d-43bd-a7f6-053a1f9cdcf3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Uniform\n",
+      "Markowitz\n"
+     ]
+    }
+   ],
+   "source": [
+    "for name, weights in strategy_dict.items():\n",
+    "    print(name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "id": "ed0aea65-24c0-48a2-a957-0b1a1a4b518d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "port_returns = gen_port_rtns(rebased_df, uniform_weights_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "id": "72ec929c-629e-4e3c-841a-9fcae6610d2c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "date\n",
+       "2021-05-24    1.000000\n",
+       "2021-05-25    1.057165\n",
+       "2021-05-26    1.103699\n",
+       "2021-05-27    1.094057\n",
+       "2021-05-28    1.035221\n",
+       "                ...   \n",
+       "2022-05-13    0.858603\n",
+       "2022-05-14    0.842769\n",
+       "2022-05-15    0.863536\n",
+       "2022-05-16    0.868936\n",
+       "2022-05-17    0.878021\n",
+       "Length: 359, dtype: float64"
+      ]
+     },
+     "execution_count": 115,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "port_returns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "id": "b0694bbc-9941-41a4-bf49-96d581f82907",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "port_returns = pd.DataFrame({'Uniform': port_returns})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "id": "02b1c5fd-0b51-4b4d-9bf1-f5dcf46477a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Uniform</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>date</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2021-05-24</th>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-25</th>\n",
+       "      <td>1.057165</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-26</th>\n",
+       "      <td>1.103699</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-27</th>\n",
+       "      <td>1.094057</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-05-28</th>\n",
+       "      <td>1.035221</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-05-13</th>\n",
+       "      <td>0.858603</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-05-14</th>\n",
+       "      <td>0.842769</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-05-15</th>\n",
+       "      <td>0.863536</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-05-16</th>\n",
+       "      <td>0.868936</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2022-05-17</th>\n",
+       "      <td>0.878021</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>359 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "             Uniform\n",
+       "date                \n",
+       "2021-05-24  1.000000\n",
+       "2021-05-25  1.057165\n",
+       "2021-05-26  1.103699\n",
+       "2021-05-27  1.094057\n",
+       "2021-05-28  1.035221\n",
+       "...              ...\n",
+       "2022-05-13  0.858603\n",
+       "2022-05-14  0.842769\n",
+       "2022-05-15  0.863536\n",
+       "2022-05-16  0.868936\n",
+       "2022-05-17  0.878021\n",
+       "\n",
+       "[359 rows x 1 columns]"
+      ]
+     },
+     "execution_count": 117,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "port_returns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "id": "9f276fcd-b0aa-4faf-980d-3766737d4e35",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list1 = ['a','b', 'c']\n",
+    "list2=['a','b']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "id": "9d95a028-39f4-4bc4-b15e-1ac98c6c8242",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['a', 'b']"
+      ]
+     },
+     "execution_count": 121,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[x for x in list1 if x in list2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "id": "ef331045-44ad-4ff5-8ba7-3b4584a818c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dic = {'a':1, 'b':2}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "id": "087dc4d9-b6b5-4cd5-9c76-b227fc56e31c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dic['a'] =3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "id": "688edc89-974a-4562-81db-0bc30798c30c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'a': 3, 'b': 2}"
+      ]
+     },
+     "execution_count": 124,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6ef4a1cb-d075-4d09-8038-caf04767565b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

persist.py

@@ -0,0 +1,23 @@
+from streamlit import session_state as _state
+
+_PERSIST_STATE_KEY = f"{__name__}_PERSIST"
+
+
+def persist(key: str) -> str:
+    """Mark widget state as persistent."""
+    if _PERSIST_STATE_KEY not in _state:
+        _state[_PERSIST_STATE_KEY] = set()
+
+    _state[_PERSIST_STATE_KEY].add(key)
+
+    return key
+
+
+def load_widget_state():
+    """Load persistent widget state."""
+    if _PERSIST_STATE_KEY in _state:
+        _state.update({
+            key: value
+            for key, value in _state.items()
+            if key in _state[_PERSIST_STATE_KEY]
+        })

plot_creator.py

@@ -0,0 +1,154 @@
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+from PIL import Image
+import glob
+from risk_metrics import absolute_return, annual_vol, max_drawdown
+from streamlit_custom_slider import st_custom_slider
+
+@st.cache(persist=True, show_spinner=False)
+def create_rebase_chart(rebased_df, num_coins):
+  melt_df = pd.melt(rebased_df.iloc[:,:num_coins], ignore_index=False)
+  melt_df.columns=['coin','price (USD)']
+  return melt_df
+
+@st.cache(persist=True, show_spinner=False)
+def create_chart_df(all_returns_df, portfolio, coin):
+  melt_df = pd.melt(all_returns_df, value_vars=[portfolio, coin], ignore_index=False)
+  melt_df.columns=['Asset','Value (USD)']
+  return melt_df
+
+@st.cache(persist=True, show_spinner=False)
+def create_comparison_df(all_returns_df, selected_assets):
+  selected_assets_present = [asset for asset in selected_assets if asset in list(all_returns_df.columns)]
+  melt_df = pd.melt(all_returns_df, value_vars=selected_assets_present, ignore_index=False)
+  melt_df.columns=['Asset','Value (USD)']
+  return melt_df
+
+@st.cache(persist=True, show_spinner=False)
+def ordered_dict(dictionary):
+  return {k: v for k, v in sorted(dictionary.items(), key=lambda item: item[1], reverse=True)}
+
+# allow output mutation in this function because I'm not worried about mutation
+# and i want to reduce the time it takes streamlit to check it hasn't mutated.
+@st.cache(persist=True, show_spinner=False, allow_output_mutation=True)
+def load_images():
+  image_dict = {}
+  for filename in glob.glob('logos/*.jpg'): #assuming all logos are png format
+    im=Image.open(filename)
+    image_dict[filename[6:][:-4]]=im
+  return image_dict
+
+@st.cache(persist=True, show_spinner=False)
+def gen_performance_df(all_returns_df, market_cap_dict, strategy_dict):
+  assets = all_returns_df.columns
+  performance_df = pd.DataFrame(index = assets)
+  performance_df['Type'] = ["Portfolio" if x in  list(strategy_dict.keys()) else "Coin" for x in assets]
+  abs_return = all_returns_df.apply(absolute_return)
+  ann_vol = all_returns_df.apply(annual_vol)
+  drawdown_triples = all_returns_df.apply(max_drawdown)
+  sharpe = abs_return.divide(ann_vol)
+  market_caps=[]
+  for asset in assets:
+      try:
+          market_caps.append(int(market_cap_dict[asset]))
+      except:
+          market_caps.append(0)
+  performance_df['Total return %'] = abs_return * 100
+  performance_df['Risk / return'] =  sharpe *100
+  performance_df['Annual vol'] = ann_vol *100
+  performance_df['Max loss %'] = drawdown_triples.iloc[0] *100
+  performance_df['Market cap $M'] = [cap/1000000 for cap in market_caps]
+  return performance_df
+
+@st.cache(persist=True, show_spinner=False)
+def gen_performance_ag_df(all_returns_df, market_cap_dict, strategy_dict):
+  assets = all_returns_df.columns
+  performance_df = pd.DataFrame(index=assets)
+  performance_df['Asset'] = assets
+  performance_df['Type'] = ["Portfolio" if x in list(strategy_dict.keys()) else "Coin" for x in assets]
+  abs_return = all_returns_df.apply(absolute_return)
+  ann_vol = all_returns_df.apply(annual_vol)
+  drawdown_triples = all_returns_df.apply(max_drawdown)
+  sharpe = abs_return.divide(ann_vol)
+  market_caps=[]
+  for asset in assets:
+      try:
+          market_caps.append(int(market_cap_dict[asset]))
+      except:
+          market_caps.append(0)
+  performance_df['Risk adjusted return %'] =  sharpe *100
+  performance_df['Return over period %'] = abs_return * 100
+  performance_df['Annual volatility'] = ann_vol *100
+  performance_df['Max loss %'] = drawdown_triples.iloc[0] *100
+  performance_df['Market cap $M'] = [cap/1000000 for cap in market_caps]
+  return performance_df
+
+@st.cache(persist=True, show_spinner=False)
+def add_drawdown(fig, all_returns_df, selected_asset):
+  #calculate max drawdown
+  max_dd, start_idx, end_idx = max_drawdown(all_returns_df[selected_asset])
+  start_dd = all_returns_df.index[start_idx]
+  end_dd = all_returns_df.index[end_idx]
+  fig.add_vline(x=start_dd, line_width=1, line_color="red")
+  fig.add_vline(x=end_dd, line_width=1, line_color="red")
+  fig.add_vrect(x0=start_dd, x1=end_dd, line_width=0, fillcolor="red", opacity=0.05, annotation_text=selected_asset + " maxdd")
+  return fig, max_dd, start_dd, end_dd
+
+def write_coins(non_zero_coins, weights_dict, ids2names_dict, n_cols=2):
+  n_coins = len(non_zero_coins)
+  n_rows = 1 + n_coins // int(n_cols)
+
+  rows = [st.container() for _ in range(n_rows)]
+  cols_per_row = [r.columns(n_cols) for r in rows]
+  cols = [column for row in cols_per_row for column in row]
+
+  #cols = st.columns(n_coins)
+  #checkboxes=[]
+  for i, coin_id in enumerate(non_zero_coins):
+    cols[i].slider(ids2names_dict[coin_id], min_value=0, max_value=100,
+      value=int(weights_dict[coin_id]*100), key=coin_id,
+      disabled=True)
+
+def write_bespoke_coins(coin_names, n_cols=2):
+  n_coins = len(coin_names)
+  n_rows = 1 + n_coins // int(n_cols)
+
+  rows = [st.container() for _ in range(n_rows)]
+  cols_per_row = [r.columns(n_cols) for r in rows]
+  cols = [column for row in cols_per_row for column in row]
+
+  #cols = st.columns(n_coins)
+  #checkboxes=[]
+  weights_list = []
+  for i, coin_name in enumerate(coin_names):
+    weight = cols[i].slider(coin_name, min_value=0, max_value=100,
+      value=50, key=coin_name,
+      disabled=False)
+    weights_list.append(weight)
+  weights_list = [weight/sum(weights_list) for weight in weights_list]
+  return weights_list
+
+
+def write_coins_custom(coin_names, n_cols=2):
+  n_coins = len(coin_names)
+  n_rows = 1 + n_coins // int(n_cols)
+
+  rows = [st.container() for _ in range(n_rows)]
+  cols_per_row = [r.columns(n_cols) for r in rows]
+  cols = [column for row in cols_per_row for column in row]
+
+  #cols = st.columns(n_coins)
+  #checkboxes=[]
+  weights_list = []
+  for i, coin_name in enumerate(coin_names):
+    with cols[i]:
+      weight = st_custom_slider(coin_name, min_value=0, max_value=100,
+        value=50, key=coin_name)
+    weights_list.append(weight)
+  weights_list = [weight/sum(weights_list) for weight in weights_list]
+  return weights_list
+
+@st.cache(persist=True, show_spinner=False)
+def get_pre_selected_idx(assets, pre_selected):
+  return [i for i in range(len(assets)) if assets[i] in pre_selected]

port_creator.py

@@ -0,0 +1,141 @@
+import pandas as pd
+import streamlit as st
+from pypfopt import EfficientFrontier
+from pypfopt import risk_models
+from pypfopt import expected_returns
+from datetime import date, timedelta
+
+@st.cache(persist=True, show_spinner=False)
+def uniform(returns_df, num_coins, start_date, end_date):
+  # THERE IS AN ERROR
+  # Need to change this from num_coins being a number to investment_set being
+  # a list of assets available. otherwise there could be assets in your
+  # portfolio that are not included in your investment set graph
+  '''
+  A function to return a uniform distribution of weights across all assets with
+  a full returns history (no NaN values) between start_date and end_date.
+
+  Returns:
+    weights: a vector of weights of dimension num_coins.
+    investment_cols: a vector of column names for coins with full histories.
+  '''
+  investment_df = returns_df[start_date:end_date]
+  investment_df.dropna(axis=1, inplace=True) # drop cols with any NaN values
+  investment_cols = investment_df.columns[0:num_coins]
+  weights = [1/num_coins for _ in range(num_coins)]
+  return weights, investment_cols
+
+@st.cache(persist=True, show_spinner=False)
+def markowitz(returns_df):
+  pass
+
+@st.cache(persist=True, show_spinner=False, allow_output_mutation=True)
+def create_port_rtns(returns_df, weights, investment_cols, start_date, end_date):
+  investment_df = returns_df[investment_cols]
+  investment_df[start_date:start_date]=0
+  rebased_df = (1 + investment_df[start_date:end_date]).cumprod()
+  port_returns = rebased_df.dot(weights)
+  port_returns.index.name = 'date'
+  port_returns.name = 'price (USD)'
+  return port_returns
+
+@st.cache(persist=True, show_spinner=False)
+def markowitz_weights(histories_df,start_port_date,investment_cols, analysis_days=365):
+  start_analysis_date = start_port_date - timedelta(analysis_days)
+  analysis_df = histories_df[start_analysis_date:start_port_date][investment_cols]
+
+  # Calculate expected returns and sample covariance
+  mu = expected_returns.mean_historical_return(analysis_df)
+  S = risk_models.sample_cov(analysis_df)
+  # Optimize for maximal Sharpe ratio
+  attempts=0
+  while attempts < 50:
+    try:
+      ef = EfficientFrontier(mu, S, weight_bounds=(0, 1))
+      ef.max_sharpe()
+      break
+    except Exception as e:
+      attempts += 1
+  try:
+    cleaned_weights = ef.clean_weights()
+  except Exception as e:
+    print("Could not find optimal solution, try changing optimisation constraints or investment set")
+  return cleaned_weights
+
+@st.cache(persist=True, show_spinner=False)
+def create_weights_df(weights_dict, strategy):
+  return pd.DataFrame({
+    'strategy': strategy,
+    'assets': list(weights_dict.keys()),
+    'weights': list(weights_dict.values())
+  })
+
+@st.cache(persist=True, show_spinner=False)
+def ids_with_histories(histories_df, start_date, end_date):
+  investment_df = histories_df[start_date:end_date]
+  investment_df.dropna(axis=1, inplace=True) # drop cols with any NaN values
+  return investment_df.columns
+
+@st.cache(persist=True, show_spinner=False)
+def uniform_weights_dict(ids_with_histories):
+  weight = 1/len(ids_with_histories)
+  uniform_weights_dict = {}
+  for id in ids_with_histories:
+    uniform_weights_dict[id] = weight
+  return uniform_weights_dict
+
+@st.cache(persist=True, show_spinner=False)
+def markowitz_weights_dict(histories_df,start_port_date,ids_with_histories, analysis_days=365):
+  start_analysis_date = start_port_date - timedelta(analysis_days)
+  analysis_df = histories_df[start_analysis_date:start_port_date][ids_with_histories]
+
+  # Calculate expected returns and sample covariance
+  mu = expected_returns.mean_historical_return(analysis_df)
+  S = risk_models.sample_cov(analysis_df)
+  # Optimize for maximal Sharpe ratio
+  attempts=0
+  while attempts < 10:
+    try:
+      ef = EfficientFrontier(mu, S, weight_bounds=(0, 1))
+      ef.max_sharpe()
+      break
+    except Exception as e:
+      attempts += 1
+  try:
+    cleaned_weights = ef.clean_weights()
+  except Exception as e:
+    print("Could not find optimal solution, try changing optimisation constraints or investment set")
+  return {k: v for k, v in sorted(cleaned_weights.items(), key=lambda item: item[1], reverse=True)}
+  #return cleaned_weights
+
+@st.cache(persist=True, show_spinner=False)
+def gen_port_rtns(rebased_df, weights_dict):
+  new_weights_dict = {k: v for k, v in weights_dict.items() if k in rebased_df.columns}
+  new_weights_dict = {k: v/sum(new_weights_dict.values()) for k, v in new_weights_dict.items()}
+  return rebased_df[list(new_weights_dict.keys())].dot(list(new_weights_dict.values()))
+  #return rebased_df[list(weights_dict.keys())].dot(list(weights_dict.values()))
+
+@st.cache(persist=True, show_spinner=False)
+def gen_all_returns(rebased_df, ids_with_histories, strategy_dict):
+  '''
+  A function to generate returns for all portfolios and all coins with full
+  histories over the backtest period, rebased to the start of the backtest
+  period.
+  '''
+  port_returns = gen_port_rtns(rebased_df, strategy_dict['Uniform'])
+  port_returns = pd.DataFrame({'Uniform': port_returns})
+  temp_dict = {k: v for k, v in strategy_dict.items() if k != 'Uniform'}
+  if len(temp_dict)!=0:
+    for name, weights in temp_dict.items():
+      temp_returns = gen_port_rtns(rebased_df, weights)
+      temp_returns.name = name
+      port_returns = port_returns.join(temp_returns)
+  return port_returns.join(rebased_df[ids_with_histories])
+
+  #uniform_returns = gen_port_rtns(rebased_df, uniform_weights_dict)
+  #uniform_returns.name = "Uniform"
+  #markowitz_returns = gen_port_rtns(rebased_df, markowitz_weights_dict)
+  #markowitz_returns.name = "Markowitz"
+  #port_returns = uniform_returns.to_frame().join(markowitz_returns)
+  #return port_returns.join(rebased_df[ids_with_histories])
+

port_viewer.py

@@ -0,0 +1,159 @@
+import streamlit as st
+import json
+import plotly.express as px
+import pandas as pd
+from datetime import date, timedelta, datetime
+from risk_metrics import annual_return, absolute_return, annual_vol, max_drawdown
+import numpy as np
+from data_creator import create_assets, gen_symbols, create_histories_df, create_unix_dates, create_returns_df, create_rebased_df, date_range
+from plot_creator import create_rebase_chart
+from port_creator import uniform, create_port_rtns, markowitz_weights, create_weights_df
+from risk_metrics import max_drawdown
+
+
+# load start and end dates for investment analysis
+lookback_years = 5
+start_date = date.today() - timedelta(365)
+end_date = date.today()
+
+
+with st.sidebar:
+  investment_set = st.number_input(
+    "How many coins to would you like in your investment set?",
+    min_value=1,
+    max_value=50,
+    value=10,
+    help="Coins will be added to your investment set in order of largest market cap"
+    #("Top 5 coins", "Top 10 coins")
+  )
+  portfolio_type = st.selectbox(
+    'Select portfolio strategy',
+    ('Uniform', 'Markowitz'),
+    help='''
+    Uniform: An equal propotion of your initial investment is allocated to each
+    asset in the investment set (provided the asset existed at the start date of
+     your investment period). \n
+    Markowitz: Your initial investment is allocated to each asset in the
+    investment set to achieve the "market portfolio"  using a risk-variance
+    analysis (provided the asset existed at the start date of your investment
+    period).
+    '''
+  )
+
+
+# Pull down histories from coincap, and create dataframes for historic prices,
+# returns and rebased cumulative price; histories_df, returns_df, and
+# rebased_df, respectively.
+# All fo the functions in the block below have been decorated with st.cache()
+# and so will only be re-run if their arguments, or their underlying code, are
+# changed
+assets_json = create_assets(total_coins=100)
+symbols, names, coin_ids = gen_symbols(assets_json)
+start_unix, end_unix = create_unix_dates(today=date.today(), lookback_years=lookback_years)
+histories_df = create_histories_df(coin_ids, start_unix, end_unix)
+returns_df = create_returns_df(histories_df)
+rebased_df = create_rebased_df(returns_df, start_date=start_date, end_date=end_date)
+
+if 'rebased_df' not in st.session_state:
+    st.session_state.rebased_df = rebased_df
+
+#def adjust_rebased(returns_df, start_date, end_date):
+def adjust_rebased():
+  st.session_state.rebased_df = create_rebased_df(returns_df,
+  start_date = st.session_state.myslider[0],
+  end_date=st.session_state.myslider[1])
+
+
+# Draw rebased graph
+melt_df = create_rebase_chart(st.session_state.rebased_df, num_coins=investment_set)
+fig = px.line(melt_df, x=melt_df.index, y='price (USD)', color='coin')
+
+with st.expander('Quick explantion', expanded = True):
+  st.subheader("What's this all about then, eh?")
+  st.write('''
+  The app allows you to construct portfolios of crypto currencies and to
+  backtest their historic performance.
+
+  You can select how many coins you would like in your investment set using the
+  dropdown box in the sidebar.
+
+  You can select from two different portfolio constructions
+  strategies using the dropdown box in the sidebar:
+
+  - Uniform - An equal propotion of your initial investment is allocated to each coin.
+  - Markowitz - Your initial investment is allocated to each coin to achieve the portfolio with the highest sharpe ratio in the 365 day period prior to the investment start date.
+
+  You can adjust the date range for the portfolio backtest using the slider widget below.
+
+  If you would like to see the performance of the individual coins in your investment set
+  over the backtest period click the + icon in the Coin view expander.
+
+  To collapse this expander click the - icon at the top right.
+
+  ''')
+
+# Add select slider to allow
+date_list = date_range(end_date,lookback_years-1)
+start_port_date, end_port_date = st.select_slider(
+     'Select date range for portolio backtest',
+     key="myslider",
+     options=date_list,
+     value=(date.today() - timedelta(365), date.today()),
+     on_change=adjust_rebased
+     )
+
+with st.expander("Coin view", expanded=False):
+  st.subheader('Individual coin performance')
+  st.write(fig)
+
+uniform_weights, investment_cols = uniform(returns_df, num_coins=investment_set,
+start_date=start_port_date, end_date=end_port_date)
+
+uniform_weights_dict = {}
+for i, coin in enumerate(investment_cols):
+  uniform_weights_dict[coin] = uniform_weights[i]
+markowitz_weights_dict = markowitz_weights(histories_df,start_port_date,investment_cols, analysis_days=365)
+
+uniform_returns = create_port_rtns(returns_df, uniform_weights, investment_cols, start_port_date, end_port_date)
+markotwitz_returns = create_port_rtns(returns_df, list(markowitz_weights_dict.values()), investment_cols, start_port_date, end_port_date)
+returns_dict = {'Uniform': uniform_returns, 'Markowitz':markotwitz_returns}
+strategy_dict = {'Uniform': uniform_weights_dict, 'Markowitz':markowitz_weights_dict}
+port_return = returns_dict[portfolio_type]
+
+#calculate max drawdown
+max_dd, start_idx, end_idx = max_drawdown(port_return)
+start_dd = port_return.index[start_idx]
+end_dd = port_return.index[end_idx]
+
+
+port_fig = px.line(port_return, x=port_return.index, y='price (USD)')
+port_fig.add_vline(x=start_dd, line_width=1, line_color="red")
+port_fig.add_vline(x=end_dd, line_width=1, line_color="red")
+port_fig.add_vrect(x0=start_dd, x1=end_dd, line_width=0, fillcolor="red", opacity=0.05, annotation_text="max drawdown ")
+st.subheader("{} portfolio performance".format(portfolio_type))
+
+weights_df = create_weights_df(strategy_dict[portfolio_type], portfolio_type)
+
+bar_fig = px.bar(weights_df, x="strategy", y="weights", color="assets", width=200)
+bar_fig.update_layout(showlegend=False, xaxis={'visible': False}, )
+
+
+cols = st.columns([8,1])
+cols[0].write(port_fig)
+cols[1].write(bar_fig)
+
+cols = st.columns([1,3])
+outlay = cols[0].number_input('Initial $ amount', min_value=0, value=1000,
+  step=1)
+final_amount = outlay*port_return[-1]
+max_loss=outlay*max_dd
+
+cols[1].write('''For an initial investment of **${:,}**\n
+
+  You would have ended up with **${:,}** \n
+
+  You would have suffered a maximum loss of **{:.0f}%** of your portfolio value
+  between **{}** and **{}**'''.format(
+    outlay, int(final_amount), max_dd*100, start_dd, end_dd))
+
+