axdata 0.1.0__py3-none-any.whl

axdata_source_tdx/_tdx_wire/_binary.py

@@ -0,0 +1,218 @@
+"""Provider-owned lightweight binary helpers for 7709 parsers."""
+
+from __future__ import annotations
+
+from importlib import import_module
+_EXCEPTIONS_MODULE = "axdata_source_tdx._tdx_wire.exceptions"
+_EXCEPTION_EXPORTS = {"ProtocolError"}
+_STDLIB_EXPORTS = {"date", "datetime", "math", "struct"}
+
+
+def _protocol_error():
+    return import_module(_EXCEPTIONS_MODULE).ProtocolError
+
+
+def _date_exports():
+    module = import_module("datetime")
+    globals()["date"] = module.date
+    globals()["datetime"] = module.datetime
+    return module.date, module.datetime
+
+
+def _math_module():
+    module = import_module("math")
+    globals()["math"] = module
+    return module
+
+
+def _struct_module():
+    module = import_module("struct")
+    globals()["struct"] = module
+    return module
+
+
+def little_u16(data: bytes) -> int:
+    return int.from_bytes(data, "little", signed=False)
+
+
+def little_u32(data: bytes) -> int:
+    return int.from_bytes(data, "little", signed=False)
+
+
+def little_f32(data: bytes) -> float:
+    return _struct_module().unpack("<f", data)[0]
+
+
+def tdx_quantity_u32(data: bytes) -> float:
+    raw = little_u32(data)
+    if raw == 0:
+        return 0.0
+    return tdx_quantity_from_u32(raw)
+
+
+def tdx_quantity_from_u32(raw: int) -> float:
+    """Decode TDX's packed quantity number used by some capital-change fields."""
+
+    log_point = raw >> 24
+    byte_2 = (raw >> 16) & 0xFF
+    byte_1 = (raw >> 8) & 0xFF
+    byte_0 = raw & 0xFF
+
+    exp_main = log_point * 2 - 0x7F
+    exp_byte_2 = log_point * 2 - 0x86
+    exp_byte_1 = log_point * 2 - 0x8E
+    exp_byte_0 = log_point * 2 - 0x96
+
+    main = 2.0 ** abs(exp_main)
+    if exp_main < 0:
+        main = 1.0 / main
+
+    if byte_2 > 0x80:
+        byte_2_value = (2.0**exp_byte_2) * 128.0
+        byte_2_value += float(byte_2 & 0x7F) * (2.0 ** (exp_byte_2 + 1))
+    elif exp_byte_2 >= 0:
+        byte_2_value = (2.0**exp_byte_2) * float(byte_2)
+    else:
+        byte_2_value = (1.0 / (2.0**exp_byte_2)) * float(byte_2)
+
+    byte_1_value = (2.0**exp_byte_1) * float(byte_1)
+    byte_0_value = (2.0**exp_byte_0) * float(byte_0)
+    if byte_2 & 0x80:
+        byte_1_value *= 2.0
+        byte_0_value *= 2.0
+
+    return main + byte_2_value + byte_1_value + byte_0_value
+
+
+def decode_compact_float(value: int) -> float:
+    """Decode the compact float encoding used by TDX quote and K-line amounts."""
+
+    if value == 0:
+        return 0.0
+
+    signed = int.from_bytes(value.to_bytes(4, "big", signed=False), "big", signed=True)
+    logpoint = signed >> 24
+    hleax = (signed >> 16) & 0xFF
+    lheax = (signed >> 8) & 0xFF
+    lleax = signed & 0xFF
+
+    base = _math_module().pow(2.0, float(logpoint * 2 - 0x7F))
+    if hleax > 0x80:
+        high = base * (64.0 + float(hleax & 0x7F)) / 64.0
+    else:
+        high = base * float(hleax) / 128.0
+
+    scale = 2.0 if hleax & 0x80 else 1.0
+    middle = base * float(lheax) / 32768.0 * scale
+    low = base * float(lleax) / 8388608.0 * scale
+    return base + high + middle + low
+
+
+def decode_gbk_text(data: bytes) -> str:
+    return data.decode("gbk", errors="ignore").replace("\x00", "").strip()
+
+
+def yyyymmdd(value: str | int | date | datetime | None = None) -> int:
+    if value is None:
+        date_cls, _ = _date_exports()
+        return int(date_cls.today().strftime("%Y%m%d"))
+    if isinstance(value, int):
+        return value
+    if not isinstance(value, str):
+        date_cls, datetime_cls = _date_exports()
+        if isinstance(value, datetime_cls):
+            return int(value.date().strftime("%Y%m%d"))
+        if isinstance(value, date_cls):
+            return int(value.strftime("%Y%m%d"))
+
+    text = str(value).strip().replace("-", "")
+    if len(text) != 8 or not text.isdigit():
+        raise _protocol_error()(f"invalid date: {value!r}")
+    return int(text)
+
+
+def date_from_yyyymmdd(raw: int) -> date | None:
+    text = f"{raw:08d}"
+    try:
+        _, datetime_cls = _date_exports()
+        return datetime_cls.strptime(text, "%Y%m%d").date()
+    except ValueError:
+        return None
+
+
+def consume_tdx_signed_varint(payload: bytes, offset: int) -> tuple[int, int]:
+    if offset >= len(payload):
+        raise _protocol_error()("unexpected end of payload")
+
+    value = 0
+    position = offset
+    shift = 0
+    while True:
+        if position >= len(payload):
+            raise _protocol_error()("unterminated varint")
+        byte = payload[position]
+        if position == offset:
+            value += byte & 0x3F
+            shift = 6
+        else:
+            value += (byte & 0x7F) << shift
+            shift += 7
+        position += 1
+        if byte & 0x80 == 0:
+            break
+    if payload[offset] & 0x40:
+        value = -value
+    return value, position
+
+
+def consume_tdx_varint(payload: bytes, offset: int) -> tuple[int, int]:
+    if offset >= len(payload):
+        raise _protocol_error()("unexpected end of payload")
+
+    value = 0
+    position = offset
+    shift = 0
+    while True:
+        if position >= len(payload):
+            raise _protocol_error()("unterminated varint")
+        byte = payload[position]
+        value += (byte & 0x7F) << shift
+        shift += 7
+        position += 1
+        if byte & 0x80 == 0:
+            break
+    return value, position
+
+
+def __getattr__(name: str):
+    if name in _EXCEPTION_EXPORTS:
+        value = getattr(import_module(_EXCEPTIONS_MODULE), name)
+        globals()[name] = value
+        return value
+    if name == "math":
+        return _math_module()
+    if name == "struct":
+        return _struct_module()
+    if name in {"date", "datetime"}:
+        _date_exports()
+        return globals()[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__) | _EXCEPTION_EXPORTS | _STDLIB_EXPORTS)
+
+
+__all__ = [
+    "consume_tdx_signed_varint",
+    "consume_tdx_varint",
+    "date_from_yyyymmdd",
+    "decode_compact_float",
+    "decode_gbk_text",
+    "little_f32",
+    "little_u16",
+    "little_u32",
+    "tdx_quantity_from_u32",
+    "tdx_quantity_u32",
+    "yyyymmdd",
+]

axdata_source_tdx/_tdx_wire/_code_utils.py

@@ -0,0 +1,42 @@
+"""Lightweight TDX security code normalization helpers."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+from axdata_source_tdx._tdx_wire._market import market_to_id
+
+_EXCEPTIONS_MODULE = "axdata_source_tdx._tdx_wire.exceptions"
+
+
+def _protocol_error():
+    return import_module(_EXCEPTIONS_MODULE).ProtocolError
+
+
+def split_code(code: str) -> tuple[int, str, str]:
+    full_code = normalize_code(code)
+    market = full_code[:2]
+    number = full_code[2:]
+    return market_to_id(market), market, number
+
+
+def normalize_code(code: str) -> str:
+    text = str(code or "").strip().lower()
+    if len(text) == 8 and text[:2] in {"sz", "sh", "bj"} and text[2:].isdigit():
+        return text
+    if len(text) == 9 and text[6] == ".":
+        symbol, suffix = text[:6], text[7:].upper()
+        suffix_to_market = {"SH": "sh", "SZ": "sz", "BJ": "bj"}
+        market = suffix_to_market.get(suffix)
+        if market is None or not symbol.isdigit():
+            raise _protocol_error()(f"invalid code: {code!r}")
+        return market + symbol
+    if len(text) != 6 or not text.isdigit():
+        raise _protocol_error()(f"invalid code: {code!r}")
+    if text.startswith(("6", "9")):
+        return "sh" + text
+    if text.startswith(("0", "1", "2", "3")):
+        return "sz" + text
+    if text.startswith(("8", "92")):
+        return "bj" + text
+    raise _protocol_error()(f"unable to infer market for code: {code!r}")

axdata_source_tdx/_tdx_wire/_command_codec.py

@@ -0,0 +1,186 @@
+"""Provider-owned command codec dispatch for TDX 7709 protocol commands."""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any, Callable
+
+_COMMAND_PACKAGE = "axdata_source_tdx._tdx_wire.protocol.commands"
+_CODES_MODULE = "axdata_source_tdx._tdx_wire._command_codes"
+_DISPATCH_MODULE = "axdata_source_tdx._tdx_wire._command_dispatch"
+_EXCEPTIONS_MODULE = "axdata_source_tdx._tdx_wire.exceptions"
+
+Builder = Callable[[dict[str, Any], int], Any]
+Parser = Callable[[Any, dict[str, Any] | None], Any]
+_BUILDER_CACHE: dict[int, Builder] = {}
+_PARSER_CACHE: dict[int, Parser] = {}
+
+
+def _load_callable(module_name: str, function_name: str) -> Callable[..., Any]:
+    module = import_module(f"{_COMMAND_PACKAGE}.{module_name}")
+    return getattr(module, function_name)
+
+
+def _lazy_builder(module_name: str, function_name: str) -> Builder:
+    def builder(payload: dict[str, Any], msg_id: int) -> Any:
+        return _load_callable(module_name, function_name)(payload, msg_id)
+
+    builder.__name__ = function_name
+    builder.__qualname__ = function_name
+    builder.__module__ = f"{_COMMAND_PACKAGE}.{module_name}"
+    return builder
+
+
+def _lazy_parser(module_name: str, function_name: str, *, pass_request_payload: bool = True) -> Parser:
+    def parser(response: Any, request_payload: dict[str, Any] | None = None) -> Any:
+        target = _load_callable(module_name, function_name)
+        if pass_request_payload:
+            return target(response, request_payload)
+        return target(response)
+
+    parser.__name__ = function_name
+    parser.__qualname__ = function_name
+    parser.__module__ = f"{_COMMAND_PACKAGE}.{module_name}"
+    return parser
+
+
+def build_command_frame(command: int, payload: dict[str, Any] | None, msg_id: int) -> Any:
+    try:
+        builder = _builder(command)
+    except KeyError as exc:
+        raise _unsupported_command_error()(f"7709 command 0x{command:04x} is not enabled yet") from exc
+    return builder(dict(payload or {}), msg_id)
+
+
+def parse_command_response(command: int, response: Any, request_payload: dict[str, Any] | None = None) -> Any:
+    try:
+        parser = _parser(command)
+    except KeyError as exc:
+        raise _unsupported_command_error()(f"7709 command 0x{command:04x} is not enabled yet") from exc
+    return parser(response, request_payload)
+
+
+def _command_codes() -> dict[str, int]:
+    return import_module(_CODES_MODULE).COMMAND_CODES
+
+
+def _command_code(name: str) -> int:
+    return import_module(_CODES_MODULE).command_code(name)
+
+
+def _command_name(command: int) -> str:
+    return import_module(_CODES_MODULE).command_name(command)
+
+
+def _builder_targets() -> dict[str, tuple[str, str]]:
+    return import_module(_DISPATCH_MODULE).BUILDER_TARGETS
+
+
+def _parser_targets() -> dict[str, tuple[str, str, bool]]:
+    return import_module(_DISPATCH_MODULE).PARSER_TARGETS
+
+
+def _builder_target_items() -> tuple[tuple[str, tuple[str, str]], ...]:
+    return import_module(_DISPATCH_MODULE).BUILDER_TARGET_ITEMS
+
+
+def _parser_target_items() -> tuple[tuple[str, tuple[str, str, bool]], ...]:
+    return import_module(_DISPATCH_MODULE).PARSER_TARGET_ITEMS
+
+
+def _builder_target(name: str) -> tuple[str, str]:
+    return import_module(_DISPATCH_MODULE).builder_target(name)
+
+
+def _parser_target(name: str) -> tuple[str, str, bool]:
+    return import_module(_DISPATCH_MODULE).parser_target(name)
+
+
+def _builder(command: int) -> Builder:
+    builders = globals().get("BUILDERS")
+    if builders is not None:
+        return builders[command]
+    cached = _BUILDER_CACHE.get(command)
+    if cached is not None:
+        return cached
+    command_name = _command_name(command)
+    module_name, function_name = _builder_target(command_name)
+    builder = _lazy_builder(module_name, function_name)
+    _BUILDER_CACHE[command] = builder
+    return builder
+
+
+def _parser(command: int) -> Parser:
+    parsers = globals().get("PARSERS")
+    if parsers is not None:
+        return parsers[command]
+    cached = _PARSER_CACHE.get(command)
+    if cached is not None:
+        return cached
+    command_name = _command_name(command)
+    module_name, function_name, pass_request_payload = _parser_target(command_name)
+    parser = _lazy_parser(module_name, function_name, pass_request_payload=pass_request_payload)
+    _PARSER_CACHE[command] = parser
+    return parser
+
+
+def _builders() -> dict[int, Builder]:
+    cached = globals().get("BUILDERS")
+    if cached is not None:
+        return cached
+    builders = {}
+    for name, (module_name, function_name) in _builder_target_items():
+        command = _command_code(name)
+        builder = _BUILDER_CACHE.get(command)
+        if builder is None:
+            builder = _lazy_builder(module_name, function_name)
+            _BUILDER_CACHE[command] = builder
+        builders[command] = builder
+    globals()["BUILDERS"] = builders
+    return builders
+
+
+def _parsers() -> dict[int, Parser]:
+    cached = globals().get("PARSERS")
+    if cached is not None:
+        return cached
+    parsers = {}
+    for name, (module_name, function_name, pass_request_payload) in _parser_target_items():
+        command = _command_code(name)
+        parser = _PARSER_CACHE.get(command)
+        if parser is None:
+            parser = _lazy_parser(module_name, function_name, pass_request_payload=pass_request_payload)
+            _PARSER_CACHE[command] = parser
+        parsers[command] = parser
+    globals()["PARSERS"] = parsers
+    return parsers
+
+
+def _unsupported_command_error() -> type[Exception]:
+    return import_module(_EXCEPTIONS_MODULE).UnsupportedCommandError
+
+
+def __getattr__(name: str) -> Any:
+    if name == "BUILDERS":
+        return _builders()
+    if name == "PARSERS":
+        return _parsers()
+    if name == "COMMAND_CODES":
+        return _command_codes()
+    if name == "BUILDER_TARGETS":
+        return _builder_targets()
+    if name == "PARSER_TARGETS":
+        return _parser_targets()
+    if name == "UnsupportedCommandError":
+        return _unsupported_command_error()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "BUILDERS",
+    "Builder",
+    "PARSERS",
+    "Parser",
+    "build_command_frame",
+    "parse_command_response",
+]

axdata_source_tdx/_tdx_wire/_command_codes.py

@@ -0,0 +1,74 @@
+"""Provider-owned 7709 command code facts."""
+
+from __future__ import annotations
+
+COMMAND_CODE_ITEMS: tuple[tuple[str, int], ...] = (
+    ("heartbeat", 0x0004),
+    ("handshake", 0x000D),
+    ("capital_changes", 0x000F),
+    ("finance_info", 0x0010),
+    ("security_list", 0x044D),
+    ("security_count", 0x044E),
+    ("price_limits", 0x0452),
+    ("intraday_subchart", 0x051B),
+    ("klines", 0x052D),
+    ("today_intraday", 0x0537),
+    ("legacy_quotes", 0x053E),
+    ("refresh_quotes", 0x0547),
+    ("category_quotes", 0x054B),
+    ("explicit_quotes", 0x054C),
+    ("auction_process", 0x056A),
+    ("file_content", 0x06B9),
+    ("historical_intraday", 0x0FB4),
+    ("today_trades", 0x0FC5),
+    ("historical_trades", 0x0FC6),
+    ("recent_historical_intraday", 0x0FEB),
+)
+
+_TYPE_EXPORTS = {
+    "TYPE_HEARTBEAT": "heartbeat",
+    "TYPE_HANDSHAKE": "handshake",
+}
+
+
+def command_code(name: str) -> int:
+    for command_name, code in COMMAND_CODE_ITEMS:
+        if command_name == name:
+            return code
+    raise KeyError(name)
+
+
+def command_name(code: int) -> str:
+    for command_name, command_code_value in COMMAND_CODE_ITEMS:
+        if command_code_value == code:
+            return command_name
+    raise KeyError(code)
+
+
+def _command_codes() -> dict[str, int]:
+    cached = globals().get("COMMAND_CODES")
+    if cached is not None:
+        return cached
+    command_codes = dict(COMMAND_CODE_ITEMS)
+    globals()["COMMAND_CODES"] = command_codes
+    return command_codes
+
+
+def __getattr__(name: str):
+    if name == "COMMAND_CODES":
+        return _command_codes()
+    if name in _TYPE_EXPORTS:
+        value = command_code(_TYPE_EXPORTS[name])
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "COMMAND_CODE_ITEMS",
+    "COMMAND_CODES",
+    "TYPE_HEARTBEAT",
+    "TYPE_HANDSHAKE",
+    "command_code",
+    "command_name",
+]

axdata_source_tdx/_tdx_wire/_command_defaults.py

@@ -0,0 +1,15 @@
+"""Provider-owned TDX command defaults kept outside command runtimes."""
+
+DEFAULT_AUCTION_MODE = 3
+DEFAULT_AUCTION_COUNT = 500
+DEFAULT_TODAY_INTRADAY_RESERVED_TAIL = b"\x00\x00\x00\x93"
+RECENT_HISTORICAL_INTRADAY_DATE_BASE = 0xFED62304
+FILE_PATH_FIELD_SIZE = 300
+
+__all__ = [
+    "DEFAULT_AUCTION_COUNT",
+    "DEFAULT_AUCTION_MODE",
+    "DEFAULT_TODAY_INTRADAY_RESERVED_TAIL",
+    "FILE_PATH_FIELD_SIZE",
+    "RECENT_HISTORICAL_INTRADAY_DATE_BASE",
+]

axdata_source_tdx/_tdx_wire/_command_dispatch.py

@@ -0,0 +1,96 @@
+"""Provider-owned command dispatch target facts."""
+
+BUILDER_TARGET_ITEMS: tuple[tuple[str, tuple[str, str]], ...] = (
+    ("heartbeat", ("session", "build_heartbeat_frame")),
+    ("handshake", ("session", "build_handshake_frame")),
+    ("capital_changes", ("corporate", "build_capital_changes_frame")),
+    ("finance_info", ("finance", "build_finance_info_frame")),
+    ("security_list", ("security", "build_security_list_frame")),
+    ("security_count", ("security", "build_security_count_frame")),
+    ("price_limits", ("price_limits", "build_price_limits_frame")),
+    ("intraday_subchart", ("subchart", "build_intraday_subchart_frame")),
+    ("klines", ("klines", "build_klines_frame")),
+    ("today_intraday", ("intraday", "build_today_intraday_frame")),
+    ("legacy_quotes", ("quotes", "build_legacy_quotes_frame")),
+    ("refresh_quotes", ("quotes", "build_refresh_quotes_frame")),
+    ("category_quotes", ("quotes", "build_category_quotes_frame")),
+    ("explicit_quotes", ("quotes", "build_explicit_quotes_frame")),
+    ("auction_process", ("auction", "build_auction_process_frame")),
+    ("file_content", ("resources", "build_file_content_frame")),
+    ("historical_intraday", ("intraday", "build_historical_intraday_frame")),
+    ("today_trades", ("trades", "build_today_trades_frame")),
+    ("historical_trades", ("trades", "build_historical_trades_frame")),
+    ("recent_historical_intraday", ("intraday", "build_recent_historical_intraday_frame")),
+)
+
+PARSER_TARGET_ITEMS: tuple[tuple[str, tuple[str, str, bool]], ...] = (
+    ("heartbeat", ("session", "parse_heartbeat_payload", False)),
+    ("handshake", ("session", "parse_handshake_payload", False)),
+    ("capital_changes", ("corporate", "parse_capital_changes_payload", True)),
+    ("finance_info", ("finance", "parse_finance_info_payload", True)),
+    ("security_list", ("security", "parse_security_list_payload", True)),
+    ("security_count", ("security", "parse_security_count_payload", False)),
+    ("price_limits", ("price_limits", "parse_price_limits_payload", True)),
+    ("intraday_subchart", ("subchart", "parse_intraday_subchart_payload", True)),
+    ("klines", ("klines", "parse_klines_payload", True)),
+    ("today_intraday", ("intraday", "parse_today_intraday_payload", True)),
+    ("legacy_quotes", ("quotes", "parse_legacy_quotes_payload", True)),
+    ("refresh_quotes", ("quotes", "parse_refresh_quotes_payload", True)),
+    ("category_quotes", ("quotes", "parse_category_quotes_payload", True)),
+    ("explicit_quotes", ("quotes", "parse_explicit_quotes_payload", True)),
+    ("auction_process", ("auction", "parse_auction_process_payload", True)),
+    ("file_content", ("resources", "parse_file_content_payload", True)),
+    ("historical_intraday", ("intraday", "parse_historical_intraday_payload", True)),
+    ("today_trades", ("trades", "parse_today_trades_payload", True)),
+    ("historical_trades", ("trades", "parse_historical_trades_payload", True)),
+    ("recent_historical_intraday", ("intraday", "parse_recent_historical_intraday_payload", True)),
+)
+
+
+def builder_target(name: str) -> tuple[str, str]:
+    for command_name, target in BUILDER_TARGET_ITEMS:
+        if command_name == name:
+            return target
+    raise KeyError(name)
+
+
+def parser_target(name: str) -> tuple[str, str, bool]:
+    for command_name, target in PARSER_TARGET_ITEMS:
+        if command_name == name:
+            return target
+    raise KeyError(name)
+
+
+def _builder_targets() -> dict[str, tuple[str, str]]:
+    cached = globals().get("BUILDER_TARGETS")
+    if cached is not None:
+        return cached
+    builder_targets = dict(BUILDER_TARGET_ITEMS)
+    globals()["BUILDER_TARGETS"] = builder_targets
+    return builder_targets
+
+
+def _parser_targets() -> dict[str, tuple[str, str, bool]]:
+    cached = globals().get("PARSER_TARGETS")
+    if cached is not None:
+        return cached
+    parser_targets = dict(PARSER_TARGET_ITEMS)
+    globals()["PARSER_TARGETS"] = parser_targets
+    return parser_targets
+
+
+def __getattr__(name: str):
+    if name == "BUILDER_TARGETS":
+        return _builder_targets()
+    if name == "PARSER_TARGETS":
+        return _parser_targets()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+__all__ = [
+    "BUILDER_TARGET_ITEMS",
+    "BUILDER_TARGETS",
+    "PARSER_TARGET_ITEMS",
+    "PARSER_TARGETS",
+    "builder_target",
+    "parser_target",
+]