Files
Jyotisha/scripts/rectification_purpose_gate/scope.py
T

334 lines
16 KiB
Python

"""Build a server-owned purpose binding and collect native calculation receipts."""
from __future__ import annotations
from copy import deepcopy
from datetime import datetime, timedelta, timezone
from hashlib import sha256
import json
from math import isfinite
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
from scripts.consultation_plan_contract import PLAN_VERSION, plan_route_contract
from . import BINDING_KEYS
POLICY_VERSION = "purpose_policy_v1"
GRANULARITIES = ("structure", "year", "month", "day")
DOMAIN_ALIASES = {
"career": "career", "事业": "career",
"finance": "wealth", "wealth": "wealth", "财富": "wealth",
"marriage": "marriage", "relationship": "marriage", "婚恋": "marriage",
"structure": "structure", "整体结构": "structure",
}
SECOND = timedelta(seconds=1)
TIMING_LAYERS = frozenset({"Dasha", "Vimshottari", "Narayana", "Transit"})
KNOWN_STATES = frozenset({"executed", "blocked", "not_applicable", "error"})
MISSING_POLICY_LAYER = "purpose_policy"
def fingerprint(value) -> str:
payload = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False)
return sha256(payload.encode("utf-8")).hexdigest()
def _text(value, name: str) -> str:
if not isinstance(value, str) or not value.strip():
raise ValueError(f"{name}_required")
return value.strip()
def _number(value, lower: float, upper: float, name: str) -> float:
if (not isinstance(value, (int, float)) or isinstance(value, bool)
or not isfinite(value) or not lower <= value <= upper):
raise ValueError(f"{name}_invalid")
return float(value)
def stamp(value: str | datetime) -> datetime:
"""Parse an explicit time and return the UTC instant (without rounding)."""
at = value if isinstance(value, datetime) else datetime.fromisoformat(_text(value, "timestamp"))
if at.utcoffset() is None:
raise ValueError("explicit_timestamp_zone_required")
return at.astimezone(timezone.utc)
def _parse_range_endpoint(value, profile: dict) -> datetime:
local = datetime.fromisoformat(_text(value, "range_endpoint"))
if local.microsecond:
raise ValueError("range_endpoint_exceeds_second_resolution")
if local.utcoffset() is not None:
return stamp(local)
if "timezone" not in profile:
return stamp(local.replace(tzinfo=timezone(timedelta(hours=profile["tz"]))))
zone = ZoneInfo(profile["timezone"])
choices = {
stamp(local.replace(tzinfo=zone, fold=fold))
for fold in (0, 1)
if stamp(local.replace(tzinfo=zone, fold=fold)).astimezone(zone).replace(tzinfo=None) == local
}
if len(choices) != 1:
raise ValueError("ambiguous_or_missing_local_time_use_offset_or_explicit_branches")
return choices.pop()
def _profiles(profiles: dict) -> dict:
branches = profiles.get("branches")
if not isinstance(branches, dict) or not branches:
raise ValueError("explicit_profile_branches_required")
normalized = {}
for branch, item in branches.items():
branch = _text(branch, "branch_id")
if not isinstance(item, dict) or branch in normalized:
raise ValueError("profile_branch_invalid")
profile = deepcopy(item)
profile["lat"] = _number(item.get("lat"), -90, 90, "latitude")
profile["lon"] = _number(item.get("lon"), -180, 180, "longitude")
profile["ayanamsa"] = _text(item.get("ayanamsa"), "ayanamsa").lower()
profile["node_mode"] = _text(item.get("node_mode"), "node_mode").lower()
if profile["node_mode"] not in ("mean", "true"):
raise ValueError("node_mode_invalid")
if item.get("timezone") is not None:
profile["timezone"] = _text(item["timezone"], "timezone")
try:
ZoneInfo(profile["timezone"])
except ZoneInfoNotFoundError as exc:
raise ValueError("timezone_invalid") from exc
if "tz" in item:
raise ValueError("supply_either_timezone_or_fixed_offset")
else:
profile.pop("timezone", None)
profile["tz"] = _number(item.get("tz"), -14, 14, "timezone_offset")
normalized[branch] = profile
return dict(sorted(normalized.items()))
def _ranges(remaining_ranges: list, branches: dict) -> list[dict]:
if not isinstance(remaining_ranges, list) or not remaining_ranges:
raise ValueError("remaining_ranges_required")
ranges = []
for source in remaining_ranges:
if not isinstance(source, dict):
raise ValueError("range_invalid")
branch = source.get("branch_id")
if branch is None and len(branches) == 1:
branch = next(iter(branches))
if not isinstance(branch, str) or branch not in branches:
raise ValueError("range_branch_required")
start = _parse_range_endpoint(source.get("start"), branches[branch])
end = _parse_range_endpoint(source.get("end"), branches[branch])
closed_start, closed_end = source.get("closed_start", True), source.get("closed_end", True)
if type(closed_start) is not bool or type(closed_end) is not bool:
raise ValueError("range_boundary_invalid")
if start + (timedelta(0) if closed_start else SECOND) > end - (timedelta(0) if closed_end else SECOND):
raise ValueError("empty_or_reversed_second_resolution_range")
ranges.append({
"branch_id": branch, "start": start.isoformat(), "end": end.isoformat(),
"closed_start": closed_start, "closed_end": closed_end,
"duration_seconds": int((end - start).total_seconds()),
"source": deepcopy(source.get("source")),
})
if {item["branch_id"] for item in ranges} != set(branches):
raise ValueError("profile_branch_without_remaining_range")
ordered = sorted(ranges, key=lambda item: (item["branch_id"], item["start"], item["end"], fingerprint(item)))
return [{"range_id": f"r{index}", **item} for index, item in enumerate(ordered, 1)]
def range_limits(item: dict) -> tuple[datetime, datetime]:
start, end = stamp(item["start"]), stamp(item["end"])
return (
start if item["closed_start"] else start + SECOND,
end if item["closed_end"] else end - SECOND,
)
def profile_clock(at: datetime, profile: dict) -> datetime:
zone = ZoneInfo(profile["timezone"]) if "timezone" in profile else timezone(timedelta(hours=profile["tz"]))
return stamp(at).astimezone(zone)
def _policy(domains: list[str], granularity: str, version: str) -> dict:
# 产品约定,待占星师审核。Use the existing server route's machine-readable
# layers for domain scopes. "structure" is the explicit basic-chart scope.
forecast = granularity != "structure"
layers = []
missing = []
for domain in domains:
if domain == "structure" and not forecast:
layers.extend(("D1", "D9", "moon_nakshatra"))
continue
route = plan_route_contract(domain) if domain in ("career", "wealth", "marriage") else None
if route is None:
missing.append(domain)
continue
for layer in route.required_layers:
if layer not in TIMING_LAYERS or forecast:
layers.extend(("Vimshottari", "Narayana") if layer == "Dasha" else (layer,))
if missing or version != POLICY_VERSION:
layers.append(MISSING_POLICY_LAYER)
if version != POLICY_VERSION:
layers = [MISSING_POLICY_LAYER]
depth = {"structure": 0, "year": 1, "month": 2, "day": 3}[granularity]
return {
"id": POLICY_VERSION, "version": version, "route_version": PLAN_VERSION,
"required_layers": list(dict.fromkeys(layers)), "missing_domains": missing,
"vimshottari_depth": depth, "narayana_depth": min(depth, 2),
"decision_predicates": ["structure_identity"] + (["window_presence", f"{granularity}_bucket", "target_boundaries"] if forecast else []),
"birth_resolution_seconds": 1,
}
def _forecast(question: dict, granularity: str) -> dict | None:
if granularity == "structure":
return None
start = stamp(question.get("forecast_start"))
end = stamp(question.get("forecast_end"))
if end <= start:
raise ValueError("forecast_window_reversed")
original = datetime.fromisoformat(question["forecast_start"])
raw_targets = question.get("target_boundaries", [])
if not isinstance(raw_targets, list):
raise ValueError("target_boundaries_invalid")
targets = sorted({stamp(item).isoformat() for item in raw_targets})
if any(not start <= stamp(target) <= end for target in targets):
raise ValueError("target_boundary_outside_forecast_window")
return {
"start": start.isoformat(), "end": end.isoformat(), "target_boundaries": targets,
"comparison_offset_seconds": int(original.utcoffset().total_seconds()),
}
def build_scope_request(question: dict, original_input: dict, remaining_ranges: list,
profiles: dict, evaluated_at: str) -> dict:
"""Normalize scope and bind it to the exact candidate set and native profile."""
text = _text(question.get("question"), "question")
supplied = question.get("domains")
if not isinstance(supplied, list) or not supplied:
raise ValueError("domains_required")
tokens = [_text(token, "domain").casefold() for token in supplied]
domains = sorted({DOMAIN_ALIASES.get(token, token) for token in tokens})
granularity = _text(question.get("granularity"), "granularity")
if granularity not in GRANULARITIES:
raise ValueError("unsupported_granularity")
event_class = question.get("event_class")
if event_class is not None:
event_class = _text(event_class, "event_class")
version = _text(question.get("precision_policy_version", POLICY_VERSION), "precision_policy_version")
branches = _profiles(profiles)
ranges = _ranges(remaining_ranges, branches)
forecast = _forecast(question, granularity)
evaluated = stamp(evaluated_at).isoformat()
policy = _policy(domains, granularity, version)
purpose = {
"question": " ".join(text.split()), "domains": domains, "event_class": event_class,
"granularity": granularity, "required_techniques": policy["required_layers"],
"required_outputs": policy["required_layers"], "decision_predicates": policy["decision_predicates"],
"precision_policy_id": POLICY_VERSION, "evaluated_at": evaluated, "forecast_window": forecast,
}
fingerprints = {
"input_revision": _text(original_input.get("input_revision"), "input_revision"),
"candidate_set_fingerprint": fingerprint({"ranges": ranges, "zone_resolution": original_input.get("zone_resolution")}),
"purpose_fingerprint": fingerprint({key: value for key, value in purpose.items() if key != "forecast_window"}),
"profile_fingerprint": fingerprint(branches),
"engine_version": _text(profiles.get("engine_version"), "engine_version"),
"precision_policy_version": f"{version}:{fingerprint(policy)}",
"forecast_window_fingerprint": fingerprint({"window": forecast, "evaluated_at": evaluated}),
}
return {
"schema": "jyotish.purpose_scope_request.v1",
"original_time_record": deepcopy(original_input), "plausible_ranges": ranges,
"purpose_scope": purpose, "policy": policy, "profiles": branches,
"binding": {key: fingerprints[key] for key in BINDING_KEYS},
}
def usable(output: dict) -> bool:
value = output["value"]
return (output["status"] == "executed" and value is not None and type(value) is not bool
and value not in ("", [], {}, "blocked", "unavailable", "unknown")
and all(isinstance(output.get(key), str) and output[key].strip() for key in ("method_id", "result_ref")))
def _output(item: dict | None, layer: str) -> dict:
if item is None:
return {
"layer": layer, "status": "blocked", "reason": "method_unresolved",
"value": None, "result_ref": None, "method_id": None, "dependencies": [],
}
if not isinstance(item, dict):
raise ValueError("native_output_invalid")
status = item.get("status")
dependencies = item.get("dependencies", [])
if status not in KNOWN_STATES or not isinstance(dependencies, list) or not all(isinstance(key, str) for key in dependencies):
raise ValueError("native_output_status_or_dependencies_invalid")
result = {
"layer": layer, "status": status, "value": deepcopy(item.get("value")),
"method_id": item.get("method_id"), "result_ref": item.get("result_ref"),
"dependencies": list(dependencies), "reason": item.get("reason"),
}
if "periods" in item:
result["periods"] = deepcopy(item["periods"])
if status == "executed" and not usable(result):
result["status"], result["reason"] = "blocked", "calculation_failure"
if result["status"] == "not_applicable":
result["reason"] = result["reason"] or "outside_native_method_scope"
return result
def _complete_ranges(ranges: list[dict], observed: dict[str, set[datetime]]) -> bool:
for item in ranges:
start, end = range_limits(item)
required = int((end - start).total_seconds()) + 1
count = sum(start <= at <= end for at in observed.get(item["branch_id"], ()))
if count != required:
return False
return True
def collect_scope_outputs(scope_request: dict, native_results: list) -> dict:
"""Collect trusted candidate results only; endpoint samples do not establish coverage."""
required = scope_request["policy"]["required_layers"]
profiles = scope_request["profiles"]
ranges = scope_request["plausible_ranges"]
candidates = []
observed: dict[str, set[datetime]] = {}
for row in native_results:
branch = row.get("branch_id")
if not isinstance(branch, str) or branch not in profiles:
raise ValueError("unknown_native_branch")
at = stamp(row.get("candidate_at"))
if at.microsecond or at in observed.setdefault(branch, set()):
raise ValueError("duplicate_or_non_second_native_candidate")
covered = []
for item in ranges:
start, end = range_limits(item)
if item["branch_id"] == branch and start <= at <= end:
covered.append(item["range_id"])
if not covered:
raise ValueError("native_candidate_outside_scope")
if row.get("profile") != profiles[branch]:
raise ValueError("native_profile_binding_mismatch")
observed[branch].add(at)
outputs = row.get("outputs", {})
if not isinstance(outputs, dict) or not all(isinstance(layer, str) and layer for layer in outputs):
raise ValueError("native_outputs_invalid")
layers = sorted(set(required) | outputs.keys())
candidate_id = f"{branch}@{at.isoformat()}"
candidates.append({
"candidate_id": candidate_id, "candidate_at": at.isoformat(), "branch_id": branch,
"range_ids": covered, "profile": deepcopy(profiles[branch]), "raw": deepcopy(row.get("raw")),
"outputs": {layer: _output(outputs.get(layer), layer) for layer in layers},
})
complete = _complete_ranges(ranges, observed)
coverage = {}
for layer in required:
executed = sum(usable(candidate["outputs"][layer]) for candidate in candidates)
coverage[layer] = ("executed_complete" if complete and executed == len(candidates)
else "partial" if executed else "blocked")
return {
"binding": dict(scope_request["binding"]), "required_layers": list(required),
"layer_coverage": coverage, "domain_complete": complete,
"historical_evidence_state": "not_evaluated",
"candidates": sorted(candidates, key=lambda row: (row["branch_id"], row["candidate_at"])),
}