Update app.py

app.py

@@ -1,6 +1,7 @@
 
-import yfinance as yf
+import streamlit as st
 from datetime import datetime, timedelta
+import yfinance as yf
 import numpy as np
 import pandas as pd
 from sklearn.decomposition import PCA
@@ -11,7 +12,7 @@ import matplotlib.pyplot as plt
 
 class DataFetcher:
     """Fetches historical financial data using yfinance."""
-    def __init__(self, ticker, nb_days):
+    def __init__(self, ticker, nb_days=50):
         self.ticker = ticker
         self.nb_days = nb_days
         self.data = None
@@ -21,7 +22,6 @@ class DataFetcher:
         end_date = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
         start_date = end_date - timedelta(days=self.nb_days)
         end_date = end_date + timedelta(days=1)
-        print(f"Fetching data from {start_date} to {end_date}")
         self.data = yf.download(self.ticker, start=start_date, end=end_date, interval="1h")
 
 class FinancialDataProcessor:
@@ -111,9 +111,9 @@ class StrategyBuilder:
     def analyze_feature_importance(self, shap_values, feature_names):
         """Analyzes feature importance based on SHAP values."""
         if isinstance(shap_values, list):
-            shap_values = shap_values[1]  # Use second class for binary classification
+            shap_values = shap_values[1]
 
-        if len(shap_values.shape) == 3:  # Handle multi-output cases
+        if len(shap_values.shape) == 3:
             shap_values = shap_values[:, :, 1]
 
         mean_abs_shap = np.mean(np.abs(shap_values), axis=0)
@@ -126,8 +126,6 @@ class StrategyBuilder:
             'Mean_Abs_SHAP': mean_abs_shap
         }).sort_values(by='Mean_Abs_SHAP', ascending=False)
 
-        print("Feature Importance based on Shapley Values:")
-        print(feature_importance)
         return feature_importance
 
     def refine_thresholds(self, feature_importance, buy_threshold=0.5, sell_threshold=0.5):
@@ -149,9 +147,14 @@ class Backtester:
         position = None
         entry_price = None
         portfolio_values = []
+        positions = []
+        entry_prices = []
 
         for i in range(1, len(self.data)):
             last_row = self.data.iloc[i]
+            prev_position = position
+            prev_entry_price = entry_price
+
             if (last_row['PCA_Scenario'] == 'Buy' and last_row['PCA_Buy%'] > buy_threshold) or \
                (last_row['Scenario'] == 'Buy' and last_row['Buy%'] > buy_threshold):
                 if position != 'Buy':
@@ -169,12 +172,19 @@ class Backtester:
                 portfolio_value *= (entry_price / last_row['Close'])
 
             portfolio_values.append(portfolio_value)
+            positions.append(prev_position)
+            entry_prices.append(prev_entry_price)
+
+        return portfolio_values, position, entry_price, positions[-1], entry_prices[-1]
 
-        return portfolio_values, position, entry_price
+# Streamlit interface
+st.set_page_config(page_title="Crypto Trading Bot", layout="wide")
+st.title("Real-Time Crypto Trading Analysis")
 
-def main():
+def run_analysis():
     try:
-        fetcher = DataFetcher(ticker="BTC-USD", nb_days=200)
+        ticker = "BTC-USD"  # Fixed to BTC-USD
+        fetcher = DataFetcher(ticker=ticker)
         fetcher.fetch_data()
 
         processor = FinancialDataProcessor(fetcher.data)
@@ -192,33 +202,53 @@ def main():
         buy_threshold, sell_threshold = strategy_builder.refine_thresholds(feature_importance)
 
         backtester = Backtester(processed_data)
-        portfolio_values, final_position, entry_price = backtester.backtest(buy_threshold, sell_threshold)
+        portfolio_values, current_position, current_entry, prev_position, prev_entry = backtester.backtest(buy_threshold, sell_threshold)
 
         last_row = processed_data.iloc[-1]
-        print("\n=== Final Position and Market Values ===")
-        print(f"Final Portfolio Value: ${portfolio_values[-1]:.2f}")
-        print(f"Current Position: {final_position or 'No position'}")
-        if final_position:
-            print(f"Entry Price: ${entry_price:.2f}")
-        print(f"Latest Close Price: ${last_row['Close']:.2f}")
-        print("\nDecision Metrics:")
-        print(f"Buy%: {last_row['Buy%']:.4f} | Sell%: {last_row['Sell%']:.4f}")
-        print(f"PCA_Buy%: {last_row['PCA_Buy%']:.4f} | PCA_Sell%: {last_row['PCA_Sell%']:.4f}")
-        print(f"Applied Thresholds - Buy: {buy_threshold:.2f}, Sell: {sell_threshold:.2f}")
-
-        plt.figure(figsize=(12, 6))
-        plt.plot(processed_data.index[1:], portfolio_values, label='Portfolio Value', color='blue')
-        plt.title('Portfolio Value Over Time (Backtest)')
-        plt.xlabel('Date')
-        plt.ylabel('Portfolio Value ($)')
-        plt.legend()
-        plt.grid()
-        plt.show()
+        prev_row = processed_data.iloc[-2]
+
+        # Display current status
+        st.header("Current Status")
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.subheader("Position Info")
+            st.metric("Current Position", current_position or "No position")
+            st.metric("Previous Position", prev_position or "No position")
+            if current_entry:
+                st.metric("Current Entry Price", f"${current_entry:.2f}")
+            if prev_entry:
+                st.metric("Previous Entry Price", f"${prev_entry:.2f}")
+
+        with col2:
+            st.subheader("Current Bar")
+            st.metric("Close Price", f"${last_row['Close']:.2f}")
+            st.metric("Buy Signal", f"{last_row['Buy%']:.4f}")
+            st.metric("Sell Signal", f"{last_row['Sell%']:.4f}")
+
+        with col3:
+            st.subheader("Previous Bar")
+            st.metric("Close Price", f"${prev_row['Close']:.2f}")
+            st.metric("Buy Signal", f"{prev_row['Buy%']:.4f}")
+            st.metric("Sell Signal", f"{prev_row['Sell%']:.4f}")
+
+        # Portfolio Performance
+        st.header("Portfolio Performance")
+        st.metric("Current Portfolio Value", f"${portfolio_values[-1]:.2f}")
+        st.metric("Return", f"{((portfolio_values[-1] - 10000) / 10000 * 100):.2f}%")
+
+        # Feature importance
+        st.header("Strategy Analysis")
+        st.dataframe(feature_importance)
 
     except Exception as e:
-        print(f"An error occurred: {e}")
-        import traceback
-        traceback.print_exc()
+        st.error(f"An error occurred: {str(e)}")
+
+# Run analysis automatically on page load
+run_analysis()
 
-if __name__ == "__main__":
-    main()
+# Auto-refresh every 5 minutes
+st.empty()
+st.markdown("*Data updates automatically every 5 minutes*")
+if st.button("Refresh Now"):
+    run_analysis()