Prepare for HF Spaces deployment

app.py

@@ -0,0 +1,7 @@
+"""
+Hugging Face Spaces entry point
+This file is required for HF Spaces deployment
+"""
+from index_interface_supabase import *
+
+# The app will auto-launch when imported with iface.launch()

cryptoindex.py

@@ -35,7 +35,7 @@ def format_output(mymean, mystandarddeviation, mysharpe):
     return output
 
 import os
-api_key = os.getenv("POLYGON_KEY")
+api_key = os.getenv("POLYGON_API_KEY")
 
 import pandas as pd
 from polygon import RESTClient
@@ -149,4 +149,4 @@ def update_weights(fname="/tmp/wts.csv", **kwargs):
     _, dfs = get_crypto_index(crypto_data)
     retval = dfs[dfs.date == dfs.date.max()]
     retval.to_csv(fname, index = False)
-    return retval
+    return retval

index_interface_supabase.py

@@ -0,0 +1,233 @@
+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
+import os
+from supabase import create_client, Client
+from datetime import datetime
+import hashlib
+import json
+import uuid
+from dotenv import load_dotenv
+
+load_dotenv()
+
+supabase_url = os.getenv("SUPABASE_URL", "")
+supabase_key = os.getenv("SUPABASE_KEY", "")
+
+print(f"Supabase URL: {supabase_url[:30]}..." if supabase_url else "No Supabase URL")
+print(f"Supabase Key: {supabase_key[:20]}..." if supabase_key else "No Supabase Key")
+
+try:
+    supabase: Client = create_client(supabase_url, supabase_key) if supabase_url else None
+    if supabase:
+        # Test the connection
+        test_response = supabase.table('index_cache').select('id').limit(1).execute()
+        print("Supabase connection test successful")
+except Exception as e:
+    print(f"Supabase initialization error: {e}")
+    supabase = None
+
+
+def get_cache_key(start_date: str, end_date: str, locale: str, market_type: str) -> str:
+    """Generate a unique cache key for the given parameters."""
+    key_string = f"{start_date}_{end_date}_{locale}_{market_type}"
+    return hashlib.md5(key_string.encode()).hexdigest()
+
+
+def get_or_create_session(request: gr.Request) -> str:
+    """Get or create a session ID from the Gradio request."""
+    if hasattr(request, 'session_hash'):
+        return request.session_hash
+    return str(uuid.uuid4())
+
+
+def fetch_from_cache(cache_key: str):
+    """Fetch index data from Supabase cache."""
+    if not supabase:
+        print("Supabase client not initialized")
+        return None
+    
+    try:
+        print(f"Fetching cache for key: {cache_key}")
+        response = supabase.table('index_cache').select('*').eq('cache_key', cache_key).execute()
+        if response.data and len(response.data) > 0:
+            data = response.data[0]
+            v_data = pd.read_json(data['index_data'])
+            v_data.index = pd.to_datetime(v_data.index)
+            print(f"Cache hit for key: {cache_key}")
+            return v_data
+        else:
+            print(f"Cache miss for key: {cache_key}")
+    except Exception as e:
+        print(f"Cache fetch error: {e}")
+        print(f"Error type: {type(e)}")
+        if hasattr(e, 'response'):
+            print(f"Response: {e.response}")
+    
+    return None
+
+
+def save_to_cache(cache_key: str, v_data: pd.DataFrame, start_date: str, end_date: str, 
+                  locale: str, market_type: str):
+    """Save index data to Supabase cache."""
+    if not supabase:
+        return
+    
+    try:
+        cache_data = {
+            'cache_key': cache_key,
+            'start_date': start_date,
+            'end_date': end_date,
+            'locale': locale,
+            'market_type': market_type,
+            'index_data': v_data.to_json(),
+            'created_at': datetime.now().isoformat()
+        }
+        
+        supabase.table('index_cache').upsert(cache_data).execute()
+    except Exception as e:
+        print(f"Cache save error: {e}")
+
+
+def get_user_weights(session_id: str, locale: str, market_type: str):
+    """Get user-specific weights from Supabase."""
+    if not supabase:
+        return None
+    
+    try:
+        response = supabase.table('user_weights').select('*').eq('session_id', session_id).eq('locale', locale).eq('market_type', market_type).order('created_at', desc=True).limit(1).execute()
+        
+        if response.data and len(response.data) > 0:
+            weights_data = response.data[0]['weights_data']
+            return pd.read_json(weights_data)
+    except Exception as e:
+        print(f"Error fetching user weights: {e}")
+    
+    return None
+
+
+def save_user_weights(session_id: str, weights_df: pd.DataFrame, locale: str, market_type: str):
+    """Save user-specific weights to Supabase."""
+    if not supabase:
+        return
+    
+    try:
+        weights_data = {
+            'session_id': session_id,
+            'locale': locale,
+            'market_type': market_type,
+            'weights_data': weights_df.to_json(),
+            'created_at': datetime.now().isoformat()
+        }
+        
+        supabase.table('user_weights').insert(weights_data).execute()
+    except Exception as e:
+        print(f"Error saving user weights: {e}")
+
+
+def plot_index_prices(start_date, end_date, request: gr.Request, **kwargs):
+    """Plot historical index prices with caching."""
+    session_id = get_or_create_session(request)
+    locale = kwargs.get('locale', 'global')
+    market_type = kwargs.get('market_type', 'crypto')
+    
+    cache_key = get_cache_key(start_date, end_date, locale, market_type)
+    
+    v = fetch_from_cache(cache_key)
+    
+    if v is None:
+        cryptodf = fetch_crypto_data(start_date=start_date, end_date=end_date, **kwargs)
+        v, _ = get_crypto_index(cryptodf, func=np.sqrt)
+        save_to_cache(cache_key, v, start_date, end_date, locale, market_type)
+    
+    _, _, _, 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(request: gr.Request, locale='global', market_type='crypto'):
+    """Update real-time prices with user-specific weights."""
+    session_id = get_or_create_session(request)
+    
+    if should_update_weights():
+        weights_df = update_weights(locale=locale, market_type=market_type)
+        save_user_weights(session_id, weights_df, locale, market_type)
+    
+    last_day = get_user_weights(session_id, locale, market_type)
+    
+    if last_day is None:
+        weights_df = update_weights(locale=locale, market_type=market_type)
+        save_user_weights(session_id, weights_df, locale, market_type)
+        last_day = weights_df
+    
+    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, request: gr.Request = None, **kwargs):
+    """Create graph based on user choice."""
+    if choice == "Historical":
+        fig, stats = plot_index_prices(start_date, end_date, request, **kwargs)
+    else:
+        fig, stats = realtime_update_weighted_prices(request, **kwargs)
+    
+    return gr.Plot(fig), gr.Markdown(stats)
+
+
+def initialize_database():
+    """Initialize Supabase tables if they don't exist."""
+    if not supabase:
+        print("Supabase not configured. Running in local mode.")
+        return
+    
+    print("Supabase connected successfully!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    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()
+    
+    initialize_database()
+    
+    with gr.Blocks() as iface:
+        gr.Markdown("# Crypto Index Tracker (Supabase Edition)")
+        gr.Markdown("Each user session has isolated data and computations are cached.")
+        
+        startdatebox = gr.Textbox(label="Start Date", placeholder="YYYY-MM-DD")
+        enddatebox = gr.Textbox(label="End Date", placeholder="YYYY-MM-DD")
+        radio = gr.Radio(choices=["Historical", "Real-time"], label="Graph Type", value="Historical")
+        update_button = gr.Button("Update Graph")
+        
+        theplot = gr.Plot()
+        thestats = gr.Markdown()
+        
+        make_graph_partial = partial(make_graph, locale=args.locale, market_type=args.market_type)
+        
+        radio.change(
+            fn=make_graph_partial,
+            inputs=[radio, startdatebox, enddatebox],
+            outputs=[theplot, thestats]
+        )
+        
+        update_button.click(
+            fn=make_graph_partial,
+            inputs=[radio, startdatebox, enddatebox],
+            outputs=[theplot, thestats]
+        )
+    
+    # Detect if running on Hugging Face Spaces
+    if os.getenv("SPACE_ID"):
+        iface.launch()
+    else:
+        iface.launch(server_port=7860, server_name="0.0.0.0", share=args.share)

requirements.txt

@@ -0,0 +1,12 @@
+# Core dependencies
+gradio==4.19.2
+plotly==5.18.0
+pandas==2.1.4
+numpy==1.26.3
+polygon-api-client==1.13.6
+
+# Supabase integration
+supabase==2.3.0
+
+# Optional but recommended
+python-dotenv==1.0.0