Tracking Crypto Derivatives

# Crypto Derivatives Tracker Configuration
# ==========================================

# General settings
general:
  # Default output format: console or json
  default_format: console

  # Default symbols to track
  default_symbols:
    - BTC
    - ETH

  # Cache TTL in seconds
  cache_ttl: 300

  # Request timeout in seconds
  request_timeout: 30

# Exchange configuration
exchanges:
  # Enabled exchanges for data collection
  enabled:
    - binance
    - bybit
    - okx
    - deribit
    - bitmex

  # Primary exchange for each data type
  primary:
    funding: binance
    open_interest: binance
    liquidations: binance
    options: deribit
    basis: binance

  # Rate limits (requests per minute)
  rate_limits:
    binance: 1200
    bybit: 120
    okx: 60
    deribit: 100
    bitmex: 30

# Funding rate settings
funding:
  # Interpretation thresholds (8-hour rate as percentage)
  thresholds:
    extreme: 0.08    # Above this is extreme
    strong: 0.03     # Above this is strong
    neutral: 0.005   # Below this is neutral

  # Minimum spread for arbitrage alerts (percentage)
  min_arb_spread: 0.02

  # Alert on extreme funding
  alert_extreme: true

# Open interest settings
open_interest:
  # Trend detection thresholds (24h change percentage)
  thresholds:
    strong_change: 10.0    # >10% is strong move
    moderate_change: 5.0   # >5% is moderate

  # Divergence detection minimum change
  divergence_min_change: 2.0

# Liquidation settings
liquidations:
  # Cascade risk thresholds (USD within 5% of price)
  cascade_thresholds:
    critical: 500000000   # $500M
    high: 200000000       # $200M
    medium: 100000000     # $100M

  # Minimum liquidation size to track (USD)
  min_liquidation_size: 100000

  # Large liquidation threshold (USD)
  large_liquidation_threshold: 1000000

# Options settings
options:
  # IV interpretation thresholds (percentage)
  iv_thresholds:
    high: 70.0
    low: 40.0

  # Put/call ratio interpretation
  pcr_thresholds:
    bearish: 1.2    # Above this is bearish
    bullish: 0.7    # Below this is bullish

  # Days until expiry for pressure levels
  expiry_pressure:
    high: 2      # <= 2 days
    medium: 7    # <= 7 days

# Basis settings
basis:
  # Structure interpretation thresholds (annualized percentage)
  structure_thresholds:
    strong: 5.0      # >5% annualized is strong
    moderate: 2.0    # >2% is moderate

  # Minimum yield for carry trade alerts
  min_carry_yield: 5.0

# Output formatting
formatting:
  # Console width
  console_width: 70

  # Number of decimal places
  decimals:
    rate: 4
    percentage: 2
    currency: 0

  # Currency formatting
  currency:
    symbol: "$"
    thousands_separator: ","
    decimal_separator: "."

# Alerts and notifications
alerts:
  # Enable alerts
  enabled: false

  # Alert conditions
  conditions:
    extreme_funding: true
    high_cascade_risk: true
    large_liquidation: true
    oi_divergence: true

  # Webhook URL for alerts (optional)
  webhook_url: ""

# Logging
logging:
  # Log level: DEBUG, INFO, WARNING, ERROR
  level: INFO

  # Log file path (optional)
  file: ""

  # Log format
  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

#!/usr/bin/env python3
"""
Basis and spread calculator.

Calculates futures basis and spreads with:
- Spot-futures basis tracking
- Annualized basis yield
- Term structure analysis
- Contango/backwardation detection
"""

from dataclasses import dataclass
from decimal import Decimal
from typing import Dict, List, Optional
from datetime import datetime, date

from exchange_client import ExchangeClient, BasisData, Exchange


@dataclass
class BasisAnalysis:
    """Comprehensive basis analysis."""

    symbol: str
    spot_price: Decimal
    basis_data: List[BasisData]
    avg_basis_pct: float
    avg_annualized: float
    market_structure: str          # "contango", "backwardation", "mixed"
    structure_strength: str        # "strong", "moderate", "weak"
    best_carry_expiry: Optional[str]
    best_carry_yield: float
    timestamp: datetime


@dataclass
class CarryOpportunity:
    """Cash-and-carry arbitrage opportunity."""

    symbol: str
    exchange: str
    expiry: str
    spot_price: Decimal
    futures_price: Decimal
    basis_pct: float
    days_to_expiry: int
    annualized_yield: float
    direction: str                 # "long_basis" or "short_basis"
    strategy: str                  # Trade description
    risk_notes: str


class BasisCalculator:
    """
    Calculates and analyzes futures basis.

    Features:
    - Multi-expiry analysis
    - Term structure visualization
    - Carry trade identification
    - Contango/backwardation detection
    """

    # Structure interpretation
    STRONG_BASIS = 5.0             # >5% annualized is strong
    MODERATE_BASIS = 2.0           # >2% is moderate

    def __init__(
        self,
        client: Optional[ExchangeClient] = None,
    ):
        """
        Initialize basis calculator.

        Args:
            client: Exchange client for data fetching
        """
        self.client = client or ExchangeClient(use_mock=True)

    def analyze(
        self,
        symbol: str,
        spot_price: Optional[Decimal] = None,
        exchanges: Optional[List[Exchange]] = None,
    ) -> BasisAnalysis:
        """
        Analyze basis for a symbol.

        Args:
            symbol: Trading symbol (e.g., "BTC")
            spot_price: Current spot price
            exchanges: Exchanges to include

        Returns:
            BasisAnalysis with all metrics
        """
        # Set default spot price if not provided
        if spot_price is None:
            if symbol == "BTC":
                spot_price = Decimal("67500")
            elif symbol == "ETH":
                spot_price = Decimal("2500")
            else:
                spot_price = Decimal("100")

        # Fetch basis data
        basis_list = self.client.get_all_basis(symbol, spot_price, exchanges)

        if not basis_list:
            raise ValueError(f"No basis data available for {symbol}")

        # Calculate averages
        avg_basis = sum(b.basis_pct for b in basis_list) / len(basis_list)
        avg_annual = sum(b.annualized_pct for b in basis_list) / len(basis_list)

        # Determine market structure
        structure, strength = self._analyze_structure(basis_list)

        # Find best carry opportunity
        best_carry = max(basis_list, key=lambda b: b.annualized_pct)

        return BasisAnalysis(
            symbol=symbol,
            spot_price=spot_price,
            basis_data=basis_list,
            avg_basis_pct=round(avg_basis, 3),
            avg_annualized=round(avg_annual, 2),
            market_structure=structure,
            structure_strength=strength,
            best_carry_expiry=best_carry.expiry,
            best_carry_yield=best_carry.annualized_pct,
            timestamp=datetime.now(),
        )

    def _analyze_structure(
        self,
        basis_list: List[BasisData],
    ) -> tuple:
        """
        Analyze term structure from basis data.

        Returns:
            (structure, strength) tuple
        """
        positive = sum(1 for b in basis_list if b.basis_pct > 0)
        negative = sum(1 for b in basis_list if b.basis_pct < 0)
        total = len(basis_list)

        # Determine structure
        if positive == total:
            structure = "contango"
        elif negative == total:
            structure = "backwardation"
        elif positive > negative:
            structure = "contango"  # Mostly contango
        elif negative > positive:
            structure = "backwardation"
        else:
            structure = "mixed"

        # Determine strength from magnitude
        avg_abs = sum(abs(b.annualized_pct) for b in basis_list) / total
        if avg_abs >= self.STRONG_BASIS:
            strength = "strong"
        elif avg_abs >= self.MODERATE_BASIS:
            strength = "moderate"
        else:
            strength = "weak"

        return structure, strength

    def find_carry_opportunities(
        self,
        symbols: List[str],
        min_yield: float = 5.0,
    ) -> List[CarryOpportunity]:
        """
        Find cash-and-carry arbitrage opportunities.

        Strategy:
        - Contango: Buy spot, sell futures, collect basis
        - Backwardation: Sell spot (if possible), buy futures

        Args:
            symbols: Symbols to scan
            min_yield: Minimum annualized yield (%)

        Returns:
            List of carry opportunities
        """
        opportunities = []

        for symbol in symbols:
            try:
                analysis = self.analyze(symbol)

                for basis in analysis.basis_data:
                    if abs(basis.annualized_pct) >= min_yield:
                        if basis.basis_pct > 0:
                            # Contango - long basis trade
                            direction = "long_basis"
                            strategy = (
                                f"Buy {symbol} spot at ${float(analysis.spot_price):,.0f}, "
                                f"sell {basis.expiry} futures at ${float(basis.futures_price):,.0f}"
                            )
                            risk_notes = "Funding costs may reduce yield; early liquidation risk"
                        else:
                            # Backwardation - short basis trade
                            direction = "short_basis"
                            strategy = (
                                f"Short {symbol} spot (borrow), "
                                f"buy {basis.expiry} futures at ${float(basis.futures_price):,.0f}"
                            )
                            risk_notes = "Borrowing costs apply; squeeze risk in tight markets"

                        opportunities.append(CarryOpportunity(
                            symbol=symbol,
                            exchange=basis.exchange,
                            expiry=basis.expiry,
                            spot_price=analysis.spot_price,
                            futures_price=basis.futures_price,
                            basis_pct=basis.basis_pct,
                            days_to_expiry=basis.days_to_expiry,
                            annualized_yield=basis.annualized_pct,
                            direction=direction,
                            strategy=strategy,
                            risk_notes=risk_notes,
                        ))
            except Exception:
                continue

        # Sort by yield descending
        opportunities.sort(key=lambda x: abs(x.annualized_yield), reverse=True)
        return opportunities

    def get_term_structure(
        self,
        symbol: str,
        spot_price: Optional[Decimal] = None,
    ) -> List[Dict]:
        """
        Get term structure data for visualization.

        Args:
            symbol: Trading symbol
            spot_price: Current spot price

        Returns:
            List of expiry data points
        """
        analysis = self.analyze(symbol, spot_price)

        # Sort by days to expiry
        sorted_basis = sorted(
            analysis.basis_data,
            key=lambda b: b.days_to_expiry
        )

        return [
            {
                "expiry": b.expiry,
                "days": b.days_to_expiry,
                "futures_price": float(b.futures_price),
                "basis_pct": b.basis_pct,
                "annualized_pct": b.annualized_pct,
                "exchange": b.exchange,
            }
            for b in sorted_basis
        ]

    def calculate_implied_rate(
        self,
        spot: Decimal,
        futures: Decimal,
        days: int,
    ) -> Dict:
        """
        Calculate implied interest rate from basis.

        Args:
            spot: Spot price
            futures: Futures price
            days: Days to expiry

        Returns:
            Dict with rate calculations
        """
        if days <= 0:
            return {"error": "Days must be positive"}

        basis = float(futures - spot)
        basis_pct = basis / float(spot) * 100
        annualized = basis_pct * 365 / days

        return {
            "spot": float(spot),
            "futures": float(futures),
            "days_to_expiry": days,
            "basis_usd": round(basis, 2),
            "basis_pct": round(basis_pct, 3),
            "annualized_rate": round(annualized, 2),
            "structure": "contango" if basis > 0 else "backwardation",
        }


def demo():
    """Demonstrate basis calculator."""
    calc = BasisCalculator()

    print("=" * 70)
    print("BASIS CALCULATOR")
    print("=" * 70)

    # Analyze BTC basis
    analysis = calc.analyze("BTC", Decimal("67500"))

    print(f"\n📈 {analysis.symbol} BASIS ANALYSIS")
    print(f"   Spot Price: ${analysis.spot_price:,}")
    print("-" * 60)

    print(f"\n{'Expiry':<12} {'Futures':>12} {'Basis':>10} {'Annual':>10} {'Days':>6}")
    print("-" * 60)

    for basis in sorted(analysis.basis_data, key=lambda b: b.days_to_expiry):
        print(
            f"{basis.expiry:<12} "
            f"${float(basis.futures_price):>10,.0f} "
            f"{basis.basis_pct:>+9.2f}% "
            f"{basis.annualized_pct:>+9.1f}% "
            f"{basis.days_to_expiry:>6}"
        )

    print("-" * 60)
    print(f"\nMarket Structure: {analysis.structure_strength.title()} {analysis.market_structure.title()}")
    print(f"Average Basis: {analysis.avg_basis_pct:+.2f}%")
    print(f"Average Annualized: {analysis.avg_annualized:+.1f}%")
    print(f"Best Carry: {analysis.best_carry_expiry} ({analysis.best_carry_yield:+.1f}% annualized)")

    # Term structure
    print("\n" + "-" * 60)
    print("TERM STRUCTURE")
    print("-" * 60)

    structure = calc.get_term_structure("BTC", Decimal("67500"))
    for point in structure:
        bar = "+" * min(int(abs(point["annualized_pct"]) / 2), 20)
        direction = "▲" if point["annualized_pct"] > 0 else "▼"
        print(f"{point['expiry']:<12} {direction} {bar} {point['annualized_pct']:+.1f}%")

    # Carry opportunities
    print("\n" + "=" * 70)
    print("CARRY TRADE SCANNER")
    print("=" * 70)

    opportunities = calc.find_carry_opportunities(["BTC", "ETH"], min_yield=5.0)
    if opportunities:
        print(f"\n{'Symbol':<6} {'Expiry':<12} {'Basis':>8} {'Annual':>10} {'Direction':<12}")
        print("-" * 60)
        for opp in opportunities[:5]:
            print(
                f"{opp.symbol:<6} "
                f"{opp.expiry:<12} "
                f"{opp.basis_pct:>+7.2f}% "
                f"{opp.annualized_yield:>+9.1f}% "
                f"{opp.direction:<12}"
            )

        print("\nTop Opportunity:")
        top = opportunities[0]
        print(f"   Strategy: {top.strategy}")
        print(f"   Risk: {top.risk_notes}")
    else:
        print("\nNo carry opportunities found above threshold")


if __name__ == "__main__":
    demo()

#!/usr/bin/env python3
"""
Crypto Derivatives Tracker - Main CLI.

Comprehensive derivatives market analysis:
- Funding rate tracking
- Open interest analysis
- Liquidation monitoring
- Options flow analysis
- Basis/spread calculations
- Multi-asset dashboard

Usage:
    python derivatives_tracker.py funding BTC
    python derivatives_tracker.py oi BTC --format json
    python derivatives_tracker.py liquidations BTC
    python derivatives_tracker.py options BTC
    python derivatives_tracker.py basis BTC
    python derivatives_tracker.py dashboard BTC ETH
"""

import argparse
import sys
from decimal import Decimal
from typing import List, Optional

from exchange_client import ExchangeClient
from funding_tracker import FundingTracker
from oi_analyzer import OIAnalyzer
from liquidation_monitor import LiquidationMonitor
from options_analyzer import OptionsAnalyzer
from basis_calculator import BasisCalculator
from formatters import ConsoleFormatter, JSONFormatter, ReportGenerator


def cmd_funding(args):
    """Handle funding subcommand."""
    tracker = FundingTracker()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    print(console.header(f"{args.symbol} FUNDING RATE ANALYSIS"))

    analysis = tracker.analyze(args.symbol)

    if args.format == "json":
        print(json_fmt.funding_report(args.symbol, {
            "weighted_avg": analysis.weighted_avg,
            "annualized_avg": analysis.annualized_avg,
            "spread": analysis.spread,
            "sentiment": analysis.sentiment,
            "sentiment_strength": analysis.sentiment_strength,
            "arbitrage_opportunity": analysis.arbitrage_opportunity,
            "rates": [
                {
                    "exchange": r.exchange,
                    "rate": float(r.rate),
                    "annualized": r.annualized,
                    "next_payment": r.time_to_payment_str,
                }
                for r in analysis.rates
            ],
        }))
        return

    # Console format
    print(f"\n{'Exchange':<12} {'Current':>10} {'Annualized':>12} {'Next Payment':>14}")
    print("-" * 50)

    for rate in sorted(analysis.rates, key=lambda r: r.rate, reverse=True):
        print(
            f"{rate.exchange:<12} "
            f"{float(rate.rate):>+9.4%} "
            f"{rate.annualized:>+11.2f}% "
            f"{rate.time_to_payment_str:>14}"
        )

    print("-" * 50)
    print(f"\nWeighted Average: {analysis.weighted_avg:+.4%}")
    print(f"Annualized: {analysis.annualized_avg:+.2f}%")
    print(f"Spread (max-min): {analysis.spread:.4%}")
    print(f"\nSentiment: {console.sentiment_icon(analysis.sentiment)} "
          f"{analysis.sentiment_strength.title()} {analysis.sentiment.title()}")

    if analysis.is_extreme:
        print(f"\n⚠️  EXTREME FUNDING - Contrarian opportunity")

    if analysis.arbitrage_opportunity:
        print(f"\n💰 ARBITRAGE OPPORTUNITY")
        print(f"   Long on {analysis.min_rate.exchange} ({float(analysis.min_rate.rate):+.4%})")
        print(f"   Short on {analysis.max_rate.exchange} ({float(analysis.max_rate.rate):+.4%})")
        print(f"   Profit: {analysis.arbitrage_spread:.4%} per 8h")


def cmd_oi(args):
    """Handle open interest subcommand."""
    analyzer = OIAnalyzer()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    print(console.header(f"{args.symbol} OPEN INTEREST ANALYSIS"))

    analysis = analyzer.analyze(args.symbol)

    if args.format == "json":
        print(json_fmt.oi_report(args.symbol, {
            "total_oi_usd": float(analysis.total_oi_usd),
            "total_oi_contracts": float(analysis.total_oi_contracts),
            "avg_change_24h": analysis.avg_change_24h,
            "avg_change_7d": analysis.avg_change_7d,
            "weighted_long_ratio": analysis.weighted_long_ratio,
            "long_percentage": analysis.long_percentage,
            "dominant_exchange": analysis.dominant_exchange,
            "dominant_share": analysis.dominant_share,
            "trend": analysis.trend,
            "trend_strength": analysis.trend_strength,
            "exchanges": [
                {
                    "exchange": oi.exchange,
                    "oi_usd": float(oi.oi_usd),
                    "change_24h": oi.change_24h_pct,
                    "change_7d": oi.change_7d_pct,
                    "long_ratio": oi.long_ratio,
                }
                for oi in analysis.exchanges
            ],
        }))
        return

    # Console format
    print(f"\n{'Exchange':<12} {'OI (USD)':>14} {'24h Chg':>10} {'7d Chg':>10} {'Share':>8}")
    print("-" * 60)

    for oi in sorted(analysis.exchanges, key=lambda x: x.oi_usd, reverse=True):
        share = float(oi.oi_usd) / float(analysis.total_oi_usd) * 100
        print(
            f"{oi.exchange:<12} "
            f"${float(oi.oi_usd)/1e9:>12.2f}B "
            f"{oi.change_24h_pct:>+9.1f}% "
            f"{oi.change_7d_pct:>+9.1f}% "
            f"{share:>7.1f}%"
        )

    print("-" * 60)
    print(f"\nTotal OI: ${float(analysis.total_oi_usd)/1e9:.2f}B")
    print(f"24h Change: {analysis.avg_change_24h:+.1f}%")
    print(f"7d Change: {analysis.avg_change_7d:+.1f}%")
    print(f"\nLong/Short Ratio: {analysis.weighted_long_ratio:.2f} "
          f"({analysis.long_percentage:.1f}% long)")
    print(f"Trend: {analysis.trend_strength.title()} {analysis.trend.title()}")
    print(f"Dominant Exchange: {analysis.dominant_exchange} ({analysis.dominant_share:.1f}%)")

    # Check for divergence
    if args.price_change:
        print(console.section("DIVERGENCE ANALYSIS"))
        divergence = analyzer.detect_divergence(args.symbol, args.price_change)
        if divergence:
            print(f"\n🔍 Divergence Detected!")
            print(f"   OI:    {divergence.oi_direction} ({divergence.oi_change_pct:+.1f}%)")
            print(f"   Price: {divergence.price_direction} ({divergence.price_change_pct:+.1f}%)")
            print(f"   Signal: {divergence.signal.upper()}")
            print(f"   {divergence.description}")
            print(f"   Confidence: {divergence.confidence}")
        else:
            print("\nNo significant divergence detected")


def cmd_liquidations(args):
    """Handle liquidations subcommand."""
    monitor = LiquidationMonitor()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    price = Decimal(str(args.price)) if args.price else None
    summary = monitor.get_summary(args.symbol, price)

    print(console.header(f"{args.symbol} LIQUIDATION MONITOR"))

    if args.format == "json":
        print(json_fmt.format({
            "symbol": summary.symbol,
            "current_price": float(summary.current_price),
            "total_24h_usd": float(summary.total_24h_usd),
            "long_liquidations_usd": float(summary.long_liquidations_usd),
            "short_liquidations_usd": float(summary.short_liquidations_usd),
            "cascade_risk": summary.cascade_risk,
            "long_levels": [
                {
                    "price": float(l.price),
                    "total_value_usd": float(l.total_value_usd),
                    "density": l.density,
                }
                for l in summary.long_levels
            ],
            "short_levels": [
                {
                    "price": float(l.price),
                    "total_value_usd": float(l.total_value_usd),
                    "density": l.density,
                }
                for l in summary.short_levels
            ],
        }))
        return

    print(f"\n   Current Price: ${summary.current_price:,}")
    print("-" * 60)

    # 24h totals
    print(f"\n24h Liquidations:")
    print(f"   Total:  ${float(summary.total_24h_usd)/1e6:,.1f}M")
    print(f"   Longs:  ${float(summary.long_liquidations_usd)/1e6:,.1f}M")
    print(f"   Shorts: ${float(summary.short_liquidations_usd)/1e6:,.1f}M")

    # Cascade risk
    print(f"\nCascade Risk: {console.risk_icon(summary.cascade_risk)} "
          f"{summary.cascade_risk.upper()}")

    # Heatmap
    print(console.section("LIQUIDATION HEATMAP"))

    print(f"\nLONG LIQUIDATIONS (below ${summary.current_price:,}):")
    for level in summary.long_levels[:4]:
        bar_len = min(int(float(level.total_value_usd) / 10_000_000), 20)
        bar = "█" * bar_len
        density_mark = "⚠️ " if level.density in ["high", "critical"] else ""
        print(
            f"  ${float(level.price):>10,.0f} {bar} "
            f"${float(level.total_value_usd)/1e6:.0f}M "
            f"{density_mark}{level.density.upper()}"
        )

    print(f"\nSHORT LIQUIDATIONS (above ${summary.current_price:,}):")
    for level in summary.short_levels[:4]:
        bar_len = min(int(float(level.total_value_usd) / 10_000_000), 20)
        bar = "█" * bar_len
        density_mark = "⚠️ " if level.density in ["high", "critical"] else ""
        print(
            f"  ${float(level.price):>10,.0f} {bar} "
            f"${float(level.total_value_usd)/1e6:.0f}M "
            f"{density_mark}{level.density.upper()}"
        )

    # Large liquidations
    if args.large:
        print(console.section("RECENT LARGE LIQUIDATIONS"))
        large = monitor.get_recent_large_liquidations(
            args.symbol, min_value_usd=1_000_000, limit=5
        )
        if large:
            print(f"\n{'Exchange':<10} {'Side':<6} {'Price':>12} {'Value':>12} {'When':>10}")
            print("-" * 60)
            for l in large:
                print(
                    f"{l['exchange']:<10} "
                    f"{l['side']:<6} "
                    f"${l['price']:>10,.0f} "
                    f"${l['value_usd']/1e6:>10.1f}M "
                    f"{l['time_ago']:>10}"
                )


def cmd_options(args):
    """Handle options subcommand."""
    analyzer = OptionsAnalyzer()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    price = Decimal(str(args.price)) if args.price else None
    analysis = analyzer.analyze(args.symbol, current_price=price)

    print(console.header(f"{args.symbol} OPTIONS ANALYSIS"))

    if args.format == "json":
        print(json_fmt.format({
            "symbol": analysis.symbol,
            "expiry": analysis.snapshot.expiry,
            "atm_iv": analysis.snapshot.atm_iv,
            "iv_interpretation": analysis.iv_interpretation,
            "iv_percentile": analysis.iv_percentile,
            "put_call_ratio_volume": analysis.snapshot.put_call_ratio_volume,
            "put_call_ratio_oi": analysis.snapshot.put_call_ratio_oi,
            "sentiment_from_pcr": analysis.sentiment_from_pcr,
            "sentiment_from_skew": analysis.sentiment_from_skew,
            "overall_sentiment": analysis.overall_sentiment,
            "max_pain": float(analysis.snapshot.max_pain),
            "max_pain_distance_pct": analysis.max_pain_distance_pct,
            "expiry_pressure": analysis.expiry_pressure,
            "total_call_oi": float(analysis.snapshot.total_call_oi),
            "total_put_oi": float(analysis.snapshot.total_put_oi),
        }))
        return

    snap = analysis.snapshot
    print(f"\nExpiry: {snap.expiry}")
    print(f"Exchange: {snap.exchange}")

    print(f"\nImplied Volatility:")
    print(f"   ATM IV: {snap.atm_iv:.1f}%")
    print(f"   Interpretation: {analysis.iv_interpretation.upper()}")
    print(f"   IV Rank: {analysis.iv_percentile:.0f}th percentile")

    print(f"\nPut/Call Analysis:")
    print(f"   PCR (Volume): {snap.put_call_ratio_volume:.2f}")
    print(f"   PCR (OI): {snap.put_call_ratio_oi:.2f}")
    print(f"   Sentiment: {console.sentiment_icon(analysis.sentiment_from_pcr)} "
          f"{analysis.sentiment_from_pcr.upper()}")

    print(f"\nMax Pain:")
    print(f"   Price: ${snap.max_pain:,.0f}")
    print(f"   Distance: {analysis.max_pain_distance_pct:+.1f}% from current")

    print(f"\nOpen Interest:")
    print(f"   Calls: ${float(snap.total_call_oi)/1e9:.2f}B")
    print(f"   Puts:  ${float(snap.total_put_oi)/1e9:.2f}B")

    print(f"\nOverall Sentiment: {console.sentiment_icon(analysis.overall_sentiment)} "
          f"{analysis.overall_sentiment.upper()}")
    print(f"Expiry Pressure: {analysis.expiry_pressure.upper()}")

    # Max pain levels
    if args.max_pain:
        print(console.section("MAX PAIN BY EXPIRY"))
        levels = analyzer.get_max_pain_levels(args.symbol)
        print(f"\n{'Expiry':<12} {'Max Pain':>12} {'Call OI':>12} {'Put OI':>12} {'PCR':>6}")
        print("-" * 50)
        for lvl in levels:
            print(
                f"{lvl['expiry']:<12} "
                f"${lvl['max_pain']:>10,.0f} "
                f"${lvl['call_oi']/1e9:>10.1f}B "
                f"${lvl['put_oi']/1e9:>10.1f}B "
                f"{lvl['pcr_oi']:>5.2f}"
            )

    # Options flow
    if args.flow:
        print(console.section("OPTIONS FLOW (Simulated)"))
        flows = analyzer.generate_mock_flow(args.symbol, count=5)
        print(f"\n{'Type':<6} {'Strike':>10} {'Size':>8} {'Premium':>12} {'Interpretation':<25}")
        print("-" * 70)
        for flow in flows:
            print(
                f"{flow.option_type.upper():<6} "
                f"${float(flow.strike):>8,.0f} "
                f"{flow.size_contracts:>8} "
                f"${float(flow.premium_usd):>10,.0f} "
                f"{flow.interpretation:<25}"
            )


def cmd_basis(args):
    """Handle basis subcommand."""
    calc = BasisCalculator()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    price = Decimal(str(args.price)) if args.price else None
    analysis = calc.analyze(args.symbol, price)

    print(console.header(f"{args.symbol} BASIS ANALYSIS"))

    if args.format == "json":
        print(json_fmt.format({
            "symbol": analysis.symbol,
            "spot_price": float(analysis.spot_price),
            "avg_basis_pct": analysis.avg_basis_pct,
            "avg_annualized": analysis.avg_annualized,
            "market_structure": analysis.market_structure,
            "structure_strength": analysis.structure_strength,
            "best_carry_expiry": analysis.best_carry_expiry,
            "best_carry_yield": analysis.best_carry_yield,
            "basis_data": [
                {
                    "expiry": b.expiry,
                    "futures_price": float(b.futures_price),
                    "basis_pct": b.basis_pct,
                    "annualized_pct": b.annualized_pct,
                    "days_to_expiry": b.days_to_expiry,
                }
                for b in analysis.basis_data
            ],
        }))
        return

    print(f"\n   Spot Price: ${analysis.spot_price:,}")
    print("-" * 60)

    print(f"\n{'Expiry':<12} {'Futures':>12} {'Basis':>10} {'Annual':>10} {'Days':>6}")
    print("-" * 60)

    for basis in sorted(analysis.basis_data, key=lambda b: b.days_to_expiry):
        print(
            f"{basis.expiry:<12} "
            f"${float(basis.futures_price):>10,.0f} "
            f"{basis.basis_pct:>+9.2f}% "
            f"{basis.annualized_pct:>+9.1f}% "
            f"{basis.days_to_expiry:>6}"
        )

    print("-" * 60)
    print(f"\nMarket Structure: {analysis.structure_strength.title()} "
          f"{analysis.market_structure.title()}")
    print(f"Average Basis: {analysis.avg_basis_pct:+.2f}%")
    print(f"Average Annualized: {analysis.avg_annualized:+.1f}%")
    print(f"Best Carry: {analysis.best_carry_expiry} "
          f"({analysis.best_carry_yield:+.1f}% annualized)")

    # Term structure
    print(console.section("TERM STRUCTURE"))
    structure = calc.get_term_structure(args.symbol, analysis.spot_price)
    for point in structure:
        bar = "+" * min(int(abs(point["annualized_pct"]) / 2), 20)
        direction = "▲" if point["annualized_pct"] > 0 else "▼"
        print(f"{point['expiry']:<12} {direction} {bar} {point['annualized_pct']:+.1f}%")

    # Carry scanner
    if args.carry:
        print(console.section("CARRY TRADE SCANNER"))
        opportunities = calc.find_carry_opportunities([args.symbol], min_yield=5.0)
        if opportunities:
            print(f"\n{'Expiry':<12} {'Basis':>8} {'Annual':>10} {'Direction':<12}")
            print("-" * 50)
            for opp in opportunities[:5]:
                print(
                    f"{opp.expiry:<12} "
                    f"{opp.basis_pct:>+7.2f}% "
                    f"{opp.annualized_yield:>+9.1f}% "
                    f"{opp.direction:<12}"
                )

            print("\nTop Opportunity:")
            top = opportunities[0]
            print(f"   Strategy: {top.strategy}")
            print(f"   Risk: {top.risk_notes}")
        else:
            print("\nNo carry opportunities found above threshold")


def cmd_dashboard(args):
    """Handle dashboard subcommand."""
    console = ConsoleFormatter()
    report_gen = ReportGenerator()

    funding_tracker = FundingTracker()
    oi_analyzer = OIAnalyzer()
    liq_monitor = LiquidationMonitor()

    print(console.header("CRYPTO DERIVATIVES DASHBOARD"))

    for symbol in args.symbols:
        print(f"\n{'=' * 70}")
        print(f" {symbol} ".center(70, "="))
        print("=" * 70)

        try:
            # Funding
            funding = funding_tracker.analyze(symbol)
            print(f"\n📊 FUNDING")
            print(f"   Rate: {funding.weighted_avg:+.4%} ({funding.annualized_avg:+.1f}% annual)")
            print(f"   Sentiment: {console.sentiment_icon(funding.sentiment)} "
                  f"{funding.sentiment.title()}")

            # OI
            oi = oi_analyzer.analyze(symbol)
            print(f"\n📈 OPEN INTEREST")
            print(f"   Total: ${float(oi.total_oi_usd)/1e9:.1f}B ({oi.avg_change_24h:+.1f}% 24h)")
            print(f"   Long/Short: {oi.weighted_long_ratio:.2f} ({oi.long_percentage:.0f}% long)")
            print(f"   Trend: {oi.trend_strength.title()} {oi.trend.title()}")

            # Liquidations
            liq = liq_monitor.get_summary(symbol)
            print(f"\n💥 LIQUIDATIONS (24h)")
            print(f"   Total: ${float(liq.total_24h_usd)/1e6:.1f}M")
            print(f"   Longs: ${float(liq.long_liquidations_usd)/1e6:.1f}M | "
                  f"Shorts: ${float(liq.short_liquidations_usd)/1e6:.1f}M")
            print(f"   Cascade Risk: {console.risk_icon(liq.cascade_risk)} "
                  f"{liq.cascade_risk.upper()}")

        except Exception as e:
            print(f"\n⚠️  Error fetching data for {symbol}: {e}")

    print(f"\n{'=' * 70}")
    print(f"Dashboard generated at: {console.H_LINE * 50}")


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Crypto Derivatives Tracker",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    %(prog)s funding BTC
    %(prog)s oi BTC --price-change 3.5
    %(prog)s liquidations BTC --large
    %(prog)s options BTC --flow --max-pain
    %(prog)s basis BTC --carry
    %(prog)s dashboard BTC ETH SOL
        """,
    )

    subparsers = parser.add_subparsers(dest="command", help="Available commands")

    # Funding subcommand
    funding_parser = subparsers.add_parser("funding", help="Analyze funding rates")
    funding_parser.add_argument("symbol", help="Trading symbol (e.g., BTC)")
    funding_parser.add_argument("--format", choices=["console", "json"],
                               default="console", help="Output format")

    # OI subcommand
    oi_parser = subparsers.add_parser("oi", help="Analyze open interest")
    oi_parser.add_argument("symbol", help="Trading symbol")
    oi_parser.add_argument("--price-change", type=float, dest="price_change",
                          help="24h price change %% for divergence analysis")
    oi_parser.add_argument("--format", choices=["console", "json"],
                          default="console", help="Output format")

    # Liquidations subcommand
    liq_parser = subparsers.add_parser("liquidations", help="Monitor liquidations")
    liq_parser.add_argument("symbol", help="Trading symbol")
    liq_parser.add_argument("--price", type=float, help="Current price override")
    liq_parser.add_argument("--large", action="store_true",
                           help="Show recent large liquidations")
    liq_parser.add_argument("--format", choices=["console", "json"],
                          default="console", help="Output format")

    # Options subcommand
    opt_parser = subparsers.add_parser("options", help="Analyze options market")
    opt_parser.add_argument("symbol", help="Trading symbol")
    opt_parser.add_argument("--price", type=float, help="Current price override")
    opt_parser.add_argument("--max-pain", action="store_true", dest="max_pain",
                           help="Show max pain by expiry")
    opt_parser.add_argument("--flow", action="store_true",
                           help="Show options flow")
    opt_parser.add_argument("--format", choices=["console", "json"],
                          default="console", help="Output format")

    # Basis subcommand
    basis_parser = subparsers.add_parser("basis", help="Calculate futures basis")
    basis_parser.add_argument("symbol", help="Trading symbol")
    basis_parser.add_argument("--price", type=float, help="Spot price override")
    basis_parser.add_argument("--carry", action="store_true",
                             help="Show carry opportunities")
    basis_parser.add_argument("--format", choices=["console", "json"],
                            default="console", help="Output format")

    # Dashboard subcommand
    dash_parser = subparsers.add_parser("dashboard", help="Multi-asset dashboard")
    dash_parser.add_argument("symbols", nargs="+", help="Trading symbols")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    # Dispatch to command handler
    commands = {
        "funding": cmd_funding,
        "oi": cmd_oi,
        "liquidations": cmd_liquidations,
        "options": cmd_options,
        "basis": cmd_basis,
        "dashboard": cmd_dashboard,
    }

    try:
        commands[args.command](args)
    except KeyboardInterrupt:
        print("\nInterrupted")
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ Error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Output formatters for derivatives tracker.

Provides consistent formatting for:
- Console output (tables, charts)
- JSON export
- Report generation
"""

import json
from dataclasses import asdict
from datetime import datetime
from decimal import Decimal
from typing import Any, Dict, List, Optional, Union


class DecimalEncoder(json.JSONEncoder):
    """JSON encoder that handles Decimal types."""

    def default(self, obj):
        if isinstance(obj, Decimal):
            return float(obj)
        if isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)


def format_currency(value: Union[float, Decimal], decimals: int = 0) -> str:
    """Format value as currency."""
    val = float(value)
    if abs(val) >= 1e9:
        return f"${val/1e9:.1f}B"
    elif abs(val) >= 1e6:
        return f"${val/1e6:.1f}M"
    elif abs(val) >= 1e3:
        return f"${val/1e3:.1f}K"
    else:
        return f"${val:,.{decimals}f}"


def format_percent(value: float, decimals: int = 2, sign: bool = True) -> str:
    """Format value as percentage."""
    if sign:
        return f"{value:+.{decimals}f}%"
    else:
        return f"{value:.{decimals}f}%"


def format_time_ago(dt: datetime) -> str:
    """Format datetime as time ago string."""
    delta = datetime.now() - dt
    minutes = int(delta.total_seconds() / 60)

    if minutes < 1:
        return "just now"
    elif minutes < 60:
        return f"{minutes}m ago"
    elif minutes < 1440:
        hours = minutes // 60
        return f"{hours}h ago"
    else:
        days = minutes // 1440
        return f"{days}d ago"


class ConsoleFormatter:
    """
    Formats data for console output.

    Features:
    - ASCII tables
    - Bar charts
    - Color indicators
    - Consistent widths
    """

    # Box drawing characters
    H_LINE = "─"
    V_LINE = "│"
    CROSS = "┼"
    TOP_LEFT = "┌"
    TOP_RIGHT = "┐"
    BOT_LEFT = "└"
    BOT_RIGHT = "┘"

    # Sentiment indicators
    BULLISH = "🟢"
    BEARISH = "🔴"
    NEUTRAL = "🟡"
    MIXED = "⚪"

    # Risk indicators
    RISK_CRITICAL = "🔴"
    RISK_HIGH = "🟠"
    RISK_MEDIUM = "🟡"
    RISK_LOW = "🟢"

    def __init__(self, width: int = 70):
        """Initialize formatter with terminal width."""
        self.width = width

    def header(self, title: str, char: str = "=") -> str:
        """Create a centered header."""
        return f"{char * self.width}\n{title.center(self.width)}\n{char * self.width}"

    def subheader(self, title: str, char: str = "-") -> str:
        """Create a subheader."""
        return f"{char * self.width}\n{title}\n{char * self.width}"

    def section(self, title: str) -> str:
        """Create a section divider."""
        return f"\n{self.H_LINE * self.width}\n{title}\n{self.H_LINE * self.width}"

    def sentiment_icon(self, sentiment: str) -> str:
        """Get icon for sentiment."""
        icons = {
            "bullish": self.BULLISH,
            "bearish": self.BEARISH,
            "neutral": self.NEUTRAL,
            "mixed": self.MIXED,
        }
        return icons.get(sentiment.lower(), self.NEUTRAL)

    def risk_icon(self, risk: str) -> str:
        """Get icon for risk level."""
        icons = {
            "critical": self.RISK_CRITICAL,
            "high": self.RISK_HIGH,
            "medium": self.RISK_MEDIUM,
            "low": self.RISK_LOW,
        }
        return icons.get(risk.lower(), self.RISK_LOW)

    def bar(
        self,
        value: float,
        max_value: float,
        width: int = 20,
        char: str = "█",
    ) -> str:
        """Create a horizontal bar."""
        if max_value <= 0:
            return ""
        fill = min(int(value / max_value * width), width)
        return char * fill

    def format_funding_table(
        self,
        rates: List[Dict],
    ) -> str:
        """Format funding rates as table."""
        lines = []
        lines.append(f"{'Exchange':<12} {'Current':>10} {'Annualized':>12} {'Next Payment':>14}")
        lines.append("-" * 50)

        for rate in sorted(rates, key=lambda r: r.get("rate", 0), reverse=True):
            lines.append(
                f"{rate['exchange']:<12} "
                f"{rate['rate']:>+9.4%} "
                f"{rate['annualized']:>+11.1f}% "
                f"{rate.get('next_payment', 'N/A'):>14}"
            )

        return "\n".join(lines)

    def format_oi_table(
        self,
        exchanges: List[Dict],
        total: float,
    ) -> str:
        """Format open interest as table."""
        lines = []
        lines.append(f"{'Exchange':<12} {'OI (USD)':>14} {'24h Chg':>10} {'7d Chg':>10} {'Share':>8}")
        lines.append("-" * 60)

        for ex in sorted(exchanges, key=lambda x: x.get("oi_usd", 0), reverse=True):
            share = ex.get("oi_usd", 0) / total * 100 if total > 0 else 0
            lines.append(
                f"{ex['exchange']:<12} "
                f"{format_currency(ex.get('oi_usd', 0)):>14} "
                f"{ex.get('change_24h', 0):>+9.1f}% "
                f"{ex.get('change_7d', 0):>+9.1f}% "
                f"{share:>7.1f}%"
            )

        return "\n".join(lines)

    def format_liquidation_heatmap(
        self,
        levels: List[Dict],
        side: str,
        max_value: float,
    ) -> str:
        """Format liquidation levels as visual heatmap."""
        lines = []

        for level in levels:
            bar_len = min(int(level.get("value_usd", 0) / 10_000_000), 20)
            bar = "█" * bar_len
            density = level.get("density", "low")
            marker = "⚠️ " if density in ["high", "critical"] else ""

            lines.append(
                f"  ${float(level.get('price', 0)):>10,.0f} {bar} "
                f"{format_currency(level.get('value_usd', 0))} "
                f"{marker}{density.upper()}"
            )

        return "\n".join(lines)

    def format_options_summary(
        self,
        analysis: Dict,
    ) -> str:
        """Format options analysis summary."""
        lines = []

        lines.append(f"Implied Volatility:")
        lines.append(f"   ATM IV: {analysis.get('atm_iv', 0):.1f}%")
        lines.append(f"   Interpretation: {analysis.get('iv_interpretation', 'unknown').upper()}")
        lines.append(f"   IV Rank: {analysis.get('iv_percentile', 50):.0f}th percentile")

        lines.append(f"\nPut/Call Analysis:")
        lines.append(f"   PCR (Volume): {analysis.get('pcr_volume', 0):.2f}")
        lines.append(f"   PCR (OI): {analysis.get('pcr_oi', 0):.2f}")
        lines.append(f"   Sentiment: {analysis.get('pcr_sentiment', 'neutral').upper()}")

        lines.append(f"\nMax Pain:")
        lines.append(f"   Price: ${analysis.get('max_pain', 0):,.0f}")
        lines.append(f"   Distance: {analysis.get('max_pain_distance', 0):+.1f}% from current")

        return "\n".join(lines)

    def format_basis_term_structure(
        self,
        structure: List[Dict],
    ) -> str:
        """Format term structure as visual chart."""
        lines = []

        for point in structure:
            annual = point.get("annualized_pct", 0)
            bar = "+" * min(int(abs(annual) / 2), 20)
            direction = "▲" if annual > 0 else "▼"
            lines.append(
                f"{point.get('expiry', 'N/A'):<12} {direction} {bar} "
                f"{annual:+.1f}%"
            )

        return "\n".join(lines)


class JSONFormatter:
    """
    Formats data for JSON export.

    Features:
    - Clean JSON structure
    - Decimal handling
    - Datetime serialization
    - Nested object support
    """

    def __init__(self, indent: int = 2):
        """Initialize formatter."""
        self.indent = indent

    def format(self, data: Any) -> str:
        """Format any data as JSON string."""
        return json.dumps(
            self._prepare(data),
            cls=DecimalEncoder,
            indent=self.indent,
        )

    def _prepare(self, obj: Any) -> Any:
        """Prepare object for JSON serialization."""
        if hasattr(obj, "__dataclass_fields__"):
            # Dataclass - convert to dict
            return {k: self._prepare(v) for k, v in asdict(obj).items()}
        elif isinstance(obj, dict):
            return {k: self._prepare(v) for k, v in obj.items()}
        elif isinstance(obj, (list, tuple)):
            return [self._prepare(item) for item in obj]
        elif isinstance(obj, Decimal):
            return float(obj)
        elif isinstance(obj, datetime):
            return obj.isoformat()
        else:
            return obj

    def funding_report(
        self,
        symbol: str,
        analysis: Dict,
    ) -> str:
        """Generate funding rate JSON report."""
        report = {
            "report_type": "funding_rates",
            "symbol": symbol,
            "generated_at": datetime.now().isoformat(),
            "data": self._prepare(analysis),
        }
        return self.format(report)

    def oi_report(
        self,
        symbol: str,
        analysis: Dict,
    ) -> str:
        """Generate open interest JSON report."""
        report = {
            "report_type": "open_interest",
            "symbol": symbol,
            "generated_at": datetime.now().isoformat(),
            "data": self._prepare(analysis),
        }
        return self.format(report)

    def derivatives_dashboard(
        self,
        symbol: str,
        funding: Dict,
        oi: Dict,
        liquidations: Dict,
        options: Optional[Dict] = None,
        basis: Optional[Dict] = None,
    ) -> str:
        """Generate complete derivatives dashboard JSON."""
        report = {
            "report_type": "derivatives_dashboard",
            "symbol": symbol,
            "generated_at": datetime.now().isoformat(),
            "funding": self._prepare(funding),
            "open_interest": self._prepare(oi),
            "liquidations": self._prepare(liquidations),
        }

        if options:
            report["options"] = self._prepare(options)
        if basis:
            report["basis"] = self._prepare(basis)

        return self.format(report)


class ReportGenerator:
    """
    Generates formatted reports combining multiple data sources.
    """

    def __init__(self):
        """Initialize report generator."""
        self.console = ConsoleFormatter()
        self.json_fmt = JSONFormatter()

    def derivatives_summary(
        self,
        symbol: str,
        funding: Dict,
        oi: Dict,
        liquidations: Dict,
        format: str = "console",
    ) -> str:
        """
        Generate derivatives market summary.

        Args:
            symbol: Trading symbol
            funding: Funding rate analysis
            oi: Open interest analysis
            liquidations: Liquidation summary
            format: Output format ("console" or "json")

        Returns:
            Formatted summary string
        """
        if format == "json":
            return self.json_fmt.derivatives_dashboard(
                symbol, funding, oi, liquidations
            )

        # Console format
        lines = []
        lines.append(self.console.header(f"{symbol} DERIVATIVES SUMMARY"))

        # Funding section
        lines.append(f"\n📊 FUNDING RATES")
        lines.append(f"   Weighted Average: {format_percent(funding.get('weighted_avg', 0) * 100, 4)}")
        lines.append(f"   Annualized: {format_percent(funding.get('annualized_avg', 0), 1)}")
        lines.append(f"   Sentiment: {funding.get('sentiment', 'unknown').upper()}")

        # OI section
        lines.append(f"\n📈 OPEN INTEREST")
        lines.append(f"   Total: {format_currency(oi.get('total_oi_usd', 0))}")
        lines.append(f"   24h Change: {format_percent(oi.get('avg_change_24h', 0), 1)}")
        lines.append(f"   Trend: {oi.get('trend', 'unknown').title()}")

        # Liquidations section
        lines.append(f"\n💥 LIQUIDATIONS")
        lines.append(f"   24h Total: {format_currency(liquidations.get('total_24h_usd', 0))}")
        lines.append(f"   Longs: {format_currency(liquidations.get('long_liquidations_usd', 0))}")
        lines.append(f"   Shorts: {format_currency(liquidations.get('short_liquidations_usd', 0))}")
        risk = liquidations.get('cascade_risk', 'low')
        lines.append(f"   Cascade Risk: {self.console.risk_icon(risk)} {risk.upper()}")

        lines.append(f"\n{self.console.H_LINE * self.console.width}")
        lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

        return "\n".join(lines)


def demo():
    """Demonstrate formatters."""
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    print(console.header("FORMATTER DEMO"))

    # Currency formatting
    print("\nCurrency Formatting:")
    print(f"  $1,234,567,890 → {format_currency(1234567890)}")
    print(f"  $12,345,678    → {format_currency(12345678)}")
    print(f"  $123,456       → {format_currency(123456)}")

    # Percent formatting
    print("\nPercent Formatting:")
    print(f"  5.5   → {format_percent(5.5)}")
    print(f"  -3.25 → {format_percent(-3.25)}")
    print(f"  0.02  → {format_percent(0.02, 4)}")

    # Bars
    print("\nBar Charts:")
    print(f"  100/100: {console.bar(100, 100)}")
    print(f"   50/100: {console.bar(50, 100)}")
    print(f"   25/100: {console.bar(25, 100)}")

    # Sentiment icons
    print("\nSentiment Icons:")
    for sent in ["bullish", "bearish", "neutral", "mixed"]:
        print(f"  {sent}: {console.sentiment_icon(sent)}")

    # JSON export
    print("\n" + console.section("JSON EXPORT"))
    sample_data = {
        "symbol": "BTC",
        "price": Decimal("67500.50"),
        "timestamp": datetime.now(),
        "metrics": {
            "funding": 0.01,
            "oi": Decimal("15000000000"),
        }
    }
    print(json_fmt.format(sample_data))


if __name__ == "__main__":
    demo()