@intentsolutionsio/crypto-derivatives-tracker 1.0.0 → 1.0.3

package/skills/tracking-crypto-derivatives/scripts/derivatives_tracker.py

@@ -22,9 +22,7 @@ Usage:
 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
@@ -44,23 +42,28 @@ def cmd_funding(args):
     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": [
+        print(
+            json_fmt.funding_report(
+                args.symbol,
                 {
-                    "exchange": r.exchange,
-                    "rate": float(r.rate),
-                    "annualized": r.annualized,
-                    "next_payment": r.time_to_payment_str,
-                }
-                for r in analysis.rates
-            ],
-        }))
+                    "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
@@ -69,24 +72,23 @@ def cmd_funding(args):
 
     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}"
+            f"{rate.exchange:<12} {float(rate.rate):>+9.4%} {rate.annualized:>+11.2f}% {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()}")
+    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")
+        print("\n⚠️  EXTREME FUNDING - Contrarian opportunity")
 
     if analysis.arbitrage_opportunity:
-        print(f"\n💰 ARBITRAGE OPPORTUNITY")
+        print("\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")
@@ -103,28 +105,33 @@ def cmd_oi(args):
     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": [
+        print(
+            json_fmt.oi_report(
+                args.symbol,
                 {
-                    "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
-            ],
-        }))
+                    "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
@@ -135,18 +142,17 @@ def cmd_oi(args):
         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"${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"\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"\nLong/Short Ratio: {analysis.weighted_long_ratio:.2f} ({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}%)")
 
@@ -155,7 +161,7 @@ def cmd_oi(args):
         print(console.section("DIVERGENCE ANALYSIS"))
         divergence = analyzer.detect_divergence(args.symbol, args.price_change)
         if divergence:
-            print(f"\n🔍 Divergence Detected!")
+            print("\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()}")
@@ -177,44 +183,47 @@ def cmd_liquidations(args):
     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": [
+        print(
+            json_fmt.format(
                 {
-                    "price": float(l.price),
-                    "total_value_usd": float(l.total_value_usd),
-                    "density": l.density,
+                    "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
+                    ],
                 }
-                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")
+    print("\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()}")
+    print(f"\nCascade Risk: {console.risk_icon(summary.cascade_risk)} {summary.cascade_risk.upper()}")
 
     # Heatmap
     print(console.section("LIQUIDATION HEATMAP"))
@@ -226,7 +235,7 @@ def cmd_liquidations(args):
         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"${float(level.total_value_usd) / 1e6:.0f}M "
             f"{density_mark}{level.density.upper()}"
         )
 
@@ -237,16 +246,14 @@ def cmd_liquidations(args):
         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"${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
-        )
+        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)
@@ -255,7 +262,7 @@ def cmd_liquidations(args):
                     f"{l['exchange']:<10} "
                     f"{l['side']:<6} "
                     f"${l['price']:>10,.0f} "
-                    f"${l['value_usd']/1e6:>10.1f}M "
+                    f"${l['value_usd'] / 1e6:>10.1f}M "
                     f"{l['time_ago']:>10}"
                 )
 
@@ -272,50 +279,55 @@ def cmd_options(args):
     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),
-        }))
+        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("\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("\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"   Sentiment: {console.sentiment_icon(analysis.sentiment_from_pcr)} {analysis.sentiment_from_pcr.upper()}")
 
-    print(f"\nMax Pain:")
+    print("\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("\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"\nOverall Sentiment: {console.sentiment_icon(analysis.overall_sentiment)} "
+        f"{analysis.overall_sentiment.upper()}"
+    )
     print(f"Expiry Pressure: {analysis.expiry_pressure.upper()}")
 
     # Max pain levels
@@ -328,8 +340,8 @@ def cmd_options(args):
             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['call_oi'] / 1e9:>10.1f}B "
+                f"${lvl['put_oi'] / 1e9:>10.1f}B "
                 f"{lvl['pcr_oi']:>5.2f}"
             )
 
@@ -361,26 +373,30 @@ def cmd_basis(args):
     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": [
+        print(
+            json_fmt.format(
                 {
-                    "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,
+                    "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
+                    ],
                 }
-                for b in analysis.basis_data
-            ],
-        }))
+            )
+        )
         return
 
     print(f"\n   Spot Price: ${analysis.spot_price:,}")
@@ -399,12 +415,10 @@ def cmd_basis(args):
         )
 
     print("-" * 60)
-    print(f"\nMarket Structure: {analysis.structure_strength.title()} "
-          f"{analysis.market_structure.title()}")
+    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} "
-          f"({analysis.best_carry_yield:+.1f}% annualized)")
+    print(f"Best Carry: {analysis.best_carry_expiry} ({analysis.best_carry_yield:+.1f}% annualized)")
 
     # Term structure
     print(console.section("TERM STRUCTURE"))
@@ -422,12 +436,7 @@ def cmd_basis(args):
             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(f"{opp.expiry:<12} {opp.basis_pct:>+7.2f}% {opp.annualized_yield:>+9.1f}% {opp.direction:<12}")
 
             print("\nTop Opportunity:")
             top = opportunities[0]
@@ -440,7 +449,7 @@ def cmd_basis(args):
 def cmd_dashboard(args):
     """Handle dashboard subcommand."""
     console = ConsoleFormatter()
-    report_gen = ReportGenerator()
+    ReportGenerator()
 
     funding_tracker = FundingTracker()
     oi_analyzer = OIAnalyzer()
@@ -456,26 +465,26 @@ def cmd_dashboard(args):
         try:
             # Funding
             funding = funding_tracker.analyze(symbol)
-            print(f"\n📊 FUNDING")
+            print("\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()}")
+            print(f"   Sentiment: {console.sentiment_icon(funding.sentiment)} {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("\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()}")
+            print("\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)} {liq.cascade_risk.upper()}")
 
         except Exception as e:
             print(f"\n⚠️  Error fetching data for {symbol}: {e}")
@@ -505,45 +514,37 @@ Examples:
     # 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")
+    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")
+    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")
+    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")
+    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")
+    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")

package/skills/tracking-crypto-derivatives/scripts/formatters.py

@@ -30,11 +30,11 @@ 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"
+        return f"${val / 1e9:.1f}B"
     elif abs(val) >= 1e6:
-        return f"${val/1e6:.1f}M"
+        return f"${val / 1e6:.1f}M"
     elif abs(val) >= 1e3:
-        return f"${val/1e3:.1f}K"
+        return f"${val / 1e3:.1f}K"
     else:
         return f"${val:,.{decimals}f}"
 
@@ -216,17 +216,17 @@ class ConsoleFormatter:
         """Format options analysis summary."""
         lines = []
 
-        lines.append(f"Implied Volatility:")
+        lines.append("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("\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("\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")
 
@@ -243,10 +243,7 @@ class ConsoleFormatter:
             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}%"
-            )
+            lines.append(f"{point.get('expiry', 'N/A'):<12} {direction} {bar} {annual:+.1f}%")
 
         return "\n".join(lines)
 
@@ -377,32 +374,30 @@ class ReportGenerator:
             Formatted summary string
         """
         if format == "json":
-            return self.json_fmt.derivatives_dashboard(
-                symbol, funding, oi, liquidations
-            )
+            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("\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("\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("\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')
+        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}")
@@ -450,7 +445,7 @@ def demo():
         "metrics": {
             "funding": 0.01,
             "oi": Decimal("15000000000"),
-        }
+        },
     }
     print(json_fmt.format(sample_data))