Update app.py

app.py

@@ -21,7 +21,7 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 21 v3.2 — GOLD MACRO & FLOW ENGINE (АВТО-ОТПРАВКА)
+# 👑 TOMIRIS SPACE 21 v3.3 — GOLD MACRO & FLOW ENGINE (FIXED)
 # ============================================
 import os, time, json, logging, asyncio
 from typing import Dict, Any, List, Optional
@@ -36,47 +36,96 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(level
 logger = logging.getLogger("Space21_GoldMacro")
 
 # ================= КОНФИГУРАЦИЯ =================
+SPACE_ID = 21
+SPACE_NAME = "Gold Macro & Flow"
 SYMBOL = "XAU/USD"
-HUB_URL = os.getenv("SPACE17_URL", "https://tomiris-ai-name5-5.hf.space")
-TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "f33e660d8c1945d19e3c4ded72a2875e")
+
+# 🔥 ПРАВИЛЬНЫЙ URL ХАБА
+HUB_URL = os.getenv("HUB_URL", "https://pro-3-tomiris-hub.hf.space")
+HUB_SECRET = os.getenv("HUB_SECRET", "TomyrisUltraSecret2026!")
+
+TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "763fbc9719484fca9863f6c2b5c337f5")
 FRED_KEY = os.getenv("FRED_KEY", "faa11c8e2e4beee08c5b966e8b63a513")
-NEWSAPI_KEY = os.getenv("NEWSAPI_KEY", "948c7816beea47baa23b054592472d0e")
+NEWSAPI_KEY = os.getenv("NEWSAPI_KEY", "4742c7ca753049b7bef3e3f23d3f5aaa")
+
+STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "600"))
+AUTO_SEND_INTERVAL = int(os.getenv("AUTO_SEND_INTERVAL", "900"))
 
-# Интервал авто-отправки
-AUTO_SEND_INTERVAL = int(os.getenv("AUTO_SEND_INTERVAL", "300"))
+logger.info(f"🔗 Хаб: {HUB_URL}")
+logger.info(f"⏱️ Стартовый сон: {STARTUP_SLEEP}с | Интервал: {AUTO_SEND_INTERVAL}с")
+logger.info(f"🔑 FRED: {'✅' if FRED_KEY else '❌'} | NewsAPI: {'✅' if NEWSAPI_KEY else '❌'} | TwelveData: {'✅' if TWELVE_DATA_KEY else '❌'}")
 
 GOLD_ETFS = ["GLD", "IAU", "GDX"]
 CACHE_TTL = {"fred": 3600, "etf_aum": 600, "cot": 86400, "gpr": 900}
 CACHE: Dict[str, Any] = {}
 
 # ================= HTTP КЛИЕНТ =================
-http_client = httpx.AsyncClient(timeout=15.0)
+limits = httpx.Limits(max_connections=10, max_keepalive_connections=5)
+http_client = httpx.AsyncClient(timeout=httpx.Timeout(20.0, connect=5.0), limits=limits)
 
-# ================= ОТПРАВКА В HUB =================
-async def send_signal_to_hub(symbol: str, direction: str, confidence: float):
-    try:
-        resp = await http_client.post(f"{HUB_URL}/signal", json={
-            "space": "space_21_gold_macro",
-            "symbol": symbol,
-            "direction": direction,
-            "confidence": confidence,
-            "raw": json.dumps({"source": "space_21_gold_macro"})
-        }, timeout=10)
-        if resp.status_code == 200:
-            logger.info(f"📤 {symbol}: {direction} conf={confidence:.3f} отправлен в Hub")
-        else:
-            logger.warning(f"Hub вернул {resp.status_code}")
-    except Exception as e:
-        logger.error(f"Ошибка отправки в Hub: {e}")
+def hub_headers():
+    return {
+        "X-Hub-Secret": HUB_SECRET,
+        "Content-Type": "application/json"
+    }
+
+# ================= ОТПРАВКА В HUB (ИСПРАВЛЕНО) =================
+async def send_signal_to_hub(symbol: str, signal: str, confidence: float, features: Dict = None):
+    if features is None:
+        features = {}
+    
+    payload = {
+        "space_id": SPACE_ID,
+        "space_name": SPACE_NAME,
+        "symbol": symbol,
+        "signal": signal,           # ✅ BUY/SELL/WAIT
+        "confidence": round(confidence, 4),
+        "features": features,
+        "metadata": {"version": "3.3"},
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    for attempt in range(3):
+        try:
+            headers = hub_headers()
+            r = await http_client.post(f"{HUB_URL}/signals", json=payload, timeout=15, headers=headers)
+            if r.status_code == 200:
+                logger.info(f"📤 {symbol}: {signal} conf={confidence:.3f}")
+                return True
+            elif r.status_code == 429:
+                wait = 3 * (attempt + 1)
+                logger.warning(f"⏳ 429 для {symbol}, жду {wait}с...")
+                await asyncio.sleep(wait)
+            else:
+                logger.warning(f"Попытка {attempt+1}: HTTP {r.status_code}")
+                await asyncio.sleep(2)
+        except Exception as e:
+            logger.warning(f"Попытка {attempt+1}: {e}")
+            await asyncio.sleep(2)
+    
+    logger.error(f"❌ Не удалось отправить {symbol}")
+    return False
 
 # ================= ЗАГРУЗКА ДАННЫХ =================
 async def fetch_fred_series(series_id: str, days: int = 30) -> List[Dict]:
+    if not FRED_KEY:
+        return []
     try:
         r = await http_client.get(
-            f"https://api.stlouisfed.org/fred/series/observations?series_id={series_id}&api_key={FRED_KEY}&file_type=json&sort_order=desc&limit={days}")
+            f"https://api.stlouisfed.org/fred/series/observations?series_id={series_id}&api_key={FRED_KEY}&file_type=json&sort_order=desc&limit={days}"
+        )
         if r.status_code == 200:
             data = r.json()
-            return [{'date': obs['date'], 'value': float(obs['value'])} for obs in data.get('observations', []) if obs['value'] != '.']
+            values = []
+            for obs in data.get('observations', []):
+                if obs['value'] != '.':
+                    try:
+                        values.append({'date': obs['date'], 'value': float(obs['value'])})
+                    except ValueError:
+                        continue
+            if values:
+                logger.info(f"✅ FRED {series_id}: {len(values)} записей")
+            return values
     except Exception as e:
         logger.warning(f"FRED {series_id}: {e}")
     return []
@@ -86,13 +135,14 @@ async def fetch_dxy() -> Dict[str, Any]:
     if len(values) >= 2:
         current = values[0]['value']
         month_ago = values[-1]['value']
-        change = ((current - month_ago) / month_ago) * 100
-        return {
-            'dxy': round(current, 2),
-            'change_1m': round(change, 2),
-            'trend': 'STRENGTHENING' if change > 2 else 'WEAKENING' if change < -2 else 'STABLE',
-            'gold_signal': 'BULLISH' if change < -2 else 'BEARISH' if change > 2 else 'NEUTRAL'
-        }
+        if month_ago > 0:
+            change = ((current - month_ago) / month_ago) * 100
+            return {
+                'dxy': round(current, 2),
+                'change_1m': round(change, 2),
+                'trend': 'STRENGTHENING' if change > 2 else 'WEAKENING' if change < -2 else 'STABLE',
+                'gold_signal': 'BULLISH' if change < -2 else 'BEARISH' if change > 2 else 'NEUTRAL'
+            }
     return {'dxy': 104.5, 'gold_signal': 'NEUTRAL'}
 
 async def fetch_tips_yield() -> Dict[str, Any]:
@@ -107,6 +157,8 @@ async def fetch_tips_yield() -> Dict[str, Any]:
     return {'tips_yield': 0.5, 'gold_signal': 'NEUTRAL'}
 
 async def fetch_etf_aum(ticker: str) -> Optional[float]:
+    if not TWELVE_DATA_KEY:
+        return None
     try:
         r = await http_client.get(f"https://api.twelvedata.com/statistics?symbol={ticker}&apikey={TWELVE_DATA_KEY}")
         if r.status_code == 200:
@@ -121,14 +173,17 @@ async def analyze_etf_flows() -> Dict[str, Any]:
     etf_data = {}
     total_change = 0.0
     count = 0
+    
     for ticker in GOLD_ETFS:
         aum_now = await fetch_etf_aum(ticker)
         if aum_now is None:
             continue
+        
         prev_key = f"aum_{ticker}_prev"
         prev_aum = CACHE.get(prev_key, aum_now)
         change = aum_now - prev_aum
         change_pct = (change / prev_aum * 100) if prev_aum > 0 else 0
+        
         etf_data[ticker] = {
             "aum": aum_now,
             "change_24h": round(change_pct, 2),
@@ -139,6 +194,7 @@ async def analyze_etf_flows() -> Dict[str, Any]:
         CACHE[prev_key] = aum_now
 
     avg_change = total_change / count if count else 0
+    
     if avg_change > 1:
         flow_signal, gold_signal = "STRONG_INFLOW", "BULLISH"
     elif avg_change > 0:
@@ -148,6 +204,7 @@ async def analyze_etf_flows() -> Dict[str, Any]:
     else:
         flow_signal, gold_signal = "NEUTRAL", "NEUTRAL"
 
+    logger.info(f"✅ ETF Flow: {flow_signal} ({round(avg_change, 2)}%)")
     return {
         "etfs": etf_data,
         "avg_change_pct": round(avg_change, 2),
@@ -157,56 +214,74 @@ async def analyze_etf_flows() -> Dict[str, Any]:
 
 async def fetch_cot_report() -> Dict[str, Any]:
     try:
-        df = pd.read_csv("https://raw.githubusercontent.com/datasets/cftc-commitment-of-traders/main/data/gold.csv")
-        if not df.empty:
-            noncomm_net = df['Noncommercial_Long'] - df['Noncommercial_Short']
-            latest_net = int(noncomm_net.iloc[-1])
-            lookback = min(156, len(noncomm_net))
-            recent = noncomm_net.iloc[-lookback:]
-            percentile = (recent < latest_net).mean() * 100
-            if percentile > 80:
-                cot_signal = "BULLISH_EXTREME"
-            elif percentile > 60:
-                cot_signal = "BULLISH"
-            elif percentile < 20:
-                cot_signal = "BEARISH_EXTREME"
-            elif percentile < 40:
-                cot_signal = "BEARISH"
-            else:
-                cot_signal = "NEUTRAL"
-
-            return {
-                'report_date': str(df['Date'].iloc[-1]),
-                'noncommercial_net': latest_net,
-                'percentile': round(percentile, 1),
-                'cot_signal': cot_signal,
-                'gold_signal': 'BULLISH' if 'BULLISH' in cot_signal else 'BEARISH' if 'BEARISH' in cot_signal else 'NEUTRAL'
-            }
+        r = await http_client.get(
+            "https://raw.githubusercontent.com/datasets/cftc-commitment-of-traders/main/data/gold.csv",
+            timeout=15
+        )
+        if r.status_code == 200:
+            df = pd.read_csv(io.StringIO(r.text))
+            if not df.empty:
+                noncomm_net = df['Noncommercial_Long'] - df['Noncommercial_Short']
+                latest_net = int(noncomm_net.iloc[-1])
+                lookback = min(156, len(noncomm_net))
+                recent = noncomm_net.iloc[-lookback:]
+                percentile = (recent < latest_net).mean() * 100
+                
+                if percentile > 80:
+                    cot_signal = "BULLISH_EXTREME"
+                elif percentile > 60:
+                    cot_signal = "BULLISH"
+                elif percentile < 20:
+                    cot_signal = "BEARISH_EXTREME"
+                elif percentile < 40:
+                    cot_signal = "BEARISH"
+                else:
+                    cot_signal = "NEUTRAL"
+
+                logger.info(f"✅ COT: {cot_signal} (percentile={round(percentile, 1)}%)")
+                return {
+                    'report_date': str(df['Date'].iloc[-1]),
+                    'noncommercial_net': latest_net,
+                    'percentile': round(percentile, 1),
+                    'cot_signal': cot_signal,
+                    'gold_signal': 'BULLISH' if 'BULLISH' in cot_signal else 'BEARISH' if 'BEARISH' in cot_signal else 'NEUTRAL'
+                }
     except Exception as e:
         logger.warning(f"COT error: {e}")
     return {'cot_signal': 'NEUTRAL', 'gold_signal': 'NEUTRAL'}
 
 async def fetch_gpr() -> Dict[str, Any]:
+    if not NEWSAPI_KEY:
+        return {'gpr_level': 'UNAVAILABLE', 'gold_signal': 'NEUTRAL'}
     try:
-        r = await http_client.get(f"https://newsapi.org/v2/everything?q=geopolitical+war+sanctions&pageSize=5&apiKey={NEWSAPI_KEY}")
+        r = await http_client.get(
+            f"https://newsapi.org/v2/everything?q=geopolitical+war+sanctions&pageSize=5&apiKey={NEWSAPI_KEY}"
+        )
         if r.status_code == 200:
             total = r.json().get('totalResults', 0)
-            r_all = await http_client.get(f"https://newsapi.org/v2/everything?q=all&pageSize=5&apiKey={NEWSAPI_KEY}")
+            r_all = await http_client.get(
+                f"https://newsapi.org/v2/everything?q=all&pageSize=5&apiKey={NEWSAPI_KEY}"
+            )
             total_all = r_all.json().get('totalResults', 1) if r_all.status_code == 200 else 1000
             ratio = total / max(total_all, 1)
+            
             if ratio > 0.15:
                 level, gold_signal = "HIGH", "BULLISH"
             elif ratio > 0.08:
                 level, gold_signal = "ELEVATED", "SLIGHTLY_BULLISH"
             else:
                 level, gold_signal = "LOW", "NEUTRAL"
+            
+            logger.info(f"✅ GPR: {level} (ratio={round(ratio, 4)})")
             return {'gpr_level': level, 'mentions_share': round(ratio, 4), 'gold_signal': gold_signal}
-    except:
-        pass
-    return {'gpr_level': 'LOW', 'gold_signal': 'NEUTRAL'}
+    except Exception as e:
+        logger.warning(f"GPR error: {e}")
+    return {'gpr_level': 'UNAVAILABLE', 'gold_signal': 'NEUTRAL'}
 
 # ================= ГЛАВНЫЙ МАКРО‑АНАЛИЗ =================
 async def analyze_gold_macro() -> Dict[str, Any]:
+    logger.info("🥇 Запуск Gold Macro анализа...")
+    
     dxy, tips, etf, cot, gpr = await asyncio.gather(
         fetch_dxy(), fetch_tips_yield(), analyze_etf_flows(), fetch_cot_report(), fetch_gpr()
     )
@@ -250,16 +325,21 @@ async def analyze_gold_macro() -> Dict[str, Any]:
 
     score = max(0, min(100, score))
 
+    # 🔥 BUY/SELL вместо LONG/SHORT
     if score > 60:
-        direction, confidence = "LONG", score / 100
+        signal = "BUY"
+        confidence = score / 100
     elif score < 40:
-        direction, confidence = "SHORT", (100 - score) / 100
+        signal = "SELL"
+        confidence = (100 - score) / 100
     else:
-        direction, confidence = "WAIT", 0.0
+        signal = "WAIT"
+        confidence = 0.0
 
+    logger.info(f"🥇 Gold Macro Score: {score} → {signal} (conf={confidence:.3f})")
     return {
         "macro_score": score,
-        "direction": direction,
+        "signal": signal,
         "confidence": round(confidence, 4),
         "signals": signals,
         "metrics": {
@@ -275,48 +355,44 @@ async def analyze_gold_macro() -> Dict[str, Any]:
 async def get_gold_macro_signal() -> Dict[str, Any]:
     start = time.time()
     analysis = await analyze_gold_macro()
-    latency = int((time.time() - start) * 1000)
-
-    await send_signal_to_hub(SYMBOL, analysis['direction'], analysis['confidence'])
-
-    result = {
-        "space": "space_21_gold_macro",
-        "timestamp": int(time.time()),
+    
+    features = {
+        "macro_score": analysis['macro_score'],
+        "dxy_change": analysis['metrics'].get('dxy', {}).get('change_1m', 0),
+        "etf_flow": analysis['metrics'].get('etf_flows', {}).get('avg_change_pct', 0)
+    }
+    await send_signal_to_hub(SYMBOL, analysis['signal'], analysis['confidence'], features)
+    
+    elapsed = int((time.time() - start) * 1000)
+    
+    return {
+        "space_id": SPACE_ID,
         "symbol": SYMBOL,
-        "signal": {
-            "direction": analysis['direction'],
-            "confidence": analysis['confidence']
-        },
-        "macro_analysis": {
-            "score": analysis['macro_score'],
-            "signals": analysis['signals'],
-            "metrics": analysis['metrics']
-        },
-        "latency_ms": latency
+        "signal": analysis['signal'],
+        "confidence": analysis['confidence'],
+        "macro_score": analysis['macro_score'],
+        "latency_ms": elapsed
     }
 
-    logger.info(f"🥇 Gold Macro: {analysis['direction']} | Score={analysis['macro_score']}")
-    return result
-
 # ================= АВТО-ОТПРАВКА =================
 async def auto_send_loop():
-    logger.info(f"🔄 Авто-отправка Gold Macro запущена (интервал {AUTO_SEND_INTERVAL}с)")
-    await asyncio.sleep(30)
+    logger.info(f"⏳ Стартовый сон {STARTUP_SLEEP}с...")
+    await asyncio.sleep(STARTUP_SLEEP)
+    logger.info(f"🔄 Авто-отправка Gold Macro (интервал {AUTO_SEND_INTERVAL}с)")
     while True:
         try:
             await get_gold_macro_signal()
-            logger.info("✅ Gold Macro авто-отправка завершена")
         except Exception as e:
             logger.error(f"Ошибка авто-отправки: {e}")
         await asyncio.sleep(AUTO_SEND_INTERVAL)
 
 # ================= FASTAPI =================
-app = FastAPI(title="Tomiris Space 21 v3.2 — Gold Macro & Flow Engine (Auto-Hub)")
+app = FastAPI(title="Tomiris Space 21 v3.3 — Gold Macro & Flow Engine")
 
 @app.on_event("startup")
 async def startup():
     asyncio.create_task(auto_send_loop())
-    logger.info("🚀 Space 21 v3.2 запущен с авто-отправкой в Hub")
+    logger.info(f"🚀 Space 21 v3.3 ЗАПУЩЕН | Хаб: {HUB_URL}")
 
 @app.on_event("shutdown")
 async def shutdown():
@@ -325,13 +401,16 @@ async def shutdown():
 @app.get("/health")
 async def health():
     return {
+        "space_id": SPACE_ID,
         "status": "operational",
-        "version": "3.2",
-        "hub_url": HUB_URL,
-        "auto_send_interval": AUTO_SEND_INTERVAL,
-        "async": True
+        "version": "3.3",
+        "hub_url": HUB_URL
     }
 
+@app.head("/health")
+async def health_head():
+    return {}
+
 @app.get("/consilium")
 async def consilium():
     return await get_gold_macro_signal()
@@ -364,8 +443,12 @@ async def full():
 async def send_now():
     return await get_gold_macro_signal()
 
+@app.get("/")
+async def root():
+    return {"name": "Gold Macro & Flow v3.3", "space_id": SPACE_ID, "hub": HUB_URL}
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print("🚀 SPACE 21 v3.2 — GOLD MACRO & FLOW ENGINE (АВТО-ОТПРАВКА) ЗАПУЩЕН!")
+print("🚀 SPACE 21 v3.3 — GOLD MACRO & FLOW ENGINE ГОТОВ К РАБОТЕ!")