axdata 0.1.0__py3-none-any.whl

axdata_core/adapters/tdx_ext/models.py

@@ -0,0 +1,96 @@
+"""Structured models for TDX extended market responses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtMarket:
+    category: int
+    market: int
+    name: str
+    short_name: str
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtInstrument:
+    category: int
+    market: int
+    code: str
+    name: str
+    desc: str
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtQuoteLevel:
+    price: float | None
+    volume: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtQuote:
+    market: int
+    code: str
+    active: int | None
+    pre_close: float | None
+    open: float | None
+    high: float | None
+    low: float | None
+    last_price: float | None
+    active_volume: int | None
+    volume: int | None
+    current_volume: int | None
+    amount: float | None
+    inside_volume: int | None
+    outside_volume: int | None
+    open_interest: int | None
+    open_interest_change: int | None
+    settlement: float | None
+    average_price: float | None
+    pre_settlement: float | None
+    pre_volume: float | None
+    trade_date: str | None
+    raise_speed: float | None
+    bid_levels: tuple[TdxExtQuoteLevel, ...]
+    ask_levels: tuple[TdxExtQuoteLevel, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtKlineBar:
+    market: int
+    code: str
+    trade_time: str
+    period: str
+    open: float | None
+    high: float | None
+    low: float | None
+    close: float | None
+    amount: float | None
+    volume: int | None
+    open_interest: int | None = None
+    settlement: float | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtIntradayPoint:
+    market: int
+    code: str
+    trade_date: str | None
+    time_label: str
+    price: float | None
+    average_price: float | None
+    volume: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtTrade:
+    market: int
+    code: str
+    trade_date: str | None
+    time_label: str
+    price_raw: int
+    price: float | None
+    volume: int
+    position_change: int
+    direction_marker: int

axdata_core/adapters/tdx_ext/options.py

@@ -0,0 +1,36 @@
+"""Execution option helpers for TDX extended market requests."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def normalize_tdx_ext_request_options(options: dict[str, Any] | None) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+    for key, value in dict(options or {}).items():
+        if value is None:
+            continue
+        normalized[str(key)] = value
+    allowed = {"source_server_count", "connections_per_server", "server_cache_root"}
+    unknown = sorted(set(normalized) - allowed)
+    if unknown:
+        from axdata_core.source_errors import SourceRequestValidationError
+
+        raise SourceRequestValidationError(
+            f"Unknown request option(s): {', '.join(unknown)}. Known options: {', '.join(sorted(allowed))}."
+        )
+    return normalized
+
+
+def positive_tdx_ext_option_int(value: Any, name: str, *, maximum: int) -> int:
+    from axdata_core.source_errors import SourceRequestValidationError
+
+    try:
+        number = int(value)
+    except (TypeError, ValueError) as exc:
+        raise SourceRequestValidationError(f"{name} must be an integer.") from exc
+    if number < 1:
+        raise SourceRequestValidationError(f"{name} must be >= 1.")
+    if number > maximum:
+        raise SourceRequestValidationError(f"{name} must be <= {maximum}.")
+    return number

axdata_core/adapters/tdx_ext/pool.py

@@ -0,0 +1,153 @@
+"""Small worker pool for TDX extended market requests."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from threading import Lock
+from typing import Any, TypeVar
+
+from .options import normalize_tdx_ext_request_options, positive_tdx_ext_option_int
+from .servers import TdxExtServer
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+@dataclass(frozen=True, slots=True)
+class TdxExtPoolConfig:
+    """Resolved extended-market pool configuration."""
+
+    source_server_count: int
+    connections_per_server: int
+    connection_count: int
+    requested_connections_per_server: int
+    servers: tuple[TdxExtServer, ...]
+
+
+class TdxExtClientPool:
+    """Run independent extended-market requests on independent clients."""
+
+    def __init__(
+        self,
+        *,
+        servers: Sequence[TdxExtServer],
+        connections_per_server: int,
+        connection_count: int | None = None,
+        timeout: float = 6.0,
+        client_factory: Callable[..., Any] | None = None,
+    ) -> None:
+        self.servers = tuple(servers)
+        self.connections_per_server = max(1, int(connections_per_server))
+        self.timeout = timeout
+        self.client_factory = client_factory or _tdx_ext_client_class()
+        self._clients: list[Any] = []
+        self._client_locks: list[Lock] = []
+        target_connection_count = max(1, int(connection_count or (len(self.servers) * self.connections_per_server)))
+        created = 0
+        while created < target_connection_count:
+            server = self.servers[created % len(self.servers)]
+            self._clients.append(
+                self.client_factory(
+                    servers=(server,),
+                    timeout=self.timeout,
+                )
+            )
+            self._client_locks.append(Lock())
+            created += 1
+
+    @property
+    def connection_count(self) -> int:
+        return len(self._clients)
+
+    def close(self) -> None:
+        for client in self._clients:
+            close = getattr(client, "close", None)
+            if callable(close):
+                close()
+
+    def __enter__(self) -> "TdxExtClientPool":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def map(self, items: Sequence[T], func: Callable[[Any, T], R]) -> list[R]:
+        if not items:
+            return []
+        if self.connection_count <= 1 or len(items) <= 1:
+            client = self._clients[0]
+            return [func(client, item) for item in items]
+
+        worker_count = min(self.connection_count, len(items))
+
+        def run_one(index: int, item: T) -> tuple[int, R]:
+            client_index = index % self.connection_count
+            client = self._clients[client_index]
+            with self._client_locks[client_index]:
+                return index, func(client, item)
+
+        results_by_index: dict[int, R] = {}
+        with ThreadPoolExecutor(max_workers=worker_count, thread_name_prefix="axdata-tdx-ext") as executor:
+            futures = [executor.submit(run_one, index, item) for index, item in enumerate(items)]
+            for future in as_completed(futures):
+                index, result = future.result()
+                results_by_index[index] = result
+        return [results_by_index[index] for index in range(len(items))]
+
+
+def _tdx_ext_client_class() -> Any:
+    from .client import TdxExtClient
+
+    return TdxExtClient
+
+
+def _configured_extended_servers(*, cache_root: str | None = None) -> tuple[TdxExtServer, ...]:
+    from .exceptions import ConnectionClosedError
+    from .host_config import configured_extended_servers as configured
+
+    return configured(cache_root=cache_root, unavailable_error=ConnectionClosedError)
+
+
+def resolve_tdx_ext_pool_config(
+    options: dict[str, Any],
+    *,
+    minimum_tasks: int,
+) -> TdxExtPoolConfig | None:
+    """Return a pool config only when options request useful parallelism."""
+
+    if minimum_tasks <= 1:
+        return None
+    if not options:
+        return None
+    server_cache_root = options.get("server_cache_root")
+    servers = _configured_extended_servers(cache_root=server_cache_root)
+    source_server_count = positive_tdx_ext_option_int(
+        options.get("source_server_count", 1),
+        "source_server_count",
+        maximum=64,
+    )
+    connections_per_server = positive_tdx_ext_option_int(
+        options.get("connections_per_server", 1),
+        "connections_per_server",
+        maximum=64,
+    )
+    selected_servers = tuple(servers[: min(source_server_count, len(servers))])
+    connection_count = min(len(selected_servers) * connections_per_server, 128)
+    if connection_count <= 1:
+        return None
+    return TdxExtPoolConfig(
+        source_server_count=len(selected_servers),
+        connections_per_server=max(1, (connection_count + len(selected_servers) - 1) // len(selected_servers)),
+        connection_count=connection_count,
+        requested_connections_per_server=connections_per_server,
+        servers=selected_servers,
+    )
+
+
+def flatten_results(results: Iterable[Sequence[R]]) -> list[R]:
+    rows: list[R] = []
+    for result in results:
+        rows.extend(result)
+    return rows

axdata_core/adapters/tdx_ext/provider_bridge.py

@@ -0,0 +1,35 @@
+"""Provider/legacy adapter bridge helpers for TDX extended-market requests."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .request import TdxExtRequestAdapter
+
+
+def create_tdx_ext_request_adapter(
+    options: Mapping[str, object] | None = None,
+) -> TdxExtRequestAdapter:
+    """Create a TDX extended-market request adapter from execution options."""
+
+    from .request import TdxExtRequestAdapter
+
+    client_pool, client_pool_config, adapter_options = split_tdx_ext_provider_options(options)
+    return TdxExtRequestAdapter(
+        options=adapter_options,
+        client_pool=client_pool,
+        client_pool_config=client_pool_config,
+    )
+
+
+def split_tdx_ext_provider_options(
+    options: Mapping[str, object] | None = None,
+) -> tuple[Any | None, Any | None, dict[str, object]]:
+    """Return injected pool resources and remaining TDX Ext execution options."""
+
+    resolved_options = dict(options or {})
+    client_pool = resolved_options.pop("client_pool", None)
+    client_pool_config = resolved_options.pop("client_pool_config", None)
+    return client_pool, client_pool_config, resolved_options