AdrianoDev
a13e3fe045
Common (mcp_common): - indicators.py: vol_cone, hurst_exponent, half_life_mean_reversion, garch11_forecast, autocorrelation, rolling_sharpe, var_cvar - options.py (nuovo): oi_weighted_skew, smile_asymmetry, atm_vs_wings_vol, dealer_gamma_profile, vanna_charm_aggregate - microstructure.py (nuovo): orderbook_imbalance (ratio + microprice + slope) - stats.py (nuovo): cointegration_test Engle-Granger + ADF helper Deribit (+6 tool MCP): - get_dealer_gamma_profile (net dealer gamma + flip level) - get_vanna_charm (vanna/charm aggregati pesati OI) - get_oi_weighted_skew, get_smile_asymmetry, get_atm_vs_wings_vol - get_orderbook_imbalance Bybit (+2 tool MCP): - get_orderbook_imbalance, get_basis_term_structure (futures dated curve) Macro (+2 tool MCP): - get_yield_curve_slope (2y10y/5y30y + butterfly + regime) - get_breakeven_inflation (FRED T5YIE/T10YIE/T5YIFR) Sentiment (+3 tool MCP): - get_funding_arb_spread (opportunità arb compatte annualizzate) - get_liquidation_heatmap (heuristic da OI delta + funding extreme, no feed paid Coinglass) - get_cointegration_pairs (Engle-Granger su coppie crypto Binance hourly) Tutto in TDD pure-Python (no numpy/scipy in mcp_common). README aggiornato con elenco completo. 442 test totali verdi. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
656 lines
25 KiB
Python
656 lines
25 KiB
Python
from __future__ import annotations
|
|
|
|
import os
|
|
import re
|
|
import xml.etree.ElementTree as ET
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
CRYPTOPANIC_URL = "https://cryptopanic.com/api/v1/posts/"
|
|
ALTERNATIVE_ME_URL = "https://api.alternative.me/fng/"
|
|
COINDESK_RSS = "https://www.coindesk.com/arc/outboundfeeds/rss/"
|
|
LUNARCRUSH_COIN_URL = "https://lunarcrush.com/api4/public/coins/{symbol}/v1"
|
|
CRYPTOCOMPARE_NEWS_URL = "https://min-api.cryptocompare.com/data/v2/news/"
|
|
MESSARI_NEWS_URL = "https://data.messari.io/api/v1/news"
|
|
|
|
|
|
async def _fetch_coindesk_headlines(limit: int = 20) -> list[dict[str, Any]]:
|
|
items: list[dict[str, Any]] = []
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10, follow_redirects=True) as client:
|
|
resp = await client.get(COINDESK_RSS)
|
|
if resp.status_code != 200:
|
|
return items
|
|
root = ET.fromstring(resp.text)
|
|
for node in root.findall(".//item")[:limit]:
|
|
items.append(
|
|
{
|
|
"title": node.findtext("title", ""),
|
|
"source": "CoinDesk",
|
|
"published_at": node.findtext("pubDate", ""),
|
|
"url": node.findtext("link", ""),
|
|
}
|
|
)
|
|
except Exception:
|
|
pass
|
|
return items
|
|
|
|
WORLD_NEWS_FEEDS = [
|
|
("Reuters Business", "https://feeds.reuters.com/reuters/businessNews"),
|
|
("CNBC Top News", "https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=100003114"),
|
|
("Bloomberg Markets", "https://feeds.bloomberg.com/markets/news.rss"),
|
|
("CoinDesk", "https://www.coindesk.com/arc/outboundfeeds/rss/"),
|
|
]
|
|
|
|
# Public funding rate endpoints (no auth required)
|
|
BINANCE_FUNDING_URL = "https://fapi.binance.com/fapi/v1/premiumIndex"
|
|
BYBIT_FUNDING_URL = "https://api.bybit.com/v5/market/tickers"
|
|
OKX_FUNDING_URL = "https://www.okx.com/api/v5/public/funding-rate"
|
|
BINANCE_OI_HIST_URL = "https://fapi.binance.com/futures/data/openInterestHist"
|
|
|
|
|
|
async def _fetch_cryptocompare_news(limit: int = 20) -> list[dict[str, Any]]:
|
|
"""CER-017: CryptoCompare news free (no key needed)."""
|
|
items: list[dict[str, Any]] = []
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(CRYPTOCOMPARE_NEWS_URL, params={"lang": "EN"})
|
|
if resp.status_code != 200:
|
|
return items
|
|
data = resp.json()
|
|
for r in (data.get("Data") or [])[:limit]:
|
|
ts = r.get("published_on")
|
|
try:
|
|
import datetime as _dt
|
|
pub = _dt.datetime.fromtimestamp(int(ts), _dt.UTC).isoformat() if ts else ""
|
|
except (TypeError, ValueError):
|
|
pub = ""
|
|
items.append({
|
|
"title": r.get("title", ""),
|
|
"source": r.get("source", "CryptoCompare"),
|
|
"published_at": pub,
|
|
"url": r.get("url", ""),
|
|
"provider": "cryptocompare",
|
|
})
|
|
except Exception:
|
|
pass
|
|
return items
|
|
|
|
|
|
async def _fetch_messari_news(limit: int = 20) -> list[dict[str, Any]]:
|
|
"""CER-017: Messari news free (no key needed for basic feed)."""
|
|
items: list[dict[str, Any]] = []
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(MESSARI_NEWS_URL)
|
|
if resp.status_code != 200:
|
|
return items
|
|
data = resp.json()
|
|
for r in (data.get("data") or [])[:limit]:
|
|
items.append({
|
|
"title": r.get("title", ""),
|
|
"source": (r.get("author") or {}).get("name") or "Messari",
|
|
"published_at": r.get("published_at", ""),
|
|
"url": r.get("url", ""),
|
|
"provider": "messari",
|
|
})
|
|
except Exception:
|
|
pass
|
|
return items
|
|
|
|
|
|
def _normalize_title(t: str) -> str:
|
|
"""Lowercase + strip non-alnum per dedup tra provider."""
|
|
return "".join(ch for ch in t.lower() if ch.isalnum() or ch.isspace()).strip()
|
|
|
|
|
|
async def fetch_crypto_news(api_key: str = "", limit: int = 20) -> dict[str, Any]:
|
|
"""CER-017: multi-source aggregator (CoinDesk + CryptoCompare + Messari) + dedup.
|
|
|
|
Se `api_key` Cryptopanic presente, include anche quella come 4° source.
|
|
"""
|
|
import asyncio
|
|
|
|
# CoinDesk + CryptoCompare + Messari sempre (free, no key)
|
|
tasks = [
|
|
_fetch_coindesk_headlines(limit),
|
|
_fetch_cryptocompare_news(limit),
|
|
_fetch_messari_news(limit),
|
|
]
|
|
include_cp = bool(api_key) and api_key.lower() not in ("placeholder", "none", "changeme")
|
|
if include_cp:
|
|
tasks.append(_fetch_cryptopanic_news(api_key, limit))
|
|
|
|
results = await asyncio.gather(*tasks, return_exceptions=True)
|
|
all_items: list[dict[str, Any]] = []
|
|
providers_ok: list[str] = []
|
|
providers_failed: list[str] = []
|
|
provider_names = ["coindesk", "cryptocompare", "messari"]
|
|
if include_cp:
|
|
provider_names.append("cryptopanic")
|
|
for name, res in zip(provider_names, results, strict=True):
|
|
if isinstance(res, Exception) or not res:
|
|
providers_failed.append(name)
|
|
continue
|
|
providers_ok.append(name)
|
|
for item in res:
|
|
if "provider" not in item:
|
|
item["provider"] = name
|
|
all_items.append(item)
|
|
|
|
# Dedup per normalized title — preserva primo match
|
|
seen: set[str] = set()
|
|
deduped: list[dict[str, Any]] = []
|
|
for h in all_items:
|
|
key = _normalize_title(h.get("title", ""))
|
|
if not key or key in seen:
|
|
continue
|
|
seen.add(key)
|
|
deduped.append(h)
|
|
|
|
# Sort per published_at DESC (stringhe ISO confrontabili; quelle vuote in fondo)
|
|
deduped.sort(key=lambda x: x.get("published_at") or "", reverse=True)
|
|
|
|
return {
|
|
"headlines": deduped[:limit],
|
|
"sources": providers_ok,
|
|
"sources_failed": providers_failed,
|
|
"total_before_dedup": len(all_items),
|
|
"total_after_dedup": len(deduped),
|
|
}
|
|
|
|
|
|
async def _fetch_cryptopanic_news(api_key: str, limit: int) -> list[dict[str, Any]]:
|
|
"""Cryptopanic as one of the sources. Failure → []."""
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
CRYPTOPANIC_URL,
|
|
params={"auth_token": api_key, "public": "true"},
|
|
)
|
|
if resp.status_code >= 400:
|
|
return []
|
|
data = resp.json()
|
|
except Exception:
|
|
return []
|
|
return [
|
|
{
|
|
"title": r.get("title", ""),
|
|
"source": (r.get("source") or {}).get("title", "Cryptopanic"),
|
|
"published_at": r.get("published_at", ""),
|
|
"url": r.get("url", ""),
|
|
"provider": "cryptopanic",
|
|
}
|
|
for r in (data.get("results") or [])[:limit]
|
|
]
|
|
|
|
|
|
async def _fetch_lunarcrush(symbol: str, api_key: str) -> dict | None:
|
|
"""CER-P2-005: LunarCrush v4 social metrics. Ritorna None se fail."""
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
LUNARCRUSH_COIN_URL.format(symbol=symbol.upper()),
|
|
headers={"Authorization": f"Bearer {api_key}"},
|
|
)
|
|
if resp.status_code != 200:
|
|
return None
|
|
data = (resp.json() or {}).get("data") or {}
|
|
return {
|
|
"galaxy_score": data.get("galaxy_score"),
|
|
"alt_rank": data.get("alt_rank"),
|
|
"sentiment": data.get("sentiment"), # 0-100 scale
|
|
"social_volume_24h": data.get("social_volume_24h"),
|
|
"social_dominance": data.get("social_dominance"),
|
|
}
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _fng_to_sentiment(value: int) -> float:
|
|
"""Normalize fear&greed 0-100 to [-1, 1] proxy sentiment."""
|
|
return round((value - 50) / 50.0, 3)
|
|
|
|
|
|
async def fetch_social_sentiment(symbol: str = "BTC") -> dict[str, Any]:
|
|
"""CER-P2-005: provider chain LunarCrush + fear_greed proxy.
|
|
|
|
Se LUNARCRUSH_API_KEY env è presente e risponde, usa valori reali.
|
|
Altrimenti deriva proxy da fear_greed per popolare twitter/reddit sentiment
|
|
(marcato come derived=True così l'agent sa che è proxy).
|
|
"""
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
fng_resp = await client.get(ALTERNATIVE_ME_URL, params={"limit": 1})
|
|
fng_data = fng_resp.json()
|
|
fng_list = fng_data.get("data", [])
|
|
fng = fng_list[0] if fng_list else {}
|
|
fng_value = int(fng.get("value", 0))
|
|
proxy = _fng_to_sentiment(fng_value) if fng_value else 0.0
|
|
|
|
result: dict[str, Any] = {
|
|
"fear_greed_index": fng_value,
|
|
"fear_greed_label": fng.get("value_classification", ""),
|
|
"symbol": symbol.upper(),
|
|
"social_volume": 0,
|
|
"twitter_sentiment": 0.0,
|
|
"reddit_sentiment": 0.0,
|
|
"source": "fear_greed_only",
|
|
"derived": True,
|
|
}
|
|
|
|
lc_key = os.environ.get("LUNARCRUSH_API_KEY", "").strip()
|
|
if lc_key:
|
|
lc = await _fetch_lunarcrush(symbol, lc_key)
|
|
if lc is not None:
|
|
# LunarCrush sentiment 0-100 → normalize to [-1, 1]
|
|
lc_sent = lc.get("sentiment")
|
|
norm = round((float(lc_sent) - 50) / 50.0, 3) if lc_sent is not None else None
|
|
result.update({
|
|
"twitter_sentiment": norm if norm is not None else proxy,
|
|
"reddit_sentiment": norm if norm is not None else proxy,
|
|
"social_volume": int(lc.get("social_volume_24h") or 0),
|
|
"galaxy_score": lc.get("galaxy_score"),
|
|
"alt_rank": lc.get("alt_rank"),
|
|
"social_dominance": lc.get("social_dominance"),
|
|
"source": "lunarcrush+fear_greed",
|
|
"derived": False,
|
|
})
|
|
return result
|
|
|
|
# Proxy-only path
|
|
result["twitter_sentiment"] = proxy
|
|
result["reddit_sentiment"] = proxy
|
|
result["note"] = (
|
|
"twitter/reddit derived from fear_greed_index; configure LUNARCRUSH_API_KEY "
|
|
"for real social metrics"
|
|
)
|
|
return result
|
|
|
|
|
|
async def fetch_funding_rates(asset: str = "BTC") -> dict[str, Any]:
|
|
"""Fetch perpetual funding rates from Binance, Bybit and OKX public APIs."""
|
|
asset = asset.upper()
|
|
usdt_symbol = f"{asset}USDT"
|
|
okx_inst = f"{asset}-USDT-SWAP"
|
|
rates: list[dict[str, Any]] = []
|
|
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
# Binance
|
|
try:
|
|
resp = await client.get(BINANCE_FUNDING_URL, params={"symbol": usdt_symbol})
|
|
if resp.status_code == 200:
|
|
d = resp.json()
|
|
rates.append(
|
|
{
|
|
"exchange": "binance",
|
|
"asset": asset,
|
|
"rate": float(d.get("lastFundingRate", 0)),
|
|
"next_funding_time": d.get("nextFundingTime", ""),
|
|
}
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
# Bybit
|
|
try:
|
|
resp = await client.get(
|
|
BYBIT_FUNDING_URL,
|
|
params={"category": "linear", "symbol": usdt_symbol},
|
|
)
|
|
if resp.status_code == 200:
|
|
items = resp.json().get("result", {}).get("list", [])
|
|
if items:
|
|
d = items[0]
|
|
rates.append(
|
|
{
|
|
"exchange": "bybit",
|
|
"asset": asset,
|
|
"rate": float(d.get("fundingRate", 0)),
|
|
"next_funding_time": d.get("nextFundingTime", ""),
|
|
}
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
# OKX
|
|
try:
|
|
resp = await client.get(OKX_FUNDING_URL, params={"instId": okx_inst})
|
|
if resp.status_code == 200:
|
|
items = resp.json().get("data", [])
|
|
if items:
|
|
d = items[0]
|
|
rates.append(
|
|
{
|
|
"exchange": "okx",
|
|
"asset": asset,
|
|
"rate": float(d.get("fundingRate", 0)),
|
|
"next_funding_time": d.get("nextFundingTime", ""),
|
|
}
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
return {"asset": asset, "rates": rates}
|
|
|
|
|
|
async def fetch_cross_exchange_funding(assets: list[str] | None = None) -> dict[str, Any]:
|
|
"""Snapshot multi-asset funding rates con spread e arbitrage detection."""
|
|
from datetime import UTC, datetime as _dt
|
|
|
|
assets = [a.upper() for a in (assets or ["BTC", "ETH", "SOL"])]
|
|
snapshot: dict[str, dict[str, Any]] = {}
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
for asset in assets:
|
|
rates: dict[str, float | None] = {
|
|
"binance": None,
|
|
"bybit": None,
|
|
"okx": None,
|
|
"hyperliquid": None,
|
|
}
|
|
try:
|
|
resp = await client.get(
|
|
BINANCE_FUNDING_URL, params={"symbol": f"{asset}USDT"}
|
|
)
|
|
if resp.status_code == 200:
|
|
rates["binance"] = float(resp.json().get("lastFundingRate", 0))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
resp = await client.get(
|
|
BYBIT_FUNDING_URL,
|
|
params={"category": "linear", "symbol": f"{asset}USDT"},
|
|
)
|
|
if resp.status_code == 200:
|
|
items = resp.json().get("result", {}).get("list", [])
|
|
if items:
|
|
rates["bybit"] = float(items[0].get("fundingRate", 0))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
resp = await client.get(
|
|
OKX_FUNDING_URL, params={"instId": f"{asset}-USDT-SWAP"}
|
|
)
|
|
if resp.status_code == 200:
|
|
items = resp.json().get("data", [])
|
|
if items:
|
|
rates["okx"] = float(items[0].get("fundingRate", 0))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
resp = await client.post(
|
|
"https://api.hyperliquid.xyz/info",
|
|
json={"type": "metaAndAssetCtxs"},
|
|
)
|
|
if resp.status_code == 200:
|
|
data = resp.json()
|
|
universe = data[0].get("universe") or []
|
|
ctx_list = data[1] if len(data) > 1 else []
|
|
for meta, ctx in zip(universe, ctx_list, strict=False):
|
|
if meta.get("name", "").upper() == asset:
|
|
rates["hyperliquid"] = float(ctx.get("funding", 0))
|
|
break
|
|
except Exception:
|
|
pass
|
|
|
|
present = [v for v in rates.values() if v is not None]
|
|
spread_max_min = max(present) - min(present) if present else None
|
|
anomaly = None
|
|
if present and spread_max_min is not None:
|
|
mean_r = sum(present) / len(present)
|
|
for name, v in rates.items():
|
|
if v is None:
|
|
continue
|
|
if abs(v - mean_r) > 2 * (spread_max_min / 2 or 1e-9):
|
|
anomaly = f"{name}_outlier"
|
|
break
|
|
|
|
snapshot[asset] = {
|
|
**rates,
|
|
"spread_max_min": spread_max_min,
|
|
"anomaly": anomaly,
|
|
}
|
|
|
|
# Arbitrage opportunities
|
|
arbs = []
|
|
for asset, data in snapshot.items():
|
|
values = [(k, v) for k, v in data.items() if k in ("binance", "bybit", "okx", "hyperliquid") and v is not None]
|
|
if len(values) < 2:
|
|
continue
|
|
values.sort(key=lambda x: x[1])
|
|
low_ex, low_v = values[0]
|
|
high_ex, high_v = values[-1]
|
|
diff = high_v - low_v
|
|
ann_pct = diff * 24 * 365 * 100 # hourly funding → annual pct
|
|
if ann_pct > 50:
|
|
arbs.append({
|
|
"asset": asset,
|
|
"pair": f"long_{low_ex}_short_{high_ex}",
|
|
"funding_differential_ann": round(ann_pct, 2),
|
|
"risk_adjusted": "acceptable" if ann_pct > 100 else "marginal",
|
|
})
|
|
|
|
return {
|
|
"assets": assets,
|
|
"snapshot": snapshot,
|
|
"arbitrage_opportunities": arbs,
|
|
"data_timestamp": _dt.now(UTC).isoformat(),
|
|
}
|
|
|
|
|
|
async def fetch_funding_arb_spread(assets: list[str] | None = None) -> dict[str, Any]:
|
|
"""Riassume opportunità di arbitrage funding su cross-exchange in un
|
|
formato compatto: per ogni asset, rate min/max + spread + annualized %.
|
|
Wrapper su fetch_cross_exchange_funding focalizzato su action items.
|
|
"""
|
|
base = await fetch_cross_exchange_funding(assets)
|
|
snapshot = base.get("snapshot") or {}
|
|
rows: list[dict[str, Any]] = []
|
|
for asset, data in snapshot.items():
|
|
rates = {k: v for k, v in data.items() if k in ("binance", "bybit", "okx", "hyperliquid") and v is not None}
|
|
if len(rates) < 2:
|
|
continue
|
|
sorted_rates = sorted(rates.items(), key=lambda x: x[1])
|
|
low_ex, low_v = sorted_rates[0]
|
|
high_ex, high_v = sorted_rates[-1]
|
|
spread = high_v - low_v
|
|
# Funding cycle: 8h on most, 1h on hyperliquid → assume 8h => 3x/day
|
|
ann_pct = spread * 3 * 365 * 100
|
|
actionable = ann_pct > 50
|
|
rows.append({
|
|
"asset": asset,
|
|
"long_venue": low_ex,
|
|
"short_venue": high_ex,
|
|
"long_funding": low_v,
|
|
"short_funding": high_v,
|
|
"spread": spread,
|
|
"annualized_pct": round(ann_pct, 2),
|
|
"actionable": actionable,
|
|
})
|
|
rows.sort(key=lambda r: -r["annualized_pct"])
|
|
return {
|
|
"opportunities": rows,
|
|
"data_timestamp": base.get("data_timestamp"),
|
|
}
|
|
|
|
|
|
async def fetch_liquidation_heatmap(asset: str = "BTC") -> dict[str, Any]:
|
|
"""Heuristic liquidation pressure: combina OI delta + funding extreme su
|
|
asset. NON usa feed liq paid (Coinglass): stima dove si concentra
|
|
leveraged exposure pronta a essere liquidata.
|
|
|
|
long_squeeze_risk: high se OI cresce + funding positivo (long crowded).
|
|
short_squeeze_risk: high se OI cresce + funding negativo (short crowded).
|
|
"""
|
|
asset = asset.upper()
|
|
oi = await fetch_oi_history(asset=asset, period="5m", limit=288)
|
|
funding = await fetch_cross_exchange_funding(assets=[asset])
|
|
snap = (funding.get("snapshot") or {}).get(asset) or {}
|
|
rates = [v for k, v in snap.items() if k in ("binance", "bybit", "okx", "hyperliquid") and v is not None]
|
|
avg_funding = sum(rates) / len(rates) if rates else None
|
|
|
|
delta_4h = oi.get("delta_pct_4h")
|
|
delta_24h = oi.get("delta_pct_24h")
|
|
|
|
long_risk = "low"
|
|
short_risk = "low"
|
|
if avg_funding is not None and delta_24h is not None:
|
|
if avg_funding > 0.0001 and delta_24h > 5:
|
|
long_risk = "high"
|
|
elif avg_funding > 0.00005 and delta_24h > 2:
|
|
long_risk = "medium"
|
|
if avg_funding < -0.0001 and delta_24h > 5:
|
|
short_risk = "high"
|
|
elif avg_funding < -0.00005 and delta_24h > 2:
|
|
short_risk = "medium"
|
|
|
|
return {
|
|
"asset": asset,
|
|
"avg_funding_rate": avg_funding,
|
|
"oi_delta_pct_4h": delta_4h,
|
|
"oi_delta_pct_24h": delta_24h,
|
|
"long_squeeze_risk": long_risk,
|
|
"short_squeeze_risk": short_risk,
|
|
"note": "heuristic — non sostituisce feed liq dedicati (Coinglass).",
|
|
}
|
|
|
|
|
|
async def fetch_cointegration_pairs(
|
|
pairs: list[list[str]] | None = None,
|
|
lookback_hours: int = 24,
|
|
) -> dict[str, Any]:
|
|
"""Test Engle-Granger su coppie crypto su Binance hourly.
|
|
pairs: lista di [base, quote] (es. [["BTC", "ETH"]]). Default top-3.
|
|
"""
|
|
from mcp_common.stats import cointegration_test
|
|
|
|
pairs = pairs or [["BTC", "ETH"], ["BTC", "SOL"], ["ETH", "SOL"]]
|
|
out: list[dict[str, Any]] = []
|
|
interval = "1h"
|
|
limit = max(50, lookback_hours)
|
|
|
|
async with httpx.AsyncClient(timeout=15) as client:
|
|
for pair in pairs:
|
|
if len(pair) != 2:
|
|
continue
|
|
a, b = pair[0].upper(), pair[1].upper()
|
|
sym_a = f"{a}USDT"
|
|
sym_b = f"{b}USDT"
|
|
try:
|
|
resp_a = await client.get(
|
|
"https://api.binance.com/api/v3/klines",
|
|
params={"symbol": sym_a, "interval": interval, "limit": limit},
|
|
)
|
|
resp_b = await client.get(
|
|
"https://api.binance.com/api/v3/klines",
|
|
params={"symbol": sym_b, "interval": interval, "limit": limit},
|
|
)
|
|
if resp_a.status_code != 200 or resp_b.status_code != 200:
|
|
continue
|
|
closes_a = [float(k[4]) for k in resp_a.json()]
|
|
closes_b = [float(k[4]) for k in resp_b.json()]
|
|
if len(closes_a) != len(closes_b):
|
|
n = min(len(closes_a), len(closes_b))
|
|
closes_a = closes_a[-n:]
|
|
closes_b = closes_b[-n:]
|
|
result = cointegration_test(closes_a, closes_b)
|
|
out.append({
|
|
"pair": [a, b],
|
|
"samples": len(closes_a),
|
|
**result,
|
|
})
|
|
except Exception as e:
|
|
out.append({"pair": [a, b], "error": str(e)})
|
|
|
|
out.sort(key=lambda r: r.get("adf_t_stat") or 0)
|
|
return {
|
|
"results": out,
|
|
"lookback_hours": lookback_hours,
|
|
}
|
|
|
|
|
|
async def fetch_world_news() -> dict[str, Any]:
|
|
"""Fetch world financial news from free RSS feeds."""
|
|
articles: list[dict[str, Any]] = []
|
|
|
|
async with httpx.AsyncClient(timeout=10, follow_redirects=True) as client:
|
|
for source_name, url in WORLD_NEWS_FEEDS:
|
|
try:
|
|
resp = await client.get(url)
|
|
if resp.status_code != 200:
|
|
continue
|
|
root = ET.fromstring(resp.text)
|
|
for item in root.findall(".//item")[:5]:
|
|
title = item.findtext("title", "")
|
|
link = item.findtext("link", "")
|
|
pub_date = item.findtext("pubDate", "")
|
|
description = item.findtext("description", "")
|
|
if "<" in description:
|
|
description = re.sub(r"<[^>]+>", "", description).strip()
|
|
articles.append(
|
|
{
|
|
"source": source_name,
|
|
"title": title,
|
|
"url": link,
|
|
"published": pub_date,
|
|
"summary": description[:200] if description else "",
|
|
}
|
|
)
|
|
except Exception:
|
|
continue
|
|
|
|
return {"articles": articles, "count": len(articles)}
|
|
|
|
|
|
async def fetch_oi_history(asset: str = "BTC", period: str = "5m", limit: int = 288) -> dict[str, Any]:
|
|
"""Open interest history perpetual da Binance futures (public).
|
|
|
|
period: 5m|15m|30m|1h|2h|4h|6h|12h|1d (Binance API).
|
|
limit: 1..500, default 288 = 24h a 5min.
|
|
"""
|
|
asset = asset.upper()
|
|
symbol = f"{asset}USDT"
|
|
limit = max(1, min(int(limit), 500))
|
|
points: list[dict[str, Any]] = []
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
BINANCE_OI_HIST_URL,
|
|
params={"symbol": symbol, "period": period, "limit": limit},
|
|
)
|
|
if resp.status_code == 200:
|
|
for row in resp.json() or []:
|
|
points.append(
|
|
{
|
|
"timestamp": int(row.get("timestamp", 0)),
|
|
"oi": float(row.get("sumOpenInterest", 0)),
|
|
"oi_value_usd": float(row.get("sumOpenInterestValue", 0)),
|
|
}
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
def _delta_pct(points: list[dict[str, Any]], minutes_back: int) -> float | None:
|
|
if len(points) < 2:
|
|
return None
|
|
current = points[-1]
|
|
cutoff_ts = current["timestamp"] - minutes_back * 60 * 1000
|
|
past = next((p for p in reversed(points) if p["timestamp"] <= cutoff_ts), None)
|
|
if past is None or past["oi"] == 0:
|
|
return None
|
|
return round(100.0 * (current["oi"] - past["oi"]) / past["oi"], 3)
|
|
|
|
return {
|
|
"asset": asset,
|
|
"exchange": "binance",
|
|
"symbol": symbol,
|
|
"period": period,
|
|
"points": points,
|
|
"current_oi": points[-1]["oi"] if points else None,
|
|
"current_oi_value_usd": points[-1]["oi_value_usd"] if points else None,
|
|
"delta_pct_1h": _delta_pct(points, 60),
|
|
"delta_pct_4h": _delta_pct(points, 240),
|
|
"delta_pct_24h": _delta_pct(points, 1440),
|
|
"data_points": len(points),
|
|
}
|