axdata 0.1.0__py3-none-any.whl

axdata_source_tdx/_tdx_wire/protocol/commands/trades.py

@@ -0,0 +1,275 @@
+"""Trade-detail command builders and parsers."""
+
+from __future__ import annotations
+
+from datetime import datetime, time
+from importlib import import_module
+from typing import Any
+
+from axdata_source_tdx._tdx_wire.protocol.frame import RequestFrame, ResponseFrame
+from axdata_source_tdx._tdx_wire._code_utils import split_code
+from axdata_source_tdx._tdx_wire._command_layouts import SIDE_MAP
+
+from axdata_source_tdx._tdx_wire._command_codes import command_code
+
+TYPE_HISTORICAL_TRADES = command_code("historical_trades")
+TYPE_TODAY_TRADES = command_code("today_trades")
+_BINARY_MODULE = "axdata_source_tdx._tdx_wire._binary"
+_EXCEPTIONS_MODULE = "axdata_source_tdx._tdx_wire.exceptions"
+_MODEL_MODULE = "axdata_source_tdx._tdx_wire.models.trade"
+_TIME_UTILS_MODULE = "axdata_source_tdx._tdx_wire._time_utils"
+_BINARY_EXPORTS = {
+    "consume_tdx_signed_varint",
+    "consume_tdx_varint",
+    "date_from_yyyymmdd",
+    "little_f32",
+    "little_u16",
+    "yyyymmdd",
+}
+_EXCEPTION_EXPORTS = {"ProtocolError"}
+_MODEL_EXPORTS = {"TradeDetailRecord", "TradeDetailSeries"}
+_TIME_EXPORTS = {"SHANGHAI_TZ"}
+
+
+def _protocol_error():
+    return import_module(_EXCEPTIONS_MODULE).ProtocolError
+
+
+def _binary():
+    return import_module(_BINARY_MODULE)
+
+
+def _consume_tdx_signed_varint(payload: bytes, offset: int) -> tuple[int, int]:
+    return _binary().consume_tdx_signed_varint(payload, offset)
+
+
+def _consume_tdx_varint(payload: bytes, offset: int) -> tuple[int, int]:
+    return _binary().consume_tdx_varint(payload, offset)
+
+
+def _date_from_yyyymmdd(raw: int):
+    return _binary().date_from_yyyymmdd(raw)
+
+
+def _little_f32(data: bytes) -> float:
+    return _binary().little_f32(data)
+
+
+def _little_u16(data: bytes) -> int:
+    return _binary().little_u16(data)
+
+
+def _yyyymmdd(value) -> int:
+    return _binary().yyyymmdd(value)
+
+
+def _trade_detail_record_cls():
+    return import_module(_MODEL_MODULE).TradeDetailRecord
+
+
+def _trade_detail_series_cls():
+    return import_module(_MODEL_MODULE).TradeDetailSeries
+
+
+def _shanghai_tz():
+    return import_module(_TIME_UTILS_MODULE).SHANGHAI_TZ
+
+
+def build_today_trades_frame(payload: dict[str, Any], msg_id: int) -> RequestFrame:
+    market_id, _, number = split_code(payload["code"])
+    start = normalize_trade_start(payload.get("start", 0))
+    count = normalize_trade_count(payload.get("count", 115))
+    data = (
+        market_id.to_bytes(1, "little", signed=False)
+        + b"\x00"
+        + number.encode("ascii")
+        + start.to_bytes(2, "little", signed=False)
+        + count.to_bytes(2, "little", signed=False)
+    )
+    return RequestFrame(msg_id=msg_id, msg_type=TYPE_TODAY_TRADES, data=data)
+
+
+def build_historical_trades_frame(payload: dict[str, Any], msg_id: int) -> RequestFrame:
+    market_id, _, number = split_code(payload["code"])
+    trade_date_raw = historical_trade_date(payload)
+    start = normalize_trade_start(payload.get("start", 0))
+    count = normalize_trade_count(payload.get("count", 900))
+    data = (
+        trade_date_raw.to_bytes(4, "little", signed=False)
+        + market_id.to_bytes(2, "little", signed=False)
+        + number.encode("ascii")
+        + start.to_bytes(2, "little", signed=False)
+        + count.to_bytes(2, "little", signed=False)
+    )
+    return RequestFrame(msg_id=msg_id, msg_type=TYPE_HISTORICAL_TRADES, data=data)
+
+
+def parse_today_trades_payload(
+    response: ResponseFrame,
+    request_payload: dict[str, Any] | None = None,
+) -> TradeDetailSeries:
+    request_payload = request_payload or {}
+    requested_code = request_payload.get("code", "sz000001")
+    market_id, exchange, number = split_code(requested_code)
+    start = normalize_trade_start(request_payload.get("start", 0))
+    count = normalize_trade_count(request_payload.get("count", 115))
+    payload = response.data
+    if len(payload) < 2:
+        raise _protocol_error()("invalid today trades payload")
+
+    record_count = _little_u16(payload[:2])
+    records = parse_trade_records(payload, offset=2, record_count=record_count, start=start, trade_date_raw=None)
+    return _trade_detail_series_cls()(
+        exchange=exchange,
+        market_id=market_id,
+        code=number,
+        start=start,
+        request_count=count,
+        records=tuple(records),
+        raw_payload=payload if request_payload.get("include_raw") else b"",
+    )
+
+
+def parse_historical_trades_payload(
+    response: ResponseFrame,
+    request_payload: dict[str, Any] | None = None,
+) -> TradeDetailSeries:
+    request_payload = request_payload or {}
+    requested_code = request_payload.get("code", "sz000001")
+    market_id, exchange, number = split_code(requested_code)
+    trade_date_raw = historical_trade_date(request_payload)
+    trade_date = _date_from_yyyymmdd(trade_date_raw)
+    if trade_date is None:
+        raise _protocol_error()(f"invalid historical trades trade_date: {trade_date_raw}")
+    start = normalize_trade_start(request_payload.get("start", 0))
+    count = normalize_trade_count(request_payload.get("count", 900))
+    payload = response.data
+    if len(payload) < 6:
+        raise _protocol_error()("invalid historical trades payload")
+
+    record_count = _little_u16(payload[:2])
+    price_base_raw_f32 = float(_little_f32(payload[2:6]))
+    records = parse_trade_records(payload, offset=6, record_count=record_count, start=start, trade_date_raw=trade_date_raw)
+    return _trade_detail_series_cls()(
+        exchange=exchange,
+        market_id=market_id,
+        code=number,
+        start=start,
+        request_count=count,
+        records=tuple(records),
+        trade_date=trade_date,
+        price_base_raw_f32=price_base_raw_f32,
+        raw_payload=payload if request_payload.get("include_raw") else b"",
+    )
+
+
+def parse_trade_records(
+    payload: bytes,
+    *,
+    offset: int,
+    record_count: int,
+    start: int,
+    trade_date_raw: int | None,
+) -> list[TradeDetailRecord]:
+    trade_date = _date_from_yyyymmdd(trade_date_raw) if trade_date_raw is not None else None
+    trade_detail_record = _trade_detail_record_cls()
+    records: list[TradeDetailRecord] = []
+    price_acc_raw = 0
+    for index in range(record_count):
+        record_start = offset
+        if offset + 2 > len(payload):
+            raise _protocol_error()("truncated trade time field")
+        time_minutes = _little_u16(payload[offset : offset + 2])
+        offset += 2
+        price_delta_raw, offset = _consume_tdx_signed_varint(payload, offset)
+        volume, offset = _consume_tdx_varint(payload, offset)
+        order_count, offset = _consume_tdx_varint(payload, offset)
+        status_raw, offset = _consume_tdx_varint(payload, offset)
+        tail_raw, offset = _consume_tdx_varint(payload, offset)
+        price_acc_raw += price_delta_raw
+        trade_time = trade_time_from_minutes(time_minutes)
+        trade_datetime = (
+            datetime.combine(trade_date, trade_time, tzinfo=_shanghai_tz())
+            if trade_date is not None
+            else None
+        )
+        records.append(
+            trade_detail_record(
+                trade_time=trade_time,
+                trade_datetime=trade_datetime,
+                trade_date=trade_date,
+                index=index,
+                absolute_index=start + index,
+                time_minutes=time_minutes,
+                price=price_acc_raw / 10000.0,
+                price_acc_raw=price_acc_raw,
+                price_delta_raw=price_delta_raw,
+                volume=volume,
+                order_count=order_count,
+                status_raw=status_raw,
+                side=SIDE_MAP.get(status_raw, f"status_{status_raw}"),
+                tail_raw=tail_raw,
+                record_hex=payload[record_start:offset].hex(),
+            )
+        )
+
+    if offset != len(payload):
+        raise _protocol_error()(f"unexpected trailing trade payload bytes: {len(payload) - offset}")
+    return records
+
+
+def trade_time_from_minutes(time_minutes: int) -> time:
+    if time_minutes < 0 or time_minutes >= 24 * 60:
+        raise _protocol_error()(f"invalid trade time minutes: {time_minutes}")
+    return time(time_minutes // 60, time_minutes % 60)
+
+
+def historical_trade_date(payload: dict[str, Any]) -> int:
+    value = payload.get("trade_date", payload.get("date"))
+    if value in (None, "", 0, "0"):
+        raise _protocol_error()("historical trades trade_date is required")
+    return _yyyymmdd(value)
+
+
+def normalize_trade_start(value: Any) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError) as exc:
+        raise _protocol_error()("start must be an integer") from exc
+    if parsed < 0 or parsed > 0xFFFF:
+        raise _protocol_error()("start must be between 0 and 65535")
+    return parsed
+
+
+def normalize_trade_count(value: Any) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError) as exc:
+        raise _protocol_error()("count must be an integer") from exc
+    if parsed <= 0 or parsed > 0xFFFF:
+        raise _protocol_error()("count must be between 1 and 65535")
+    return parsed
+
+
+def __getattr__(name: str) -> Any:
+    if name in _EXCEPTION_EXPORTS:
+        value = getattr(import_module(_EXCEPTIONS_MODULE), name)
+        globals()[name] = value
+        return value
+    if name in _MODEL_EXPORTS:
+        value = getattr(import_module(_MODEL_MODULE), name)
+        globals()[name] = value
+        return value
+    if name in _BINARY_EXPORTS:
+        value = getattr(import_module(_BINARY_MODULE), name)
+        globals()[name] = value
+        return value
+    if name in _TIME_EXPORTS:
+        value = getattr(import_module(_TIME_UTILS_MODULE), name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | _EXCEPTION_EXPORTS | _MODEL_EXPORTS | _BINARY_EXPORTS | _TIME_EXPORTS)

axdata_source_tdx/_tdx_wire/protocol/constants.py

@@ -0,0 +1,70 @@
+"""7709 protocol constants."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+
+_COMMAND_CODES_MODULE = "axdata_source_tdx._tdx_wire._command_codes"
+_FRAME_CONSTANTS_MODULE = "axdata_source_tdx._tdx_wire.protocol._frame_constants"
+_REQUEST_DEFAULTS_MODULE = "axdata_source_tdx._tdx_wire._request_defaults"
+_COMMAND_EXPORTS = {
+    "TYPE_AUCTION_PROCESS": "auction_process",
+    "TYPE_CAPITAL_CHANGES": "capital_changes",
+    "TYPE_CATEGORY_QUOTES": "category_quotes",
+    "TYPE_EXPLICIT_QUOTES": "explicit_quotes",
+    "TYPE_FILE_CONTENT": "file_content",
+    "TYPE_FINANCE_INFO": "finance_info",
+    "TYPE_HANDSHAKE": "handshake",
+    "TYPE_HEARTBEAT": "heartbeat",
+    "TYPE_HISTORICAL_INTRADAY": "historical_intraday",
+    "TYPE_HISTORICAL_TRADES": "historical_trades",
+    "TYPE_INTRADAY_SUBCHART": "intraday_subchart",
+    "TYPE_KLINES": "klines",
+    "TYPE_LEGACY_QUOTES": "legacy_quotes",
+    "TYPE_PRICE_LIMITS": "price_limits",
+    "TYPE_RECENT_HISTORICAL_INTRADAY": "recent_historical_intraday",
+    "TYPE_REFRESH_QUOTES": "refresh_quotes",
+    "TYPE_SECURITY_COUNT": "security_count",
+    "TYPE_SECURITY_LIST": "security_list",
+    "TYPE_TODAY_INTRADAY": "today_intraday",
+    "TYPE_TODAY_TRADES": "today_trades",
+}
+_FRAME_EXPORTS = {"CONTROL_DEFAULT", "PREFIX", "PREFIX_RESP"}
+_REQUEST_DEFAULT_EXPORTS = {"DEFAULT_CODE_PAGE_SIZE", "DEFAULT_QUOTE_BATCH_SIZE"}
+
+
+def _command_codes_module():
+    return import_module(_COMMAND_CODES_MODULE)
+
+
+def _frame_constants_module():
+    return import_module(_FRAME_CONSTANTS_MODULE)
+
+
+def _request_defaults_module():
+    return import_module(_REQUEST_DEFAULTS_MODULE)
+
+
+def __getattr__(name: str):
+    if name in _COMMAND_EXPORTS:
+        value = _command_codes_module().command_code(_COMMAND_EXPORTS[name])
+    elif name == "command_code":
+        value = _command_codes_module().command_code
+    elif name == "COMMAND_CODES":
+        value = _command_codes_module().COMMAND_CODES
+    elif name in _FRAME_EXPORTS:
+        value = getattr(_frame_constants_module(), name)
+    elif name in _REQUEST_DEFAULT_EXPORTS:
+        value = getattr(_request_defaults_module(), name)
+    else:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))
+
+
+__all__ = sorted(set(_COMMAND_EXPORTS) | _FRAME_EXPORTS | _REQUEST_DEFAULT_EXPORTS | {"COMMAND_CODES", "command_code"})

axdata_source_tdx/_tdx_wire/protocol/frame.py

@@ -0,0 +1,141 @@
+"""7709 TCP frame encoding and decoding."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib import import_module
+
+
+from ._frame_constants import CONTROL_DEFAULT, PREFIX, PREFIX_RESP
+
+
+_EXCEPTIONS_MODULE = "axdata_source_tdx._tdx_wire.exceptions"
+_EXCEPTION_EXPORTS = {"ConnectionClosedError", "ProtocolError"}
+_STDLIB_EXPORTS = {"socket", "struct", "zlib"}
+
+
+def _connection_closed_error():
+    return import_module(_EXCEPTIONS_MODULE).ConnectionClosedError
+
+
+def _protocol_error():
+    return import_module(_EXCEPTIONS_MODULE).ProtocolError
+
+
+def __getattr__(name: str):
+    if name in _EXCEPTION_EXPORTS:
+        value = getattr(import_module(_EXCEPTIONS_MODULE), name)
+        globals()[name] = value
+        return value
+    if name in _STDLIB_EXPORTS:
+        value = import_module(name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | _EXCEPTION_EXPORTS | _STDLIB_EXPORTS)
+
+
+@dataclass(frozen=True, slots=True)
+class RequestFrame:
+    msg_id: int
+    msg_type: int
+    data: bytes = b""
+    control: int = CONTROL_DEFAULT
+
+    def to_bytes(self) -> bytes:
+        import struct
+
+        length = len(self.data) + 2
+        return struct.pack("<BIBHHH", PREFIX, self.msg_id, self.control, length, length, self.msg_type) + self.data
+
+
+@dataclass(frozen=True, slots=True)
+class ResponseFrame:
+    control: int
+    msg_id: int
+    msg_type: int
+    zip_length: int
+    length: int
+    data: bytes
+    raw: bytes
+    response_header_reserved: int = 0
+
+
+def read_exact(sock: socket.socket, size: int) -> bytes:
+    chunks = bytearray()
+    while len(chunks) < size:
+        piece = sock.recv(size - len(chunks))
+        if not piece:
+            raise _connection_closed_error()("socket closed by remote peer")
+        chunks.extend(piece)
+    return bytes(chunks)
+
+
+def read_response_frame(sock: socket.socket) -> bytes:
+    window = bytearray(read_exact(sock, 4))
+    while bytes(window) != PREFIX_RESP:
+        window = window[1:] + read_exact(sock, 1)
+
+    header = read_exact(sock, 12)
+    zip_length = int.from_bytes(header[8:10], "little", signed=False)
+    payload = read_exact(sock, zip_length)
+    return bytes(window) + header + payload
+
+
+def decode_response(raw: bytes) -> ResponseFrame:
+    if len(raw) < 16:
+        raise _protocol_error()(f"invalid response length: {len(raw)}")
+    if raw[:4] != PREFIX_RESP:
+        raise _protocol_error()(f"invalid response prefix: {raw[:4].hex()}")
+
+    control = raw[4]
+    msg_id = int.from_bytes(raw[5:9], "little", signed=False)
+    reserved = raw[9]
+    msg_type = int.from_bytes(raw[10:12], "little", signed=False)
+    zip_length = int.from_bytes(raw[12:14], "little", signed=False)
+    length = int.from_bytes(raw[14:16], "little", signed=False)
+    payload = raw[16:]
+
+    if len(payload) != zip_length:
+        raise _protocol_error()(f"zip length mismatch: expected {zip_length}, got {len(payload)}")
+
+    if zip_length != length:
+        import zlib
+
+        data = zlib.decompress(payload)
+    else:
+        data = payload
+    if len(data) != length:
+        raise _protocol_error()(f"decoded length mismatch: expected {length}, got {len(data)}")
+
+    return ResponseFrame(
+        control=control,
+        msg_id=msg_id,
+        msg_type=msg_type,
+        zip_length=zip_length,
+        length=length,
+        data=data,
+        raw=raw,
+        response_header_reserved=reserved,
+    )
+
+
+__all__ = [
+    "ConnectionClosedError",
+    "CONTROL_DEFAULT",
+    "PREFIX",
+    "PREFIX_RESP",
+    "ProtocolError",
+    "RequestFrame",
+    "ResponseFrame",
+    "dataclass",
+    "decode_response",
+    "read_exact",
+    "read_response_frame",
+    "socket",
+    "struct",
+    "zlib",
+]

axdata_source_tdx/_tdx_wire/protocol/unit.py

@@ -0,0 +1,98 @@
+"""Compatibility binary helpers for 7709 command parsers."""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from importlib import import_module
+
+
+_BINARY_MODULE_NAME = "axdata_source_tdx._tdx_wire._binary"
+_MARKET_MODULE_NAME = "axdata_source_tdx._tdx_wire._market"
+_MARKET_EXPORTS = {"ID_TO_MARKET", "MARKET_TO_ID", "market_to_id", "normalize_market"}
+
+_BINARY_MODULE = None
+_MARKET_MODULE = None
+
+
+def _load_binary_module():
+    global _BINARY_MODULE
+    if _BINARY_MODULE is None:
+        _BINARY_MODULE = import_module(_BINARY_MODULE_NAME)
+    return _BINARY_MODULE
+
+
+def _load_market_module():
+    global _MARKET_MODULE
+    if _MARKET_MODULE is None:
+        _MARKET_MODULE = import_module(_MARKET_MODULE_NAME)
+    return _MARKET_MODULE
+
+
+def little_u16(data: bytes) -> int:
+    return _load_binary_module().little_u16(data)
+
+
+def little_u32(data: bytes) -> int:
+    return _load_binary_module().little_u32(data)
+
+
+def little_f32(data: bytes) -> float:
+    return _load_binary_module().little_f32(data)
+
+
+def tdx_quantity_u32(data: bytes) -> float:
+    return _load_binary_module().tdx_quantity_u32(data)
+
+
+def tdx_quantity_from_u32(raw: int) -> float:
+    return _load_binary_module().tdx_quantity_from_u32(raw)
+
+
+def decode_gbk_text(data: bytes) -> str:
+    return _load_binary_module().decode_gbk_text(data)
+
+
+def yyyymmdd(value: str | int | date | datetime | None = None) -> int:
+    return _load_binary_module().yyyymmdd(value)
+
+
+def date_from_yyyymmdd(raw: int) -> date | None:
+    return _load_binary_module().date_from_yyyymmdd(raw)
+
+
+def consume_tdx_signed_varint(payload: bytes, offset: int) -> tuple[int, int]:
+    return _load_binary_module().consume_tdx_signed_varint(payload, offset)
+
+
+def consume_tdx_varint(payload: bytes, offset: int) -> tuple[int, int]:
+    return _load_binary_module().consume_tdx_varint(payload, offset)
+
+
+def __getattr__(name: str):
+    if name in _MARKET_EXPORTS:
+        value = getattr(_load_market_module(), name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))
+
+
+__all__ = [
+    "ID_TO_MARKET",
+    "MARKET_TO_ID",
+    "consume_tdx_signed_varint",
+    "consume_tdx_varint",
+    "date_from_yyyymmdd",
+    "decode_gbk_text",
+    "little_f32",
+    "little_u16",
+    "little_u32",
+    "market_to_id",
+    "normalize_market",
+    "tdx_quantity_from_u32",
+    "tdx_quantity_u32",
+    "yyyymmdd",
+]

axdata_source_tdx/_tdx_wire/py.typed

@@ -0,0 +1 @@
+

axdata_source_tdx/_tdx_wire/transport/__init__.py

@@ -0,0 +1,28 @@
+"""Transport abstractions for axdata_source_tdx._tdx_wire."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+__all__ = ["InMemoryTransport", "PooledSocketTransport", "SocketTransport", "Transport"]
+
+_EXPORT_MODULES = {
+    "InMemoryTransport": ".memory",
+    "PooledSocketTransport": ".pool",
+    "SocketTransport": ".socket",
+    "Transport": ".base",
+}
+
+
+def __getattr__(name: str):
+    module_name = _EXPORT_MODULES.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module = import_module(module_name, __name__)
+    value = getattr(module, name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

axdata_source_tdx/_tdx_wire/transport/base.py

@@ -0,0 +1,21 @@
+"""Transport interface definitions."""
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+
+class Transport(Protocol):
+    """Request/response transport used by API services."""
+
+    def connect(self) -> None:
+        """Open transport resources."""
+
+    def close(self) -> None:
+        """Close transport resources."""
+
+    def execute(self, command: int, payload: dict[str, Any] | None = None) -> Any:
+        """Execute one logical protocol command."""
+
+    def request(self, command: str) -> str:
+        """Legacy text request used by early health tests."""

axdata_source_tdx/_tdx_wire/transport/memory.py

@@ -0,0 +1,42 @@
+"""测试和示例使用的内存 transport。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class InMemoryTransport:
+    """不依赖 socket 的确定性 transport。
+
+    用于在接入真实 7709 服务器前验证对外 API 和单元测试。
+    """
+
+    def __init__(self) -> None:
+        self.connected = False
+        self.calls: list[tuple[int, dict[str, Any]]] = []
+        self.responses: dict[int, Any] = {}
+
+    def connect(self) -> None:
+        self.connected = True
+
+    def close(self) -> None:
+        self.connected = False
+
+    def register_response(self, command: int, response: Any) -> None:
+        self.responses[command] = response
+
+    def execute(self, command: int, payload: dict[str, Any] | None = None) -> Any:
+        request_payload = dict(payload or {})
+        self.calls.append((command, request_payload))
+        if command in self.responses:
+            return self.responses[command]
+        return {
+            "command": f"0x{command:04x}",
+            "payload": request_payload,
+            "status": "memory_transport",
+        }
+
+    def request(self, command: str) -> str:
+        if command == "ping":
+            return "pong"
+        raise ValueError(f"unsupported command: {command}")