root/Jyotisha
2
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
cf7598b33784b6e41eb7338900e0acc22fb7d884
Jyotisha/scripts/yoga_engine.py
T

1986 lines
94 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Yoga 规则引擎 v1.0 (数据驱动架构)
从 JSON 规则配置中读取 Yoga 定义，通用条件解释器执行检测。
设计原则:
- 规则完全数据驱动，加新 Yoga 只需改 JSON
- 条件类型可扩展，覆盖 BPHS/PyJHora 主流 Yoga 模式
- 与原 cmd_yoga() API 兼容
"""
import ast
import json
import os
from typing import Dict, List, Any, Optional
# ============================================================================
# 基础常量（自包含，避免循环导入）
# ============================================================================
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'
}
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'
}
MOOLATRIKONA_SIGN = {
'Sun': 'Leo', 'Moon': 'Taurus', 'Mars': 'Aries', 'Mercury': 'Virgo',
'Jupiter': 'Sagittarius', 'Venus': 'Libra', 'Saturn': 'Aquarius'
}
# PyJHora const.friendly_planets mapped from planet ids to names.
FRIENDLY_PLANETS = {
'Sun': ['Moon', 'Mars', 'Jupiter'],
'Moon': ['Sun', 'Mercury'],
'Mars': ['Sun', 'Moon', 'Jupiter'],
'Mercury': ['Sun', 'Venus'],
'Jupiter': ['Sun', 'Moon', 'Mars'],
'Venus': ['Mercury', 'Saturn', 'Rahu'],
'Saturn': ['Mercury', 'Venus', 'Rahu'],
'Rahu': ['Venus', 'Saturn'],
'Ketu': ['Sun', 'Mars'],
}
PLANET_CN = {
"Ketu": "南交点Ketu", "Venus": "金星Venus", "Sun": "太阳Sun",
"Moon": "月亮Moon", "Mars": "火星Mars", "Rahu": "北交点Rahu",
"Jupiter": "木星Jupiter", "Saturn": "土星Saturn", "Mercury": "水星Mercury"
}
BENEFICS = ['Jupiter', 'Venus', 'Mercury', 'Moon']
MALEFICS = ['Mars', 'Saturn', 'Sun', 'Rahu', 'Ketu']
MOVABLE_SIGNS = ['Aries', 'Cancer', 'Libra', 'Capricorn']
FIXED_SIGNS = ['Taurus', 'Leo', 'Scorpio', 'Aquarius']
DUAL_SIGNS = ['Gemini', 'Virgo', 'Sagittarius', 'Pisces']
ALL_PLANETS = ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn', 'Rahu', 'Ketu']
PLANET_INDEX = {planet: idx for idx, planet in enumerate(ALL_PLANETS)}
RAHU_KETU_OWNED_SIGN_INDEX = {'Rahu': 10, 'Ketu': 7}
# PyJHora const.house_strengths_of_planets, copied to make Yoga rule alignment deterministic.
# Strength scale: 5 own/lord, 4 exalted, 3 friend, 2 neutral, 1 enemy, 0 debilitated.
HOUSE_STRENGTHS = {
'Sun': [4, 1, 2, 2, 5, 2, 0, 3, 3, 1, 1, 3],
'Moon': [2, 4, 3, 5, 3, 3, 2, 0, 2, 2, 2, 2],
'Mars': [5, 2, 1, 0, 3, 1, 2, 5, 3, 4, 2, 3],
'Mercury': [2, 3, 5, 1, 3, 5, 3, 2, 2, 2, 2, 0],
'Jupiter': [3, 1, 1, 4, 3, 3, 1, 3, 5, 0, 2, 5],
'Venus': [2, 5, 3, 1, 1, 0, 5, 2, 3, 3, 3, 4],
'Saturn': [0, 3, 3, 1, 1, 3, 4, 1, 2, 5, 5, 2],
'Rahu': [1, 4, 4, 1, 1, 3, 3, 0, 0, 3, 1, 3],
'Ketu': [1, 0, 0, 1, 1, 3, 3, 4, 4, 3, 1, 3],
}
def _get_dignity_level(planet: str, sign: str) -> str:
"""判断行星在某星座的尊严等级"""
if EXALTATION.get(planet) == sign:
return 'EXALTED'
if SIGN_LORDS.get(sign) == planet:
return 'OWN_SIGN'
if MOOLATRIKONA_SIGN.get(planet) == sign:
return 'MOOLATRIKONA'
if DEBILITATION.get(planet) == sign:
return 'DEBILITATED'
return 'NEUTRAL'
# ============================================================================
# YogaContext: 封装星盘数据，提供查询接口
# ============================================================================
class YogaContext:
"""Yoga 检测上下文。封装行星数据并提供各类查询方法。"""
def __init__(self, planets: Dict[str, Dict], ascendant: str, context: Optional[Dict] = None):
self.planets = planets # name -> {sign, house, degree, ...}
self.ascendant = ascendant
self.asc_idx = SIGNS.index(ascendant) if ascendant in SIGNS else 0
self.context = context or {}
self.d9 = self.context.get("d9", {}) if isinstance(self.context, dict) else {}
self.d60 = self.context.get("d60", {}) if isinstance(self.context, dict) else {}
self.panchanga = self.context.get("panchanga", {}) if isinstance(self.context, dict) else {}
self.upagraha = self.context.get("upagraha", {}) if isinstance(self.context, dict) else {}
# 预计算 D1 宫主星。v6.0.39: Scorpio/Aquarius follow PyJHora's dynamic co-lord resolver
# (Scorpio: stronger of Mars/Ketu; Aquarius: stronger of Saturn/Rahu), while SIGN_LORDS stays
# as the classical fixed fallback for dignity tables and non-Jaimini contexts.
self._house_lords: Dict[int, str] = {}
for h in range(1, 13):
sign = SIGNS[(self.asc_idx + h - 1) % 12]
self._house_lords[h] = self._resolve_sign_lord(sign)
# 预计算 D9 宫主星（用于依赖 Navamsa 的 B.V. Raman Yoga）
d9_asc = self.d9.get("ascendant")
d9_asc_idx = SIGNS.index(d9_asc) if d9_asc in SIGNS else None
self._d9_house_lords: Dict[int, str] = {}
if d9_asc_idx is not None:
for h in range(1, 13):
sign = SIGNS[(d9_asc_idx + h - 1) % 12]
self._d9_house_lords[h] = self._resolve_sign_lord(sign)
# 预计算 D60 宫主星（用于依赖 Shashtiamsa 的 B.V. Raman Yoga）
d60_asc = self.d60.get("ascendant")
d60_asc_idx = SIGNS.index(d60_asc) if d60_asc in SIGNS else None
self._d60_house_lords: Dict[int, str] = {}
if d60_asc_idx is not None:
for h in range(1, 13):
sign = SIGNS[(d60_asc_idx + h - 1) % 12]
self._d60_house_lords[h] = self._resolve_sign_lord(sign)
def _sign_index_of_planet(self, planet: str) -> Optional[int]:
sign = self.sign_of(planet)
return SIGNS.index(sign) if sign in SIGNS else None
def _rasi_drishti_sign_indices_from(self, sign_idx: int) -> List[int]:
sign_name = SIGNS[sign_idx]
if sign_name in MOVABLE_SIGNS:
return [i for i in [1, 4, 7, 10] if i not in ((sign_idx + 1) % 12, (sign_idx - 1) % 12)]
if sign_name in FIXED_SIGNS:
return [i for i in [0, 3, 6, 9] if i not in ((sign_idx + 1) % 12, (sign_idx - 1) % 12)]
return [SIGNS.index(s) for s in DUAL_SIGNS if SIGNS.index(s) != sign_idx]
def _stronger_co_lord(self, planet1: str, planet2: str) -> str:
"""Approximate PyJHora stronger_planet_from_planet_positions() for Sc/Aq co-lords."""
h1 = self._sign_index_of_planet(planet1)
h2 = self._sign_index_of_planet(planet2)
if h1 is None:
return planet2
if h2 is None:
return planet1
node_owned_sign = RAHU_KETU_OWNED_SIGN_INDEX.get(planet1) or RAHU_KETU_OWNED_SIGN_INDEX.get(planet2)
if node_owned_sign is not None:
if h1 == node_owned_sign and h2 != node_owned_sign:
return planet2
if h2 == node_owned_sign and h1 != node_owned_sign:
return planet1
planet1_co_count = sum(1 for p in self.planets if self._sign_index_of_planet(p) == h1) - 1
planet2_co_count = sum(1 for p in self.planets if self._sign_index_of_planet(p) == h2) - 1
if planet1_co_count > planet2_co_count:
return planet1
if planet2_co_count > planet1_co_count:
return planet2
dispositor1 = self._resolve_sign_lord(SIGNS[h1], dynamic_co_lords=False)
dispositor2 = self._resolve_sign_lord(SIGNS[h2], dynamic_co_lords=False)
support1 = sum(
self._sign_index_of_planet(p) == h1
for p in ['Mercury', 'Jupiter', dispositor1]
if p in self.planets
)
support1 += sum(
p in self.planets and self._sign_index_of_planet(p) in self._rasi_drishti_sign_indices_from(h1)
for p in ['Mercury', 'Jupiter', dispositor1]
)
support2 = sum(
self._sign_index_of_planet(p) == h2
for p in ['Mercury', 'Jupiter', dispositor2]
if p in self.planets
)
support2 += sum(
p in self.planets and self._sign_index_of_planet(p) in self._rasi_drishti_sign_indices_from(h2)
for p in ['Mercury', 'Jupiter', dispositor2]
)
if support1 > support2:
return planet1
if support2 > support1:
return planet2
strength1 = HOUSE_STRENGTHS.get(planet1, [None] * 12)[h1]
strength2 = HOUSE_STRENGTHS.get(planet2, [None] * 12)[h2]
if strength1 == 4 and strength2 is not None and strength1 > strength2:
return planet1
if strength2 == 4 and strength1 is not None and strength2 > strength1:
return planet2
def modality_rank(sign_idx: int) -> int:
sign_name = SIGNS[sign_idx]
if sign_name in DUAL_SIGNS:
return 3
if sign_name in FIXED_SIGNS:
return 2
return 1
rank1 = modality_rank(h1)
rank2 = modality_rank(h2)
if rank1 > rank2:
return planet1
if rank2 > rank1:
return planet2
degree1 = self.degree_of(planet1)
degree2 = self.degree_of(planet2)
if degree1 is not None and degree2 is not None:
return planet1 if degree1 > degree2 else planet2
return planet1
def _resolve_sign_lord(self, sign: str, dynamic_co_lords: bool = True) -> Optional[str]:
if not dynamic_co_lords:
return SIGN_LORDS.get(sign)
if sign == 'Scorpio':
return self._stronger_co_lord('Mars', 'Ketu')
if sign == 'Aquarius':
return self._stronger_co_lord('Saturn', 'Rahu')
return SIGN_LORDS.get(sign)
# --- 基础查询 ---
def house_of(self, planet: str) -> Optional[int]:
return self.planets.get(planet, {}).get("house")
def sign_of(self, planet: str) -> Optional[str]:
return self.planets.get(planet, {}).get("sign")
def degree_of(self, planet: str) -> Optional[float]:
return self.planets.get(planet, {}).get("degree")
def lord_of_house(self, house: int) -> Optional[str]:
return self._house_lords.get(house)
def planets_in_house(self, house: int) -> List[str]:
return [p for p, info in self.planets.items() if info.get("house") == house]
# --- D9 / Panchanga / Upagraha 扩展上下文 ---
def d9_house_of(self, planet: str) -> Optional[int]:
return self.d9.get("planets", {}).get(planet, {}).get("house")
def d9_sign_of(self, planet: str) -> Optional[str]:
return self.d9.get("planets", {}).get(planet, {}).get("sign")
def d9_lord_of_house(self, house: int) -> Optional[str]:
return self._d9_house_lords.get(house)
def navamsa_dispositor(self, planet: str) -> Optional[str]:
sign = self.d9_sign_of(planet)
return self._resolve_sign_lord(sign) if sign else None
# --- D60 / Shashtiamsa 扩展上下文 ---
def d60_house_of(self, planet: str) -> Optional[int]:
return self.d60.get("planets", {}).get(planet, {}).get("house")
def d60_sign_of(self, planet: str) -> Optional[str]:
return self.d60.get("planets", {}).get(planet, {}).get("sign")
def d60_lord_of_house(self, house: int) -> Optional[str]:
return self._d60_house_lords.get(house)
def shashtiamsa_dispositor(self, planet: str) -> Optional[str]:
sign = self.d60_sign_of(planet)
return self._resolve_sign_lord(sign) if sign else None
# --- D9 尊严查询（用于跨分盘 Yoga 判断） ---
def is_exalted_in_d9(self, planet: str) -> bool:
s = self.d9_sign_of(planet)
return s is not None and EXALTATION.get(planet) == s
def is_debilitated_in_d9(self, planet: str) -> bool:
s = self.d9_sign_of(planet)
return s is not None and DEBILITATION.get(planet) == s
def is_own_sign_in_d9(self, planet: str) -> bool:
s = self.d9_sign_of(planet)
return s is not None and self._resolve_sign_lord(s) == planet
def is_moolatrikona_in_d9(self, planet: str) -> bool:
s = self.d9_sign_of(planet)
return s is not None and MOOLATRIKONA_SIGN.get(planet) == s
def dignity_in_d9(self, planet: str) -> str:
s = self.d9_sign_of(planet)
return _get_dignity_level(planet, s) if s else 'NEUTRAL'
def is_friendly_navamsa(self, planet: str) -> bool:
"""Check if planet is in friendly sign in D9 (used by dharidhra method1)."""
s = self.d9_sign_of(planet)
if not s:
return False
lord = self._resolve_sign_lord(s)
return lord in FRIENDLY_PLANETS.get(planet, [])
def is_unfriendly_navamsa(self, planet: str) -> bool:
"""Check if planet is in unfriendly/enemy sign in D9."""
s = self.d9_sign_of(planet)
if not s:
return False
lord = self._resolve_sign_lord(s)
# Enemy if not friendly and not self
if lord == planet:
return False
return lord not in FRIENDLY_PLANETS.get(planet, [])
# --- Functional Malefic / Benefic（基于月亮盈亏和宫主关系） ---
def functional_malefics(self) -> List[str]:
"""
Return functional malefics for this chart.
Rules (per PyJHora/B.V. Raman):
- Lords of 3, 6, 8, 11, 12 are functional malefics
- Mercury is malefic if conjunct with malefic
- Moon is malefic if waning (Krishna Paksha)
"""
fm = []
dusthana_lords = [self.lord_of_house(h) for h in [3, 6, 8, 11, 12]]
fm.extend([l for l in dusthana_lords if l])
# Mercury becomes functional malefic if conjunct with natural malefic
if 'Mercury' in self.planets:
merc_h = self.house_of('Mercury')
merc_conj_malefic = any(
m in self.planets and self.house_of(m) == merc_h
for m in ['Mars', 'Saturn', 'Rahu', 'Ketu', 'Sun']
)
if merc_conj_malefic and 'Mercury' not in fm:
fm.append('Mercury')
# Waning Moon is functional malefic
if self.is_waning_moon() and 'Moon' in self.planets and 'Moon' not in fm:
fm.append('Moon')
return list(set(fm))
def functional_benefics(self) -> List[str]:
"""Return functional benefics = all planets minus functional malefics minus natural malefics."""
fm = set(self.functional_malefics())
nm = set(MALEFICS)
return [p for p in ALL_PLANETS if p in self.planets and p not in fm and p not in nm]
# --- Shashtiamsa / Vaiseshikamsa 简化评分 ---
def is_shashtiamsa_evil(self, planet: str) -> bool:
"""
Simplified evil shashtiamsa check.
In D60, if planet is debilitated, in enemy sign, or in dusthana house → evil.
"""
s = self.d60_sign_of(planet)
h = self.d60_house_of(planet)
if s is None or h is None:
return False
debil = DEBILITATION.get(planet) == s
lord = self._resolve_sign_lord(s)
enemy = lord not in FRIENDLY_PLANETS.get(planet, []) and lord != planet
dusthana = h in [6, 8, 12]
return debil or enemy or dusthana
def is_shashtiamsa_good(self, planet: str) -> bool:
"""Good shashtiamsa: exalted, own sign, or moolatrikona in D60."""
s = self.d60_sign_of(planet)
if s is None:
return False
return EXALTATION.get(planet) == s or self._resolve_sign_lord(s) == planet or MOOLATRIKONA_SIGN.get(planet) == s
def vaiseshikamsa_score(self, planet: str) -> int:
"""
Simplified Vaiseshikamsa scoring (0-20 scale, higher = better).
Combines D1 dignity + D9 dignity + D60 dignity.
"""
score = 0
# D1 dignity (0-8)
d1_dignity = self.dignity(planet)
d1_scores = {'EXALTED': 8, 'OWN_SIGN': 7, 'MOOLATRIKONA': 6, 'NEUTRAL': 3, 'DEBILITATED': 0}
score += d1_scores.get(d1_dignity, 3)
# D9 dignity (0-7)
d9_dignity = self.dignity_in_d9(planet)
score += d1_scores.get(d9_dignity, 3) - 1 # slightly lower weight
# D60 dignity (0-5)
s60 = self.d60_sign_of(planet)
if s60:
d60_dignity = _get_dignity_level(planet, s60)
d60_scores = {'EXALTED': 5, 'OWN_SIGN': 4, 'MOOLATRIKONA': 3, 'NEUTRAL': 2, 'DEBILITATED': 0}
score += d60_scores.get(d60_dignity, 2)
return score
def tithi(self) -> Optional[int]:
return self.panchanga.get("tithi")
def is_waning_moon(self) -> bool:
return bool(self.panchanga.get("is_waning_moon"))
def upagraha_house(self, name: str) -> Optional[int]:
payload = self.upagraha.get(str(name).lower(), {})
return payload.get("house")
def upagraha_sign(self, name: str) -> Optional[str]:
payload = self.upagraha.get(str(name).lower(), {})
return payload.get("sign")
# --- 尊严 ---
def is_exalted(self, planet: str) -> bool:
s = self.sign_of(planet)
return s is not None and EXALTATION.get(planet) == s
def is_own_sign(self, planet: str) -> bool:
s = self.sign_of(planet)
return s is not None and self._resolve_sign_lord(s) == planet
def is_moolatrikona(self, planet: str) -> bool:
s = self.sign_of(planet)
return s is not None and MOOLATRIKONA_SIGN.get(planet) == s
def is_debilitated(self, planet: str) -> bool:
s = self.sign_of(planet)
return s is not None and DEBILITATION.get(planet) == s
def dignity(self, planet: str) -> str:
s = self.sign_of(planet)
return _get_dignity_level(planet, s) if s else 'NEUTRAL'
# --- 宫位性质 ---
def is_kendra(self, house: int) -> bool:
return house in [1, 4, 7, 10]
def is_trikona(self, house: int) -> bool:
return house in [1, 5, 9]
def is_dusthana(self, house: int) -> bool:
return house in [6, 8, 12]
def is_upachaya(self, house: int) -> bool:
return house in [3, 6, 10, 11]
def is_maraka(self, house: int) -> bool:
return house in [2, 7]
def is_badhaka(self, house: int) -> bool:
"""Badhaka 宫：基本盘7宫，固定盘9宫，变动盘11宫"""
asc = self.ascendant
if asc in ['Aries', 'Cancer', 'Libra', 'Capricorn']:
return house == 11
if asc in ['Taurus', 'Leo', 'Scorpio', 'Aquarius']:
return house == 9
return house == 7
# --- 相对宫位关系 ---
def house_offset(self, from_house: int, to_house: int) -> int:
"""从 from_house 到 to_house 的宫位偏移 (0=同宫, 1=下一宫, ...)"""
return (to_house - from_house) % 12
def is_kendra_from(self, planet: str, from_planet: str) -> bool:
h1 = self.house_of(from_planet)
h2 = self.house_of(planet)
if h1 is None or h2 is None:
return False
return self.house_offset(h1, h2) in [0, 3, 6, 9]
def is_trikona_from(self, planet: str, from_planet: str) -> bool:
h1 = self.house_of(from_planet)
h2 = self.house_of(planet)
if h1 is None or h2 is None:
return False
return self.house_offset(h1, h2) in [0, 4, 8]
def is_2nd_or_12th_from(self, planet: str, from_planet: str) -> bool:
h1 = self.house_of(from_planet)
h2 = self.house_of(planet)
if h1 is None or h2 is None:
return False
return self.house_offset(h1, h2) in [1, 11]
# --- 角色解析 ---
def resolve(self, ref: Any) -> List[str]:
"""
解析行星引用为具体行星名称列表。
支持: 字符串行星名、角色对象、角色字符串。
"""
if isinstance(ref, str):
if ref in self.planets:
return [ref]
if ref == "benefics":
return [p for p in BENEFICS if p in self.planets]
if ref == "malefics":
return [p for p in MALEFICS if p in self.planets]
if ref == "all":
return list(self.planets.keys())
if ref in ("visible", "sun_to_saturn"):
return [p for p in ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn'] if p in self.planets]
if ref == "kendra_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [1, 4, 7, 10]]))
if ref == "trikona_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [1, 5, 9]]))
if ref == "dusthana_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [6, 8, 12]]))
if ref == "upachaya_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [3, 6, 10, 11]]))
if ref.startswith("lord:"):
house = int(ref.split(":")[1])
lord = self._house_lords.get(house)
return [lord] if lord else []
return []
if isinstance(ref, dict):
role = ref.get("role")
if role == "lord":
house = ref.get("house")
lord = self._house_lords.get(house)
return [lord] if lord else []
if role == "kendra_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [1, 4, 7, 10]]))
if role == "trikona_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [1, 5, 9]]))
if role == "dusthana_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [6, 8, 12]]))
if role == "upachaya_lords":
return list(dict.fromkeys([self._house_lords[h] for h in [3, 6, 10, 11]]))
if role == "benefics":
return [p for p in BENEFICS if p in self.planets]
if role == "malefics":
return [p for p in MALEFICS if p in self.planets]
if role == "all":
return list(self.planets.keys())
if role in ("visible", "sun_to_saturn"):
return [p for p in ['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn'] if p in self.planets]
if role == "set":
return [p for p in ref.get("planets", []) if p in self.planets]
return []
def resolve_single(self, ref: Any) -> Optional[str]:
"""解析为单个行星，返回 None 或行星名"""
lst = self.resolve(ref)
return lst[0] if lst else None
# ============================================================================
# YogaEngine: 规则加载与检测
# ============================================================================
class YogaEngine:
"""Yoga 检测引擎。从 JSON 加载规则，对星盘执行条件匹配。"""
def __init__(self, rules_path: str):
with open(rules_path, 'r', encoding='utf-8') as f:
data = json.load(f)
self.schema_version = data.get("schema_version", "1.0")
self.rules = [r for r in data.get("rules", []) if r.get("enabled", True)]
def detect(self, planets: Dict[str, Dict], ascendant: str, context: Optional[Dict] = None) -> List[Dict]:
"""
检测 Yoga。
返回: [{name, name_cn, combination, effects, strength, source, bvr_id, category}, ...]
"""
ctx = YogaContext(planets, ascendant, context=context)
results = []
seen_dedup = set()
# 规则匹配
for rule in self.rules:
matches = self._eval_rule(rule, ctx)
for m in matches:
entry = {
"name": rule["name"],
"name_cn": rule["name_cn"],
"combination": m.get("combination", ""),
"effects": rule.get("effects", []),
"strength": m.get("strength", rule.get("strength", "中")),
"source": rule.get("source", ""),
"bvr_id": rule.get("bvr_id"),
"category": rule.get("category", ""),
"rule_id": rule.get("id", ""),
}
dedup_key = rule.get("dedup_key") or rule["name"]
dedup_val = f"{dedup_key}:{m.get('combination', '')}"
if dedup_val in seen_dedup:
continue
seen_dedup.add(dedup_val)
results.append(entry)
# ── 附加算法级 Yoga（不在 rules JSON 中） ──
results += self._detect_solar_lunar_yogas(ctx)
return results
def _detect_solar_lunar_yogas(self, ctx: YogaContext) -> List[Dict]:
"""
检测 Solar Yogas (Veshi/Voshi/Ubhayachari) 和 Lunar Yogas (Sunapha/Anapha/Durudhura/Kemadruma)。
来源：从 dangling commit f19369c 恢复的失散代码（原在 jyotish_engine.py cmd_yoga 中）。
算法：基于行星相对于太阳/月亮的位置，非规则 JSON 可表达的。
"""
results = []
p = ctx.planets
planets_in_house = {} # house_num -> [planet_names]
# 如果度数是浮点，尝试排序
sun_house = None
moon_house = None
for pname, pinfo in p.items():
h = pinfo.get("house")
# 计算行星实际度数
if h is not None:
planets_in_house.setdefault(h, []).append(pname)
if pname == "Sun":
sun_house = h
elif pname == "Moon":
moon_house = h
# Solar Yogas
if sun_house is not None:
h2 = ((sun_house - 1 + 1) % 12) + 1 # 太阳第2宫
h12 = ((sun_house - 1 + 11) % 12) + 1 # 太阳第12宫
p_in_h2 = [n for n in planets_in_house.get(h2, []) if n != "Sun"]
p_in_h12 = [n for n in planets_in_house.get(h12, []) if n != "Sun"]
if p_in_h12 and not p_in_h2:
results.append({"name": "Voshi Yoga", "name_cn": "太阳前瑜伽",
"combination": f"{'+'.join(p_in_h12)}在太阳第12宫",
"effects": ["口才出众", "善于表达", "受人尊敬", "知识渊博"],
"strength": "中", "category": "solar_yoga", "source": "Parashara"})
if p_in_h2 and not p_in_h12:
results.append({"name": "Veshi Yoga", "name_cn": "太阳后瑜伽",
"combination": f"{'+'.join(p_in_h2)}在太阳第2宫",
"effects": ["财富充裕", "生活舒适", "性情愉快", "人缘好"],
"strength": "中", "category": "solar_yoga", "source": "Parashara"})
if p_in_h2 and p_in_h12:
results.append({"name": "Ubhayachari Yoga", "name_cn": "太阳双夹瑜伽",
"combination": "太阳两侧均有行星",
"effects": ["性格坚毅", "口才与财富兼备", "受人爱戴", "社会影响力"],
"strength": "强", "category": "solar_yoga", "source": "Parashara"})
# Lunar Yogas
if moon_house is not None:
h2 = ((moon_house - 1 + 1) % 12) + 1 # 月亮第2宫
h12 = ((moon_house - 1 + 11) % 12) + 1 # 月亮第12宫
p_in_h2 = [n for n in planets_in_house.get(h2, []) if n != "Moon"]
p_in_h12 = [n for n in planets_in_house.get(h12, []) if n != "Moon"]
if p_in_h12 and not p_in_h2:
results.append({"name": "Anapha Yoga", "name_cn": "月后瑜伽",
"combination": f"{'+'.join(p_in_h12)}在月亮第12宫",
"effects": ["体格健壮", "名声良好", "品德高尚", "行业领袖"],
"strength": "中", "category": "lunar_yoga", "source": "Parashara"})
if p_in_h2 and not p_in_h12:
results.append({"name": "Sunapha Yoga", "name_cn": "月前瑜伽",
"combination": f"{'+'.join(p_in_h2)}在月亮第2宫",
"effects": ["自力更生", "财富充裕", "受人尊敬", "生活富足"],
"strength": "中", "category": "lunar_yoga", "source": "Parashara"})
if p_in_h2 and p_in_h12:
results.append({"name": "Durudhura Yoga", "name_cn": "月双夹瑜伽",
"combination": "月亮两侧均有行星",
"effects": ["享受丰富", "善于辞令", "性格坚定", "多元才华"],
"strength": "强", "category": "lunar_yoga", "source": "Parashara"})
return results
# ------------------------------------------------------------------------
# 规则级评估
# ------------------------------------------------------------------------
def _eval_rule(self, rule: Dict, ctx: YogaContext) -> List[Dict]:
"""评估单条规则，返回匹配列表（空表示无匹配）"""
logic = rule.get("logic", {})
return self._eval_condition(logic, ctx, rule, {})
def _eval_condition(self, cond: Dict, ctx: YogaContext, rule: Dict,
bindings: Dict) -> List[Dict]:
"""评估条件节点，返回匹配列表"""
# v6.0.31: 兼容历史规则中的 "op" 字段。
# 早期批量扩展脚本误用 op 而不是 type；如果只读 type，会导致这些规则静默失效。
ctype = cond.get("type") or cond.get("op")
# v6.0.32: 兼容批量生成规则使用的 compound_conditions/compound 结构。
if ctype == "compound_conditions":
cond = {**cond, "type": "and"}
return self._eval_and(cond, ctx, rule, bindings)
if ctype == "compound":
operator = str(cond.get("operator", "AND")).lower()
cond = {**cond, "type": "or" if operator == "or" else "and"}
return self._eval_condition(cond, ctx, rule, bindings)
handler = getattr(self, f"_eval_{ctype}", None)
if handler:
return handler(cond, ctx, rule, bindings)
# v6.0.32: 兼容 PyJHora/BVR 批量规则中的语义型 condition type，
# 避免未知类型静默导致整条 compound rule 永远失效。
if ctype:
return self._eval_semantic_condition(ctype, cond, ctx, rule, bindings)
return []
# ------------------------------------------------------------------------
# 复合条件
# ------------------------------------------------------------------------
def _eval_and(self, cond, ctx, rule, bindings):
"""AND: 所有子条件必须同时满足"""
subs = cond.get("conditions", [])
if not subs:
return [{"combination": "", "strength": rule.get("strength", "中")}]
results = self._eval_condition(subs[0], ctx, rule, bindings)
if not results:
return []
for sub in subs[1:]:
new_results = []
for match in results:
b = {**bindings, **match.get("bindings", {})}
sub_matches = self._eval_condition(sub, ctx, rule, b)
for sm in sub_matches:
combo = match.get("combination", "")
sm_combo = sm.get("combination", "")
merged_combo = "; ".join(filter(None, [combo, sm_combo]))
new_results.append({
"combination": merged_combo,
"strength": sm.get("strength", match.get("strength")),
"bindings": {**match.get("bindings", {}), **sm.get("bindings", {})}
})
results = new_results
if not results:
return []
return results
def _eval_or(self, cond, ctx, rule, bindings):
"""OR: 任一子条件满足即可"""
all_results = []
for sub in cond.get("conditions", []):
matches = self._eval_condition(sub, ctx, rule, bindings)
all_results.extend(matches)
return all_results
def _eval_not(self, cond, ctx, rule, bindings):
"""NOT: 子条件不满足时返回一个空匹配"""
matches = self._eval_condition(cond.get("condition", {}), ctx, rule, bindings)
return [] if matches else [{"combination": "", "strength": rule.get("strength", "中")}]
# ------------------------------------------------------------------------
# 单条件类型
# ------------------------------------------------------------------------
def _eval_same_house(self, cond, ctx, rule, bindings):
"""两颗行星同宫"""
# 支持两种写法：
# 1) {"a": ..., "b": ...}
# 2) {"planets": ["Sun", "Mercury", ...]}：任意两颗同宫即满足
if "planets" in cond and "a" not in cond and "b" not in cond:
planets = cond.get("planets", [])
pa = self._resolve_binding({"role": "set", "planets": planets}, ctx, bindings)
pb = pa
else:
pa = self._resolve_binding(cond.get("a"), ctx, bindings)
pb = self._resolve_binding(cond.get("b"), ctx, bindings)
results = []
for a in pa:
for b in pb:
if a == b:
continue
h1 = ctx.house_of(a)
h2 = ctx.house_of(b)
if h1 is not None and h1 == h2:
tmpl = cond.get("combo_template", "{a}与{b}同在第{h}宫")
combo = tmpl.format(a=PLANET_CN.get(a, a), b=PLANET_CN.get(b, b), h=h1, a_raw=a, b_raw=b)
results.append({"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"a": a, "b": b, "house": h1}})
return results
def _eval_in_houses(self, cond, ctx, rule, bindings):
"""行星在指定宫位列表中"""
refs = self._resolve_binding(cond.get("planet", "$planet"), ctx, bindings)
houses = cond.get("houses", [])
exclude = cond.get("exclude", [])
results = []
for p in refs:
if p in exclude:
continue
h = ctx.house_of(p)
if h is not None and h in houses:
tmpl = cond.get("combo_template", "{p}在第{h}宫")
combo = tmpl.format(p=PLANET_CN.get(p, p), h=h, p_raw=p)
results.append({"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planet": p, "house": h}})
return results
def _eval_not_in_houses(self, cond, ctx, rule, bindings):
"""行星不在指定宫位列表中"""
refs = self._resolve_binding(cond.get("planet"), ctx, bindings)
houses = cond.get("houses", [])
results = []
for p in refs:
h = ctx.house_of(p)
if h is not None and h not in houses:
results.append({"combination": "", "strength": rule.get("strength", "中"),
"bindings": {"planet": p, "house": h}})
return results
def _eval_in_houses_from(self, cond, ctx, rule, bindings):
"""行星在指定行星/基准的相对宫位关系中"""
refs = self._resolve_binding(cond.get("planet"), ctx, bindings)
from_ref = cond.get("from")
relations = cond.get("relations", [])
results = []
# 解析 relations（支持字符串别名和整数偏移）
valid_offsets = set()
for r in relations:
if r == "kendra":
valid_offsets.update([0, 3, 6, 9])
elif r == "trikona":
valid_offsets.update([0, 4, 8])
elif r == "2nd_12th":
valid_offsets.update([1, 11])
elif r == "3rd_11th":
valid_offsets.update([2, 10])
elif r == "same":
valid_offsets.add(0)
elif isinstance(r, int):
valid_offsets.add(r)
for p in refs:
h1 = ctx.house_of(p)
if h1 is None:
continue
# from 可以是行星或固定宫位
if isinstance(from_ref, int):
h_base = from_ref
else:
from_planets = self._resolve_binding(from_ref, ctx, bindings)
for fp in from_planets:
h_base = ctx.house_of(fp)
if h_base is None:
continue
off = ctx.house_offset(h_base, h1)
if off in valid_offsets:
tmpl = cond.get("combo_template", "{p}在第{h}宫（从{fp}的{rel}）")
rel_name = self._offset_name(off)
combo = tmpl.format(p=PLANET_CN.get(p, p), h=h1, fp=PLANET_CN.get(fp, fp),
rel=rel_name, off=off, p_raw=p, fp_raw=fp)
results.append({"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planet": p, "from": fp, "house": h1}})
return results
def _eval_dignity(self, cond, ctx, rule, bindings):
"""行星尊严检查"""
refs = self._resolve_binding(cond.get("planet"), ctx, bindings)
dignity_type = cond.get("dignity") # exalted, own, moolatrikona, debilitated
results = []
for p in refs:
ok = False
if dignity_type == "exalted":
ok = ctx.is_exalted(p)
elif dignity_type == "own":
ok = ctx.is_own_sign(p)
elif dignity_type == "moolatrikona":
ok = ctx.is_moolatrikona(p)
elif dignity_type == "debilitated":
ok = ctx.is_debilitated(p)
elif dignity_type == "strong":
ok = ctx.is_exalted(p) or ctx.is_own_sign(p) or ctx.is_moolatrikona(p)
elif dignity_type == "not_debilitated":
ok = not ctx.is_debilitated(p)
elif dignity_type == "not_enemy":
ok = True # placeholder, not used in current rules
# v6.0.31: 兼容历史规则中的 status 字段。
# 批量规则曾使用 {"op":"dignity", "status":"exalted"}，而引擎原本只读取 dignity。
if dignity_type is None:
status = cond.get("status")
if status == "exalted":
ok = ctx.is_exalted(p)
dignity_type = status
elif status == "own":
ok = ctx.is_own_sign(p)
dignity_type = status
elif status == "moolatrikona":
ok = ctx.is_moolatrikona(p)
dignity_type = status
elif status == "debilitated":
ok = ctx.is_debilitated(p)
dignity_type = status
elif status == "strong":
ok = ctx.is_exalted(p) or ctx.is_own_sign(p) or ctx.is_moolatrikona(p)
dignity_type = status
if ok:
sign = ctx.sign_of(p)
tmpl = cond.get("combo_template", "{p}{dignity}在{sign}")
combo = tmpl.format(p=PLANET_CN.get(p, p), dignity=dignity_type, sign=sign or "", p_raw=p)
results.append({"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planet": p, "sign": sign}})
return results
def _eval_count(self, cond, ctx, rule, bindings):
"""统计满足条件的行星数量"""
refs = self._resolve_binding(cond.get("items", cond.get("planets")), ctx, bindings)
sub_cond = cond.get("condition", {})
min_count = cond.get("min", 1)
max_count = cond.get("max")
matched = []
for p in refs:
# 临时把 planet 绑定为 p，评估子条件
sub_bindings = {**bindings, "planet": p}
matches = self._eval_condition(sub_cond, ctx, rule, sub_bindings)
if matches:
matched.append(p)
count = len(matched)
ok = count >= min_count
if max_count is not None:
ok = ok and count <= max_count
if ok:
tmpl = cond.get("combo_template", "{count}颗行星满足条件")
combo = tmpl.format(count=count, planets="、".join(PLANET_CN.get(p, p) for p in matched))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"count": count, "matched": matched}}]
return []
def _eval_houses_occupied(self, cond, ctx, rule, bindings):
"""行星占据的宫位数量"""
refs = self._resolve_binding(cond.get("planets", "all"), ctx, bindings)
occupied = set()
for p in refs:
h = ctx.house_of(p)
if h is not None:
occupied.add(h)
count = len(occupied)
target = cond.get("count")
min_count = cond.get("min")
max_count = cond.get("max")
ok = False
if target is not None:
ok = count == target
else:
ok = True
if min_count is not None:
ok = ok and count >= min_count
if max_count is not None:
ok = ok and count <= max_count
if ok:
tmpl = cond.get("combo_template", "行星分布在{count}个宫位")
combo = tmpl.format(count=count)
return [{"combination": combo, "strength": rule.get("strength", "中")}]
return []
def _eval_adjacent_houses(self, cond, ctx, rule, bindings):
"""目标宫位的前/后宫位有指定行星"""
target = cond.get("house")
sides = cond.get("sides", ["prev", "next"])
refs = self._resolve_binding(cond.get("planets"), ctx, bindings)
require_both = cond.get("both", False)
prev_h = ((target - 2) % 12) + 1
next_h = (target % 12) + 1
prev_ok = any(ctx.house_of(p) == prev_h for p in refs) if "prev" in sides else True
next_ok = any(ctx.house_of(p) == next_h for p in refs) if "next" in sides else True
if require_both:
ok = prev_ok and next_ok
else:
ok = prev_ok or next_ok
if ok:
tmpl = cond.get("combo_template", "第{target}宫被夹击")
combo = tmpl.format(target=target, prev=prev_h, next=next_h)
return [{"combination": combo, "strength": rule.get("strength", "中")}]
return []
def _eval_all_in_houses(self, cond, ctx, rule, bindings):
"""所有指定行星都在给定宫位集合中。"""
refs = self._resolve_binding(cond.get("planets", "visible"), ctx, bindings)
houses = set(cond.get("houses", []))
if not refs or not houses:
return []
occupied = [ctx.house_of(p) for p in refs]
ok = all(h in houses for h in occupied if h is not None) and len(occupied) == len(refs)
if ok:
tmpl = cond.get("combo_template", "所有指定行星均落入{houses}")
combo = tmpl.format(houses="/".join(str(h) for h in sorted(houses)), planets="、".join(PLANET_CN.get(p, p) for p in refs))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planets": refs, "houses": sorted(houses)}}]
return []
def _eval_all_in_house_sets(self, cond, ctx, rule, bindings):
"""所有指定行星都在多个候选宫位集合之一中。"""
refs = self._resolve_binding(cond.get("planets", "visible"), ctx, bindings)
house_sets = cond.get("house_sets", [])
if not refs or not house_sets:
return []
for houses in house_sets:
houses_set = set(houses)
occupied = [ctx.house_of(p) for p in refs]
ok = all(h in houses_set for h in occupied if h is not None) and len(occupied) == len(refs)
if ok:
tmpl = cond.get("combo_template", "所有指定行星均落入候选宫位集合{houses}")
combo = tmpl.format(houses="/".join(str(h) for h in sorted(houses_set)), planets="、".join(PLANET_CN.get(p, p) for p in refs))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planets": refs, "houses": sorted(houses_set)}}]
return []
def _eval_occupied_houses_exact(self, cond, ctx, rule, bindings):
"""指定行星实际占据的宫位集合与目标集合完全一致。"""
refs = self._resolve_binding(cond.get("planets", "visible"), ctx, bindings)
houses = set(cond.get("houses", []))
occupied = {ctx.house_of(p) for p in refs if ctx.house_of(p) is not None}
if refs and occupied == houses:
tmpl = cond.get("combo_template", "指定行星只占据{houses}")
combo = tmpl.format(houses="/".join(str(h) for h in sorted(houses)), planets="、".join(PLANET_CN.get(p, p) for p in refs))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planets": refs, "houses": sorted(houses)}}]
return []
def _eval_occupied_houses_exact_sets(self, cond, ctx, rule, bindings):
"""指定行星实际占据的宫位集合等于候选集合之一。"""
refs = self._resolve_binding(cond.get("planets", "visible"), ctx, bindings)
house_sets = cond.get("house_sets", [])
occupied = {ctx.house_of(p) for p in refs if ctx.house_of(p) is not None}
for houses in house_sets:
houses_set = set(houses)
if refs and occupied == houses_set:
tmpl = cond.get("combo_template", "指定行星只占据候选宫位集合{houses}")
combo = tmpl.format(houses="/".join(str(h) for h in sorted(houses_set)), planets="、".join(PLANET_CN.get(p, p) for p in refs))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"planets": refs, "houses": sorted(houses_set)}}]
return []
def _eval_has_planet_in_house(self, cond, ctx, rule, bindings):
"""指定行星集合中至少一颗在某宫。"""
refs = self._resolve_binding(cond.get("planets", "all"), ctx, bindings)
house = cond.get("house")
matched = [p for p in refs if ctx.house_of(p) == house]
if matched:
tmpl = cond.get("combo_template", "第{house}宫有{planets}")
combo = tmpl.format(house=house, planets="、".join(PLANET_CN.get(p, p) for p in matched))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"matched": matched, "house": house}}]
return []
def _eval_has_planet_in_house_from(self, cond, ctx, rule, bindings):
"""指定行星集合中至少一颗在某参考行星的相对宫位。houses 使用传统 1-12 口径。"""
refs = self._resolve_binding(cond.get("planets", "all"), ctx, bindings)
from_planet = cond.get("from") or cond.get("from_planet")
from_list = self._resolve_binding(from_planet, ctx, bindings)
houses = cond.get("houses", [])
exclude = set(cond.get("exclude", []))
results = []
for fp in from_list:
base = ctx.house_of(fp)
if base is None:
continue
for rel_house in houses:
target = ((base + rel_house - 2) % 12) + 1
matched = [p for p in refs if p not in exclude and p != fp and ctx.house_of(p) == target]
if matched:
tmpl = cond.get("combo_template", "{planets}在{fp}的第{rel}宫")
combo = tmpl.format(
planets="、".join(PLANET_CN.get(p, p) for p in matched),
fp=PLANET_CN.get(fp, fp),
rel=rel_house,
target=target,
)
results.append({"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"matched": matched, "from": fp, "rel_house": rel_house, "house": target}})
return results
def _eval_houses_with_planets_count(self, cond, ctx, rule, bindings):
"""在指定宫位集合中，有多少个宫位至少包含一颗指定集合行星。"""
refs = self._resolve_binding(cond.get("planets", "all"), ctx, bindings)
houses = cond.get("houses", [])
min_count = cond.get("min", 1)
max_count = cond.get("max")
occupied = []
for h in houses:
matched = [p for p in refs if ctx.house_of(p) == h]
if matched:
occupied.append((h, matched))
count = len(occupied)
ok = count >= min_count
if max_count is not None:
ok = ok and count <= max_count
if ok:
tmpl = cond.get("combo_template", "{count}个目标宫位有指定行星")
detail = "; ".join(f"第{h}宫:" + "、".join(PLANET_CN.get(p, p) for p in ps)
for h, ps in occupied)
combo = tmpl.format(count=count, detail=detail,
houses="/".join(str(h) for h, _ in occupied))
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"occupied": occupied, "count": count}}]
return []
def _eval_degree_gap(self, cond, ctx, rule, bindings):
"""同星座内两颗行星度数差小于阈值"""
pa = self._resolve_binding(cond.get("a"), ctx, bindings)
pb = self._resolve_binding(cond.get("b"), ctx, bindings)
max_gap = cond.get("max_gap", 1.0)
results = []
for a in pa:
for b in pb:
if a == b:
continue
s1 = ctx.sign_of(a)
s2 = ctx.sign_of(b)
if s1 is None or s1 != s2:
continue
d1 = ctx.degree_of(a)
d2 = ctx.degree_of(b)
if d1 is None or d2 is None:
continue
if abs(d1 - d2) < max_gap:
tmpl = cond.get("combo_template", "{a}与{b}在{sign}内相距{gap:.2f}°")
combo = tmpl.format(a=PLANET_CN.get(a, a), b=PLANET_CN.get(b, b), sign=s1,
gap=abs(d1 - d2))
results.append({"combination": combo, "strength": rule.get("strength", "中")})
return results
def _eval_parivartana(self, cond, ctx, rule, bindings):
"""两颗宫主星互换星座（Parivartana/互落）"""
la = ctx.resolve_single(cond.get("lord_a"))
lb = ctx.resolve_single(cond.get("lord_b"))
if la is None or lb is None or la == lb:
return []
sa = ctx.sign_of(la)
sb = ctx.sign_of(lb)
if sa is None or sb is None:
return []
lord_of_sa = SIGN_LORDS.get(sa)
lord_of_sb = SIGN_LORDS.get(sb)
if lord_of_sa == lb and lord_of_sb == la:
tmpl = cond.get("combo_template", "{la}与{lb}互换星座")
combo = tmpl.format(la=PLANET_CN.get(la, la), lb=PLANET_CN.get(lb, lb))
return [{"combination": combo, "strength": rule.get("strength", "强")}]
return []
def _eval_any_pair(self, cond, ctx, rule, bindings):
"""从集合 A 和集合 B 中各取一个元素，配对满足条件"""
if "planets" in cond and "from" not in cond and "to" not in cond:
set_a = self._resolve_binding({"role": "set", "planets": cond.get("planets", [])}, ctx, bindings)
set_b = set_a
exclude_self = True
else:
set_a = self._resolve_binding(cond.get("from"), ctx, bindings)
set_b = self._resolve_binding(cond.get("to"), ctx, bindings)
exclude_self = cond.get("exclude_self", False)
sub_cond = cond.get("condition", {})
results = []
for a in set_a:
for b in set_b:
if exclude_self and a == b:
continue
pair_bindings = {**bindings, "a": a, "b": b}
matches = self._eval_condition(sub_cond, ctx, rule, pair_bindings)
for m in matches:
m["bindings"] = {**m.get("bindings", {}), "a": a, "b": b}
results.extend(matches)
return results
def _eval_all_planets(self, cond, ctx, rule, bindings):
"""所有指定行星都满足某个条件"""
refs = self._resolve_binding(cond.get("planets", "all"), ctx, bindings)
sub_cond = cond.get("condition", {})
all_match = True
matched_combo_parts = []
for p in refs:
b = {**bindings, "planet": p}
matches = self._eval_condition(sub_cond, ctx, rule, b)
if not matches:
all_match = False
break
matched_combo_parts.append(matches[0].get("combination", ""))
if all_match and refs:
combo = "; ".join(filter(None, matched_combo_parts))
return [{"combination": combo, "strength": rule.get("strength", "中")}]
return []
def _eval_any_planet(self, cond, ctx, rule, bindings):
"""任一指定行星满足条件"""
refs = self._resolve_binding(cond.get("planets"), ctx, bindings)
sub_cond = cond.get("condition", {})
for p in refs:
b = {**bindings, "planet": p}
matches = self._eval_condition(sub_cond, ctx, rule, b)
if matches:
return matches
return []
def _eval_exists(self, cond, ctx, rule, bindings):
"""存在至少一个行星满足条件"""
refs = self._resolve_binding(cond.get("planets"), ctx, bindings)
sub_cond = cond.get("condition", {})
for p in refs:
b = {**bindings, "planet": p}
matches = self._eval_condition(sub_cond, ctx, rule, b)
if matches:
return matches
return []
def _eval_lord_in_house(self, cond, ctx, rule, bindings):
"""某宫主星在指定宫位"""
house = cond.get("house")
target_houses = cond.get("target_houses", [])
lord = ctx.lord_of_house(house)
if lord is None or lord not in ctx.planets:
return []
lh = ctx.house_of(lord)
if lh is not None and lh in target_houses:
tmpl = cond.get("combo_template", "{house}宫主{lord}在第{lh}宫")
combo = tmpl.format(house=house, lord=PLANET_CN.get(lord, lord), lh=lh)
return [{"combination": combo, "strength": rule.get("strength", "中"),
"bindings": {"lord": lord, "house": lh}}]
return []
def _eval_lords_relation(self, cond, ctx, rule, bindings):
"""两个宫主星之间的特定关系（同宫/互落等）"""
lord_a = ctx.resolve_single(cond.get("lord_a"))
lord_b = ctx.resolve_single(cond.get("lord_b"))
if lord_a is None or lord_b is None:
return []
relation = cond.get("relation", "same_house")
if relation == "same_house":
ha = ctx.house_of(lord_a)
hb = ctx.house_of(lord_b)
if ha is not None and ha == hb:
tmpl = cond.get("combo_template", "{la}与{lb}同在第{h}宫")
combo = tmpl.format(la=PLANET_CN.get(lord_a, lord_a), lb=PLANET_CN.get(lord_b, lord_b), h=ha)
return [{"combination": combo, "strength": rule.get("strength", "中")}]
return []
def _eval_custom(self, cond, ctx, rule, bindings):
"""自定义 Python 表达式（用于复杂规则）"""
expr = cond.get("expr", "")
if not expr:
return []
def house_of(p): return ctx.house_of(p)
def sign_of(p): return ctx.sign_of(p)
def deg_of(p): return ctx.degree_of(p)
def lord(h): return ctx.lord_of_house(h)
def in_houses(p, hs): h = house_of(p); return h is not None and h in hs
def dignity(p): return ctx.dignity(p)
def exalted(p): return ctx.is_exalted(p)
def own(p): return ctx.is_own_sign(p)
def debil(p): return ctx.is_debilitated(p)
def moola(p): return ctx.is_moolatrikona(p)
def kendra(h): return ctx.is_kendra(h)
def trikona(h): return ctx.is_trikona(h)
def dusthana(h): return ctx.is_dusthana(h)
def upachaya(h): return ctx.is_upachaya(h)
def kendra_from(p, fp): return ctx.is_kendra_from(p, fp)
def trikona_from(p, fp): return ctx.is_trikona_from(p, fp)
def offset(fh, th): return ctx.house_offset(fh, th)
def planets_in(h): return ctx.planets_in_house(h)
def resolve(ref): return ctx.resolve(ref)
# v6.0.32: 修复 custom 规则中常用的缺失辅助函数
def same_house(a, b):
"""两颗行星是否同宫（允许自比较：同星恒为 True）"""
ha = ctx.house_of(a)
hb = ctx.house_of(b)
return ha is not None and ha == hb
def aspect(a, b):
"""行星a是否aspect行星b（7th aspect + Mars/Jupiter/Saturn的特殊aspect）"""
if a == b:
return False
ha = ctx.house_of(a)
hb = ctx.house_of(b)
if ha is None or hb is None:
return False
off = ctx.house_offset(ha, hb)
# 7th aspect for all planets
if off == 6:
return True
# Mars: 4th, 8th aspects
if a == 'Mars' and off in (3, 7):
return True
# Jupiter: 5th, 9th aspects
if a == 'Jupiter' and off in (4, 8):
return True
# Saturn: 3rd, 10th aspects
if a == 'Saturn' and off in (2, 9):
return True
return False
def aspects_house(p, h):
if p not in ctx.planets or h is None:
return False
return h == ctx.house_of(p) or offset(ctx.house_of(p), h) in (6, 3 if p == 'Mars' else -1, 7 if p == 'Mars' else -1, 4 if p == 'Jupiter' else -1, 8 if p == 'Jupiter' else -1, 2 if p == 'Saturn' else -1, 9 if p == 'Saturn' else -1)
def graha_aspects_house(p, h):
if p not in ctx.planets or h is None:
return False
return offset(ctx.house_of(p), h) in (6, 3 if p == 'Mars' else -1, 7 if p == 'Mars' else -1, 4 if p == 'Jupiter' else -1, 8 if p == 'Jupiter' else -1, 2 if p == 'Saturn' else -1, 9 if p == 'Saturn' else -1)
def external_benchmark_planets_aspecting_raasi(p, h):
"""Replicate PyJHora house.planets_aspecting_the_raasi() behavior for source parity."""
if p not in ctx.planets or h is None:
return False
sign_name = ctx.sign_of(p)
if sign_name not in SIGNS:
return False
target_rasi_idx = (ctx.asc_idx + h - 1) % 12
aspected_signs = rasi_drishti_signs_from(sign_name)
planet_ids_in_aspected_signs = [
PLANET_INDEX[q]
for q in ctx.planets
if q in PLANET_INDEX and ctx.sign_of(q) in aspected_signs
]
return target_rasi_idx in planet_ids_in_aspected_signs
def external_benchmark_aspected_planets_of_raasi(h):
"""Replicate PyJHora house.aspected_planets_of_the_raasi(): planets whose rasi drishti hits a target house."""
if h is None:
return []
target_sign = house_sign(h)
return [
p for p in ctx.planets
if p in PLANET_INDEX and target_sign in rasi_drishti_signs_from(ctx.sign_of(p))
]
def rasi_drishti_signs_from(sign_name):
if sign_name not in SIGNS:
return []
sign_idx = SIGNS.index(sign_name)
if sign_name in MOVABLE_SIGNS:
return [SIGNS[i] for i in [1, 4, 7, 10] if i not in ((sign_idx + 1) % 12, (sign_idx - 1) % 12)]
if sign_name in FIXED_SIGNS:
return [SIGNS[i] for i in [0, 3, 6, 9] if i not in ((sign_idx + 1) % 12, (sign_idx - 1) % 12)]
return [s for s in DUAL_SIGNS if s != sign_name]
def rasi_aspects_house(p, h):
if p not in ctx.planets or h is None:
return False
return house_sign(h) in rasi_drishti_signs_from(ctx.sign_of(p))
def rasi_aspects(a, b):
return a in ctx.planets and b in ctx.planets and rasi_aspects_house(a, ctx.house_of(b))
def rasi_aspected_by_planets(h):
return [p for p in ctx.planets if rasi_aspects_house(p, h)]
def sign_index_of_planet(p):
sign_name = ctx.sign_of(p)
return SIGNS.index(sign_name) if sign_name in SIGNS else None
def house_strength(p):
sign_idx = sign_index_of_planet(p)
if sign_idx is None or p not in HOUSE_STRENGTHS:
return None
strength = HOUSE_STRENGTHS[p][sign_idx]
sign_name = SIGNS[sign_idx]
# v6.0.39: PyJHora dynamic co-lord owner strength for Scorpio/Aquarius.
# Without this, Ketu/Rahu can become house lords but still look non-owner in strength checks.
if sign_name in ('Scorpio', 'Aquarius') and ctx._resolve_sign_lord(sign_name) == p:
return max(strength, 5)
return strength
def strong(p, include_neutral=False):
strength = house_strength(p)
if strength is None:
return False
return strength >= (2 if include_neutral else 3)
def weak(p):
strength = house_strength(p)
return strength is not None and strength <= 2
def associated(a, b):
return a in ctx.planets and b in ctx.planets and (same_house(a, b) or aspect(a, b) or aspect(b, a))
def temporal_friend(a, b):
if a not in ctx.planets or b not in ctx.planets or a == b:
return False
# PyJHora temporary friends: 2/3/4/10/11/12 from a planet.
return offset(ctx.house_of(a), ctx.house_of(b)) in [1, 2, 3, 9, 10, 11]
def natural_friend(a, b):
return a in FRIENDLY_PLANETS.get(b, []) and b in FRIENDLY_PLANETS.get(a, [])
def occupants(h):
return ctx.planets_in_house(h) if h is not None else []
def only_benefics_in_house(h):
ps = occupants(h)
return bool(ps) and all(p in BENEFICS for p in ps)
def only_malefics_in_house(h):
ps = occupants(h)
return bool(ps) and all(p in MALEFICS for p in ps)
def house_has_benefic(h):
return any(p in BENEFICS for p in occupants(h))
def house_has_malefic(h):
return any(p in MALEFICS for p in occupants(h))
def house_sign(h):
if h is None:
return None
return SIGNS[(ctx.asc_idx + h - 1) % 12]
def movable_house(h):
return house_sign(h) in MOVABLE_SIGNS
def d9_house_of(p): return ctx.d9_house_of(p)
def d9_sign_of(p): return ctx.d9_sign_of(p)
def d9_lord_of_house(h): return ctx.d9_lord_of_house(h)
def navamsa_dispositor(p): return ctx.navamsa_dispositor(p)
def tithi(): return ctx.tithi()
def is_waning_moon(): return ctx.is_waning_moon()
def upagraha_house(name): return ctx.upagraha_house(name)
def upagraha_sign(name): return ctx.upagraha_sign(name)
def gulika_house(): return ctx.upagraha_house("gulika")
def maandi_house(): return ctx.upagraha_house("maandi")
def gulika_sign(): return ctx.upagraha_sign("gulika")
def maandi_sign(): return ctx.upagraha_sign("maandi")
def exal(p): return ctx.is_exalted(p)
def lord_of_house(h): return ctx.lord_of_house(h)
def sign(p): return ctx.sign_of(p)
def check_amala_from(base_house):
"""Amala: 第10宫仅有吉星，支持从Lagna/Moon等基准宫位计算。"""
target = ((base_house - 1 + 9) % 12) + 1
occupants = ctx.planets_in_house(target)
return bool(occupants) and all(p in BENEFICS for p in occupants)
def external_benchmark_natural_benefics():
"""Replicate PyJHora yoga._get_natural_benefics(): Jupiter, Venus, plus benefic Mercury."""
benefics = [p for p in ["Jupiter", "Venus"] if p in ctx.planets]
mercury_house = ctx.house_of("Mercury")
if mercury_house is not None:
mercury_alone = len(ctx.planets_in_house(mercury_house)) == 1
mercury_with_jupiter_or_venus = any(ctx.house_of(p) == mercury_house for p in ["Jupiter", "Venus"] if p in ctx.planets)
if mercury_alone or mercury_with_jupiter_or_venus:
benefics.append("Mercury")
return benefics
# 辅助：获取星盘所有行星名列表
def _planets_list():
return list(ctx.planets.keys())
# 辅助：获取所有宫主星（1-12宫）
def _all_lords():
return [ctx.lord_of_house(h) for h in range(1, 13)]
# 辅助：获取角宫主星列表
def _kendra_lords_list():
ai = SIGNS.index(ctx.ascendant) if ctx.ascendant in SIGNS else 0
return list(set([SIGN_LORDS[SIGNS[(ai + h - 1) % 12]] for h in [1, 4, 7, 10]]))
# 辅助：获取三方宫主星列表
def _trikona_lords_list():
ai = SIGNS.index(ctx.ascendant) if ctx.ascendant in SIGNS else 0
return list(set([SIGN_LORDS[SIGNS[(ai + h - 1) % 12]] for h in [1, 5, 9]]))
safe_globals = {
# 安全内置函数：只开放规则表达式需要的纯函数，避免 custom 规则因 all/any/len/set 缺失而静默失效。
"all": all, "any": any, "len": len, "set": set, "tuple": tuple, "sorted": sorted,
"abs": abs, "min": min, "max": max, "sum": sum, "range": range,
"list": list, "bool": bool,
"ctx": ctx, "bindings": bindings, "rule": rule,
"SIGNS": SIGNS, "SIGN_LORDS": SIGN_LORDS,
"FRIENDLY_PLANETS": FRIENDLY_PLANETS,
"RAHU_KETU_OWNED_SIGN_INDEX": RAHU_KETU_OWNED_SIGN_INDEX,
"EXALTATION": EXALTATION, "DEBILITATION": DEBILITATION,
"PLANET_CN": PLANET_CN, "BENEFICS": BENEFICS, "MALEFICS": MALEFICS,
"MOVABLE_SIGNS": MOVABLE_SIGNS, "FIXED_SIGNS": FIXED_SIGNS, "DUAL_SIGNS": DUAL_SIGNS,
"PLANET_INDEX": PLANET_INDEX, "HOUSE_STRENGTHS": HOUSE_STRENGTHS,
"ALL_PLANETS": ALL_PLANETS, "MOOLATRIKONA_SIGN": MOOLATRIKONA_SIGN,
# 基础查询
"house_of": house_of, "sign_of": sign_of, "deg_of": deg_of,
"get_sign_of": sign_of, # 别名
"lord": lord, "lords_of": lord, # 别名（接受宫位数）
# 尊严检查
"dignity": dignity,
"exalted": exalted, "is_exalted": exalted,
"own": own, "is_own_sign": own,
"debil": debil, "is_debilitated": debil,
"moola": moola, "is_moolatrikona": moola,
# 宫位类型
"in_houses": in_houses, "planets_in": planets_in,
"kendra": kendra, "is_kendra": kendra,
"trikona": trikona, "is_trikona": trikona,
"dusthana": dusthana, "is_dusthana": dusthana,
"upachaya": upachaya, "is_upachaya": upachaya,
"kendra_from": kendra_from, "trikona_from": trikona_from,
"offset": offset,
# v6.0.32: 同宫与相位检查（custom规则常用）
"same_house": same_house, "aspect": aspect, "aspects_house": aspects_house,
"graha_aspects_house": graha_aspects_house,
"external_benchmark_planets_aspecting_raasi": external_benchmark_planets_aspecting_raasi,
"external_benchmark_aspected_planets_of_raasi": external_benchmark_aspected_planets_of_raasi,
"rasi_drishti_signs_from": rasi_drishti_signs_from,
"rasi_aspects_house": rasi_aspects_house, "rasi_aspects": rasi_aspects,
"rasi_aspected_by_planets": rasi_aspected_by_planets,
"house_strength": house_strength, "strong": strong, "weak": weak,
"associated": associated, "temporal_friend": temporal_friend, "natural_friend": natural_friend,
"occupants": occupants, "only_benefics_in_house": only_benefics_in_house,
"only_malefics_in_house": only_malefics_in_house,
"house_has_benefic": house_has_benefic, "house_has_malefic": house_has_malefic,
"house_sign": house_sign, "movable_house": movable_house,
"external_benchmark_natural_benefics": external_benchmark_natural_benefics,
"d9_house_of": d9_house_of, "d9_sign_of": d9_sign_of,
"d9_lord_of_house": d9_lord_of_house, "navamsa_dispositor": navamsa_dispositor,
"tithi": tithi, "is_waning_moon": is_waning_moon,
"upagraha_house": upagraha_house, "upagraha_sign": upagraha_sign,
"gulika_house": gulika_house, "maandi_house": maandi_house,
"gulika_sign": gulika_sign, "maandi_sign": maandi_sign,
# v6.1.3: D60 / Shashtiamsa 扩展
"d60_house_of": lambda p: ctx.d60_house_of(p),
"d60_sign_of": lambda p: ctx.d60_sign_of(p),
"d60_lord_of_house": lambda h: ctx.d60_lord_of_house(h),
"shashtiamsa_dispositor": lambda p: ctx.shashtiamsa_dispositor(p),
"is_shashtiamsa_evil": lambda p: ctx.is_shashtiamsa_evil(p),
"is_shashtiamsa_good": lambda p: ctx.is_shashtiamsa_good(p),
# v6.1.3: D9 尊严扩展
"is_exalted_in_d9": lambda p: ctx.is_exalted_in_d9(p),
"is_debilitated_in_d9": lambda p: ctx.is_debilitated_in_d9(p),
"is_own_sign_in_d9": lambda p: ctx.is_own_sign_in_d9(p),
"is_moolatrikona_in_d9": lambda p: ctx.is_moolatrikona_in_d9(p),
"dignity_in_d9": lambda p: ctx.dignity_in_d9(p),
"is_friendly_navamsa": lambda p: ctx.is_friendly_navamsa(p),
"is_unfriendly_navamsa": lambda p: ctx.is_unfriendly_navamsa(p),
# v6.1.3: Functional malefic / benefic
"functional_malefics": lambda: ctx.functional_malefics(),
"functional_benefics": lambda: ctx.functional_benefics(),
# v6.1.3: Vaiseshikamsa scoring
"vaiseshikamsa_score": lambda p: ctx.vaiseshikamsa_score(p),
"exal": exal, "lord_of_house": lord_of_house, "sign": sign,
"check_amala_from": check_amala_from,
"Benefics": BENEFICS, "Malefics": MALEFICS,
"planets": ctx.planets,
# 解析
"resolve": resolve,
# 列表辅助
"planets_list": _planets_list,
"all_lords": _all_lords,
"kendra_lords_list": _kendra_lords_list,
"trikona_lords_list": _trikona_lords_list,
}
# v6.0.32: 支持多行语句（if/else/for等）+ 末尾表达式求值模式。
# 不能简单 split 最后一行：多行 if/else 的最后一行经常只是 else 分支内部表达式，
# 直接 exec 前半段会产生缩进不完整。这里用 AST 捕获“实际执行分支”的末尾表达式。
result = None
exec_globals = {"__builtins__": {}, **safe_globals}
def _capture_tail_expr(block):
"""把代码块末尾表达式改写为 __result__ = <expr>；递归处理 if/for/while 分支。"""
if not block:
return block
last = block[-1]
if isinstance(last, ast.Expr):
block[-1] = ast.Assign(targets=[ast.Name(id="__result__", ctx=ast.Store())], value=last.value)
elif isinstance(last, ast.If):
last.body = _capture_tail_expr(last.body)
last.orelse = _capture_tail_expr(last.orelse)
elif isinstance(last, (ast.For, ast.While)):
last.body = _capture_tail_expr(last.body)
last.orelse = _capture_tail_expr(last.orelse)
elif isinstance(last, ast.Try):
last.body = _capture_tail_expr(last.body)
last.orelse = _capture_tail_expr(last.orelse)
last.finalbody = _capture_tail_expr(last.finalbody)
for handler in last.handlers:
handler.body = _capture_tail_expr(handler.body)
return block
try:
# 同一命名空间同时作为 globals/locals，保证 list/dict comprehension 能访问 BENEFICS 等名称。
result = eval(expr, exec_globals, exec_globals)
except SyntaxError:
try:
tree = ast.parse(expr.strip(), mode="exec")
tree.body = _capture_tail_expr(tree.body)
ast.fix_missing_locations(tree)
exec(compile(tree, "<yoga_custom>", "exec"), exec_globals, exec_globals)
result = exec_globals.get("__result__")
except Exception:
pass
except Exception:
pass
if result:
combo = cond.get("combo_template", "自定义条件满足")
if callable(combo):
combo = combo(ctx, bindings)
strength = cond.get("strength", rule.get("strength", "中"))
if callable(strength):
strength = strength(ctx, bindings)
return [{"combination": combo, "strength": strength}]
return []
def _eval_semantic_condition(self, ctype, cond, ctx, rule, bindings):
"""兼容批量抽取规则中的语义型条件。返回保守布尔匹配。"""
def success(combo=None):
return [{"combination": combo or cond.get("note", ctype), "strength": rule.get("strength", "中")}]
def house(ref):
if isinstance(ref, int):
return ref
if isinstance(ref, str):
if ref in ctx.planets:
return ctx.house_of(ref)
low = ref.lower()
if low in ("lagna", "asc", "ascendant"):
return 1
if low == "moon":
return ctx.house_of("Moon")
return None
def planet_list(default=None):
ps = cond.get("planets", default or [])
if ps == "all":
return [p for p in ALL_PLANETS if p in ctx.planets]
if isinstance(ps, str):
return [ps] if ps in ctx.planets else []
return [p for p in ps if p in ctx.planets]
def aspects(a, b):
# b 可为行星名或宫位整数；支持检查行星对宫位/行星的传统相位。
ha = ctx.house_of(a)
hb = ctx.house_of(b) if isinstance(b, str) else b
if ha is None or hb is None or a == b:
return False
off = ctx.house_offset(ha, hb)
return off == 6 or (a == "Mars" and off in (3, 7)) or (a == "Jupiter" and off in (4, 8)) or (a == "Saturn" and off in (2, 9))
def related(a, b):
return a in ctx.planets and b in ctx.planets and (ctx.house_of(a) == ctx.house_of(b) or aspects(a, b) or aspects(b, a))
def house_lord(h):
return ctx.lord_of_house(h) if isinstance(h, int) else None
def is_benefic(p):
return p in BENEFICS
def is_malefic(p):
return p in MALEFICS
def is_strong(p):
return p in ctx.planets and (ctx.is_exalted(p) or ctx.is_own_sign(p) or ctx.is_moolatrikona(p) or ctx.is_kendra(ctx.house_of(p)) or ctx.is_trikona(ctx.house_of(p)))
def rel_house(base, offset0):
return ((base - 1 + offset0) % 12) + 1 if base else None
if ctype == "placeholder":
return []
if ctype == "planet_in_lagna":
p = cond.get("planet")
return success() if p in ctx.planets and ctx.house_of(p) == 1 else []
if ctype == "planet_in_house":
p = cond.get("planet")
h = cond.get("house")
return success() if p in ctx.planets and ctx.house_of(p) == h else []
if ctype == "venus_in_house":
h = cond.get("house")
return success() if "Venus" in ctx.planets and ctx.house_of("Venus") == h else []
if ctype == "benefic_in_house":
h = cond.get("house")
return success() if any(ctx.house_of(p) == h for p in BENEFICS if p in ctx.planets) else []
if ctype == "planets_in_house":
h = cond.get("house")
ps = planet_list()
return success() if h and ps and all(ctx.house_of(p) == h for p in ps) else []
if ctype == "planets_conjunct_in_same_house":
ps = planet_list()
return success() if len(ps) >= 2 and len({ctx.house_of(p) for p in ps}) == 1 else []
if ctype == "planets_in_exactly_n_signs":
ps = planet_list(['Sun', 'Moon', 'Mars', 'Mercury', 'Jupiter', 'Venus', 'Saturn'])
n = cond.get("n")
return success() if n and len({ctx.sign_of(p) for p in ps if p in ctx.planets}) == n else []
if ctype == "planets_in_kendras":
ps = planet_list()
return success() if ps and all(ctx.is_kendra(ctx.house_of(p)) for p in ps) else []
if ctype == "planets_in_trines":
ps = planet_list()
return success() if ps and all(ctx.is_trikona(ctx.house_of(p)) for p in ps) else []
if ctype == "malefics_in_kendras_and_trines":
ps = [p for p in MALEFICS if p in ctx.planets]
return success() if any(ctx.is_kendra(ctx.house_of(p)) for p in ps) and any(ctx.is_trikona(ctx.house_of(p)) for p in ps) else []
if ctype == "malefics_in_lagna":
return success() if any(ctx.house_of(p) == 1 for p in MALEFICS if p in ctx.planets) else []
if ctype == "malefics_in_trines":
return success() if any(ctx.is_trikona(ctx.house_of(p)) for p in MALEFICS if p in ctx.planets) else []
if ctype == "planet_exalted_in_kendra":
p = cond.get("planet")
return success() if p in ctx.planets and ctx.is_exalted(p) and ctx.is_kendra(ctx.house_of(p)) else []
if ctype == "lord_exalted":
p = house_lord(cond.get("lord_of") or cond.get("house"))
return success() if p and ctx.is_exalted(p) else []
if ctype == "lord_in_kendra":
p = house_lord(cond.get("lord_of") or cond.get("house"))
return success() if p and ctx.is_kendra(ctx.house_of(p)) else []
if ctype == "lord_in_exaltation_own_or_mool_trikona":
p = house_lord(cond.get("lord_of") or cond.get("house"))
return success() if p and (ctx.is_exalted(p) or ctx.is_own_sign(p) or ctx.is_moolatrikona(p)) else []
if ctype == "mercury_strong_in_kendra_or_trikona":
return success() if "Mercury" in ctx.planets and is_strong("Mercury") and (ctx.is_kendra(ctx.house_of("Mercury")) or ctx.is_trikona(ctx.house_of("Mercury"))) else []
if ctype == "moon_strong":
return success() if "Moon" in ctx.planets and is_strong("Moon") else []
if ctype == "planet_in_own_or_exalted_sign":
p = cond.get("planet")
return success() if p in ctx.planets and (ctx.is_own_sign(p) or ctx.is_exalted(p)) else []
if ctype == "planet_aspected_by_planet":
p = cond.get("planet") or cond.get("to")
by = cond.get("by") or cond.get("from")
return success() if p in ctx.planets and by in ctx.planets and aspects(by, p) else []
if ctype == "navamsa_lord_of_2_5_11_exalted_joins_9th_lord":
l9 = house_lord(9)
for h in (2, 5, 11):
lord_h = house_lord(h)
disp = ctx.navamsa_dispositor(lord_h) if lord_h else None
if disp and l9 and disp in ctx.planets and ctx.is_exalted(disp) and related(disp, l9):
return success()
return []
if ctype == "navamsa_lord_of_moon_exalted_in_rasi":
disp = ctx.navamsa_dispositor("Moon")
return success() if disp and disp in ctx.planets and ctx.is_exalted(disp) else []
if ctype == "navamsa_dispositor_exalted_in_10th_with_lagna_lord":
ref = cond.get("reference_planet")
if ref == "10th_lord":
ref_planet = house_lord(10)
else:
ref_planet = ref if ref in ctx.planets else None
disp = ctx.navamsa_dispositor(ref_planet) if ref_planet else None
l1 = house_lord(1)
return success() if disp and l1 and disp in ctx.planets and ctx.is_exalted(disp) and ctx.house_of(disp) == 10 and related(disp, l1) else []
if ctype == "navamsa_lord_of_4th_lord_in_12th":
l4 = house_lord(4)
disp = ctx.navamsa_dispositor(l4) if l4 else None
return success() if disp and disp in ctx.planets and ctx.house_of(disp) == 12 else []
if ctype == "moon_with_malefics_in_navamsa_cancer_scorpio":
moon_sign = ctx.d9_sign_of("Moon")
moon_house = ctx.d9_house_of("Moon")
return success() if moon_sign in {"Cancer", "Scorpio"} and moon_house and any(ctx.d9_house_of(p) == moon_house for p in MALEFICS if p in ctx.planets and p != "Moon") else []
if ctype == "sun_and_mandi_in_house":
target = cond.get("house") or cond.get("in_house")
if target is None and cond.get("house_offset") is not None:
target = int(cond.get("house_offset")) + 1
return success() if target and ctx.house_of("Sun") == target and ctx.upagraha_house("maandi") == target else []
if ctype == "planet_conjunct_planet":
a = cond.get("planet") or cond.get("a")
b = cond.get("with") or cond.get("b")
return success() if a in ctx.planets and b in ctx.planets and ctx.house_of(a) == ctx.house_of(b) else []
if ctype == "lord_in_house":
lord = ctx.lord_of_house(cond.get("lord_of") or cond.get("house") or cond.get("lord_house"))
target = cond.get("in_house") or cond.get("target_house")
return success() if lord and ctx.house_of(lord) == target else []
if ctype == "house_lord_in_kendra":
lord = ctx.lord_of_house(cond.get("house"))
return success() if lord and ctx.is_kendra(ctx.house_of(lord)) else []
if ctype == "house_lord_in_trine":
lord = ctx.lord_of_house(cond.get("house"))
return success() if lord and ctx.is_trikona(ctx.house_of(lord)) else []
if ctype in ("lagna_hemmed_by_malefics_not_aspected_by_benefics", "lagna_hemmed_by_benefics_not_aspected_by_malefics"):
group = MALEFICS if "malefics" in ctype else BENEFICS
blockers = BENEFICS if "malefics" in ctype else MALEFICS
has_2 = any(ctx.house_of(p) == 2 for p in group if p in ctx.planets)
has_12 = any(ctx.house_of(p) == 12 for p in group if p in ctx.planets)
aspected = any(aspects(p, 1) for p in blockers if p in ctx.planets)
return success() if has_2 and has_12 and not aspected else []
if ctype == "planets_in_mutual_kendras_or_conjunction":
ps = planet_list()
if len(ps) >= 2:
a, b = ps[0], ps[1]
ha, hb = ctx.house_of(a), ctx.house_of(b)
return success() if ha and hb and (ha == hb or ctx.house_offset(ha, hb) in (0, 3, 6, 9)) else []
if ctype == "lords_in_mutual_conjunction_or_aspect":
houses = cond.get("lords") or []
ps = [house_lord(h) for h in houses]
return success() if len(ps) >= 2 and related(ps[0], ps[1]) else []
if ctype == "aspected_by_benefics":
p = cond.get("planet")
if isinstance(p, str) and p.endswith("_lord"):
p = house_lord(int(p.split("_")[0])) if p.split("_")[0].isdigit() else None
return success() if p and any(aspects(b, p) for b in BENEFICS if b in ctx.planets) else []
if ctype == "aspected_by_malefic":
p = cond.get("planet")
if p == "4th_lord":
p = house_lord(4)
return success() if p and any(aspects(m, p) for m in MALEFICS if m in ctx.planets) else []
if ctype == "5th_lord_afflicted_by_saturn_or_rahu":
p = house_lord(5)
return success() if p and (related(p, "Saturn") or related(p, "Rahu")) else []
if ctype == "malefic_in_lagna_or_gulika_in_trine_OR_gulika_with_kendra_trine_lord_OR_l1_with_rahu_sat_ket":
l1 = house_lord(1)
gh = ctx.upagraha_house("gulika")
# PyJHora: condition 3 stands alone; condition 1 requires BOTH malefic in Lagna AND Gulika in trine.
l1_with_rahu_sat_ket = l1 and any(ctx.house_of(l1) == ctx.house_of(p) for p in ["Rahu", "Saturn", "Ketu"] if p in ctx.planets and p != l1)
if l1_with_rahu_sat_ket:
return success()
if gh is None:
return []
malefic_in_lagna = any(ctx.house_of(p) == 1 for p in MALEFICS if p in ctx.planets)
gulika_in_trine = gh in (1, 5, 9)
if malefic_in_lagna and gulika_in_trine:
return success()
kendra_trine_lords = {house_lord(h) for h in (1, 4, 5, 7, 9, 10)}
gulika_with_kendra_trine_lord = any(
lord and lord in ctx.planets and ctx.house_of(lord) == gh for lord in kendra_trine_lords
)
return success() if gulika_with_kendra_trine_lord else []
if ctype == "same_lord_for_1st_and_4th":
return success() if house_lord(1) == house_lord(4) else []
if ctype == "1st_and_4th_lords_are_natural_or_temporal_friends":
# 保守近似：同宫/互相位视作 temporal association。
l1, l4 = house_lord(1), house_lord(4)
return success() if l1 and l4 and related(l1, l4) else []
if ctype == "1st_and_4th_lords_aspected_by_benefics":
l1, l4 = house_lord(1), house_lord(4)
ok1 = l1 and any(aspects(b, l1) for b in BENEFICS if b in ctx.planets)
ok4 = l4 and any(aspects(b, l4) for b in BENEFICS if b in ctx.planets)
return success() if ok1 and ok4 else []
if ctype == "4th_lord_is_benefic_aspected_by_benefic":
l4 = house_lord(4)
return success() if l4 and is_benefic(l4) and any(aspects(b, l4) for b in BENEFICS if b in ctx.planets and b != l4) else []
if ctype == "4th_house_or_lord_with_aspect_of_jupiter":
l4 = house_lord(4)
return success() if "Jupiter" in ctx.planets and (aspects("Jupiter", 4) or (l4 and related("Jupiter", l4))) else []
if ctype == "4th_lord_with_benefics":
l4 = house_lord(4)
return success() if l4 and any(ctx.house_of(l4) == ctx.house_of(b) for b in BENEFICS if b in ctx.planets and b != l4) else []
if ctype == "4th_lord_aspected_by_benefics":
l4 = house_lord(4)
return success() if l4 and any(aspects(b, l4) for b in BENEFICS if b in ctx.planets and b != l4) else []
if ctype == "4th_lord_in_kendra_or_trikona":
l4 = house_lord(4)
return success() if l4 and (ctx.is_kendra(ctx.house_of(l4)) or ctx.is_trikona(ctx.house_of(l4))) else []
if ctype == "lagna_lord_in_dry_sign":
l1 = house_lord(1)
# PyJHora const.dry_signs = [0,1,2,4,5,8] = Aries,Taurus,Gemini,Leo,Virgo,Sagittarius
dry_signs = {"Aries", "Taurus", "Gemini", "Leo", "Virgo", "Sagittarius"}
# PyJHora const.dry_planets = [0,2,6] = Sun,Mars,Saturn
dry_lords = {"Sun", "Mars", "Saturn"}
# PyJHora Y112: (ll_house in dry_signs) OR (ll_house_owner in dry_planets)
# ll_house = sign of lagna lord; ll_house_owner = dynamic lord of that sign
ll_in_dry = l1 and ctx.sign_of(l1) in dry_signs
l1_house = ctx.house_of(l1) if l1 else None
ll_owner_dry = l1_house and ctx.lord_of_house(l1_house) in dry_lords
return success() if l1 and (ll_in_dry or ll_owner_dry) else []
if ctype == "navamsa_lagna_in_dry_planet_sign":
d9_asc = ctx.d9.get("ascendant")
dry_lords = {"Sun", "Mars", "Saturn"}
return success() if d9_asc and SIGN_LORDS.get(d9_asc) in dry_lords else []
if ctype == "lagna_lord_and_navamsa_lord_both_in_watery_signs":
l1 = house_lord(1)
navamsa_lord = ctx.navamsa_dispositor(l1) if l1 else None
watery = {"Cancer", "Scorpio", "Pisces"}
return success() if l1 and navamsa_lord and ctx.sign_of(l1) in watery and ctx.sign_of(navamsa_lord) in watery else []
if ctype == "jupiter_in_lagna_or_aspects_lagna_from_watery":
return success() if "Jupiter" in ctx.planets and (ctx.house_of("Jupiter") == 1 or (ctx.sign_of("Jupiter") in {"Cancer", "Scorpio", "Pisces"} and aspects("Jupiter", 1))) else []
if ctype == "lagna_watery_with_benefics_or_lagna_lord_watery":
l1 = house_lord(1)
asc_watery = ctx.ascendant in {"Cancer", "Scorpio", "Pisces"}
watery_planets = {"Moon", "Venus"}
return success() if (asc_watery and any(ctx.house_of(b) == 1 for b in BENEFICS if b in ctx.planets)) or (l1 in watery_planets) else []
if ctype == "jupiter_in_lagna_mars_in_7th":
return success() if ctx.house_of("Jupiter") == 1 and ctx.house_of("Mars") == 7 else []
if ctype == "saturn_in_lagna_mars_in_5_7_9":
return success() if ctx.house_of("Saturn") == 1 and ctx.house_of("Mars") in (5, 7, 9) else []
if ctype == "saturn_in_12th_with_waning_moon":
return success() if ctx.house_of("Saturn") == 12 and ctx.is_waning_moon() else []
if ctype == "moon_mercury_in_kendra_with_planet":
return success() if ctx.house_of("Moon") == ctx.house_of("Mercury") and ctx.is_kendra(ctx.house_of("Moon")) and len(ctx.planets_in_house(ctx.house_of("Moon"))) >= 3 else []
if ctype == "four_planet_chain_all_in_kendra_trine_or_exaltation":
l1 = house_lord(1)
if not l1:
return []
chain = [l1]
current = l1
for _ in range(2):
sign_current = ctx.sign_of(current)
current = SIGN_LORDS.get(sign_current) if sign_current else None
if not current:
return []
chain.append(current)
d9_disp = ctx.navamsa_dispositor(current)
if not d9_disp:
return []
chain.append(d9_disp)
ok = all(
p in ctx.planets and (ctx.is_kendra(ctx.house_of(p)) or ctx.is_trikona(ctx.house_of(p)) or ctx.is_exalted(p))
for p in chain
)
return success() if ok else []
if ctype == "planets_in_relative_houses":
base = house(cond.get("from", "lagna")) or 1
offsets = cond.get("houses") or cond.get("offsets") or []
ps = planet_list(ALL_PLANETS)
targets = {rel_house(base, int(o) % 12) for o in offsets}
return success() if any(ctx.house_of(p) in targets for p in ps) else []
if ctype == "house_empty":
h = cond.get("house")
return success() if h and not ctx.planets_in_house(h) else []
if ctype == "planet_in_house_with_aspect_or_conjunction":
"""Jupiter in 2nd/5th, conjoined or aspected by Mercury AND Venus (kalaanidhi yoga)"""
planet = cond.get("planet", "")
house_offsets = cond.get("house_offsets", [])
aspecting_or_conjoining = cond.get("aspecting_or_conjoining", [])
if not planet or planet not in ctx.planets:
return []
ph = ctx.house_of(planet)
if ph is None:
return []
# Check planet is in one of the target houses (from lagna)
target_houses = set()
for off in house_offsets:
h = (1 + off) % 12
if h == 0: h = 12
target_houses.add(h)
if ph not in target_houses:
return []
# Check ALL specified planets must conjoin or aspect
for other in aspecting_or_conjoining:
if other not in ctx.planets:
return []
# Check conjunction (same house)
if ctx.house_of(other) == ph:
continue
# Check aspect (graha drishti)
if aspects(other, planet):
continue
# Neither conjoined nor aspecting → fail
return []
return success()
return []
# ------------------------------------------------------------------------
# 辅助方法
# ------------------------------------------------------------------------
def _resolve_binding(self, ref, ctx, bindings):
"""解析引用，支持变量绑定替换"""
if ref is None:
return []
if isinstance(ref, str) and ref.startswith("$"):
# 绑定变量引用，如 "$a"
val = bindings.get(ref[1:])
if val is None:
return []
return [val] if isinstance(val, str) else (val if isinstance(val, list) else [val])
return ctx.resolve(ref)
@staticmethod
def _offset_name(off: int) -> str:
names = {0: "同宫", 1: "2宫", 2: "3宫", 3: "4宫(Kendra)", 4: "5宫(Trine)",
5: "6宫", 6: "7宫(Kendra)", 7: "8宫", 8: "9宫(Trine)",
9: "10宫(Kendra)", 10: "11宫", 11: "12宫"}
return names.get(off, f"{off+1}宫")
# ============================================================================
# 便捷入口
# ============================================================================
def detect_yogas(planets: Dict[str, Dict], ascendant: str,
rules_path: Optional[str] = None,
context: Optional[Dict] = None) -> List[Dict]:
"""便捷函数：检测 Yoga"""
if rules_path is None:
# 自动查找规则文件
script_dir = os.path.dirname(os.path.abspath(__file__))
skill_dir = os.path.dirname(script_dir)
rules_path = os.path.join(skill_dir, "references", "yoga_rules.json")
engine = YogaEngine(rules_path)
return engine.detect(planets, ascendant, context=context)
def detect_yogas_from_json(chart_json: Dict, rules_path: Optional[str] = None) -> List[Dict]:
"""从 chart JSON 结构中提取 planets + ascendant 并检测"""
planets = chart_json.get("planets", {})
asc = chart_json.get("ascendant", chart_json.get("ascendant_sign", "Aries"))
return detect_yogas(planets, asc, rules_path, context=chart_json.get("context"))
if __name__ == "__main__":
# 简单自测
test_planets = {
"Sun": {"sign": "Aries", "house": 1, "degree": 10.5},
"Moon": {"sign": "Cancer", "house": 4, "degree": 15.0},
"Jupiter": {"sign": "Libra", "house": 7, "degree": 20.0},
}
print("YogaEngine loaded. Run with a rules file to test.")
Reference in New Issue View Git Blame Copy Permalink