aria-code 0.52.0__py3-none-any.whl

aria_code/datasources/sources/finnhub_source.py

@@ -0,0 +1,198 @@
+"""
+datasources/sources/finnhub_source.py — Finnhub 美股/港股数据源
+================================================================
+使用 ~/.arthera/providers.json 中配置的 Finnhub API key，
+提供实时行情、历史 K 线、基本面数据。
+免费套餐：每分钟 60 次请求，支持美股 / ETF / 指数 / 外汇 / 加密。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import math
+import time
+import urllib.request
+from datetime import datetime, timedelta, date, timezone
+from pathlib import Path
+from typing import Optional
+
+import pandas as pd
+
+from ..base import BaseDataSource, FundamentalsResult, HistoryResult, QuoteResult
+from aria_code.packages.aria_core.paths import aria_home
+
+logger = logging.getLogger(__name__)
+
+_PROVIDERS_FILE = aria_home() / "providers.json"
+_BASE = "https://finnhub.io/api/v1"
+
+
+def _read_finnhub_key() -> str:
+    try:
+        import os
+        env = os.getenv("FINNHUB_API_KEY", "") or os.getenv("FINNHUB_KEY", "")
+        if env:
+            return env
+        if _PROVIDERS_FILE.exists():
+            raw = json.loads(_PROVIDERS_FILE.read_text(encoding="utf-8"))
+            key = raw.get("data", {}).get("finnhub", {}).get("api_key", "")
+            if key:
+                return key
+    except Exception:
+        pass
+    return ""
+
+
+def _fh_get(path: str, key: str, params: dict = None, timeout: int = 8) -> dict:
+    qs = "&".join(f"{k}={v}" for k, v in (params or {}).items())
+    url = f"{_BASE}{path}?token={key}" + (f"&{qs}" if qs else "")
+    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.loads(r.read())
+
+
+class FinnhubSource(BaseDataSource):
+
+    name         = "finnhub"
+    markets      = ["us", "hk", "crypto"]
+    requires_key = True
+
+    def __init__(self, config=None):
+        super().__init__(config)
+        self._key = _read_finnhub_key()
+
+    def is_configured(self) -> bool:
+        return bool(self._key)
+
+    # ── Quote ─────────────────────────────────────────────────────────────────
+
+    def quote(self, symbol: str) -> Optional[QuoteResult]:
+        if not self._key:
+            return None
+        sym = symbol.upper().replace(".HK", "")
+        try:
+            data = _fh_get("/quote", self._key, {"symbol": sym})
+            price = float(data.get("c") or 0)
+            if price <= 0:
+                return None
+            prev = float(data.get("pc") or price)
+            chg_pct = round((price - prev) / prev * 100, 2) if prev else 0
+
+            # Extra: company profile for name / market cap
+            name = sym
+            mkt_cap = 0.0
+            currency = "USD"
+            try:
+                prof = _fh_get("/stock/profile2", self._key, {"symbol": sym})
+                name = prof.get("name") or sym
+                mkt_cap = float(prof.get("marketCapitalization") or 0) * 1e6
+                currency = prof.get("currency") or "USD"
+            except Exception:
+                pass
+
+            return QuoteResult(
+                symbol     = symbol,
+                name       = name,
+                price      = price,
+                change     = round(price - prev, 4),
+                change_pct = chg_pct,
+                volume     = float(data.get("v") or 0),
+                high_52w   = float(data.get("h") or 0),
+                low_52w    = float(data.get("l") or 0),
+                market_cap = mkt_cap,
+                currency   = currency,
+                market     = "us",
+                source     = self.name,
+            )
+        except Exception as e:
+            logger.debug(f"[finnhub] quote({symbol}) 失败: {e}")
+            return None
+
+    # ── History ───────────────────────────────────────────────────────────────
+
+    def history(self, symbol: str, days: int = 90, interval: str = "1d") -> Optional[HistoryResult]:
+        if not self._key:
+            return None
+        sym = symbol.upper()
+        resolution = "D" if interval in ("1d", "day", "daily") else "60"
+        _end   = int(time.time())
+        _start = int((datetime.now() - timedelta(days=days + 5)).timestamp())
+        try:
+            data = _fh_get("/stock/candle", self._key, {
+                "symbol": sym, "resolution": resolution,
+                "from": _start, "to": _end,
+            })
+            if data.get("s") != "ok":
+                return None
+            t = data.get("t", [])
+            o = data.get("o", [])
+            h = data.get("h", [])
+            l = data.get("l", [])
+            c = data.get("c", [])
+            v = data.get("v", [])
+            if not c:
+                return None
+            df = pd.DataFrame({
+                "日期":  [datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d") for ts in t],
+                "开盘":  o, "最高": h, "最低": l, "收盘": c, "成交量": v,
+            })
+            df.index = pd.to_datetime(df["日期"])
+            # Also add English column aliases for DataService compatibility
+            df["Open"]   = df["开盘"]
+            df["High"]   = df["最高"]
+            df["Low"]    = df["最低"]
+            df["Close"]  = df["收盘"]
+            df["Volume"] = df["成交量"]
+            return HistoryResult(symbol=symbol, data=df, source=self.name, interval=interval)
+        except Exception as e:
+            logger.debug(f"[finnhub] history({symbol}) 失败: {e}")
+            return None
+
+    # ── Fundamentals ──────────────────────────────────────────────────────────
+
+    def fundamentals(self, symbol: str) -> Optional[FundamentalsResult]:
+        if not self._key:
+            return None
+        sym = symbol.upper()
+        try:
+            # Basic financials (PE, market cap, etc.)
+            metrics_data = _fh_get("/stock/metric", self._key, {"symbol": sym, "metric": "all"})
+            m = metrics_data.get("metric") or {}
+
+            def _mf(key: str) -> Optional[float]:
+                v = m.get(key)
+                if v is None:
+                    return None
+                try:
+                    fv = float(v)
+                    return None if (math.isnan(fv) or fv == 0) else fv
+                except (TypeError, ValueError):
+                    return None
+
+            pe   = _mf("peTTM") or _mf("peExclExtraItemsTTM")
+            pb   = _mf("pbAnnual") or _mf("pbQuarterly")
+            roe  = _mf("roeTTM") or _mf("roeAnnual")
+            div_yield = _mf("dividendYieldIndicatedAnnual")
+            rev_growth = _mf("revenueGrowthTTMYoy")
+            eps_growth = _mf("epsGrowthTTMYoy")
+            mktcap_raw = _mf("marketCapitalization")
+            total_mv = (mktcap_raw * 1e6) if mktcap_raw else None
+
+            if pe is None and pb is None and roe is None:
+                return None
+
+            return FundamentalsResult(
+                symbol         = symbol,
+                pe_ttm         = pe,
+                pb             = pb,
+                roe            = roe,
+                revenue_growth = rev_growth,
+                net_profit_growth = eps_growth,
+                dividend_yield = div_yield,
+                total_mv       = total_mv,
+                source         = self.name,
+            )
+        except Exception as e:
+            logger.debug(f"[finnhub] fundamentals({symbol}) 失败: {e}")
+            return None

aria_code/datasources/sources/fred_source.py

@@ -0,0 +1,223 @@
+"""
+datasources/sources/fred_source.py — FRED (Federal Reserve Economic Data)
+=========================================================================
+完全免费，无需 API key（可选 key 提升频率限制）。
+覆盖：宏观经济指标、利率、CPI、GDP、就业数据等 800,000+ 系列。
+
+配置（可选）: FRED_API_KEY 环境变量 或 ~/.aria/.env
+
+FRED series 示例：
+  DGS10      — 10年美国国债收益率
+  FEDFUNDS   — 联邦基金利率
+  CPIAUCSL   — 消费者价格指数
+  GDP        — 美国 GDP
+  UNRATE     — 失业率
+  SP500      — S&P 500 指数
+  DEXCNUS    — 人民币/美元汇率
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..base import BaseDataSource, HistoryResult, QuoteResult
+from aria_code.packages.aria_core.paths import aria_home
+
+logger = logging.getLogger(__name__)
+
+_FRED_BASE = "https://fred.stlouisfed.org/graph/fredgraph.csv?id="
+_FRED_API  = "https://api.stlouisfed.org/fred"
+
+# 常用宏观指标 symbol → FRED series id 映射
+MACRO_ALIASES: Dict[str, str] = {
+    "US10Y":    "DGS10",
+    "US2Y":     "DGS2",
+    "US3M":     "DTB3",
+    "FEDFUNDS": "FEDFUNDS",
+    "CPI":      "CPIAUCSL",
+    "CPIYOY":   "CPIAUCSL",
+    "PCE":      "PCEPI",
+    "GDP":      "GDP",
+    "UNRATE":   "UNRATE",
+    "NFP":      "PAYEMS",
+    "SP500":    "SP500",
+    "NASDAQ":   "NASDAQCOM",
+    "WILSHIRE": "WILL5000PR",
+    "USDINR":   "DEXINUS",
+    "USDCNY":   "DEXCHUS",
+    "USDEUR":   "DEXUSEU",
+    "VIX":      "VIXCLS",
+    "M2":       "M2SL",
+    "MORTGAGE": "MORTGAGE30US",
+    "HOUSING":  "HOUST",
+}
+
+
+def _load_api_key() -> str:
+    key = os.getenv("FRED_API_KEY", "")
+    if not key:
+        for p in [Path.home() / ".aria" / ".env", aria_home() / ".env"]:
+            if p.exists():
+                for line in p.read_text(encoding="utf-8").splitlines():
+                    if line.startswith("FRED_API_KEY="):
+                        key = line.split("=", 1)[1].strip()
+                        break
+            if key:
+                break
+    if not key:
+        try:
+            import json as _json
+            _p = aria_home() / "providers.json"
+            if _p.exists():
+                _raw = _json.loads(_p.read_text(encoding="utf-8"))
+                key = _raw.get("data", {}).get("fred", {}).get("api_key", "")
+        except Exception:
+            pass
+    return key
+
+
+class FREDSource(BaseDataSource):
+    """
+    Federal Reserve Economic Data — 宏观经济数据源。
+    无需 key 即可使用 CSV 下载接口；有 key 可使用 JSON API 获得更多元数据。
+    """
+
+    name         = "fred"
+    markets      = ["us", "macro"]
+    requires_key = False
+
+    def __init__(self, config=None):
+        super().__init__(config)
+        self._api_key = _load_api_key()
+
+    def is_configured(self) -> bool:
+        return True  # 无需 key，免费开放
+
+    def supports(self, symbol: str) -> bool:
+        s = symbol.upper()
+        return s in MACRO_ALIASES or s in MACRO_ALIASES.values()
+
+    def _resolve_series(self, symbol: str) -> str:
+        s = symbol.upper()
+        return MACRO_ALIASES.get(s, s)
+
+    def quote(self, symbol: str) -> Optional[QuoteResult]:
+        try:
+            h = self.history(symbol, days=30)
+            if h is None or h.data is None or h.data.empty:
+                return None
+            last = h.data.iloc[-1]
+            val  = float(last.get("close", last.iloc[0]))
+            series_id = self._resolve_series(symbol)
+            return QuoteResult(
+                symbol    = symbol,
+                name      = f"FRED:{series_id}",
+                price     = val,
+                currency  = "USD",
+                market    = "macro",
+                source    = self.name,
+                timestamp = str(h.data.index[-1].date()),
+            )
+        except Exception as e:
+            logger.debug(f"[fred] quote {symbol} 失败: {e}")
+            return None
+
+    def history(
+        self,
+        symbol: str,
+        days: int = 365,
+        interval: str = "1d",
+        _timeout: int = 12,
+    ) -> Optional[HistoryResult]:
+        try:
+            import pandas as pd
+            import urllib.request
+            import json
+
+            series_id = self._resolve_series(symbol)
+            start = (date.today() - timedelta(days=days)).strftime("%Y-%m-%d")
+            end   = date.today().strftime("%Y-%m-%d")
+
+            def _parse_api(url: str) -> Optional[pd.DataFrame]:
+                req = urllib.request.Request(url, headers={"User-Agent": "aria-code/1.0"})
+                with urllib.request.urlopen(req, timeout=_timeout) as resp:
+                    data = json.loads(resp.read())
+                obs = data.get("observations", [])
+                rows = []
+                for o in obs:
+                    try:
+                        rows.append({"date": o["date"], "close": float(o["value"])})
+                    except (ValueError, KeyError):
+                        pass
+                if not rows:
+                    return None
+                _df = pd.DataFrame(rows)
+                _df["date"] = pd.to_datetime(_df["date"])
+                return _df.set_index("date").sort_index()
+
+            def _parse_csv(url: str) -> Optional[pd.DataFrame]:
+                req = urllib.request.Request(url, headers={"User-Agent": "aria-code/1.0"})
+                with urllib.request.urlopen(req, timeout=_timeout) as resp:
+                    _df = pd.read_csv(resp, parse_dates=["DATE"], index_col="DATE")
+                _df.columns = ["close"]
+                _df = _df.replace(".", float("nan")).dropna()
+                _df["close"] = _df["close"].astype(float)
+                return _df if not _df.empty else None
+
+            df = None
+
+            # 优先使用 JSON API（有 key 速率更高）
+            if self._api_key:
+                api_url = (
+                    f"{_FRED_API}/series/observations?series_id={series_id}"
+                    f"&observation_start={start}&observation_end={end}"
+                    f"&api_key={self._api_key}&file_type=json"
+                )
+                try:
+                    df = _parse_api(api_url)
+                except Exception as _e1:
+                    logger.debug(f"[fred] JSON API 失败，尝试 CSV: {_e1}")
+
+            # 回落：免费 CSV 下载接口（无需 key，但国内可能超时）
+            if df is None:
+                csv_url = (
+                    f"{_FRED_BASE}{series_id}"
+                    f"&cosd={start}&coed={end}"
+                )
+                try:
+                    df = _parse_csv(csv_url)
+                except Exception as _e2:
+                    logger.debug(f"[fred] CSV 也失败: {_e2}")
+
+            if df is None:
+                return None
+            return HistoryResult(symbol=symbol, data=df, source=self.name, interval="1d")
+        except Exception as e:
+            logger.debug(f"[fred] history {symbol} 失败: {e}")
+            return None
+
+    def search_series(self, query: str, limit: int = 10) -> List[Dict[str, Any]]:
+        """用关键词搜索 FRED 系列（需要 API key）。"""
+        if not self._api_key:
+            return [{"error": "需要 FRED_API_KEY 才能搜索系列"}]
+        try:
+            import urllib.request
+            import json
+            import urllib.parse
+            q   = urllib.parse.quote(query)
+            url = (f"{_FRED_API}/series/search?search_text={q}"
+                   f"&limit={limit}&api_key={self._api_key}&file_type=json")
+            req = urllib.request.Request(url, headers={"User-Agent": "aria-code/1.0"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read())
+            return [
+                {"id": s["id"], "title": s["title"], "frequency": s.get("frequency_short"),
+                 "units": s.get("units_short"), "last_updated": s.get("last_updated")}
+                for s in data.get("seriess", [])
+            ]
+        except Exception as e:
+            return [{"error": str(e)}]

aria_code/datasources/sources/tushare_source.py

@@ -0,0 +1,143 @@
+"""
+datasources/sources/tushare_source.py — Tushare A股数据源
+==========================================================
+需要 TUSHARE_TOKEN 环境变量（已在 .env 中配置）。
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Optional
+
+from ..base import BaseDataSource, FundamentalsResult, HistoryResult, QuoteResult
+from aria_code.packages.aria_core.paths import aria_home
+
+logger = logging.getLogger(__name__)
+
+
+def _load_token() -> str:
+    token = os.getenv("TUSHARE_TOKEN", "")
+    if not token:
+        env_paths = [
+            Path.cwd() / ".env",
+            Path.cwd().parent / ".env",
+            Path.home() / ".aria" / ".env",
+            aria_home() / ".env",
+        ]
+        for p in env_paths:
+            if p.exists():
+                for line in p.read_text(encoding="utf-8").splitlines():
+                    if line.startswith("TUSHARE_TOKEN="):
+                        token = line.split("=", 1)[1].strip()
+                        break
+            if token:
+                break
+    return token
+
+
+class TushareSource(BaseDataSource):
+
+    name         = "tushare"
+    markets      = ["a_share"]
+    requires_key = True
+
+    def __init__(self, config=None):
+        super().__init__(config)
+        self._token = _load_token()
+        self._pro   = None
+
+    def is_configured(self) -> bool:
+        return bool(self._token)
+
+    def _get_pro(self):
+        if self._pro is None:
+            import tushare as ts
+            ts.set_token(self._token)
+            self._pro = ts.pro_api()
+        return self._pro
+
+    def _to_ts_code(self, symbol: str) -> str:
+        s = symbol.upper().replace("SH","").replace("SZ","").replace(".","").strip()
+        code = s[:6]
+        return f"{code}.SH" if code.startswith(("6","9")) else f"{code}.SZ"
+
+    def quote(self, symbol: str) -> Optional[QuoteResult]:
+        """
+        使用 pro.daily 获取最近交易日收盘价（不调用 daily_basic 避免限频）。
+        PE/PB 留给 fundamentals() 单独获取。
+        """
+        try:
+            import time as _t
+            pro     = self._get_pro()
+            ts_code = self._to_ts_code(symbol)
+            end     = date.today().strftime("%Y%m%d")
+            start   = (date.today() - timedelta(days=10)).strftime("%Y%m%d")
+            df      = pro.daily(ts_code=ts_code, start_date=start, end_date=end)
+            _t.sleep(0.35)
+            if df is None or df.empty:
+                return None
+            # trade_date 格式 YYYYMMDD，字符串排序等价于日期排序
+            latest = df.sort_values("trade_date", ascending=False).iloc[0]
+            price  = float(latest.get("close",     0))
+            prev   = float(latest.get("pre_close", price))
+            return QuoteResult(
+                symbol     = symbol,
+                price      = price,
+                change     = round(price - prev, 4),
+                change_pct = float(latest.get("pct_chg", 0)),
+                volume     = float(latest.get("vol",    0)),
+                currency   = "CNY",
+                market     = "a_share",
+                source     = self.name,
+                timestamp  = str(latest.get("trade_date", "")),
+            )
+        except Exception as e:
+            logger.debug(f"[tushare] quote {symbol} 失败: {e}")
+            return None
+
+    def history(self, symbol: str, days: int = 90, interval: str = "1d") -> Optional[HistoryResult]:
+        try:
+            import time as _t
+            import pandas as pd
+            pro     = self._get_pro()
+            ts_code = self._to_ts_code(symbol)
+            end     = date.today().strftime("%Y%m%d")
+            start   = (date.today() - timedelta(days=days + 15)).strftime("%Y%m%d")
+            df      = pro.daily(ts_code=ts_code, start_date=start, end_date=end)
+            _t.sleep(0.4)
+            if df is None or df.empty:
+                return None
+            df["trade_date"] = pd.to_datetime(df["trade_date"])
+            df = df.rename(columns={"trade_date": "date", "vol": "volume"})
+            df = df.set_index("date").sort_index()
+            return HistoryResult(symbol=symbol, data=df, source=self.name, interval=interval)
+        except Exception as e:
+            logger.debug(f"[tushare] history {symbol} 失败: {e}")
+            return None
+
+    def fundamentals(self, symbol: str) -> Optional[FundamentalsResult]:
+        try:
+            import time as _t
+            pro     = self._get_pro()
+            ts_code = self._to_ts_code(symbol)
+            for period in ["20241231", "20231231"]:
+                df = pro.fina_indicator(
+                    ts_code=ts_code, period=period,
+                    fields="ts_code,roe,netprofit_yoy,revenue_yoy"
+                )
+                _t.sleep(0.4)
+                if df is not None and not df.empty:
+                    r = df.iloc[0]
+                    return FundamentalsResult(
+                        symbol          = symbol,
+                        roe             = float(r.get("roe", 0) or 0),
+                        revenue_growth  = float(r.get("revenue_yoy", 0) or 0),
+                        net_profit_growth = float(r.get("netprofit_yoy", 0) or 0),
+                        source          = self.name,
+                    )
+        except Exception as e:
+            logger.debug(f"[tushare] fundamentals {symbol} 失败: {e}")
+        return None