hjnormey/sentiment-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

malkhut(assets)+uv: system-wide asset directory + UV universe init

Browse Source 
MALKHUT asset directory (malkhut/assets/): normalized canonical symbols,
KNOWN_EXCHANGES aux table (BINANCE/BINGX/BINGX_VST), per-exchange listing
status (TRADING/OFFLINE/UNKNOWN), JSON-backed, built for full-Binance-500
scale. Seeded with BLUE's NG7 feed universe (50 symbols) + live VST
contracts probe: 35 TRADING / 15 OFFLINE on VST (BAND, CELR, COS, CVC,
DENT, FUN, HOT, ICX, TFUEL, TUSD, USDC, WAN, WIN, XTZ, ZIL).
uv_asset_universe.init_asset_universe() = runtime tradable set for the
execution exchange; --onboard runs MALKHUT AssetCompiler for full taxonomy.
12 new tests, mutation-RED verified (status-filter + tradability guard).
This commit is contained in:
Codex
2026-07-11 21:48:05 +02:00
parent aaaf326abf
commit a062507656
7 changed files with 1687 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
prod/clean_arch/violet/uv/test_uv_asset_universe.py Normal file
View File

@@ -0,0 +1,73 @@
"""
Tests for uv_asset_universe — real classification kernel, fake CH/venue seams.
Mutation-sensitivity: flipping contract_is_tradable's status comparison, or
refresh_vst_listings' present/absent branch, goes RED here.
"""
from __future__ import annotations
import pytest
from uv_asset_universe import ( # noqa: I001 — wires MALKHUT_ROOT onto sys.path
contract_is_tradable,
import_blue_universe,
init_asset_universe,
refresh_vst_listings,
)
from malkhut.assets.directory import AssetDirectory, ListingStatus
def _dir(tmp_path):
return AssetDirectory(tmp_path / "assets.json")
CONTRACTS = [
{"symbol": "ETH-USDT", "status": 1, "apiStateOpen": "true"},
{"symbol": "TRX-USDT", "status": 1, "apiStateOpen": "true"},
{"symbol": "OLD-USDT", "status": 25, "apiStateOpen": "true"}, # delisted
{"symbol": "SHUT-USDT", "status": 1, "apiStateOpen": "false"}, # API entry closed
# BAND-USDT absent entirely (observed on VST 2026-07-11)
]
def test_contract_is_tradable():
assert contract_is_tradable(CONTRACTS[0]) is True
assert contract_is_tradable(CONTRACTS[2]) is False # status 25
assert contract_is_tradable(CONTRACTS[3]) is False # apiStateOpen false
def test_seed_and_refresh_marks_offline_and_absent(tmp_path):
d = _dir(tmp_path)
import_blue_universe(d, ["ETHUSDT", "TRXUSDT", "BANDUSDT", "OLDUSDT", "SHUTUSDT"])
assert d.symbols_for_exchange("BINANCE") == [
"BANDUSDT", "ETHUSDT", "OLDUSDT", "SHUTUSDT", "TRXUSDT"]
trading, offline = refresh_vst_listings(d, CONTRACTS)
assert (trading, offline) == (2, 3)
assert d.symbols_for_exchange("BINGX_VST") == ["ETHUSDT", "TRXUSDT"]
assert d.symbols_for_exchange("BINGX_VST", status=ListingStatus.OFFLINE) == [
"BANDUSDT", "OLDUSDT", "SHUTUSDT"]
# venue spelling preserved for tradable symbols
assert d.venue_symbol("ETHUSDT", "BINGX_VST") == "ETH-USDT"
def test_init_asset_universe_is_the_tradable_frozenset(tmp_path):
d = _dir(tmp_path)
import_blue_universe(d, ["ETHUSDT", "BANDUSDT"])
refresh_vst_listings(d, CONTRACTS)
uni = init_asset_universe("BINGX_VST", d)
assert uni == frozenset({"ETHUSDT"})
assert isinstance(uni, frozenset)
# the Binance view is unaffected by the VST stamp
assert init_asset_universe("BINANCE", d) == frozenset({"ETHUSDT", "BANDUSDT"})
def test_refresh_is_repeatable_and_recovers(tmp_path):
"""A symbol OFFLINE once must flip back to TRADING when the venue relists."""
d = _dir(tmp_path)
import_blue_universe(d, ["BANDUSDT"])
refresh_vst_listings(d, CONTRACTS) # BAND absent -> OFFLINE
assert d.symbols_for_exchange("BINGX_VST") == []
relisted = CONTRACTS + [{"symbol": "BAND-USDT", "status": 1, "apiStateOpen": "true"}]
refresh_vst_listings(d, relisted)
assert d.symbols_for_exchange("BINGX_VST") == ["BANDUSDT"]

203
prod/clean_arch/violet/uv/uv_asset_universe.py Normal file
View File

@@ -0,0 +1,203 @@
"""
UV asset-universe init — MALKHUT asset directory as the single source of truth.
Operator directive 2026-07-11: the MALKHUT asset store (malkhut/assets/) is
the system-wide known-asset universe. UV/VIOLET initialize their tradable
set from it against the CURRENT execution exchange, so a dead venue symbol
(e.g. BAND-USDT offline on VST) can never reach the kernel.
Flow:
1. import_blue_universe() — seed canonical symbols from the DOLPHIN NG7
scan feed (BINANCE listings; that feed IS the
Binance universe BLUE trades from).
2. refresh_vst_listings() — probe the execution venue's contracts endpoint
and stamp BINGX_VST TRADING/OFFLINE per symbol.
3. init_asset_universe() — the runtime call: returns the frozen tradable
set for the execution exchange. The promotion
bridge / seam refuses ENTER intents outside it.
Built for the full-Binance (~500+) universe north-star; today's feed carries
50 symbols — the store scales, the feed is the bottleneck.
CLI:
uv_asset_universe.py --seed-from-scans --refresh-vst --show
"""
from __future__ import annotations
import argparse
import json
import os
import sys
import urllib.request
from datetime import datetime, timezone
from typing import Any, Iterable
MALKHUT_ROOT = os.environ.get("MALKHUT_ROOT", "/mnt/dolphinng5_predict/MALKHUT")
if MALKHUT_ROOT not in sys.path:
sys.path.insert(0, MALKHUT_ROOT)
from malkhut.assets.directory import ( # noqa: E402
AssetDirectory,
ListingStatus,
normalize_symbol,
)
from uv_anomaly_sentinel import CHQuerier, CH_DB_UV, VST_BASE_URL # noqa: E402
FEED_SOURCE = "dolphin_ng7_scan_feed"
PROBE_SOURCE = "vst_contracts_probe"
def _now_iso() -> str:
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
# ── step 1: seed from the scan feed (the BLUE/Binance universe) ────────────
def blue_universe_from_scans(ch: CHQuerier | None = None) -> list[str]:
ch = ch or CHQuerier()
rows = ch.query(
f"SELECT DISTINCT arrayJoin(JSONExtract(assets,'Array(String)')) AS a"
f" FROM {CH_DB_UV}.prime_scans ORDER BY a FORMAT JSONEachRow"
)
return [r["a"] for r in rows]
def import_blue_universe(directory: AssetDirectory, symbols: Iterable[str]) -> int:
return directory.import_symbols(
[normalize_symbol(s) for s in symbols],
"BINANCE",
status=ListingStatus.TRADING,
checked_at=_now_iso(),
source=FEED_SOURCE,
)
# ── step 2: stamp execution-venue listings from the contracts probe ───────
def fetch_vst_contracts(base_url: str = VST_BASE_URL, timeout_s: int = 15) -> list[dict[str, Any]]:
req = urllib.request.Request(f"{base_url}/openApi/swap/v2/quote/contracts")
body = urllib.request.urlopen(req, timeout=timeout_s).read().decode("utf-8")
parsed = json.loads(body)
return parsed.get("data") or []
def contract_is_tradable(contract: dict[str, Any]) -> bool:
"""BingX contracts row -> tradable? status 1 = online; apiStateOpen gates API entry."""
return (
int(contract.get("status") or 0) == 1
and str(contract.get("apiStateOpen", "true")).lower() == "true"
)
def refresh_vst_listings(
directory: AssetDirectory, contracts: list[dict[str, Any]]
) -> tuple[int, int]:
"""Stamp BINGX_VST status for every symbol already in the directory.
Present + tradable -> TRADING; absent or non-tradable -> OFFLINE.
Returns (trading, offline) counts over the directory.
"""
now = _now_iso()
tradable: dict[str, str] = {} # canonical -> venue symbol
for c in contracts:
vsym = str(c.get("symbol") or "")
if vsym and contract_is_tradable(c):
tradable[normalize_symbol(vsym)] = vsym
n_trading = n_offline = 0
for sym in list(directory.records):
if sym in tradable:
directory.set_listing(sym, "BINGX_VST", venue_symbol=tradable[sym],
status=ListingStatus.TRADING,
checked_at=now, source=PROBE_SOURCE)
n_trading += 1
else:
directory.set_listing(sym, "BINGX_VST",
status=ListingStatus.OFFLINE,
checked_at=now, source=PROBE_SOURCE)
n_offline += 1
return n_trading, n_offline
# ── step 2b: full-taxonomy onboarding via MALKHUT's AssetCompiler ──────────
def onboard_profiles(directory: AssetDirectory, *, compiler: Any = None,
out_path: str = "") -> tuple[int, int]:
"""Run MALKHUT's asset onboarder over every directory symbol lacking a
profile_ref; persist compiled taxonomy JSON beside the directory.
Returns (compiled, failed). Failures are noted on the record, not fatal —
the directory stays authoritative for existence/listing even when the
taxonomy fetch fails.
"""
from dataclasses import asdict
if compiler is None:
from malkhut.training.asset_compiler import AssetCompiler
compiler = AssetCompiler()
path = out_path or str(directory.path.parent / "compiled_profiles.json")
try:
with open(path, encoding="utf-8") as fh:
store = json.load(fh)
except (OSError, json.JSONDecodeError):
store = {}
done = failed = 0
for sym in sorted(directory.records):
rec = directory.records[sym]
if rec.profile_ref and sym in store:
continue
result = compiler.compile_and_register(sym)
if result.asset_profile is None:
failed += 1
rec.notes = (rec.notes + " | " if rec.notes else "") + \
f"onboard failed {_now_iso()}: {'; '.join(result.warnings)[:120]}"
continue
entry = {"profile": asdict(result.asset_profile), "_compiled_at": _now_iso()}
if result.asset_behavior is not None:
entry["behavior"] = asdict(result.asset_behavior)
store[sym] = json.loads(json.dumps(entry, default=str))
rec.profile_ref = sym
done += 1
with open(path, "w", encoding="utf-8") as fh:
json.dump(store, fh, indent=1, sort_keys=True, default=str)
return done, failed
# ── step 3: the runtime call ───────────────────────────────────────────────
def init_asset_universe(execution_exchange: str = "BINGX_VST",
directory: AssetDirectory | None = None) -> frozenset[str]:
"""Tradable canonical symbols for the execution exchange in use."""
directory = directory or AssetDirectory()
return frozenset(directory.symbols_for_exchange(execution_exchange))
def main(argv: list[str] | None = None) -> int:
p = argparse.ArgumentParser(description="UV asset-universe init (MALKHUT store)")
p.add_argument("--seed-from-scans", action="store_true")
p.add_argument("--refresh-vst", action="store_true")
p.add_argument("--onboard", action="store_true",
help="full-taxonomy compile via MALKHUT AssetCompiler (rate-limited)")
p.add_argument("--show", action="store_true")
a = p.parse_args(argv)
d = AssetDirectory()
if a.seed_from_scans:
n = import_blue_universe(d, blue_universe_from_scans())
d.save()
print(f"seeded {n} BINANCE listings from {FEED_SOURCE} -> {d.path}")
if a.refresh_vst:
t, o = refresh_vst_listings(d, fetch_vst_contracts())
d.save()
print(f"BINGX_VST refresh: {t} TRADING, {o} OFFLINE")
if o:
print("OFFLINE:", ", ".join(d.symbols_for_exchange(
"BINGX_VST", status=ListingStatus.OFFLINE)))
if a.onboard:
done, failed = onboard_profiles(d)
d.save()
print(f"onboarded taxonomy: {done} compiled, {failed} failed")
if a.show:
uni = init_asset_universe("BINGX_VST", d)
print(f"directory: {len(d)} assets @ {d.path}")
print(f"BINGX_VST tradable universe ({len(uni)}):", ", ".join(sorted(uni)))
return 0
if __name__ == "__main__":
sys.exit(main())