O. J. Simpson — A Vedic Nodal Case Study

"""
O. J. Simpson — Vedic (Jyotish) chart computation.

Birth: 9 July 1947, 08:08:00 PST (UTC-8), San Francisco, CA
       (37.7749 N, 122.4194 W).  Rodden AA (Astrodatabank).
California did NOT observe daylight saving time in 1947, so PST = UTC-8.

Outputs:
  D1  (Rasi)        — natal sign positions, ascendant, houses
  D9  (Navamsa)     — marriage / dharma / inner truth
  D10 (Dasamsa)     — career / public action
  D11 (Rudramsa)    — destruction, downfall, death-events
                       (some schools call D11 'Labha-amsa' for gains.
                        Here we use the classical 11-part division;
                        Parashara's Rudramsa is the destructive reading.)
  Vimshottari Mahadasha + Antardasha sequence from birth onward,
  using sidereal Moon (Lahiri ayanamsa).

The script is general — change BIRTH_* constants for any chart.
"""
import swisseph as swe
from datetime import datetime, timedelta, timezone

# ---------------------------------------------------------------------------
# 1. BIRTH DATA  (edit these for any other chart)
# ---------------------------------------------------------------------------
BIRTH_LOCAL    = datetime(1947, 7, 9, 8, 8, 0)     # local clock time
UTC_OFFSET_HRS = -8.0                              # PST in 1947 (no DST)
LAT, LON       = 37.7749, -122.4194                # San Francisco

# Sidereal system: Lahiri (Chitrapaksha), the Indian Govt standard.
swe.set_sid_mode(swe.SIDM_LAHIRI)

# ---------------------------------------------------------------------------
# 2. JULIAN DAY (UT)
# ---------------------------------------------------------------------------
birth_utc = BIRTH_LOCAL - timedelta(hours=UTC_OFFSET_HRS)
JD_UT = swe.julday(birth_utc.year, birth_utc.month, birth_utc.day,
                   birth_utc.hour + birth_utc.minute/60 + birth_utc.second/3600)

# ---------------------------------------------------------------------------
# 3. SIDEREAL PLANET LONGITUDES
# ---------------------------------------------------------------------------
SIGNS = ['Aries','Taurus','Gemini','Cancer','Leo','Virgo',
         'Libra','Scorpio','Sagittarius','Capricorn','Aquarius','Pisces']

PLANETS = {
    'Sun'    : swe.SUN,
    'Moon'   : swe.MOON,
    'Mars'   : swe.MARS,
    'Mercury': swe.MERCURY,
    'Jupiter': swe.JUPITER,
    'Venus'  : swe.VENUS,
    'Saturn' : swe.SATURN,
    'Rahu'   : swe.MEAN_NODE,         # mean north node (classical)
}
FLAGS = swe.FLG_SWIEPH | swe.FLG_SIDEREAL | swe.FLG_SPEED

def sidereal_long(jd, planet_id):
    pos, _ = swe.calc_ut(jd, planet_id, FLAGS)
    return pos[0] % 360

natal = {name: sidereal_long(JD_UT, pid) for name, pid in PLANETS.items()}
# Ketu is exactly opposite Rahu
natal['Ketu'] = (natal['Rahu'] + 180) % 360

# Ascendant (sidereal) — use Placidus and convert
cusps_trop, ascmc_trop = swe.houses(JD_UT, LAT, LON, b'P')
ayan = swe.get_ayanamsa_ut(JD_UT)
ASC = (ascmc_trop[0] - ayan) % 360
MC  = (ascmc_trop[1] - ayan) % 360

natal['Asc'] = ASC

# ---------------------------------------------------------------------------
# 4. HELPERS — sign / nakshatra / divisional charts
# ---------------------------------------------------------------------------
def sign_of(lon):
    return SIGNS[int(lon // 30)]

def deg_in_sign(lon):
    return lon % 30

def fmt(lon):
    s = sign_of(lon)
    d = deg_in_sign(lon)
    deg = int(d); m = (d - deg)*60; mi = int(m); sec = (m-mi)*60
    return f"{deg:02d}°{mi:02d}'{sec:04.1f}\" {s}"

# ---------- D1 (Rasi) — same as natal sign ----------
def d1_sign(lon): return sign_of(lon)

# ---------- D9 (Navamsa) ----------
# Each 30° sign is split into 9 parts of 3°20'.  Starting sign of the
# navamsa cycle depends on the rasi's element:
#   movable (Aries, Cancer, Libra, Capricorn)   -> start from same sign
#   fixed   (Taurus, Leo, Scorpio, Aquarius)    -> start from 9th sign
#   dual    (Gemini, Virgo, Sag, Pisces)        -> start from 5th sign
def d9_sign(lon):
    sign_idx = int(lon // 30)
    pada     = int((lon % 30) // (30/9))         # 0..8
    mode = sign_idx % 3        # 0 movable, 1 fixed, 2 dual
    if   mode == 0: start = sign_idx
    elif mode == 1: start = (sign_idx + 8) % 12
    else:           start = (sign_idx + 4) % 12
    return SIGNS[(start + pada) % 12]

# ---------- D10 (Dasamsa) ----------
# 30° split into 10 parts of 3°.
#   from odd  signs : start from same sign
#   from even signs : start from the 9th sign
def d10_sign(lon):
    sign_idx = int(lon // 30)
    part     = int((lon % 30) // 3)              # 0..9
    if sign_idx % 2 == 0:                         # odd sign (Aries=0 is odd in Jyotish)
        start = sign_idx
    else:                                         # even sign
        start = (sign_idx + 8) % 12
    return SIGNS[(start + part) % 12]

# ---------- D11 (Rudramsa / Labhamsa) ----------
# 30° split into 11 parts of ~2°43.6"
# Per Parashara (BPHS): from any sign count begins from the 11th sign,
# proceeding direct.  (There are competing conventions; this one is the
# most-cited classical rule.)
def d11_sign(lon):
    sign_idx = int(lon // 30)
    part     = int((lon % 30) // (30/11))         # 0..10
    start = (sign_idx + 10) % 12                  # 11th from natal sign
    return SIGNS[(start + part) % 12]

DIVISIONAL = {'D1': d1_sign, 'D9': d9_sign, 'D10': d10_sign, 'D11': d11_sign}

# ---------------------------------------------------------------------------
# 5. NAKSHATRA + VIMSHOTTARI DASHA
# ---------------------------------------------------------------------------
NAKSHATRAS = [
    ('Ashwini',     'Ketu'),     ('Bharani',     'Venus'),
    ('Krittika',    'Sun'),      ('Rohini',      'Moon'),
    ('Mrigashira',  'Mars'),     ('Ardra',       'Rahu'),
    ('Punarvasu',   'Jupiter'),  ('Pushya',      'Saturn'),
    ('Ashlesha',    'Mercury'),  ('Magha',       'Ketu'),
    ('Purva Phalguni','Venus'),  ('Uttara Phalguni','Sun'),
    ('Hasta',       'Moon'),     ('Chitra',      'Mars'),
    ('Swati',       'Rahu'),     ('Vishakha',    'Jupiter'),
    ('Anuradha',    'Saturn'),   ('Jyeshtha',    'Mercury'),
    ('Mula',        'Ketu'),     ('Purva Ashadha','Venus'),
    ('Uttara Ashadha','Sun'),    ('Shravana',    'Moon'),
    ('Dhanishta',   'Mars'),     ('Shatabhisha', 'Rahu'),
    ('Purva Bhadrapada','Jupiter'),('Uttara Bhadrapada','Saturn'),
    ('Revati',      'Mercury'),
]
DASHA_YEARS = {                       # Vimshottari periods (total = 120 y)
    'Ketu':7,    'Venus':20, 'Sun':6,    'Moon':10, 'Mars':7,
    'Rahu':18,   'Jupiter':16,'Saturn':19,'Mercury':17,
}
DASHA_ORDER = ['Ketu','Venus','Sun','Moon','Mars','Rahu','Jupiter','Saturn','Mercury']

NAK_LEN = 360/27          # 13°20' = 13.3333...

def nakshatra_of(lon):
    idx = int(lon // NAK_LEN)
    return idx, NAKSHATRAS[idx]

def vimshottari(birth_dt_utc, moon_lon, horizon_years=130):
    """Yield list of (start_dt, end_dt, MD_lord, AD_lord) covering the
    full life from birth onward."""
    nak_idx, (nak_name, lord) = nakshatra_of(moon_lon)
    # fraction of nakshatra Moon has already traversed
    pos_in_nak = (moon_lon - nak_idx*NAK_LEN) / NAK_LEN
    # time consumed in current MD before birth
    md_total = DASHA_YEARS[lord]
    consumed = pos_in_nak * md_total
    md_remaining = md_total - consumed

    YEAR_DAYS = 365.2425
    sequence = []
    # first MD = current lord, only the remainder
    cur_lord = lord
    cur_start = birth_dt_utc
    cur_end   = cur_start + timedelta(days=md_remaining*YEAR_DAYS)

    # for the first MD we still need antardashas, but only those covering
    # the remaining slice — easier to compute *all* AD positions inside
    # the full natural MD, then clip by birth.
    def antardashas(md_lord, md_full_start, md_years):
        """Yield (ad_start, ad_end, ad_lord) for the natural (uncropped) MD."""
        order = DASHA_ORDER[DASHA_ORDER.index(md_lord):] + DASHA_ORDER[:DASHA_ORDER.index(md_lord)]
        t = md_full_start
        for ad_lord in order:
            ad_years = md_years * DASHA_YEARS[ad_lord] / 120
            ad_end = t + timedelta(days=ad_years*YEAR_DAYS)
            yield t, ad_end, ad_lord
            t = ad_end

    # natural start of the current MD = birth - consumed time
    md_full_start = birth_dt_utc - timedelta(days=consumed*YEAR_DAYS)

    # walk MDs across horizon
    total_years = 0
    md_lord = cur_lord
    md_start_natural = md_full_start
    while total_years < horizon_years:
        md_years = DASHA_YEARS[md_lord]
        md_end_natural = md_start_natural + timedelta(days=md_years*YEAR_DAYS)
        for ad_start, ad_end, ad_lord in antardashas(md_lord, md_start_natural, md_years):
            if ad_end <= birth_dt_utc:
                continue
            ad_start_eff = max(ad_start, birth_dt_utc)
            sequence.append((ad_start_eff, ad_end, md_lord, ad_lord))
        total_years += md_years
        md_start_natural = md_end_natural
        md_lord = DASHA_ORDER[(DASHA_ORDER.index(md_lord)+1) % 9]
    return sequence, nak_name, lord, pos_in_nak

# ---------------------------------------------------------------------------
# 6. PRINT THE NATAL CHART
# ---------------------------------------------------------------------------
print("="*72)
print(f"O. J. SIMPSON — Sidereal (Lahiri) chart")
print(f"Birth: {BIRTH_LOCAL}  PST   (UTC {birth_utc} ; JD {JD_UT:.6f})")
print(f"Place: San Francisco  ({LAT}, {LON})")
print(f"Ayanamsa (Lahiri) = {ayan:.4f}°")
print("="*72)

print(f"\nAscendant: {fmt(ASC)}   (sign lord = ?)")
print(f"Midheaven: {fmt(MC)}\n")

print(f"{'Body':8s} {'Longitude':>22s}   {'D1':12s} {'D9':12s} {'D10':12s} {'D11':12s}")
print("-"*82)
order = ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn','Rahu','Ketu','Asc']
for p in order:
    lon = natal[p]
    print(f"{p:8s} {fmt(lon):>22s}   "
          f"{d1_sign(lon):12s} {d9_sign(lon):12s} "
          f"{d10_sign(lon):12s} {d11_sign(lon):12s}")

# ---------------------------------------------------------------------------
# 7. VIMSHOTTARI DASHA
# ---------------------------------------------------------------------------
seq, nak_name, lord, pos = vimshottari(
    birth_utc.replace(tzinfo=timezone.utc), natal['Moon'], horizon_years=80)

print(f"\nMoon nakshatra: {nak_name}  (lord = {lord}, "
      f"{pos*100:.1f}% traversed at birth)")
print(f"\nVimshottari Mahadasha-Antardasha sequence:")
print(f"{'Start (UTC)':23s} {'End (UTC)':23s}  MD/AD")
print("-"*72)
prev_md = None
for s, e, md, ad in seq:
    tag = f"{md} / {ad}"
    flag = "  <-- new MD" if md != prev_md else ""
    print(f"{s.strftime('%Y-%m-%d %H:%M:%S'):23s} "
          f"{e.strftime('%Y-%m-%d %H:%M:%S'):23s}  {tag}{flag}")
    prev_md = md

"""
Compute Rahu / Ketu sidereal transits at each significant life event of
O. J. Simpson, and report the natal-house each node was transiting,
plus its current sign and aspect to natal points.

Uses Lahiri ayanamsa.  Houses are determined by *whole-sign* count from
the natal Ascendant (the standard Vedic system).
"""
import swisseph as swe
from datetime import datetime, timedelta, timezone

swe.set_sid_mode(swe.SIDM_LAHIRI)
FLAGS = swe.FLG_SWIEPH | swe.FLG_SIDEREAL | swe.FLG_SPEED

SIGNS = ['Aries','Taurus','Gemini','Cancer','Leo','Virgo',
         'Libra','Scorpio','Sagittarius','Capricorn','Aquarius','Pisces']

# ---- Natal data (re-computed for self-containment) ----
BIRTH = datetime(1947, 7, 9, 16, 8, 0, tzinfo=timezone.utc)   # 08:08 PST
LAT, LON = 37.7749, -122.4194
JD0 = swe.julday(BIRTH.year, BIRTH.month, BIRTH.day,
                 BIRTH.hour + BIRTH.minute/60)

def slong(jd, pid):
    return swe.calc_ut(jd, pid, FLAGS)[0][0] % 360

natal = {
    'Sun'    : slong(JD0, swe.SUN),
    'Moon'   : slong(JD0, swe.MOON),
    'Mars'   : slong(JD0, swe.MARS),
    'Mercury': slong(JD0, swe.MERCURY),
    'Jupiter': slong(JD0, swe.JUPITER),
    'Venus'  : slong(JD0, swe.VENUS),
    'Saturn' : slong(JD0, swe.SATURN),
    'Rahu'   : slong(JD0, swe.MEAN_NODE),
}
natal['Ketu'] = (natal['Rahu'] + 180) % 360

ayan = swe.get_ayanamsa_ut(JD0)
cusps_trop, ascmc_trop = swe.houses(JD0, LAT, LON, b'P')
ASC = (ascmc_trop[0] - ayan) % 360
asc_sign = int(ASC // 30)              # Leo = 4
print(f"Natal Ascendant: {ASC:.2f}° ({SIGNS[asc_sign]})")
print(f"Natal Rahu: {natal['Rahu']:.2f}° ({SIGNS[int(natal['Rahu']//30)]})")
print(f"Natal Ketu: {natal['Ketu']:.2f}° ({SIGNS[int(natal['Ketu']//30)]})\n")

def whole_sign_house(lon):
    """Whole-sign Vedic house number 1-12, given a sidereal longitude."""
    sign_idx = int(lon // 30)
    return ((sign_idx - asc_sign) % 12) + 1

# ---- Major life events (UT noon used when only date known) ----
EVENTS = [
    ("1947-07-09", "Birth (San Francisco)"),
    ("1949-07-09", "~Age 2 — diagnosed with rickets, leg braces"),
    ("1960-07-09", "~Age 13 — joins Persian Warriors gang"),
    ("1967-06-24", "Marries Marguerite Whitley"),
    ("1968-12-04", "Wins Heisman Trophy / daughter Arnelle born"),
    ("1969-01-28", "#1 NFL Draft pick — Buffalo Bills"),
    ("1973-12-16", "First NFL player to rush 2,000 yards (final game of season)"),
    ("1977-09-24", "Daughter Aaren born / meets Nicole Brown"),
    ("1978-03-28", "Traded to San Francisco 49ers"),
    ("1979-03-15", "Divorces Marguerite (approx)"),
    ("1979-08-26", "Daughter Aaren dies (drowning)"),
    ("1979-12-16", "Final NFL game — retires"),
    ("1985-02-02", "Marries Nicole Brown"),
    ("1985-08-03", "Inducted into Pro Football Hall of Fame"),
    ("1989-01-01", "First domestic-violence arrest (NYE 1989 incident)"),
    ("1992-02-25", "Nicole files for divorce"),
    ("1992-10-15", "Divorce from Nicole finalized"),
    ("1994-06-12", "Murders of Nicole Brown & Ron Goldman"),
    ("1994-06-17", "White Bronco chase / arrest"),
    ("1995-01-24", "Murder trial begins"),
    ("1995-10-03", "Acquitted of murder charges"),
    ("1997-02-04", "Civil trial — found liable, $33.5M"),
    ("2007-09-13", "Las Vegas hotel-room confrontation"),
    ("2008-10-03", "Convicted of robbery / kidnapping"),
    ("2008-12-05", "Sentenced 9–33 years, sent to Lovelock"),
    ("2013-07-25", "First parole hearing — partial parole granted"),
    ("2017-07-20", "Parole granted (full)"),
    ("2017-10-01", "Released from prison"),
    ("2023-05-01", "Announces undergoing chemotherapy"),
    ("2024-04-10", "Death (prostate cancer, Las Vegas)"),
]

print(f"{'Date':12s} {'Event':50s}  "
      f"{'Rahu':>14s} H  {'Ketu':>14s} H")
print("-"*112)
for date_str, ev in EVENTS:
    dt = datetime.strptime(date_str, "%Y-%m-%d")
    jd = swe.julday(dt.year, dt.month, dt.day, 12.0)
    rahu = slong(jd, swe.MEAN_NODE)
    ketu = (rahu + 180) % 360
    rh = whole_sign_house(rahu)
    kh = whole_sign_house(ketu)
    rsig = SIGNS[int(rahu//30)]
    ksig = SIGNS[int(ketu//30)]
    print(f"{date_str:12s} {ev[:50]:50s}  "
          f"{rahu%30:5.2f}° {rsig:9s} {rh:2d}  "
          f"{ketu%30:5.2f}° {ksig:9s} {kh:2d}")

# Also tag each event with its Vimshottari MD/AD
print("\n\nNow with Vimshottari MD/AD context:\n")

# Re-build the dasha sequence (copied from the main script)
NAKSHATRAS_LORD = ['Ketu','Venus','Sun','Moon','Mars','Rahu','Jupiter','Saturn','Mercury',
                   'Ketu','Venus','Sun','Moon','Mars','Rahu','Jupiter','Saturn','Mercury',
                   'Ketu','Venus','Sun','Moon','Mars','Rahu','Jupiter','Saturn','Mercury']
DASHA_YEARS = {'Ketu':7,'Venus':20,'Sun':6,'Moon':10,'Mars':7,'Rahu':18,'Jupiter':16,'Saturn':19,'Mercury':17}
DASHA_ORDER = ['Ketu','Venus','Sun','Moon','Mars','Rahu','Jupiter','Saturn','Mercury']
NAK_LEN = 360/27
YEAR_DAYS = 365.2425

moon = natal['Moon']
nak_idx = int(moon // NAK_LEN)
lord = NAKSHATRAS_LORD[nak_idx]
pos_in_nak = (moon - nak_idx*NAK_LEN) / NAK_LEN
consumed = pos_in_nak * DASHA_YEARS[lord]

md_full_start = BIRTH - timedelta(days=consumed*YEAR_DAYS)
seq = []  # list of (start, end, MD, AD)
md_lord = lord
md_start = md_full_start
total = 0
while total < 130:
    md_y = DASHA_YEARS[md_lord]
    md_end = md_start + timedelta(days=md_y*YEAR_DAYS)
    order = DASHA_ORDER[DASHA_ORDER.index(md_lord):] + DASHA_ORDER[:DASHA_ORDER.index(md_lord)]
    t = md_start
    for ad_lord in order:
        ad_y = md_y * DASHA_YEARS[ad_lord] / 120
        ad_end = t + timedelta(days=ad_y*YEAR_DAYS)
        seq.append((t, ad_end, md_lord, ad_lord))
        t = ad_end
    total += md_y
    md_start = md_end
    md_lord = DASHA_ORDER[(DASHA_ORDER.index(md_lord)+1) % 9]

def find_dasha(dt):
    dt_aware = dt.replace(tzinfo=timezone.utc)
    for s, e, md, ad in seq:
        if s <= dt_aware < e:
            return md, ad
    return None, None

print(f"{'Date':12s} {'Event':46s}  "
      f"{'Rahu':>16s}  {'Ketu':>16s}  {'MD':8s} {'AD':8s}")
print("-"*120)
for date_str, ev in EVENTS:
    dt = datetime.strptime(date_str, "%Y-%m-%d")
    jd = swe.julday(dt.year, dt.month, dt.day, 12.0)
    rahu = slong(jd, swe.MEAN_NODE)
    ketu = (rahu + 180) % 360
    rh = whole_sign_house(rahu)
    kh = whole_sign_house(ketu)
    rsig = SIGNS[int(rahu//30)]
    ksig = SIGNS[int(ketu//30)]
    md, ad = find_dasha(dt)
    print(f"{date_str:12s} {ev[:46]:46s}  "
          f"{rahu%30:5.2f}°{rsig:9s}H{rh:<2d}  "
          f"{ketu%30:5.2f}°{ksig:9s}H{kh:<2d}  "
          f"{md or '':8s} {ad or '':8s}")