repo hygiene: track the PINK launcher import closure
67 production .py modules that the running PINK service imports but which were never committed: prod/bingx/ (HTTP client, market/user streams, journal, config), prod/clean_arch/ adapters/persistence/runtime/dita/dita_v2 production modules and their co-located tests. Rule going forward: every module imported by launch_dolphin_pink.py / pink_direct.py must appear in git ls-files. Excludes _backup dirs, __pycache__, and non-code files. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Codex
263
prod/clean_arch/dita_v2/real_zinc_plane.py
Normal file
263
prod/clean_arch/dita_v2/real_zinc_plane.py
Normal file
@@ -0,0 +1,263 @@
|
||||
"""Real Zinc-backed hot-path plane for DITAv2.
|
||||
|
||||
This wrapper uses the Zinc Python adapter directly. The kernel still talks to
|
||||
the narrow ``ZincPlane`` interface; this module just makes that interface real.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import asdict
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional
|
||||
import json
|
||||
import os
|
||||
import struct
|
||||
import sys
|
||||
import threading
|
||||
|
||||
from .contracts import KernelIntent, TradeSide, TradeSlot, TradeStage, VenueOrder, VenueOrderStatus
|
||||
from .control import KernelControlSnapshot
|
||||
|
||||
_ZINC_ADAPTER_PATH = Path(__file__).resolve().parents[3] / "zinc" / "adapters" / "python"
|
||||
if _ZINC_ADAPTER_PATH.exists() and str(_ZINC_ADAPTER_PATH) not in sys.path:
|
||||
sys.path.append(str(_ZINC_ADAPTER_PATH))
|
||||
|
||||
try: # pragma: no cover - exercised in integration tests
|
||||
from zinc import SharedRegion
|
||||
except Exception as exc: # pragma: no cover
|
||||
SharedRegion = None # type: ignore[assignment]
|
||||
_ZINC_IMPORT_ERROR = exc
|
||||
else:
|
||||
_ZINC_IMPORT_ERROR = None
|
||||
|
||||
|
||||
class RealZincUnavailable(RuntimeError):
|
||||
"""Raised when the Zinc Python adapter cannot be loaded."""
|
||||
|
||||
|
||||
def require_real_zinc() -> None:
|
||||
if SharedRegion is None:
|
||||
raise RealZincUnavailable(str(_ZINC_IMPORT_ERROR))
|
||||
|
||||
|
||||
def _json_default(value: Any) -> Any:
|
||||
if hasattr(value, "value"):
|
||||
return value.value
|
||||
if hasattr(value, "isoformat"):
|
||||
try:
|
||||
return value.isoformat()
|
||||
except Exception:
|
||||
pass
|
||||
if hasattr(value, "__dict__"):
|
||||
return dict(vars(value))
|
||||
raise TypeError(f"Unsupported value: {type(value)!r}")
|
||||
|
||||
|
||||
def _slot_to_payload(slot: TradeSlot) -> Dict[str, Any]:
|
||||
data = slot.to_dict()
|
||||
return data
|
||||
|
||||
|
||||
def _slot_from_payload(payload: Dict[str, Any]) -> TradeSlot:
|
||||
active_entry_order = None
|
||||
active_exit_order = None
|
||||
if isinstance(payload.get("active_entry_order"), dict):
|
||||
active_entry_order = VenueOrder(
|
||||
internal_trade_id=str(payload.get("trade_id", "")),
|
||||
venue_order_id=str(payload["active_entry_order"].get("venue_order_id", "")),
|
||||
venue_client_id=str(payload["active_entry_order"].get("venue_client_id", "")),
|
||||
side=TradeSide(str(payload["active_entry_order"].get("side", TradeSide.FLAT.value))),
|
||||
intended_size=float(payload["active_entry_order"].get("intended_size", payload.get("size", 0.0))),
|
||||
filled_size=float(payload["active_entry_order"].get("filled_size", 0.0)),
|
||||
average_fill_price=float(payload["active_entry_order"].get("average_fill_price", 0.0)),
|
||||
status=VenueOrderStatus(str(payload["active_entry_order"].get("status", VenueOrderStatus.NEW.value))),
|
||||
metadata=dict(payload["active_entry_order"].get("metadata", {})),
|
||||
)
|
||||
if isinstance(payload.get("active_exit_order"), dict):
|
||||
active_exit_order = VenueOrder(
|
||||
internal_trade_id=str(payload.get("trade_id", "")),
|
||||
venue_order_id=str(payload["active_exit_order"].get("venue_order_id", "")),
|
||||
venue_client_id=str(payload["active_exit_order"].get("venue_client_id", "")),
|
||||
side=TradeSide(str(payload["active_exit_order"].get("side", TradeSide.FLAT.value))),
|
||||
intended_size=float(payload["active_exit_order"].get("intended_size", payload.get("size", 0.0))),
|
||||
filled_size=float(payload["active_exit_order"].get("filled_size", 0.0)),
|
||||
average_fill_price=float(payload["active_exit_order"].get("average_fill_price", 0.0)),
|
||||
status=VenueOrderStatus(str(payload["active_exit_order"].get("status", VenueOrderStatus.NEW.value))),
|
||||
metadata=dict(payload["active_exit_order"].get("metadata", {})),
|
||||
)
|
||||
slot = TradeSlot(
|
||||
slot_id=int(payload.get("slot_id", 0)),
|
||||
trade_id=str(payload.get("trade_id", "")),
|
||||
asset=str(payload.get("asset", "")),
|
||||
side=TradeSide(str(payload.get("side", TradeSide.FLAT.value))),
|
||||
entry_price=float(payload.get("entry_price", 0.0)),
|
||||
size=float(payload.get("size", 0.0)),
|
||||
initial_size=float(payload.get("initial_size", 0.0)),
|
||||
leverage=float(payload.get("leverage", 0.0)),
|
||||
entry_time=datetime.fromisoformat(payload["entry_time"]) if payload.get("entry_time") else None,
|
||||
unrealized_pnl=float(payload.get("unrealized_pnl", 0.0)),
|
||||
realized_pnl=float(payload.get("realized_pnl", 0.0)),
|
||||
closed=bool(payload.get("closed", False)),
|
||||
exit_leg_ratios=tuple(float(r) for r in payload.get("exit_leg_ratios", (1.0,))),
|
||||
active_leg_index=int(payload.get("active_leg_index", 0)),
|
||||
active_exit_order=active_exit_order,
|
||||
active_entry_order=active_entry_order,
|
||||
fsm_state=TradeStage(str(payload.get("fsm_state", TradeStage.IDLE.value))),
|
||||
close_reason=str(payload.get("close_reason", "")),
|
||||
last_event_time=datetime.fromisoformat(payload["last_event_time"]) if payload.get("last_event_time") else None,
|
||||
seen_event_ids=tuple(str(event_id) for event_id in payload.get("seen_event_ids", ())),
|
||||
metadata=dict(payload.get("metadata", {})),
|
||||
)
|
||||
return slot
|
||||
|
||||
|
||||
def _encode_packet(seq: int, payload: Dict[str, Any]) -> bytes:
|
||||
text = json.dumps(payload, sort_keys=True, ensure_ascii=False, default=_json_default, separators=(",", ":")).encode("utf-8")
|
||||
return struct.pack("!QQ", int(seq), len(text)) + text
|
||||
|
||||
|
||||
def _decode_packet(buf: memoryview) -> Dict[str, Any]:
|
||||
if len(buf) < 16:
|
||||
return {}
|
||||
seq, size = struct.unpack_from("!QQ", buf, 0)
|
||||
if size <= 0 or size > len(buf) - 16:
|
||||
return {}
|
||||
payload = bytes(buf[16 : 16 + size]).decode("utf-8")
|
||||
out = json.loads(payload)
|
||||
if isinstance(out, dict):
|
||||
out["_seq"] = seq
|
||||
return out
|
||||
|
||||
|
||||
class RealZincPlane:
|
||||
"""Shared-memory Zinc plane used by the Python prototype."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
prefix: str,
|
||||
slot_count: int = 10,
|
||||
intent_capacity: int = 1 << 20,
|
||||
state_capacity: int = 1 << 20,
|
||||
control_capacity: int = 1 << 20,
|
||||
create: bool = True,
|
||||
) -> None:
|
||||
require_real_zinc()
|
||||
base = prefix.strip("/").replace("/", "_")
|
||||
self.intent_name = f"{base}_intent"
|
||||
self.state_name = f"{base}_state"
|
||||
self.control_name = f"{base}_control"
|
||||
self._intent_seq = 0
|
||||
self._state_seq = 0
|
||||
self._control_seq = 0
|
||||
self._lock = threading.Lock()
|
||||
self._slot_cache: Dict[int, TradeSlot] = {i: TradeSlot(slot_id=i) for i in range(int(slot_count))}
|
||||
self._slot_count = int(slot_count)
|
||||
self._intent_cache: List[Dict[str, Any]] = []
|
||||
self._control_cache = KernelControlSnapshot()
|
||||
if create:
|
||||
self.intent_region = SharedRegion.create(self.intent_name, intent_capacity)
|
||||
self.state_region = SharedRegion.create(self.state_name, state_capacity)
|
||||
self.control_region = SharedRegion.create(self.control_name, control_capacity)
|
||||
self._write_region(self.control_region, self._control_seq, {"control": self._control_cache.as_dict()})
|
||||
self._write_region(
|
||||
self.state_region,
|
||||
self._state_seq,
|
||||
{"slots": [self._slot_cache[key].to_dict() for key in range(self._slot_count)]},
|
||||
)
|
||||
self._write_region(self.intent_region, self._intent_seq, {"items": []})
|
||||
else:
|
||||
self.intent_region = SharedRegion.open(self.intent_name)
|
||||
self.state_region = SharedRegion.open(self.state_name)
|
||||
self.control_region = SharedRegion.open(self.control_name)
|
||||
control_payload = _decode_packet(self.control_region.as_buffer())
|
||||
state_payload = _decode_packet(self.state_region.as_buffer())
|
||||
intent_payload = _decode_packet(self.intent_region.as_buffer())
|
||||
if isinstance(control_payload.get("control"), dict):
|
||||
self._control_cache = KernelControlSnapshot(**control_payload["control"])
|
||||
if isinstance(state_payload.get("slots"), list):
|
||||
for slot_payload in state_payload["slots"]:
|
||||
if isinstance(slot_payload, dict):
|
||||
slot = _slot_from_payload(slot_payload)
|
||||
self._slot_cache[int(slot.slot_id)] = slot
|
||||
if isinstance(intent_payload.get("items"), list):
|
||||
self._intent_cache = list(intent_payload["items"])
|
||||
|
||||
def close(self) -> None:
|
||||
self.intent_region.close()
|
||||
self.state_region.close()
|
||||
self.control_region.close()
|
||||
|
||||
def publish_intent(self, intent: KernelIntent) -> None:
|
||||
with self._lock:
|
||||
self._intent_seq += 1
|
||||
row = intent.__dict__.copy()
|
||||
row["timestamp"] = intent.timestamp.isoformat()
|
||||
row["side"] = intent.side.value
|
||||
row["action"] = intent.action.value
|
||||
row["stage"] = intent.stage.value
|
||||
row["exit_leg_ratios"] = list(intent.exit_leg_ratios)
|
||||
row["metadata"] = json.loads(json.dumps(intent.metadata, default=_json_default))
|
||||
self._intent_cache.append(row)
|
||||
self._write_region(self.intent_region, self._intent_seq, {"items": self._intent_cache[-512:]})
|
||||
|
||||
def write_slot(self, slot: TradeSlot) -> None:
|
||||
with self._lock:
|
||||
self._state_seq += 1
|
||||
self._slot_cache[int(slot.slot_id)] = slot
|
||||
payload = {
|
||||
"slots": [self._slot_cache[key].to_dict() for key in range(self._slot_count)],
|
||||
}
|
||||
self._write_region(self.state_region, self._state_seq, payload)
|
||||
|
||||
def read_slots(self) -> List[TradeSlot]:
|
||||
payload = _decode_packet(self.state_region.as_buffer())
|
||||
slots = payload.get("slots", []) if isinstance(payload, dict) else []
|
||||
return [_slot_from_payload(slot) for slot in sorted(slots, key=lambda row: int(row.get("slot_id", 0)))]
|
||||
|
||||
def read_intents(self) -> List[Dict[str, Any]]:
|
||||
payload = _decode_packet(self.intent_region.as_buffer())
|
||||
items = payload.get("items", []) if isinstance(payload, dict) else []
|
||||
return list(items)
|
||||
|
||||
def update_control(self, control: KernelControlSnapshot) -> None:
|
||||
with self._lock:
|
||||
self._control_seq += 1
|
||||
self._control_cache = control
|
||||
self._write_region(self.control_region, self._control_seq, {"control": control.as_dict()})
|
||||
|
||||
def read_control(self) -> KernelControlSnapshot:
|
||||
payload = _decode_packet(self.control_region.as_buffer())
|
||||
control = payload.get("control") if isinstance(payload, dict) else None
|
||||
if not isinstance(control, dict):
|
||||
return self._control_cache
|
||||
return KernelControlSnapshot(**control)
|
||||
|
||||
def wait_on_state(self, timeout_ms: int = 1000) -> bool:
|
||||
return bool(self.state_region.wait(timeout_ms))
|
||||
|
||||
def notify_state(self) -> None:
|
||||
self.state_region.notify()
|
||||
|
||||
def wait_on_control(self, timeout_ms: int = 1000) -> bool:
|
||||
return bool(self.control_region.wait(timeout_ms))
|
||||
|
||||
def notify_control(self) -> None:
|
||||
self.control_region.notify()
|
||||
|
||||
def wait_on_intent(self, timeout_ms: int = 1000) -> bool:
|
||||
return bool(self.intent_region.wait(timeout_ms))
|
||||
|
||||
def notify_intent(self) -> None:
|
||||
self.intent_region.notify()
|
||||
|
||||
def _write_region(self, region: Any, seq: int, payload: Dict[str, Any]) -> None:
|
||||
packet = _encode_packet(seq, payload)
|
||||
buf = region.as_buffer()
|
||||
if len(packet) > len(buf):
|
||||
raise ValueError(f"payload too large for Zinc region: {len(packet)} > {len(buf)}")
|
||||
view = memoryview(buf)
|
||||
view[:] = b"\x00" * len(view)
|
||||
view[: len(packet)] = packet
|
||||
region.notify()
|
||||
Reference in New Issue
Block a user