1# Import required libraries
2import requests
3import pandas as pd
4import numpy as np
5import matplotlib.pyplot as plt
6import seaborn as sns
7from datetime import datetime, timedelta, timezone
8import json
9from typing import Optional, List
10
11# Set up plotting style
12plt.style.use('seaborn-v0_8')
13sns.set_palette("husl")
14plt.rcParams['figure.figsize'] = (12, 8)
15
16# CoinAPI configuration
17API_KEY = "YOUR_COINAPI_KEY_HERE"  # Replace with your actual API key
18BASE_URL = "https://rest.coinapi.io"
19
20print("✅ Environment setup complete!")
21print(f"📊 Using CoinAPI base URL: {BASE_URL}")
22print(f"🔑 API Key configured: {'Yes' if API_KEY != 'YOUR_COINAPI_KEY_HERE' else 'No (Please update)'}")

1def fetch_exchange_rate_data(asset_id_base: str, asset_id_quote: str, period_id: str, time_start: str, time_end: str) -> Optional[List[dict]]:
2    """
3    Fetch historical exchange rate data from CoinAPI
4    
5    Args:
6        asset_id_base: Base asset identifier (e.g., 'BTC')
7        asset_id_quote: Quote asset identifier (e.g., 'USDT')
8        period_id: Time period (e.g., '1HRS' for 1 hour)
9        time_start: Start time in ISO format
10        time_end: End time in ISO format
11    
12    Returns:
13        List of exchange rate data points with OHLC data
14    """
15    url = f"{BASE_URL}/v1/exchangerate/{asset_id_base}/{asset_id_quote}/history"
16    
17    params = {
18        'period_id': period_id,
19        'time_start': time_start,
20        'time_end': time_end,
21        'limit': 10000
22    }
23    
24    headers = {
25        'X-CoinAPI-Key': API_KEY
26    }
27    
28    try:
29        print(f"🔄 Fetching data from {url}")
30        print(f"📅 Time range: {time_start} to {time_end}")
31        
32        response = requests.get(url, params=params, headers=headers)
33        response.raise_for_status()
34        
35        data = response.json()
36        print(f"✅ Successfully fetched {len(data)} data points")
37        return data
38        
39    except requests.exceptions.RequestException as e:
40        print(f"❌ Error fetching data: {e}")
41        if hasattr(e, 'response') and e.response is not None:
42            print(f"Response status: {e.response.status_code}")
43            print(f"Response text: {e.response.text}")
44        return None
45
46print("📋 Data fetching function created successfully!")

1# Check if API key is configured
2if API_KEY == "YOUR_COINAPI_KEY_HERE":
3    print("❌ ERROR: Please set your CoinAPI key in the previous cell!")
4    print("🔗 Get your API key at: https://www.coinapi.io/")
5    print("📝 Replace 'YOUR_COINAPI_KEY_HERE' with your actual API key")
6else:
7    # Set up time range (last 7 days)
8    end_time = datetime.now(timezone.utc)
9    start_time = end_time - timedelta(days=7)
10    
11    # Format times for API
12    time_start = start_time.strftime('%Y-%m-%dT%H:%M:%S')
13    time_end = end_time.strftime('%Y-%m-%dT%H:%M:%S')
14    
15    # Fetch BTC/USDT data
16    asset_id_base = "BTC"
17    asset_id_quote = "USDT"
18    period_id = "1HRS"
19    
20    print(f"🎯 Fetching {asset_id_base}/{asset_id_quote} data")
21    print(f"⏱️  Period: {period_id}")
22    
23    exchange_rate_data = fetch_exchange_rate_data(asset_id_base, asset_id_quote, period_id, time_start, time_end)
24    
25    if exchange_rate_data:
26        print("\n📊 Sample data structure:")
27        print(json.dumps(exchange_rate_data[0], indent=2))
28    else:
29        print("\n❌ Failed to fetch data. Please check your API key and try again.")

1if 'exchange_rate_data' in locals() and exchange_rate_data:
2    # Convert to DataFrame
3    df = pd.DataFrame(exchange_rate_data)
4    
5    print(f"📈 DataFrame created with shape: {df.shape}")
6    print(f"📋 Columns: {list(df.columns)}")
7    
8    # Convert time columns to datetime
9    df['time_period_start'] = pd.to_datetime(df['time_period_start'])
10    df['time_period_end'] = pd.to_datetime(df['time_period_end'])
11    
12    # Rename columns for clarity
13    df = df.rename(columns={
14        'rate_open': 'open',
15        'rate_high': 'high',
16        'rate_low': 'low',
17        'rate_close': 'close'
18    })
19    
20    # Sort by time
21    df = df.sort_values('time_period_start')
22    
23    print("\n📊 First few rows:")
24    display(df.head())
25    
26    print("\n📋 Data types:")
27    print(df.dtypes)
28    
29    print("\n📈 Summary statistics:")
30    display(df[['open', 'high', 'low', 'close']].describe())
31    
32    # Check for missing values
33    print("\n🔍 Missing values check:")
34    missing_values = df.isnull().sum()
35    if missing_values.sum() > 0:
36        print(missing_values[missing_values > 0])
37    else:
38        print("✅ No missing values found!")
39        
40else:
41    print("❌ No data available for processing.")

1if 'df' in locals() and not df.empty:
2    print("🔢 Calculating volatility indicators...")
3    
4    # Basic volatility indicators
5    df['volatility'] = df['high'] - df['low']  # Price range
6    df['normalized_volatility'] = (df['high'] - df['low']) / df['close']  # Relative volatility
7    
8    # Calculate True Range (TR) for ATR
9    df['tr1'] = df['high'] - df['low']
10    df['tr2'] = abs(df['high'] - df['close'].shift(1))
11    df['tr3'] = abs(df['low'] - df['close'].shift(1))
12    df['true_range'] = df[['tr1', 'tr2', 'tr3']].max(axis=1)
13    
14    # Calculate ATR (14-period average)
15    df['atr'] = df['true_range'].rolling(window=14).mean()
16    
17    # Calculate volatility ratio (current vs historical average)
18    df['volatility_ratio'] = df['normalized_volatility'] / df['normalized_volatility'].rolling(window=20).mean()
19    
20    # Calculate simple moving averages
21    df['sma_20'] = df['close'].rolling(window=20).mean()
22    df['sma_50'] = df['close'].rolling(window=50).mean()
23    
24    print("✅ Volatility indicators calculation complete!")
25    
26    print("\n📊 Sample data with volatility indicators:")
27    display(df[['time_period_start', 'close', 'volatility', 'normalized_volatility', 'atr', 'volatility_ratio']].head(10))
28    
29    # Show volatility statistics
30    print("\n📈 Volatility Statistics:")
31    print(f"Average Volatility: ${df['volatility'].mean():.2f}")
32    print(f"Average Normalized Volatility: {df['normalized_volatility'].mean():.4f}")
33    print(f"Average ATR: ${df['atr'].mean():.2f}")
34    print(f"Average Volatility Ratio: {df['volatility_ratio'].mean():.2f}")
35    
36    # Show moving average statistics
37    print("\n📊 Moving Average Statistics:")
38    print(f"20-period SMA: ${df['sma_20'].iloc[-1]:.2f}")
39    print(f"50-period SMA: ${df['sma_50'].iloc[-1]:.2f}")
40    
41else:
42    print("❌ No data available for volatility calculation.")

1if 'df' in locals() and 'normalized_volatility' in df.columns:
2    print("📈 Analyzing price trends and volatility patterns...")
3    
4    # Calculate price trend direction
5    df['price_change'] = df['close'].diff()
6    df['price_trend'] = np.where(df['price_change'] > 0, 'Upward', 'Downward')
7    
8    # Handle the first row (no previous value)
9    df.loc[df.index[0], 'price_trend'] = 'No Change'
10    
11    # Identify volatility regimes
12    volatility_threshold = df['normalized_volatility'].quantile(0.75)  # 75th percentile
13    df['volatility_regime'] = np.where(df['normalized_volatility'] > volatility_threshold, 'High', 'Low')
14    
15    # Calculate trend statistics
16    trend_counts = df['price_trend'].value_counts()
17    volatility_counts = df['volatility_regime'].value_counts()
18    
19    print("✅ Trend analysis complete!")
20    
21    print(f"\n📊 Total periods analyzed: {len(df)}")
22    
23    print("\n📈 Price trend distribution:")
24    for trend, count in trend_counts.items():
25        percentage = (count / len(df)) * 100
26        print(f"  {trend}: {count} periods ({percentage:.1f}%)")
27    
28    print("\n📊 Volatility regime distribution:")
29    for regime, count in volatility_counts.items():
30        percentage = (count / len(df)) * 100
31        print(f"  {regime} Volatility: {count} periods ({percentage:.1f}%)")
32    
33    print("\n📋 Sample data with trend and volatility analysis:")
34    display(df[['time_period_start', 'close', 'price_change', 'price_trend', 'normalized_volatility', 'volatility_regime']].head(10))
35    
36    # Calculate average price change by trend
37    print("\n📊 Average price change by trend:")
38    trend_stats = df.groupby('price_trend')['price_change'].agg(['mean', 'std', 'count'])
39    display(trend_stats)
40    
41else:
42    print("❌ No data available for trend analysis.")

1if 'df' in locals() and not df.empty:
2    print("🎨 Creating comprehensive visualizations...")
3    
4    # Create a comprehensive visualization with 4 subplots
5    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(16, 12))
6    fig.suptitle('Price Trend Analysis with Volatility Indicators', fontsize=16, fontweight='bold')
7    
8    # Plot 1: Price with Moving Averages
9    ax1.plot(df['time_period_start'], df['close'], label='Close Price', linewidth=2, color='blue')
10    ax1.plot(df['time_period_start'], df['sma_20'], label='20-period SMA', linewidth=2, alpha=0.7, color='red')
11    ax1.plot(df['time_period_start'], df['sma_50'], label='50-period SMA', linewidth=2, alpha=0.7, color='green')
12    ax1.set_title('Price Trend with Moving Averages', fontweight='bold')
13    ax1.set_xlabel('Time')
14    ax1.set_ylabel('Price (USDT)')
15    ax1.legend()
16    ax1.grid(True, alpha=0.3)
17    
18    # Plot 2: Volatility
19    ax2.bar(df['time_period_start'], df['volatility'], alpha=0.7, color='lightblue')
20    ax2.set_title('Price Volatility Over Time', fontweight='bold')
21    ax2.set_xlabel('Time')
22    ax2.set_ylabel('Volatility (USDT)')
23    ax2.grid(True, alpha=0.3)
24    
25    # Plot 3: Normalized Volatility
26    ax3.plot(df['time_period_start'], df['normalized_volatility'], color='orange', linewidth=2)
27    ax3.axhline(y=df['normalized_volatility'].mean(), color='red', linestyle='--', alpha=0.7, label='Average')
28    ax3.set_title('Normalized Volatility Over Time', fontweight='bold')
29    ax3.set_xlabel('Time')
30    ax3.set_ylabel('Normalized Volatility')
31    ax3.legend()
32    ax3.grid(True, alpha=0.3)
33    
34    # Plot 4: ATR
35    ax4.plot(df['time_period_start'], df['atr'], color='green', linewidth=2)
36    ax4.set_title('Average True Range (ATR)', fontweight='bold')
37    ax4.set_xlabel('Time')
38    ax4.set_ylabel('ATR (USDT)')
39    ax4.grid(True, alpha=0.3)
40    
41    plt.tight_layout()
42    plt.show()
43    
44    print("✅ Main visualization complete!")
45    
46else:
47    print("❌ No data available for visualization.")

1if 'df' in locals() and not df.empty:
2    print("🎨 Creating trend and volatility correlation plot...")
3    
4    # Create trend and volatility correlation plot
5    plt.figure(figsize=(12, 8))
6    
7    # Color code by trend
8    colors = {'Upward': 'green', 'Downward': 'red', 'No Change': 'gray'}
9    
10    for trend in df['price_trend'].unique():
11        mask = df['price_trend'] == trend
12        plt.scatter(df[mask]['normalized_volatility'], df[mask]['price_change'], 
13                   c=colors[trend], label=trend, alpha=0.6, s=50)
14    
15    plt.xlabel('Normalized Volatility')
16    plt.ylabel('Price Change (USDT)')
17    plt.title('Price Change vs Volatility by Trend', fontweight='bold')
18    plt.legend()
19    plt.grid(True, alpha=0.3)
20    plt.show()
21    
22    print("✅ Correlation plot complete!")
23    
24else:
25    print("❌ No data available for correlation plot.")

1if 'df' in locals() and not df.empty:
2    print("📊 Performing comprehensive statistical analysis...")
3    
4    print("=" * 60)
5    print("PRICE TREND AND VOLATILITY ANALYSIS SUMMARY")
6    print("=" * 60)
7    
8    print(f"📅 Analysis Period: {df['time_period_start'].min()} to {df['time_period_start'].max()}")
9    print(f"📊 Total Data Points: {len(df)}")
10    
11    print("\n" + "=" * 40)
12    print("PRICE STATISTICS")
13    print("=" * 40)
14    print(f"💰 Starting Price: ${df['close'].iloc[0]:.2f}")
15    print(f"💰 Ending Price: ${df['close'].iloc[-1]:.2f}")
16    print(f"📈 Total Price Change: ${df['close'].iloc[-1] - df['close'].iloc[0]:.2f}")
17    print(f"📊 Percentage Change: {((df['close'].iloc[-1] / df['close'].iloc[0]) - 1) * 100:.2f}%")
18    
19    print("\n" + "=" * 40)
20    print("VOLATILITY STATISTICS")
21    print("=" * 40)
22    print(f"📊 Average Volatility: {df['volatility'].mean():.4f}")
23    print(f"📊 Volatility Range: {df['volatility'].min():.4f} - {df['volatility'].max():.4f}")
24    print(f"📊 Average Normalized Volatility: {df['normalized_volatility'].mean():.4f}")
25    print(f"📊 Average ATR: {df['atr'].mean():.4f}")
26    
27    print("\n" + "=" * 40)
28    print("TREND ANALYSIS")
29    print("=" * 40)
30    trend_summary = df['price_trend'].value_counts()
31    for trend, count in trend_summary.items():
32        percentage = (count / len(df)) * 100
33        print(f"📈 {trend} Trend: {count} periods ({percentage:.1f}%)")
34    
35    print("\n" + "=" * 40)
36    print("VOLATILITY REGIME ANALYSIS")
37    print("=" * 40)
38    volatility_summary = df['volatility_regime'].value_counts()
39    for regime, count in volatility_summary.items():
40        percentage = (count / len(df)) * 100
41        print(f"📊 {regime} Volatility: {count} periods ({percentage:.1f}%)")
42    
43    # Calculate correlation between price change and volatility
44    correlation = df['price_change'].corr(df['normalized_volatility'])
45    print("\n" + "=" * 40)
46    print("CORRELATION ANALYSIS")
47    print("=" * 40)
48    print(f"📊 Price Change vs Volatility Correlation: {correlation:.4f}")
49    
50    if abs(correlation) > 0.3:
51        print("🔗 Strong correlation detected between price changes and volatility.")
52    elif abs(correlation) > 0.1:
53        print("🔗 Moderate correlation detected between price changes and volatility.")
54    else:
55        print("🔗 Weak correlation between price changes and volatility.")
56    
57    print("\n" + "=" * 60)
58    print("ANALYSIS COMPLETE!")
59    print("=" * 60)
60    
61else:
62    print("❌ No data available for summary analysis.")