update app.py

app.py

@@ -1,16 +1,16 @@
-"""MineROI-Net Gradio App - Updated to use complete historical blockchain data"""
-
 import gradio as gr
 import pandas as pd
 import plotly.graph_objects as go
-from datetime import datetime, timedelta
+from datetime import datetime
 import os
-from miner_specs import MINER_SPECS, get_miner_list, ELECTRICITY_RATES
-from fetch_blockchain_data import get_blockchain_data_for_date, load_complete_blockchain_data
+
 from preprocessing import get_latest_sequence
-from electricity_prices import get_electricity_rate
 from predictor import MineROIPredictor
-from fetch_asic_prices import fetch_asic_price_for_date, FALLBACK_PRICES
+from fetch_blockchain_data import get_latest_blockchain_data
+
+# internal dummy miner used only for age_days etc. (not shown in UI)
+DEFAULT_MINER_NAME = "s19pro"
+
 
 MODEL_PATH = "best_model_weights.pth"
 
@@ -26,91 +26,90 @@ def init_predictor():
 
 
 def init_app():
-    """Initialize app - load complete blockchain data into memory"""
+    """Initialize app (no need for local blockchain_data_complete.csv)."""
     print("\n" + "="*80)
     print("🚀 INITIALIZING MINEROI-NET APP")
     print("="*80)
-    
-    # Load complete blockchain data into memory (one-time)
-    complete_df = load_complete_blockchain_data()
-    
-    if complete_df is not None:
-        print(f"\n✅ Complete blockchain data loaded successfully!")
-        print(f"   {len(complete_df):,} days available")
-        print(f"   Date range: {complete_df['date'].min().date()} to {complete_df['date'].max().date()}")
-        print(f"\n✅ You can now predict for ANY date in this range!")
-    else:
-        print(f"\n⚠️  WARNING: blockchain_data_complete.csv not found!")
-        print(f"   App will work with limited recent data only")
-        print(f"\n📥 To enable full historical predictions:")
-        print(f"   1. Run: python download_complete_blockchain_data.py")
-        print(f"   2. Upload blockchain_data_complete.csv to your Gradio space")
-    
+    print("\nUsing live blockchain.com data (last 90 days).")
+    print("Model will use the latest 30 days for ROI prediction.")
     print("="*80 + "\n")
-    
-    # Initialize predictor
     init_predictor()
 
 
-def predict_roi(miner_name,region,prediction_date,machine_price,machine_hashrate,machine_power,machine_efficiency,electricity_rate):
-    """Make prediction for a specific date"""
+
+def predict_roi(machine_price, machine_hashrate, machine_power, machine_efficiency, electricity_rate):
+    """
+    Real-time prediction:
+    - Uses latest 90 days from blockchain.com
+    - Model uses last 30 days
+    - Scaler chosen based on electricity_rate:
+        < 0.05  -> ethiopia scaler
+        0.05-0.09 -> china scaler
+        > 0.09 -> texas scaler
+    """
     try:
         window_size = 30
-        
-        # Convert prediction_date to datetime
-        if isinstance(prediction_date, str):
-            prediction_date = datetime.strptime(prediction_date, '%Y-%m-%d')
 
+        # -------- parse user inputs --------
         miner_price = float(machine_price)
         miner_hashrate = float(machine_hashrate)
         machine_power = float(machine_power)
         machine_efficiency = float(machine_efficiency)
         electricity_rate = float(electricity_rate)
 
-        print(f"User machine specs:")
+        print("User machine specs:")
         print(f"  Price:           {miner_price}")
         print(f"  Hashrate (TH/s): {miner_hashrate}")
         print(f"  Power (W):       {machine_power}")
         print(f"  Efficiency:      {machine_efficiency}")
         print(f"  Elec rate:       {electricity_rate} USD/kWh")
-        
-        print(f"\n{'='*80}")
-        print(f"PREDICTION REQUEST")
-        print(f"{'='*80}")
-        print(f"Miner: {miner_name}")
-        print(f"Region: {region}")
-        print(f"Date: {prediction_date.date()}")
-        print(f"{'='*80}\n")
-        
-        # Get blockchain data for this specific date (30 days before + target date)
-        print(f"📡 Fetching blockchain data for {prediction_date.date()}...")
-        blockchain_df = get_blockchain_data_for_date(prediction_date, window_size=window_size)
-        
+
+        # -------- choose scaler region from electricity_rate --------
+        if electricity_rate < 0.05:
+            scaler_region = "ethiopia"
+            region_bucket = "Low-cost (< $0.05/kWh)"
+        elif electricity_rate <= 0.09:
+            scaler_region = "china"
+            region_bucket = "Medium-cost ($0.05–$0.09/kWh)"
+        else:
+            scaler_region = "texas"
+            region_bucket = "High-cost (> $0.09/kWh)"
+
+        print("\n" + "=" * 80)
+        print("PREDICTION REQUEST")
+        print("=" * 80)
+        print(f"Scaler region (from electricity rate): {scaler_region}")
+        print("=" * 80 + "\n")
+
+        # -------- fetch latest blockchain data (no date input) --------
+        print("📡 Fetching latest blockchain data (last 90 days)...")
+        blockchain_df = get_latest_blockchain_data(days=90)
+
         if blockchain_df is None or len(blockchain_df) < window_size:
             error_msg = f"""
             <div style='background: #e74c3c; color: white; padding: 20px; border-radius: 10px;'>
                 <h3 style='margin: 0;'>❌ Error: Insufficient Data</h3>
                 <p style='margin: 10px 0 0 0;'>
-                    Not enough blockchain data available for {prediction_date.date()}.
+                    Not enough blockchain data available.
                     Need at least {window_size} days of historical data.
                 </p>
             </div>
             """
             return error_msg, error_msg, None, None
-        
+
         print(f"✅ Got {len(blockchain_df)} days of data")
         print(f"   Date range: {blockchain_df['date'].min().date()} to {blockchain_df['date'].max().date()}")
-        
+
         price_source = "User input"
-        print(f"   Using user-provided price for {miner_name}: ${miner_price:,.2f}")
-        
-        # Get sequence (now uses blockchain_df which is date-specific)
-        print(f"\n🔧 Preparing features...")
-        sequence, _, pred_date = get_latest_sequence(
+        print(f"   Using user-provided price: ${miner_price:,.2f}")
+
+        # -------- build sequence with user machine specs --------
+        print("\n🔧 Preparing features...")
+        sequence, df_window, pred_date = get_latest_sequence(
             blockchain_df,
-            miner_name,
+            DEFAULT_MINER_NAME,          # internal dummy miner, not shown to user
             miner_price,
-            region,
+            scaler_region,
             window_size,
             machine_hashrate=miner_hashrate,
             power=machine_power,
@@ -118,38 +117,38 @@ def predict_roi(miner_name,region,prediction_date,machine_price,machine_hashrate
             electricity_rate=electricity_rate,
         )
         print(f"✅ Sequence prepared: {sequence.shape}")
-        
-        # Predict
-        print(f"\n🤖 Running prediction...")
-        result = predictor.predict(sequence, region)
+
+        # -------- model prediction --------
+        print("\n🤖 Running prediction...")
+        result = predictor.predict(sequence, scaler_region)
         print(f"✅ Prediction: {result['predicted_label']} ({result['confidence']:.1%})")
-        
-        # Create displays
+
+        # -------- build UI outputs --------
         miner_info = create_miner_info(
-            miner_name,
             miner_price,
-            region,
             price_source,
-            prediction_date,
+            pred_date,
             miner_hashrate,
             machine_power,
             machine_efficiency,
             electricity_rate,
+            region_bucket,
         )
-        prediction_html = warning_html + create_prediction_html(result, pred_date, window_size)
-        confidence_chart = create_confidence_chart(result['probabilities'])
+        prediction_html = create_prediction_html(result, pred_date, window_size)
+        confidence_chart = create_confidence_chart(result["probabilities"])
         price_chart = create_price_chart(blockchain_df, window_size)
-        
-        print(f"{'='*80}\n")
-        
+
+        print("=" * 80 + "\n")
+
         return miner_info, prediction_html, confidence_chart, price_chart
-        
+
     except Exception as e:
         import traceback
+
         error_details = traceback.format_exc()
-        print(f"\n❌ ERROR:")
+        print("\n❌ ERROR:")
         print(error_details)
-        
+
         error = f"""
         <div style='background: #e74c3c; color: white; padding: 20px; border-radius: 10px;'>
             <h3 style='margin: 0;'>❌ Prediction Error</h3>
@@ -159,24 +158,20 @@ def predict_roi(miner_name,region,prediction_date,machine_price,machine_hashrate
         return error, error, None, None
 
 
+
 def create_miner_info(
-    miner_name,
     price,
-    region,
     source,
-    prediction_date,
+    pred_date,
     machine_hashrate,
     machine_power,
     machine_efficiency,
     electricity_rate,
+    region_bucket,
 ):
     """
-    Display miner info using user-provided specs (price, hashrate, power, efficiency, elec rate).
-    We still use MINER_SPECS only to get the pretty full_name.
+    Display miner info for a user-specified machine (no ASIC dropdown).
     """
-    specs = MINER_SPECS[miner_name]
-    full_name = specs["full_name"]
-
     elec_rate = float(electricity_rate)
     daily_cost = (float(machine_power) * 24.0 / 1000.0) * elec_rate
 
@@ -190,7 +185,7 @@ def create_miner_info(
 
     return f"""
     <div style="background: #1e1e1e; padding: 20px; border-radius: 10px; border: 1px solid #333; color: #ffffff;">
-        <h3 style="color: #F7931A; margin-top: 0;">{full_name}</h3>
+        <h3 style="color: #F7931A; margin-top: 0;">Custom ASIC Miner</h3>
         <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px;">
             <div>
                 <p><strong>Hashrate:</strong> {machine_hashrate:.2f} TH/s</p>
@@ -199,13 +194,13 @@ def create_miner_info(
             </div>
             <div>
                 <p>
-                    <strong>Price ({prediction_date.date()}):</strong> ${price:,.2f}
+                    <strong>Price (as of {pred_date.date()}):</strong> ${price:,.2f}
                     <span style="background: {badge_color}; color: white; padding: 2px 8px; border-radius: 4px; font-size: 0.8em;">
                         {source}
                     </span>
                 </p>
-                <p><strong>Region:</strong> {region.title()}</p>
                 <p><strong>Electricity rate:</strong> {elec_rate:.4f} USD/kWh</p>
+                <p><strong>Cost bucket:</strong> {region_bucket}</p>
                 <p><strong>Estimated daily elec cost:</strong> ${daily_cost:,.2f}</p>
             </div>
         </div>
@@ -262,41 +257,21 @@ def create_price_chart(df, window):
 
 
 def create_interface():
-    # Default date: today
-    today = datetime.now().date()
-    
-    # Check if complete data is available to set min_date
-    complete_df = load_complete_blockchain_data()
-    if complete_df is not None:
-        min_date = complete_df['date'].min().date()
-        max_date = complete_df['date'].max().date()
-        date_info = f"{min_date} to {max_date}"
-    else:
-        min_date = datetime(2018, 1, 22).date()
-        max_date = today
-        date_info = "⚠️ Limited (complete data not loaded)"
-    
     with gr.Blocks(title="MineROI-Net") as app:
         gr.Markdown("# 🪙 MineROI-Net: Bitcoin Mining Hardware ROI Predictor")
-        # gr.Markdown("### Powered by Complete Historical Blockchain Data")
-        
+        gr.Markdown(
+            "Uses the **latest 30 days** of Bitcoin network data from blockchain.com "
+            "to classify your miner as Unprofitable / Marginal / Profitable."
+        )
+
         with gr.Row():
+            # ---- Left: inputs ----
             with gr.Column(scale=1):
                 gr.Markdown("### Configuration")
-                miner = gr.Dropdown(choices=sorted(get_miner_list()), value='s19pro', label="ASIC Miner")
-                region = gr.Dropdown(choices=['texas', 'china', 'ethiopia'], value='texas', label="Region")
-                
-                # Date picker for prediction date
-                prediction_date = gr.Textbox(
-                    label="📅 Prediction Date",
-                    value=str(today),
-                    info=f"Format: YYYY-MM-DD (e.g., 2024-12-08)",
-                    placeholder="2024-12-08",
-                    elem_classes="date-input"
-                )
+
                 machine_price = gr.Number(
                     label="Machine price (USD)",
-                    value=2500.0,  # you can choose a nicer default
+                    value=2500.0,
                     precision=2,
                 )
                 machine_hashrate = gr.Number(
@@ -316,31 +291,26 @@ def create_interface():
                 )
                 electricity_rate = gr.Number(
                     label="Electricity rate (USD/kWh)",
-                    value=ELECTRICITY_RATES["texas"],  # 0.1549 by default
+                    value=0.07,   # neutral default
                     precision=4,
                 )
-                
+
                 btn = gr.Button("🔮 Predict ROI", variant="primary", size="lg")
-                
-                gr.Markdown(f"""
-                ### About
-                - 🔴 **Unprofitable** (ROI ≤ 0)
-                - 🟡 **Marginal** (0 < ROI < 1)
-                - 🟢 **Profitable** (ROI ≥ 1)
-                
-                **Model:** 83.7% accuracy (30-day window)
-                
-                **Date Range:** {date_info}
-                
-                **Price Source:**
-                - 🟢 Green badge = Real API data
-                - 🔴 Red badge = Fallback estimate
-                
-                **Data Source:**
-                - Uses complete historical blockchain data
-                - Loaded at app startup for fast predictions
-                """)
-            
+
+                gr.Markdown(
+                    """
+                    ### About
+
+                    - 🔴 **Unprofitable** (ROI ≤ 0)  
+                    - 🟡 **Marginal** (0 < ROI < 1)  
+                    - 🟢 **Profitable** (ROI ≥ 1)  
+
+                    **Model:** trained on 30-day windows of Bitcoin network and miner features.  
+                    **Live mode:** whenever you click *Predict*, the app pulls the latest blockchain data.
+                    """
+                )
+
+            # ---- Right: outputs ----
             with gr.Column(scale=2):
                 gr.Markdown("### Results")
                 miner_info = gr.HTML()
@@ -348,13 +318,11 @@ def create_interface():
                 with gr.Row():
                     conf_plot = gr.Plot()
                     price_plot = gr.Plot()
-        
+
+        # Connect button to prediction function
         btn.click(
             fn=predict_roi,
             inputs=[
-                miner,
-                region,
-                prediction_date,
                 machine_price,
                 machine_hashrate,
                 machine_power,
@@ -363,10 +331,11 @@ def create_interface():
             ],
             outputs=[miner_info, prediction, conf_plot, price_plot],
         )
-    
+
     return app
 
 
+
 if __name__ == "__main__":
     # Initialize app (loads complete data into memory)
     init_app()