Initial commit

README.md

@@ -0,0 +1,11 @@
+<<<<<<< HEAD
+# cryptoind
+index for crypto assets
+=======
+---
+title: crypto_index
+app_file: index_interface.py
+sdk: gradio
+sdk_version: 4.24.0
+---
+>>>>>>> 99c909b (Initial commit)

cryptoindex.py

@@ -0,0 +1,151 @@
+from polygon import RESTClient
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+
+def calc_dates(date: datetime = datetime.now()) -> tuple:
+    this_year = date - timedelta(days=date.day-1)
+    one_year = this_year + timedelta(days=-365)
+    return (one_year.strftime("%Y-%m-%d"), this_year.strftime("%Y-%m-%d"))
+
+
+def do_sharpe(ser, days=True):
+    mins_in_year = 60 * 24 * 365
+    days_in_year = 365
+    if days:
+        themean = ser.pct_change().mean() * days_in_year
+        thestd = ser.pct_change().std() * np.sqrt(days_in_year)
+        
+    else:
+        themean = ser.pct_change().mean() * mins_in_year
+        thestd = ser.pct_change().std() * np.sqrt(mins_in_year)
+    sharpe = themean/thestd 
+    return themean, thestd, sharpe, format_output(themean, thestd, sharpe)
+
+
+def format_output(mymean, mystandarddeviation, mysharpe):
+    output = f"""
+    | Metric             | Value                |
+    |--------------------|----------------------|
+    | Mean               | {mymean:.2f}         |
+    | Standard Deviation | {mystandarddeviation:.2f} |
+    | Sharpe-Rivin             | {mysharpe:.3f}       |
+    """
+    return output
+
+api_key="BBRlVSAOiNqeJ77yjnveFBqZZTOFv2gN"
+
+import pandas as pd
+from polygon import RESTClient
+client = RESTClient(api_key)
+
+def get_ticker_trade(ticker: str):
+    coinname = ticker[2:-3]
+    thetrade = client.get_last_crypto_trade(coinname, "USD")
+    return thetrade.price
+
+def update_df(last_day):
+    last_day["price"] = last_day.ticker.map(get_ticker_trade)
+    weights = last_day.weight
+    return np.average(last_day.price, weights = weights)
+
+def get_daily_bars(ticker:str, dete = datetime.now()):
+    thedate = dete.strftime("%Y-%m-%d")
+    bars = client.get_aggs(ticker=ticker, multiplier=1, timespan="minute", from_= thedate, to=thedate, limit=50000)
+    thedf = pd.DataFrame(bars)[['timestamp', "close"]]
+    thedf.set_index(pd.to_datetime(thedf.timestamp, unit='ms'), inplace = True)
+    thedf.drop("timestamp", axis = 1, inplace = True)
+    thedf.rename({"close": ticker}, axis = 1, inplace = True)
+    return thedf
+
+def update_day(last_day, func =np.sqrt):
+    dflist = []
+    for ticker in last_day.ticker:
+        dflist.append(get_daily_bars(ticker))
+    newdf = pd.concat(dflist, axis = 1)
+    oldind = newdf.index
+    last_day_r = last_day.reset_index(drop=True)
+    newdf_r = newdf.reset_index(drop=True)
+    close_column = last_day['close']
+    #newdf_r = newdf_r.div(close_column, axis=0)
+    newdf_r.index = oldind
+
+    newdf_r["indprice"] = newdf_r.apply(lambda x: np.average(x, weights=func(last_day.weight)), axis = 1)
+    return newdf_r.indprice.ffill()
+
+etfs = ['VOO','SOXL','TQQQ','LQD','HYG','QQQ', 'IVV','SPY', 'IWM', 'DJI', 'IXIC', 'VIX', 'TLT', 'IEF', 'GLD', 'SLV', 'USO', 'UNG', 
+        'VXX', 'FXE', 'FXY', 'FXB', 'FXA', 'FXC', 'FXF', 'XAU', 'XAG', 'XPT', 'XPD', 'XME', 'XHB', 'XLF', 'XLY', 'XLC', 'XLI', 'XLE', 
+        'XLV', 'XLP', 'XLRE', 'XLK', 'XLU', 'XLC', 'XLB', 'XITK', 'XNTK', 'XNWK', 'XNGK']
+def fetch_crypto_data(start_date, end_date, *, locale = 'global', market_type = 'crypto'):
+    # Generate the date range
+    dates = pd.date_range(start=start_date, end=end_date, freq='D')
+
+    all_data = []
+    for date in dates:
+        formatted_date = date.strftime('%Y-%m-%d')
+        daily_data = pd.DataFrame(client.get_grouped_daily_aggs(formatted_date, locale=locale, market_type=market_type))
+        all_data.append(daily_data)
+
+    newdata =  pd.concat(all_data)
+    if market_type == 'crypto':
+        newdata= newdata[newdata['ticker'].str.endswith('USD')]
+    elif market_type == 'stocks':
+        newdata= newdata[~newdata['ticker'].isin(etfs)]
+    else:
+        pass
+    newdata["totalvol"] =  newdata.volume*newdata.close
+    newdata["totalvol2"] =  newdata.volume/newdata.close
+    # Sort the data by timestamp to ensure correct EMA calculation
+    newdata.sort_values(by='timestamp', inplace=True)
+
+    # Calculate the EMA of the `totalvol` column
+    # `span` is set to 30 for a 30-day EMA
+    newdata['totalvol_ema'] = newdata.groupby('ticker')['totalvol'].transform(lambda x: x.ewm(span=30, adjust=False).mean())
+    newdata['totalvol2_ema'] = newdata.groupby('ticker')['totalvol2'].transform(lambda x: x.ewm(span=30, adjust=False).mean())
+    return newdata
+
+# Example usage
+#start_date = '2020-01-01'
+#end_date = '2024-03-27'
+#crypto_data = fetch_crypto_data(start_date, end_date)
+
+
+def get_crypto_index(crypto_data, howmany = 20, func = lambda x: x):
+
+    ser = pd.Series(np.ones(howmany)).map(func)
+    p = pd.Series(np.ones(howmany))
+    valdict = {}
+    dfdict = {}
+    crypto_data.sort_values('timestamp', inplace = True, ascending = True)
+    for d, df in crypto_data.groupby('timestamp'):
+        df = df[df.open > 0.01]
+        df = df.sort_values('totalvol_ema', ascending=False).head(howmany)
+        #indopen =np.average(df.open/p, weights = ser)
+        indopen = np.average(df.open.values, weights=ser.values)
+        #indclose =np.average(df.close/p, weights = ser)
+        indclose = np.average(df.close.values, weights=ser.values)
+        ser = df.totalvol_ema.map(func)
+        p  = df.close
+        valdict[d] = {'open': indopen, 'close': indclose}
+        dfdict[d] = pd.DataFrame({'ticker':df.ticker, 'weight':ser, 'close': df.close})
+
+    first_key = next(iter(valdict))
+    del valdict[first_key]
+    del dfdict[first_key]
+    vals = pd.DataFrame(valdict).T
+    vals.index = pd.to_datetime(vals.index, unit = 'ms')
+    vallist  =[]
+    for key, val in dfdict.items():
+        val['date'] = pd.to_datetime(key, unit = 'ms')
+        vallist.append(val)
+    dfs = pd.concat(vallist)
+    return vals, dfs
+
+def update_weights(fname="/tmp/wts.csv", **kwargs):
+    start_date, end_date = calc_dates()
+    crypto_data = fetch_crypto_data(start_date, end_date, **kwargs)
+    _, dfs = get_crypto_index(crypto_data)
+    retval = dfs[dfs.date == dfs.date.max()]
+    retval.to_csv(fname, index = False)
+    return retval

index_interface.py

@@ -0,0 +1,89 @@
+import gradio as gr
+import plotly.express as px
+from cryptoindex import *
+import pandas as pd
+from updater import *
+from time import sleep
+from functools import partial
+import argparse
+
+
+last_start_date = None
+last_end_date = None
+is_current = False
+v = None
+t = 0
+real_time_data = None
+is_historical = False
+
+update_weights1()
+
+""" def mytimer(interval=60):
+    while True:
+        print("Timer: ", t)
+        t += 1
+        sleep(interval)
+
+threading.Thread(target=mytimer, daemon=True).start()
+ """
+
+def plot_index_prices(start_date, end_date, **kwargs):
+    global last_start_date, last_end_date, is_current, v
+
+    if start_date != last_start_date or end_date != last_end_date:
+        last_start_date = start_date
+        last_end_date = end_date
+        is_current = False 
+
+    if not is_current:
+        cryptodf = fetch_crypto_data(start_date = start_date, end_date = end_date, **kwargs)
+        v, _ = get_crypto_index(cryptodf, func = np.sqrt)
+        is_current = True
+    _, _, _, output = do_sharpe(v.close)
+    fig = px.line(v, x=v.index, y='close', title='Index Prices')
+    fig.update_xaxes(rangeslider_visible=True)
+    return fig, output
+
+def realtime_update_weighted_prices(fname="/tmp/wts.csv"):
+    if should_update_weights():
+        # If it's time to update the weights, spawn a thread to do so
+        threading.Thread(target=update_weights1, daemon=True).start()
+    last_day = pd.read_csv(fname, parse_dates=["date"])
+    prices = update_day(last_day)
+    _, _, _, output = do_sharpe(prices, days = False)
+    fig = px.line(prices, x=prices.index, y=prices.values, title='Index Today')
+    return fig, output
+   
+def make_graph(choice, start_date = None, end_date = None, fname = "/tmp/wts.csv", **kwargs):
+    if choice == "Historical":
+        fig,stats = plot_index_prices(start_date, end_date, **kwargs)
+        
+    else:
+        fig, stats =realtime_update_weighted_prices(fname)
+    
+    return gr.Plot(fig), gr.Markdown(stats)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_file" , default="/tmp/wts.csv", help="Weights for realtime computation")
+    parser.add_argument("--locale", default = 'global', help="the locale")
+    parser.add_argument("--market_type", default = 'crypto', help="the market type")
+    parser.add_argument("--share", action = "store_true", help="share the interface")
+    args = parser.parse_args()
+    make_graph_flex = partial(make_graph, fname = args.data_file, locale = args.locale, market_type = args.market_type)
+    update_weights1(fname=args.data_file, locale = args.locale, market_type = args.market_type)
+    with gr.Blocks() as iface:  # Use () for context manager
+    
+        
+        startdatebox = gr.Textbox(label="Start Date")
+        enddatebox = gr.Textbox(label="End Date")
+        radio = gr.Radio(choices=["Historical", "Real-time"], label="graph type")
+        update_button = gr.Button("Update Graph")  # Add a button to trigger the graph update
+
+
+
+        theplot = gr.Plot()
+        thestats = gr.Markdown()
+        radio.change(fn = make_graph_flex, inputs = [radio, startdatebox, enddatebox], outputs = [theplot, thestats])
+        update_button.click(fn = make_graph_flex, inputs = [radio, startdatebox, enddatebox], outputs = [theplot, thestats])
+        iface.launch(share=args.share)

updater.py

@@ -0,0 +1,25 @@
+import datetime
+import threading 
+from cryptoindex import update_weights
+
+
+# Global variable to track when the weights were last updated
+last_update = None
+
+def update_weights1(**kwargs):
+    update_weights(**kwargs)
+    # Your logic to update weights goes here
+    print("Weights updated.")
+    global last_update
+    last_update = datetime.datetime.now()
+
+def should_update_weights():
+    global last_update
+    current_time = datetime.datetime.now()
+    
+    # Check if the current time is within the first 10 seconds after midnight
+    # and the last update wasn't today
+    if current_time.time() < datetime.time(0, 2, 0) and (last_update is None or current_time.date() > last_update.date()):
+        return True
+    return False
+