axdata 0.1.0__py3-none-any.whl

axdata_source_tdx/resources/tdx_quote_servers.json

@@ -0,0 +1,49 @@
+{
+  "schema_version": 1,
+  "kind": "quote",
+  "servers": [
+    {"name": "普通行情1", "host": "116.205.183.150", "port": 7709, "enabled": true, "priority": 1},
+    {"name": "普通行情2", "host": "116.205.171.132", "port": 7709, "enabled": true, "priority": 2},
+    {"name": "普通行情3", "host": "111.230.186.52", "port": 7709, "enabled": true, "priority": 3},
+    {"name": "普通行情4", "host": "129.204.230.128", "port": 7709, "enabled": true, "priority": 4},
+    {"name": "普通行情5", "host": "116.205.163.254", "port": 7709, "enabled": true, "priority": 5},
+    {"name": "普通行情6", "host": "110.41.2.72", "port": 7709, "enabled": true, "priority": 6},
+    {"name": "普通行情7", "host": "159.75.29.111", "port": 7709, "enabled": true, "priority": 7},
+    {"name": "普通行情8", "host": "43.139.95.83", "port": 7709, "enabled": true, "priority": 8},
+    {"name": "普通行情9", "host": "175.178.128.227", "port": 7709, "enabled": true, "priority": 9},
+    {"name": "普通行情10", "host": "110.41.147.114", "port": 7709, "enabled": true, "priority": 10},
+    {"name": "普通行情11", "host": "124.71.9.153", "port": 7709, "enabled": true, "priority": 11},
+    {"name": "普通行情12", "host": "81.71.32.47", "port": 7709, "enabled": true, "priority": 12},
+    {"name": "普通行情13", "host": "43.139.18.171", "port": 7709, "enabled": true, "priority": 13},
+    {"name": "普通行情14", "host": "119.97.185.59", "port": 7709, "enabled": true, "priority": 14},
+    {"name": "普通行情15", "host": "123.60.70.228", "port": 7709, "enabled": true, "priority": 15},
+    {"name": "普通行情16", "host": "123.60.73.44", "port": 7709, "enabled": true, "priority": 16},
+    {"name": "普通行情17", "host": "124.70.199.56", "port": 7709, "enabled": true, "priority": 17},
+    {"name": "普通行情18", "host": "175.178.112.197", "port": 7709, "enabled": true, "priority": 18},
+    {"name": "普通行情19", "host": "101.33.225.16", "port": 7709, "enabled": true, "priority": 19},
+    {"name": "普通行情20", "host": "124.71.187.122", "port": 7709, "enabled": true, "priority": 20},
+    {"name": "普通行情21", "host": "124.71.187.72", "port": 7709, "enabled": true, "priority": 21},
+    {"name": "普通行情22", "host": "111.229.247.189", "port": 7709, "enabled": true, "priority": 22},
+    {"name": "普通行情23", "host": "121.36.225.169", "port": 7709, "enabled": true, "priority": 23},
+    {"name": "普通行情24", "host": "150.158.160.2", "port": 7709, "enabled": true, "priority": 24},
+    {"name": "普通行情25", "host": "123.60.164.122", "port": 7709, "enabled": true, "priority": 25},
+    {"name": "普通行情26", "host": "49.232.15.141", "port": 7709, "enabled": true, "priority": 26},
+    {"name": "普通行情27", "host": "122.51.120.217", "port": 7709, "enabled": true, "priority": 27},
+    {"name": "普通行情28", "host": "111.231.113.208", "port": 7709, "enabled": true, "priority": 28},
+    {"name": "普通行情29", "host": "124.223.163.242", "port": 7709, "enabled": true, "priority": 29},
+    {"name": "普通行情30", "host": "62.234.50.143", "port": 7709, "enabled": true, "priority": 30},
+    {"name": "普通行情31", "host": "101.35.121.35", "port": 7709, "enabled": true, "priority": 31},
+    {"name": "普通行情32", "host": "101.42.240.54", "port": 7709, "enabled": true, "priority": 32},
+    {"name": "普通行情33", "host": "101.43.159.194", "port": 7709, "enabled": true, "priority": 33},
+    {"name": "普通行情34", "host": "81.70.151.186", "port": 7709, "enabled": true, "priority": 34},
+    {"name": "普通行情35", "host": "82.156.174.84", "port": 7709, "enabled": true, "priority": 35},
+    {"name": "普通行情36", "host": "123.60.84.66", "port": 7709, "enabled": true, "priority": 36},
+    {"name": "普通行情37", "host": "120.53.8.251", "port": 7709, "enabled": true, "priority": 37},
+    {"name": "普通行情38", "host": "124.70.133.119", "port": 7709, "enabled": true, "priority": 38},
+    {"name": "普通行情39", "host": "118.25.98.114", "port": 7709, "enabled": true, "priority": 39},
+    {"name": "普通行情40", "host": "122.51.232.182", "port": 7709, "enabled": true, "priority": 40},
+    {"name": "普通行情41", "host": "101.42.164.241", "port": 7709, "enabled": true, "priority": 41},
+    {"name": "普通行情42", "host": "152.136.191.169", "port": 7709, "enabled": true, "priority": 42},
+    {"name": "普通行情43", "host": "82.156.214.79", "port": 7709, "enabled": true, "priority": 43}
+  ]
+}

axdata_source_tdx/security_codes.py

@@ -0,0 +1,127 @@
+"""TDX security code-list classification and row normalization."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from .codes import MARKET_TO_EXCHANGE, tdx_code_to_instrument_id
+from .normalize_utils import get_value
+
+
+ASSET_TYPE_MAP = {
+    "a_share": "stock",
+    "b_share": "stock",
+    "etf": "etf",
+    "fund": "fund",
+    "index": "index",
+    "cdr": "cdr",
+}
+
+BOARD_MAP = {
+    "sse_main_board": "主板",
+    "sse_star_market": "科创板",
+    "sse_cdr": "CDR",
+    "szse_main_board": "主板",
+    "szse_chinext": "创业板",
+    "bse_listed_stock": "北交所",
+    "none": None,
+}
+
+SCOPE_TO_BOARDS = {
+    "all": None,
+    "全部": None,
+    "*": None,
+    "main": {"sse_main_board", "szse_main_board"},
+    "主板": {"sse_main_board", "szse_main_board"},
+    "star": {"sse_star_market"},
+    "科创板": {"sse_star_market"},
+    "cdr": {"sse_cdr"},
+    "CDR": {"sse_cdr"},
+    "chinext": {"szse_chinext"},
+    "创业板": {"szse_chinext"},
+    "bse": {"bse_listed_stock"},
+    "北交所": {"bse_listed_stock"},
+}
+
+
+def normalize_security(item: Any) -> dict[str, Any]:
+    category = get_value(item, "category")
+    board = get_value(item, "board")
+    tdx_code = str(get_value(item, "full_code") or "").lower()
+    instrument_id = tdx_code_to_instrument_id(tdx_code)
+    symbol = str(get_value(item, "code") or instrument_id.split(".", 1)[0])
+    market = str(get_value(item, "exchange") or "").lower()
+    asset_type = ASSET_TYPE_MAP.get(str(category), str(category or "unknown"))
+    return {
+        "instrument_id": instrument_id,
+        "symbol": symbol,
+        "tdx_code": tdx_code,
+        "exchange": MARKET_TO_EXCHANGE.get(market, market.upper()),
+        "name": get_value(item, "name"),
+        "asset_type": asset_type,
+        "tdx_category": category,
+        "tdx_category_reason": get_value(item, "category_reason"),
+        "listing_status": "listed",
+        "list_date": None,
+        "market": BOARD_MAP.get(str(board), board),
+        "market_code": board,
+        "tdx_market_reason": get_value(item, "board_reason"),
+        "tdx_decimal": get_value(item, "decimal"),
+        "tdx_multiple": get_value(item, "multiple"),
+        "tdx_previous_close_price": get_value(item, "previous_close_price"),
+        "tdx_volume_ratio_base": get_value(item, "volume_ratio_base"),
+    }
+
+
+def board_from_tdx_code(tdx_code: Any) -> str | None:
+    text = str(tdx_code or "").strip().lower()
+    if len(text) != 8:
+        return None
+    market = text[:2]
+    symbol = text[2:]
+    if market == "bj":
+        return "bse_listed_stock"
+    if market == "sh":
+        if symbol.startswith("688"):
+            return "sse_star_market"
+        if symbol.startswith("689"):
+            return "sse_cdr"
+        if symbol.startswith(("600", "601", "603", "605")):
+            return "sse_main_board"
+    if market == "sz":
+        if symbol.startswith(("300", "301")):
+            return "szse_chinext"
+        if symbol.startswith(("000", "001", "002", "003", "004")):
+            return "szse_main_board"
+    return None
+
+
+def index_type_from_tdx_code(tdx_code: str) -> str:
+    code = str(tdx_code or "").lower()
+    if code.startswith(("sh000", "sz399", "bj899")):
+        return "official_index"
+    if code.startswith(("sh880", "sh881", "sh999")):
+        return "tdx_block_index"
+    return "index"
+
+
+def etf_type_from_tdx_code(tdx_code: str) -> str | None:
+    code = str(tdx_code or "").lower()
+    if code.startswith(("sh51", "sh56", "sh58")):
+        return "sse_etf"
+    if code.startswith("sz15"):
+        return "szse_etf"
+    return None
+
+
+def normalize_index_code_row(row: Mapping[str, Any], index_type: str) -> dict[str, Any]:
+    return {
+        "instrument_id": row.get("instrument_id"),
+        "symbol": row.get("symbol"),
+        "tdx_code": row.get("tdx_code"),
+        "exchange": row.get("exchange"),
+        "name": row.get("name"),
+        "index_type": index_type,
+        "previous_close": row.get("tdx_previous_close_price"),
+    }

axdata_source_tdx/series_history.py

@@ -0,0 +1,348 @@
+"""Historical K-line and trade pagination helpers for TDX requests."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, is_dataclass, replace
+from types import SimpleNamespace
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class KlineParallelOptions:
+    hosts: list[str]
+    pool_size: int
+
+
+@dataclass(frozen=True)
+class KlineRequestResult:
+    index: int
+    rows: list[dict[str, Any]]
+    series: Any
+    page_count: int
+
+
+@dataclass(frozen=True)
+class KlineHostResult:
+    results: list[KlineRequestResult]
+    meta: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class KlineParallelResult:
+    results: list[KlineRequestResult]
+    host_metas: list[dict[str, Any]]
+    host_count: int
+    pool_size_per_host: int
+    concurrency_capacity: int
+    concurrency_limit: int
+
+
+def kline_parallel_options(
+    options: Any,
+    *,
+    has_connection_options: Callable[[Any], bool],
+    option_hosts: Callable[..., list[str] | None],
+    option_connections_per_server: Callable[[Any], int],
+    configured_hosts: Callable[[], list[str]],
+    configured_hosts_from_options: Callable[..., list[str]],
+    env_int: Callable[..., int],
+    default_host_count: int,
+    default_pool_size: int,
+) -> KlineParallelOptions:
+    if has_connection_options(options):
+        hosts = option_hosts(
+            options,
+            configured_hosts=configured_hosts_from_options,
+        ) or configured_hosts()
+        pool_size = option_connections_per_server(options)
+    else:
+        host_count = env_int("AXDATA_TDX_KLINE_HOST_COUNT", default_host_count, minimum=1)
+        pool_size = env_int("AXDATA_TDX_KLINE_POOL_SIZE", default_pool_size, minimum=1)
+        hosts = list(configured_hosts()[:host_count])
+    return KlineParallelOptions(hosts=list(hosts), pool_size=pool_size)
+
+
+def request_trade_series_history(
+    client: Any,
+    tdx_code: str,
+    *,
+    trade_date: str | None,
+    page_size: int,
+    max_start: int,
+    price_decimal: Callable[[Any, str], int],
+    today_trades: Callable[..., Any],
+    historical_trades: Callable[..., Any],
+    trade_records: Callable[[Any], Sequence[Any]],
+    normalize_trade_row: Callable[..., dict[str, Any]],
+) -> tuple[list[dict[str, Any]], int]:
+    current_start = 0
+    page_count = 0
+    rows: list[dict[str, Any]] = []
+    decimal = price_decimal(client, tdx_code)
+
+    while current_start <= max_start:
+        if trade_date is None:
+            series = today_trades(
+                client,
+                tdx_code,
+                start=current_start,
+                count=page_size,
+            )
+        else:
+            series = historical_trades(
+                client,
+                tdx_code,
+                trade_date=trade_date,
+                start=current_start,
+                count=page_size,
+            )
+        page_count += 1
+        records = trade_records(series)
+        if not records:
+            break
+
+        rows.extend(normalize_trade_row(series, record, decimal=decimal) for record in records)
+        if len(records) < page_size:
+            break
+        current_start += len(records)
+
+    return rows, page_count
+
+
+def request_kline_series_history(
+    client: Any,
+    tdx_code: str,
+    *,
+    period: str,
+    page_size: int,
+    adjust: str,
+    anchor_date: Any,
+    kind: str = "stock",
+    max_count: int,
+    tdx_kline: Callable[..., Any],
+    kline_bars: Callable[[Any], Sequence[Any]],
+    get_value: Callable[[Any, str, Any], Any],
+) -> tuple[Any, int]:
+    current_start = 0
+    page_count = 0
+    first_series: Any | None = None
+    bars_by_time: dict[Any, Any] = {}
+
+    while current_start <= max_count:
+        series = tdx_kline(
+            client,
+            tdx_code,
+            period=period,
+            start=current_start,
+            count=page_size,
+            adjust=adjust,
+            anchor_date=anchor_date,
+            kind=kind,
+        )
+        if first_series is None:
+            first_series = series
+        page_count += 1
+        bars = kline_bars(series)
+        if not bars:
+            break
+
+        new_bar_count = 0
+        for bar in bars:
+            key = get_value(bar, "time", None)
+            if key in bars_by_time:
+                continue
+            bars_by_time[key] = bar
+            new_bar_count += 1
+
+        if len(bars) < page_size or new_bar_count == 0:
+            break
+        current_start += len(bars)
+
+    assert first_series is not None
+    bars = tuple(sorted(bars_by_time.values(), key=lambda item: get_value(item, "time", None)))
+    if is_dataclass(first_series):
+        return replace(first_series, bars=bars), page_count
+    series_dict = {
+        key: value
+        for key, value in vars(first_series).items()
+        if not key.startswith("_")
+    }
+    series_dict["bars"] = bars
+    return SimpleNamespace(**series_dict), page_count
+
+
+def request_kline_code_history(
+    client: Any,
+    index: int,
+    tdx_code: str,
+    *,
+    period: str,
+    page_size: int,
+    adjust: str,
+    anchor_date: Any,
+    kind: str = "stock",
+    request_series_history: Callable[..., tuple[Any, int]],
+    normalize_kline_row: Callable[[Any, Any], dict[str, Any]],
+    kline_bars: Callable[[Any], Sequence[Any]],
+    row_sort_key: Callable[[dict[str, Any]], Any],
+) -> KlineRequestResult:
+    series, page_count = request_series_history(
+        client,
+        tdx_code,
+        period=period,
+        page_size=page_size,
+        adjust=adjust,
+        anchor_date=anchor_date,
+        kind=kind,
+    )
+    rows = sorted((normalize_kline_row(series, bar) for bar in kline_bars(series)), key=row_sort_key)
+    return KlineRequestResult(index=index, rows=rows, series=series, page_count=page_count)
+
+
+def request_recent_daily_bars(
+    client: Any,
+    tdx_code: str,
+    *,
+    count: int,
+    stats_date: Any,
+    max_count: int,
+    tdx_kline: Callable[..., Any],
+    kline_bars: Callable[[Any], Sequence[Any]],
+    get_value: Callable[[Any, str, Any], Any],
+    bar_trade_date: Callable[[Any], str | None],
+) -> tuple[list[Any], int]:
+    stats_date_text = str(stats_date or "")
+    page_size = max(1, int(count))
+    current_start = 0
+    page_count = 0
+
+    while current_start <= max_count:
+        series = tdx_kline(
+            client,
+            tdx_code,
+            period="day",
+            start=current_start,
+            count=page_size,
+            adjust="none",
+            anchor_date=None,
+        )
+        page_count += 1
+        bars = sorted(kline_bars(series), key=lambda item: get_value(item, "time", None), reverse=True)
+        if not bars:
+            break
+
+        filtered: list[Any] = []
+        has_base_bar = False
+        for bar in bars:
+            trade_date = bar_trade_date(bar)
+            if stats_date_text and trade_date and trade_date > stats_date_text:
+                continue
+            filtered.append(bar)
+            if stats_date_text and trade_date and trade_date < stats_date_text:
+                has_base_bar = True
+            if len(filtered) >= 5:
+                return filtered, page_count
+
+        oldest_date = bar_trade_date(bars[-1])
+        if filtered and (not stats_date_text or has_base_bar):
+            return filtered, page_count
+        if stats_date_text and oldest_date and oldest_date < stats_date_text:
+            break
+        if len(bars) < page_size:
+            break
+        current_start += len(bars)
+
+    return [], page_count
+
+
+def request_kline_codes_on_host(
+    host: str,
+    indexed_codes: Sequence[tuple[int, str]],
+    *,
+    pool_size: int,
+    period: str,
+    page_size: int,
+    adjust: str,
+    anchor_date: Any,
+    create_client: Callable[..., Any],
+    request_code_history: Callable[..., KlineRequestResult],
+    client_meta: Callable[[Any], dict[str, Any]],
+) -> KlineHostResult:
+    client = create_client(
+        hosts=[host],
+        pool_size=pool_size,
+        heartbeat_interval=None,
+    )
+    try:
+        if hasattr(client, "connect"):
+            client.connect()
+        worker_count = min(pool_size, max(1, len(indexed_codes)))
+        results: list[KlineRequestResult] = []
+        with ThreadPoolExecutor(max_workers=worker_count, thread_name_prefix="axdata-tdx-kline-host") as executor:
+            futures = [
+                executor.submit(
+                    request_code_history,
+                    client,
+                    index,
+                    tdx_code,
+                    period=period,
+                    page_size=page_size,
+                    adjust=adjust,
+                    anchor_date=anchor_date,
+                )
+                for index, tdx_code in indexed_codes
+            ]
+            for future in as_completed(futures):
+                results.append(future.result())
+        return KlineHostResult(results=results, meta=client_meta(client))
+    finally:
+        if hasattr(client, "close"):
+            client.close()
+
+
+def request_kline_codes_parallel(
+    hosts: Sequence[str],
+    tdx_codes: Sequence[str],
+    *,
+    pool_size: int,
+    period: str,
+    page_size: int,
+    adjust: str,
+    anchor_date: Any,
+    request_on_host: Callable[..., KlineHostResult],
+) -> KlineParallelResult:
+    capacity = len(hosts) * pool_size
+    concurrency_limit = min(len(tdx_codes), capacity)
+
+    indexed_codes = list(enumerate(tdx_codes))
+    worker_count = min(len(hosts), len(indexed_codes))
+    grouped_codes = [indexed_codes[index::worker_count] for index in range(worker_count)]
+    host_results: list[KlineHostResult] = []
+    with ThreadPoolExecutor(max_workers=worker_count, thread_name_prefix="axdata-tdx-kline") as executor:
+        futures = [
+            executor.submit(
+                request_on_host,
+                hosts[index],
+                grouped_codes[index],
+                pool_size=pool_size,
+                period=period,
+                page_size=page_size,
+                adjust=adjust,
+                anchor_date=anchor_date,
+            )
+            for index in range(worker_count)
+            if grouped_codes[index]
+        ]
+        for future in as_completed(futures):
+            host_results.append(future.result())
+
+    return KlineParallelResult(
+        results=[result for host_result in host_results for result in host_result.results],
+        host_metas=[host_result.meta for host_result in host_results],
+        host_count=len(hosts),
+        pool_size_per_host=pool_size,
+        concurrency_capacity=capacity,
+        concurrency_limit=concurrency_limit,
+    )

axdata_source_tdx/server_cache.py

@@ -0,0 +1,21 @@
+"""TDX data-root scoped cache helpers owned by the provider package."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def tdx_server_cache_root(data_root: str | Path | None) -> str | None:
+    """Return the data-root scoped TDX server cache directory."""
+
+    if data_root in (None, ""):
+        return None
+    return str(Path(data_root).expanduser().resolve() / "cache" / "tdx_servers")
+
+
+def tdx_stats_cache_root(data_root: str | Path | None) -> str | None:
+    """Return the data-root scoped TDX statistics resource cache directory."""
+
+    if data_root in (None, ""):
+        return None
+    return str(Path(data_root).expanduser().resolve() / "cache" / "tdx" / "stats")