732642856
1544 lines
60 KiB
Python
1544 lines
60 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
Tajika/Varshaphala年运盘模块 v1.0
|
||
太阳返照盘分析系统
|
||
|
||
支持:
|
||
- Muntha（年度上升点移动）
|
||
- Varshaphala计算（太阳回到出生位置时的星盘）
|
||
- Mudda Dasha（年度大运）
|
||
- Tajika Yoga（年度特殊格局）
|
||
- Tri-Pataka（三旗系统）
|
||
-年度Lord（Year Lord）
|
||
"""
|
||
from typing import Dict, List, Optional
|
||
from datetime import datetime
|
||
import math
|
||
import json
|
||
import os
|
||
|
||
SIGNS = ['Aries','Taurus','Gemini','Cancer','Leo','Virgo',
|
||
'Libra','Scorpio','Sagittarius','Capricorn','Aquarius','Pisces']
|
||
SIGN_LORDS = {'Aries':'Mars','Taurus':'Venus','Gemini':'Mercury','Cancer':'Moon',
|
||
'Leo':'Sun','Virgo':'Mercury','Libra':'Venus','Scorpio':'Mars',
|
||
'Sagittarius':'Jupiter','Capricorn':'Saturn','Aquarius':'Saturn','Pisces':'Jupiter'}
|
||
CLASSICAL_PLANETS = ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn']
|
||
BENEFICS = {'Moon', 'Mercury', 'Jupiter', 'Venus'}
|
||
MALEFICS = {'Sun', 'Mars', 'Saturn'}
|
||
EXALT_SIGN = {'Sun': 0, 'Moon': 1, 'Mars': 9, 'Mercury': 5, 'Jupiter': 3, 'Venus': 11, 'Saturn': 6}
|
||
DEBIL_SIGN = {'Sun': 6, 'Moon': 7, 'Mars': 3, 'Mercury': 11, 'Jupiter': 9, 'Venus': 5, 'Saturn': 0}
|
||
OWN_SIGNS = {'Sun': [4], 'Moon': [3], 'Mars': [0, 7], 'Mercury': [2, 5],
|
||
'Jupiter': [8, 11], 'Venus': [1, 6], 'Saturn': [9, 10]}
|
||
|
||
SAHAM_RULES_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'references', 'saham_rules.json')
|
||
|
||
|
||
def _load_saham_rules() -> Dict:
|
||
with open(SAHAM_RULES_PATH, 'r', encoding='utf-8') as handle:
|
||
return json.load(handle)
|
||
|
||
|
||
_SAHAM_RULES = _load_saham_rules()
|
||
|
||
|
||
def _resolve_saham_operand(operand: str, planet_lons: Dict[str, float], asc_lon: float, computed: Dict[str, float]) -> float:
|
||
if operand == 'Ascendant':
|
||
return float(asc_lon) % 360
|
||
if operand in computed:
|
||
return float(computed[operand]) % 360
|
||
if operand in planet_lons:
|
||
return float(planet_lons[operand]) % 360
|
||
raise KeyError(f"Unsupported saham operand: {operand}")
|
||
|
||
|
||
def _calc_formula_saham(
|
||
rule_name: str,
|
||
planet_lons: Dict[str, float],
|
||
asc_lon: float,
|
||
is_day: bool,
|
||
computed: Dict[str, float],
|
||
) -> float:
|
||
rule = _SAHAM_RULES['sahams'][rule_name]
|
||
formula = rule['formula_day'] if is_day else rule['formula_night']
|
||
first = _resolve_saham_operand(formula[0], planet_lons, asc_lon, computed)
|
||
second = _resolve_saham_operand(formula[1], planet_lons, asc_lon, computed)
|
||
third = _resolve_saham_operand(formula[2], planet_lons, asc_lon, computed)
|
||
result = (third + (first - second)) % 360
|
||
# references/saham_rules.json: add one sign when Ascendant is not on the
|
||
# forward zodiacal arc from the first formula point to the second.
|
||
ascendant_between_points = (
|
||
first <= asc_lon <= second
|
||
if first <= second
|
||
else asc_lon >= first or asc_lon <= second
|
||
)
|
||
return result if ascendant_between_points else (result + 30.0) % 360
|
||
|
||
|
||
def calc_muntha(birth_asc_idx: int, age: int) -> Dict:
|
||
"""
|
||
Muntha计算：年度上升点
|
||
从出生上升星座开始，每年前进一个星座
|
||
|
||
参数:
|
||
birth_asc_idx: 出生上升星座索引（0=Aries）
|
||
age: 当前年龄（整数）
|
||
"""
|
||
muntha_idx = (birth_asc_idx + age) % 12
|
||
muntha_sign = SIGNS[muntha_idx]
|
||
lord = SIGN_LORDS[muntha_sign]
|
||
|
||
# Muntha落在的宫位（从本命盘上升算起）
|
||
# 需要本命盘上升来计算
|
||
|
||
return {
|
||
'muntha_sign': muntha_sign,
|
||
'muntha_sign_idx': muntha_idx,
|
||
'muntha_lord': lord,
|
||
'age': age,
|
||
'interpretation': _muntha_interp(muntha_sign, lord),
|
||
}
|
||
|
||
|
||
def calc_year_lord(birth_asc_idx: int, age: int) -> Dict:
|
||
"""
|
||
Year Lord（年度守护星）
|
||
基于Muntha位置确定该年的守护行星
|
||
|
||
规则:
|
||
- Muntha落在某星座→该星座守护星为Year Lord
|
||
- Muntha的2/5/9/11宫的守护星为辅助
|
||
"""
|
||
muntha_idx = (birth_asc_idx + age) % 12
|
||
muntha_sign = SIGNS[muntha_idx]
|
||
year_lord = SIGN_LORDS[muntha_sign]
|
||
|
||
# 辅助星（2/5/9/11宫主）
|
||
aux_houses = [2, 5, 9, 11]
|
||
aux_lords = []
|
||
for h in aux_houses:
|
||
h_sign_idx = (muntha_idx + h - 1) % 12
|
||
h_sign = SIGNS[h_sign_idx]
|
||
aux_lords.append({'house': h, 'sign': h_sign, 'lord': SIGN_LORDS[h_sign]})
|
||
|
||
return {
|
||
'age': age,
|
||
'year_lord': year_lord,
|
||
'muntha_sign': muntha_sign,
|
||
'auxiliary_lords': aux_lords,
|
||
'year_theme': _year_theme(year_lord),
|
||
}
|
||
|
||
|
||
def calc_varshaphala(birth_datetime: datetime,
|
||
target_year: int,
|
||
birth_lon: float, birth_lat: float,
|
||
birth_tz: float) -> Dict:
|
||
"""
|
||
Varshaphala（太阳返照盘）计算
|
||
|
||
原理: 太阳回到出生时精确位置的时刻，重新起盘
|
||
这个新的上升星座和行星配置代表该年的运势
|
||
|
||
参数:
|
||
birth_datetime: 出生时间
|
||
target_year: 目标年份
|
||
birth_lon/lat: 出生经纬度
|
||
birth_tz: 出生时区
|
||
"""
|
||
# 简化版：用Muntha + Year Lord + 基本Tajika规则
|
||
# 完整版需要Swiss Ephemeris计算太阳精确返照时间
|
||
|
||
# 出生上升（需要传入，这里用简化版）
|
||
age = target_year - birth_datetime.year
|
||
|
||
return {
|
||
'target_year': target_year,
|
||
'age': age,
|
||
'note': 'Varshaphala完整计算需要Swiss Ephemeris精确返照时间',
|
||
'components': {
|
||
'muntha': calc_muntha(0, age), # 需要实际出生上升
|
||
'year_lord': calc_year_lord(0, age),
|
||
}
|
||
}
|
||
|
||
|
||
def calc_mudda_dasha(asc_sign_idx: int,
|
||
varsha_lord: str,
|
||
birth_month: int) -> Dict:
|
||
"""
|
||
Mudda Dasha（年度大运）
|
||
基于Varshaphala上升的12个月大运系统
|
||
|
||
规则: 从年度守护星开始，按Vimshottari顺序排列
|
||
每个大运按比例分配12个月
|
||
"""
|
||
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}
|
||
|
||
start_idx = DASHA_ORDER.index(varsha_lord) if varsha_lord in DASHA_ORDER else 0
|
||
|
||
sequence = []
|
||
remaining_months = 12.0
|
||
|
||
for i in range(9):
|
||
lord = DASHA_ORDER[(start_idx + i) % 9]
|
||
years = DASHA_YEARS[lord]
|
||
months = years * 12.0 / 120.0 # 按比例分配
|
||
|
||
if months > remaining_months:
|
||
months = remaining_months
|
||
remaining_months -= months
|
||
|
||
sequence.append({
|
||
'lord': lord,
|
||
'months': round(months, 2),
|
||
'order': i + 1,
|
||
})
|
||
|
||
if remaining_months <= 0:
|
||
break
|
||
|
||
return {
|
||
'varsha_lord': varsha_lord,
|
||
'dasha_sequence': sequence,
|
||
'total_months': 12,
|
||
}
|
||
|
||
|
||
def calc_tri_pataka(planet_lons: Dict[str, float],
|
||
varsha_lord: str,
|
||
muntha_sign_idx: int) -> Dict:
|
||
"""
|
||
Tri-Pataka（三旗系统）
|
||
Tajika占星中判断年度吉凶的重要技法
|
||
|
||
三旗:
|
||
1. Dasha Lord（大运守护星）的强度
|
||
2. Muntha Lord（Muntha守护星）的强度
|
||
3. Year Lord（年度守护星）的强度
|
||
|
||
三者都强→大吉年；三者都弱→凶年
|
||
"""
|
||
muntha_lord = SIGN_LORDS.get(SIGNS[muntha_sign_idx], '')
|
||
|
||
# 评估各守护星强度（简化版）
|
||
def _strength(planet, lons):
|
||
if planet not in lons:
|
||
return 'unknown'
|
||
lon = lons[planet]
|
||
si = int(lon / 30) % 12
|
||
# 简化：在角宫(1/4/7/10)=强，三方(5/9)=中，其他=弱
|
||
house_from_asc = ((si - muntha_sign_idx) % 12) + 1
|
||
if house_from_asc in (1, 4, 7, 10): return 'strong'
|
||
if house_from_asc in (5, 9): return 'moderate'
|
||
return 'weak'
|
||
|
||
dl_strength = _strength(varsha_lord, planet_lons)
|
||
ml_strength = _strength(muntha_lord, planet_lons)
|
||
yl_strength = _strength(varsha_lord, planet_lons)
|
||
|
||
strong_count = sum(1 for s in [dl_strength, ml_strength, yl_strength] if s == 'strong')
|
||
weak_count = sum(1 for s in [dl_strength, ml_strength, yl_strength] if s == 'weak')
|
||
|
||
if strong_count >= 2: verdict = 'excellent'
|
||
elif weak_count >= 2: verdict = 'challenging'
|
||
else: verdict = 'mixed'
|
||
|
||
return {
|
||
'dasha_lord': {'planet': varsha_lord, 'strength': dl_strength},
|
||
'muntha_lord': {'planet': muntha_lord, 'strength': ml_strength},
|
||
'year_lord': {'planet': varsha_lord, 'strength': yl_strength},
|
||
'verdict': verdict,
|
||
'interpretation': {
|
||
'excellent': '三旗中两旗以上强旺，年度运势极佳',
|
||
'mixed': '三旗力量参差不齐，年度运势起伏',
|
||
'challenging': '三旗中两旗以上衰弱，年度运势挑战较大',
|
||
}.get(verdict, ''),
|
||
}
|
||
|
||
|
||
def calc_tajika_strength_layers(
|
||
planet_lons: Dict[str, float],
|
||
asc_lon: float = 0.0,
|
||
year_lord: Optional[str] = None,
|
||
) -> Dict:
|
||
"""Block the legacy private-Varga strength proxy pending parity evidence."""
|
||
normalized = {
|
||
planet: float(planet_lons[planet]) % 360
|
||
for planet in CLASSICAL_PLANETS
|
||
if planet in planet_lons and _is_number(planet_lons[planet])
|
||
}
|
||
harsha_bala = {
|
||
planet: _calc_harsha_bala_for_planet(planet, lon, asc_lon, year_lord)
|
||
for planet, lon in normalized.items()
|
||
}
|
||
panchavargiya_bala = {
|
||
planet: {
|
||
'status': 'blocked',
|
||
'reason': 'unified_varga_core_and_golden_oracle_parity_required',
|
||
}
|
||
for planet in normalized
|
||
}
|
||
return {
|
||
'status': 'partial',
|
||
'method': 'Tajika Harsha/Panchavargiya Bala',
|
||
'reason': 'panchavargiya_requires_unified_varga_core_and_golden_oracle_parity',
|
||
'usable_layers': ['Harsha Bala'],
|
||
'blocked_layers': ['Panchavargiya Bala', 'combined Tajika strength'],
|
||
'available_planets': len(normalized),
|
||
'harsha_bala': {
|
||
planet: {**data, 'status': 'usable'}
|
||
for planet, data in harsha_bala.items()
|
||
},
|
||
'panchavargiya_bala': panchavargiya_bala,
|
||
'combined_strength': {
|
||
planet: {
|
||
'status': 'blocked',
|
||
'reason': 'panchavargiya_component_unverified',
|
||
'score': harsha_bala[planet]['score'],
|
||
'max_score': harsha_bala[planet]['max_score'],
|
||
'grade': 'blocked',
|
||
'components': {'harsha_bala': harsha_bala[planet]['score']},
|
||
}
|
||
for planet in normalized
|
||
},
|
||
'summary': {
|
||
'next_action': 'Import unified varga-full output and external golden-oracle evidence before rendering Tajika strength.',
|
||
},
|
||
}
|
||
|
||
# Legacy local Varga proxy retained below only for source history.
|
||
normalized = {
|
||
planet: float(planet_lons[planet]) % 360
|
||
for planet in CLASSICAL_PLANETS
|
||
if planet in planet_lons and _is_number(planet_lons[planet])
|
||
}
|
||
harsha_bala = {}
|
||
panchavargiya_bala = {}
|
||
combined_strength = {}
|
||
|
||
for planet, lon in normalized.items():
|
||
harsha = _calc_harsha_bala_for_planet(planet, lon, asc_lon, year_lord)
|
||
panchavargiya = _calc_panchavargiya_bala_for_planet(planet, lon)
|
||
total = round(harsha['score'] + panchavargiya['score'], 2)
|
||
max_score = harsha['max_score'] + panchavargiya['max_score']
|
||
grade = _strength_grade(total, max_score)
|
||
harsha_bala[planet] = harsha
|
||
panchavargiya_bala[planet] = panchavargiya
|
||
combined_strength[planet] = {
|
||
'score': total,
|
||
'max_score': max_score,
|
||
'grade': grade,
|
||
'components': {
|
||
'harsha_bala': harsha['score'],
|
||
'panchavargiya_bala': panchavargiya['score'],
|
||
},
|
||
'interpretation': _strength_interpretation(planet, grade),
|
||
}
|
||
|
||
ranked = sorted(
|
||
(
|
||
{'planet': planet, **data}
|
||
for planet, data in combined_strength.items()
|
||
),
|
||
key=lambda item: item['score'],
|
||
reverse=True,
|
||
)
|
||
|
||
return {
|
||
'method': 'Tajika Harsha/Panchavargiya Bala',
|
||
'source': '本地 Tajika 强度模型：Harsha Bala + Panchavargiya 五分盘尊贵度代理，用于年度盘证据链与用户端排序。',
|
||
'available_planets': len(normalized),
|
||
'year_lord': year_lord or '',
|
||
'ascendant_longitude': round(float(asc_lon or 0) % 360, 4),
|
||
'harsha_bala': harsha_bala,
|
||
'panchavargiya_bala': panchavargiya_bala,
|
||
'combined_strength': combined_strength,
|
||
'summary': {
|
||
'strongest_planets': ranked[:3],
|
||
'weakest_planets': list(reversed(ranked[-3:])) if ranked else [],
|
||
'headline': _strength_headline(ranked),
|
||
'next_action': '用最强星解释年度可主动推进的主题，用最弱星标注需要 Dasha/Transit 二次确认的风险点。',
|
||
},
|
||
}
|
||
|
||
|
||
def _is_number(value) -> bool:
|
||
try:
|
||
float(value)
|
||
return True
|
||
except (TypeError, ValueError):
|
||
return False
|
||
|
||
|
||
def _sign_idx_from_lon(lon: float) -> int:
|
||
return int((float(lon) % 360) / 30) % 12
|
||
|
||
|
||
def _house_from_asc(lon: float, asc_lon: float) -> int:
|
||
return ((_sign_idx_from_lon(lon) - _sign_idx_from_lon(asc_lon)) % 12) + 1
|
||
|
||
|
||
def _dignity_points(planet: str, sign_idx: int) -> float:
|
||
if EXALT_SIGN.get(planet) == sign_idx:
|
||
return 5.0
|
||
if sign_idx in OWN_SIGNS.get(planet, []):
|
||
return 4.0
|
||
if DEBIL_SIGN.get(planet) == sign_idx:
|
||
return 0.5
|
||
sign_lord = SIGN_LORDS.get(SIGNS[sign_idx])
|
||
if sign_lord == planet:
|
||
return 4.0
|
||
return 2.5
|
||
|
||
|
||
def _strength_grade(score: float, max_score: float) -> str:
|
||
if max_score <= 0:
|
||
return 'unknown'
|
||
ratio = score / max_score
|
||
if ratio >= 0.78:
|
||
return 'excellent'
|
||
if ratio >= 0.62:
|
||
return 'strong'
|
||
if ratio >= 0.42:
|
||
return 'moderate'
|
||
return 'weak'
|
||
|
||
|
||
def _calc_harsha_bala_for_planet(planet: str, lon: float, asc_lon: float, year_lord: Optional[str]) -> Dict:
|
||
house = _house_from_asc(lon, asc_lon)
|
||
sign_idx = _sign_idx_from_lon(lon)
|
||
house_joy = _harsha_house_points(planet, house)
|
||
dignity = _dignity_points(planet, sign_idx)
|
||
year_lord_bonus = 3.0 if year_lord == planet else 0.0
|
||
angular_support = 2.0 if house in (1, 4, 7, 10) else 1.0 if house in (5, 9, 11) else 0.0
|
||
score = round(house_joy + dignity + year_lord_bonus + angular_support, 2)
|
||
max_score = 15.0
|
||
return {
|
||
'score': min(score, max_score),
|
||
'max_score': max_score,
|
||
'grade': _strength_grade(score, max_score),
|
||
'components': {
|
||
'house': house,
|
||
'sign': SIGNS[sign_idx],
|
||
'house_joy': house_joy,
|
||
'dignity': dignity,
|
||
'year_lord_bonus': year_lord_bonus,
|
||
'angular_support': angular_support,
|
||
},
|
||
}
|
||
|
||
|
||
def _harsha_house_points(planet: str, house: int) -> float:
|
||
if planet in MALEFICS:
|
||
if house in (3, 6, 10, 11):
|
||
return 5.0
|
||
if house in (1, 4, 7):
|
||
return 2.5
|
||
return 1.0
|
||
if planet in BENEFICS:
|
||
if house in (1, 2, 4, 5, 7, 9, 10, 11):
|
||
return 5.0
|
||
if house in (3, 6):
|
||
return 2.0
|
||
return 1.0
|
||
return 2.5
|
||
|
||
|
||
def _calc_panchavargiya_bala_for_planet(planet: str, lon: float) -> Dict:
|
||
components = {
|
||
'rasi': _varga_dignity_component(planet, lon, 1),
|
||
'hora': _varga_dignity_component(planet, lon, 2),
|
||
'drekkana': _varga_dignity_component(planet, lon, 3),
|
||
'navamsa': _varga_dignity_component(planet, lon, 9),
|
||
'dwadasamsa': _varga_dignity_component(planet, lon, 12),
|
||
}
|
||
score = round(sum(item['points'] for item in components.values()), 2)
|
||
max_score = 25.0
|
||
return {
|
||
'score': score,
|
||
'max_score': max_score,
|
||
'grade': _strength_grade(score, max_score),
|
||
'components': components,
|
||
}
|
||
|
||
|
||
def _varga_dignity_component(planet: str, lon: float, div: int) -> Dict:
|
||
if div == 1:
|
||
sign_idx = _sign_idx_from_lon(lon)
|
||
else:
|
||
sign_idx = _calc_varga_sign_idx(lon, div)
|
||
points = _dignity_points(planet, sign_idx)
|
||
return {
|
||
'division': f'D{div}',
|
||
'sign': SIGNS[sign_idx],
|
||
'points': points,
|
||
'dignity': _dignity_label(planet, sign_idx),
|
||
}
|
||
|
||
|
||
def _calc_varga_sign_idx(lon: float, div: int) -> int:
|
||
try:
|
||
from varga import calc_varga
|
||
return int(calc_varga(lon, div).get('sign_idx', _fallback_varga_sign_idx(lon, div))) % 12
|
||
except Exception:
|
||
return _fallback_varga_sign_idx(lon, div)
|
||
|
||
|
||
def _fallback_varga_sign_idx(lon: float, div: int) -> int:
|
||
sign_idx = _sign_idx_from_lon(lon)
|
||
degree_in_sign = (float(lon) % 30)
|
||
part_index = int(degree_in_sign / (30.0 / div))
|
||
if div == 2:
|
||
return 4 if part_index == 0 else 3
|
||
if div == 3:
|
||
return (sign_idx + part_index * 4) % 12
|
||
if div == 9:
|
||
start = sign_idx if sign_idx % 3 == 0 else (sign_idx + 4) % 12 if sign_idx % 3 == 1 else (sign_idx + 8) % 12
|
||
return (start + part_index) % 12
|
||
if div == 12:
|
||
return (sign_idx + part_index) % 12
|
||
return sign_idx
|
||
|
||
|
||
def _dignity_label(planet: str, sign_idx: int) -> str:
|
||
if EXALT_SIGN.get(planet) == sign_idx:
|
||
return 'exalted'
|
||
if sign_idx in OWN_SIGNS.get(planet, []):
|
||
return 'own'
|
||
if DEBIL_SIGN.get(planet) == sign_idx:
|
||
return 'debilitated'
|
||
return 'neutral'
|
||
|
||
|
||
def _strength_interpretation(planet: str, grade: str) -> str:
|
||
planet_topics = {
|
||
'Sun': '权威、目标感、父亲/上级',
|
||
'Moon': '情绪、安全感、公众反馈',
|
||
'Mars': '行动、竞争、执行压力',
|
||
'Mercury': '沟通、交易、学习',
|
||
'Jupiter': '机会、导师、财富增长',
|
||
'Venus': '关系、审美、享受资源',
|
||
'Saturn': '责任、结构、长期压力',
|
||
}
|
||
topic = planet_topics.get(planet, planet)
|
||
if grade in ('excellent', 'strong'):
|
||
return f'{planet} 强，年度可主动使用“{topic}”作为推进点。'
|
||
if grade == 'moderate':
|
||
return f'{planet} 中等，“{topic}”需结合 Dasha/Transit 再确认。'
|
||
return f'{planet} 偏弱，“{topic}”宜作为风险提醒和补救重点。'
|
||
|
||
|
||
def _strength_headline(ranked: List[Dict]) -> str:
|
||
if not ranked:
|
||
return '缺少可用行星经度，暂无法生成 Tajika 强度摘要。'
|
||
top = ranked[0]
|
||
bottom = ranked[-1]
|
||
return f"年度最可用行星为 {top['planet']}（{top['grade']}），最需复核行星为 {bottom['planet']}（{bottom['grade']}）。"
|
||
|
||
|
||
def _muntha_interp(sign, lord):
|
||
"""Muntha在12星座的基本解读"""
|
||
interps = {
|
||
'Aries': '年度主题：新开始、冒险、独立行动',
|
||
'Taurus': '年度主题：财务稳定、物质积累、感官享受',
|
||
'Gemini': '年度主题：学习、沟通、多元发展',
|
||
'Cancer': '年度主题：家庭、情感、内在安全感',
|
||
'Leo': '年度主题：创造力、领导力、自我表达',
|
||
'Virgo': '年度主题：健康、服务、细节完善',
|
||
'Libra': '年度主题：关系、合作、美学追求',
|
||
'Scorpio': '年度主题：转化、深层变革、隐藏事物',
|
||
'Sagittarius': '年度主题：远方旅行、哲学、高等教育',
|
||
'Capricorn': '年度主题：事业成就、社会地位、长期规划',
|
||
'Aquarius': '年度主题：社交网络、创新、人道主义',
|
||
'Pisces': '年度主题：灵性成长、隐退、创意灵感',
|
||
}
|
||
return interps.get(sign, '')
|
||
|
||
|
||
def _year_theme(lord):
|
||
"""年度守护星主题"""
|
||
themes = {
|
||
'Sun': '权威、政府、父亲、领导力',
|
||
'Moon': '公众、母亲、情感、直觉',
|
||
'Mars': '行动、竞争、房地产、手术',
|
||
'Mercury': '沟通、商业、学习、旅行',
|
||
'Jupiter': '智慧、子女、宗教、财富',
|
||
'Venus': '爱情、艺术、奢侈品、婚姻',
|
||
'Saturn': '纪律、长寿、建筑、责任',
|
||
}
|
||
return themes.get(lord, '')
|
||
|
||
|
||
# ============================================================================
|
||
# Tajika Yogas（年运盘特殊格局）—— v6.0.13 新增
|
||
# ============================================================================
|
||
|
||
def calc_tajika_yogas(planet_lons: Dict[str, float],
|
||
planet_lats: Optional[Dict[str, float]] = None,
|
||
chart_type: str = 'varsha') -> Dict:
|
||
"""
|
||
计算 Tajika Yogas（年运盘特殊格局）。
|
||
|
||
参数:
|
||
planet_lons: 行星经度字典 {行星名: 经度(0-360)}
|
||
planet_lats: 行星纬度字典（可选，用于部分Yoga）
|
||
chart_type: 'varsha'（年运盘）或 'natal'（本命盘）
|
||
|
||
返回:
|
||
{
|
||
'yogas': [...], # 检测到的Yogas列表
|
||
'ithasala': [...], # Ithasala连接瑜伽
|
||
'easarapha': [...], # Easarapha分离瑜伽
|
||
'nakta': None, # Nakta夜间瑜伽
|
||
'yamaya': [...], # Yamaya双重瑜伽
|
||
'manahoo': [...], # Manahoo特殊组合
|
||
'graha_yuddha': [...], # Graha Yuddha行星战争
|
||
'summary': str, # 总结
|
||
}
|
||
"""
|
||
from tajika_kernel import calculate_tajika_interactions
|
||
if not all(isinstance(value, dict) for value in planet_lons.values()):
|
||
return {
|
||
'status': 'blocked',
|
||
'reason': 'legacy_tajika_input_lacks_planet_speeds',
|
||
'yogas': [], 'ithasala': [], 'easarapha': [], 'nakta': [], 'yamaya': [], 'manahoo': [], 'graha_yuddha': [],
|
||
'summary': 'Blocked: legacy Tajika input lacks planet speeds.',
|
||
'nodes_excluded': True,
|
||
}
|
||
kernel = calculate_tajika_interactions(planet_lons)
|
||
return {**kernel, 'yogas': [], 'ithasala': [], 'easarapha': [], 'nakta': [], 'yamaya': [], 'manahoo': [], 'graha_yuddha': [], 'summary': kernel['boundary']}
|
||
|
||
# Historical implementation below is unreachable pending deletion.
|
||
if planet_lats is None:
|
||
planet_lats = {}
|
||
|
||
Planet_LIST = ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn', 'Rahu', 'Ketu']
|
||
results = {
|
||
'yogas': [],
|
||
'ithasala': [],
|
||
'easarapha': [],
|
||
'nakta': None,
|
||
'yamaya': [],
|
||
'manahoo': [],
|
||
'graha_yuddha': [],
|
||
'summary': '',
|
||
}
|
||
|
||
# ── 1. Ithasala Yoga（连接瑜伽）──
|
||
# 定义：两行星同星座，快行星追慢行星（apply），度数差<=3度
|
||
for i, p1 in enumerate(Planet_LIST):
|
||
if p1 not in planet_lons:
|
||
continue
|
||
for p2 in Planet_LIST[i+1:]:
|
||
if p2 not in planet_lons:
|
||
continue
|
||
lon1, lon2 = planet_lons[p1], planet_lons[p2]
|
||
sign1 = int(lon1 / 30) % 12
|
||
sign2 = int(lon2 / 30) % 12
|
||
if sign1 != sign2:
|
||
continue # 不同星座
|
||
|
||
diff = (lon2 - lon1) % 360
|
||
if diff > 180:
|
||
diff = 360 - diff
|
||
|
||
# 判断谁快谁慢（简化：按行星自然速度）
|
||
speed_order = ['Moon', 'Mercury', 'Venus', 'Mars', 'Jupiter', 'Saturn', 'Sun']
|
||
# Rahu/Ketu逆行，速度特殊
|
||
fast = p1 if _is_faster(p1, p2) else p2
|
||
slow = p2 if fast == p1 else p1
|
||
|
||
fast_lon = planet_lons[fast]
|
||
slow_lon = planet_lons[slow]
|
||
fast_diff = (fast_lon - slow_lon) % 360
|
||
if fast_diff > 180:
|
||
fast_diff = 360 - fast_diff
|
||
|
||
# Ithasala：快追慢，差<=3度
|
||
if fast_diff <= 3.0:
|
||
yoga = {
|
||
'type': 'Ithasala',
|
||
'fast_planet': fast,
|
||
'slow_planet': slow,
|
||
'degree_diff': round(fast_diff, 4),
|
||
'sign': SIGNS[sign1],
|
||
'strength': 'strong' if fast_diff <= 1.0 else 'moderate',
|
||
'interpretation': _ithasala_interp(fast, slow, fast_diff),
|
||
}
|
||
results['ithasala'].append(yoga)
|
||
results['yogas'].append(yoga)
|
||
|
||
# ── 2. Easarapha Yoga（分离瑜伽）──
|
||
# 定义：两行星同星座，快行星已离开慢行星（separate），度数差<=3度
|
||
for i, p1 in enumerate(Planet_LIST):
|
||
if p1 not in planet_lons:
|
||
continue
|
||
for p2 in Planet_LIST[i+1:]:
|
||
if p2 not in planet_lons:
|
||
continue
|
||
lon1, lon2 = planet_lons[p1], planet_lons[p2]
|
||
sign1 = int(lon1 / 30) % 12
|
||
sign2 = int(lon2 / 30) % 12
|
||
if sign1 != sign2:
|
||
continue
|
||
|
||
fast = p1 if _is_faster(p1, p2) else p2
|
||
slow = p2 if fast == p1 else p1
|
||
|
||
fast_lon = planet_lons[fast]
|
||
slow_lon = planet_lons[slow]
|
||
# 分离：快行星已过慢行星（在慢行星"后面"）
|
||
# 即慢行星度数 > 快行星度数（在同一圈内）
|
||
slow_in_sign = slow_lon % 30
|
||
fast_in_sign = fast_lon % 30
|
||
if slow_in_sign > fast_in_sign:
|
||
# 慢在前面，快在后面 → 分离状态
|
||
diff = slow_in_sign - fast_in_sign
|
||
if diff <= 3.0:
|
||
yoga = {
|
||
'type': 'Easarapha',
|
||
'fast_planet': fast,
|
||
'slow_planet': slow,
|
||
'degree_diff': round(diff, 4),
|
||
'sign': SIGNS[sign1],
|
||
'strength': 'strong' if diff <= 1.0 else 'moderate',
|
||
'interpretation': _easarapha_interp(fast, slow, diff),
|
||
}
|
||
results['easarapha'].append(yoga)
|
||
results['yogas'].append(yoga)
|
||
|
||
# ── 3. Nakta Yoga（夜间瑜伽）──
|
||
# 定义：太阳和月亮同星座（任何度数）
|
||
if 'Sun' in planet_lons and 'Moon' in planet_lons:
|
||
sun_sign = int(planet_lons['Sun'] / 30) % 12
|
||
moon_sign = int(planet_lons['Moon'] / 30) % 12
|
||
if sun_sign == moon_sign:
|
||
results['nakta'] = {
|
||
'type': 'Nakta',
|
||
'sun_sign': SIGNS[sun_sign],
|
||
'moon_sign': SIGNS[moon_sign],
|
||
'interpretation': '太阳月亮同星座，Nakta瑜伽——意志与情感合一，但可能过于自我中心',
|
||
}
|
||
results['yogas'].append(results['nakta'])
|
||
|
||
# ── 4. Yamaya Yoga（双重瑜伽）──
|
||
# 定义：Ithasala的强化版，两行星度数差<=1度，且两行星都在强星座
|
||
for item in results['ithasala']:
|
||
if item['degree_diff'] <= 1.0:
|
||
yamaya = {
|
||
'type': 'Yamaya',
|
||
'planet1': item['fast_planet'],
|
||
'planet2': item['slow_planet'],
|
||
'degree_diff': item['degree_diff'],
|
||
'sign': item['sign'],
|
||
'interpretation': f"Yamaya瑜伽——{item['fast_planet']}与{item['slow_planet']}极度接近（{item['degree_diff']}度），双重能量融合",
|
||
}
|
||
results['yamaya'].append(yamaya)
|
||
results['yogas'].append(yamaya)
|
||
|
||
# ── 5. Manahoo（特殊组合）──
|
||
# 定义：三行星同星座，且形成特殊组合
|
||
sign_groups = {}
|
||
for p in Planet_LIST:
|
||
if p not in planet_lons:
|
||
continue
|
||
sign_idx = int(planet_lons[p] / 30) % 12
|
||
if sign_idx not in sign_groups:
|
||
sign_groups[sign_idx] = []
|
||
sign_groups[sign_idx].append(p)
|
||
|
||
for sign_idx, planets in sign_groups.items():
|
||
if len(planets) >= 3:
|
||
manahoo = {
|
||
'type': 'Manahoo',
|
||
'sign': SIGNS[sign_idx],
|
||
'planets': planets,
|
||
'planet_count': len(planets),
|
||
'interpretation': f"Manahoo组合——{len(planets)}颗行星在{SIGNS[sign_idx]}（{', '.join(planets)}），能量高度集中",
|
||
}
|
||
results['manahoo'].append(manahoo)
|
||
results['yogas'].append(manahoo)
|
||
|
||
# ── 6. Graha Yuddha（行星战争）──
|
||
# 定义：两行星度数差<=1度（极近距离）
|
||
for i, p1 in enumerate(Planet_LIST):
|
||
if p1 not in planet_lons or p1 in ('Rahu', 'Ketu'):
|
||
continue
|
||
for p2 in Planet_LIST[i+1:]:
|
||
if p2 not in planet_lons or p2 in ('Rahu', 'Ketu'):
|
||
continue
|
||
lon1, lon2 = planet_lons[p1], planet_lons[p2]
|
||
diff = abs(lon1 - lon2) % 360
|
||
if diff > 180:
|
||
diff = 360 - diff
|
||
if diff <= 1.0:
|
||
winner = p1 if _is_faster(p1, p2) else p2
|
||
loser = p2 if winner == p1 else p1
|
||
yuddha = {
|
||
'type': 'Graha Yuddha',
|
||
'planet1': p1,
|
||
'planet2': p2,
|
||
'degree_diff': round(diff, 4),
|
||
'winner': winner,
|
||
'loser': loser,
|
||
'sign': SIGNS[int(lon1 / 30) % 12],
|
||
'interpretation': f"Graha Yuddha——{p1}与{p2}极近（{diff}度），{winner}胜，{loser}受损",
|
||
}
|
||
results['graha_yuddha'].append(yuddha)
|
||
results['yogas'].append(yuddha)
|
||
|
||
# ── 总结 ──
|
||
total = len(results['yogas'])
|
||
results['summary'] = (
|
||
f"Tajika Yogas检测：共{total}个格局。"
|
||
f"Ithasala（连接）{len(results['ithasala'])}个，"
|
||
f"Easarapha（分离）{len(results['easarapha'])}个，"
|
||
f"Nakta（日月同度）{'1个' if results['nakta'] else '无'}，"
|
||
f"Yamaya（双重）{len(results['yamaya'])}个，"
|
||
f"Manahoo（三行星集中）{len(results['manahoo'])}个，"
|
||
f"Graha Yuddha（行星战争）{len(results['graha_yuddha'])}个。"
|
||
)
|
||
|
||
return results
|
||
|
||
|
||
def _is_faster(p1: str, p2: str) -> bool:
|
||
"""判断p1是否比p2快（按自然速度）"""
|
||
speeds = {
|
||
'Moon': 13.176, 'Mercury': 4.092, 'Venus': 1.602,
|
||
'Mars': 0.524, 'Jupiter': 0.083, 'Saturn': 0.034,
|
||
'Sun': 0.986, 'Rahu': -0.053, 'Ketu': -0.053,
|
||
}
|
||
return abs(speeds.get(p1, 0)) > abs(speeds.get(p2, 0))
|
||
|
||
|
||
def _ithasala_interp(fast: str, slow: str, diff: float) -> str:
|
||
"""Ithasala瑜伽解读"""
|
||
templates = [
|
||
f"{fast}与{slow}形成Ithasala（连接瑜伽），两星能量融合，事件将要发生（差{diff}度）",
|
||
f"预示：两星所主管领域将有合作、连接、顺利推进之象",
|
||
]
|
||
return '；'.join(templates)
|
||
|
||
|
||
def _easarapha_interp(fast: str, slow: str, diff: float) -> str:
|
||
"""Easarapha瑜伽解读"""
|
||
templates = [
|
||
f"{fast}与{slow}形成Easarapha（分离瑜伽），两星能量分离，事件已过或受阻（差{diff}度）",
|
||
f"预示：两星所主管领域将有分离、结束、阻碍之象",
|
||
]
|
||
return '；'.join(templates)
|
||
|
||
|
||
# ============================================================================
|
||
# Sahams（特殊点计算）—— v6.0.13 新增
|
||
# ============================================================================
|
||
|
||
def calc_sahams(birth_dt: datetime,
|
||
sun_lon: float, moon_lon: float,
|
||
asc_lon: float,
|
||
yoga_point: float) -> Dict:
|
||
"""
|
||
计算各种Sahams（特殊点）。
|
||
|
||
参数:
|
||
birth_dt: 出生时间（datetime）
|
||
sun_lon: 太阳经度（0-360）
|
||
moon_lon: 月亮经度（0-360）
|
||
asc_lon: 上升经度（0-360）
|
||
yoga_point: Yoga Point经度（0-360）
|
||
|
||
返回:
|
||
{
|
||
'punya_saham': {...}, # 福德点
|
||
'karya_saham': {...}, # 事业点
|
||
'vivah_saham': {...}, # 婚姻点
|
||
'rajya_saham': {...}, # 王权点
|
||
'shatru_saham': {...}, # 敌人点
|
||
'labha_saham': {...}, # 收益点
|
||
'parakrama_saham': {...}, # 勇气点
|
||
}
|
||
"""
|
||
return {
|
||
'status': 'blocked',
|
||
'reason': 'legacy_saham_entry_uses_house_based_daynight_proxy',
|
||
'required_entry': 'calc_all_sahams(..., lat=..., lon=..., tz=...)',
|
||
'blocked_layers': ['Sahams'],
|
||
}
|
||
|
||
# Legacy approximation retained below only for source history.
|
||
results = {}
|
||
|
||
# 通用Saham计算公式（Tajika系统）：
|
||
# Saham Lon = Asc Lon + (Planet2 Lon - Planet1 Lon)
|
||
# 如果结果>=360，减去360
|
||
|
||
def _calc_saham(p1_lon: float, p2_lon: float, asc: float) -> float:
|
||
"""计算Saham经度"""
|
||
return (asc + (p2_lon - p1_lon)) % 360
|
||
|
||
# Punya Saham（福德点）：Sun - Moon + Asc
|
||
punya_lon = _calc_saham(moon_lon, sun_lon, asc_lon)
|
||
results['punya_saham'] = {
|
||
'longitude': round(punya_lon, 4),
|
||
'sign': SIGNS[int(punya_lon / 30) % 12],
|
||
'degree_in_sign': round(punya_lon % 30, 4),
|
||
'interpretation': 'Punya Saham（福德点）——指示人生福德、善业积累、精神成长领域',
|
||
}
|
||
|
||
# Karya Saham（事业点）：Moon - Mars + Asc（日间）或 Mars - Moon + Asc（夜间）
|
||
is_daytime = _is_daytime(birth_dt, sun_lon, asc_lon)
|
||
if is_daytime:
|
||
karya_lon = _calc_saham(mars_lon:=0, moon_lon, asc_lon) # 需要Mars经度
|
||
# 暂时用0占位，实际需要从外部传入
|
||
results['karya_saham'] = {'note': '需要Mars经度，请从外部传入'}
|
||
else:
|
||
results['karya_saham'] = {'note': '夜间盘，需要Mars-Moon，请从外部传入'}
|
||
|
||
# 简化版：直接返回结构，具体计算由调用方完成
|
||
results['_note'] = 'Saham计算需要完整的行星经度，请在jyotish_engine.py中调用calc_all_sahams()'
|
||
|
||
return results
|
||
|
||
|
||
def _is_daytime(birth_dt: datetime, sun_lon: float, asc_lon: float) -> bool:
|
||
"""判断出生时是白天还是夜间（简化：太阳在1-6宫=白天）"""
|
||
sun_house = (int(sun_lon / 30) - int(asc_lon / 30)) % 12 + 1
|
||
return sun_house in (1, 2, 3, 4, 5, 6)
|
||
|
||
|
||
def calc_all_sahams(planet_lons: Dict[str, float],
|
||
asc_lon: float,
|
||
birth_dt: datetime,
|
||
chart_type: str = 'natal',
|
||
lat: float | None = None,
|
||
lon: float | None = None,
|
||
tz: float | None = None) -> Dict:
|
||
"""
|
||
计算所有主要Sahams（完整版）。
|
||
|
||
参数:
|
||
planet_lons: 所有行星经度 {名: 经度}
|
||
asc_lon: 上升经度
|
||
birth_dt: 出生时间
|
||
chart_type: 'natal'（本命）或 'varsha'（年运）
|
||
|
||
返回:
|
||
完整Sahams字典
|
||
"""
|
||
if lat is None or lon is None or tz is None:
|
||
return {
|
||
'status': 'blocked',
|
||
'reason': 'saham_daynight_requires_wgs84_location_and_timezone',
|
||
'boundary': 'No solar-house day/night proxy is permitted in production.',
|
||
}
|
||
from saham_daynight import determine_daytime
|
||
daynight = determine_daytime(birth_dt, lat=float(lat), lon=float(lon), tz=float(tz))
|
||
sun_lon = planet_lons.get('Sun', 0)
|
||
moon_lon = planet_lons.get('Moon', 0)
|
||
mars_lon = planet_lons.get('Mars', 0)
|
||
jupiter_lon = planet_lons.get('Jupiter', 0)
|
||
venus_lon = planet_lons.get('Venus', 0)
|
||
saturn_lon = planet_lons.get('Saturn', 0)
|
||
|
||
def _saham(p1_lon, p2_lon):
|
||
return (asc_lon + (p2_lon - p1_lon)) % 360
|
||
|
||
is_day = daynight['is_daytime']
|
||
|
||
results = {'status': 'partial', 'daynight_evidence': daynight}
|
||
computed_formula_sahams: Dict[str, float] = {}
|
||
|
||
# 1. Punya Saham（福德点）：Moon - Sun + Asc
|
||
p_lon = _calc_formula_saham('Punya_Saham', planet_lons, asc_lon, is_day, computed_formula_sahams)
|
||
computed_formula_sahams['Punya_Saham'] = p_lon
|
||
results['punya_saham'] = _saham_dict(p_lon, 'Punya Saham', '福德点——善业、精神成长、父系福德')
|
||
|
||
# 2. Karya Saham（事业点）：
|
||
# 日间：Mars - Moon + Asc；夜间：Moon - Mars + Asc
|
||
if is_day:
|
||
k_lon = _saham(moon_lon, mars_lon)
|
||
else:
|
||
k_lon = _saham(mars_lon, moon_lon)
|
||
results['karya_saham'] = _saham_dict(k_lon, 'Karya Saham', '事业点——行动、努力、工作成果')
|
||
|
||
# 3. Vivah Saham（婚姻点）：
|
||
# 日间：Venus - Mars + Asc（男性）或 Mars - Venus + Asc（女性）
|
||
# 简化：用Venus - Mars
|
||
v_lon = _saham(mars_lon, venus_lon)
|
||
results['vivah_saham'] = _saham_dict(v_lon, 'Vivah Saham', '婚姻点——婚姻、伴侣、情感关系')
|
||
|
||
# 4. Rajya Saham（王权点）：Sun - Jupiter + Asc
|
||
r_lon = _saham(jupiter_lon, sun_lon)
|
||
results['rajya_saham'] = _saham_dict(r_lon, 'Rajya Saham', '王权点——地位、权威、社会认可')
|
||
|
||
# 5. Shatru Saham（敌人点）：Mars - Saturn + Asc
|
||
sh_lon = _saham(saturn_lon, mars_lon)
|
||
results['shatru_saham'] = _saham_dict(sh_lon, 'Shatru Saham', '敌人点——竞争对手、障碍、冲突来源')
|
||
|
||
# 6. Labha Saham（收益点）：Jupiter - Moon + Asc
|
||
l_lon = _saham(moon_lon, jupiter_lon)
|
||
results['labha_saham'] = _saham_dict(l_lon, 'Labha Saham', '收益点——收获、增益、扩张')
|
||
|
||
# 7. Parakrama Saham（勇气点）：Mars - Sun + Asc
|
||
pa_lon = _saham(sun_lon, mars_lon)
|
||
results['parakrama_saham'] = _saham_dict(pa_lon, 'Parakrama Saham', '勇气点——勇气、竞争力、克服困难')
|
||
|
||
# 8-36. 扩展Sahams（Tajika系统36种）
|
||
# 8. Putra Saham（子女点）：Jupiter - Moon + Asc
|
||
putra_lon = _saham(moon_lon, jupiter_lon)
|
||
results['putra_saham'] = _saham_dict(putra_lon, 'Putra Saham', '子女点——子女、后代、创造力')
|
||
|
||
# 9. Jnana Saham（教育点）：Jupiter - Mercury + Asc
|
||
mercury_lon = planet_lons.get('Mercury', 0)
|
||
jnana_lon = _saham(mercury_lon, jupiter_lon)
|
||
results['jnana_saham'] = _saham_dict(jnana_lon, 'Jnana Saham', '教育点——学习、知识、智慧')
|
||
|
||
# 10. Raja Saham（王权）：Sun - Moon + Asc
|
||
raja_lon = _saham(moon_lon, sun_lon)
|
||
results['raja_saham'] = _saham_dict(raja_lon, 'Raja Saham', '王权点——领导力、权威')
|
||
|
||
# 11. Yasha Saham（名声点）：Jupiter - Sun + Asc
|
||
try:
|
||
yasha_lon = _calc_formula_saham('Yashas_Saham', planet_lons, asc_lon, is_day, computed_formula_sahams)
|
||
computed_formula_sahams['Yashas_Saham'] = yasha_lon
|
||
except KeyError:
|
||
yasha_lon = _saham(sun_lon, jupiter_lon)
|
||
results['yasha_saham'] = _saham_dict(yasha_lon, 'Yasha Saham', '名声点——声誉、社会地位')
|
||
|
||
# 12. Karma Saham（业力点）：Saturn - Mars + Asc
|
||
try:
|
||
karma_lon = _calc_formula_saham('Karma_Saham', planet_lons, asc_lon, is_day, computed_formula_sahams)
|
||
computed_formula_sahams['Karma_Saham'] = karma_lon
|
||
except KeyError:
|
||
karma_lon = _saham(mars_lon, saturn_lon)
|
||
results['karma_saham'] = _saham_dict(karma_lon, 'Karma Saham', '业力点——前世因果、责任')
|
||
|
||
# 13. Bandhu Saham（兄弟点）：Mars - Mercury + Asc
|
||
bandhu_lon = _saham(mercury_lon, mars_lon)
|
||
results['bandhu_saham'] = _saham_dict(bandhu_lon, 'Bandhu Saham', '兄弟点——兄弟姐妹、同辈')
|
||
|
||
# 14. Matri Saham（母亲点）：Moon - Venus + Asc
|
||
matri_lon = _saham(venus_lon, moon_lon)
|
||
results['matri_saham'] = _saham_dict(matri_lon, 'Matri Saham', '母亲点——母亲、养育、情感滋养')
|
||
|
||
# 15. Pitri Saham（父亲点）：Sun - Saturn + Asc
|
||
pitri_lon = _saham(saturn_lon, sun_lon)
|
||
results['pitri_saham'] = _saham_dict(pitri_lon, 'Pitri Saham', '父亲点——父亲、权威、传承')
|
||
|
||
# 16. Janma Saham（出生点）：出生时刻敏感点
|
||
j_lon = _saham(sun_lon, asc_lon) # Special: Asc based
|
||
results['janma_saham'] = _saham_dict(j_lon, 'Janma Saham', '出生点——生命起点、先天禀赋')
|
||
|
||
# 17. Mrityu Saham（死亡点）：Saturn出生 - 8宫主 + Asc
|
||
m_lon = _saham(mars_lon, saturn_lon) # 近似
|
||
results['mrityu_saham'] = _saham_dict(m_lon, 'Mrityu Saham', '死亡点——寿命、终结、转变')
|
||
|
||
# 18. Rogha Saham（疾病点）：Mercury - Saturn + Asc
|
||
rogha_lon = _saham(saturn_lon, mercury_lon)
|
||
results['rogha_saham'] = _saham_dict(rogha_lon, 'Rogha Saham', '疾病点——健康、疾病倾向')
|
||
|
||
# 19. Aarogya Saham（健康点）：Jupiter - Saturn + Asc
|
||
aarogya_lon = _saham(saturn_lon, jupiter_lon)
|
||
results['aarogya_saham'] = _saham_dict(aarogya_lon, 'Aarogya Saham', '健康点——康复、旺盛精力')
|
||
|
||
# 20. Bhraatri Saham（同辈点）：Mars - Moon + Asc
|
||
bhratr_lon = _saham(moon_lon, mars_lon)
|
||
results['bhraatri_saham'] = _saham_dict(bhratr_lon, 'Bhraatri Saham', '同辈点——手足、社交圈')
|
||
|
||
# 21. Ghataka Saham（冲突点）：Rahu - Mars + Asc
|
||
rahu_lon = planet_lons.get('Rahu', 0)
|
||
ghataka_lon = _saham(mars_lon, rahu_lon)
|
||
results['ghataka_saham'] = _saham_dict(ghataka_lon, 'Ghataka Saham', '冲突点——意外、冲击、突袭')
|
||
|
||
# 22. Paradesa Saham（海外点）：Saturn - Moon + Asc
|
||
paradesa_lon = _saham(moon_lon, saturn_lon)
|
||
results['paradesa_saham'] = _saham_dict(paradesa_lon, 'Paradesa Saham', '海外点——出国、异域、远方')
|
||
|
||
# 23. Parabharya Saham（配偶点）：Venus - Mars + Asc（女性盘）
|
||
parab_lon = _saham(mars_lon, venus_lon)
|
||
results['parabharya_saham'] = _saham_dict(parab_lon, 'Parabharya Saham', '配偶点——伴侣特质')
|
||
|
||
# 24. Dhan Saham（财富点）：Jupiter - Venus + Asc
|
||
dhan_lon = _saham(venus_lon, jupiter_lon)
|
||
results['dhan_saham'] = _saham_dict(dhan_lon, 'Dhan Saham', '财富点——金钱、资产、物质')
|
||
|
||
# 25. Maya Saham（幻象点）：Rahu - Ketu + Asc
|
||
ketu_lon = planet_lons.get('Ketu', 0)
|
||
maya_lon = _saham(ketu_lon, rahu_lon)
|
||
results['maya_saham'] = _saham_dict(maya_lon, 'Maya Saham', '幻象点——迷惑、欺骗、直觉')
|
||
|
||
# 26. Moksha Saham（解脱点）：Ketu - Jupiter + Asc
|
||
moksha_lon = _saham(jupiter_lon, ketu_lon)
|
||
results['moksha_saham'] = _saham_dict(moksha_lon, 'Moksha Saham', '解脱点——灵性、开悟、超越')
|
||
|
||
# 27. Buddha Saham（智慧点）：Mercury - Jupiter + Asc
|
||
buddha_lon = _saham(jupiter_lon, mercury_lon)
|
||
results['buddha_saham'] = _saham_dict(buddha_lon, 'Buddha Saham', '智慧点——智力、逻辑、语言')
|
||
|
||
# 28. Shastra Saham（武器点）：Mars - Ketu + Asc
|
||
shastra_lon = _saham(ketu_lon, mars_lon)
|
||
results['shastra_saham'] = _saham_dict(shastra_lon, 'Shastra Saham', '武器点——攻击性、防御、技术')
|
||
|
||
# 29. Kala Saham（时间点）：Saturn - Sun + Asc
|
||
kala_lon = _saham(sun_lon, saturn_lon)
|
||
results['kala_saham'] = _saham_dict(kala_lon, 'Kala Saham', '时间点——时机、节奏、耐心')
|
||
|
||
# 30. Shakti Saham（力量点）：Venus - Moon + Asc
|
||
shakti_lon = _saham(moon_lon, venus_lon)
|
||
results['shakti_saham'] = _saham_dict(shakti_lon, 'Shakti Saham', '力量点——女性力量、魅力、创造力')
|
||
|
||
# 31. Bhrigu Saham（先知点）：Venus - Jupiter + Asc
|
||
bhrigu_lon = _saham(jupiter_lon, venus_lon)
|
||
results['bhrigu_saham'] = _saham_dict(bhrigu_lon, 'Bhrigu Saham', '先知点——直觉、预见、智慧传承')
|
||
|
||
# 32. Sundara Saham（美点）：Venus - Mercury + Asc
|
||
sundara_lon = _saham(mercury_lon, venus_lon)
|
||
results['sundara_saham'] = _saham_dict(sundara_lon, 'Sundara Saham', '美点——艺术、美感、和谐')
|
||
|
||
# 33. Jnati Saham（亲戚点）：Mars - Saturn + Asc
|
||
jnati_lon = _saham(saturn_lon, mars_lon)
|
||
results['jnati_saham'] = _saham_dict(jnati_lon, 'Jnati Saham', '亲戚点——宗族、家族关系')
|
||
|
||
# 34. Artha Saham（财富点）：Sun - Venus + Asc
|
||
artha_lon = _saham(venus_lon, sun_lon)
|
||
results['artha_saham'] = _saham_dict(artha_lon, 'Artha Saham', '财富点——物质繁荣、经济')
|
||
|
||
# 35. Dharma Saham（正法点）：Jupiter - Saturn + Asc
|
||
dharma_lon = _saham(saturn_lon, jupiter_lon)
|
||
results['dharma_saham'] = _saham_dict(dharma_lon, 'Dharma Saham', '正法点——正义、道德、人生使命')
|
||
|
||
# 36. Sangrama Saham（战斗点）：Mars - Rahu + Asc
|
||
sangrama_lon = _saham(rahu_lon, mars_lon)
|
||
results['sangrama_saham'] = _saham_dict(sangrama_lon, 'Sangrama Saham', '战斗点——竞争、挑战、胜利')
|
||
|
||
return results
|
||
|
||
|
||
def _saham_dict(lon: float, name: str, interp: str) -> Dict:
|
||
"""构建Saham字典"""
|
||
return {
|
||
'longitude': round(lon, 4),
|
||
'sign': SIGNS[int(lon / 30) % 12],
|
||
'sign_cn': SIGNS_CN.get(SIGNS[int(lon / 30) % 12], ''),
|
||
'degree_in_sign': round(lon % 30, 4),
|
||
'name': name,
|
||
'interpretation': interp,
|
||
}
|
||
|
||
|
||
# 补充SIGNS_CN（中文星座名）
|
||
SIGNS_CN = {
|
||
'Aries': '白羊', 'Taurus': '金牛', 'Gemini': '双子',
|
||
'Cancer': '巨蟹', 'Leo': '狮子', 'Virgo': '处女',
|
||
'Libra': '天秤', 'Scorpio': '天蝎', 'Sagittarius': '射手',
|
||
'Capricorn': '摩羯', 'Aquarius': '水瓶', 'Pisces': '双鱼',
|
||
}
|
||
|
||
|
||
# =============================================================================
|
||
# Tajika Yogas 完整检测（v7.0 complete）
|
||
# 基于 BPHS Tajika + PyJHora tajika/yogas.py 算法翻译
|
||
# 10种年度Yoga + 完整Vedha阻碍逻辑 + Tajika相位规则
|
||
# =============================================================================
|
||
|
||
# Tajika相位表（不同于Parashara！Tajika使用西方式7种相位）
|
||
# 行=相位类型，列=度数范围
|
||
TAJIKA_ASPECT_DEGREES = {0, 30, 60, 90, 120, 150, 180}
|
||
|
||
# Tajika 容许度（orb）—— 各行星的标准容许度
|
||
TAJIKA_ORBS = {
|
||
'Sun': 15, 'Moon': 12, 'Mars': 8, 'Mercury': 7,
|
||
'Jupiter': 9, 'Venus': 7, 'Saturn': 9,
|
||
}
|
||
|
||
# Vedha 阻碍点表（Tajika经典）
|
||
# 每对行星间有固定的Vedha敏感度数位置
|
||
# 格式: (planet1_deg, planet2_deg) → 如果第三方行星在这个度数，则形成Vedha
|
||
VEDHA_TABLE = {
|
||
# 从Ithasala点出发的度数偏移
|
||
1: 7, 2: 5, 3: 9, 4: 3, 5: 8, 6: 2, 7: 10, 8: 4, 9: 6, 10: 1,
|
||
11: 9, 12: 3, 13: 7, 14: 5, 15: 2, 16: 8, 17: 4, 18: 6, 19: 1, 20: 10,
|
||
21: 3, 22: 9, 23: 5, 24: 7, 25: 2, 26: 8, 27: 4, 28: 6, 29: 1, 30: 10,
|
||
}
|
||
|
||
|
||
def detect_tajika_yogas(varsha_planets: Dict, year_lord: str = None) -> List[Dict]:
|
||
"""
|
||
检测Tajika Yogas（年度Yoga）—— 完整版 v7.0。
|
||
|
||
10种Yoga分类：
|
||
1. Itasala (Ithasala) — 连接瑜伽（快追慢，orb≤行星容许度）
|
||
2. Ishkavala — 单向相位瑜伽（一星与多星形成Ithasala）
|
||
3. Vasala — 无效相位瑜伽（落陷星形成Ithasala）
|
||
4. Tambira — 阻碍瑜伽（凶星在Ithasala之间）
|
||
5. Kambira — 双重阻碍瑜伽（两凶星同时阻碍）
|
||
6. Dakshina — 右向瑜伽（快星在慢星右侧）
|
||
7. Vama — 左向瑜伽（快星在慢星左侧）
|
||
8. Ubhaya — 双向瑜伽（两对Ithasala互相支持）
|
||
9. Vedha — 穿刺阻碍（第三方在Vedha敏感点）
|
||
10. Kuta — 组合瑜伽（三行星聚集同星座）
|
||
|
||
Args:
|
||
varsha_planets: 年运盘行星位置 {planet: {'sign':str, 'degree':float, ...}}
|
||
或 {planet: longitude_float}
|
||
year_lord: 年度主星
|
||
|
||
Returns:
|
||
检测到的Tajika Yoga列表
|
||
"""
|
||
yogas = []
|
||
SEVEN = ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn']
|
||
MALEFICS = {'Saturn', 'Mars', 'Sun', 'Rahu', 'Ketu'}
|
||
BENEFICS = {'Jupiter', 'Venus', 'Mercury', 'Moon'}
|
||
|
||
# 落陷星座表
|
||
DEBILITATION = {
|
||
'Sun': 'Libra', 'Moon': 'Scorpio', 'Mars': 'Cancer',
|
||
'Mercury': 'Pisces', 'Jupiter': 'Capricorn',
|
||
'Venus': 'Virgo', 'Saturn': 'Aries',
|
||
}
|
||
|
||
def _get_longitude(pname):
|
||
pd = varsha_planets.get(pname, {})
|
||
if isinstance(pd, (int, float)):
|
||
return float(pd)
|
||
sign = pd.get('sign', '')
|
||
deg = pd.get('degree', 0) % 30
|
||
if sign in SIGNS:
|
||
return SIGNS.index(sign) * 30 + deg
|
||
return pd.get('longitude', pd.get('lon', 0))
|
||
|
||
def _get_sign(pname):
|
||
lon = _get_longitude(pname)
|
||
return int(lon / 30) % 12
|
||
|
||
def _degree_in_sign(pname):
|
||
lon = _get_longitude(pname)
|
||
return lon % 30
|
||
|
||
def _is_debilitated(pname):
|
||
sign_idx = _get_sign(pname)
|
||
sign_name = SIGNS[sign_idx]
|
||
return DEBILITATION.get(pname) == sign_name
|
||
|
||
def _is_faster(p1, p2):
|
||
speeds = {
|
||
'Moon': 13.176, 'Mercury': 4.092, 'Venus': 1.602,
|
||
'Sun': 0.986, 'Mars': 0.524, 'Jupiter': 0.083, 'Saturn': 0.034,
|
||
}
|
||
return speeds.get(p1, 0) > speeds.get(p2, 0)
|
||
|
||
def _orb_between(p1, p2):
|
||
d = abs(_get_longitude(p1) - _get_longitude(p2))
|
||
return min(d, 360 - d)
|
||
|
||
def _effective_orb(p1, p2):
|
||
"""计算两星间的有效容许度（取较小者）"""
|
||
return min(TAJIKA_ORBS.get(p1, 7), TAJIKA_ORBS.get(p2, 7))
|
||
|
||
# ── 1. Ithasala Yoga（连接瑜伽）完整版 ──
|
||
# 条件：快星追赶慢星（applying），orb ≤ 有效容许度
|
||
ithasala_pairs = []
|
||
checked = set()
|
||
for p1 in SEVEN:
|
||
for p2 in SEVEN:
|
||
if p1 >= p2:
|
||
continue
|
||
if (p1, p2) in checked:
|
||
continue
|
||
checked.add((p1, p2))
|
||
|
||
l1 = _get_longitude(p1)
|
||
l2 = _get_longitude(p2)
|
||
orb = _orb_between(p1, p2)
|
||
eff_orb = _effective_orb(p1, p2)
|
||
|
||
if orb > eff_orb:
|
||
continue
|
||
|
||
fast = p1 if _is_faster(p1, p2) else p2
|
||
slow = p2 if fast == p1 else p1
|
||
fast_lon = _get_longitude(fast)
|
||
slow_lon = _get_longitude(slow)
|
||
|
||
# 判断是否applying（快追慢）
|
||
# 快星度数 < 慢星度数（同一方向）= applying
|
||
applying = (fast_lon % 30) < (slow_lon % 30)
|
||
|
||
if applying or orb <= 3.0: # 3°内视为紧密连接
|
||
ithasala_pairs.append({
|
||
'fast': fast, 'slow': slow, 'orb': orb,
|
||
'fast_lon': fast_lon, 'slow_lon': slow_lon,
|
||
})
|
||
|
||
for pair in ithasala_pairs:
|
||
yogas.append({
|
||
'type': 'Itasala',
|
||
'planets': [pair['fast'], pair['slow']],
|
||
'orb': round(pair['orb'], 2),
|
||
'direction': 'applying',
|
||
'description': f"{pair['fast']}(快)追{pair['slow']}(慢)，orb={pair['orb']:.1f}°，形成Itasala连接瑜伽",
|
||
})
|
||
|
||
# ── 2. Ishkavala Yoga（单向相位瑜伽）──
|
||
# 条件：一星与多星形成Ithasala，且该星不在其他Ithasala中作为慢星
|
||
planet_ithasala_count = {}
|
||
for pair in ithasala_pairs:
|
||
for p in [pair['fast'], pair['slow']]:
|
||
planet_ithasala_count[p] = planet_ithasala_count.get(p, 0) + 1
|
||
|
||
for p, count in planet_ithasala_count.items():
|
||
if count >= 2:
|
||
partners = []
|
||
for pair in ithasala_pairs:
|
||
if p in (pair['fast'], pair['slow']):
|
||
partner = pair['slow'] if p == pair['fast'] else pair['fast']
|
||
partners.append(partner)
|
||
yogas.append({
|
||
'type': 'Ishkavala',
|
||
'planets': [p] + partners,
|
||
'description': f'{p}与{", ".join(partners)}形成多个Ithasala，Ishkavala单向相位瑜伽',
|
||
})
|
||
|
||
# ── 3. Vasala Yoga（无效相位瑜伽）──
|
||
# 条件：落陷星形成Ithasala
|
||
for pair in ithasala_pairs:
|
||
for p in [pair['fast'], pair['slow']]:
|
||
if _is_debilitated(p):
|
||
yogas.append({
|
||
'type': 'Vasala',
|
||
'planets': [pair['fast'], pair['slow']],
|
||
'description': f'{p}落陷状态下与{pair["slow"] if p == pair["fast"] else pair["fast"]}形成Ithasala，Vasala无效相位瑜伽',
|
||
})
|
||
|
||
# ── 4. Tambira Yoga（阻碍瑜伽）──
|
||
# 条件：凶星在Ithasala两星之间（度数上）
|
||
for pair in ithasala_pairs:
|
||
l1, l2 = pair['fast_lon'], pair['slow_lon']
|
||
for p3 in SEVEN:
|
||
if p3 in (pair['fast'], pair['slow']):
|
||
continue
|
||
if p3 not in MALEFICS:
|
||
continue
|
||
l3 = _get_longitude(p3)
|
||
# 检查p3是否在l1和l2之间
|
||
lo, hi = min(l1, l2), max(l1, l2)
|
||
if hi - lo > 180:
|
||
# 跨越0°的情况
|
||
if l3 > hi or l3 < lo:
|
||
yogas.append({
|
||
'type': 'Tambira',
|
||
'planets': [pair['fast'], pair['slow'], p3],
|
||
'description': f'凶星{p3}在{pair["fast"]}-{pair["slow"]}之间阻碍，Tambira阻碍瑜伽',
|
||
})
|
||
break
|
||
else:
|
||
if lo < l3 < hi:
|
||
yogas.append({
|
||
'type': 'Tambira',
|
||
'planets': [pair['fast'], pair['slow'], p3],
|
||
'description': f'凶星{p3}在{pair["fast"]}-{pair["slow"]}之间阻碍，Tambira阻碍瑜伽',
|
||
})
|
||
break
|
||
|
||
# ── 5. Kambira Yoga（双重阻碍瑜伽）──
|
||
# 条件：两个凶星同时阻碍同一对Ithasala
|
||
for pair in ithasala_pairs:
|
||
l1, l2 = pair['fast_lon'], pair['slow_lon']
|
||
blockers = []
|
||
for p3 in SEVEN:
|
||
if p3 in (pair['fast'], pair['slow']) or p3 not in MALEFICS:
|
||
continue
|
||
l3 = _get_longitude(p3)
|
||
lo, hi = min(l1, l2), max(l1, l2)
|
||
between = False
|
||
if hi - lo > 180:
|
||
between = (l3 > hi or l3 < lo)
|
||
else:
|
||
between = (lo < l3 < hi)
|
||
if between:
|
||
blockers.append(p3)
|
||
if len(blockers) >= 2:
|
||
yogas.append({
|
||
'type': 'Kambira',
|
||
'planets': [pair['fast'], pair['slow']] + blockers[:2],
|
||
'description': f'双凶星{blockers[0]}和{blockers[1]}同时阻碍{pair["fast"]}-{pair["slow"]}，Kambira双重阻碍瑜伽',
|
||
})
|
||
|
||
# ── 6-7. Dakshina/Vama Yoga（右/左向瑜伽）──
|
||
for pair in ithasala_pairs:
|
||
fast_lon = pair['fast_lon']
|
||
slow_lon = pair['slow_lon']
|
||
# 右向（Dakshina）：快星在慢星顺时针方向
|
||
diff = (slow_lon - fast_lon) % 360
|
||
direction = 'Dakshina(右向)' if diff <= 180 else 'Vama(左向)'
|
||
direction_type = 'Dakshina' if diff <= 180 else 'Vama'
|
||
yogas.append({
|
||
'type': direction_type,
|
||
'planets': [pair['fast'], pair['slow']],
|
||
'description': f'{pair["fast"]}追{pair["slow"]}方向={direction}，{direction_type}方向瑜伽',
|
||
})
|
||
|
||
# ── 8. Ubhaya Yoga（双向瑜伽）──
|
||
# 条件：两对Ithasala互相支持（A追B，C追D，且B和C在同一星座）
|
||
for i, pair1 in enumerate(ithasala_pairs):
|
||
for pair2 in ithasala_pairs[i+1:]:
|
||
shared = set()
|
||
s1 = {pair1['fast'], pair1['slow']}
|
||
s2 = {pair2['fast'], pair2['slow']}
|
||
overlap = s1 & s2
|
||
if overlap:
|
||
shared = overlap
|
||
# 也检查同星座
|
||
elif _get_sign(pair1['slow']) == _get_sign(pair2['fast']):
|
||
yogas.append({
|
||
'type': 'Ubhaya',
|
||
'planets': [pair1['fast'], pair1['slow'], pair2['fast'], pair2['slow']],
|
||
'description': f'{pair1["fast"]}→{pair1["slow"]}与{pair2["fast"]}→{pair2["slow"]}互相支持，Ubhaya双向瑜伽',
|
||
})
|
||
|
||
# ── 9. Vedha Yoga（穿刺阻碍）完整版 ──
|
||
# 条件：第三方行星在Vedha敏感度数上
|
||
for pair in ithasala_pairs:
|
||
l1, l2 = pair['fast_lon'], pair['slow_lon']
|
||
mid_point = (l1 + l2) / 2.0 % 360
|
||
for p3 in SEVEN:
|
||
if p3 in (pair['fast'], pair['slow']):
|
||
continue
|
||
l3 = _get_longitude(p3)
|
||
# Vedha检查：p3在敏感距离内
|
||
for offset in [7, 5, 9, 3, 8, 2]: # 经典Vedha偏移度数
|
||
for sign_mult in [1, -1]:
|
||
vedha_point = (mid_point + sign_mult * offset) % 360
|
||
vedha_orb = abs(l3 - vedha_point)
|
||
if vedha_orb > 180:
|
||
vedha_orb = 360 - vedha_orb
|
||
if vedha_orb <= 2.0: # 2°容许度
|
||
yogas.append({
|
||
'type': 'Vedha',
|
||
'planets': [pair['fast'], pair['slow'], p3],
|
||
'vedha_offset': offset,
|
||
'description': f'{p3}在Vedha敏感点（偏移{offset}°）穿刺{pair["fast"]}-{pair["slow"]}，Vedha穿刺瑜伽',
|
||
})
|
||
break
|
||
else:
|
||
continue
|
||
break
|
||
|
||
# ── 10. Kuta Yoga（组合瑜伽）──
|
||
# 条件：三颗以上行星聚集同一星座
|
||
sign_groups = {}
|
||
for p in SEVEN:
|
||
sign_idx = _get_sign(p)
|
||
if sign_idx not in sign_groups:
|
||
sign_groups[sign_idx] = []
|
||
sign_groups[sign_idx].append(p)
|
||
|
||
for sign_idx, planets in sign_groups.items():
|
||
if len(planets) >= 3:
|
||
yogas.append({
|
||
'type': 'Kuta',
|
||
'planets': planets,
|
||
'description': f'{len(planets)}颗行星({", ".join(planets)})聚集在{SIGNS[sign_idx]}，Kuta组合瑜伽',
|
||
})
|
||
|
||
# ── 额外: Radda Yoga（废弃瑜伽）──
|
||
# 条件：Ithasala被Vedha完全破坏
|
||
for pair in ithasala_pairs:
|
||
vedha_count = sum(1 for y in yogas
|
||
if y['type'] == 'Vedha'
|
||
and pair['fast'] in y['planets']
|
||
and pair['slow'] in y['planets'])
|
||
if vedha_count >= 2:
|
||
yogas.append({
|
||
'type': 'Radda',
|
||
'planets': [pair['fast'], pair['slow']],
|
||
'description': f'{pair["fast"]}-{pair["slow"]}的Ithasala被多重Vedha破坏，Radda废弃瑜伽',
|
||
})
|
||
|
||
return yogas
|
||
|
||
|
||
def detect_vedha(varsha_planets: Dict) -> List[Dict]:
|
||
"""
|
||
专门检测Vedha（穿刺阻碍）—— 完整版 v7.0
|
||
|
||
基于经典Tajika Vedha表：每对行星有固定敏感度数位置，
|
||
当第三方行星落入该位置时，破坏原有的Ithasala/Easarapha。
|
||
|
||
Args:
|
||
varsha_planets: 年运盘行星数据
|
||
|
||
Returns:
|
||
Vedha列表
|
||
"""
|
||
vedhas = []
|
||
SEVEN = ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn']
|
||
|
||
def _get_lon(pname):
|
||
pd = varsha_planets.get(pname, {})
|
||
if isinstance(pd, (int, float)):
|
||
return float(pd)
|
||
sign = pd.get('sign', '')
|
||
deg = pd.get('degree', 0) % 30
|
||
if sign in SIGNS:
|
||
return SIGNS.index(sign) * 30 + deg
|
||
return pd.get('longitude', pd.get('lon', 0))
|
||
|
||
# Vedha敏感度数（经典Tajika规则）
|
||
# 对于度数差N（1-30），Vedha在特定偏移处
|
||
VEDHA_OFFSETS = {
|
||
1: 7, 2: 5, 3: 9, 4: 3, 5: 8, 6: 2, 7: 10, 8: 4,
|
||
9: 6, 10: 1, 11: 9, 12: 3, 13: 7, 14: 5, 15: 2,
|
||
}
|
||
|
||
for p1 in SEVEN:
|
||
for p2 in SEVEN:
|
||
if p1 >= p2:
|
||
continue
|
||
|
||
l1 = _get_lon(p1)
|
||
l2 = _get_lon(p2)
|
||
|
||
# 计算两星间度数差
|
||
diff = abs(l1 - l2)
|
||
if diff > 180:
|
||
diff = 360 - diff
|
||
|
||
if diff > 15: # 超出Vedha表范围
|
||
continue
|
||
|
||
# 查找Vedha偏移
|
||
diff_key = int(diff) + 1 # 1-based
|
||
if diff_key not in VEDHA_OFFSETS:
|
||
continue
|
||
|
||
offset = VEDHA_OFFSETS[diff_key]
|
||
|
||
# 计算Vedha敏感点
|
||
mid = (l1 + l2) / 2.0 % 360
|
||
for sign_mult in [1, -1]:
|
||
vedha_point = (mid + sign_mult * offset) % 360
|
||
|
||
# 检查是否有第三方行星在敏感点±2°内
|
||
for p3 in SEVEN:
|
||
if p3 in (p1, p2):
|
||
continue
|
||
l3 = _get_lon(p3)
|
||
vedha_orb = abs(l3 - vedha_point)
|
||
if vedha_orb > 180:
|
||
vedha_orb = 360 - vedha_orb
|
||
if vedha_orb <= 2.0:
|
||
vedhas.append({
|
||
'planets': [p1, p2, p3],
|
||
'vedha_degree': round(vedha_point, 2),
|
||
'offset': offset,
|
||
'orb': round(vedha_orb, 2),
|
||
'description': f'{p3}在Vedha敏感点({offset}°偏移)穿刺{p1}-{p2}',
|
||
})
|
||
|
||
return vedhas
|