feat: Trading Economics API for upcoming events with forecasts

- New services/te_calendar.py: fetch_upcoming(weeks_ahead) calls TE API
  for 9 countries (USD/EUR/GBP/JPY/AUD/CAD/NZD/CHF/CNY), converts to
  ff_calendar format, upserts with source='te_api'
- New endpoints: GET/POST /api/eco/te-key, POST /api/eco/te-sync,
  GET /api/eco/te-sync/status
- Daily scheduler in main.py: FF live sync + TE sync (if key configured)
  run 60s after startup then every 24h
- CalendarPage: TEPanel with key input (password field, Enter to save,
  "Get free key" link to tradingeconomics.com/api/login),
  "Sync upcoming (6 weeks)" button with polling

FF HTML scraper kept as fallback but TE API is the primary source
for upcoming forecasts (no Cloudflare blocking on server IPs).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/services/te_calendar.py

@@ -0,0 +1,160 @@
+"""
+Trading Economics calendar service — upcoming events with consensus forecasts.
+Free API: https://tradingeconomics.com/api/login (500 calls/month)
+Endpoint: GET https://api.tradingeconomics.com/calendar/country/united%20states?c=KEY
+"""
+import logging
+from datetime import datetime, timezone, timedelta, date
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_TE_BASE = "https://api.tradingeconomics.com"
+
+# TE country names → our currency codes
+_TE_COUNTRY_TO_CCY: Dict[str, str] = {
+    "united states": "USD",
+    "euro area":     "EUR",
+    "united kingdom":"GBP",
+    "japan":         "JPY",
+    "australia":     "AUD",
+    "canada":        "CAD",
+    "new zealand":   "NZD",
+    "switzerland":   "CHF",
+    "china":         "CNY",
+}
+
+# TE importance (1=low, 2=medium, 3=high) → our impact labels
+_TE_IMPORTANCE = {1: "low", 2: "medium", 3: "high"}
+
+_COUNTRIES = list(_TE_COUNTRY_TO_CCY.keys())
+
+
+def _get_te_key() -> str:
+    from services.database import get_config
+    return (get_config("te_api_key") or "").strip()
+
+
+def check_te_key() -> Dict[str, Any]:
+    key = _get_te_key()
+    return {
+        "configured": bool(key),
+        "preview": (key[:4] + "…" + key[-4:]) if len(key) > 8 else ("***" if key else ""),
+    }
+
+
+def _parse_te_datetime(dt_str: str) -> tuple[str, str]:
+    """Parse TE datetime '2026-07-04T12:30:00' (UTC) → (date, time)."""
+    if not dt_str:
+        return "", "00:00"
+    try:
+        # TE returns UTC datetimes
+        dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d"), dt.strftime("%H:%M")
+    except Exception:
+        return dt_str[:10] if len(dt_str) >= 10 else "", "00:00"
+
+
+def fetch_upcoming(weeks_ahead: int = 6) -> Dict[str, Any]:
+    """
+    Fetch upcoming calendar events from Trading Economics API and upsert into ff_calendar.
+    Covers today → today + weeks_ahead weeks.
+    """
+    from services.database import get_conn
+    from services.ff_calendar import _upsert_batch, FF_TO_FRED, SUPPORTED_CURRENCIES
+
+    key = _get_te_key()
+    if not key:
+        return {"error": "Trading Economics API key not configured. Register free at tradingeconomics.com/api/login"}
+
+    today = date.today()
+    date_to = today + timedelta(weeks=weeks_ahead)
+
+    params = {
+        "c":         key,
+        "d1":        str(today),
+        "d2":        str(date_to),
+        "importance": "1,2,3",          # all impact levels
+    }
+
+    total_inserted = 0
+    conn = get_conn()
+
+    for country in _COUNTRIES:
+        ccy = _TE_COUNTRY_TO_CCY[country]
+        try:
+            url = f"{_TE_BASE}/calendar/country/{country.replace(' ', '%20')}"
+            resp = httpx.get(url, params=params, timeout=20, follow_redirects=True)
+            print(f"[TE calendar] {country}: HTTP {resp.status_code}", flush=True)
+
+            if resp.status_code == 401:
+                conn.close()
+                return {"error": "Invalid Trading Economics API key"}
+            if resp.status_code == 403:
+                conn.close()
+                return {"error": "TE API key quota exceeded or invalid plan"}
+
+            resp.raise_for_status()
+            events = resp.json()
+            if not isinstance(events, list):
+                continue
+
+            batch = []
+            for ev in events:
+                event_name = (ev.get("Event") or ev.get("event") or "").strip()
+                if not event_name:
+                    continue
+
+                importance = ev.get("Importance") or ev.get("importance") or 1
+                impact = _TE_IMPORTANCE.get(int(importance), "low")
+
+                dt_str = ev.get("Date") or ev.get("date") or ""
+                ev_date, ev_time = _parse_te_datetime(dt_str)
+                if not ev_date:
+                    continue
+
+                actual   = _fmt_val(ev.get("Actual")   or ev.get("actual"))
+                forecast = _fmt_val(ev.get("Forecast")  or ev.get("forecast"))
+                previous = _fmt_val(ev.get("Previous")  or ev.get("previous"))
+
+                series_id = FF_TO_FRED.get(event_name)
+
+                batch.append((
+                    ev_date, ev_time, ccy, impact, event_name,
+                    actual or None, forecast or None, previous or None,
+                    series_id, None, "te_api",
+                ))
+
+            if batch:
+                _upsert_batch(conn, batch)
+                conn.commit()
+                total_inserted += len(batch)
+                print(f"[TE calendar] {country}: {len(batch)} events upserted", flush=True)
+
+        except Exception as e:
+            logger.warning(f"[TE calendar] {country}: {e}")
+            print(f"[TE calendar] {country} error: {e}", flush=True)
+
+    conn.close()
+    return {
+        "total_upserted": total_inserted,
+        "date_from":      str(today),
+        "date_to":        str(date_to),
+        "countries":      len(_COUNTRIES),
+    }
+
+
+def _fmt_val(v: Any) -> str:
+    """Convert TE numeric value to string, return empty if None/NaN."""
+    if v is None:
+        return ""
+    try:
+        f = float(v)
+        if f != f:  # NaN check
+            return ""
+        # Format cleanly: no trailing .0 for integers
+        return str(int(f)) if f == int(f) else str(round(f, 4))
+    except (TypeError, ValueError):
+        return str(v).strip()