Files
Jyotisha/scripts/career_semantic_profile.py
T
ClaudeandClaude Opus 5.5 8ed5b5f3c9 feat(engine): port upstream skill calculation fixes into the engine (BUG-1699)
- affliction_evidence / career_semantic_profile / career_analysis (functional
  roles, affliction signals, user-industry gate)
- sade_sati.build_saturn_cycle_timeline with bisected ingress moments
  (FLG_SIDEREAL frame, BUG-1275)
- Chesta profile candidates and PL9 AV cell profile as sidecars
  (shadbala.py / ashtakavarga.py stay frozen, ERR-110)
- Raman Sahams in the annual pack; book rule packets + admission gate
- consultation_native_layers: affliction_evidence, career_analysis,
  sade_sati_timeline, shadbala_chesta_profiles, book_rules,
  annual_tajika.raman_sahams

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DbBXoyn7Hj3LCW3BUs5bZ8
2026-11-07 14:42:54 +08:00

296 lines
13 KiB
Python

"""Auditable career-role semantics layered on the existing evidence snapshot."""
from __future__ import annotations
from datetime import date as calendar_date
import json
from pathlib import Path
from typing import Any
_ROOT = Path(__file__).resolve().parents[1]
_TAXONOMY = _ROOT / "references" / "career_semantic_taxonomy.json"
_PROVENANCE = {"existing_source", "traditional_reference", "research_hypothesis"}
_PUBLIC_CASE_SOURCE_TIERS = {
"primary",
"primary_public_record",
"verified_secondary",
"public_research",
}
_RELIABLE_TIME_RATINGS = {"AA", "A", "reliable", "verified"}
_SIMILARITY_LEVELS = tuple(f"L{level}" for level in range(6))
_SOURCE_PATHS = {
"D1": "modules.chart",
"D10": "modules.varga_full.D10_Dasamsa",
"A10": "modules.special_lagnas.A10_Karma_Pada",
"vimsopaka": "ai_prompt_pack.evidence_snapshot.vimsopaka_semantic_summary",
"western": "western.natal",
}
_REQUIRED_EXECUTION = {
"D1": {"D1"},
"D10": {"D10"},
"A10": {"A10"},
"vimsopaka": {"Vimsopaka"},
"western": {"Western"},
}
def _get(source: dict[str, Any], path: str) -> Any:
current: Any = source
for key in path.split("."):
if not isinstance(current, dict):
return None
current = current.get(key)
return current
def _is_public_url(value: Any) -> bool:
return isinstance(value, str) and value.startswith(("https://", "http://"))
def _is_iso_date(value: Any) -> bool:
if not isinstance(value, str):
return False
try:
return calendar_date.fromisoformat(value).isoformat() == value
except ValueError:
return False
def validate_case_card(card: dict[str, Any] | None) -> dict[str, Any]:
"""Validate public career-case metadata without retaining case content."""
card = card if isinstance(card, dict) else {}
errors: list[str] = []
if not _is_public_url(card.get("source_url")):
errors.append("source_url")
if card.get("source_tier") not in _PUBLIC_CASE_SOURCE_TIERS:
errors.append("source_tier")
if not isinstance(card.get("birth_data_provenance"), str) or not card["birth_data_provenance"].strip():
errors.append("birth_data_provenance")
if card.get("time_reliability") not in _RELIABLE_TIME_RATINGS:
errors.append("time_reliability")
event = card.get("career_event")
if not isinstance(event, dict):
errors.extend(("career_event.date", "career_event.description", "career_event.source_url"))
else:
if not _is_iso_date(event.get("date")):
errors.append("career_event.date")
if not isinstance(event.get("description"), str) or not event["description"].strip():
errors.append("career_event.description")
if not _is_public_url(event.get("source_url")):
errors.append("career_event.source_url")
similarity = card.get("similarity")
if not isinstance(similarity, dict):
errors.append("similarity")
similarity = {}
elif any(level not in _SIMILARITY_LEVELS or not isinstance(value, str) or not value.strip() for level, value in similarity.items()):
errors.append("similarity")
if not isinstance(card.get("transferability_boundary"), str) or not card["transferability_boundary"].strip():
errors.append("transferability_boundary")
if errors:
return {"status": "rejected", "errors": errors}
if all(level in similarity for level in _SIMILARITY_LEVELS) and "L4" in similarity:
return {"status": "accepted_calibration_candidate", "errors": []}
return {"status": "accepted_background_only", "errors": []}
def load_taxonomy(path: Path = _TAXONOMY) -> dict[str, Any]:
taxonomy = json.loads(path.read_text(encoding="utf-8"))
templates = taxonomy.get("signal_templates")
domains = taxonomy.get("domains")
if not isinstance(templates, dict) or not isinstance(domains, dict):
raise ValueError("career taxonomy requires templates and domains")
for domain in domains.values():
roles = domain.get("role_clusters") if isinstance(domain, dict) else None
if not isinstance(roles, dict):
raise ValueError("career taxonomy domain requires role_clusters")
for role_id, template_ids in list(roles.items()):
if not isinstance(template_ids, list):
raise ValueError(f"role {role_id} requires signal template ids")
signals = []
for template_id in template_ids:
rule = dict(templates.get(template_id) or {})
if not rule:
raise ValueError(f"unknown signal template: {template_id}")
if rule.get("provenance") not in _PROVENANCE:
raise ValueError(f"invalid provenance for {template_id}")
required = {"id", "layer", "path", "operator", "value", "weight", "polarity", "note", "provenance"}
if not required <= set(rule):
raise ValueError(f"incomplete semantic rule: {template_id}")
signals.append(rule)
roles[role_id] = {"signals": signals}
return taxonomy
def _matches(rule: dict[str, Any], indian: dict[str, Any], western: dict[str, Any]) -> bool:
source = western if rule["layer"].startswith("western") else indian
path = rule["path"]
if source is indian and path.startswith("modules."):
path = path.removeprefix("modules.")
value = _get(source, path)
if rule["operator"] == "in":
return value in rule["value"]
if rule["operator"] == "not_in":
return value not in rule["value"]
return False
def build_career_execution_audit(
modules: dict[str, Any],
western: dict[str, Any] | None,
vimsopaka_semantic_summary: dict[str, Any] | None,
) -> list[dict[str, str]]:
"""Record only the five inputs this semantic classifier consumes."""
modules = modules if isinstance(modules, dict) else {}
checks = {
"D1": _get(modules, "chart.ascendant"),
"D10": _get(modules, "varga_full.D10_Dasamsa"),
"A10": _get(modules, "special_lagnas.A10_Karma_Pada"),
"Vimsopaka": vimsopaka_semantic_summary if isinstance(vimsopaka_semantic_summary, dict) and vimsopaka_semantic_summary.get("status") == "used" else None,
"Western": western,
}
return [
{"technique": technique, "status": "executed" if value not in (None, {}, [], "") else "blocked"}
for technique, value in checks.items()
]
def _missing_execution(audit: Any) -> list[str]:
rows = audit if isinstance(audit, list) else []
statuses = {
str(row.get("technique")): str(row.get("status"))
for row in rows if isinstance(row, dict)
}
return [
key for key, names in _REQUIRED_EXECUTION.items()
if not any(statuses.get(name) == "executed" for name in names)
]
def _evidence_item(path: str, layer: str, weight: int, note: str, polarity: str = "support") -> dict[str, Any]:
return {
"id": f"career_semantic:{path}",
"layer": layer,
"path": path,
"weight": weight,
"note": note,
"provenance": "research_hypothesis",
"polarity": polarity,
}
def _screenwriter_house_evidence(modules: dict[str, Any], western: dict[str, Any]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
"""Return source-path-only career signals; never retain chart payload values."""
candidates = (
("modules.chart.planets.Mercury.house", "indian_natal", 3, "D1 third-house communication signal", {3}),
("modules.chart.planets.Venus.house", "indian_natal", 3, "D1 fifth-house creative signal", {5}),
("modules.varga_full.D10_Dasamsa.Mercury.house", "indian_d10", 3, "D10 tenth-house vocational writing signal", {10}),
("modules.varga_full.D10_Dasamsa.Venus.house", "indian_d10", 3, "D10 fifth-house creative execution signal", {5}),
("natal.planets.mercury.house", "western_natal", 2, "Western fifth-house writing signal", {5}),
("natal.planets.venus.house", "western_natal", 2, "Western fifth-house creative signal", {5}),
)
support = []
for path, layer, weight, note, expected in candidates:
source = western if path.startswith("natal.") else modules
lookup_path = path.removeprefix("modules.")
if _get(source, lookup_path) in expected:
support.append(_evidence_item(path, layer, weight, note))
if _get(western, "natal.angles.mc.ruler") == "Mercury":
support.append(_evidence_item("natal.angles.mc.ruler", "western_natal", 3, "MC ruler supports communication vocation"))
counter = []
for path, layer in (
("modules.chart.planets.Saturn.house", "indian_natal"),
("modules.varga_full.D10_Dasamsa.Saturn.house", "indian_d10"),
("natal.planets.saturn.house", "western_natal"),
):
source = western if path.startswith("natal.") else modules
if _get(source, path.removeprefix("modules.")) in {8, 9, 12}:
counter.append(_evidence_item(path, layer, 1, "Counterweight requiring career-history verification", "counter"))
return support, counter
def build_career_semantic_profile(
modules: dict[str, Any],
western: dict[str, Any] | None,
vimsopaka_semantic_summary: dict[str, Any] | None,
technique_audit: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
modules = modules if isinstance(modules, dict) else {}
western = western if isinstance(western, dict) else None
source_paths = dict(_SOURCE_PATHS)
if isinstance(vimsopaka_semantic_summary, dict) and isinstance(vimsopaka_semantic_summary.get("source_path"), str):
source_paths["vimsopaka"] = vimsopaka_semantic_summary["source_path"]
missing = []
if not _get(modules, "chart.ascendant"):
missing.append("D1")
if not _get(modules, "varga_full.D10_Dasamsa"):
missing.append("D10")
if not _get(modules, "special_lagnas.A10_Karma_Pada"):
missing.append("A10")
if not isinstance(vimsopaka_semantic_summary, dict) or vimsopaka_semantic_summary.get("status") != "used":
missing.append("vimsopaka")
if western is None:
missing.append("western")
missing = list(dict.fromkeys(missing + _missing_execution(technique_audit)))
if missing:
return {
"status": "blocked",
"missing_required_evidence": missing,
"ranked_domains": [],
"ranked_role_clusters": [],
"cross_system_conflicts": [],
"verification_questions": [],
"vimsopaka_source_path": "ai_prompt_pack.evidence_snapshot.vimsopaka_semantic_summary",
"source_paths": source_paths,
"technique_audit": list(technique_audit or []),
}
taxonomy = load_taxonomy()
domains = []
roles = []
for domain_id, domain in taxonomy["domains"].items():
domain_score = 0
for role_id, role in domain["role_clusters"].items():
support, counter = [], []
score = 0
for rule in role["signals"]:
if not _matches(rule, modules, western):
continue
item = {key: rule[key] for key in ("id", "layer", "path", "weight", "note", "provenance")}
if rule["polarity"] == "counter":
counter.append(item)
score -= int(rule["weight"])
else:
support.append(item)
score += int(rule["weight"])
if role_id == "screenwriter":
house_support, house_counter = _screenwriter_house_evidence(modules, western)
support.extend(house_support)
counter.extend(house_counter)
score += sum(item["weight"] for item in house_support)
score -= sum(item["weight"] for item in house_counter)
if not support and not counter:
continue
research_only = support and all(item["provenance"] == "research_hypothesis" for item in support)
roles.append({
"id": role_id,
"domain": domain_id,
"score": score,
"supporting_evidence": support,
"counter_evidence": counter,
"assertion_label": "parameter_sensitive" if research_only else "multi_system_consensus" if any(item["layer"].startswith("western") for item in support) and any(item["layer"].startswith("indian") for item in support) else "single_system_inference",
"confidence_cap": "medium" if not research_only else "low",
"verification_questions": ["该方向是否已有作品、客户、项目或持续训练可供回测?"],
})
domain_score += score
domains.append({"id": domain_id, "score": domain_score})
return {
"status": "used",
"missing_required_evidence": [],
"ranked_domains": sorted(domains, key=lambda item: (-item["score"], item["id"])),
"ranked_role_clusters": sorted(roles, key=lambda item: (-item["score"], item["id"])),
"cross_system_conflicts": [],
"verification_questions": ["请用已知职业节点回测候选簇,不将回测信息倒灌至盲读。"],
"vimsopaka_source_path": "ai_prompt_pack.evidence_snapshot.vimsopaka_semantic_summary",
"source_paths": source_paths,
"technique_audit": list(technique_audit or []),
}