app.py

app.py

@@ -4,7 +4,7 @@ import pandas as pd
 import plotly.graph_objs as go
 import time
 
-# Fallback data in case both APIs fail
+# Fallback data for demonstration purposes
 fallback_historical_data = {
     'bitcoin': [
         [1633046400000, 42000], [1633132800000, 42250], [1633219200000, 41500],
@@ -18,205 +18,133 @@ fallback_current_prices = {
     'binancecoin': 380
 }
 
-# Function to fetch historical price data from CoinGecko with retry logic
+# Function to fetch historical price data from CoinGecko
 def fetch_historical_data(coin_id, from_timestamp, to_timestamp):
     url = f"https://api.coingecko.com/api/v3/coins/{coin_id}/market_chart/range?vs_currency=usd&from={from_timestamp}&to={to_timestamp}"
-    for _ in range(3):  # Retry 3 times before failing
-        try:
-            response = requests.get(url, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            prices = data['prices']
-            return prices
-        except requests.exceptions.RequestException:
-            time.sleep(1)  # Wait 1 second before retrying
-    return fallback_historical_data.get(coin_id, f"Error fetching historical data for {coin_id}")
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        return data['prices']
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching historical data: {e}")
+        return fallback_historical_data.get(coin_id, f"Error fetching historical data for {coin_id}")
 
-# Function to fetch current prices from CoinGecko and fallback to CryptoCompare
+# Function to fetch current prices with fallback
 def fetch_current_price(coin_id):
     gecko_url = f"https://api.coingecko.com/api/v3/simple/price?ids={coin_id}&vs_currencies=usd"
     compare_url = f"https://min-api.cryptocompare.com/data/price?fsym={coin_id.upper()}&tsyms=USD"
 
-    # First, try CoinGecko API
-    for _ in range(3):  # Retry 3 times before failing
-        try:
-            response = requests.get(gecko_url, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            return data[coin_id]['usd']
-        except requests.exceptions.RequestException:
-            time.sleep(1)
-
-    # If CoinGecko fails, try CryptoCompare API
     try:
-        response = requests.get(compare_url, timeout=10)
+        response = requests.get(gecko_url, timeout=10)
         response.raise_for_status()
         data = response.json()
-        return data['USD']
-    except requests.exceptions.RequestException:
-        # Return fallback data if both APIs fail
-        return fallback_current_prices.get(coin_id, f"Error fetching current price for {coin_id}")
+        return data[coin_id]['usd']
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching CoinGecko price: {e}")
+        
+        # Try CryptoCompare if CoinGecko fails
+        try:
+            response = requests.get(compare_url, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            return data['USD']
+        except requests.exceptions.RequestException as e2:
+            print(f"Error fetching CryptoCompare price: {e2}")
+            return fallback_current_prices.get(coin_id, "Price not available")
 
-# Function to convert dates to timestamps
+# Convert date string to timestamp
 def date_to_timestamp(date_str):
     return int(pd.Timestamp(date_str).timestamp())
 
 # Function to plot historical prices using Plotly
 def plot_historical_prices(coin_name, from_date, to_date):
-    from_timestamp = date_to_timestamp(from_date)
-    to_timestamp = date_to_timestamp(to_date)
-    
-    prices = fetch_historical_data(coin_name, from_timestamp, to_timestamp)
-    
-    if isinstance(prices, str):  # In case of error (fallback or API error)
-        return prices
-    
-    df = pd.DataFrame(prices, columns=['timestamp', 'price'])
-    df['date'] = pd.to_datetime(df['timestamp'], unit='ms')
-    
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df['date'], y=df['price'], mode='lines', name=coin_name))
-    fig.update_layout(title=f'{coin_name.capitalize()} Prices from {from_date} to {to_date}', xaxis_title='Date', yaxis_title='Price (USD)')
-    return fig
-
-# Function to provide TradingView widget HTML
-def tradingview_widget():
-    widget_html = """
-    <iframe 
-        src="https://www.tradingview.com/widgetembed/?frameElementId=tradingview_ea33b&symbol=BINANCE:BTCUSDT&interval=60" 
-        width="800" 
-        height="600" 
-        frameborder="0" 
-        allowtransparency="true" 
-        scrolling="no" 
-        allowfullscreen="true">
-    </iframe>
-    """
-    return widget_html
-
-# Function to analyze order book data (mocked for demo)
-def analyze_order_book():
-    return "Order book analysis: Buying pressure above, selling pressure below."
-
-# Function to analyze technical indicators (mocked for demo)
-def analyze_technicals():
-    return "Technical analysis: Divergence detected, RSI showing overbought."
-
-# Function to analyze funding rates (mocked for demo)
-def analyze_funding_rate():
-    return "Funding rate: Higher on longs, suggesting bullish sentiment."
-
-# Function to analyze on-chain metrics (mocked for demo)
-def analyze_on_chain():
-    return "On-chain analysis: Ichimoku cloud shows potential reversal."
-
-# Function to fetch and analyze news sentiment (mocked for demo)
-def analyze_news():
-    return "News analysis: Positive sentiment with increasing institutional interest."
-
-# Function to combine all AI BTC analysis into one output
+    try:
+        from_timestamp = date_to_timestamp(from_date)
+        to_timestamp = date_to_timestamp(to_date)
+        
+        prices = fetch_historical_data(coin_name, from_timestamp, to_timestamp)
+        
+        if isinstance(prices, str):
+            return prices
+        
+        df = pd.DataFrame(prices, columns=['timestamp', 'price'])
+        df['date'] = pd.to_datetime(df['timestamp'], unit='ms')
+        
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=df['date'], y=df['price'], mode='lines', name=coin_name))
+        fig.update_layout(title=f'{coin_name.capitalize()} Prices', xaxis_title='Date', yaxis_title='Price (USD)')
+        return fig
+    except Exception as e:
+        return f"Error in plotting chart: {e}"
+
+# Function to analyze BTC (mock data)
 def btc_analysis():
-    order_book = analyze_order_book()
-    technicals = analyze_technicals()
-    funding_rate = analyze_funding_rate()
-    on_chain = analyze_on_chain()
-    news = analyze_news()
-    
-    return f"""
-    {order_book}
-    {technicals}
-    {funding_rate}
-    {on_chain}
-    {news}
-    """
-
-# Function to fetch real-time trade data from CoinGecko (with retry and backup logic)
+    try:
+        return "BTC Analysis: Market is bullish with increasing buying pressure."
+    except Exception as e:
+        return f"Error in BTC analysis: {e}"
+
+# Function to fetch real-time trade data
 def fetch_real_time_trade_data(coin_id):
-    fallback_data = {
-        'bitcoin': [1633039200000, 42000],
-        'ethereum': [1633039200000, 3100],
-        'binancecoin': [1633039200000, 380],
-    }
+    fallback_data = {'bitcoin': [1633039200000, 42000]}
     
     gecko_url = f"https://api.coingecko.com/api/v3/coins/{coin_id}/market_chart?vs_currency=usd&days=1"
-    compare_url = f"https://min-api.cryptocompare.com/data/price?fsym={coin_id.upper()}&tsyms=USD"
     
-    # First, try CoinGecko API
-    for _ in range(3):  # Retry 3 times before failing
-        try:
-            response = requests.get(gecko_url, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            return data['prices'][-1]  # Latest price data
-        except requests.exceptions.RequestException:
-            time.sleep(1)
-
-    # If CoinGecko fails, try CryptoCompare API
     try:
-        response = requests.get(compare_url, timeout=10)
+        response = requests.get(gecko_url, timeout=10)
         response.raise_for_status()
         data = response.json()
-        return [None, data['USD']]
-    except requests.exceptions.RequestException:
-        # If both APIs fail, return fallback data
-        return fallback_data.get(coin_id, f"Error fetching real-time trade data for {coin_id}")
+        return data['prices'][-1]  # Latest price data
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching trade data: {e}")
+        return fallback_data.get(coin_id, "Trade data not available")
 
 # Function to display real-time trade data
 def real_time_trade_dashboard(coin):
-    data = fetch_real_time_trade_data(coin)
-    if isinstance(data, str):  # In case of error
-        return data
-    return f"The latest trading data for {coin.capitalize()} is: ${data[1]}"
-
-# Top 100 Cryptocurrencies (by CoinGecko IDs)
-top_100_cryptos = [
-    'bitcoin', 'ethereum', 'binancecoin', 'ripple', 'solana', 'cardano', 'dogecoin', 'polygon', 'polkadot', 'tron',
-]
-
-# Gradio Interface Setup
+    try:
+        data = fetch_real_time_trade_data(coin)
+        return f"The latest trade data for {coin.capitalize()}: ${data[1]}"
+    except Exception as e:
+        return f"Error in real-time trade dashboard: {e}"
 
-# AI BTC Analysis Interface
+# Gradio Interfaces
 btc_analysis_interface = gr.Interface(
     fn=btc_analysis,
     inputs=[],
     outputs=gr.Textbox(label="BTC Analysis"),
-    title="AI-Powered BTC Analysis"
+    title="BTC Market Analysis"
 )
 
-# TradingView Interface for live charts
-tradingview_interface = gr.Interface(
-    fn=tradingview_widget,
-    inputs=[],
-    outputs=gr.HTML(label="TradingView Chart"),
-    title="Live TradingView Chart"
-)
-
-# Real-time Trade Data Interface
 real_time_trade_interface = gr.Interface(
     fn=real_time_trade_dashboard,
-    inputs=gr.Dropdown(choices=top_100_cryptos, label="Cryptocurrency"),
+    inputs=gr.Dropdown(choices=['bitcoin', 'ethereum'], label="Cryptocurrency"),
     outputs=gr.Textbox(label="Real-Time Trade Data"),
-    title="Real-Time Cryptocurrency Trade Data"
+    title="Real-Time Trade Data"
 )
 
-# Price Chart Interface
 crypto_price_chart_interface = gr.Interface(
     fn=plot_historical_prices,
     inputs=[
-        gr.Dropdown(choices=top_100_cryptos, label="Cryptocurrency"),
+        gr.Dropdown(choices=['bitcoin', 'ethereum'], label="Cryptocurrency"),
         gr.Textbox(value="2024-01-01", label="From Date (YYYY-MM-DD)"),
         gr.Textbox(value="2025-12-31", label="To Date (YYYY-MM-DD)")
     ],
-    outputs=gr.Plot(label="Cryptocurrency Price Chart"),
-    title="Cryptocurrency Price Chart (2024-2025)"
+    outputs=gr.Plot(label="Price Chart"),
+    title="Cryptocurrency Price Chart"
 )
 
-# Current Price Interface
 current_price_interface = gr.Interface(
     fn=fetch_current_price,
-    inputs=gr.Dropdown(choices=top_100_cryptos, label="Cryptocurrency"),
+    inputs=gr.Dropdown(choices=['bitcoin', 'ethereum'], label="Cryptocurrency"),
     outputs=gr.Textbox(label="Current Price"),
-    title="Current Cryptocurrency Price"
+    title="Current Price"
+)
+
+# Launch Gradio app
+app = gr.TabbedInterface(
+    [btc_analysis_interface, real_time_trade_interface, crypto_price_chart_interface, current_price_interface],
+    ["BTC Analysis", "Real-Time Trade Data", "Price Chart", "Current Price"]
 )
 
-# Combining all interfaces into a single
+app.launch()