193 lines
7.7 KiB
Python
193 lines
7.7 KiB
Python
"""Deterministic registry/universe construction and artifact serialization."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from collections import Counter
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
from .definitions import (
|
|
HISTORICAL_DEFINITIONS,
|
|
HISTORICAL_VARIANTS,
|
|
ImplementationStatus,
|
|
IndicatorDefinition,
|
|
IndicatorVariant,
|
|
Role,
|
|
)
|
|
|
|
HISTORICAL_ARTIFACT_PATH = Path(__file__).with_name("hs22_historical_registry_v1.json")
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class IndicatorUniverse:
|
|
name: str
|
|
variants: tuple[IndicatorVariant, ...]
|
|
namespace: str = "historical"
|
|
|
|
def by_role(self, role: Role | str) -> tuple[IndicatorVariant, ...]:
|
|
return tuple(variant for variant in self.variants if variant.role == Role(role))
|
|
|
|
def contains(self, variant: IndicatorVariant) -> bool:
|
|
return variant in self.variants
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class IndicatorRegistry:
|
|
definitions: tuple[IndicatorDefinition, ...]
|
|
variants: tuple[IndicatorVariant, ...]
|
|
|
|
def definition(self, indicator_id: int) -> IndicatorDefinition | None:
|
|
return next((item for item in self.definitions if item.indicator_id == indicator_id), None)
|
|
|
|
def variant(self, indicator_id: int, period: int, p1: float = 0.0) -> IndicatorVariant | None:
|
|
return next(
|
|
(
|
|
item
|
|
for item in self.variants
|
|
if (item.indicator_id, item.period, item.p1) == (indicator_id, period, p1)
|
|
),
|
|
None,
|
|
)
|
|
|
|
def role_pool(self, role: Role | str) -> tuple[IndicatorVariant, ...]:
|
|
return HS22_HISTORICAL_COMPLETE_V1.by_role(role)
|
|
|
|
|
|
def _all_definitions() -> tuple[IndicatorDefinition, ...]:
|
|
# Historical aliases remain metadata only. Formula execution is unavailable.
|
|
existing = {item.indicator_id: item for item in HISTORICAL_DEFINITIONS}
|
|
aliases = {25: 1, 26: None, 27: None}
|
|
for indicator_id, target in aliases.items():
|
|
base = existing[indicator_id]
|
|
existing[indicator_id] = IndicatorDefinition(
|
|
indicator_id,
|
|
base.name,
|
|
base.role,
|
|
ImplementationStatus.ALIAS,
|
|
target,
|
|
"historical_alias; execution_refused",
|
|
)
|
|
definitions = tuple(sorted(existing.values(), key=lambda item: item.indicator_id))
|
|
assert len(definitions) == 145
|
|
return definitions
|
|
|
|
|
|
HISTORICAL_REGISTRY = IndicatorRegistry(_all_definitions(), HISTORICAL_VARIANTS)
|
|
HS22_HISTORICAL_COMPLETE_V1 = IndicatorUniverse("HS22_HISTORICAL_COMPLETE_V1", HISTORICAL_VARIANTS)
|
|
EXPERIMENTAL_UNIVERSE = IndicatorUniverse("HS22_EXPERIMENTAL_V1", (), "experimental")
|
|
UNREGISTERED_INDICATORS = {
|
|
"MOM_JERK": "unregistered; unknown_dispatch_returns_all_nan; no_fallback",
|
|
}
|
|
|
|
|
|
def cohort001_universe(manifest: object | None = None) -> IndicatorUniverse:
|
|
"""Build the derived universe only from canonical manifest variants.
|
|
|
|
A missing manifest intentionally produces an empty placeholder; it never
|
|
substitutes the broad historical pool.
|
|
"""
|
|
variants: list[IndicatorVariant] = []
|
|
if isinstance(manifest, dict):
|
|
rows = manifest.get("variants", ())
|
|
else:
|
|
rows = ()
|
|
for row in rows:
|
|
if not isinstance(row, dict):
|
|
continue
|
|
try:
|
|
candidate = IndicatorVariant(
|
|
int(row["indicator_id"]),
|
|
int(row["period"]),
|
|
float(row.get("p1", 0.0)),
|
|
Role(row["role"]),
|
|
)
|
|
except (KeyError, TypeError, ValueError):
|
|
continue
|
|
if candidate in HISTORICAL_VARIANTS:
|
|
variants.append(candidate)
|
|
return IndicatorUniverse("HS22_COHORT001_V1", tuple(variants), "derived")
|
|
|
|
|
|
HS22_COHORT001_V1 = cohort001_universe()
|
|
|
|
# This is the complete, role-sensitive Cohort001 execution surface recovered
|
|
# from the frozen oracle. It is product data, not an oracle dependency.
|
|
_HS22_REQUIRED_TRIPLES = (
|
|
(17, 16, 2.0, "signal"), (18, 16, 2.0, "signal"), (18, 22, 2.5, "signal"), (18, 24, 2.5, "signal"),
|
|
(19, 8, 4.0, "signal"), (19, 10, 2.0, "signal"), (19, 10, 4.0, "signal"), (19, 14, 3.0, "signal"),
|
|
(21, 10, 0.0, "trigger"), (21, 14, 0.0, "trigger"), (21, 18, 0.0, "signal"), (21, 22, 0.0, "trigger"),
|
|
(24, 14, 1.0, "signal"), (30, 14, 0.0, "confirm"), (31, 5, 0.0, "confirm"), (31, 7, 0.0, "confirm"),
|
|
(31, 21, 0.0, "confirm"), (33, 16, 0.0, "confirm"), (33, 20, 0.0, "confirm"), (33, 22, 0.0, "confirm"),
|
|
(33, 24, 0.0, "confirm"), (36, 10, 0.0, "confirm"), (36, 18, 0.0, "confirm"), (36, 20, 0.0, "confirm"),
|
|
(39, 20, 0.0, "vol"), (40, 12, 0.0, "vol"), (40, 14, 0.0, "vol"), (41, 12, 0.0, "vol"),
|
|
(41, 16, 0.0, "vol"), (41, 22, 0.0, "vol"), (42, 20, 0.0, "vol"), (42, 44, 0.0, "confirm"),
|
|
(50, 8, 0.0, "trend"), (53, 18, 0.0, "vol"), (53, 30, 0.0, "vol"), (54, 22, 0.0, "trend"),
|
|
(54, 30, 0.0, "trend"), (55, 10, 0.0, "vol"), (57, 10, 0.0, "trend"), (58, 30, 0.0, "trend"),
|
|
(61, 14, 0.0, "trend"), (63, 11, 0.0, "trend"), (70, 18, 0.0, "trend"), (70, 20, 0.0, "trend"),
|
|
(71, 14, 0.0, "trend"), (71, 18, 0.0, "trend"), (72, 18, 0.0, "trend"), (73, 20, 0.0, "trend"),
|
|
(75, 26, 0.0, "trend"), (76, 23, 0.0, "trend"), (77, 1, 0.0, "vol"), (79, 30, 2.0, "trigger"),
|
|
(79, 30, 8.0, "trend"), (79, 40, 8.0, "trigger"), (79, 50, 2.0, "trigger"), (79, 50, 8.0, "trigger"),
|
|
(79, 60, 2.0, "trend"), (79, 60, 2.0, "trigger"), (81, 25, 0.0, "trigger"), (82, 30, 3.0, "trigger"),
|
|
(82, 40, 1.0, "trigger"), (91, 8, 0.0, "signal"), (91, 11, 0.0, "signal"), (92, 5, 0.0, "signal"),
|
|
(92, 17, 0.0, "signal"), (101, 8, 0.0, "trend"), (106, 8, 0.0, "confirm"), (106, 14, 0.0, "confirm"),
|
|
(112, 30, 0.0, "vol"), (113, 30, 0.0, "vol"), (114, 20, 10.0, "vol"), (114, 30, 50.0, "vol"),
|
|
(122, 60, 0.0, "trigger"), (122, 90, 0.0, "trigger"), (122, 150, 0.0, "trigger"), (122, 180, 0.0, "trigger"),
|
|
(122, 210, 0.0, "trigger"), (124, 60, 0.0, "signal"), (129, 22, 2.0, "signal"), (129, 30, 2.0, "signal"),
|
|
(152, 15, 0.0, "vol"),
|
|
)
|
|
|
|
HS22_REQUIRED_V1 = IndicatorUniverse(
|
|
"HS22_COHORT001_REQUIRED_V1",
|
|
tuple(
|
|
IndicatorVariant(
|
|
indicator_id,
|
|
period,
|
|
p1,
|
|
{"trend": Role.TREND, "signal": Role.OSC, "trigger": Role.LEVEL,
|
|
"confirm": Role.OSC, "vol": Role.FILTER}[slot],
|
|
)
|
|
for indicator_id, period, p1, slot in _HS22_REQUIRED_TRIPLES
|
|
),
|
|
"derived",
|
|
)
|
|
|
|
|
|
def historical_artifact() -> dict[str, object]:
|
|
role_counts = Counter(item.role.value for item in HISTORICAL_VARIANTS)
|
|
return {
|
|
"schema_version": 1,
|
|
"registry": "HS22_HISTORICAL_COMPLETE_V1",
|
|
"definition_count": len(HISTORICAL_REGISTRY.definitions),
|
|
"variant_count": len(HISTORICAL_VARIANTS),
|
|
"role_counts": dict(sorted(role_counts.items())),
|
|
"definitions": [
|
|
{
|
|
"indicator_id": item.indicator_id,
|
|
"name": item.name,
|
|
"role": item.role.value if item.role else None,
|
|
"status": item.status.value,
|
|
"alias_of": item.alias_of,
|
|
"behavior": item.behavior,
|
|
}
|
|
for item in HISTORICAL_REGISTRY.definitions
|
|
],
|
|
"variants": [item.asdict() for item in HISTORICAL_VARIANTS],
|
|
"unknown_behavior": "all_nan; no_fallback",
|
|
"unregistered": UNREGISTERED_INDICATORS,
|
|
}
|
|
|
|
|
|
def historical_artifact_bytes() -> bytes:
|
|
return json.dumps(
|
|
historical_artifact(), sort_keys=True, separators=(",", ":"), allow_nan=False
|
|
).encode()
|
|
|
|
|
|
def historical_artifact_digest() -> str:
|
|
return hashlib.sha256(historical_artifact_bytes()).hexdigest()
|
|
|
|
|
|
def write_historical_artifact(path: Path = HISTORICAL_ARTIFACT_PATH) -> None:
|
|
path.write_bytes(historical_artifact_bytes() + b"\n")
|