Spaces:
Running
Running
| """ | |
| vedic-calculator v0.5 - PyJHora 精确计算引擎 | |
| 基于 pysweph 天文核心 + PyJHora 精确算法（含 9 项 Shadbala bug 修正） | |
| 输出完整的 structured_data 所需数据 | |
| v0.5: 移除所有 dashaflow fallback（错误结果比无结果更糟），fail-fast | |
| v0.4: Dasha 接入 PyJHora（≤2天） | |
| v0.3: SAV/Shadbala fallback 显式 WARNING | |
| """ | |
| import swisseph as swe | |
| from datetime import datetime, timedelta | |
| import pytz | |
| import json | |
| import sys | |
| from calculation_profile import ( | |
| configure_swe as _profile_configure_swe, | |
| node_planet_id, | |
| profile_meta, | |
| ) | |
| # dashaflow — 仅用于 dignity/jaimini（这些无 PyJHora bug，不需要修正） | |
| from dashaflow.dignity import get_dignity, get_compound_relationship, check_combustion, get_digbala | |
| from dashaflow.jaimini import calculate_jaimini_karakas | |
| # ── PyJHora 精确模块（必须全部加载，否则 fail-fast）── | |
| _SETUP_HINT = ( | |
| "\n╔══════════════════════════════════════════════════════╗\n" | |
| "║ PyJHora 未正确安装！请运行: ║\n" | |
| "║ python vedic-calculator/scripts/setup_env.py ║\n" | |
| "╚══════════════════════════════════════════════════════╝" | |
| ) | |
| _load_errors = [] | |
| try: | |
| from ashtakavarga_pyjhora import calculate_ashtakavarga_fixed as _av_pyjhora | |
| except ImportError as e: | |
| _av_pyjhora = None | |
| _load_errors.append(f'ashtakavarga_pyjhora: {e}') | |
| try: | |
| from shadbala_pyjhora import calculate_shadbala_fixed as _shadbala_pyjhora | |
| except ImportError as e: | |
| _shadbala_pyjhora = None | |
| _load_errors.append(f'shadbala_pyjhora: {e}') | |
| try: | |
| from dasha_pyjhora import calculate_dasha_fixed as _dasha_pyjhora | |
| except ImportError as e: | |
| _dasha_pyjhora = None | |
| _load_errors.append(f'dasha_pyjhora: {e}') | |
| try: | |
| from divisional_pyjhora import calculate_divisional_charts as _div_pyjhora | |
| except ImportError as e: | |
| _div_pyjhora = None | |
| _load_errors.append(f'divisional_pyjhora: {e}') | |
| try: | |
| from extras_pyjhora import ( | |
| calculate_bhava_bala as _bhava_bala_pyjhora, | |
| calculate_special_lagnas as _special_lagnas_pyjhora, | |
| calculate_vargeeya_bala as _vargeeya_bala_pyjhora, | |
| ) | |
| except ImportError as e: | |
| _bhava_bala_pyjhora = None | |
| _special_lagnas_pyjhora = None | |
| _vargeeya_bala_pyjhora = None | |
| _load_errors.append(f'extras_pyjhora: {e}') | |
| # Fail-fast: 核心模块必须全部加载 | |
| _REQUIRED = {'SAV': _av_pyjhora, 'Shadbala': _shadbala_pyjhora, 'Dasha': _dasha_pyjhora} | |
| _missing = [name for name, mod in _REQUIRED.items() if mod is None] | |
| if _missing: | |
| print(f"\n❌ FATAL: 以下核心模块加载失败: {', '.join(_missing)}", file=sys.stderr) | |
| for err in _load_errors: | |
| print(f" → {err}", file=sys.stderr) | |
| print(_SETUP_HINT, file=sys.stderr) | |
| raise ImportError(f"vedic-calculator 核心模块缺失: {', '.join(_missing)}. 请运行 setup_env.py") | |
| # === 配置 === | |
| # ⚠️ swe 是进程级全局状态：PyJHora 模块(SAV/Shadbala/Dasha)每次调用都会把 | |
| # ayanamsa/node 是 pysweph 进程级全局状态。PyJHora wrappers 也会改这些值， | |
| # 所以每次计算前都必须按 calculation_profile 显式重设，避免上一个请求污染 | |
| # lagna、行星、星宿/pada 和 dasha。 | |
| def _configure_swe(calculation_profile=None): | |
| return _profile_configure_swe(calculation_profile) | |
| _configure_swe() | |
| SIGNS = ['Aries','Taurus','Gemini','Cancer','Leo','Virgo', | |
| 'Libra','Scorpio','Sagittarius','Capricorn','Aquarius','Pisces'] | |
| SIGN_ABBR = ['Ar','Ta','Ge','Cn','Le','Vi','Li','Sc','Sg','Cp','Aq','Pi'] | |
| PLANETS_SWE = { | |
| 'Sun': swe.SUN, 'Moon': swe.MOON, 'Mars': swe.MARS, | |
| 'Mercury': swe.MERCURY, 'Jupiter': swe.JUPITER, | |
| 'Venus': swe.VENUS, 'Saturn': swe.SATURN | |
| } | |
| 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' | |
| } | |
| 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'), | |
| ('Moola','Ketu'), ('Purva Ashadha','Venus'), ('Uttara Ashadha','Sun'), | |
| ('Shravana','Moon'), ('Dhanishta','Mars'), ('Shatabhisha','Rahu'), | |
| ('Purva Bhadrapada','Jupiter'), ('Uttara Bhadrapada','Saturn'), ('Revati','Mercury') | |
| ] | |
| DASHA_ORDER = ['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} | |
| HOUSE_DOMAINS = { | |
| 1:'自我', 2:'财富', 3:'兄弟', 4:'家庭', 5:'子女', | |
| 6:'疾病', 7:'婚姻', 8:'变故', 9:'运势', 10:'事业', | |
| 11:'收入', 12:'损耗' | |
| } | |
| # === 核心计算函数 === | |
| def to_jd(year, month, day, hour, minute, tz_str): | |
| tz = pytz.timezone(tz_str) | |
| local_dt = tz.localize(datetime(year, month, day, hour, minute)) | |
| utc_dt = local_dt.astimezone(pytz.utc) | |
| ut_hour = utc_dt.hour + utc_dt.minute/60.0 + utc_dt.second/3600.0 | |
| return swe.julday(utc_dt.year, utc_dt.month, utc_dt.day, ut_hour) | |
| def calc_planet(jd, planet_id): | |
| flags = swe.FLG_SIDEREAL | swe.FLG_SPEED | |
| result = swe.calc_ut(jd, planet_id, flags) | |
| lon = result[0][0] | |
| speed = result[0][3] | |
| sign_idx = int(lon / 30) | |
| degree = lon % 30 | |
| deg_int = int(degree) | |
| min_int = round((degree - deg_int) * 60) | |
| return { | |
| 'longitude': lon, 'sign': SIGNS[sign_idx], 'sign_idx': sign_idx, | |
| 'degree': degree, 'deg_str': f"{deg_int}°{min_int:02d}'", | |
| 'retrograde': speed < 0, 'speed': speed | |
| } | |
| def calc_lagna(jd, lat, lon): | |
| flags = swe.FLG_SIDEREAL | |
| cusps, ascmc = swe.houses_ex(jd, lat, lon, b'W', flags) | |
| asc_lon = ascmc[0] | |
| sign_idx = int(asc_lon / 30) | |
| degree = asc_lon % 30 | |
| deg_int = int(degree) | |
| min_int = round((degree - deg_int) * 60) | |
| return { | |
| 'longitude': asc_lon, 'sign': SIGNS[sign_idx], 'sign_idx': sign_idx, | |
| 'degree': degree, 'deg_str': f"{deg_int}°{min_int:02d}'" | |
| } | |
| def get_nakshatra(longitude): | |
| nak_idx = int(longitude / (360/27)) | |
| pada = int((longitude % (360/27)) / (360/108)) + 1 | |
| name, lord = NAKSHATRAS[nak_idx] | |
| return {'name': name, 'pada': pada, 'lord': lord} | |
| def get_house(planet_sign_idx, lagna_sign_idx): | |
| return ((planet_sign_idx - lagna_sign_idx) % 12) + 1 | |
| def calc_navamsha(longitude): | |
| """D9 Navamsha: each sign divided into 9 parts of 3°20'""" | |
| nav_part = int((longitude % 30) / (30/9)) | |
| sign_idx = int(longitude / 30) | |
| # Navamsha starts from: Fire→Ar, Earth→Cp, Air→Li, Water→Cn | |
| element_start = [0, 9, 6, 3] # Ar, Cp, Li, Cn | |
| element = sign_idx % 4 # 0=fire, 1=earth, 2=air, 3=water | |
| d9_sign_idx = (element_start[element] + nav_part) % 12 | |
| return SIGNS[d9_sign_idx], d9_sign_idx | |
| def calc_dashamsha(longitude): | |
| """D10 Dashamsha: each sign divided into 10 parts of 3° | |
| Odd signs: count from same sign | |
| Even signs: count from 9th sign (= +8 in 0-indexed) | |
| """ | |
| part = int((longitude % 30) / 3) | |
| sign_idx = int(longitude / 30) | |
| if sign_idx % 2 == 0: # Odd signs (Ar, Ge, Le...) | |
| d10_sign_idx = (sign_idx + part) % 12 | |
| else: # Even signs: 9th from sign = +8 (0-indexed) | |
| d10_sign_idx = (sign_idx + part + 8) % 12 | |
| return SIGNS[d10_sign_idx], d10_sign_idx | |
| def calc_chaturthamsha(longitude): | |
| """D4""" | |
| part = int((longitude % 30) / (30/4)) | |
| sign_idx = int(longitude / 30) | |
| d4_sign_idx = (sign_idx + part * 3) % 12 | |
| return SIGNS[d4_sign_idx], d4_sign_idx | |
| def calc_panchamsha(longitude): | |
| """D5 Panchamsha: each sign divided into 5 parts of 6° | |
| BPHS lords: | |
| Odd signs: Mars(Ar), Saturn(Aq), Jupiter(Sg), Mercury(Ge), Venus(Li) | |
| Even signs: Venus(Ta), Mercury(Vi), Jupiter(Pi), Saturn(Cp), Mars(Sc) | |
| """ | |
| part = int((longitude % 30) / 6) | |
| sign_idx = int(longitude / 30) | |
| if sign_idx % 2 == 0: # odd sign (0-indexed even = zodiac odd) | |
| starts = [0, 10, 8, 2, 6] # Ar, Aq, Sg, Ge, Li | |
| else: # even sign | |
| starts = [1, 5, 11, 9, 7] # Ta, Vi, Pi, Cp, Sc | |
| d5_sign_idx = starts[part] if part < 5 else sign_idx | |
| return SIGNS[d5_sign_idx], d5_sign_idx | |
| def calc_chara_karakas_7k8k(planets): | |
| """Calculate both 7K and 8K Chara Karakas""" | |
| # Effective degree = degree in sign (for Rahu: 30 - degree) | |
| karaka_data = [] | |
| for name in ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn']: | |
| karaka_data.append((name, planets[name]['degree'])) | |
| # 7K: sort by degree descending, top 7 | |
| sorted_7k = sorted(karaka_data, key=lambda x: x[1], reverse=True) | |
| karaka_names_7k = ['AK','AmK','BK','MK','PK','GK','DK'] | |
| karakas_7k = [(karaka_names_7k[i], sorted_7k[i][0], sorted_7k[i][1]) | |
| for i in range(7)] | |
| # 8K: add Rahu (30 - degree) | |
| rahu_eff_deg = 30 - planets['Rahu']['degree'] | |
| karaka_data_8k = karaka_data + [('Rahu', rahu_eff_deg)] | |
| sorted_8k = sorted(karaka_data_8k, key=lambda x: x[1], reverse=True) | |
| karaka_names_8k = ['AK','AmK','BK','MK','PiK','PK','GK','DK'] | |
| karakas_8k = [(karaka_names_8k[i], sorted_8k[i][0], sorted_8k[i][1]) | |
| for i in range(8)] | |
| # DK争议: 比较7K的第7位 vs 8K的第7位 | |
| # 目的：检测加入Rahu后，"第7位(配偶指示星位)"是否换了行星 | |
| dk_7k = karakas_7k[6][1] # 7K第7位 | |
| dk_8k = sorted_8k[6][0] # 8K第7位（不是第8位！） | |
| dk_consistent = dk_7k == dk_8k | |
| return { | |
| '7k': karakas_7k, | |
| '8k': karakas_8k, | |
| 'dk_7k': dk_7k, | |
| 'dk_8k': dk_8k, | |
| 'dk_consistent': dk_consistent | |
| } | |
| def calc_aspects(planets): | |
| """Calculate major aspects between planets""" | |
| aspects = [] | |
| planet_names = list(planets.keys()) | |
| for i in range(len(planet_names)): | |
| for j in range(i+1, len(planet_names)): | |
| p1, p2 = planet_names[i], planet_names[j] | |
| lon1, lon2 = planets[p1]['longitude'], planets[p2]['longitude'] | |
| diff = abs(lon1 - lon2) | |
| if diff > 180: diff = 360 - diff | |
| # Check aspect types | |
| aspect_type = None | |
| orb = None | |
| if diff < 10: | |
| aspect_type = '合相' | |
| orb = diff | |
| elif abs(diff - 60) < 8: | |
| aspect_type = '六合(60°)' | |
| orb = abs(diff - 60) | |
| elif abs(diff - 90) < 8: | |
| aspect_type = '刑(90°)' | |
| orb = abs(diff - 90) | |
| elif abs(diff - 120) < 8: | |
| aspect_type = '三合(120°)' | |
| orb = abs(diff - 120) | |
| elif abs(diff - 180) < 10: | |
| aspect_type = '对冲(180°)' | |
| orb = abs(diff - 180) | |
| if aspect_type and orb is not None: | |
| aspects.append({ | |
| 'p1': p1, 'p2': p2, 'type': aspect_type, | |
| 'degree_diff': round(diff, 2), 'orb': round(orb, 2) | |
| }) | |
| # Sort by orb (tighter aspects first) | |
| aspects.sort(key=lambda x: x['orb']) | |
| return aspects[:8] # Top 8 most significant | |
| def calc_house_lords(lagna_sign_idx): | |
| """Calculate house lord table""" | |
| lords = {} | |
| for house in range(1, 13): | |
| sign_idx = (lagna_sign_idx + house - 1) % 12 | |
| lord = SIGN_LORDS[sign_idx] | |
| lords[house] = {'sign': SIGNS[sign_idx], 'lord': lord, 'domain': HOUSE_DOMAINS[house]} | |
| return lords | |
| def calc_vimsottari_dasha(moon_lon, birth_year, birth_month, birth_day, birth_hour, birth_minute): | |
| """Calculate Vimsottari Dasha periods""" | |
| nak = get_nakshatra(moon_lon) | |
| nak_lord = nak['lord'] | |
| start_idx = DASHA_ORDER.index(nak_lord) | |
| nak_span = 360/27 | |
| elapsed_in_nak = moon_lon % nak_span | |
| remaining_fraction = 1 - (elapsed_in_nak / nak_span) | |
| birth_dt = datetime(birth_year, birth_month, birth_day, birth_hour, birth_minute) | |
| dashas = [] | |
| # 第一个大运起始 = 出生日 - 已过大运年数（回溯到出生前） | |
| first_planet_years = DASHA_YEARS[DASHA_ORDER[start_idx]] | |
| elapsed_years = first_planet_years * (1 - remaining_fraction) | |
| current_dt = birth_dt - timedelta(days=elapsed_years * 365.25) | |
| for i in range(9): | |
| idx = (start_idx + i) % 9 | |
| planet = DASHA_ORDER[idx] | |
| years = DASHA_YEARS[planet] | |
| days = years * 365.25 | |
| end_dt = current_dt + timedelta(days=days) | |
| # Mark current | |
| now = datetime.now() | |
| is_current = current_dt <= now <= end_dt | |
| # Antardasha子期计算 | |
| antardashas = [] | |
| ad_start = current_dt | |
| for j in range(9): | |
| ad_idx = (idx + j) % 9 | |
| ad_planet = DASHA_ORDER[ad_idx] | |
| ad_years = years * DASHA_YEARS[ad_planet] / 120 | |
| ad_days = ad_years * 365.25 | |
| ad_end = ad_start + timedelta(days=ad_days) | |
| ad_is_current = ad_start <= now <= ad_end | |
| antardashas.append({ | |
| 'planet': ad_planet, | |
| 'start': ad_start.strftime('%Y-%m-%d'), | |
| 'end': ad_end.strftime('%Y-%m-%d'), | |
| 'is_current': ad_is_current | |
| }) | |
| ad_start = ad_end | |
| dashas.append({ | |
| 'planet': planet, | |
| 'start': current_dt.strftime('%Y-%m'), | |
| 'end': end_dt.strftime('%Y-%m'), | |
| 'years': round(years, 1), | |
| 'is_current': is_current, | |
| 'antardashas': antardashas | |
| }) | |
| current_dt = end_dt | |
| return dashas | |
| def calc_special_points(lagna, planets): | |
| """Calculate AL, UL and other special Jaimini points. | |
| Note: JHora may use different settings (Rahu/Ketu lord rules, dual-sign lords). | |
| Our implementation follows standard BPHS Jaimini method. | |
| """ | |
| lagna_idx = lagna['sign_idx'] | |
| def calc_arudha(house_num, lagna_idx): | |
| """Calculate Arudha Pada for a given house (BPHS standard)""" | |
| sign_idx = (lagna_idx + house_num - 1) % 12 | |
| lord = SIGN_LORDS[sign_idx] | |
| lord_sign_idx = planets[lord]['sign_idx'] | |
| # Count from house sign to lord (1-based: lord in same sign = 1st) | |
| dist = (lord_sign_idx - sign_idx) % 12 | |
| # Arudha = same distance from lord's position | |
| arudha_idx = (lord_sign_idx + dist) % 12 | |
| # BPHS Exception: arudha cannot be in 1st or 7th from house sign | |
| # If 1st → use 10th from house sign | |
| # If 7th → use 4th from house sign | |
| if arudha_idx == sign_idx: | |
| arudha_idx = (sign_idx + 9) % 12 # 10th from house sign | |
| elif arudha_idx == (sign_idx + 6) % 12: | |
| arudha_idx = (sign_idx + 3) % 12 # 4th from house sign | |
| return SIGNS[arudha_idx], arudha_idx | |
| al_sign, al_idx = calc_arudha(1, lagna_idx) | |
| al_house = get_house(al_idx, lagna_idx) | |
| ul_sign, ul_idx = calc_arudha(12, lagna_idx) | |
| ul_house = get_house(ul_idx, lagna_idx) | |
| return { | |
| 'AL': {'sign': al_sign, 'sign_idx': al_idx, 'house': al_house}, | |
| 'UL': {'sign': ul_sign, 'sign_idx': ul_idx, 'house': ul_house}, | |
| } | |
| def calc_transits(lagna_sign_idx, moon_sign_idx, calculation_profile=None): | |
| """Calculate current transit positions for slow planets. | |
| Used by core-pro for Sade Sati, BAV transit calibration, double transit. | |
| """ | |
| now = datetime.utcnow() # swe.julday expects UT, not server-local time | |
| jd_now = swe.julday(now.year, now.month, now.day, now.hour + now.minute/60) | |
| profile = _configure_swe(calculation_profile) | |
| flags = swe.FLG_SIDEREAL | swe.FLG_SPEED | |
| transits = {} | |
| # Slow planets: Saturn, Jupiter, Rahu, Ketu | |
| slow_planets = {'Saturn': swe.SATURN, 'Jupiter': swe.JUPITER} | |
| for name, pid in slow_planets.items(): | |
| result = swe.calc_ut(jd_now, pid, flags) | |
| lon = result[0][0] | |
| sign_idx = int(lon / 30) | |
| house = get_house(sign_idx, lagna_sign_idx) | |
| transits[name] = {'sign': SIGNS[sign_idx], 'sign_idx': sign_idx, 'house': house} | |
| result = swe.calc_ut(jd_now, node_planet_id(profile['id']), flags) | |
| rahu_lon = result[0][0] | |
| rahu_idx = int(rahu_lon / 30) | |
| transits['Rahu'] = {'sign': SIGNS[rahu_idx], 'sign_idx': rahu_idx, | |
| 'house': get_house(rahu_idx, lagna_sign_idx)} | |
| ketu_idx = (rahu_idx + 6) % 12 | |
| transits['Ketu'] = {'sign': SIGNS[ketu_idx], 'sign_idx': ketu_idx, | |
| 'house': get_house(ketu_idx, lagna_sign_idx)} | |
| # Sade Sati check | |
| saturn_idx = transits['Saturn']['sign_idx'] | |
| sade_sati = 'inactive' | |
| if saturn_idx == (moon_sign_idx - 1) % 12: | |
| sade_sati = 'phase1_rising' | |
| elif saturn_idx == moon_sign_idx: | |
| sade_sati = 'phase2_peak' | |
| elif saturn_idx == (moon_sign_idx + 1) % 12: | |
| sade_sati = 'phase3_fading' | |
| transits['sade_sati'] = sade_sati | |
| # Double transit (Saturn-Jupiter intersection) | |
| sat_houses = {transits['Saturn']['house']} | |
| # Saturn aspects: 3rd, 7th, 10th | |
| sat_h = transits['Saturn']['house'] | |
| for asp in [3, 7, 10]: | |
| sat_houses.add(((sat_h - 1 + asp - 1) % 12) + 1) | |
| jup_houses = {transits['Jupiter']['house']} | |
| # Jupiter aspects: 5th, 7th, 9th | |
| jup_h = transits['Jupiter']['house'] | |
| for asp in [5, 7, 9]: | |
| jup_houses.add(((jup_h - 1 + asp - 1) % 12) + 1) | |
| double_transit = sorted(sat_houses & jup_houses) | |
| transits['double_transit_houses'] = double_transit | |
| transits['timestamp'] = now.strftime('%Y-%m-%d') | |
| return transits | |
| # 各行星的额外全相位（除所有行星都有的第7位外）；whole-sign | |
| _SPECIAL_DRISHTI = {'Mars': [4, 8], 'Jupiter': [5, 9], 'Saturn': [3, 10]} | |
| def calc_graha_drishti(planets, lagna_sign_idx): | |
| """经典吠陀相位 (graha drishti, whole-sign)：所有行星看第7位； | |
| 火星另看4/8、木星5/9、土星3/10。与 calc_aspects（西式度数相位）互补—— | |
| 格局审计查"凶星压制/吉星扶持"必须用这个，不是西式相位。 | |
| 只算七正曜（Rahu/Ketu 的 drishti 各派有争议，不输出免得误导）。 | |
| """ | |
| drishti = {} | |
| for name in ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn']: | |
| p_sign = planets[name]['sign_idx'] | |
| offsets = [7] + _SPECIAL_DRISHTI.get(name, []) | |
| aspected_signs = [(p_sign + off - 1) % 12 for off in offsets] | |
| aspects_houses = sorted(get_house(s, lagna_sign_idx) for s in aspected_signs) | |
| aspects_planets = sorted( | |
| other for other in planets | |
| if other != name and planets[other]['sign_idx'] in aspected_signs | |
| ) | |
| drishti[name] = {'houses': aspects_houses, 'planets': aspects_planets} | |
| return drishti | |
| def calc_transit_timeline(lagna_sign_idx, moon_sign_idx, years=5, calculation_profile=None): | |
| """未来 N 年土星/木星过运时间线（按月采样，合并成段）。 | |
| 动态预测的弹药：四色时间线、Sade Sati 阶段、双过运节点都从这里拿精确年月， | |
| 不再靠 AI 凭训练数据猜星历。whole-sign，标注到月。 | |
| """ | |
| _configure_swe(calculation_profile) | |
| flags = swe.FLG_SIDEREAL | |
| now = datetime.utcnow() | |
| samples = [] # (yyyy_mm, sat_sign_idx, jup_sign_idx) | |
| for m in range(years * 12 + 1): | |
| y = now.year + (now.month - 1 + m) // 12 | |
| mo = (now.month - 1 + m) % 12 + 1 | |
| jd = swe.julday(y, mo, 15, 0) # mid-month sample | |
| sat_idx = int(swe.calc_ut(jd, swe.SATURN, flags)[0][0] / 30) | |
| jup_idx = int(swe.calc_ut(jd, swe.JUPITER, flags)[0][0] / 30) | |
| samples.append((f"{y:04d}-{mo:02d}", sat_idx, jup_idx)) | |
| def _segments(idx_of): | |
| segs = [] | |
| for ym, sat, jup in samples: | |
| sign_idx = idx_of(sat, jup) | |
| if segs and segs[-1]['sign_idx'] == sign_idx: | |
| segs[-1]['end'] = ym | |
| else: | |
| segs.append({'sign_idx': sign_idx, 'sign': SIGNS[sign_idx], | |
| 'house': get_house(sign_idx, lagna_sign_idx), | |
| 'start': ym, 'end': ym}) | |
| return segs | |
| saturn_segments = _segments(lambda s, j: s) | |
| jupiter_segments = _segments(lambda s, j: j) | |
| # Sade Sati 阶段窗口（土星过月亮的12/1/2位） | |
| _PHASES = {-1: 'phase1_rising', 0: 'phase2_peak', 1: 'phase3_fading'} | |
| sade_sati_windows = [] | |
| for seg in saturn_segments: | |
| for off, phase in _PHASES.items(): | |
| if seg['sign_idx'] == (moon_sign_idx + off) % 12: | |
| sade_sati_windows.append({'phase': phase, 'start': seg['start'], 'end': seg['end']}) | |
| # 双过运窗口：土(本位+3/7/10相)与木(本位+5/7/9相)同时激活的宫位，按月合并 | |
| def _houses_hit(sign_idx, extra_offsets): | |
| h = get_house(sign_idx, lagna_sign_idx) | |
| hit = {h} | |
| for asp in extra_offsets: | |
| hit.add(((h - 1 + asp - 1) % 12) + 1) | |
| return hit | |
| double_transit_windows = [] | |
| for ym, sat, jup in samples: | |
| overlap = sorted(_houses_hit(sat, [3, 7, 10]) & _houses_hit(jup, [5, 7, 9])) | |
| if double_transit_windows and double_transit_windows[-1]['houses'] == overlap: | |
| double_transit_windows[-1]['end'] = ym | |
| else: | |
| double_transit_windows.append({'houses': overlap, 'start': ym, 'end': ym}) | |
| return { | |
| 'saturn_segments': saturn_segments, | |
| 'jupiter_segments': jupiter_segments, | |
| 'sade_sati_windows': sade_sati_windows, | |
| 'double_transit_windows': double_transit_windows, | |
| 'sampled': f"monthly x {years}y from {samples[0][0]}", | |
| } | |
| # === 主计算函数 === | |
| def calculate_full_chart(year, month, day, hour, minute, lat, lon, tz_str="Asia/Kolkata", | |
| calculation_profile=None): | |
| """计算完整星盘数据""" | |
| profile = _configure_swe(calculation_profile) # 必须每次重设：上个请求的 PyJHora 调用会改全局 swe 状态 | |
| jd = to_jd(year, month, day, hour, minute, tz_str) | |
| ayanamsa = swe.get_ayanamsa_ut(jd) | |
| # 1. Lagna | |
| lagna = calc_lagna(jd, lat, lon) | |
| lagna['nakshatra'] = get_nakshatra(lagna['longitude']) | |
| lagna['house'] = 1 | |
| # 2. Planets (7 main) | |
| planets = {} | |
| for name, pid in PLANETS_SWE.items(): | |
| p = calc_planet(jd, pid) | |
| p['house'] = get_house(p['sign_idx'], lagna['sign_idx']) | |
| p['nakshatra'] = get_nakshatra(p['longitude']) | |
| planets[name] = p | |
| # 3. Rahu & Ketu | |
| flags = swe.FLG_SIDEREAL | swe.FLG_SPEED | |
| result = swe.calc_ut(jd, node_planet_id(profile['id']), flags) | |
| rahu_lon = result[0][0] | |
| rahu_sign_idx = int(rahu_lon / 30) | |
| rahu_deg = rahu_lon % 30 | |
| planets['Rahu'] = { | |
| 'longitude': rahu_lon, 'sign': SIGNS[rahu_sign_idx], | |
| 'sign_idx': rahu_sign_idx, 'degree': rahu_deg, | |
| 'deg_str': f"{int(rahu_deg)}°{round((rahu_deg%1)*60):02d}'", | |
| 'retrograde': True, 'speed': result[0][3], | |
| 'house': get_house(rahu_sign_idx, lagna['sign_idx']), | |
| 'nakshatra': get_nakshatra(rahu_lon) | |
| } | |
| ketu_lon = (rahu_lon + 180) % 360 | |
| ketu_sign_idx = int(ketu_lon / 30) | |
| ketu_deg = ketu_lon % 30 | |
| planets['Ketu'] = { | |
| 'longitude': ketu_lon, 'sign': SIGNS[ketu_sign_idx], | |
| 'sign_idx': ketu_sign_idx, 'degree': ketu_deg, | |
| 'deg_str': f"{int(ketu_deg)}°{round((ketu_deg%1)*60):02d}'", | |
| 'retrograde': True, 'speed': -result[0][3], | |
| 'house': get_house(ketu_sign_idx, lagna['sign_idx']), | |
| 'nakshatra': get_nakshatra(ketu_lon) | |
| } | |
| # 4. SAV/BAV (PyJHora — no fallback) | |
| tz = pytz.timezone(tz_str) | |
| _tz_dt = tz.localize(datetime(year, month, day, hour, minute)) | |
| _tz_offset = _tz_dt.utcoffset().total_seconds() / 3600.0 | |
| ashtak = _av_pyjhora(year, month, day, hour, minute, lat, lon, _tz_offset, profile['id']) | |
| # Map SAV to houses | |
| sav_by_house = {} | |
| for h in range(1, 13): | |
| sign_idx = (lagna['sign_idx'] + h - 1) % 12 | |
| sign_name = SIGNS[sign_idx] | |
| sav_by_house[h] = {'sign': sign_name, 'value': ashtak['sarvashtakavarga'].get(sign_name, 0)} | |
| # 5. Divisional charts (PyJHora: 15 charts) | |
| if _div_pyjhora is not None: | |
| divisional_charts = _div_pyjhora( | |
| year, month, day, hour, minute, lat, lon, _tz_offset, | |
| calculation_profile=profile['id'], | |
| ) | |
| else: | |
| divisional_charts = {} | |
| # Extract d9/d10/d4/d5 in legacy (sign_name, sign_idx) format for backward compat | |
| if divisional_charts: | |
| def _legacy_fmt(chart_key): | |
| ch = divisional_charts.get(chart_key, {}) | |
| return {p: (ch[p]['sign'], ch[p]['sign_idx']) for p in ch if 'error' not in ch} | |
| d9 = _legacy_fmt('D9') | |
| d10 = _legacy_fmt('D10') | |
| d4 = _legacy_fmt('D4') | |
| d5 = _legacy_fmt('D5') | |
| else: | |
| d9, d10, d4, d5 = {}, {}, {}, {} | |
| # Vargottama check | |
| vargottama = {} | |
| for name in planets: | |
| d9_sign = d9.get(name, (None, None)) | |
| d9_sign_name = d9_sign[0] if isinstance(d9_sign, tuple) else d9_sign.get('sign', None) if isinstance(d9_sign, dict) else None | |
| vargottama[name] = planets[name]['sign'] == d9_sign_name | |
| # 6. Dignity & Compound Relationship (自建，不依赖dashaflow) | |
| # BPHS Panchadha Maitri 算法 | |
| # Step 1: 旺/入庙/陷检测 | |
| EXALTATION = {'Sun':'Aries','Moon':'Taurus','Mars':'Capricorn', | |
| 'Mercury':'Virgo','Jupiter':'Cancer','Venus':'Pisces','Saturn':'Libra'} | |
| DEBILITATION = {'Sun':'Libra','Moon':'Scorpio','Mars':'Cancer', | |
| 'Mercury':'Pisces','Jupiter':'Capricorn','Venus':'Virgo','Saturn':'Aries'} | |
| OWN_SIGNS = {'Sun':['Leo'],'Moon':['Cancer'],'Mars':['Aries','Scorpio'], | |
| 'Mercury':['Gemini','Virgo'],'Jupiter':['Sagittarius','Pisces'], | |
| 'Venus':['Taurus','Libra'],'Saturn':['Capricorn','Aquarius']} | |
| # Step 2: 自然关系表 (Naisargika Maitri) - BPHS标准 | |
| NATURAL_REL = { | |
| 'Sun': {'friend':['Moon','Mars','Jupiter'], 'enemy':['Venus','Saturn'], 'neutral':['Mercury']}, | |
| 'Moon': {'friend':['Sun','Mercury'], 'enemy':[], 'neutral':['Mars','Jupiter','Venus','Saturn']}, | |
| 'Mars': {'friend':['Sun','Moon','Jupiter'], 'enemy':['Mercury'], 'neutral':['Venus','Saturn']}, | |
| 'Mercury': {'friend':['Sun','Venus'], 'enemy':['Moon'], 'neutral':['Mars','Jupiter','Saturn']}, | |
| 'Jupiter': {'friend':['Sun','Moon','Mars'], 'enemy':['Mercury','Venus'], 'neutral':['Saturn']}, | |
| 'Venus': {'friend':['Mercury','Saturn'], 'enemy':['Sun','Moon'], 'neutral':['Mars','Jupiter']}, | |
| 'Saturn': {'friend':['Mercury','Venus'], 'enemy':['Sun','Moon','Mars'], 'neutral':['Jupiter']}, | |
| } | |
| def get_natural_rel(planet, lord): | |
| """查自然关系: friend/enemy/neutral""" | |
| if planet == lord: | |
| return 'own' | |
| rel = NATURAL_REL.get(planet, {}) | |
| if lord in rel.get('friend', []): return 'friend' | |
| if lord in rel.get('enemy', []): return 'enemy' | |
| return 'neutral' | |
| def get_temporal_rel(planet_sign_idx, lord_sign_idx): | |
| """查临时关系: 座主落在行星的2/3/4/10/11/12宫=临时友""" | |
| dist = (lord_sign_idx - planet_sign_idx) % 12 | |
| # 距离2,3,4,10,11,12宫 = dist值1,2,3,9,10,11 (0-indexed) | |
| return 'temp_friend' if dist in {1,2,3,9,10,11} else 'temp_enemy' | |
| # Step 4: Panchadha合成表 | |
| COMPOUND_TABLE = { | |
| ('friend', 'temp_friend'): 'great_friend', | |
| ('friend', 'temp_enemy'): 'neutral', | |
| ('enemy', 'temp_friend'): 'neutral', | |
| ('enemy', 'temp_enemy'): 'great_enemy', | |
| ('neutral','temp_friend'): 'friend', | |
| ('neutral','temp_enemy'): 'enemy', | |
| } | |
| dignity_data = {} | |
| for name in ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn']: | |
| p = planets[name] | |
| sign = p['sign'] | |
| lord = SIGN_LORDS[p['sign_idx']] | |
| # Step 1: 旺/入庙/陷直接确定 | |
| if EXALTATION.get(name) == sign: | |
| compound = 'exalted' | |
| elif DEBILITATION.get(name) == sign: | |
| compound = 'debilitated' | |
| elif sign in OWN_SIGNS.get(name, []): | |
| compound = 'own_sign' | |
| else: | |
| # Step 2+3+4: 自然+临时→合成 | |
| natural = get_natural_rel(name, lord) | |
| if natural == 'own': | |
| compound = 'own_sign' | |
| else: | |
| # 找座主的实际位置 | |
| lord_sign_idx = planets[lord]['sign_idx'] if lord in planets else p['sign_idx'] | |
| temporal = get_temporal_rel(p['sign_idx'], lord_sign_idx) | |
| compound = COMPOUND_TABLE.get((natural, temporal), 'neutral') | |
| dignity_data[name] = {'basic': compound, 'compound': compound} | |
| # 7. Combustion check | |
| sun_lon = planets['Sun']['longitude'] | |
| combustion = {} | |
| for name in ['Moon','Mars','Mercury','Jupiter','Venus','Saturn']: | |
| is_retro = planets[name]['retrograde'] | |
| comb_result = check_combustion(name, planets[name]['longitude'], sun_lon, is_retro) | |
| is_combust = comb_result if isinstance(comb_result, bool) else comb_result.get('is_combust', False) | |
| if is_combust: | |
| diff = abs(planets[name]['longitude'] - sun_lon) | |
| if diff > 180: diff = 360 - diff | |
| combustion[name] = {'distance': round(diff, 2)} | |
| # 8. Chara Karakas | |
| karakas = calc_chara_karakas_7k8k(planets) | |
| # 9. Aspects | |
| aspects = calc_aspects(planets) | |
| # 10. House lords | |
| house_lords = calc_house_lords(lagna['sign_idx']) | |
| # Add planet positions to house lords | |
| for h, info in house_lords.items(): | |
| planet = info['lord'] | |
| if planet in planets: | |
| info['lord_house'] = planets[planet]['house'] | |
| # 11. Vimsottari Dasha (PyJHora — no fallback) | |
| dashas = _dasha_pyjhora(year, month, day, hour, minute, lat, lon, _tz_offset, profile['id']) | |
| # 12. Shadbala (PyJHora + 9 bug fixes — no fallback) | |
| shadbala_data = _shadbala_pyjhora( | |
| year, month, day, hour, minute, lat, lon, _tz_offset, profile['id'] | |
| ) | |
| # 13. Moon phase | |
| moon_sun_diff = (planets['Moon']['longitude'] - planets['Sun']['longitude']) % 360 | |
| is_waxing = moon_sun_diff < 180 | |
| # 14. Digbala | |
| digbala = {} | |
| for name in ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn']: | |
| digbala[name] = get_digbala(name, planets[name]['house']) | |
| # 15. Special Points (AL, UL) | |
| special_points = calc_special_points(lagna, planets) | |
| # 16. Transit positions (current slow planet positions) | |
| transits = calc_transits(lagna['sign_idx'], planets['Moon']['sign_idx'], profile['id']) | |
| # 16b. Graha drishti (吠陀相位) + 未来5年过运时间线 (动态预测弹药) | |
| graha_drishti = calc_graha_drishti(planets, lagna['sign_idx']) | |
| transit_timeline = calc_transit_timeline(lagna['sign_idx'], planets['Moon']['sign_idx'], calculation_profile=profile['id']) | |
| # 17. Bhava Bala, Special Lagnas, Vargeeya Bala (via PyJHora) | |
| bhava_bala = None | |
| special_lagnas = None | |
| vargeeya_bala = None | |
| if any([_bhava_bala_pyjhora, _special_lagnas_pyjhora, _vargeeya_bala_pyjhora]): | |
| try: | |
| tz = pytz.timezone(tz_str) | |
| _tz_dt = tz.localize(datetime(year, month, day, hour, minute)) | |
| _tz_offset = _tz_dt.utcoffset().total_seconds() / 3600.0 | |
| if _bhava_bala_pyjhora: | |
| bhava_bala = _bhava_bala_pyjhora(year, month, day, hour, minute, lat, lon, _tz_offset, profile['id']) | |
| if _special_lagnas_pyjhora: | |
| special_lagnas = _special_lagnas_pyjhora(year, month, day, hour, minute, lat, lon, _tz_offset, profile['id']) | |
| if _vargeeya_bala_pyjhora: | |
| vargeeya_bala = _vargeeya_bala_pyjhora(year, month, day, hour, minute, lat, lon, _tz_offset, profile['id']) | |
| except Exception: | |
| pass | |
| return { | |
| 'calculation_profile': profile_meta(profile['id']), | |
| 'ayanamsa': ayanamsa, | |
| 'lagna': lagna, | |
| 'planets': planets, | |
| 'sav': ashtak['sarvashtakavarga'], | |
| 'sav_by_house': sav_by_house, | |
| 'bav': ashtak['bhinnashtakavarga'], | |
| 'd9': d9, 'd10': d10, 'd4': d4, 'd5': d5, | |
| 'divisional_charts': divisional_charts, | |
| 'vargottama': vargottama, | |
| 'dignity': dignity_data, | |
| 'combustion': combustion, | |
| 'karakas': karakas, | |
| 'aspects': aspects, | |
| 'house_lords': house_lords, | |
| 'dashas': dashas, | |
| 'shadbala': shadbala_data, | |
| 'moon_phase': {'waxing': is_waxing, 'sun_moon_diff': round(moon_sun_diff, 1)}, | |
| 'digbala': digbala, | |
| 'special_points': special_points, | |
| 'transits': transits, | |
| 'graha_drishti': graha_drishti, | |
| 'transit_timeline': transit_timeline, | |
| 'bhava_bala': bhava_bala, | |
| 'special_lagnas': special_lagnas, | |
| 'vargeeya_bala': vargeeya_bala, | |
| } | |
| # === TEST === | |
| if __name__ == '__main__': | |
| print("=== vedic-calculator v0.2 Full Test ===\n") | |
| # Gandhi: 1869-10-02, 07:12, Porbandar | |
| chart = calculate_full_chart(1869, 10, 2, 7, 12, 21.6417, 69.6293, "Asia/Kolkata") | |
| print(f"Ayanamsa (Lahiri): {chart['ayanamsa']:.4f}°") | |
| print(f"Lagna: {chart['lagna']['sign']} {chart['lagna']['deg_str']}") | |
| print(f"\n--- Planets ---") | |
| print(f" {'Planet':<10} {'Sign':<12} {'Deg':>8} {'H':>3} {'R':>2} {'Dignity':<16} {'Compound'}") | |
| for name in ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn','Rahu','Ketu']: | |
| p = chart['planets'][name] | |
| r = 'R' if p['retrograde'] else '' | |
| dig = chart['dignity'].get(name, {}) | |
| basic = dig.get('basic', '-') | |
| compound = dig.get('compound', '-') | |
| print(f" {name:<10} {p['sign']:<12} {p['deg_str']:>8} {p['house']:>3} {r:>2} {str(basic):<16} {compound}") | |
| print(f"\n--- SAV by House ---") | |
| total = 0 | |
| for h in range(1, 13): | |
| s = chart['sav_by_house'][h] | |
| total += s['value'] | |
| print(f" {h}宫({s['sign'][:2]}): {s['value']}", end=' ') | |
| if h % 6 == 0: print() | |
| print(f" Total: {total}") | |
| print(f"\n--- Chara Karakas (7K) ---") | |
| for k, planet, deg in chart['karakas']['7k']: | |
| print(f" {k}: {planet} ({deg:.1f}°)") | |
| print(f" DK争议: 7K={chart['karakas']['dk_7k']}, 8K={chart['karakas']['dk_8k']}, 一致={chart['karakas']['dk_consistent']}") | |
| print(f"\n--- Aspects (top 5) ---") | |
| for a in chart['aspects'][:5]: | |
| print(f" {a['p1']}-{a['p2']}: {a['type']} ({a['degree_diff']}°, orb {a['orb']}°)") | |
| print(f"\n--- Dasha ---") | |
| for d in chart['dashas']: | |
| marker = '→' if d['is_current'] else ' ' | |
| print(f" {marker} {d['planet']:<10} {d['start']} ~ {d['end']} ({d['years']}yr)") | |
| print(f"\n--- D9 Navamsha ---") | |
| for name in ['Lagna','Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn','Rahu','Ketu']: | |
| sign = chart['d9'][name][0] | |
| varg = ' ★V' if chart['vargottama'].get(name, False) else '' | |
| print(f" {name:<10} → {sign}{varg}") | |
| print(f"\n--- Shadbala ---") | |
| if 'error' in chart['shadbala']: | |
| print(f" Error: {chart['shadbala']['error']}") | |
| else: | |
| for name, data in chart['shadbala'].items(): | |
| if isinstance(data, dict): | |
| total = data.get('total_rupas', data.get('total', '?')) | |
| print(f" {name:<10} {total}") | |
| print(f"\n--- Moon Phase ---") | |
| phase = chart['moon_phase'] | |
| print(f" {'盈月(Shukla)' if phase['waxing'] else '亏月(Krishna)'}, 距Sun {phase['sun_moon_diff']}°") | |
| print(f"\n--- Combustion ---") | |
| if chart['combustion']: | |
| for name, data in chart['combustion'].items(): | |
| print(f" {name}: {data}") | |
| else: | |
| print(" 无燃烧行星") | |
| print(f"\n--- House Lords ---") | |
| for h in range(1, 13): | |
| info = chart['house_lords'][h] | |
| print(f" {h}宫({info['domain']}): {info['lord']} → {info.get('lord_house','?')}宫") | |
| print(f"\n✅ 全部14个数据板块计算完成!") | |