feat: vendor four upstream Goel Jaimini strength modules
Issue #94 T1. Place goel_jaimini_strength, trikona_raman, sthira_brahma_goel_short_method, and trikona_dasha from upstream 5fb8379c under scripts/. The only local edit is the SOURCE book citation. Raise ROOT_PY_BUDGET from 448 to 452. Co-Authored-By: Grok (agent loop) Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jesse-ux
co-authored by
Grok (agent loop)
Cursor
Grok (agent loop)
Cursor
parent
a9bf16816b
commit
424f03a4d5
@@ -0,0 +1,137 @@
|
||||
"""Goel's full Jaimini strength and special-point profile, not Bhava Bala.
|
||||
|
||||
Source: Predicting through Jaimini Astrology, printed pp10-17 (PDF pp14-21).
|
||||
The published p15 example is the numeric regression. Dignity degree ranges
|
||||
reuse the explicitly named Raman manual profile; no universal lineage claim.
|
||||
"""
|
||||
import math
|
||||
from scripts.trikona_raman import CLASSICAL, DIGNITY_PROFILE, _dignity, _validate_positions
|
||||
from scripts.narayana_dasha import _rasi_aspects
|
||||
from scripts.sthira_brahma_goel_short_method import SIGNS, SIGN_LORDS
|
||||
|
||||
PROFILE = 'goel_full_jaimini_strength_ch1_v1'
|
||||
SOURCE = 'V. P. Goel, Predicting through Jaimini Astrology'
|
||||
KARAKA_POINTS = (60, 45, 30, 22.5, 15, 7.5, 3.75)
|
||||
MALEFICS = ('Sun', 'Mars', 'Saturn', 'Rahu', 'Ketu')
|
||||
|
||||
|
||||
def calculate_goel_strength(planet_longitudes, *, node_occupancy_policy='include_nodes_text'):
|
||||
if node_occupancy_policy not in {'include_nodes_text', 'exclude_nodes_worked_example'}:
|
||||
raise ValueError('explicit Goel node occupancy policy required')
|
||||
_validate_positions(planet_longitudes)
|
||||
signs = {p: int(v // 30) for p, v in planet_longitudes.items()}
|
||||
degrees = {p: planet_longitudes[p] % 30 for p in CLASSICAL}
|
||||
ranked = sorted(CLASSICAL, key=degrees.get, reverse=True)
|
||||
if any(math.isclose(degrees[a], degrees[b], rel_tol=0, abs_tol=1e-10)
|
||||
for i, a in enumerate(ranked) for b in ranked[i + 1:]):
|
||||
return dict(status='blocked', reason='equal_degree_seven_karaka_rank_requires_finer_positions', profile_id=PROFILE)
|
||||
ak = ranked[0]
|
||||
karakas = dict(zip(ranked, KARAKA_POINTS))
|
||||
|
||||
def contacts(sign, candidates):
|
||||
return [p for p in candidates if signs[p] == sign or _rasi_aspects(signs[p], sign)]
|
||||
|
||||
planets = {}
|
||||
for p in CLASSICAL:
|
||||
sign = signs[p]
|
||||
dignity, moola = _dignity(p, planet_longitudes[p])
|
||||
kendra = (60, 30, 15)[(sign - signs[ak]) % 3]
|
||||
before = [q for q, s in signs.items() if s == (sign - 1) % 12]
|
||||
after = [q for q, s in signs.items() if s == (sign + 1) % 12]
|
||||
kartari = 60 if sign % 2 == 0 and before and after else 0
|
||||
malefic_contacts = contacts(sign, [q for q in MALEFICS if q != p])
|
||||
adhipati = 60 if p != 'Moon' and malefic_contacts else 0
|
||||
planets[p] = dict(sign_idx=sign, degree_in_sign=degrees[p],
|
||||
dignity=dignity, mooltrikona=moola, karaka=karakas[p], kendriya=kendra,
|
||||
kartari=kartari, adhipati=adhipati, malefic_contacts=malefic_contacts,
|
||||
kartari_before=before, kartari_after=after,
|
||||
total=moola + karakas[p] + kendra + kartari + adhipati)
|
||||
rows = []
|
||||
for sign in range(12):
|
||||
lord = SIGN_LORDS[sign]
|
||||
occupants = [p for p, s in signs.items() if s == sign]
|
||||
permanent = (15, 30, 60)[sign % 3]
|
||||
karaka = sum(karakas.get(p, 0) for p in occupants)
|
||||
counted = occupants if node_occupancy_policy == 'include_nodes_text' else [p for p in occupants if p in CLASSICAL]
|
||||
sthana = 45 + 15 * len(counted) if counted else 0
|
||||
# Three roles, not distinct planets: Goel p103 explicitly explains
|
||||
# double credit when Mercury/Jupiter is also the sign lord.
|
||||
aspect_roles = [role for role, p in [('Jupiter', 'Jupiter'), ('Mercury', 'Mercury'), ('lord', lord)]
|
||||
if contacts(sign, [p])]
|
||||
aspect = 60 * len(aspect_roles)
|
||||
rows.append(dict(sign_idx=sign, sign=SIGNS[sign], lord=lord,
|
||||
permanent=permanent, karaka=karaka, sthana=sthana, occupants=occupants, counted_occupants=counted,
|
||||
aspect=aspect, aspect_roles=aspect_roles, lord_strength=planets[lord]['total'],
|
||||
total=permanent + karaka + sthana + aspect + planets[lord]['total']))
|
||||
return dict(status='executed', confidence_status='parameter_sensitive', profile_id=PROFILE,
|
||||
source=SOURCE, source_locator='PDF pp14-21; printed pp10-17; lines461-736',
|
||||
dignity_profile=DIGNITY_PROFILE, malefic_profile='Sun_Mars_Saturn_Rahu_Ketu_excluding_self',
|
||||
node_occupancy_policy=node_occupancy_policy,
|
||||
aspect_profile='jaimini_rasi_drishti', aspect_role_policy='distinct_roles',
|
||||
atmakaraka=ak, planets=planets, rashi_strengths=rows,
|
||||
claim_boundary='Named Goel full method with declared dignity ranges; not PL9 or all-lineage parity.')
|
||||
|
||||
|
||||
def build_goel_chart_evidence(planet_longitudes, ascendant_longitude):
|
||||
if (type(ascendant_longitude) not in (int, float)
|
||||
or not math.isfinite(ascendant_longitude)
|
||||
or not 0 <= ascendant_longitude < 360):
|
||||
raise ValueError('ascendant longitude must be a finite number in [0,360)')
|
||||
strength = calculate_goel_strength(planet_longitudes)
|
||||
result = dict(strength=strength, special_points={})
|
||||
if strength['status'] != 'executed':
|
||||
result['special_points'] = {
|
||||
name: dict(status='blocked', reason=strength['reason'], profile_id=PROFILE)
|
||||
for name in ('Brahma', 'Maheshwara', 'Rudra')
|
||||
}
|
||||
return result
|
||||
strength['worked_example_node_exclusion'] = calculate_goel_strength(
|
||||
planet_longitudes, node_occupancy_policy='exclude_nodes_worked_example')
|
||||
strength['source_discrepancy'] = (
|
||||
'Printed p14 includes nodes in Sthana; printed p15 worked totals omit them. '
|
||||
'Both numeric alternatives are preserved; the explicit text is the active profile.')
|
||||
lagna = int(float(ascendant_longitude) % 360 // 30)
|
||||
seventh = (lagna + 6) % 12
|
||||
planets = strength['planets']
|
||||
rashis = strength['rashi_strengths']
|
||||
ak_sign = planets[strength['atmakaraka']]['sign_idx']
|
||||
|
||||
def choose(candidates, rule):
|
||||
candidates = list(dict.fromkeys(candidates))
|
||||
scores = {p: planets[p]['total'] for p in candidates}
|
||||
winners = [p for p in candidates if scores[p] == max(scores.values())]
|
||||
return dict(status='executed' if len(winners) == 1 else 'blocked',
|
||||
value=winners[0] if len(winners) == 1 else None,
|
||||
candidates=scores, rule=rule,
|
||||
reason=None if len(winners) == 1 else 'equal_Goel_strength_no_unique_selector',
|
||||
profile_id=PROFILE, confidence_status='parameter_sensitive',
|
||||
source=SOURCE, source_locator='PDF pp20-21; printed pp16-17; lines701-736')
|
||||
|
||||
eighth_ak = SIGN_LORDS[(ak_sign + 7) % 12]
|
||||
if planets[eighth_ak]['sign_idx'] == (ak_sign + 7) % 12:
|
||||
brahma = choose([eighth_ak], 'eighth_lord_from_AK_occupies_eighth_from_AK')
|
||||
elif rashis[lagna]['total'] == rashis[seventh]['total']:
|
||||
brahma = dict(status='blocked', reason='equal_Lagna_seventh_Goel_strength', profile_id=PROFILE)
|
||||
else:
|
||||
anchor = lagna if rashis[lagna]['total'] > rashis[seventh]['total'] else seventh
|
||||
brahma = choose([SIGN_LORDS[(anchor + h - 1) % 12] for h in (6, 8, 12)
|
||||
if SIGN_LORDS[(anchor + h - 1) % 12] != 'Saturn'],
|
||||
'strongest_6_8_12_lord_from_stronger_Lagna_seventh_excluding_Saturn')
|
||||
brahma['anchor_sign_idx'] = anchor
|
||||
maheswara = choose([eighth_ak] + ([SIGN_LORDS[(ak_sign + 11) % 12]]
|
||||
if planets[eighth_ak]['dignity'] == 'exalted' else []),
|
||||
'eighth_lord_from_AK_compare_twelfth_if_exalted')
|
||||
rudra_candidates = list(dict.fromkeys([SIGN_LORDS[(lagna + 7) % 12], SIGN_LORDS[(lagna + 1) % 12]]))
|
||||
afflicted = [p for p in rudra_candidates if planets[p]['malefic_contacts']]
|
||||
rudra = choose(afflicted if len(afflicted) == 1 else rudra_candidates,
|
||||
'stronger_8th_2nd_lord_unless_only_weaker_has_malefic_contact')
|
||||
result['special_points'] = dict(Brahma=brahma, Maheshwara=maheswara, Rudra=rudra)
|
||||
result['lagna_seventh_strength'] = dict(lagna=rashis[lagna]['total'],
|
||||
seventh=rashis[seventh]['total'], profile_id=PROFILE, source=SOURCE,
|
||||
comparison='lagna_vs_seventh')
|
||||
# Frozen-export compatibility only. PVR Niryaana is second/eighth Ayur
|
||||
# comparison; callers must not route these Goel totals into that selector.
|
||||
result['niryaana_shoola_strength'] = dict(result['lagna_seventh_strength'],
|
||||
deprecated=True, replacement='lagna_seventh_strength',
|
||||
not_for='pvr_niryaana_shoola_ayur_rasi_strength_v1')
|
||||
return result
|
||||
@@ -0,0 +1,112 @@
|
||||
"""Source-bounded Brahma selector for the Goel/Rao short-method profile.
|
||||
|
||||
This is intentionally explicit-input only. It implements the short method
|
||||
described in the local Jaimini transcriptions: choose the stronger of Lagna
|
||||
and the seventh sign, inspect the 6th/8th/12th lords from that anchor, exclude
|
||||
Saturn, then rank the remaining candidates by declared strength and degree.
|
||||
It does not implement the separate odd/back-rising or BPHS override clauses.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
|
||||
SIGNS = (
|
||||
"Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
|
||||
"Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces",
|
||||
)
|
||||
SIGN_LORDS = {
|
||||
0: "Mars", 1: "Venus", 2: "Mercury", 3: "Moon",
|
||||
4: "Sun", 5: "Mercury", 6: "Venus", 7: "Mars",
|
||||
8: "Jupiter", 9: "Saturn", 10: "Saturn", 11: "Jupiter",
|
||||
}
|
||||
PROFILE_ID = "goel_rao_short_brahma_method_v1"
|
||||
|
||||
|
||||
def _candidate(
|
||||
*,
|
||||
house: int,
|
||||
anchor_sign_index: int,
|
||||
planets: dict[str, dict[str, Any]],
|
||||
strengths: dict[str, float],
|
||||
) -> dict[str, Any]:
|
||||
sign_index = (anchor_sign_index + house - 1) % 12
|
||||
lord = SIGN_LORDS[sign_index]
|
||||
planet = planets.get(lord) if isinstance(planets.get(lord), dict) else {}
|
||||
degree = planet.get("degree_in_sign", planet.get("degree"))
|
||||
return {
|
||||
"source_house": house,
|
||||
"source_sign_index": sign_index,
|
||||
"source_sign": SIGNS[sign_index],
|
||||
"planet": lord,
|
||||
"planet_sign_index": planet.get("sign_index", planet.get("sign_idx")),
|
||||
"planet_sign": planet.get("sign"),
|
||||
"degree_in_sign": float(degree) if isinstance(degree, (int, float)) else None,
|
||||
"declared_strength": strengths.get(lord),
|
||||
"saturn_excluded": lord == "Saturn",
|
||||
}
|
||||
|
||||
|
||||
def select_brahma_goel_short_method(
|
||||
*,
|
||||
lagna_sign_index: int,
|
||||
planets: dict[str, dict[str, Any]],
|
||||
planet_strengths: dict[str, float],
|
||||
lagna_strength: float,
|
||||
seventh_strength: float,
|
||||
) -> dict[str, Any]:
|
||||
"""Select Brahma under the explicit Goel/Rao short-method profile."""
|
||||
if not 0 <= int(lagna_sign_index) < 12:
|
||||
return {"status": "blocked", "reason": "lagna_sign_index must be 0..11", "candidates": []}
|
||||
if not isinstance(planets, dict) or not isinstance(planet_strengths, dict):
|
||||
return {"status": "blocked", "reason": "planets and planet_strengths are required", "candidates": []}
|
||||
if not isinstance(lagna_strength, (int, float)) or not isinstance(seventh_strength, (int, float)):
|
||||
return {"status": "blocked", "reason": "lagna_strength and seventh_strength are required", "candidates": []}
|
||||
|
||||
anchor = int(lagna_sign_index) if float(lagna_strength) >= float(seventh_strength) else (int(lagna_sign_index) + 6) % 12
|
||||
candidates = [
|
||||
_candidate(house=house, anchor_sign_index=anchor, planets=planets, strengths=planet_strengths)
|
||||
for house in (6, 8, 12)
|
||||
]
|
||||
eligible = [row for row in candidates if not row["saturn_excluded"] and row["declared_strength"] is not None]
|
||||
if not eligible:
|
||||
return {
|
||||
"profile_id": PROFILE_ID,
|
||||
"status": "blocked",
|
||||
"confidence_status": "parameter_sensitive",
|
||||
"reason": "No non-Saturn candidate has a declared strength.",
|
||||
"anchor": {"sign_index": anchor, "sign": SIGNS[anchor], "selected_by": "lagna_vs_seventh_strength"},
|
||||
"candidates": candidates,
|
||||
}
|
||||
eligible.sort(
|
||||
key=lambda row: (
|
||||
float(row["declared_strength"]),
|
||||
float(row["degree_in_sign"]) if row["degree_in_sign"] is not None else -1.0,
|
||||
),
|
||||
reverse=True,
|
||||
)
|
||||
selected = eligible[0]
|
||||
return {
|
||||
"profile_id": PROFILE_ID,
|
||||
"status": "executed",
|
||||
"confidence_status": "parameter_sensitive",
|
||||
"verification_status": "source_bounded_explicit_input",
|
||||
"anchor": {
|
||||
"sign_index": anchor,
|
||||
"sign": SIGNS[anchor],
|
||||
"selected_by": "stronger_of_lagna_and_seventh",
|
||||
"lagna_strength": float(lagna_strength),
|
||||
"seventh_strength": float(seventh_strength),
|
||||
},
|
||||
"candidates": candidates,
|
||||
"selected": selected,
|
||||
"source_rule": (
|
||||
"Goel/Rao short method: strongest of 6th, 8th, and 12th lords from "
|
||||
"the stronger Lagna/7th anchor, excluding Saturn."
|
||||
),
|
||||
"unresolved": [
|
||||
"odd_sign_and_back_rising_filter_not_applied",
|
||||
"BPHS_verse_172_karaka_and_saturn_node_override_not_applied",
|
||||
"strength_source_is_declared_input_not_recomputed_here",
|
||||
],
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
"""Separate Trikona profiles: Raghava Bhatta MD and Raman confirmed-parent AD."""
|
||||
import argparse
|
||||
from copy import deepcopy
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
if __package__ in (None, ''):
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
|
||||
from scripts.narayana_dasha import SIGNS, SIGN_LORDS, _NARAYANA_DIGNITY
|
||||
|
||||
PROFILE = 'trikona_raghava_bhatta_explicit_seed_md_v1'
|
||||
SOURCE = 'https://saptarishisastrology.com/trikona-dasa-a-critical-review-by-iranganti-rangacharya/'
|
||||
RAMAN_AD_PROFILE = 'trikona_raman_94_confirmed_full_md_ad_v1'
|
||||
RAMAN_SOURCE = 'https://www.scribd.com/doc/127930441/Studies-in-Jaimini-Astrology-by-b-v-Raman'
|
||||
|
||||
|
||||
def build_trikona_raman_antardasa_report(*, md_sign_idx, full_md_years,
|
||||
full_md_start, parent_source, parent_profile, year_days, profile):
|
||||
"""Raman section94 AD only; a confirmed, untruncated parent is input."""
|
||||
if profile != RAMAN_AD_PROFILE or parent_profile != 'raman_studies_jaimini_92_93':
|
||||
raise ValueError('explicit Raman AD and Raman sections92/93 parent profiles required')
|
||||
if type(md_sign_idx) is not int or not 0 <= md_sign_idx < 12:
|
||||
raise ValueError('md_sign_idx must be integer 0..11')
|
||||
if not isinstance(parent_source, str) or not parent_source.strip():
|
||||
raise ValueError('parent_source must identify the confirmed full MD, not birth balance')
|
||||
for name, value, low, high in [('full_md_years', full_md_years, 0, 12),
|
||||
('year_days', year_days, 300, 400)]:
|
||||
if (isinstance(value, bool) or not isinstance(value, (int, float)) or
|
||||
not math.isfinite(value) or not low <= value <= high or value == 0):
|
||||
raise ValueError(f'{name} outside supported finite range')
|
||||
if not isinstance(full_md_start, str):
|
||||
raise ValueError('full_md_start must be aware ISO datetime')
|
||||
anchor = datetime.fromisoformat(full_md_start.replace('Z', '+00:00'))
|
||||
if anchor.tzinfo is None or anchor.utcoffset() is None:
|
||||
raise ValueError('full_md_start must include UTC offset')
|
||||
anchor = anchor.astimezone(timezone.utc)
|
||||
# Raman section155 specifies these groups; neither parity nor ninth-from-parent.
|
||||
direction = 1 if md_sign_idx in (0, 1, 2, 6, 7, 8) else -1
|
||||
offsets = [group + trine for group in range(4) for trine in (0, 4, 8)]
|
||||
try:
|
||||
edges = [(anchor + timedelta(days=full_md_years * year_days * i / 12)).isoformat()
|
||||
for i in range(13)]
|
||||
except OverflowError as exc:
|
||||
raise ValueError('calendar boundary outside supported datetime range') from exc
|
||||
periods = [dict(sign_idx=(md_sign_idx + direction * offset) % 12,
|
||||
sign=SIGNS[(md_sign_idx + direction * offset) % 12],
|
||||
years=full_md_years / 12, start_utc=edges[i], end_utc=edges[i + 1],
|
||||
start_age=full_md_years * i / 12, end_age=full_md_years * (i + 1) / 12)
|
||||
for i, offset in enumerate(offsets)]
|
||||
result = dict(status='parameter_sensitive', variant_profile_id=profile,
|
||||
tradition_profile='bv_raman_studies_in_jaimini_astrology', source=RAMAN_SOURCE,
|
||||
source_locator='section94 pp61-62; Savya groups section155 p127',
|
||||
parent=dict(sign_idx=md_sign_idx, sign=SIGNS[md_sign_idx], years=full_md_years,
|
||||
start_utc=edges[0], end_utc=edges[-1], source=parent_source,
|
||||
profile=parent_profile, status='supplied_confirmed_full_parent'),
|
||||
year_days=year_days, direction=direction, periods=periods,
|
||||
child_periods=dict(level='AD', status='executed', count=12),
|
||||
pratyantardasa=dict(status='blocked', reason='section94_does_not_establish_PD'),
|
||||
limits=['Parent seed, duration and full start supplied, not calculated or independently verified',
|
||||
'No birth-balance clipping; do not supply a residual MD as a full parent',
|
||||
'Fixed year_days is explicit caller convention, not a source date oracle',
|
||||
'Raman AD only; never attach to Raghava Bhatta or PyJHora parents automatically',
|
||||
'No PD, event inference or default customer export'])
|
||||
lines = ['# Trikona — Raman confirmed full MD / AD', '', f'Profile: {profile}',
|
||||
f'Source: {RAMAN_SOURCE} — {result["source_locator"]}', '',
|
||||
'| AD | Years | Start UTC | End UTC |', '| --- | --- | --- | --- |']
|
||||
lines += [f"| {p['sign']} | {p['years']} | {p['start_utc']} | {p['end_utc']} |" for p in periods]
|
||||
lines += ['', *result['limits'], '', '```json', json.dumps(result, ensure_ascii=False, indent=2), '```']
|
||||
return dict(status=result['status'], customer_export_admitted=False,
|
||||
evidence_appendix=[result], exports=dict(markdown='\n'.join(lines),
|
||||
ai_evidence_bundle=deepcopy(result)))
|
||||
|
||||
|
||||
def build_trikona_native_report(*, lagna_sign_idx, seed_sign_idx, seed_source,
|
||||
planet_longitudes, epoch, year_days, profile):
|
||||
if profile != PROFILE:
|
||||
raise ValueError('explicit Raghava Bhatta profile required')
|
||||
if any(type(v) is not int or not 0 <= v < 12 for v in (lagna_sign_idx, seed_sign_idx)):
|
||||
raise ValueError('sign indices must be integers 0..11')
|
||||
if (seed_sign_idx - lagna_sign_idx) % 12 not in (0, 4, 8):
|
||||
raise ValueError('seed must be Lagna, fifth or ninth')
|
||||
if not isinstance(seed_source, str) or not seed_source.strip():
|
||||
raise ValueError('seed_source must explain the supplied strength decision')
|
||||
required = set(SIGN_LORDS.values())
|
||||
if not isinstance(planet_longitudes, dict) or set(planet_longitudes) != required:
|
||||
raise ValueError('exactly seven classical planetary longitudes required; no node co-lords')
|
||||
if any(isinstance(v, bool) or not isinstance(v, (int, float)) or
|
||||
not math.isfinite(v) or not 0 <= v < 360 for v in planet_longitudes.values()):
|
||||
raise ValueError('planetary longitudes must be finite in [0,360)')
|
||||
if isinstance(year_days, bool) or not isinstance(year_days, (int, float)) or not math.isfinite(year_days) or not 300 <= year_days <= 400:
|
||||
raise ValueError('explicit year_days 300..400 required')
|
||||
if not isinstance(epoch, str):
|
||||
raise ValueError('aware ISO epoch required')
|
||||
anchor = datetime.fromisoformat(epoch.replace('Z', '+00:00'))
|
||||
if anchor.tzinfo is None or anchor.utcoffset() is None:
|
||||
raise ValueError('epoch must include UTC offset')
|
||||
anchor = anchor.astimezone(timezone.utc)
|
||||
direction = 1 if seed_sign_idx % 2 == 0 else -1
|
||||
if seed_sign_idx % 3 == 0:
|
||||
offsets = list(range(12))
|
||||
elif seed_sign_idx % 3 == 1:
|
||||
offsets = [5 * i for i in range(12)]
|
||||
else:
|
||||
offsets = [group + trine for group in range(4) for trine in (0, 4, 8)]
|
||||
periods = []
|
||||
age = 0
|
||||
for offset in offsets:
|
||||
sign = (seed_sign_idx + direction * offset) % 12
|
||||
lord = SIGN_LORDS[SIGNS[sign]]
|
||||
lord_sign = int(planet_longitudes[lord] // 30)
|
||||
count_direction = 1 if sign % 2 == 0 else -1
|
||||
count = ((lord_sign - sign) * count_direction) % 12 + 1
|
||||
dignity = _NARAYANA_DIGNITY[lord]
|
||||
adjustment = int(lord_sign in dignity['exalted']) - int(lord_sign in dignity['debilitated'])
|
||||
years = 12 if lord_sign == sign else min(12, count + adjustment)
|
||||
end = age + years
|
||||
try:
|
||||
start_utc = (anchor + timedelta(days=age * year_days)).isoformat()
|
||||
end_utc = (anchor + timedelta(days=end * year_days)).isoformat()
|
||||
except OverflowError as exc:
|
||||
raise ValueError('calendar boundary outside supported datetime range') from exc
|
||||
periods.append(dict(sign_idx=sign, sign=SIGNS[sign], lord=lord,
|
||||
lord_sign_idx=lord_sign, inclusive_count=count, dignity_adjustment=adjustment,
|
||||
years=years, start_age=age, end_age=end, start_utc=start_utc, end_utc=end_utc))
|
||||
age = end
|
||||
result = dict(status='parameter_sensitive', variant_profile_id=PROFILE,
|
||||
tradition_profile='raghava_bhatta_as_presented_by_rangacharya', source=SOURCE,
|
||||
lagna_sign_idx=lagna_sign_idx, seed_sign_idx=seed_sign_idx,
|
||||
seed_selection=dict(status='supplied_not_calculated', source=seed_source),
|
||||
epoch_utc=anchor.isoformat(), year_days=year_days, periods=periods,
|
||||
child_periods=dict(status='blocked', reason='method_specific_AD_PD_rules_not_established'),
|
||||
limits=['Supplied strongest trine; strength selection is not calculated',
|
||||
'Full first MD begins at explicit epoch; no fractional birth balance inferred',
|
||||
'Fixed-day calendar is caller convention, not verified source dates',
|
||||
'First cycle only; no automatic customer export or event certainty'])
|
||||
lines = ['# Trikona — Raghava Bhatta / Rangacharya method 2', '',
|
||||
'Status: parameter_sensitive', f'Source: {SOURCE}', f'Profile: {PROFILE}', '',
|
||||
'| Sign | Years | Start UTC | End UTC |', '| --- | --- | --- | --- |']
|
||||
lines += [f"| {p['sign']} | {p['years']} | {p['start_utc']} | {p['end_utc']} |" for p in periods]
|
||||
lines += ['', *result['limits'], 'AD/PD: blocked — method-specific rules not established',
|
||||
'', '```json', json.dumps(result, ensure_ascii=False, indent=2), '```']
|
||||
return dict(status=result['status'], customer_export_admitted=False,
|
||||
evidence_appendix=[result], exports=dict(markdown='\n'.join(lines), ai_evidence_bundle=deepcopy(result)))
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--request', type=Path, required=True)
|
||||
parser.add_argument('--mode', choices=('method2-md', 'raman-confirmed-md-ad', 'raman-native'), default='method2-md')
|
||||
parser.add_argument('--format', choices=('json', 'markdown'), default='json')
|
||||
args = parser.parse_args()
|
||||
builder = (build_trikona_raman_antardasa_report if args.mode == 'raman-confirmed-md-ad'
|
||||
else build_trikona_native_report)
|
||||
if args.mode == 'raman-native':
|
||||
from scripts.trikona_raman import build_trikona_raman_report
|
||||
builder = build_trikona_raman_report
|
||||
report = builder(**json.loads(args.request.read_text()))
|
||||
print(report['exports']['markdown'] if args.format == 'markdown' else json.dumps(report, ensure_ascii=False, indent=2))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,233 @@
|
||||
"""Raman's numerical Rasi strength and Trikona MD/AD, explicit conventions.
|
||||
|
||||
Studies in Jaimini Astrology sections62-72,79-86,92-94. This is Raman's
|
||||
adaptation, not a universal Jaimini comparator or the Raghava Bhatta method.
|
||||
"""
|
||||
from copy import deepcopy
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import json
|
||||
import math
|
||||
|
||||
from scripts.jaimini import FRIENDSHIP
|
||||
from scripts.narayana_dasha import SIGNS, SIGN_LORDS, _NARAYANA_DIGNITY, _rasi_aspects
|
||||
from scripts.trikona_dasha import RAMAN_AD_PROFILE, RAMAN_SOURCE, build_trikona_raman_antardasa_report
|
||||
|
||||
PROFILE = 'trikona_raman_numeric_seed_md_ad_candidate_v1'
|
||||
STRENGTH_PROFILE = 'raman_studies_62_72_numeric_v1'
|
||||
DIGNITY_PROFILE = 'raman_manual_degree_mt_exaltation_first_v1'
|
||||
CLASSICAL = ('Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn')
|
||||
SAVYA = {0, 1, 2, 6, 7, 8}
|
||||
AMSA = (60, 45, 30, 22.5, 15, 7.5, 3.75)
|
||||
# Raman, A Manual of Hindu Astrology, section29 printed p12. These differ
|
||||
# from the repository Shadbala table; never silently substitute that table.
|
||||
MT = {'Sun': (4, 0, 20), 'Moon': (1, 4, 30), 'Mars': (0, 0, 18),
|
||||
'Mercury': (5, 16, 20), 'Jupiter': (8, 0, 13), 'Venus': (6, 0, 10),
|
||||
'Saturn': (10, 0, 20)}
|
||||
|
||||
|
||||
def _validate_positions(positions):
|
||||
if not isinstance(positions, dict) or set(positions) != set(CLASSICAL) | {'Rahu', 'Ketu'}:
|
||||
raise ValueError('exactly seven classical planets plus Rahu and Ketu required')
|
||||
if any(type(v) not in (int, float) or not math.isfinite(v) or not 0 <= v < 360
|
||||
for v in positions.values()):
|
||||
raise ValueError('longitudes must be finite numbers in [0,360)')
|
||||
if not math.isclose((positions['Rahu'] - positions['Ketu']) % 360, 180, abs_tol=1e-7, rel_tol=0):
|
||||
raise ValueError('Rahu and Ketu must be opposite in the same position profile')
|
||||
|
||||
|
||||
def _dignity(planet, longitude):
|
||||
sign, degree = int(longitude // 30), longitude % 30
|
||||
if sign in _NARAYANA_DIGNITY[planet]['exalted']:
|
||||
return 'exalted', 60
|
||||
if sign in _NARAYANA_DIGNITY[planet]['debilitated']:
|
||||
return 'debilitated', 3.75
|
||||
mt_sign, lo, hi = MT[planet]
|
||||
if sign == mt_sign and lo <= degree < hi:
|
||||
return 'moolatrikona', 45
|
||||
owner = SIGN_LORDS[SIGNS[sign]]
|
||||
if owner == planet:
|
||||
return 'own', 30
|
||||
if owner in FRIENDSHIP[planet]['friend']:
|
||||
return 'friend', 22.5
|
||||
if owner in FRIENDSHIP[planet]['enemy']:
|
||||
return 'enemy', 7.5
|
||||
return 'neutral', 15
|
||||
|
||||
|
||||
def calculate_raman_rasi_strength(*, planet_longitudes, strength_profile,
|
||||
dignity_profile, druk_role_policy):
|
||||
if strength_profile != STRENGTH_PROFILE or dignity_profile != DIGNITY_PROFILE:
|
||||
raise ValueError('explicit Raman strength and dignity profiles required')
|
||||
if druk_role_policy not in ('distinct_planets', 'distinct_roles'):
|
||||
raise ValueError('druk_role_policy must be distinct_planets or distinct_roles')
|
||||
_validate_positions(planet_longitudes)
|
||||
signs = {p: int(v // 30) for p, v in planet_longitudes.items()}
|
||||
degrees = {p: planet_longitudes[p] % 30 for p in CLASSICAL}
|
||||
ranked = sorted(CLASSICAL, key=degrees.get, reverse=True)
|
||||
ties = [[p for p in CLASSICAL if degrees[p] == value] for value in set(degrees.values())]
|
||||
ties = sorted((group for group in ties if len(group) > 1), key=lambda group: degrees[group[0]], reverse=True)
|
||||
result = dict(profile=strength_profile, dignity_profile=dignity_profile,
|
||||
druk_role_policy=druk_role_policy, source=RAMAN_SOURCE, locator='sections62-72',
|
||||
status='blocked' if ties else 'executed', rank_ties=ties, planet_strengths={}, rasi_strengths=[])
|
||||
# Section65 does not specify equal-rank scores. Preserve own-sign strengths
|
||||
# below, but never fabricate a total/rank/Atmakaraka when a degree tie exists.
|
||||
ak = None if ties else ranked[0]
|
||||
result['atmakaraka'] = ak
|
||||
if not ties:
|
||||
for rank, planet in enumerate(ranked):
|
||||
label, dignity = _dignity(planet, planet_longitudes[planet])
|
||||
kendra = (60, 30, 15)[(signs[planet] - signs[ak]) % 3]
|
||||
result['planet_strengths'][planet] = dict(dignity_label=label,
|
||||
moolatrikona_bala=dignity, amsa_bala=AMSA[rank], kendra_bala=kendra,
|
||||
total=dignity + AMSA[rank] + kendra)
|
||||
for sign in range(12):
|
||||
lord = SIGN_LORDS[SIGNS[sign]]
|
||||
role_planets = ['Jupiter', 'Mercury', lord]
|
||||
if druk_role_policy == 'distinct_planets':
|
||||
role_planets = list(dict.fromkeys(role_planets))
|
||||
hits = [p for p in role_planets if signs[p] == sign or _rasi_aspects(signs[p], sign)]
|
||||
occupants = [p for p, position in signs.items() if position == sign]
|
||||
chara = (15, 30, 60)[sign % 3]
|
||||
sthira = 45 + 15 * len(occupants) if occupants else 0
|
||||
own = chara + 60 * len(hits) + sthira
|
||||
special = 60 if ak and signs[ak] == sign else (None if ties else 0)
|
||||
lord_strength = None if ties else result['planet_strengths'][lord]['total']
|
||||
result['rasi_strengths'].append(dict(sign_idx=sign, sign=SIGNS[sign], lord=lord,
|
||||
chara_bala=chara, druk_bala=60 * len(hits), druk_contributors=hits,
|
||||
sthira_bala=sthira, occupants=occupants, own_strength=own,
|
||||
lord_strength=lord_strength, special_strength=special,
|
||||
total=None if ties else own + lord_strength + special))
|
||||
if ties:
|
||||
result['reason'] = 'equal_degree_AMSA_rank_rule_not_established; provide finer positions or a sourced tie profile'
|
||||
return result
|
||||
|
||||
|
||||
def _duration(sign, signs, *, node_dignity_profile):
|
||||
"""Sections79-86, retaining the selected lord and decision trace."""
|
||||
direction = 1 if sign in SAVYA else -1
|
||||
classical = SIGN_LORDS[SIGNS[sign]]
|
||||
lords = [classical] + ({7: ['Ketu'], 10: ['Rahu']}.get(sign, []))
|
||||
base = {p: ((signs[p] - sign) * direction) % 12 or 12 for p in lords}
|
||||
adjustment = {p: (int(signs[p] in _NARAYANA_DIGNITY[p]['exalted']) -
|
||||
int(signs[p] in _NARAYANA_DIGNITY[p]['debilitated']))
|
||||
if p in CLASSICAL else 0 for p in lords}
|
||||
trace = ['section79_savya_count_minus_one']
|
||||
selected = lords[:]
|
||||
if len(lords) == 2:
|
||||
if signs[lords[0]] == signs[lords[1]]:
|
||||
trace.append('section82_same_own' if signs[lords[0]] == sign else 'sections83_84_conjunction')
|
||||
# Conjunction outside own sign explicitly refers to section79 only.
|
||||
years = base[lords[0]]
|
||||
return dict(status='executed', years=years, lords=selected, trace=trace,
|
||||
count_direction=direction, candidates=base, node_dignity_profile=node_dignity_profile)
|
||||
away = [p for p in lords if signs[p] != sign]
|
||||
if len(away) == 1:
|
||||
selected = away
|
||||
trace.append('section85_prefer_lord_away_from_own')
|
||||
else:
|
||||
associates = {p: sum(s == signs[p] for name, s in signs.items() if name != p) for p in lords}
|
||||
selected = [p for p in selected if associates[p] == max(associates.values())]
|
||||
trace.append('section86_associate_count')
|
||||
if len(selected) > 1:
|
||||
modes = {p: signs[p] % 3 for p in selected}
|
||||
selected = [p for p in selected if modes[p] == max(modes.values())]
|
||||
trace.append('section86_dual_fixed_movable')
|
||||
if len(selected) > 1:
|
||||
selected = [p for p in selected if base[p] == max(base[q] for q in selected)]
|
||||
trace.append('section86_larger_span')
|
||||
if classical in selected and adjustment[classical] == -1:
|
||||
return dict(status='blocked', reason='section86_over_debilitated_and_node_exaltation_exception_unresolved',
|
||||
lords=selected, candidates=base, trace=trace)
|
||||
years_by_lord = {p: (12 if signs[p] == sign else base[p] + adjustment[p]) for p in selected}
|
||||
if len(set(years_by_lord.values())) != 1:
|
||||
return dict(status='blocked', reason='equal_colord_rank_with_different_adjusted_years',
|
||||
lords=selected, candidates=years_by_lord, trace=trace)
|
||||
years = next(iter(years_by_lord.values()))
|
||||
return dict(status='executed' if years > 0 else 'blocked', years=years,
|
||||
reason=None if years > 0 else 'nonpositive_adjusted_span_no_clipping_rule',
|
||||
lords=selected, trace=trace, candidates=base, dignity_adjustments=adjustment,
|
||||
count_direction=direction, node_dignity_profile=node_dignity_profile)
|
||||
|
||||
|
||||
def build_trikona_raman_report(*, lagna_sign_idx, planet_longitudes, epoch, year_days,
|
||||
profile, strength_profile, dignity_profile, druk_role_policy, node_dignity_profile):
|
||||
if profile != PROFILE:
|
||||
raise ValueError('explicit Raman native profile required')
|
||||
if type(lagna_sign_idx) is not int or not 0 <= lagna_sign_idx < 12:
|
||||
raise ValueError('lagna_sign_idx must be integer 0..11')
|
||||
if node_dignity_profile != 'unassigned_no_adjustment':
|
||||
raise ValueError('node_dignity_profile must explicitly select unassigned_no_adjustment')
|
||||
if type(year_days) not in (int, float) or not math.isfinite(year_days) or not 300 <= year_days <= 400:
|
||||
raise ValueError('year_days must be finite in 300..400')
|
||||
if not isinstance(epoch, str):
|
||||
raise ValueError('aware ISO epoch required')
|
||||
anchor = datetime.fromisoformat(epoch.replace('Z', '+00:00'))
|
||||
if anchor.tzinfo is None or anchor.utcoffset() is None:
|
||||
raise ValueError('epoch must include UTC offset')
|
||||
anchor = anchor.astimezone(timezone.utc)
|
||||
strength = calculate_raman_rasi_strength(planet_longitudes=planet_longitudes,
|
||||
strength_profile=strength_profile, dignity_profile=dignity_profile, druk_role_policy=druk_role_policy)
|
||||
signs = {p: int(v // 30) for p, v in planet_longitudes.items()}
|
||||
trines = [(lagna_sign_idx + offset) % 12 for offset in (0, 4, 8)]
|
||||
candidates = [strength['rasi_strengths'][s] for s in trines]
|
||||
seeds = [] if strength['status'] == 'blocked' else [r['sign_idx'] for r in candidates
|
||||
if r['total'] == max(c['total'] for c in candidates)]
|
||||
durations = [dict(sign_idx=s, sign=SIGNS[s], **_duration(s, signs,
|
||||
node_dignity_profile=node_dignity_profile)) for s in range(12)]
|
||||
branches = []
|
||||
for seed in seeds:
|
||||
age = 0
|
||||
dated = True
|
||||
periods = []
|
||||
direction = 1 if seed in SAVYA else -1
|
||||
for offset in [group + trine for group in range(4) for trine in (0, 4, 8)]:
|
||||
sign = (seed + direction * offset) % 12
|
||||
row = deepcopy(durations[sign])
|
||||
if row['status'] != 'executed':
|
||||
dated = False
|
||||
if dated:
|
||||
try:
|
||||
start = (anchor + timedelta(days=age * year_days)).isoformat()
|
||||
end = (anchor + timedelta(days=(age + row['years']) * year_days)).isoformat()
|
||||
except OverflowError as exc:
|
||||
raise ValueError('calendar boundary outside supported datetime range') from exc
|
||||
row.update(start_age=age, end_age=age + row['years'], start_utc=start, end_utc=end,
|
||||
calendar_status='calculated_with_caller_fixed_year')
|
||||
child = build_trikona_raman_antardasa_report(md_sign_idx=sign,
|
||||
full_md_years=row['years'], full_md_start=start,
|
||||
parent_source='Native Raman sections79-86/92-93; see duration trace',
|
||||
parent_profile='raman_studies_jaimini_92_93', year_days=year_days, profile=RAMAN_AD_PROFILE)
|
||||
row['antardasas'] = child['evidence_appendix'][0]['periods']
|
||||
# Parent and child formulas can round sub-microsecond floating
|
||||
# days differently; share the exact already-calculated edge.
|
||||
row['antardasas'][-1]['end_utc'] = end
|
||||
age += row['years']
|
||||
else:
|
||||
row.update(calendar_status='blocked_by_unresolved_prior_or_current_duration', antardasas=[])
|
||||
periods.append(row)
|
||||
branches.append(dict(seed_sign_idx=seed, direction=direction,
|
||||
status='parameter_sensitive' if dated else 'partial', periods=periods))
|
||||
result = dict(status='blocked' if not seeds else 'parameter_sensitive', variant_profile_id=profile,
|
||||
tradition_profile='bv_raman_studies_in_jaimini_astrology', source=RAMAN_SOURCE,
|
||||
strength=strength, seed_selection=dict(status='blocked' if not seeds else 'parallel_tie' if len(seeds)>1 else 'calculated',
|
||||
candidates=candidates, selected_signs=seeds), duration_evidence=durations, branches=branches,
|
||||
epoch_utc=anchor.isoformat(), year_days=year_days, node_dignity_profile=node_dignity_profile,
|
||||
pratyantardasa=dict(status='blocked', reason='Raman_section94_does_not_establish_PD'),
|
||||
limits=['Raman numerical adaptation, not universal Jaimini strength',
|
||||
'Druk role deduplication is explicit; source does not resolve duplicate roles',
|
||||
'Degree MT follows Raman Manual section29; exaltation checked first by explicit profile',
|
||||
'Node dignity left unassigned by caller convention, not a universal no-exaltation doctrine',
|
||||
'Full first MD starts at caller epoch; no fractional birth-balance inferred',
|
||||
'Fixed year_days not source-date verified; first cycle only; no customer admission'])
|
||||
lines = ['# Trikona — Raman numerical seed / MD / AD', '', f'Profile: {profile}',
|
||||
f'Source: {RAMAN_SOURCE}', '', '## Strength and seed',
|
||||
'| Trine sign | Strength |', '| --- | --- |']
|
||||
lines += [f"| {r['sign']} | {r['total']} |" for r in candidates]
|
||||
for branch in branches:
|
||||
lines += ['', f"## Seed {SIGNS[branch['seed_sign_idx']]}",
|
||||
'| MD | Years | Start UTC | End UTC |', '| --- | --- | --- | --- |']
|
||||
lines += [f"| {r['sign']} | {r.get('years', 'blocked')} | {r.get('start_utc', 'blocked')} | {r.get('end_utc', 'blocked')} |"
|
||||
for r in branch['periods']]
|
||||
lines += ['', *result['limits'], '', '```json', json.dumps(result, ensure_ascii=False, indent=2), '```']
|
||||
return dict(status=result['status'], customer_export_admitted=False, evidence_appendix=[result],
|
||||
exports=dict(markdown='\n'.join(lines), ai_evidence_bundle=deepcopy(result)))
|
||||
Reference in New Issue
Block a user