migration: preserve market data and search slice

app/ifind_client.py

@@ -1,385 +1,7 @@
-from __future__ import annotations
+"""Compatibility alias for the canonical iFinD provider implementation."""
 
-import copy
-import json
-import threading
-import time
-import urllib.error
-import urllib.request
-from datetime import datetime, timedelta
-from typing import Any
+import sys
 
+from backend.data.providers import ifind_client as _implementation
 
-class IfindError(RuntimeError):
-    pass
-
-
-class IfindHttpClient:
-    BASE_URL = "https://quantapi.51ifind.com/api/v1"
-    AUTH_ENDPOINT = "get_access_token"
-    AUTH_ERROR_CODES = {-1302, -1303, -1304, -4302, -4303}
-
-    def __init__(
-        self,
-        refresh_token: str = "",
-        access_token: str = "",
-        timeout: int = 15,
-    ) -> None:
-        self.timeout = max(3, int(timeout))
-        self._refresh_token = str(refresh_token or "").strip()
-        self._access_token = str(access_token or "").strip()
-        self._access_expires_at: datetime | None = None
-        self._token_lock = threading.Lock()
-        self._cache_lock = threading.Lock()
-        self._cache: dict[str, dict[str, Any]] = {}
-
-    @property
-    def configured(self) -> bool:
-        return bool(self._refresh_token or self._access_token)
-
-    def set_credentials(self, refresh_token: str, access_token: str = "") -> None:
-        refresh_token = str(refresh_token or "").strip()
-        access_token = str(access_token or "").strip()
-        with self._token_lock:
-            refresh_changed = refresh_token != self._refresh_token
-            self._refresh_token = refresh_token
-            if access_token or refresh_changed:
-                self._access_token = access_token
-                self._access_expires_at = None
-        if refresh_changed:
-            with self._cache_lock:
-                self._cache.clear()
-
-    def status(self) -> dict[str, Any]:
-        return {
-            "configured": self.configured,
-            "access_ready": bool(self._access_token),
-            "access_expires_at": (
-                self._access_expires_at.isoformat(timespec="seconds")
-                if self._access_expires_at
-                else ""
-            ),
-        }
-
-    def test_connection(self) -> dict[str, Any]:
-        payload = self.real_time(
-            "000001.SH",
-            ["open", "high", "low", "latest", "preClose"],
-            cache_ttl=0,
-        )
-        return {
-            "ok": bool(payload),
-            "sample_time": str(payload[0].get("time") or "") if payload else "",
-        }
-
-    def real_time(
-        self,
-        codes: str | list[str],
-        indicators: list[str],
-        cache_ttl: int = 10,
-    ) -> list[dict[str, Any]]:
-        code_text = self._codes(codes)
-        payload = self._request(
-            "real_time_quotation",
-            {"codes": code_text, "indicators": ",".join(indicators)},
-            cache_key=f"rq:{code_text}:{','.join(indicators)}",
-            cache_ttl=cache_ttl,
-        )
-        return self._table_rows(payload)
-
-    def history(
-        self,
-        codes: str | list[str],
-        indicators: list[str],
-        start_date: str,
-        end_date: str,
-        cache_ttl: int = 300,
-    ) -> list[dict[str, Any]]:
-        code_text = self._codes(codes)
-        payload = self._request(
-            "cmd_history_quotation",
-            {
-                "codes": code_text,
-                "indicators": ",".join(indicators),
-                "startdate": self._display_date(start_date),
-                "enddate": self._display_date(end_date),
-                "functionpara": {"CPS": "forward1", "Fill": "Omit"},
-            },
-            cache_key=f"hq:{code_text}:{start_date}:{end_date}:{','.join(indicators)}",
-            cache_ttl=cache_ttl,
-        )
-        return self._table_rows(payload)
-
-    def intraday(
-        self,
-        code: str,
-        start_time: str,
-        end_time: str,
-        cache_ttl: int = 20,
-    ) -> list[dict[str, Any]]:
-        indicators = ["open", "high", "low", "close", "volume", "amount", "avgPrice"]
-        payload = self._request(
-            "high_frequency",
-            {
-                "codes": self._codes(code),
-                "indicators": ",".join(indicators),
-                "starttime": start_time,
-                "endtime": end_time,
-                "functionpara": {
-                    "CPS": "forward1",
-                    "Fill": "Previous",
-                    "Timeformat": "LocalTime",
-                    "Interval": "1",
-                    "Limitstart": "09:30:00",
-                    "Limitend": "15:00:00",
-                },
-            },
-            cache_key=f"hf:{code}:{start_time}:{end_time}",
-            cache_ttl=cache_ttl,
-        )
-        return self._table_rows(payload)
-
-    def snapshots(
-        self,
-        codes: str | list[str],
-        indicators: list[str],
-        start_time: str,
-        end_time: str,
-        cache_ttl: int = 8,
-    ) -> list[dict[str, Any]]:
-        code_text = self._codes(codes)
-        payload = self._request(
-            "snap_shot",
-            {
-                "codes": code_text,
-                "indicators": ",".join(indicators),
-                "starttime": start_time,
-                "endtime": end_time,
-            },
-            cache_key=f"ss:{code_text}:{start_time}:{end_time}:{','.join(indicators)}",
-            cache_ttl=cache_ttl,
-        )
-        return self._table_rows(payload)
-
-    def wencai(self, query: str, search_type: str = "stock", cache_ttl: int = 300) -> list[dict[str, Any]]:
-        normalized = " ".join(str(query or "").split())
-        if not normalized:
-            raise IfindError("问财查询不能为空。")
-        payload = self._request(
-            "smart_stock_picking",
-            {"searchstring": normalized, "searchtype": search_type},
-            cache_key=f"wc:{search_type}:{normalized}",
-            cache_ttl=cache_ttl,
-        )
-        return self._table_rows(payload)
-
-    def report_query(
-        self,
-        codes: str | list[str],
-        begin_date: str,
-        end_date: str,
-        cache_ttl: int = 300,
-    ) -> list[dict[str, Any]]:
-        code_text = self._codes(codes)
-        payload = self._request(
-            "report_query",
-            {
-                "codes": code_text,
-                "beginrDate": self._display_date(begin_date),
-                "endrDate": self._display_date(end_date),
-                "outputpara": (
-                    "reportDate:Y,thscode:Y,secName:Y,ctime:Y,"
-                    "reportTitle:Y,pdfURL:Y,seq:Y"
-                ),
-            },
-            cache_key=f"report:{code_text}:{begin_date}:{end_date}",
-            cache_ttl=cache_ttl,
-        )
-        return self._table_rows(payload)
-
-    def _request(
-        self,
-        endpoint: str,
-        body: dict[str, Any],
-        cache_key: str = "",
-        cache_ttl: int = 0,
-    ) -> dict[str, Any]:
-        if not self.configured:
-            raise IfindError("iFinD 尚未配置。")
-        if cache_key and cache_ttl > 0:
-            cached = self._cached(cache_key, cache_ttl)
-            if cached is not None:
-                return cached
-
-        payload = self._post(endpoint, body, self._ensure_access_token())
-        if self._is_auth_error(payload) and self._refresh_token:
-            self._invalidate_access_token()
-            payload = self._post(endpoint, body, self._ensure_access_token(force=True))
-        self._validate_payload(payload)
-        if cache_key and cache_ttl > 0:
-            with self._cache_lock:
-                self._cache[cache_key] = {
-                    "created_at": time.time(),
-                    "payload": copy.deepcopy(payload),
-                }
-        return payload
-
-    def _ensure_access_token(self, force: bool = False) -> str:
-        with self._token_lock:
-            now = datetime.now().astimezone().replace(tzinfo=None)
-            token_valid = bool(self._access_token) and (
-                self._access_expires_at is None
-                or self._access_expires_at > now + timedelta(minutes=2)
-            )
-            if token_valid and not force:
-                return self._access_token
-            if not self._refresh_token:
-                if self._access_token:
-                    return self._access_token
-                raise IfindError("iFinD Refresh Token 尚未配置。")
-            payload = self._post(self.AUTH_ENDPOINT, {}, "", self._refresh_token)
-            self._validate_payload(payload)
-            data = payload.get("data") or {}
-            token = str(data.get("access_token") or "").strip()
-            if not token:
-                raise IfindError("iFinD 未返回 Access Token。")
-            expires_at = self._parse_datetime(data.get("expired_time"))
-            self._access_token = token
-            self._access_expires_at = expires_at
-            return token
-
-    def _post(
-        self,
-        endpoint: str,
-        body: dict[str, Any],
-        access_token: str,
-        refresh_token: str = "",
-    ) -> dict[str, Any]:
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            "User-Agent": "XiaobaiReviewWeb/1.0",
-            "ifindlang": "cn",
-        }
-        if access_token:
-            headers["access_token"] = access_token
-        if refresh_token:
-            headers["refresh_token"] = refresh_token
-        request = urllib.request.Request(
-            f"{self.BASE_URL}/{endpoint}",
-            data=json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8"),
-            headers=headers,
-            method="POST",
-        )
-        try:
-            with urllib.request.urlopen(request, timeout=self.timeout) as response:
-                payload = json.loads(response.read().decode("utf-8"))
-        except urllib.error.HTTPError as exc:
-            detail = ""
-            try:
-                detail_payload = json.loads(exc.read().decode("utf-8", errors="replace"))
-                detail = str(detail_payload.get("errmsg") or detail_payload.get("message") or "")
-            except (json.JSONDecodeError, OSError):
-                pass
-            raise IfindError(f"iFinD HTTP {exc.code}{f'：{detail[:160]}' if detail else ''}") from exc
-        except (urllib.error.URLError, TimeoutError, OSError, json.JSONDecodeError) as exc:
-            raise IfindError("iFinD 数据请求失败。") from exc
-        if not isinstance(payload, dict):
-            raise IfindError("iFinD 返回格式不正确。")
-        return payload
-
-    def _cached(self, key: str, ttl: int) -> dict[str, Any] | None:
-        with self._cache_lock:
-            cached = self._cache.get(key)
-            if not cached:
-                return None
-            if time.time() - float(cached.get("created_at") or 0) > ttl:
-                self._cache.pop(key, None)
-                return None
-            return copy.deepcopy(cached["payload"])
-
-    def _invalidate_access_token(self) -> None:
-        with self._token_lock:
-            self._access_token = ""
-            self._access_expires_at = None
-
-    @classmethod
-    def _validate_payload(cls, payload: dict[str, Any]) -> None:
-        try:
-            error_code = int(payload.get("errorcode") or 0)
-        except (TypeError, ValueError):
-            error_code = -1
-        if error_code != 0:
-            message = str(payload.get("errmsg") or "未知错误")
-            raise IfindError(f"iFinD 返回错误：{message[:200]}")
-
-    @classmethod
-    def _is_auth_error(cls, payload: dict[str, Any]) -> bool:
-        try:
-            error_code = int(payload.get("errorcode") or 0)
-        except (TypeError, ValueError):
-            error_code = 0
-        message = str(payload.get("errmsg") or "").casefold()
-        return error_code in cls.AUTH_ERROR_CODES or "token" in message or "鉴权" in message
-
-    @staticmethod
-    def _table_rows(payload: dict[str, Any]) -> list[dict[str, Any]]:
-        tables = payload.get("tables") or []
-        if isinstance(tables, dict):
-            tables = [tables]
-        rows: list[dict[str, Any]] = []
-        for block in tables if isinstance(tables, list) else []:
-            if not isinstance(block, dict):
-                continue
-            table = block.get("table") or {}
-            if not isinstance(table, dict):
-                continue
-            times = block.get("time") or []
-            codes = block.get("thscode") or block.get("thscodes") or []
-            if isinstance(codes, str):
-                codes = [codes]
-            lengths = [len(value) for value in table.values() if isinstance(value, list)]
-            row_count = max(lengths or [len(times) if isinstance(times, list) else 0, 1 if table else 0])
-            for index in range(row_count):
-                row: dict[str, Any] = {}
-                if isinstance(times, list) and index < len(times):
-                    row["time"] = times[index]
-                if codes:
-                    row["thscode"] = codes[index] if index < len(codes) else codes[0]
-                for field, values in table.items():
-                    if isinstance(values, list):
-                        row[field] = values[index] if index < len(values) else None
-                    elif index == 0:
-                        row[field] = values
-                rows.append(row)
-        return rows
-
-    @staticmethod
-    def _codes(codes: str | list[str]) -> str:
-        if isinstance(codes, list):
-            values = [str(code or "").strip().upper() for code in codes]
-        else:
-            values = [part.strip().upper() for part in str(codes or "").split(",")]
-        values = [value for value in values if value]
-        if not values:
-            raise IfindError("iFinD 证券代码不能为空。")
-        if len(values) > 100:
-            raise IfindError("iFinD 单次证券代码过多。")
-        return ",".join(values)
-
-    @staticmethod
-    def _display_date(value: str) -> str:
-        compact = str(value or "").replace("-", "")
-        if len(compact) != 8 or not compact.isdigit():
-            raise IfindError("iFinD 日期格式不正确。")
-        return f"{compact[:4]}-{compact[4:6]}-{compact[6:]}"
-
-    @staticmethod
-    def _parse_datetime(value: Any) -> datetime | None:
-        text = str(value or "").strip()
-        if not text:
-            return None
-        try:
-            return datetime.fromisoformat(text)
-        except ValueError:
-            return None
+sys.modules[__name__] = _implementation