Final_Code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"5\">Take Data from the WEB</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests as rq\n",
    "from bs4 import BeautifulSoup\n",
    "import html5lib\n",
    "import lxml\n",
    "import selenium\n",
    "import time\n",
    "from selenium import webdriver\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Settings\n",
    "start=\"20241202\" #Start one day previous to the one you want to start from\n",
    "end=\"20241211\"\n",
    "Crypto_Alt_Season=\"BTC\" #Crypto that i want to use as an indicator for my ALT season (default BTC)\n",
    "Crypto_to_invest=\"ETH\" #Crypto that i want to buy and seel\n",
    "Metric=\"Price\" #Metric of my Alt Season\n",
    "N_Crypto=50 #Number of Crypto i take into consideration for my ALT season (max 200)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function to get every date from a range\n",
    "def Print_every_day(start,end):\n",
    "    date=[]\n",
    "\n",
    "    month31=[1,3,5,7,8,10,12]\n",
    "    month30=[4,6,9,11]\n",
    "\n",
    "    year=int(start[:4])\n",
    "    month=int(start[4:6])\n",
    "    day=int(start[6:8])\n",
    "    \n",
    "    year_end=int(end[:4])\n",
    "    moth_end=int(end[4:6])\n",
    "    day_end=int(end[6:8])\n",
    "\n",
    "    while (year<year_end) or (year==year_end and month<moth_end) or (year==year_end and month==moth_end and day<day_end):\n",
    "\n",
    "\n",
    "        if year%4==0:#Check if it is a leap year\n",
    "\n",
    "            if month<12:#Check if I'm at the end of the month\n",
    "\n",
    "                if (month in month31): \n",
    "                    if day<31:\n",
    "                        day+=1\n",
    "                    else:\n",
    "                        month+=1\n",
    "                        day=1\n",
    "\n",
    "                elif (month in month30): \n",
    "                    if day<30:\n",
    "                        day+=1\n",
    "                    else:\n",
    "                        month+=1\n",
    "                        day=1\n",
    "\n",
    "                elif day<29: #February\n",
    "                    day+=1\n",
    "                else:\n",
    "                    month+=1\n",
    "                    day=1\n",
    "            else:\n",
    "                if day<31:\n",
    "                    day+=1\n",
    "                else:\n",
    "                    year+=1\n",
    "                    month=1\n",
    "                    day=1\n",
    "        else:\n",
    "            if month<12:\n",
    "\n",
    "                if (month in month31): \n",
    "                    if day<31:\n",
    "                        day+=1\n",
    "                    else:\n",
    "                        month+=1\n",
    "                        day=1\n",
    "\n",
    "                elif (month in month30): \n",
    "                    if day<30:\n",
    "                        day+=1\n",
    "                    else:\n",
    "                        month+=1\n",
    "                        day=1\n",
    "\n",
    "                elif day<28: \n",
    "                    day+=1\n",
    "                else:\n",
    "                    month+=1\n",
    "                    day=1\n",
    "            else:\n",
    "                if day<31:\n",
    "                    day+=1\n",
    "                else:\n",
    "                    year+=1\n",
    "                    month=1\n",
    "                    day=1\n",
    "\n",
    "\n",
    "        if day<10: #Check if I need to add a 0 in front of the number\n",
    "            day=str(day)\n",
    "            day=\"0\"+day\n",
    "        else:\n",
    "            day=str(day)\n",
    "\n",
    "        if month<10: #Check if I need to add a 0 in front of the month\n",
    "            month=str(month)\n",
    "            month=\"0\"+month\n",
    "        else:\n",
    "            month=str(month)\n",
    "        \n",
    "        year=str(year)\n",
    "\n",
    "        date.append(year+month+day) #Add my date to the date \n",
    "        #Reconvert in int so that i can do operation on them\n",
    "        year=int(year)\n",
    "        month=int(month)\n",
    "        day=int(day)\n",
    "    \n",
    "    return date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take the Data from the internet\n",
    "\n",
    "sleep_for=1 \n",
    "sleep=1\n",
    "Date=Print_every_day(start,end) \n",
    "\n",
    "#Cycle every page untill i get to the end\n",
    "for j in range(len(Date)):\n",
    "    \n",
    "    url=f\"https://coinmarketcap.com/historical/{Date[j]}/\"\n",
    "    driver=webdriver.Chrome()\n",
    "    driver.get(url)\n",
    "    time.sleep(sleep_for)\n",
    "    scroll_height = driver.execute_script(\"return document.body.scrollHeight;\")\n",
    "    screen_height = driver.execute_script(\"return window.screen.height;\") \n",
    "\n",
    "    \n",
    "    i=1\n",
    "    while True:\n",
    "        \n",
    "        step=screen_height * i\n",
    "        driver.execute_script(f\"window.scrollTo(0, {step});\")\n",
    "        i += 1\n",
    "        time.sleep(sleep)\n",
    "\n",
    "        \n",
    "        if step> scroll_height:\n",
    "            break\n",
    "\n",
    "    #Extract data from the html\n",
    "    html = driver.page_source \n",
    "    driver.quit()\n",
    "    soup=BeautifulSoup(html,\"html.parser\")\n",
    "    righe=soup.find_all(\"tr\",class_=\"cmc-table-row\")#Load all row of the table\n",
    "\n",
    "\n",
    "    Rank=[]\n",
    "    Ticket=[]\n",
    "    Market_Cap=[]\n",
    "    Vol=[]\n",
    "    Price=[]\n",
    "    Supply=[]\n",
    "    Change1h=[]\n",
    "    Change24h=[]\n",
    "    Change7d=[]\n",
    "    Historical_Data_1w=pd.DataFrame()\n",
    "\n",
    "\n",
    "\n",
    "    #Take all data that i need\n",
    "    for x in righe:\n",
    "        num=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sticky cmc-table__cell--sortable cmc-table__cell--left cmc-table__cell--sort-by__rank\")\n",
    "        Simbolo=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--left cmc-table__cell--sort-by__symbol\")\n",
    "        MC=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__market-cap\")\n",
    "        Volume=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__volume-24-h\")\n",
    "        PriceData=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__price\")\n",
    "        Circulating_Supply=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__circulating-supply\")\n",
    "        Change_1h=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__percent-change-1-h\")\n",
    "        Change_24h=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__percent-change-24-h\")\n",
    "        Change_7d=x.find(\"td\",class_=\"cmc-table__cell cmc-table__cell--sortable cmc-table__cell--right cmc-table__cell--sort-by__percent-change-7-d\")\n",
    "\n",
    "        num=num.text\n",
    "        if \"--\" in num:\n",
    "            num=num.replace(\"--\",\"\")\n",
    "            Rank.append(int(num))\n",
    "        else:\n",
    "            Rank.append(int(num))\n",
    "        \n",
    "        Simbolo=Simbolo.text\n",
    "        if \"--\" in Simbolo:\n",
    "            Simbolo=Simbolo.replace(\"--\",\"\")\n",
    "            Ticket.append(Simbolo)\n",
    "        else:\n",
    "            Ticket.append(Simbolo)\n",
    "\n",
    "        MC=MC.text\n",
    "        MC = MC.replace(',', '')\n",
    "        MC = MC.replace('$', '')\n",
    "        if \"--\" in MC:\n",
    "            MC=MC.replace(\"--\",\"\")\n",
    "            Market_Cap.append(MC)\n",
    "        else:\n",
    "            Market_Cap.append(float(MC))\n",
    "        \n",
    "        if Volume!=None:\n",
    "            Volume=Volume.text\n",
    "            Volume = Volume.replace(',', '')\n",
    "            Volume = Volume.replace('$', '')\n",
    "            if \"<\" in Volume:\n",
    "                Volume = Volume.replace('<', '')\n",
    "            if \">\" in Volume:\n",
    "                Volume = Volume.replace('>', '')\n",
    "            if \"--\" in Volume:\n",
    "                Volume=Volume.replace(\"--\",\"\")\n",
    "                Vol.append(Volume)\n",
    "            else:\n",
    "                Vol.append(float(Volume))\n",
    "        else:\n",
    "            Vol.append(None)\n",
    "\n",
    "        PriceData=PriceData.text\n",
    "        PriceData = PriceData.replace(',', '')\n",
    "        PriceData = PriceData.replace('$', '')\n",
    "        if \"--\" in PriceData:\n",
    "            PriceData=PriceData.replace(\"--\",\"\")\n",
    "            Price.append(PriceData)\n",
    "        else:\n",
    "            Price.append(float(PriceData))\n",
    "\n",
    "        Circulating_Supply=Circulating_Supply.text\n",
    "        Circulating_Supply = Circulating_Supply.replace('.', '')\n",
    "        \n",
    "        Circulating_Supply = Circulating_Supply.replace('*', '')\n",
    "        Circulating_Supply = Circulating_Supply.replace(Simbolo, '')\n",
    "        if \"--\" in Circulating_Supply:\n",
    "            Circulating_Supply=Circulating_Supply.replace(\"--\",\"\")\n",
    "            Supply.append(Circulating_Supply)\n",
    "        else:\n",
    "            Supply.append(float(Circulating_Supply))\n",
    "\n",
    "\n",
    "        Change_1h=Change_1h.text\n",
    "        Change_1h = Change_1h.replace(',', '.')\n",
    "        Change_1h = Change_1h.replace('%', '')\n",
    "        if \"<\" in Change_1h:\n",
    "            Change_1h = Change_1h.replace('<', '')\n",
    "        if \">\" in Change_1h:\n",
    "            Change_1h = Change_1h.replace('>', '')\n",
    "        if \"--\" in Change_1h:\n",
    "            Change_1h=Change_1h.replace(\"--\",\"\")\n",
    "            Change1h.append(Change_1h)\n",
    "        else:\n",
    "            if len(Change_1h)>=8:#To account for changes 1.046,36% so that i can format them\n",
    "                Change_1h=Change_1h.replace(\".\",\"\")\n",
    "                Change_1h=(float(Change_1h))/100 #Now it would be something like 104636, so i divide by 100 to get the original value\n",
    "                Change1h.append(Change_1h)\n",
    "            else:\n",
    "                Change1h.append(float(Change_1h))\n",
    "\n",
    "        Change_24h=Change_24h.text\n",
    "        Change_24h = Change_24h.replace(',', '.')\n",
    "        Change_24h = Change_24h.replace('%', \"\")\n",
    "        if \"<\" in Change_24h:\n",
    "            Change_24h = Change_24h.replace('<', '')\n",
    "        if \">\" in Change_24h:\n",
    "            Change_24h = Change_24h.replace('>', '')\n",
    "        if \"--\" in Change_24h:\n",
    "            Change_24h = Change_24h.replace('--', \"\")\n",
    "            Change24h.append(Change_24h)\n",
    "        else:\n",
    "            if len(Change_24h)>=8:\n",
    "                Change_24h=Change_24h.replace(\".\",\"\")\n",
    "                Change_24h=(float(Change_24h))/100\n",
    "                Change24h.append(Change_24h)\n",
    "            else:\n",
    "                Change24h.append(float(Change_24h))\n",
    "  \n",
    "        Change_7d=Change_7d.text\n",
    "        Change_7d = Change_7d.replace(',', '.')\n",
    "        Change_7d = Change_7d.replace('%', '')\n",
    "        if \"<\" in Change_7d:\n",
    "            Change_7d = Change_7d.replace('<', \"\")\n",
    "        if \">\" in Change_7d:\n",
    "            Change_7d = Change_7d.replace('>', '')\n",
    "        if \"--\" in Change_7d:\n",
    "            Change_7d = Change_7d.replace('--', \"\")\n",
    "            Change7d.append(Change_7d)\n",
    "        else:\n",
    "            if len(Change_7d)>=8:\n",
    "                Change_7d=Change_7d.replace(\".\",\"\")\n",
    "                Change_7d=(float(Change_7d))/100 \n",
    "                Change7d.append(Change_7d)\n",
    "            else:\n",
    "                Change7d.append(float(Change_7d))\n",
    "            \n",
    "        #Put everything inside a dataframe, and then inside a csv\n",
    "        Historical_Data_1w=pd.DataFrame({\"Rank\":Rank,\"Symbol\":Ticket,\"Market Cap\":Market_Cap,\"Volume\":Vol,\"Price\":Price,  \n",
    "                                 \"Circulating\":Supply,\"1h Variation\":Change1h,\"24h Variation\":Change24h,\"7d Variation\":Change7d})\n",
    "        Historical_Data_1w.to_csv(f\"Hystorical_Data_CoinMarketCap/{Date[j]}.csv\") \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"5\">Create the  of Assets that i need to eliminate from my ALT season index</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "url=\"https://coinmarketcap.com/view/stablecoin/\"\n",
    "Information=rq.get(url)\n",
    "\n",
    "soup=BeautifulSoup(Information.content,\"html.parser\")\n",
    "\n",
    "\n",
    "rw1=soup.find_all(\"tr\",style=\"cursor:pointer\")\n",
    "rw2=soup.find_all(\"tr\",class_=\"sc-240ce903-0 iPeVVh\")\n",
    "\n",
    "Ticket=[]\n",
    "\n",
    "\n",
    "for x in rw1:\n",
    "    Symbol=x.find(\"div\",class_=\"sc-e8147118-3 jcakMR\")#sc-1c5f2868-3 hHWqgz was the old class_\n",
    "    \n",
    "    Ticket.append(Symbol.text)\n",
    "\n",
    "for x in rw2:\n",
    "    \n",
    "    Symbol=x.find(\"span\",class_=\"crypto-symbol\") #Questo è quello giusto\n",
    "    Ticket.append(Symbol.text)\n",
    "\n",
    "Stable_Coin=pd.Series(Ticket)\n",
    "Stable_Coin.to_csv(\"Stable_Coin_and_Asset_Backed_Token/Stable Coin List.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sleep=1\n",
    "#Take the data of asset-backed crypto\n",
    "url=\"https://www.coingecko.com/en/categories/asset-backed-tokens\"\n",
    "\n",
    "driver=webdriver.Chrome()\n",
    "driver.get(url)\n",
    "\n",
    "scroll_height = driver.execute_script(\"return document.body.scrollHeight;\")\n",
    "screen_height = driver.execute_script(\"return window.screen.height;\") \n",
    "\n",
    "\n",
    "i=1\n",
    "while True:\n",
    "    \n",
    "    step=screen_height * i\n",
    "    driver.execute_script(f\"window.scrollTo(0, {step});\")\n",
    "    i += 1\n",
    "    time.sleep(sleep)\n",
    "\n",
    "    \n",
    "    if step> scroll_height:\n",
    "        break\n",
    "\n",
    "    \n",
    "\n",
    "html = driver.page_source \n",
    "driver.quit()\n",
    "\n",
    "\n",
    "soup=BeautifulSoup(html,\"html.parser\")\n",
    "\n",
    "\n",
    "righe=soup.find_all(\"tr\",class_=\"hover:tw-bg-gray-50 tw-bg-white dark:tw-bg-moon-900 hover:dark:tw-bg-moon-800 tw-text-sm\")\n",
    "\n",
    "\n",
    "Ticket=[]\n",
    "\n",
    "#Take every data i need from each row of the table\n",
    "for x in righe:\n",
    "    Simbolo=x.find(\"div\",class_=\"tw-block 2lg:tw-inline tw-text-xs tw-leading-4 tw-text-gray-500 dark:tw-text-moon-200 tw-font-medium\")\n",
    "    Simbolo=Simbolo.text\n",
    "\n",
    "    MarketCap=x.find(\"td\",class_=\"tw-text-end tw-px-1 tw-py-2.5 2lg:tw-p-2.5 tw-bg-inherit tw-text-gray-900 dark:tw-text-moon-50\")\n",
    "    \n",
    "\n",
    "    Simbolo_Finale=\"\"\n",
    "    for ln in range(len(Simbolo)):\n",
    "        \n",
    "        dummy=\"\"\n",
    "\n",
    "        if ln>2 and ln<range(len(Simbolo))[-1] and Simbolo[ln]!=\"\":\n",
    "            dummy = Simbolo[ln]\n",
    "\n",
    "        Simbolo_Finale+=dummy\n",
    "    \n",
    "    Ticket.append(Simbolo_Finale)\n",
    "\n",
    "Ticket=Ticket[:32] #Take only the first 32, since the rest dont even have a Market Cap, i know that it is a bad way of solving this problem, but it works just fine \n",
    "print(Ticket)\n",
    "\n",
    "\n",
    "Assets_Backed_Token=pd.Series(Ticket)\n",
    "Assets_Backed_Token.to_csv(\"Stable_Coin_and_Asset_Backed_Token/Asset Backed Token List.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"5\">Calculate the Alt Season</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math as mt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Per prima cosa mi trovo la lista di tutte le crypto che mi sono state in top, nella mia serie di dati\n",
    "def Find_Unique_Crypto(start,end,Number_Of_Crypto):\n",
    "    Date=Print_every_day(start,end)\n",
    "    Crypto_ticket=pd.Series()\n",
    "    for d in Date:\n",
    "        Data_Extracted=pd.read_csv(f\"Hystorical_Data_CoinMarketCap/{d}.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "        Crypto_ticket=pd.concat([Crypto_ticket,Data_Extracted[\"Symbol\"][:Number_Of_Crypto]],ignore_index=True)\n",
    "        \n",
    "    \n",
    "    Crypto_ticket=list(set(Crypto_ticket)) #I make it a set so that it has only unique value, then i make it a list in case i need to do operations on it\n",
    "    Crypto_ticket=pd.Series(Crypto_ticket)\n",
    "\n",
    "    Crypto_ticket.drop(Crypto_ticket.index[pd.isna(Crypto_ticket)==True],inplace=True) #Delete nan values\n",
    "    \n",
    "    return Crypto_ticket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "Date=Print_every_day(start,end)\n",
    "Crypto_ticket=Find_Unique_Crypto(\"20130427\",end,N_Crypto)#I put a fixed start so that i can easily concatenate my dataset\n",
    "Data_R=Date\n",
    "print(Data_R[-1])\n",
    "\n",
    "Empty_Data=['20131031', '20140107', '20140122', '20140329', '20141002', '20141212', '20150110', '20150228', '20150918', '20170710', '20210407', '20210408']\n",
    "\n",
    "try:\n",
    "    for ed in Empty_Data:\n",
    "        Data_R.remove(ed)\n",
    "    print(Data_R)\n",
    "except:\n",
    "    \"\" \n",
    "\n",
    "\n",
    "#Load the list of Stable Coin and Asset Backed Crypto since i dont want to use them when calculating the ALT season\n",
    "Stable_Coin=pd.read_csv(\"Stable_Coin_and_Asset_Backed_Token/Stable Coin List.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "Asset_Backed_Crypto=pd.read_csv(\"Stable_Coin_and_Asset_Backed_Token/Asset Backed Token List.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "\n",
    "\n",
    "\n",
    "Historical_Data_Of_Interest=pd.DataFrame()\n",
    "\n",
    "\n",
    "\n",
    "for t in Crypto_ticket:\n",
    "    Data_Of_Interest=[]\n",
    "    N_Crypto=50\n",
    "    Break_out=False\n",
    "\n",
    "\n",
    "    for d in Data_R:\n",
    "\n",
    "        if (Stable_Coin.index[Stable_Coin[\"0\"]==t].size>0) or (Asset_Backed_Crypto.index[Asset_Backed_Crypto[\"0\"]==t].size>0): \n",
    "            Break_out=True\n",
    "            break\n",
    "        \n",
    "            \n",
    "        Data_Extracted=pd.read_csv(f\"Hystorical_Data_CoinMarketCap/{d}.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "\n",
    "\n",
    "        \n",
    "        \n",
    "\n",
    "        if t in list(Data_Extracted[\"Symbol\"]):\n",
    "            ser=Data_Extracted[Metric].iloc[Data_Extracted.index[Data_Extracted[\"Symbol\"]==t]]#Take the Metric of the crypto I'm checking\n",
    "            ser=float(ser.iloc[0])\n",
    "            \n",
    "            Data_Of_Interest.append(ser)\n",
    "        else:\n",
    "            Data_Of_Interest.append(None)\n",
    "        \n",
    "    #Concatenate the dataset\n",
    "    if Break_out==False:\n",
    "        Historical_Data_Of_Interest_Dummy=pd.DataFrame({t:Data_Of_Interest},index=Data_R)\n",
    "        Historical_Data_Of_Interest=pd.concat([Historical_Data_Of_Interest,Historical_Data_Of_Interest_Dummy],axis=1)\n",
    "\n",
    "#Order them in alphabetical order in order to concatenate them with the dataset\n",
    "Historical_Data_Of_Interest.sort_index(axis=1,inplace=True)\n",
    "\n",
    "Old_price=pd.read_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Metric}.csv\",index_col=\"Unnamed: 0\") \n",
    "#Concat wit the old dataframe\n",
    "Historical_Data=pd.concat([Old_price,Historical_Data_Of_Interest])\n",
    "#Put inside a csv\n",
    "Historical_Data.to_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Metric}.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Apply the pct change and put inside a csv\n",
    "shift=90\n",
    "Historical_Data=Historical_Data.pct_change(periods=shift)*100\n",
    "Historical_Data.to_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Metric}_pct_change.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a table that for each days, orders the name of the cryptos in ascending order by the metric of interest\n",
    "Stable_Coin=pd.read_csv(\"Stable_Coin_and_Asset_Backed_Token/Stable Coin List.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "Asset_Backed_Crypto=pd.read_csv(\"Stable_Coin_and_Asset_Backed_Token/Asset Backed Token List.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "\n",
    "\n",
    "All_Date=Print_every_day(\"20130428\",end)\n",
    "Empty_Data=['20131031', '20140107', '20140122', '20140329', '20141002', '20141212', '20150110', '20150228', '20150918', '20170710', '20210407', '20210408']\n",
    "try:\n",
    "    for ed in Empty_Data:\n",
    "        All_Date.remove(ed)\n",
    "except:\n",
    "    \"\" \n",
    "\n",
    "Historical_Data.index=All_Date \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Historical_Data_Of_Interest_ordered_Ticket=pd.DataFrame()\n",
    "\n",
    "\n",
    "for d in All_Date:\n",
    "\n",
    "    Data_Extracted=pd.read_csv(f\"Hystorical_Data_CoinMarketCap/{d}.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "\n",
    "    Data_Extracted=Data_Extracted[\"Symbol\"]\n",
    "    Data_Extracted=[x for x in Data_Extracted.values if (x not in Stable_Coin.values and x not in Asset_Backed_Crypto.values)]\n",
    "    \n",
    "    Data_Extracted_TOP=Data_Extracted[:N_Crypto]\n",
    "\n",
    "\n",
    "    H_I_D_O_I_key_sort_TOP=[]\n",
    "    H_I_D_O_I_dict=Historical_Data.loc[d]\n",
    "    H_I_D_O_I_dict=dict(H_I_D_O_I_dict) \n",
    "    H_I_D_O_I_keys=list(H_I_D_O_I_dict.keys()) \n",
    "    H_I_D_O_I_values=list(H_I_D_O_I_dict.values()) \n",
    "    \n",
    "    \n",
    "    H_I_D_O_I_value_index_ordered=np.argsort(H_I_D_O_I_values) \n",
    "    H_I_D_O_I_dict_sort={H_I_D_O_I_keys[i]: H_I_D_O_I_values[i] for i in H_I_D_O_I_value_index_ordered} \n",
    "\n",
    "    \n",
    "    H_I_D_O_I_key_sort=list(H_I_D_O_I_dict_sort.keys())\n",
    "    \n",
    "    H_I_D_O_I_key_sort_TOP=[x for x in H_I_D_O_I_key_sort if x in Data_Extracted_TOP]\n",
    "\n",
    "    \n",
    "    Historical_Data_Of_Interest_ordered_Ticket_Dummy=pd.DataFrame(data=H_I_D_O_I_key_sort_TOP,columns=[d])\n",
    "    Historical_Data_Of_Interest_ordered_Ticket=pd.concat([Historical_Data_Of_Interest_ordered_Ticket,Historical_Data_Of_Interest_ordered_Ticket_Dummy],axis=1)\n",
    "\n",
    "\n",
    "\n",
    "#Put inside a CSV\n",
    "Historical_Data_Of_Interest_ordered_Ticket.to_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Metric}_pct_change_ordered_ticket.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#I load the data of the variation of tickets during time, and then i find the variation of the ticket i want\n",
    "H_D_O_I_final=pd.read_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Metric}_pct_change_ordered_ticket.csv\").drop(\"Unnamed: 0\",axis=1)\n",
    "\n",
    "\n",
    "\n",
    "value_altSeason=[]\n",
    "Dummy_to_use={}\n",
    "for d in H_D_O_I_final.columns:\n",
    "    \n",
    "    if len(H_D_O_I_final[d].index[H_D_O_I_final[d]==Crypto_Alt_Season])!=0:#Make sure that in that day there actually is the ticket i'm searching\n",
    "        value_altSeason.append(H_D_O_I_final[d].index[H_D_O_I_final[d]==Crypto_Alt_Season][0])\n",
    "        Dummy_to_use[d]=value_altSeason[-1]\n",
    "    else:\n",
    "        value_altSeason.append(None)\n",
    "        Dummy_to_use[d]=value_altSeason[-1]\n",
    "Dummy_to_use=pd.Series(Dummy_to_use)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#I put the value on a scale from 1 to 100\n",
    "Alt_Season=Dummy_to_use*100/len(H_D_O_I_final)#This might not be the best method, but that's the one i'm using\n",
    "\n",
    "\n",
    "\n",
    "#Since they are ordered in ascending order, if BTC has a higher return, it will be at the bottom, \n",
    "#But i want that when BTC is at the bottom it should be BCT season (so BTC is performing well)\n",
    "Alt_Season=Alt_Season.apply(lambda x: mt.sqrt((float(x)-100)**2)) #A more mathematical method to get abs, instead of just using the function\n",
    "\n",
    "\n",
    "#Put inside a csv\n",
    "Alt_Season.to_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Crypto_Alt_Season}_{Metric}_Alt_Season.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take the Data to plot them\n",
    "\n",
    "Alt_Season_Index_ToPrint=Alt_Season\n",
    "Label=[]\n",
    "for ind in range(0,len(Alt_Season_Index_ToPrint),22):\n",
    "    Label.append(Alt_Season.index[ind])\n",
    "\n",
    "Label.append(Alt_Season.index[-1])\n",
    "\n",
    "Label_Restricted=Label[-20:]\n",
    "\n",
    "yticks=[0,20,25,40,60,75,80,100]\n",
    "fig,ax =plt.subplots(1,1,figsize=(200,9),sharex=True,facecolor=\"gray\",dpi=200,sharey=False)\n",
    "\n",
    "\n",
    "ax.plot(Alt_Season.index,Alt_Season,color=\"green\")\n",
    "ax.set(title=\"Alt Season Index Price\",xlabel=\"Date (1g)\",ylabel=f\"Position {Crypto_Alt_Season}\")\n",
    "ax.set_yticks(ticks=yticks)\n",
    "ax.set_xticks(ticks=Label)\n",
    "ax.get_yticklabels()[2].set_color(\"blue\")\n",
    "ax.get_yticklabels()[5].set_color(\"orange\")\n",
    "ax.hlines(y=75,color=\"orange\",linestyles=\"dashed\",xmin=1,xmax=4099)\n",
    "ax.hlines(y=25,color=\"blue\",linestyles=\"dashed\",xmin=1,xmax=4099)\n",
    "ax.grid()\n",
    "\n",
    "print(\"The Current Value of the ALT season is: \",Alt_Season[-1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "<font size=\"5\">Buy and Sell (and example on how this code might be used)</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "Alt_Season_Index_Price=pd.read_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Crypto_to_invest}_{Metric}_Alt_Season.csv\",index_col=\"Unnamed: 0\")\n",
    "BTC_Alt_Season_Index_Price=pd.read_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/BTC_{Metric}_Alt_Season.csv\",index_col=\"Unnamed: 0\")\n",
    "Price=pd.read_csv(f\"Alt_Season_With_{N_Crypto}_Cryptos/{Metric}.csv\",index_col=\"Unnamed: 0\")\n",
    "Price.index=Price.index.astype(\"string\")\n",
    "Alt_Season_Index_Price.index=Alt_Season_Index_Price.index.astype(\"string\")\n",
    "BTC_Alt_Season_Index_Price.index=BTC_Alt_Season_Index_Price.index.astype(\"string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulate a strategy where i Buy and Sell ETH when in between BTC and ALT season\n",
    "Capital=1000\n",
    "Fees=0.001#In percentage\n",
    "First_Time=False\n",
    "Crypto_Hold=0\n",
    "All_Capital=[]\n",
    "date_label=[]\n",
    "BTC_value_buy=[] \n",
    "BTC_value_sell=[]\n",
    "Range=-300 #It goes way back than just 300 days\n",
    "\n",
    "Starting_date=0\n",
    "count_30=0 #It check if 30 days have passed or not, so that i can periodic capital\n",
    "Capital_to_add=100\n",
    "Added=0 \n",
    "for d in BTC_Alt_Season_Index_Price.index[Range:]:\n",
    "    count_30+=1 \n",
    "    \n",
    "\n",
    "    #Buy\n",
    "    if (BTC_Alt_Season_Index_Price[\"0\"].loc[d]<75 and BTC_Alt_Season_Index_Price[\"0\"].loc[d]>25) and Capital!=0 and (mt.isnan(Price[Crypto_to_invest].loc[d])==False):\n",
    "        \n",
    "        Prezzo=Price[Crypto_to_invest].loc[d]\n",
    "       \n",
    "        Crypto_Hold=Capital/Prezzo\n",
    "        \n",
    "        Crypto_Hold=Crypto_Hold-(Crypto_Hold*Fees)#Simulate fees\n",
    "        Capital=0\n",
    "        print(\"Buy\",d)\n",
    "\n",
    "    #Sell\n",
    "    if (BTC_Alt_Season_Index_Price[\"0\"].loc[d]>=80 or BTC_Alt_Season_Index_Price[\"0\"].loc[d]<=20) and Crypto_Hold!=0 and (mt.isnan(Price[Crypto_to_invest].loc[d])==False):\n",
    "        \n",
    "        Prezzo=Price[Crypto_to_invest].loc[d]\n",
    "        Capital=Crypto_Hold*Prezzo\n",
    "        Capital=Capital-(Capital*Fees)#Simulate fees\n",
    "        Crypto_Hold=0\n",
    "        All_Capital.append(Capital)\n",
    "        date_label.append(d)\n",
    "        print(\"Sell\",d)\n",
    "    \n",
    "    \n",
    "    if Crypto_Hold!=0 and count_30%30==0:\n",
    "        Added+=1\n",
    "        Crypto_Hold+=Capital_to_add/Price[Crypto_to_invest].loc[d]-(Capital_to_add/Price[Crypto_to_invest].loc[d]*Fees)\n",
    "        print(\"ADD+++++\",d)  \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#Initialize 2 variable that i use to see how much money i would have made if i just had holded BTC for the same time period\n",
    "Capital_Holding=1000\n",
    "Date_since_not_null=Alt_Season_Index_Price.index[(Alt_Season_Index_Price[\"0\"]).isnull()==False]#Find the first non nan date for the crypto i'm buying (usefull for everything except BTC since it has the longest duration out of all cryptos)\n",
    "First_Price=Price[Crypto_to_invest].loc[Date_since_not_null[Range]]\n",
    "Last_Price=Price[Crypto_to_invest].loc[BTC_Alt_Season_Index_Price.index[-1]]\n",
    "Holding=Capital_Holding/First_Price\n",
    "Holding=Holding-(Holding*Fees)#Simulate Fees\n",
    "Capital_Holding=Holding*Last_Price\n",
    "Capital_Holding=Capital_Holding-(Capital_Holding*Fees)#Simulate Fees\n",
    "\n",
    "print(\"Capital Hold\",Capital_Holding)#Capitale i would have if i just holded BTC\n",
    "print(\"End Capital\", All_Capital[-1])#Print the capital i had\n",
    "print(\"Earn not realized\",Crypto_Hold*Price[Crypto_to_invest].loc[d]-All_Capital[-1])\n",
    "print(\"Total added during time\", Added*Capital_to_add)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Output the strategy\n",
    "fig,ax=plt.subplots(1,1,figsize=(60,10),sharex=True)\n",
    "sns.lineplot(y=Holding*Price[Crypto_to_invest],x=Price.index,ax=ax)\n",
    "sns.lineplot(y=All_Capital,x=date_label,ax=ax)\n",
    "Label_y=[]\n",
    "for d in range(0,len(date_label),4):\n",
    "    Label_y.append(date_label[d])\n",
    "Label_y.append(Price.index[-1])\n",
    "ax.set_xticks(ticks=Label_y)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".VirtualEnviromentCrypto",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}