tradingSystem/app/core/etf_contract/consumer.py

458 lines
27 KiB
Python

"""Dependency-free downstream contract validation; performs no business actions.
Use the exact immutable snapshot text fetched from the snapshot instance.
Persist sequence/revision watermarks with your business update before XACK.
"""
from __future__ import annotations
from datetime import datetime, timedelta
import hashlib
import json
import math
import re
from typing import Mapping
from .signals import DIRECTIONS, KNOWN_DIRECTIONS, aware_time, lease_until, validate_snapshot
from .timing import LEGACY_POLICY, admission_until, policy_version
ACTIVE_STATES = frozenset({"OPEN", "CONTINUE"})
TERMINAL_STATES = frozenset({"RESOLVED", "REVERSED", "EXPIRED", "CLOSED", "RETRACTED"})
OBSERVATION_NAMESPACE = "mtf:etf:observation:v1"
OBSERVATION_CONTRACT_VERSION = "etf-observation-1.0"
OBSERVATION_FIELDS = ("observation_contract_version", "purpose", "model_status",
"calibration_status", "threshold_version", "review_status", "calibration_review",
"release_id", "effective_from", "trade_instruction")
OBSERVATION_EVENT_FIELDS = ("publication_mode", "observation_contract_version", "purpose", "model_status",
"calibration_status", "threshold_version", "release_id", "trade_instruction")
class ConsumerContractError(ValueError):
"""Invalid or incomplete transport data; do not acknowledge as a valid signal."""
def _pairs(values):
result = {}
for key, value in values:
if key in result:
raise ConsumerContractError("DUPLICATE_JSON_FIELD")
result[key] = value
return result
def _json(value):
if not isinstance(value, (str, bytes)):
raise ConsumerContractError("JSON_TEXT_REQUIRED")
def invalid_constant(value):
raise ConsumerContractError("NONFINITE_JSON_NUMBER")
try:
result = json.loads(value, object_pairs_hook=_pairs, parse_constant=invalid_constant)
except (ValueError, UnicodeError) as exc:
if isinstance(exc, ConsumerContractError):
raise
raise ConsumerContractError("INVALID_JSON") from None
if not isinstance(result, dict):
raise ConsumerContractError("JSON_OBJECT_REQUIRED")
try:
json.dumps(result, allow_nan=False)
except (ValueError, TypeError):
raise ConsumerContractError("NONFINITE_JSON_NUMBER") from None
return result
def decode_stream_entry(fields: Mapping) -> dict:
"""Decode the producer's single `data` field, with str or bytes clients.
Subject identity must be inside the JSON. There is no fallback to outer
ts_code or another field, avoiding ambiguous producer/consumer contracts.
"""
if not isinstance(fields, Mapping):
raise ConsumerContractError("STREAM_FIELDS_REQUIRED")
keys = list(fields)
if keys not in (["data"], [b"data"]):
raise ConsumerContractError("SINGLE_DATA_ENVELOPE_REQUIRED")
return _json(fields[keys[0]])
def _require(condition, reason):
if not condition:
raise ConsumerContractError(reason)
def _time(value):
try:
return aware_time(value)
except (ValueError, TypeError):
raise ConsumerContractError("AWARE_TIMESTAMP_REQUIRED") from None
def validate_publication_contract(snapshot: Mapping, namespace: str, manifest: Mapping | None = None) -> dict:
"""Validate the independent observation contract without approving a model.
Legacy shadow/live publications retain their existing policy. Observation
metadata is committed in both snapshot and manifest, never inferred from a
consumer option or from the fact that a publication is current.
"""
observation = namespace == OBSERVATION_NAMESPACE
if not observation:
_require(snapshot.get("publication_mode") != "observation", "OBSERVATION_NAMESPACE_MISMATCH")
return {}
_require(snapshot.get("publication_mode") == "observation", "PUBLICATION_MODE_MISMATCH")
_require(snapshot.get("trade_instruction") is False, "OBSERVATION_IS_NOT_TRADE_INSTRUCTION")
_require(isinstance(snapshot.get("release_id"), str) and bool(snapshot["release_id"].strip()),
"INVALID_OBSERVATION_RELEASE_ID")
_require(_time(snapshot.get("window_end")) >= _time(snapshot.get("effective_from")),
"WINDOW_PREDATES_OBSERVATION_RELEASE")
for key, expected in (("observation_contract_version", OBSERVATION_CONTRACT_VERSION),
("purpose", "MARKET_OBSERVATION"), ("model_status", "uncalibrated"),
("calibration_status", "PROVISIONAL")):
_require(snapshot.get(key) == expected, "INVALID_OBSERVATION_" + key.upper())
threshold = snapshot.get("threshold_version")
_require(isinstance(threshold, str) and bool(threshold.strip()), "INVALID_OBSERVATION_THRESHOLD_VERSION")
review = snapshot.get("calibration_review")
_require(isinstance(review, dict), "INVALID_CALIBRATION_REVIEW")
_require(type(review.get("sample_count")) is int and review["sample_count"] >= 0
and type(review.get("target_days")) is int and review["target_days"] > 0
and type(review.get("eligible_cohort_size")) is int and review["eligible_cohort_size"] >= 0
and isinstance(review.get("by_subject"), dict), "INVALID_CALIBRATION_SAMPLE_COUNT")
_require(all(isinstance(k, str) and type(v) is int and v >= 0 for k, v in review["by_subject"].items())
and review["sample_count"] == min(review["by_subject"].values(), default=0),
"INVALID_CALIBRATION_SAMPLE_COUNT")
expected_review = "ACCUMULATING" if review["sample_count"] < review["target_days"] else "REVIEW_DUE"
_require(snapshot.get("review_status") == expected_review, "INVALID_OBSERVATION_REVIEW_STATUS")
for subject in snapshot.get("subjects", []):
_require(isinstance(subject, Mapping), "INVALID_OBSERVATION_SUBJECT")
observed = subject.get("observation")
if observed is not None:
_require(isinstance(observed, Mapping) and observed.get("amount_unit") == "CNY"
and observed.get("flow_basis") == "TURNOVER_NOT_NET_FLOW", "INVALID_OBSERVED_AMOUNT_BASIS")
for value_key, status_key, missing in (("amount", "window_amount_status", "MISSING"),
("cumulative_amount", "cumulative_amount_status", "INCOMPLETE_PREFIX")):
amount = observed.get(value_key)
_require(amount is None or (type(amount) in (int, float) and math.isfinite(amount) and amount >= 0),
"INVALID_OBSERVED_AMOUNT")
_require(observed.get(status_key) == ("OK" if amount is not None else missing),
"OBSERVED_AMOUNT_STATUS_MISMATCH")
if value_key + "_yuan" in observed:
_require(observed[value_key + "_yuan"] == amount, "OBSERVED_AMOUNT_ALIAS_MISMATCH")
for scope in ("WINDOW_15M", "SESSION_CUM", "EOD"):
block = subject.get(scope)
if block is None:
continue
_require(isinstance(block, Mapping) and isinstance(block.get("metrics"), dict),
"INVALID_OBSERVATION_SCOPE")
metrics = block["metrics"]
_require(metrics.get("threshold_version") == threshold, "OBSERVATION_THRESHOLD_MISMATCH")
direction = block.get("direction")
_require(isinstance(direction, str) and direction in DIRECTIONS, "UNSUPPORTED_DIRECTION")
_require(block.get("direction_status") == ("UNAVAILABLE" if direction == "UNKNOWN" else "OK"),
"INVALID_DIRECTION_STATUS")
if direction == "UNKNOWN":
balance_key = "direction_balance" if scope == "WINDOW_15M" else "cumulative_direction_balance"
_require(all(metrics.get(key) is None for key in
(balance_key, "pressure_score", "high_buy_pressure_score",
"high_sell_pressure_score", "low_buy_pressure_score", "low_sell_pressure_score")),
"UNKNOWN_DIRECTION_HAS_PRESSURE")
fields = {key: snapshot[key] for key in OBSERVATION_FIELDS}
if manifest is not None:
_require(manifest.get("publication_mode") == "observation", "PUBLICATION_MODE_MISMATCH")
_require(all(json.dumps(manifest.get(key), sort_keys=True, allow_nan=False)
== json.dumps(value, sort_keys=True, allow_nan=False) for key, value in fields.items()),
"OBSERVATION_MANIFEST_MISMATCH")
return fields
def validate_observation_snapshot(manifest: Mapping, snapshot: str | bytes, now: datetime,
*, last_revision: int = -1) -> dict:
"""Read numerical observations even when no anomaly event was emitted.
This validates a READY round and returns per-subject/per-scope permissions.
``quality_eligible`` describes the recorded facts; ``observation_eligible``
additionally requires an unexpired, timely LIVE publication. Neither grants
trading authority or claims the reference thresholds have been calibrated.
Keep revision watermarks per namespace and round, never globally per day.
"""
_require(isinstance(manifest, Mapping), "OBJECTS_REQUIRED")
_require(type(last_revision) is int and last_revision >= -1, "INVALID_CONSUMER_WATERMARK")
snap = _json(snapshot)
for item in (manifest, snap):
_require(type(item.get("schema_version")) is int and item["schema_version"] == 1,
"UNSUPPORTED_SCHEMA_VERSION")
_require(type(item.get("revision")) is int and item["revision"] >= 0, "INVALID_REVISION")
_require(manifest.get("status") == "READY", "ROUND_NOT_READY")
raw = snapshot.encode("utf-8") if isinstance(snapshot, str) else snapshot
_require(hashlib.sha256(raw).hexdigest() == manifest.get("snapshot_sha256"), "SNAPSHOT_HASH_MISMATCH")
try:
end = validate_snapshot(snap)
version = policy_version(snap)
manifest_version = policy_version(manifest)
except (ValueError, TypeError, KeyError):
raise ConsumerContractError("INVALID_SNAPSHOT") from None
_require(manifest_version == version, "ROUND_TIMING_POLICY_MISMATCH")
for key in ("round_id", "trade_date", "revision"):
_require(manifest.get(key) == snap[key], "ROUND_IDENTITY_MISMATCH")
suffix = f"{snap['trade_date']}:{snap['round_id']}:r{snap['revision']}"
_require(manifest.get("manifest_key") == f"{OBSERVATION_NAMESPACE}:manifest:{suffix}"
and manifest.get("snapshot_key") == f"{OBSERVATION_NAMESPACE}:snapshot:{suffix}",
"NAMESPACE_OR_KEY_MISMATCH")
metadata = validate_publication_contract(snap, OBSERVATION_NAMESPACE, manifest)
_require(_time(manifest.get("window_end")) == end, "WINDOW_END_MISMATCH")
published = _time(manifest.get("published_at"))
_require(_time(snap.get("published_at")) == published, "PUBLICATION_TIME_MISMATCH")
_require(published >= end, "PUBLICATION_PRECEDES_WINDOW")
expiry = lease_until(end, version)
_require(_time(manifest.get("valid_until")) == expiry, "INVALID_MANIFEST_LEASE")
_require(_time(manifest.get("admission_until")) == admission_until(end, version), "INVALID_MANIFEST_ADMISSION")
_require(manifest.get("mode") == snap.get("mode"), "EVALUATION_MODE_MISMATCH")
_require(type(manifest.get("live_eligible")) is bool, "INVALID_LIVE_ELIGIBILITY")
_require(type(manifest.get("session_closed")) is bool and type(snap.get("session_closed")) is bool
and manifest["session_closed"] == snap["session_closed"] == (end.hour == 15),
"INVALID_SESSION_CLOSED")
current = _time(now)
reason = ("OLD_ROUND_REVISION" if snap["revision"] < last_revision else
"FUTURE_EVENT" if published > current or end > current else
"REPLAY_NOT_ACTIONABLE" if snap.get("mode") != "LIVE" else
"SESSION_CLOSED" if snap["session_closed"] else
"ADMISSION_DEADLINE_PASSED" if published >= admission_until(end, version) else
"LEASE_EXPIRED" if current >= expiry else
"ROUND_NOT_LIVE_ELIGIBLE" if not manifest["live_eligible"] else
"INSUFFICIENT_DATA" if snap.get("data_status") != "OK" else None)
scopes, identities = [], set()
for subject in snap["subjects"]:
identity = (subject.get("subject_type"), subject.get("subject_id"))
_require(identity[0] in {"ETF", "INDEX", "MARKET"}
and isinstance(identity[1], str) and bool(identity[1]), "INVALID_OBSERVATION_SUBJECT")
_require(identity not in identities, "DUPLICATE_OBSERVATION_SUBJECT")
identities.add(identity)
for scope in ("WINDOW_15M", "SESSION_CUM", "EOD"):
block = subject.get(scope)
if block is None:
continue
amount_key = "amount" if scope == "WINDOW_15M" else "cumulative_amount"
facts = subject.get("observation")
value = (facts if isinstance(facts, Mapping) else block["metrics"]).get(amount_key)
amount_valid = type(value) in (int, float) and math.isfinite(value) and value >= 0
model_quality = subject.get("data_status") == "OK" and block.get("data_status") == "OK"
raw_quality = (isinstance(facts, Mapping) and facts.get("amount_unit") == "CNY"
and facts.get("flow_basis") == "TURNOVER_NOT_NET_FLOW"
and facts.get("window_amount_status" if scope == "WINDOW_15M" else "cumulative_amount_status") == "OK"
and subject.get("data_status") in {"OK", "INSUFFICIENT_HISTORY"}
and block.get("data_status") in {"OK", "INSUFFICIENT_HISTORY"})
quality = amount_valid and (model_quality or raw_quality)
direction_available = model_quality and amount_valid and block["direction_status"] == "OK"
eligible = reason is None and quality
scopes.append({"subject_type": identity[0], "subject_id": identity[1], "scope": scope,
"data_status": block.get("data_status"), "quality_eligible": quality,
"model_scoring_available": model_quality,
"observation_eligible": eligible, "amount_available": quality,
"direction_available": direction_available,
"usable_fields": (["turnover"] + (["price_volume_direction"] if direction_available else []))
if eligible else []})
available = reason is None and any(item["observation_eligible"] for item in scopes)
return dict(metadata, contract_valid=True, namespace=OBSERVATION_NAMESPACE,
round_id=snap["round_id"], revision=snap["revision"],
published_at=published.isoformat(), valid_until=expiry.isoformat(),
observation_eligible=available, trade_instruction=False,
reason_code=reason or ("CURRENT_OBSERVATION" if available else "NO_USABLE_SCOPE"),
scopes=scopes, snapshot=snap)
def validate_observation_event_metadata(event: Mapping, snapshot: Mapping):
_require(all(type(event.get(key)) is type(snapshot.get(key)) and event.get(key) == snapshot.get(key)
for key in OBSERVATION_EVENT_FIELDS), "OBSERVATION_EVENT_METADATA_MISMATCH")
def read_committed_observation(snapshot_client, event_client, manifest_key: str, *, clock=None,
last_revision: int = -1) -> dict:
"""Bounded read from the two Redis instances; no writes, API or task calls.
Fetch READY from event Redis, then the exact immutable snapshot from snapshot
Redis. The caller may supply a clock callable; it is evaluated after reads
so network delay cannot turn an expired snapshot into a current observation.
A notification or latest pointer alone is never proof of commitment.
"""
pattern = re.escape(OBSERVATION_NAMESPACE) + r":manifest:\d{4}-\d{2}-\d{2}:[A-Za-z0-9_-]+:r\d+"
_require(isinstance(manifest_key, str) and re.fullmatch(pattern, manifest_key) is not None,
"INVALID_OBSERVATION_MANIFEST_KEY")
def bounded(client, key, maximum):
size = client.strlen(key)
_require(type(size) is int and 0 < size <= maximum, "MISSING_OR_OVERSIZED_COMMITTED_DATA")
raw = client.getrange(key, 0, maximum - 1)
_require(isinstance(raw, (str, bytes)), "JSON_TEXT_REQUIRED")
_require(len(raw.encode("utf-8") if isinstance(raw, str) else raw) == size,
"COMMITTED_DATA_CHANGED_DURING_READ")
return raw
encoded = bounded(event_client, manifest_key, 262_144)
manifest = _json(encoded)
_require(manifest.get("status") == "READY", "ROUND_NOT_READY")
_require(manifest.get("manifest_key") == manifest_key, "NAMESPACE_OR_KEY_MISMATCH")
expected_key = manifest_key.replace(":manifest:", ":snapshot:", 1)
_require(manifest.get("snapshot_key") == expected_key, "NAMESPACE_OR_KEY_MISMATCH")
raw = bounded(snapshot_client, expected_key, 16_777_216)
_require(bounded(event_client, manifest_key, 262_144) == encoded, "COMMITTED_DATA_CHANGED_DURING_READ")
result = validate_observation_snapshot(manifest, raw, clock() if clock else datetime.now().astimezone(),
last_revision=last_revision)
return dict(result, manifest=manifest)
def validate_envelope(event: Mapping, manifest: Mapping, snapshot: str | bytes,
now: datetime, *, allow_shadow: bool = False,
last_event_seq: int = 0, last_revision: int = -1) -> dict:
"""Validate a committed event and return an eligibility decision.
last_event_seq is the durable watermark for this event_id; last_revision is
the durable watermark for this round_id. A sequence gap is exposed for
reconciliation; it does not make a later terminal state unsafe to apply.
Structural failures raise ConsumerContractError. Valid but stale/duplicate
or shadow events return apply=False with an explicit reason code.
"""
_require(isinstance(event, Mapping) and isinstance(manifest, Mapping), "OBJECTS_REQUIRED")
_require(type(last_event_seq) is int and last_event_seq >= 0
and type(last_revision) is int and last_revision >= -1, "INVALID_CONSUMER_WATERMARK")
_require(type(allow_shadow) is bool, "INVALID_SHADOW_POLICY")
snap = _json(snapshot)
for item in (event, manifest, snap):
_require(type(item.get("schema_version")) is int and item["schema_version"] == 1,
"UNSUPPORTED_SCHEMA_VERSION")
_require(type(item.get("revision")) is int and item["revision"] >= 0, "INVALID_REVISION")
try:
json.dumps(dict(event), allow_nan=False)
except (ValueError, TypeError):
raise ConsumerContractError("EVENT_MUST_BE_FINITE_JSON") from None
_require(manifest.get("status") == "READY", "ROUND_NOT_READY")
raw = snapshot.encode("utf-8") if isinstance(snapshot, str) else snapshot
_require(hashlib.sha256(raw).hexdigest() == manifest.get("snapshot_sha256"), "SNAPSHOT_HASH_MISMATCH")
try:
end = validate_snapshot(dict(snap))
except (ValueError, TypeError, KeyError):
raise ConsumerContractError("INVALID_SNAPSHOT") from None
try:
snapshot_policy = policy_version(snap)
manifest_policy = policy_version(manifest)
event_policy = policy_version(event)
except ValueError:
raise ConsumerContractError("UNSUPPORTED_TIMING_POLICY") from None
_require(manifest_policy == snapshot_policy, "ROUND_TIMING_POLICY_MISMATCH")
for name in ("event_id", "round_id", "subject_id", "model_version", "trade_date"):
_require(isinstance(event.get(name), str) and bool(event[name]), "MISSING_EVENT_IDENTITY")
_require(event.get("producer_id") == "mtf_etf", "UNKNOWN_PRODUCER")
_require(event.get("flow_basis") == "price_volume_proxy", "UNSUPPORTED_FLOW_BASIS")
_require(isinstance(event.get("subject_type"), str)
and event["subject_type"] in {"ETF", "INDEX", "MARKET"}, "UNSUPPORTED_SUBJECT_TYPE")
_require(isinstance(event.get("scope"), str)
and event["scope"] in {"WINDOW_15M", "SESSION_CUM"}, "UNSUPPORTED_EVENT_SCOPE")
_require(isinstance(event.get("direction"), str)
and event["direction"] in DIRECTIONS, "UNSUPPORTED_DIRECTION")
direction_status = "UNAVAILABLE" if event["direction"] == "UNKNOWN" else "OK"
# Previous known-direction v1 events did not carry this additive field.
# UNKNOWN is new and must state explicitly that direction is unavailable.
_require(event.get("direction_status", "OK") == direction_status, "INVALID_DIRECTION_STATUS")
last_known = event.get("last_known_direction", event["direction"] if event["direction"] in KNOWN_DIRECTIONS else None)
_require(last_known is None or (isinstance(last_known, str) and last_known in KNOWN_DIRECTIONS),
"INVALID_LAST_KNOWN_DIRECTION")
if event["direction"] in KNOWN_DIRECTIONS:
_require(last_known == event["direction"], "LAST_KNOWN_DIRECTION_MISMATCH")
_require(type(event.get("severity")) is int and 0 <= event["severity"] <= 3, "INVALID_SEVERITY")
_require(type(event.get("event_seq")) is int and event["event_seq"] >= 1, "INVALID_EVENT_SEQUENCE")
_require(type(event.get("revision")) is int and event["revision"] >= 0, "INVALID_REVISION")
_require(isinstance(event.get("metrics"), dict), "METRICS_OBJECT_REQUIRED")
_require(isinstance(event.get("reason_codes"), list)
and all(isinstance(value, str) for value in event["reason_codes"]), "INVALID_REASON_CODES")
state = event.get("event_state")
_require(isinstance(state, str) and state in ACTIVE_STATES | TERMINAL_STATES, "UNSUPPORTED_EVENT_STATE")
if state in ACTIVE_STATES:
_require(event_policy == snapshot_policy, "ACTIVE_TIMING_POLICY_MISMATCH")
for name in ("round_id", "revision", "trade_date"):
_require(event.get(name) == manifest.get(name) == snap.get(name), "ROUND_IDENTITY_MISMATCH")
_require(_time(event.get("window_end")) == _time(manifest.get("window_end")) == end,
"WINDOW_END_MISMATCH")
_require(_time(event.get("window_start")) == end - timedelta(minutes=15), "WINDOW_START_MISMATCH")
published = _time(event.get("published_at"))
_require(published == _time(manifest.get("published_at")), "PUBLICATION_TIME_MISMATCH")
_require(published >= end, "PUBLICATION_PRECEDES_WINDOW")
valid_until = _time(event.get("valid_until"))
opened = _time(event.get("opened_at"))
_require(opened.date() == end.date() and opened <= end and opened <= valid_until <= lease_until(end, event_policy),
"INVALID_EVENT_LEASE")
_require(_time(manifest.get("valid_until")) == lease_until(end, snapshot_policy), "INVALID_MANIFEST_LEASE")
if manifest_policy != LEGACY_POLICY or "admission_until" in manifest:
_require(_time(manifest.get("admission_until")) == admission_until(end, snapshot_policy),
"INVALID_MANIFEST_ADMISSION")
_require(type(manifest.get("live_eligible")) is bool, "INVALID_LIVE_ELIGIBILITY")
manifest_key = manifest.get("manifest_key")
_require(isinstance(manifest_key, str) and ":manifest:" in manifest_key, "INVALID_MANIFEST_KEY")
namespace = manifest_key.split(":manifest:", 1)[0]
_require(namespace in {"mtf:etf:shadow:v1", "mtf:etf:live:v1", OBSERVATION_NAMESPACE}, "UNSUPPORTED_NAMESPACE")
suffix = f"{event['trade_date']}:{event['round_id']}:r{event['revision']}"
_require(manifest_key == f"{namespace}:manifest:{suffix}"
and manifest.get("snapshot_key") == f"{namespace}:snapshot:{suffix}", "NAMESPACE_OR_KEY_MISMATCH")
deployment_mode = namespace.split(":")[2]
_require(snap.get("publication_mode", deployment_mode) == deployment_mode, "PUBLICATION_MODE_MISMATCH")
_require(manifest.get("mode") == snap.get("mode", "LIVE"), "EVALUATION_MODE_MISMATCH")
metadata = validate_publication_contract(snap, namespace, manifest)
if deployment_mode == "observation":
validate_observation_event_metadata(event, snap)
observation = (validate_observation_snapshot(manifest, snapshot, now, last_revision=last_revision)
if deployment_mode == "observation" else None)
result = {**metadata, "apply": False, "active_eligible": False, "terminal": state in TERMINAL_STATES,
"reason_code": None, "namespace": namespace, "event_id": event["event_id"],
"event_seq": event["event_seq"], "round_id": event["round_id"],
"revision": event["revision"], "event_state": state,
"direction": event["direction"], "direction_status": direction_status,
"direction_available": direction_status == "OK",
"last_known_direction": last_known,
"timing_policy_version": event_policy,
"sequence_gap": event["event_seq"] > last_event_seq + 1}
reason = None
current = _time(now)
if deployment_mode == "shadow" and not allow_shadow:
reason = "SHADOW_NAMESPACE_REJECTED"
elif event["event_seq"] <= last_event_seq:
reason = "DUPLICATE_OR_OLD_SEQUENCE"
elif event["revision"] < last_revision:
reason = "OLD_ROUND_REVISION"
elif published > current or end > current:
reason = "FUTURE_EVENT"
elif manifest.get("mode") != "LIVE":
reason = "REPLAY_NOT_ACTIONABLE"
elif state in TERMINAL_STATES:
# Closing/retracting a previously applied event remains useful after
# its lease expires and when an EOD manifest has live_eligible=False.
result["apply"] = True
reason = "TERMINAL_EVENT"
elif published >= admission_until(end, event_policy):
reason = "ADMISSION_DEADLINE_PASSED"
elif current >= valid_until:
reason = "LEASE_EXPIRED"
elif not manifest["live_eligible"]:
reason = "ROUND_NOT_LIVE_ELIGIBLE"
elif deployment_mode == "live" and snap.get("model_status") != "calibrated":
reason = "MODEL_NOT_CALIBRATED"
elif observation is not None and not observation["observation_eligible"]:
reason = observation["reason_code"]
else:
_require(event["model_version"] == snap["model_version"], "ACTIVE_MODEL_MISMATCH")
subjects = [item for item in snap["subjects"]
if item.get("subject_type") == event["subject_type"]
and item.get("subject_id") == event["subject_id"]]
_require(len(subjects) == 1, "ACTIVE_SUBJECT_MISSING_OR_DUPLICATE")
evaluation = subjects[0].get(event["scope"], {})
_require(subjects[0].get("data_status") == "OK"
and evaluation.get("data_status", "OK") == "OK"
and evaluation.get("anomaly") is True, "ACTIVE_EVIDENCE_MISSING")
_require(event["direction"] == evaluation.get("direction", "UNKNOWN")
and direction_status == evaluation.get("direction_status", direction_status)
and event["severity"] == evaluation.get("severity", 0)
and event["metrics"] == evaluation.get("metrics", {}), "ACTIVE_EVIDENCE_MISMATCH")
result.update(apply=True, active_eligible=True)
reason = "ACTIVE_EVENT"
result["reason_code"] = reason
if observation is not None:
result.update(observation_eligible=result["active_eligible"], trade_instruction=False,
usable_fields=(["turnover"] + (["price_volume_direction"] if direction_status == "OK" else []))
if result["active_eligible"] else [])
return result