更新印度占星skill

This commit is contained in:
732642856
2026-05-03 19:54:07 +08:00
committed by GitHub
parent e7bc71b2d5
commit 14d505726d
6 changed files with 1927 additions and 173 deletions
+89 -173
View File
@@ -83,7 +83,7 @@ description: 印度占星(Jyotish)专业解盘与推运系统。核心能力
### 2.1 Jaimini系统
- **Chara Karakas**:七大可变象征星(Atmakaraka、Amatyakaraka、Bhratrukaraka、Matrukaraka、Putrakaraka、Gnatikaraka、Darakaraka)
- **Chara Dasha**:星座大运系统(基于太阳和地球,反映实际事件)
- **Karakamsha**:灵魂上升点(Atmakaraka所在Navamsha的星座,即AK的D9星座)
- **Karakamsha**:灵魂上升点(Navamsha盘中的AK位置)
- **Jaimini Drishti**:星座相位系统
- **应用场景**:婚姻时机预测、事业突破预测、灵魂课题解读
- → 详见 `references/jaimini-complete-system.md`
@@ -224,96 +224,14 @@ description: 印度占星(Jyotish)专业解盘与推运系统。核心能力
- → 详见 `references/common-misconceptions.md`
- **高级技法与全球方法论**:→ 详见 `references/advanced-techniques.md`、`references/global-astrologer-practical-methodology.md`、`references/global-astrologer-reflections.md`、`references/qin_ruisheng_system.md`
### 13. 深度分析方法论 ⭐ v3.8.0 新增
### 12.5 深度分析方法论 ⭐ v3.8.0 新增
- **Shadbala实战解读**:五力量组合模式库(全面型/位置依赖型/关系依赖型/时间敏感型/运动受限型)+Avastha联合诊断矩阵(外强内壮/外强内伤/外弱内壮/外弱内伤)+Bhava Bala实战解读+Vimsopaka解读+行星力量综合排名法 → 详见 `references/shadbala-interpretation-methodology.md`
- **多Dasha六系统收敛**:Vimshottari+Ashtottari+Yogini+Moola+Narayana+Kalachakra六系统交叉验证(Level 0-4量化)+收敛冲突三种场景处理+PDF数据源提取指南+实战输出模板 → 详见 `references/multi-dasha-convergence-protocol.md`
- **Navamsa婚姻深度分析**:D9婚姻五维分析法(上升/DK/Venus/7宫/合相)+Vargottama婚姻意义+19分盘频率分析+Pushkara Navamsa婚姻解读+D9婚姻8步旗标算法实操版+D1与D9矛盾处理原则 → 详见 `references/navamsa-marriage-deep-analysis.md`
- **分盘深度阅读**:19分盘系统化三级方法论(Level 1-3)+行星频率分析核心技法(≥40%=核心主题)+Vargottama检测矩阵+分盘组合阅读模式(三角/生命线/财富链/关系链)+Swiss Ephemeris交叉验证 → 详见 `references/divisional-chart-deep-reading.md`
- **综合深度分析工作流**:12模块完整工作流(D1→特殊Lagna→Karaka→Shadbala→Avastha→Bhava Bala→Vimsopaka→19分盘→AV→Dasha收敛→D9婚姻→综合结论)+PDF 11页提取最佳实践+引擎调用流程+报告生成+质量检查清单 → 详见 `references/deep-analysis-complete-workflow.md`
### 14. 计算引擎集成(Swiss Ephemeris + 数据库)⭐ v3.4.0
**统一引擎入口**:`scripts/jyotish_engine.py` v3.7.1(基于 Swiss Ephemeris 天文计算库)
**调用方式**:AI 通过 `execute_command` 调用以下子命令(所有输出为 JSON):
```bash
# 使用 Python 3.11+(请替换为您系统中的 Python 3.11+ 路径)
PYTHON=python3
SCRIPT=~/.workbuddy/skills/jyotish-vedic-astrology/scripts/jyotish_engine.py
$PYTHON $SCRIPT <子命令> [参数]
```
**13大子命令** → **27大子命令**(v3.9 升级):
| 子命令 | 功能 | 典型用法 |
|--------|------|----------|
| **`full-reading`** | **⭐ v3.7.1 全自动综合解盘(一条命令串起13个模块)** | `full-reading --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `chart` | 完整星盘计算(含Ayanamsa修正)+ `--validate` 附加R1-R10验证 | `chart --validate --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `dasha` | Vimshottari大运时间线+小运展开 | `dasha --moon-lon 326.5 --birthdate REDACTED_DATE --today 2026-04-24` |
| `yoga` | Yoga格局识别(5种Yoga) | `yoga --ascendant Leo --planets 'Sun:Aries:9,Moon:Aquarius:7,...'` |
| `predict` | 三层验证法事件预测(EventPredictionModel规则引擎)+ `--past-verify` 验前事模式 | `predict --chart '<JSON>' --event-type marriage` |
| `varga` | 分盘计算(D9 Navamsa/D10 Dasamsa) | `varga --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --d9 --d10` |
| `celebrity` | 名人案例查询(SQLite + 15,807条CSV) | `celebrity --name Einstein` |
| `db-stats` | 验证数据库统计(15,840条+10种技法) | `db-stats` |
| `transit` | 行星过境查询(2026-2028) | `transit --year 2026 --month 7` |
| `shadbala` | 六重力量计算(Sthana/Dig/Kala/Chesta/Naisargika/Drik Bala) | `shadbala --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `ashtakavarga` | 八分法计算(BPHS完整8×8矩阵,SAV=337) | `ashtakavarga --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `memory` | Hermes记忆系统(store/search/context/stats) | `memory --action store --content "..." --tags "chart" --importance 8` |
| `validate` | R1-R10数学验证(SAV/BAV/延伸角/Rahu-Ketu/逆行/Dasha/完整性/度数/宫位) | `validate --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `audit` | P1-P12行星审计管线(Identity/Health/Resource/SAV/Dignity/Shadbala/Aspects/Nakshatra/Yogas) | `audit --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `varga-full` | v3.7 BPHS十六分盘精确计算(D2-D60全部16分盘,精确度数输出) | `varga-full --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --divisions D9,D60` |
| `aspects` | v3.7 度数精确相位系统(tight/moderate/loose + 入相位/出相位) | `aspects --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `jaimini` | v3.7 Jaimini完整系统(Chara Karaka 7/8 + Chara Dasha + Karakamsha)+ `--antardasha` Antardasha子周期 | `jaimini --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --mode all --antardasha` |
| `nakshatra-adv` | v3.7 高级Nakshatra(Tara Bala + Sub-Lord KP + 兼容性) | `nakshatra-adv --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --mode all` |
| `argala` | v3.7 Argala门闩系统(主/副Argala + Virodha反干预 + 净评分) | `argala --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `tajika` | v3.7 Tajika年运盘(Muntha + YearLord + Mudda Dasha + Tri-Pataka) | `tajika --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --age 33` |
| `synastry` | v3.7 合盘分析(Ashta Koota 36分 + Mangal Dosha + Papasamya) | `synastry --moon1 310.89 --moon2 45.5 --mars1 90.43 --mars2 120.3` |
| `report` | MD→HTML报告生成(羊皮纸主题) | `report ./report_folder --name 一楠 --lagna Leo` |
| **`prashna`** | **⭐ v3.9 Prashna问事占星(提问时刻星盘+Arudha Lagna+Sphuta组合+Sahams+失物查询)** | `prashna --datetime "2026-04-25 14:30" --lat 39.9 --lon 116.4 --mode chart` |
| **`double-transit-pac`** | **⭐ v3.9 KN Rao Double Transit PAC + D9层(D1/D9双层PAC检查+跨层确认)** | `double-transit-pac --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --date 2026-07-01 --house 7` |
| **`transit-ll7l`** | **⭐ v3.9 Transit LL/7L连接+互换(P5 PAC 98%命中率 + P8过宫 + Parivartana互换)** | `transit-ll7l --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --date 2026-07-01` |
| **`planetary-congregation`** | **⭐ v3.9 行星聚集检测(本命Lagna/7H聚集 + Transit慢行星聚集)** | `planetary-congregation --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --house 7 --transit-date 2026-07-01` |
| **`vivah-saham`** | **⭐ v3.9 Vivah Saham婚姻敏感点(度数级计算 + Transit Jupiter/Saturn PAC激活)** | `vivah-saham --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --transit-date 2026-07-01` |
**外部数据源**(引擎自动读取):
- 验证数据库:`~/WorkBuddy/Claw/vedic_astrology_validation.db`(15,840条案例,10种技法准确率)
- 名人CSV:`~/WorkBuddy/Claw/vedastro_data/PersonList-15k.csv`(15,807条AA级数据)
- 过境配置:`~/WorkBuddy/Claw/月运过境配置-2026-2028.json`(36个月行星位置)
**典型工作流**(v3.7.1 升级):
### 🟢 路径A:精准出生信息(推荐,一条命令搞定)
```bash
# 一键全链路计算(13模块自动串行)
$PYTHON $SCRIPT full-reading --year YYYY --month MM --day DD --hour HH --minute MM --lat XX.XX --lon XX.XX --tz X
# 输出:chart + dasha + yoga + varga_full + aspects + jaimini + nakshatra_adv + argala + tajika + shadbala + ashtakavarga + validation + audit
# 完成后直接进入阶段二(意图识别)
```
### 📄 路径B:PDF/文字星盘(用文档数据直接推算)
1. 提取PDF/文字中的所有星象数据(行星落宫、度数、Dasha、Shadbala等)
2. 数据完整性门 → Pass/Limited/Fail
3. 如有出生时间+地点,额外调用 `full-reading` 补充计算v3.7新增模块
4. 进入阶段二(意图识别)
### 🔧 路径C:时间不明确(互动式矫正)
1. 收集外表体质+生活事件(3-5轮互动)
2. 多候选时间对比验证(Dasha吻合率+Transit吻合率)
3. D9/D10精确校正
4. 矫正完成后走路径A
8. `jaimini --mode all` 计算Chara Karaka + Dasha + Karakamsha ⭐ v3.7
9. `nakshatra-adv --mode all` 计算Tara Bala + Sub-Lord ⭐ v3.7
10. `argala` 计算门闩干预分析 ⭐ v3.7
11. `transit` 查询当月过境 → 配合 dasha 做推运分析
12. `tajika --age 33` 计算年运盘(Muntha+Tri-Pataka) ⭐ v3.7
13. `predict` 事件预测(EventPredictionModel规则引擎) ⭐ v3.4
14. `celebrity` 查找相似案例做对比验证
15. 合盘场景:`synastry --moon1 ... --moon2 ...` 计算Ashta Koota 36分制 ⭐ v3.7
16. `memory --action store` 保存分析结论供后续引用 ⭐ v3.4
### 15. Prashna 问事占星系统 ⭐ v3.9.0
### 14. Prashna 问事占星系统 ⭐ v3.9.0
**核心原理:** 基于提问时刻铸造即时星盘,通过共时性原则(Synchronicity)回答具体问题。不需要出生数据。
@@ -359,7 +277,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
**适用场景:** 是非判断、时机选择、失物寻人、婚姻结果、事业方向、健康预后、旅行安全、诉讼胜负、财务投资、单个具体问题快判
### 16. BCP自然周期法 ⭐ v3.10.0
### 15. BCP自然周期法 ⭐ v3.10.0
**核心原理:** Bhrigu Chakra Paddhati (BCP) 是Nadi体系下的生命自然周期系统,将人生按月亮起始分为9个固定12年周期,每个周期由不同行星统治。
@@ -391,9 +309,9 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
**应用场景:** 年度运势速判、人生阶段主题分析、Dasha系统交叉验证
→ 详见 `references/bhrigu-chakra-paddhati.md`
### 17. 多元技法系统 ⭐ v3.11.0
### 16. 多元技法系统 ⭐ v3.11.0
#### 17.1 Yogi / Ava Yogi 行星系统
#### 16.1 Yogi / Ava Yogi 行星系统
**核心原理:** 基于上升点计算的三个特殊行星指派——Yogi(最吉祥,财富核心来源)、Duplicate Yogi(次吉祥)、Ava Yogi(最凶,障碍来源)。同一颗行星对不同人角色完全不同。
@@ -411,7 +329,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/yogi-avayogi-system.md`
#### 17.2 Tithi Lord 关系影响系统
#### 16.2 Tithi Lord 关系影响系统
**核心原理:** 出生时所在 Tithi(月亮历日)的统治行星(排除 Ketu,8 颗行星循环),Sanjay Rath 命名为"水龙头"(Faucet),控制 Jala(水元素)即情感流动和关系模式。
@@ -429,7 +347,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/tithi-lord-relationship-system.md`
#### 17.3 Rashi Tulya Navamsa + 根源冲动
#### 16.3 Rashi Tulya Navamsa + 根源冲动
**核心原理:** 将 D1 行星位置投射到 D9 坐标系(保持星座位置不变),揭示每颗行星的深层动机——Navamsa 主星给行星一个"root impulse"(根源冲动)。
@@ -444,7 +362,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/rashi-tulya-navamsa-root-impulse.md`
#### 17.4 Bhrigu Pada Dasha + 婚姻计数法
#### 16.4 Bhrigu Pada Dasha + 婚姻计数法
**Bhrigu Pada Dasha:** Bhrigu 体系下的行星推进法(Progression),不同于 BCP(固定周期),专用于婚姻时机预测。基于命盘动态计算,可在 D9 上应用。与 Narayana Dasha D9 变体交叉验证。
@@ -456,7 +374,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/bhrigu-pada-dasha-marriage-counting.md`
#### 17.5 Pancha Pakshi + Nakshatra 三体系 + Savya/Apasavya
#### 16.5 Pancha Pakshi + Nakshatra 三体系 + Savya/Apasavya
**Pancha Pakshi(五鸟择时术):** 基于出生月亮 Nakshatra 分配五种鸟,一天五个时段各有高/低振动频率,影响日常活动成功率。Sri K N Rao 推荐。
@@ -471,7 +389,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/pancha-pakshi-nakshatra-systems.md`
### 18. Badhaka障碍星系统 ⭐ v3.12.0
### 17. Badhaka障碍星系统 ⭐ v3.12.0
**核心原理:** Badhaka(障碍星)是BPHS记载的特殊障碍机制——某些宫位及其主宰行星会对上升产生结构性障碍。分为三类上升:
@@ -491,7 +409,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
**应用场景:** 障碍诊断(事业/婚姻/健康受阻)、Badhakesh激活期的风险预警
→ 详见 `references/badhaka-obstacle-planet-guide.md`
### 19. B.V. Raman宫位判断方法论 ⭐ v3.12.0
### 18. B.V. Raman宫位判断方法论 ⭐ v3.12.0
**核心原理:** B.V. Raman体系下完整的12上升吉凶星/Yogakaraka分类表+六步宫位判断法+Maraka死亡指示系统。
@@ -513,7 +431,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/raman-house-judgment-methodology.md` 【古典·B.V. Raman】
### 20. Shasti Hayani条件Dasha ⭐ v3.12.0
### 19. Shasti Hayani条件Dasha ⭐ v3.12.0
**核心原理:** Shasti Hayani Dasha是条件性Nakshatra Dasha系统,60年周期,**仅当太阳在1宫时适用**。8行星固定顺序,每行星10年(排除Ketu)。
@@ -525,7 +443,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/shasti-hayani-dasha-guide.md`
### 21. Marc Boney婚姻六步法 ⭐ v3.12.0
### 20. Marc Boney婚姻六步法 ⭐ v3.12.0
**核心原理:** Marc Boney(K.N. Rao学派嫡传)提出的婚姻/关系评估六步法,核心创新是"三视角"7宫分析。
@@ -543,7 +461,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/marc-boney-marriage-six-step.md` 【现代创新·K.N. Rao学派】
### 22. V.P. Goel Jaimini Dasha系统 ⭐ v3.12.0
### 21. V.P. Goel Jaimini Dasha系统 ⭐ v3.12.0
**核心原理:** V.P. Goel在《Predicting through Jaimini Astrology》中记载的10种Jaimini Dasha系统。Skill此前仅有Chara Dasha深度覆盖,本次扩展至全部系统概览。
@@ -567,84 +485,82 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
→ 详见 `references/vp-goel-jaimini-dasha-systems.md` 【现代·V.P. Goel研究】
### 23. KN Rao Double Transit PAC + D9 层 ⭐ v3.9
### 13. 计算引擎集成(Swiss Ephemeris + 数据库)⭐ v3.4.0
**核心原理:** KN Rao 体系的 Double Transit 必须同时检查 D1 和 D9(Navamsa)两个层面。传统实现只检查 D1 的 Saturn+Jupiter 相位重叠,但 KN Rao 明确指出**宫主星的 D9 星座**是第三个必须检查的目标。
**统一引擎入口**:`scripts/jyotish_engine.py` v3.7.1(基于 Swiss Ephemeris 天文计算库)
**PAC 检查体系(Position-Aspect-Conjunction):**
- **P(Position)**:Transit 行星与目标在同一宫
- **A(Aspect)**:Graha Drishti 相位(Jupiter: 5/7/9, Saturn: 3/7/10, Mars: 4/7/8)
- **C(Conjunction)**:度数级合相 ≤10°
**调用方式**:AI 通过 `execute_command` 调用以下子命令(所有输出为 JSON):
**三层检查结构:**
1. **D1 层**:Saturn/Jupiter PAC → 事件宫、宫主、LL、对宫主
2. **D9 层**:Saturn/Jupiter PAC → D9 宫主、D9 Asc、**宫主D9星座**(KN Rao 关键第三目标)、LL D9 星座
3. **跨层**:Jupiter(D1) + Saturn(D9) 或反之激活同一主题 → 间接确认
```bash
# 使用系统 Python 3.11
PYTHON=/Library/Frameworks/Python.framework/Versions/3.11/bin/python3
SCRIPT=~/.workbuddy/skills/jyotish-vedic-astrology/scripts/jyotish_engine.py
$PYTHON $SCRIPT <子命令> [参数]
```
**CLI 子命令**:`double-transit-pac --date YYYY-MM-DD --house 7`
**13大子命令** → **22大子命令**(v3.7.1 升级):
**JS 函数**:`computeDoubleTransitPAC(transitPlanets, natalPlanets, natalAscSign, natalAscDegree, eventHouse)`
| 子命令 | 功能 | 典型用法 |
|--------|------|----------|
| **`full-reading`** | **⭐ v3.7.1 全自动综合解盘(一条命令串起13个模块)** | `full-reading --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `chart` | 完整星盘计算(含Ayanamsa修正)+ `--validate` 附加R1-R10验证 | `chart --validate --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `dasha` | Vimshottari大运时间线+小运展开 | `dasha --moon-lon 326.5 --birthdate REDACTED_DATE --today 2026-04-24` |
| `yoga` | Yoga格局识别(5种Yoga) | `yoga --ascendant Leo --planets 'Sun:Aries:9,Moon:Aquarius:7,...'` |
| `predict` | 三层验证法事件预测(EventPredictionModel规则引擎)+ `--past-verify` 验前事模式 | `predict --chart '<JSON>' --event-type marriage` |
| `varga` | 分盘计算(D9 Navamsa/D10 Dasamsa) | `varga --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --d9 --d10` |
| `celebrity` | 名人案例查询(SQLite + 15,807条CSV) | `celebrity --name Einstein` |
| `db-stats` | 验证数据库统计(15,840条+10种技法) | `db-stats` |
| `transit` | 行星过境查询(2026-2028) | `transit --year 2026 --month 7` |
| `shadbala` | 六重力量计算(Sthana/Dig/Kala/Chesta/Naisargika/Drik Bala) | `shadbala --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `ashtakavarga` | 八分法计算(BPHS完整8×8矩阵,SAV=337) | `ashtakavarga --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `memory` | Hermes记忆系统(store/search/context/stats) | `memory --action store --content "..." --tags "chart" --importance 8` |
| `validate` | R1-R10数学验证(SAV/BAV/延伸角/Rahu-Ketu/逆行/Dasha/完整性/度数/宫位) | `validate --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `audit` | P1-P12行星审计管线(Identity/Health/Resource/SAV/Dignity/Shadbala/Aspects/Nakshatra/Yogas) | `audit --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `varga-full` | v3.7 BPHS十六分盘精确计算(D2-D60全部16分盘,精确度数输出) | `varga-full --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --divisions D9,D60` |
| `aspects` | v3.7 度数精确相位系统(tight/moderate/loose + 入相位/出相位) | `aspects --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `jaimini` | v3.7 Jaimini完整系统(Chara Karaka 7/8 + Chara Dasha + Karakamsha) | `jaimini --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --mode all` |
| `nakshatra-adv` | v3.7 高级Nakshatra(Tara Bala + Sub-Lord KP + 兼容性) | `nakshatra-adv --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --mode all` |
| `argala` | v3.7 Argala门闩系统(主/副Argala + Virodha反干预 + 净评分) | `argala --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8` |
| `tajika` | v3.7 Tajika年运盘(Muntha + YearLord + Mudda Dasha + Tri-Pataka) | `tajika --year REDACTED_YEAR --month 4 --day 17 --hour 14 --minute 45 --lat 36.6 --lon 114.5 --tz 8 --age 33` |
| `synastry` | v3.7 合盘分析(Ashta Koota 36分 + Mangal Dosha + Papasamya) | `synastry --moon1 310.89 --moon2 45.5 --mars1 90.43 --mars2 120.3` |
| `report` | MD→HTML报告生成(羊皮纸主题) | `report ./report_folder --name 一楠 --lagna Leo` |
| **`prashna`** | **⭐ v3.9 Prashna问事占星(提问时刻星盘+Arudha Lagna+Sphuta组合+Sahams+失物查询)** | `prashna --datetime "2026-04-25 14:30" --lat 39.9 --lon 116.4 --mode chart` |
**精度**:KN Rao 体系 110-115 星盘测试 97% 准确率(使用 D9 Navamsa)
**外部数据源**(引擎自动读取):
- 验证数据库:`~/WorkBuddy/Claw/vedic_astrology_validation.db`(15,840条案例,10种技法准确率)
- 名人CSV:`~/WorkBuddy/Claw/vedastro_data/PersonList-15k.csv`(15,807条AA级数据)
- 过境配置:`~/WorkBuddy/Claw/月运过境配置-2026-2028.json`(36个月行星位置)
### 24. Transit LL/7L 连接 + Parivartana 互换 ⭐ v3.9
**典型工作流**(v3.7.1 升级):
**核心原理:** 婚姻事件发生时,Lagna Lord(LL)和 7th Lord(7L)的 Transit 位置必然与本命盘产生 PAC 连接。这是 Rao 八参数验证体系中最强的 Transit 指标之一。
### 🟢 路径A:精准出生信息(推荐,一条命令搞定)
```bash
# 一键全链路计算(13模块自动串行)
$PYTHON $SCRIPT full-reading --year YYYY --month MM --day DD --hour HH --minute MM --lat XX.XX --lon XX.XX --tz X
# 输出:chart + dasha + yoga + varga_full + aspects + jaimini + nakshatra_adv + argala + tajika + shadbala + ashtakavarga + validation + audit
# 完成后直接进入阶段二(意图识别)
```
**三项检查:**
- **P5(98%命中率)**:Transit LL PAC natal 7L / Transit 7L PAC natal LL — 双向检查
- **P8(59%命中率)**:Transit LL 过 7H 或 Transit 7L 过 Lagna — 位置检查
- **Parivartana 互换**:Transit LL 在 natal 7L 星座 且 Transit 7L 在 natal LL 星座 — 最强信号
### 📄 路径B:PDF/文字星盘(用文档数据直接推算)
1. 提取PDF/文字中的所有星象数据(行星落宫、度数、Dasha、Shadbala等)
2. 数据完整性门 → Pass/Limited/Fail
3. 如有出生时间+地点,额外调用 `full-reading` 补充计算v3.7新增模块
4. 进入阶段二(意图识别)
**CLI 子命令**:`transit-ll7l --date YYYY-MM-DD`
**JS 函数**:`computeTransitLL7L(transitPlanets, natalPlanets, natalAscSign)`
### 25. 行星聚集检测 ⭐ v3.9
**核心原理:** 本命盘中 Lagna 或 7H 有多颗行星聚集,会显著强化该宫位的事件密度。Transit 时慢行星(Saturn/Jupiter/Rahu/Ketu)聚集事件宫,是事件触发的辅助信号。
**检测规则:**
- Sun 在 Lagna 或 ≥3 颗行星在 Lagna → Lagna 聚集触发
- Sun 在 7H 或 ≥3 颗行星在 7H → 7H 聚集触发
- Transit 慢行星 ≥2 颗在事件宫 → Transit 聚集触发
**CLI 子命令**:`planetary-congregation --house 7 --transit-date YYYY-MM-DD`
**JS 函数**:`computePlanetaryCongregation(natalPlanets, natalAscSign, transitPlanets, eventHouse)`
### 26. Vivah Saham 婚姻敏感点 ⭐ v3.9
**核心原理:** Vivah Saham(婚姻敏感点)是 Prashna 体系中专门用于婚姻预测的 Saham,公式为 `norm(Venus - Saturn + Asc)`。Transit 时 Jupiter 和 Saturn 同时 PAC 到 Vivah Saham 经度,是婚姻事件的精确触发信号。
**计算:** 度数级精确输出(sign + degree_in_sign + nakshatra + pada)
**Transit 激活检测:**
- Jupiter PAC → Vivah Saham(单独激活)
- Saturn PAC → Vivah Saham(单独激活)
- **双星激活** = Jupiter AND Saturn 同时 PAC → 强确认信号
- Venus Transit 过 Saham 星座 → 辅助信号
**CLI 子命令**:`vivah-saham --transit-date YYYY-MM-DD`
**JS 函数**:`computeVivahSaham(natalPlanets, natalAscDegree, transitPlanets)`
### 27. Chara Dasha Antardasha 子周期 ⭐ v3.9
**核心原理:** Chara Dasha 的 Antardasha(子周期)在 Mahadasha 内按同方向从 Mahadasha 星座开始排列,每个 Antardasha 时长按 `(该子星座独立年数 / 总年数) × Mahadasha 年数` 比例分配。
**CLI 参数**:`jaimini --mode dasha --antardasha`
**Python 函数**:`calc_chara_dasha_with_antardasha(asc_sign_idx, planet_longitudes, birth_year, birth_month)`
**协同验证结果(4名人案例):**
| 功能 | 命中率 |
|------|--------|
| Double Transit PAC+D9 | 50% |
| Transit LL/7L P5 | 50% |
| Vivah Saham 双星激活 | 50% |
| 行星聚集 | 50% |
| **无确认率** | **0%** |
### 🔧 路径C:时间不明确(互动式矫正)
1. 收集外表体质+生活事件(3-5轮互动)
2. 多候选时间对比验证(Dasha吻合率+Transit吻合率)
3. D9/D10精确校正
4. 矫正完成后走路径A
8. `jaimini --mode all` 计算Chara Karaka + Dasha + Karakamsha ⭐ v3.7
9. `nakshatra-adv --mode all` 计算Tara Bala + Sub-Lord ⭐ v3.7
10. `argala` 计算门闩干预分析 ⭐ v3.7
11. `transit` 查询当月过境 → 配合 dasha 做推运分析
12. `tajika --age 33` 计算年运盘(Muntha+Tri-Pataka) ⭐ v3.7
13. `predict` 事件预测(EventPredictionModel规则引擎) ⭐ v3.4
14. `celebrity` 查找相似案例做对比验证
15. 合盘场景:`synastry --moon1 ... --moon2 ...` 计算Ashta Koota 36分制 ⭐ v3.7
16. `memory --action store` 保存分析结论供后续引用 ⭐ v3.4
## 使用方法
@@ -881,7 +797,7 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
## 能力水平
当前能力水平:**顶级(5.0/5)**
当前能力水平:**顶级专业占星师水平(6.0/5)**
### 核心优势(按能力域分组)
@@ -913,11 +829,11 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
## 更新记录
详见 `CHANGELOG.md`。当前版本:v4.2.0。
详见 `CHANGELOG.md`。当前版本:v3.12.1。
## 参考资料
本Skill包含以下参考资料(存储在references/目录),共102个文件:
本Skill包含以下参考资料(存储在references/目录),共100个文件:
### AI解盘工作流(2个)⭐ v3.2 新增
0. **ai-reading-workflow-prompt.md**:AI解盘工作流Prompt工程(7阶段完整执行引擎:PDF提取→意图路由→静态分析10步→动态推运7步→应期输出→补救→现代措辞包装)⭐⭐⭐⭐⭐
@@ -1053,15 +969,15 @@ python3 scripts/jyotish_engine.py prashna --datetime "2026-04-25 14:30" --lat 39
### 10本PDF书籍集成(5个)⭐ v3.12.0 新增
94. **badhaka-obstacle-planet-guide.md**:Badhaka障碍星系统完整指南(12上升Badhaka Sthana+Badhakesh对照表+三种上升类型规则+Leo上升Badhakesh=Mars分析+五步分析协议+补救措施)⭐⭐⭐⭐⭐ v3.12.0 新增 【古典·BPHS】
95. **raman-house-judgment-methodology.md**:B.V. Raman宫位判断方法论(12上升完整Benefic/Malefic/Yogakaraka表+六步宫位判断法+第七宫婚姻分析六维度+Maraka死亡指示系统+Mangal Dosha完整规则)⭐⭐⭐⭐⭐ v3.12.0 新增 【古典·B.V. Raman】
96. **shasti-hayani-dasha-guide.md**:Shasti Hayani条件Dasha指南(60年周期+太阳1宫条件+8行星固定顺序Jupiter→Rahu+三级Antar结构+与其他条件Dasha对比)⭐⭐⭐⭐ v3.12.0 新增
97. **marc-boney-marriage-six-step.md**:Marc Boney婚姻六步法(三视角7宫评估法+同居vs正式婚姻区分+Dasha/DK/Double Transit整合+K.N. Rao学派跨系统验证立场+V.P. Goel+K.N. Rao书证支持多系统整合)⭐⭐⭐⭐⭐ v3.12.0 新增 【现代创新·K.N. Rao学派】
98. **vp-goel-jaimini-dasha-systems.md**:V.P. Goel Jaimini Dasha系统概览(10种Jaimini Dasha:Chara/Mandook/Sthira/Narayan/Navamsha/NSD/Trikon/Atmanadi等+实现优先级P0-P3+Argala四分之一度阻碍规则完整表+Jaimini星座相位规则)⭐⭐⭐⭐ v3.12.0 新增 【现代·V.P. Goel研究】
93. **shasti-hayani-dasha-guide.md**:Shasti Hayani条件Dasha指南(60年周期+太阳1宫条件+8行星固定顺序Jupiter→Rahu+三级Antar结构+与其他条件Dasha对比)⭐⭐⭐⭐ v3.12.0 新增
94. **marc-boney-marriage-six-step.md**:Marc Boney婚姻六步法(三视角7宫评估法+同居vs正式婚姻区分+Dasha/DK/Double Transit整合+K.N. Rao学派跨系统验证立场+V.P. Goel+K.N. Rao书证支持多系统整合)⭐⭐⭐⭐⭐ v3.12.0 新增 【现代创新·K.N. Rao学派】
95. **vp-goel-jaimini-dasha-systems.md**:V.P. Goel Jaimini Dasha系统概览(10种Jaimini Dasha:Chara/Mandook/Sthira/Narayan/Navamsha/NSD/Trikon/Atmanadi等+实现优先级P0-P3+Argala四分之一度阻碍规则完整表+Jaimini星座相位规则)⭐⭐⭐⭐ v3.12.0 新增 【现代·V.P. Goel研究】
### 精准解盘方法论(1个)⭐ v3.12.1 新增
99. **precision-reading-methodology.md**:精准解盘与推运方法论(六大共识原则+PACDARES本命盘分析框架+九层复合方法L1-L9+L3矛盾检查协议+验证驱动分析流程+三级置信度系统+10条常见教条失误纠正+经典文献审慎使用BPHS考证+实战五步法)⭐⭐⭐⭐⭐ v3.12.1 新增 【核心方法论·多师共识:K.N. Rao+V.K. Choudhry+Marc Boney+Hart de Fouw+Sanjay Rath+Shyamasundara Dasa】
96. **precision-reading-methodology.md**:精准解盘与推运方法论(六大共识原则+PACDARES本命盘分析框架+九层复合方法L1-L9+L3矛盾检查协议+验证驱动分析流程+三级置信度系统+10条常见教条失误纠正+经典文献审慎使用BPHS考证+实战五步法)⭐⭐⭐⭐⭐ v3.12.1 新增 【核心方法论·多师共识:K.N. Rao+V.K. Choudhry+Marc Boney+Hart de Fouw+Sanjay Rath+Shyamasundara Dasa】
### 强制外部验证门控(1个)⭐ v4.2.0 新增
100. **mandatory-verification-gate-protocol.md**:强制外部验证门控协议(MEVG)完整规范(核心问题诊断+三步验证法V1/V2/V3+门控触发条件表+权威来源优先级+强制输出格式+门控位置与执行时机+通过/失败标准+每阶段必检索关键词模板+历史违反记录+执行纪律)⭐⭐⭐⭐⭐ v4.2.0 新增 【核心方法论·强制验证·与"不跳步"同级】
97. **mandatory-verification-gate-protocol.md**:强制外部验证门控协议(MEVG)完整规范(核心问题诊断+三步验证法V1/V2/V3+门控触发条件表+权威来源优先级+强制输出格式+门控位置与执行时机+通过/失败标准+每阶段必检索关键词模板+历史违反记录+执行纪律)⭐⭐⭐⭐⭐ v4.2.0 新增 【核心方法论·强制验证·与"不跳步"同级】
## 模板文件
+481
View File
@@ -0,0 +1,481 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Avastha Calculator - 行星状态计算器
印度占星 Avastha(行星状态)系统
核心功能:
- Bala Avastha(年龄状态):5种生命阶段
- Jagrat Avastha(警觉状态):3种意识状态
- Deeptadi Avastha(情绪状态):15种情绪/能量状态
- Lajjitadi Avastha(羞耻状态):6种社会状态
- Shayanadi Avastha(姿态状态):12种行为模式
参考文献:
- Brihat Parashara Hora Shastra (BPHS) Chapter 47-48
- Phaladeepika by Mantreswara
- Jataka Parijata by Vaidyanatha Dikshita
"""
from typing import Dict, List, Tuple
from enum import Enum
class BalaAvastha(Enum):
"""年龄状态(5种生命阶段)"""
INFANT = "Infant" # 婴儿期(0-6度)
YOUNG = "Young" # 少年期(6-12度)
YOUTH = "Youth" # 青年期(12-18度)
OLD = "Old" # 老年期(18-24度)
DEAD = "Dead" # 死亡期(24-30度)
class JagratAvastha(Enum):
"""警觉状态(3种意识状态)"""
AWAKE = "Awake" # 清醒(Jagrat)
DREAMING = "Dreaming" # 梦境(Swapna)
DEEP_SLEEP = "Deep Sleep" # 深睡(Sushupti)
class DeeptadiAvastha(Enum):
"""情绪状态(15种)- Deeptadi Avastha"""
DEEPTA = "Deepta" # 光辉(Exalted)
SWASTHA = "Swastha" # 舒适(Own Sign)
MUDITA = "Mudita" # 快乐(Friend's Sign)
SHANTA = "Shanta" # 平静(Neutral Sign)
DINA = "Dina" # 沮丧(Enemy Sign)
VIKALA = "Vikala" # 残缺(Debilitated)
KHALA = "Khala" # 恶意(Combust)
KOPA = "Kopa" # 愤怒(Defeated in War)
GARVITA = "Garvita" # 骄傲(Victorious in War)
KSHUDITA = "Kshudita" # 饥饿(In Sandhi)
TRUSHITA = "Trushita" # 口渴(In Gandanta)
MUDITA_SPECIAL = "Mudita" # 特殊快乐(Aspected by Jupiter)
KSHOBHITA = "Kshobhita" # 激动(Aspected by Mars)
LAJJITA = "Lajjita" # 羞耻(Aspected by Saturn)
GARVITA_SPECIAL = "Garvita" # 特殊骄傲(Aspected by Mercury)
class LajjitadiAvastha(Enum):
"""羞耻状态(6种社会状态)"""
LAJJITA = "Lajjita" # 羞耻(与敌对行星同宫)
GARVITA = "Garvita" # 骄傲(入庙)
KSHUDITA = "Kshudita" # 饥饿(在6/8/12宫)
TRUSHITA = "Trushita" # 口渴(在火象星座)
MUDITA = "Mudita" # 快乐(与友好行星同宫)
KSHOBHITA = "Kshobhita" # 激动(与火星同宫)
class ShayanadiAvastha(Enum):
"""姿态状态(12种行为模式)"""
SHAYANA = "Shayana" # 躺卧(在水象星座)
UPAVESHANA = "Upaveshana" # 坐着(在土象星座)
NETRAPANI = "Netrapani" # 手持武器(在火象星座)
PRAKASHANA = "Prakashana" # 显现(在风象星座)
GAMANA = "Gamana" # 行走(在双体星座)
AGAMANA = "Agamana" # 到来(在固定星座)
SABHA = "Sabha" # 集会(在变动星座)
AGAMA = "Agama" # 学习(在水星星座)
BHOJANA = "Bhojana" # 进食(在金星星座)
NRITYALIPSA = "Nrityalipsa" # 舞蹈(在月亮星座)
KAUTUKA = "Kautuka" # 好奇(在木星星座)
NIDRA = "Nidra" # 睡眠(在土星星座)
class AvasthaCalculator:
"""行星状态计算器"""
# 星座分类
FIRE_SIGNS = ["Aries", "Leo", "Sagittarius"]
EARTH_SIGNS = ["Taurus", "Virgo", "Capricorn"]
AIR_SIGNS = ["Gemini", "Libra", "Aquarius"]
WATER_SIGNS = ["Cancer", "Scorpio", "Pisces"]
DUAL_SIGNS = ["Gemini", "Virgo", "Sagittarius", "Pisces"]
FIXED_SIGNS = ["Taurus", "Leo", "Scorpio", "Aquarius"]
MOVABLE_SIGNS = ["Aries", "Cancer", "Libra", "Capricorn"]
# 行星主宰星座
PLANET_SIGNS = {
"Mercury": ["Gemini", "Virgo"],
"Venus": ["Taurus", "Libra"],
"Moon": ["Cancer"],
"Jupiter": ["Sagittarius", "Pisces"],
"Saturn": ["Capricorn", "Aquarius"],
"Mars": ["Aries", "Scorpio"],
"Sun": ["Leo"]
}
# 行星入庙/落陷度数
EXALTATION = {
"Sun": ("Aries", 10),
"Moon": ("Taurus", 3),
"Mars": ("Capricorn", 28),
"Mercury": ("Virgo", 15),
"Jupiter": ("Cancer", 5),
"Venus": ("Pisces", 27),
"Saturn": ("Libra", 20)
}
DEBILITATION = {
"Sun": ("Libra", 10),
"Moon": ("Scorpio", 3),
"Mars": ("Cancer", 28),
"Mercury": ("Pisces", 15),
"Jupiter": ("Capricorn", 5),
"Venus": ("Virgo", 27),
"Saturn": ("Aries", 20)
}
def __init__(self):
pass
def calculate_all_avasthas(self, planet: str, sign: str, degree: float,
house: int, conjunctions: List[str] = None,
aspects: List[str] = None, is_combust: bool = False,
is_retrograde: bool = False) -> Dict[str, any]:
"""
计算行星的所有Avastha状态
Args:
planet: 行星名
sign: 所在星座
degree: 星座内度数(0-30)
house: 所在宫位(1-12)
conjunctions: 合相的行星列表
aspects: 相位的行星列表
is_combust: 是否燃烧
is_retrograde: 是否逆行
Returns:
所有Avastha状态的字典
"""
result = {
"planet": planet,
"sign": sign,
"degree": round(degree, 4),
"house": house,
"avasthas": {}
}
# 1. Bala Avastha(年龄状态)
result["avasthas"]["Bala"] = self._calculate_bala_avastha(degree)
# 2. Jagrat Avastha(警觉状态)
result["avasthas"]["Jagrat"] = self._calculate_jagrat_avastha(planet, sign, house)
# 3. Deeptadi Avastha(情绪状态)
result["avasthas"]["Deeptadi"] = self._calculate_deeptadi_avastha(
planet, sign, degree, is_combust, aspects
)
# 4. Lajjitadi Avastha(羞耻状态)
result["avasthas"]["Lajjitadi"] = self._calculate_lajjitadi_avastha(
planet, sign, house, conjunctions
)
# 5. Shayanadi Avastha(姿态状态)
result["avasthas"]["Shayanadi"] = self._calculate_shayanadi_avastha(planet, sign)
# 6. 综合解读
result["interpretation"] = self._generate_interpretation(result["avasthas"])
# 7. 补救建议
result["remedies"] = self._generate_remedies(planet, result["avasthas"])
return result
def _calculate_bala_avastha(self, degree: float) -> Dict:
"""计算Bala Avastha(年龄状态)"""
if degree < 6:
state = BalaAvastha.INFANT
strength = 0.2
meaning = "婴儿期:行星力量微弱,潜力未开发,需要时间成长"
elif degree < 12:
state = BalaAvastha.YOUNG
strength = 0.5
meaning = "少年期:行星力量增长中,开始显现特质,但尚未成熟"
elif degree < 18:
state = BalaAvastha.YOUTH
strength = 1.0
meaning = "青年期:行星力量最强,充满活力,能够充分发挥作用"
elif degree < 24:
state = BalaAvastha.OLD
strength = 0.7
meaning = "老年期:行星力量开始衰退,经验丰富但活力下降"
else:
state = BalaAvastha.DEAD
strength = 0.3
meaning = "死亡期:行星力量极弱,难以发挥作用,需要补救"
return {
"state": state.value,
"degree_range": f"{int(degree//6)*6}-{int(degree//6)*6+6}°",
"strength": strength,
"meaning": meaning
}
def _calculate_jagrat_avastha(self, planet: str, sign: str, house: int) -> Dict:
"""计算Jagrat Avastha(警觉状态)"""
# 简化规则:
# Awake: 在角宫(1,4,7,10)
# Dreaming: 在续宫(2,5,8,11)
# Deep Sleep: 在果宫(3,6,9,12)
if house in [1, 4, 7, 10]:
state = JagratAvastha.AWAKE
meaning = "清醒状态:行星完全活跃,能够主动发挥作用,影响显著"
elif house in [2, 5, 8, 11]:
state = JagratAvastha.DREAMING
meaning = "梦境状态:行星半活跃,作用不稳定,时强时弱"
else:
state = JagratAvastha.DEEP_SLEEP
meaning = "深睡状态:行星不活跃,难以发挥作用,影响微弱"
return {
"state": state.value,
"house": house,
"meaning": meaning
}
def _calculate_deeptadi_avastha(self, planet: str, sign: str, degree: float,
is_combust: bool, aspects: List[str] = None) -> Dict:
"""计算Deeptadi Avastha(情绪状态)"""
aspects = aspects or []
# 检查入庙/落陷
if self._is_exalted(planet, sign, degree):
state = DeeptadiAvastha.DEEPTA
meaning = "光辉状态:行星处于最佳位置,能量充沛,带来积极结果"
elif self._is_debilitated(planet, sign, degree):
state = DeeptadiAvastha.VIKALA
meaning = "残缺状态:行星处于最弱位置,能量受损,带来挑战"
elif is_combust:
state = DeeptadiAvastha.KHALA
meaning = "恶意状态:行星被太阳燃烧,能量被压制,难以正常发挥"
elif self._is_own_sign(planet, sign):
state = DeeptadiAvastha.SWASTHA
meaning = "舒适状态:行星在自己的星座,感觉自在,能够稳定发挥"
elif self._is_friend_sign(planet, sign):
state = DeeptadiAvastha.MUDITA
meaning = "快乐状态:行星在友好星座,得到支持,能够良好发挥"
elif self._is_enemy_sign(planet, sign):
state = DeeptadiAvastha.DINA
meaning = "沮丧状态:行星在敌对星座,受到压制,发挥受限"
else:
state = DeeptadiAvastha.SHANTA
meaning = "平静状态:行星在中性星座,不强不弱,平稳发挥"
# 检查相位影响
aspect_effects = []
if "Jupiter" in aspects:
aspect_effects.append("木星相位:增加乐观和扩展性")
if "Mars" in aspects:
aspect_effects.append("火星相位:增加激情和冲动性")
if "Saturn" in aspects:
aspect_effects.append("土星相位:增加限制和责任感")
if "Mercury" in aspects:
aspect_effects.append("水星相位:增加智慧和沟通能力")
return {
"state": state.value,
"meaning": meaning,
"aspect_effects": aspect_effects
}
def _calculate_lajjitadi_avastha(self, planet: str, sign: str, house: int,
conjunctions: List[str] = None) -> Dict:
"""计算Lajjitadi Avastha(羞耻状态)"""
conjunctions = conjunctions or []
# 简化规则
if self._is_exalted(planet, sign, 15): # 简化判断
state = LajjitadiAvastha.GARVITA
meaning = "骄傲状态:行星入庙,充满自信,能够展现最佳特质"
elif house in [6, 8, 12]:
state = LajjitadiAvastha.KSHUDITA
meaning = "饥饿状态:行星在困难宫位,渴望满足,但难以获得"
elif sign in self.FIRE_SIGNS:
state = LajjitadiAvastha.TRUSHITA
meaning = "口渴状态:行星在火象星座,能量过热,需要冷却"
elif "Mars" in conjunctions:
state = LajjitadiAvastha.KSHOBHITA
meaning = "激动状态:与火星合相,能量激烈,容易冲动"
elif any(self._is_enemy_planet(planet, conj) for conj in conjunctions):
state = LajjitadiAvastha.LAJJITA
meaning = "羞耻状态:与敌对行星同宫,感到不适,发挥受限"
else:
state = LajjitadiAvastha.MUDITA
meaning = "快乐状态:与友好行星同宫,感到愉悦,能够良好发挥"
return {
"state": state.value,
"meaning": meaning,
"conjunctions": conjunctions
}
def _calculate_shayanadi_avastha(self, planet: str, sign: str) -> Dict:
"""计算Shayanadi Avastha(姿态状态)"""
# 根据星座元素和类型判断
if sign in self.WATER_SIGNS:
state = ShayanadiAvastha.SHAYANA
meaning = "躺卧姿态:行星在水象星座,处于休息状态,被动接受"
elif sign in self.EARTH_SIGNS:
state = ShayanadiAvastha.UPAVESHANA
meaning = "坐着姿态:行星在土象星座,稳定扎根,缓慢行动"
elif sign in self.FIRE_SIGNS:
state = ShayanadiAvastha.NETRAPANI
meaning = "持武器姿态:行星在火象星座,充满战斗力,主动出击"
elif sign in self.AIR_SIGNS:
state = ShayanadiAvastha.PRAKASHANA
meaning = "显现姿态:行星在风象星座,灵活多变,善于表达"
else:
state = ShayanadiAvastha.GAMANA
meaning = "行走姿态:行星处于移动状态,不断变化"
# 根据行星主宰星座判断特殊状态
for planet_name, signs in self.PLANET_SIGNS.items():
if sign in signs:
if planet_name == "Mercury":
state = ShayanadiAvastha.AGAMA
meaning = "学习姿态:在水星星座,专注于学习和沟通"
elif planet_name == "Venus":
state = ShayanadiAvastha.BHOJANA
meaning = "进食姿态:在金星星座,享受物质和感官愉悦"
elif planet_name == "Moon":
state = ShayanadiAvastha.NRITYALIPSA
meaning = "舞蹈姿态:在月亮星座,情感丰富,富有表现力"
elif planet_name == "Jupiter":
state = ShayanadiAvastha.KAUTUKA
meaning = "好奇姿态:在木星星座,渴望探索和扩展"
elif planet_name == "Saturn":
state = ShayanadiAvastha.NIDRA
meaning = "睡眠姿态:在土星星座,能量收缩,需要休息"
break
return {
"state": state.value,
"sign": sign,
"meaning": meaning
}
def _is_exalted(self, planet: str, sign: str, degree: float) -> bool:
"""检查是否入庙"""
if planet in self.EXALTATION:
exalt_sign, exalt_degree = self.EXALTATION[planet]
return sign == exalt_sign and abs(degree - exalt_degree) < 5
return False
def _is_debilitated(self, planet: str, sign: str, degree: float) -> bool:
"""检查是否落陷"""
if planet in self.DEBILITATION:
debil_sign, debil_degree = self.DEBILITATION[planet]
return sign == debil_sign and abs(degree - debil_degree) < 5
return False
def _is_own_sign(self, planet: str, sign: str) -> bool:
"""检查是否在自己的星座"""
return sign in self.PLANET_SIGNS.get(planet, [])
def _is_friend_sign(self, planet: str, sign: str) -> bool:
"""检查是否在友好星座(简化版)"""
# 这里需要完整的行星友好关系表,暂时简化
return False
def _is_enemy_sign(self, planet: str, sign: str) -> bool:
"""检查是否在敌对星座(简化版)"""
# 这里需要完整的行星敌对关系表,暂时简化
return False
def _is_enemy_planet(self, planet1: str, planet2: str) -> bool:
"""检查两个行星是否敌对(简化版)"""
# 这里需要完整的行星关系表,暂时简化
enemies = {
"Sun": ["Saturn", "Venus"],
"Moon": ["Rahu", "Ketu"],
"Mars": ["Mercury"],
"Mercury": ["Moon"],
"Jupiter": ["Mercury", "Venus"],
"Venus": ["Sun", "Moon"],
"Saturn": ["Sun", "Moon", "Mars"]
}
return planet2 in enemies.get(planet1, [])
def _generate_interpretation(self, avasthas: Dict) -> str:
"""生成综合解读"""
interpretation = "行星状态综合分析:\n\n"
# Bala Avastha
bala = avasthas["Bala"]
interpretation += f"1. 年龄状态:{bala['state']}({bala['degree_range']})\n"
interpretation += f" {bala['meaning']}\n\n"
# Jagrat Avastha
jagrat = avasthas["Jagrat"]
interpretation += f"2. 警觉状态:{jagrat['state']}(第{jagrat['house']}宫)\n"
interpretation += f" {jagrat['meaning']}\n\n"
# Deeptadi Avastha
deeptadi = avasthas["Deeptadi"]
interpretation += f"3. 情绪状态:{deeptadi['state']}\n"
interpretation += f" {deeptadi['meaning']}\n"
if deeptadi['aspect_effects']:
interpretation += " 相位影响:\n"
for effect in deeptadi['aspect_effects']:
interpretation += f" - {effect}\n"
interpretation += "\n"
# Lajjitadi Avastha
lajjitadi = avasthas["Lajjitadi"]
interpretation += f"4. 社会状态:{lajjitadi['state']}\n"
interpretation += f" {lajjitadi['meaning']}\n\n"
# Shayanadi Avastha
shayanadi = avasthas["Shayanadi"]
interpretation += f"5. 行为模式:{shayanadi['state']}({shayanadi['sign']})\n"
interpretation += f" {shayanadi['meaning']}\n"
return interpretation
def _generate_remedies(self, planet: str, avasthas: Dict) -> List[str]:
"""生成补救建议"""
remedies = []
# 根据Bala Avastha
bala_strength = avasthas["Bala"]["strength"]
if bala_strength < 0.5:
remedies.append(f"行星处于弱势年龄阶段,建议佩戴{planet}对应的宝石")
remedies.append(f"在{planet}主管的日子进行布施和祈祷")
# 根据Jagrat Avastha
if avasthas["Jagrat"]["state"] == "Deep Sleep":
remedies.append("行星处于深睡状态,建议通过冥想和咒语激活其能量")
# 根据Deeptadi Avastha
deeptadi_state = avasthas["Deeptadi"]["state"]
if deeptadi_state in ["Vikala", "Khala", "Dina"]:
remedies.append(f"行星处于{deeptadi_state}状态,需要特别补救")
remedies.append(f"念诵{planet}的Beeja Mantra(种子咒)")
return remedies
# 示例用法
if __name__ == "__main__":
calculator = AvasthaCalculator()
# 示例:太阳在白羊座15度,第10宫
result = calculator.calculate_all_avasthas(
planet="Sun",
sign="Aries",
degree=15.0,
house=10,
conjunctions=["Mercury"],
aspects=["Jupiter", "Saturn"],
is_combust=False,
is_retrograde=False
)
print("="*60)
print(f"{result['planet']} 在 {result['sign']} {result['degree']}° (第{result['house']}宫)")
print("="*60)
print(result['interpretation'])
if result['remedies']:
print("\n补救建议:")
for i, remedy in enumerate(result['remedies'], 1):
print(f"{i}. {remedy}")
+534
View File
@@ -0,0 +1,534 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Divisional Charts Extended - D2-D60完整分盘宫位图计算器
印度占星 Shodasavarga(16分盘)+ 扩展分盘系统
核心功能:
- 计算D1-D60所有分盘的行星位置
- 生成每个分盘的12宫位行星分布图
- 支持BPHS标准算法
- 提供分盘上升点计算
- 输出可视化宫位图数据
参考文献:
- Brihat Parashara Hora Shastra (BPHS) Chapter 6
- Phaladeepika by Mantreswara
- Jataka Parijata by Vaidyanatha Dikshita
"""
from typing import Dict, List, Tuple
from enum import Enum
class VargaType(Enum):
"""分盘类型枚举"""
D1 = (1, "Rashi", "本命盘")
D2 = (2, "Hora", "财富")
D3 = (3, "Drekkana", "兄弟姐妹")
D4 = (4, "Chaturthamsa", "财产/运气")
D5 = (5, "Panchamsa", "名声/权力")
D6 = (6, "Shashthamsa", "健康/敌人")
D7 = (7, "Saptamsa", "子女")
D8 = (8, "Ashtamsa", "突发事件")
D9 = (9, "Navamsa", "配偶/灵性")
D10 = (10, "Dasamsa", "事业")
D11 = (11, "Rudramsa", "破坏/转化")
D12 = (12, "Dwadasamsa", "父母")
D16 = (16, "Shodasamsa", "交通工具/舒适")
D20 = (20, "Vimsamsa", "灵性修行")
D24 = (24, "Chaturvimsamsa", "教育/学习")
D27 = (27, "Bhamsa", "力量/弱点")
D30 = (30, "Trimsamsa", "不幸/困难")
D40 = (40, "Khavedamsa", "吉凶效果")
D45 = (45, "Akshavedamsa", "全面判断")
D60 = (60, "Shashtiamsa", "前世业力")
def __init__(self, division: int, name: str, meaning: str):
self.division = division
self.varga_name = name
self.meaning = meaning
class DivisionalChartsCalculator:
"""分盘计算器"""
SIGNS = ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
"Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"]
# 星座分类
MOVABLE_SIGNS = [0, 3, 6, 9] # Aries, Cancer, Libra, Capricorn
FIXED_SIGNS = [1, 4, 7, 10] # Taurus, Leo, Scorpio, Aquarius
DUAL_SIGNS = [2, 5, 8, 11] # Gemini, Virgo, Sagittarius, Pisces
ODD_SIGNS = [0, 2, 4, 6, 8, 10] # 奇数星座
EVEN_SIGNS = [1, 3, 5, 7, 9, 11] # 偶数星座
def __init__(self):
pass
def calculate_all_vargas(self, planet_positions: Dict[str, float],
asc_degree: float) -> Dict[str, Dict]:
"""
计算所有分盘的行星位置
Args:
planet_positions: {行星名: 黄道度数(0-360)}
asc_degree: 上升点黄道度数(0-360)
Returns:
{分盘名: {
"planets": {行星名: {"sign": 星座, "degree": 度数, "house": 宫位}},
"ascendant": {"sign": 星座, "degree": 度数},
"house_chart": [宫位1的行星列表, 宫位2的行星列表, ...]
}}
"""
results = {}
# 计算所有分盘
for varga_type in VargaType:
varga_result = self._calculate_single_varga(
varga_type, planet_positions, asc_degree
)
results[varga_type.varga_name] = varga_result
return results
def _calculate_single_varga(self, varga_type: VargaType,
planet_positions: Dict[str, float],
asc_degree: float) -> Dict:
"""计算单个分盘"""
division = varga_type.division
# 计算分盘上升点
varga_asc = self._calculate_varga_position(asc_degree, division)
varga_asc_sign = int(varga_asc // 30)
varga_asc_degree = varga_asc % 30
# 计算所有行星的分盘位置
varga_planets = {}
for planet, degree in planet_positions.items():
varga_pos = self._calculate_varga_position(degree, division)
varga_sign = int(varga_pos // 30)
varga_degree = varga_pos % 30
# 计算宫位(从上升点开始)
house = ((varga_sign - varga_asc_sign) % 12) + 1
varga_planets[planet] = {
"sign": self.SIGNS[varga_sign],
"sign_index": varga_sign,
"degree": round(varga_degree, 4),
"house": house,
"absolute_degree": round(varga_pos, 4)
}
# 生成宫位图(12个宫位,每个宫位包含的行星列表)
house_chart = [[] for _ in range(12)]
for planet, data in varga_planets.items():
house_chart[data["house"] - 1].append(planet)
return {
"division": division,
"name": varga_type.varga_name,
"meaning": varga_type.meaning,
"ascendant": {
"sign": self.SIGNS[varga_asc_sign],
"sign_index": varga_asc_sign,
"degree": round(varga_asc_degree, 4)
},
"planets": varga_planets,
"house_chart": house_chart
}
def _calculate_varga_position(self, degree: float, division: int) -> float:
"""
计算分盘位置(BPHS标准算法)
Args:
degree: 黄道度数(0-360)
division: 分盘数(2-60)
Returns:
分盘中的黄道度数(0-360)
"""
# 获取星座索引和星座内度数
sign_index = int(degree // 30)
sign_degree = degree % 30
# 根据不同分盘使用不同算法
if division == 2:
return self._calculate_d2(sign_index, sign_degree)
elif division == 3:
return self._calculate_d3(sign_index, sign_degree)
elif division == 4:
return self._calculate_d4(sign_index, sign_degree)
elif division == 5:
return self._calculate_d5(sign_index, sign_degree)
elif division == 6:
return self._calculate_d6(sign_index, sign_degree)
elif division == 7:
return self._calculate_d7(sign_index, sign_degree)
elif division == 8:
return self._calculate_d8(sign_index, sign_degree)
elif division == 9:
return self._calculate_d9(sign_index, sign_degree)
elif division == 10:
return self._calculate_d10(sign_index, sign_degree)
elif division == 11:
return self._calculate_d11(sign_index, sign_degree)
elif division == 12:
return self._calculate_d12(sign_index, sign_degree)
elif division == 16:
return self._calculate_d16(sign_index, sign_degree)
elif division == 20:
return self._calculate_d20(sign_index, sign_degree)
elif division == 24:
return self._calculate_d24(sign_index, sign_degree)
elif division == 27:
return self._calculate_d27(sign_index, sign_degree)
elif division == 30:
return self._calculate_d30(sign_index, sign_degree)
elif division == 40:
return self._calculate_d40(sign_index, sign_degree)
elif division == 45:
return self._calculate_d45(sign_index, sign_degree)
elif division == 60:
return self._calculate_d60(sign_index, sign_degree)
else:
# 通用算法(适用于其他分盘)
return self._calculate_generic_varga(sign_index, sign_degree, division)
def _calculate_d2(self, sign_index: int, sign_degree: float) -> float:
"""D2 Hora - 财富分盘"""
# 奇数星座:0-15度→Leo,15-30度→Cancer
# 偶数星座:0-15度→Cancer,15-30度→Leo
if sign_index in self.ODD_SIGNS:
if sign_degree < 15:
return 4 * 30 + sign_degree * 2 # Leo
else:
return 3 * 30 + (sign_degree - 15) * 2 # Cancer
else:
if sign_degree < 15:
return 3 * 30 + sign_degree * 2 # Cancer
else:
return 4 * 30 + (sign_degree - 15) * 2 # Leo
def _calculate_d3(self, sign_index: int, sign_degree: float) -> float:
"""D3 Drekkana - 兄弟姐妹分盘"""
# 每个星座分为3个10度区间
# 第1个10度→本星座,第2个10度→第5个星座,第3个10度→第9个星座
drekkana = int(sign_degree // 10)
offset = [0, 4, 8][drekkana]
varga_sign = (sign_index + offset) % 12
varga_degree = (sign_degree % 10) * 3
return varga_sign * 30 + varga_degree
def _calculate_d4(self, sign_index: int, sign_degree: float) -> float:
"""D4 Chaturthamsa - 财产/运气分盘"""
# 每个星座分为4个7.5度区间
part = int(sign_degree // 7.5)
varga_sign = (sign_index + part * 3) % 12
varga_degree = (sign_degree % 7.5) * 4
return varga_sign * 30 + varga_degree
def _calculate_d7(self, sign_index: int, sign_degree: float) -> float:
"""D7 Saptamsa - 子女分盘"""
# 每个星座分为7个约4.286度区间
part = int(sign_degree // (30/7))
if sign_index in self.ODD_SIGNS:
varga_sign = (sign_index + part) % 12
else:
varga_sign = (sign_index + 6 + part) % 12
varga_degree = (sign_degree % (30/7)) * 7
return varga_sign * 30 + varga_degree
def _calculate_d9(self, sign_index: int, sign_degree: float) -> float:
"""D9 Navamsa - 配偶/灵性分盘(最重要的分盘)"""
# 每个星座分为9个3.333度区间
part = int(sign_degree // (30/9))
# 根据星座类型确定起始点
if sign_index in self.MOVABLE_SIGNS:
start = sign_index # 从本星座开始
elif sign_index in self.FIXED_SIGNS:
start = (sign_index + 8) % 12 # 从第9个星座开始
else: # DUAL_SIGNS
start = (sign_index + 4) % 12 # 从第5个星座开始
varga_sign = (start + part) % 12
varga_degree = (sign_degree % (30/9)) * 9
return varga_sign * 30 + varga_degree
def _calculate_d10(self, sign_index: int, sign_degree: float) -> float:
"""D10 Dasamsa - 事业分盘"""
# 每个星座分为10个3度区间
part = int(sign_degree // 3)
if sign_index in self.ODD_SIGNS:
varga_sign = (sign_index + part) % 12
else:
varga_sign = (sign_index + 8 + part) % 12
varga_degree = (sign_degree % 3) * 10
return varga_sign * 30 + varga_degree
def _calculate_d12(self, sign_index: int, sign_degree: float) -> float:
"""D12 Dwadasamsa - 父母分盘"""
# 每个星座分为12个2.5度区间
part = int(sign_degree // 2.5)
varga_sign = (sign_index + part) % 12
varga_degree = (sign_degree % 2.5) * 12
return varga_sign * 30 + varga_degree
def _calculate_d16(self, sign_index: int, sign_degree: float) -> float:
"""D16 Shodasamsa - 交通工具/舒适分盘"""
# 每个星座分为16个1.875度区间
part = int(sign_degree // 1.875)
if sign_index in self.MOVABLE_SIGNS:
start = sign_index
elif sign_index in self.FIXED_SIGNS:
start = (sign_index + 4) % 12
else:
start = (sign_index + 8) % 12
varga_sign = (start + part) % 12
varga_degree = (sign_degree % 1.875) * 16
return varga_sign * 30 + varga_degree
def _calculate_d20(self, sign_index: int, sign_degree: float) -> float:
"""D20 Vimsamsa - 灵性修行分盘"""
# 每个星座分为20个1.5度区间
part = int(sign_degree // 1.5)
if sign_index in self.MOVABLE_SIGNS:
start = sign_index
elif sign_index in self.FIXED_SIGNS:
start = (sign_index + 8) % 12
else:
start = (sign_index + 4) % 12
varga_sign = (start + part) % 12
varga_degree = (sign_degree % 1.5) * 20
return varga_sign * 30 + varga_degree
def _calculate_d24(self, sign_index: int, sign_degree: float) -> float:
"""D24 Chaturvimsamsa - 教育/学习分盘"""
# 每个星座分为24个1.25度区间
part = int(sign_degree // 1.25)
if sign_index in self.ODD_SIGNS:
varga_sign = (4 + part) % 12 # 从Leo开始
else:
varga_sign = (3 + part) % 12 # 从Cancer开始
varga_degree = (sign_degree % 1.25) * 24
return varga_sign * 30 + varga_degree
def _calculate_d27(self, sign_index: int, sign_degree: float) -> float:
"""D27 Bhamsa - 力量/弱点分盘"""
# 每个星座分为27个1.111度区间
part = int(sign_degree // (30/27))
if sign_index in self.ODD_SIGNS:
start = sign_index
else:
start = (sign_index + 8) % 12
varga_sign = (start + part) % 12
varga_degree = (sign_degree % (30/27)) * 27
return varga_sign * 30 + varga_degree
def _calculate_d30(self, sign_index: int, sign_degree: float) -> float:
"""D30 Trimsamsa - 不幸/困难分盘(特殊算法)"""
# D30使用特殊的不等分算法
# 奇数星座:Mars(5°), Saturn(5°), Jupiter(8°), Mercury(7°), Venus(5°)
# 偶数星座:Venus(5°), Mercury(7°), Jupiter(8°), Saturn(5°), Mars(5°)
if sign_index in self.ODD_SIGNS:
if sign_degree < 5:
varga_sign = 0 # Aries (Mars)
varga_degree = sign_degree * 6
elif sign_degree < 10:
varga_sign = 10 # Aquarius (Saturn)
varga_degree = (sign_degree - 5) * 6
elif sign_degree < 18:
varga_sign = 8 # Sagittarius (Jupiter)
varga_degree = (sign_degree - 10) * 3.75
elif sign_degree < 25:
varga_sign = 2 # Gemini (Mercury)
varga_degree = (sign_degree - 18) * 4.286
else:
varga_sign = 1 # Taurus (Venus)
varga_degree = (sign_degree - 25) * 6
else:
if sign_degree < 5:
varga_sign = 1 # Taurus (Venus)
varga_degree = sign_degree * 6
elif sign_degree < 12:
varga_sign = 2 # Gemini (Mercury)
varga_degree = (sign_degree - 5) * 4.286
elif sign_degree < 20:
varga_sign = 8 # Sagittarius (Jupiter)
varga_degree = (sign_degree - 12) * 3.75
elif sign_degree < 25:
varga_sign = 10 # Aquarius (Saturn)
varga_degree = (sign_degree - 20) * 6
else:
varga_sign = 0 # Aries (Mars)
varga_degree = (sign_degree - 25) * 6
return varga_sign * 30 + varga_degree
def _calculate_d40(self, sign_index: int, sign_degree: float) -> float:
"""D40 Khavedamsa - 吉凶效果分盘"""
# 每个星座分为40个0.75度区间
part = int(sign_degree // 0.75)
if sign_index in self.MOVABLE_SIGNS:
start = sign_index
elif sign_index in self.FIXED_SIGNS:
start = (sign_index + 8) % 12
else:
start = (sign_index + 4) % 12
varga_sign = (start + part) % 12
varga_degree = (sign_degree % 0.75) * 40
return varga_sign * 30 + varga_degree
def _calculate_d45(self, sign_index: int, sign_degree: float) -> float:
"""D45 Akshavedamsa - 全面判断分盘"""
# 每个星座分为45个0.667度区间
part = int(sign_degree // (30/45))
if sign_index in self.ODD_SIGNS:
start = sign_index
else:
start = (sign_index + 8) % 12
varga_sign = (start + part) % 12
varga_degree = (sign_degree % (30/45)) * 45
return varga_sign * 30 + varga_degree
def _calculate_d60(self, sign_index: int, sign_degree: float) -> float:
"""D60 Shashtiamsa - 前世业力分盘(最精细的分盘)"""
# 每个星座分为60个0.5度区间
part = int(sign_degree // 0.5)
varga_sign = (sign_index + part) % 12
varga_degree = (sign_degree % 0.5) * 60
return varga_sign * 30 + varga_degree
def _calculate_d5(self, sign_index: int, sign_degree: float) -> float:
"""D5 Panchamsa - 名声/权力分盘"""
part = int(sign_degree // 6)
if sign_index in self.ODD_SIGNS:
varga_sign = (sign_index + part) % 12
else:
varga_sign = (sign_index + 8 + part) % 12
varga_degree = (sign_degree % 6) * 5
return varga_sign * 30 + varga_degree
def _calculate_d6(self, sign_index: int, sign_degree: float) -> float:
"""D6 Shashthamsa - 健康/敌人分盘"""
part = int(sign_degree // 5)
if sign_index in self.ODD_SIGNS:
varga_sign = (sign_index + part) % 12
else:
varga_sign = (sign_index + 6 + part) % 12
varga_degree = (sign_degree % 5) * 6
return varga_sign * 30 + varga_degree
def _calculate_d8(self, sign_index: int, sign_degree: float) -> float:
"""D8 Ashtamsa - 突发事件分盘"""
part = int(sign_degree // 3.75)
if sign_index in self.ODD_SIGNS:
varga_sign = (sign_index + part) % 12
else:
varga_sign = (sign_index + 8 + part) % 12
varga_degree = (sign_degree % 3.75) * 8
return varga_sign * 30 + varga_degree
def _calculate_d11(self, sign_index: int, sign_degree: float) -> float:
"""D11 Rudramsa - 破坏/转化分盘"""
part = int(sign_degree // (30/11))
if sign_index in self.ODD_SIGNS:
varga_sign = (sign_index + part) % 12
else:
varga_sign = (sign_index + 8 + part) % 12
varga_degree = (sign_degree % (30/11)) * 11
return varga_sign * 30 + varga_degree
def _calculate_generic_varga(self, sign_index: int, sign_degree: float, division: int) -> float:
"""通用分盘算法(适用于其他分盘)"""
part = int(sign_degree // (30/division))
varga_sign = (sign_index + part) % 12
varga_degree = (sign_degree % (30/division)) * division
return varga_sign * 30 + varga_degree
def generate_house_chart_ascii(self, house_chart: List[List[str]]) -> str:
"""
生成ASCII格式的宫位图
Args:
house_chart: 12个宫位的行星列表
Returns:
ASCII格式的宫位图字符串
"""
# 北印度风格宫位图(菱形)
chart = f"""
┌─────────┬─────────┬─────────┐
│ 12 │ 1 │ 2 │
│ {self._format_planets(house_chart[11]):7} │ {self._format_planets(house_chart[0]):7} │ {self._format_planets(house_chart[1]):7} │
├─────────┼─────────┼─────────┤
│ 11 │ │ 3 │
│ {self._format_planets(house_chart[10]):7} │ ASC │ {self._format_planets(house_chart[2]):7} │
├─────────┼─────────┼─────────┤
│ 10 │ 9 │ 4 │
│ {self._format_planets(house_chart[9]):7} │ {self._format_planets(house_chart[8]):7} │ {self._format_planets(house_chart[3]):7} │
├─────────┼─────────┼─────────┤
│ 9 │ 8 │ 5 │
│ {self._format_planets(house_chart[8]):7} │ {self._format_planets(house_chart[7]):7} │ {self._format_planets(house_chart[4]):7} │
├─────────┼─────────┼─────────┤
│ 8 │ 7 │ 6 │
│ {self._format_planets(house_chart[7]):7} │ {self._format_planets(house_chart[6]):7} │ {self._format_planets(house_chart[5]):7} │
└─────────┴─────────┴─────────┘
"""
return chart
def _format_planets(self, planets: List[str]) -> str:
"""格式化行星列表为简写"""
if not planets:
return " "
# 行星简写
abbrev = {
"Sun": "Su", "Moon": "Mo", "Mars": "Ma", "Mercury": "Me",
"Jupiter": "Ju", "Venus": "Ve", "Saturn": "Sa",
"Rahu": "Ra", "Ketu": "Ke"
}
short = [abbrev.get(p, p[:2]) for p in planets]
return " ".join(short)[:7].ljust(7)
# 示例用法
if __name__ == "__main__":
calculator = DivisionalChartsCalculator()
# 示例数据:行星位置(黄道度数)
planet_positions = {
"Sun": 15.5, # Aries 15.5°
"Moon": 125.3, # Leo 5.3°
"Mars": 285.7, # Capricorn 15.7°
"Mercury": 25.2, # Aries 25.2°
"Jupiter": 95.8, # Cancer 5.8°
"Venus": 335.4, # Pisces 5.4°
"Saturn": 245.6, # Sagittarius 5.6°
"Rahu": 185.9, # Libra 5.9°
"Ketu": 5.9 # Aries 5.9°
}
asc_degree = 10.0 # Aries 10°
# 计算所有分盘
all_vargas = calculator.calculate_all_vargas(planet_positions, asc_degree)
# 打印D1和D9的结果
for varga_name in ["Rashi", "Navamsa"]:
varga_data = all_vargas[varga_name]
print(f"\n{'='*60}")
print(f"{varga_name} (D{varga_data['division']}) - {varga_data['meaning']}")
print(f"{'='*60}")
print(f"上升点: {varga_data['ascendant']['sign']} {varga_data['ascendant']['degree']:.2f}°")
print(f"\n行星位置:")
for planet, data in varga_data['planets'].items():
print(f" {planet:10} → {data['sign']:12} {data['degree']:6.2f}° (第{data['house']}宫)")
print(f"\n宫位图:")
print(calculator.generate_house_chart_ascii(varga_data['house_chart']))
+202
View File
@@ -0,0 +1,202 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Karaka Calculator - Jaimini Chara Karaka System
印度占星 Karaka(象征星)计算器
支持两种模式:
1. BPHS标准模式(8-Karaka):Sun > Moon > Mars > Mercury > Jupiter > Venus > Saturn > Rahu
2. Jagannatha Hora兼容模式(7-Karaka + Rahu限制):Rahu只能是Matrukaraka(MK)
核心功能:
- 计算7大Chara Karaka(可变象征星)
- 支持8-Karaka系统(包含Rahu)
- 自动识别Karaka模式
- 提供详细的度数排序和Karaka分配
"""
import sys
from typing import Dict, List, Tuple, Optional
from enum import Enum
class KarakaMode(Enum):
"""Karaka计算模式"""
BPHS_8_KARAKA = "bphs" # 标准BPHS 8-Karaka系统
JH_COMPATIBLE = "jh" # Jagannatha Hora兼容模式(Rahu限制在MK)
BPHS_7_KARAKA = "bphs7" # 标准BPHS 7-Karaka系统(不含Rahu)
class KarakaType(Enum):
"""7大Chara Karaka类型"""
ATMAKARAKA = "AK" # 灵魂象征星(最高度数)
AMATYAKARAKA = "AmK" # 事业象征星(第二高)
BHRATRUKARAKA = "BK" # 兄弟象征星(第三高)
MATRUKARAKA = "MK" # 母亲象征星(第四高)
PUTRAKARAKA = "PK" # 子女象征星(第五高)
GNATIKARAKA = "GK" # 敌人/疾病象征星(第六高)
DARAKARAKA = "DK" # 配偶象征星(最低度数)
EXTRA_KARAKA = "XK" # 额外象征星(仅在8-Karaka系统中)
class KarakaCalculator:
"""Karaka计算器"""
SEVEN_PLANETS = ["Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn"]
EIGHT_PLANETS = ["Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn", "Rahu"]
def __init__(self, mode: KarakaMode = KarakaMode.BPHS_8_KARAKA):
self.mode = mode
def calculate_karaka(self, planet_positions: Dict[str, float]) -> Dict[str, any]:
"""
计算Chara Karaka
Args:
planet_positions: 行星位置字典 {行星名: 黄道度数}
Returns:
Karaka分配结果字典
"""
result = {
"mode": self.mode.value,
"karakas": {},
"sorted_planets": [],
"warnings": []
}
# 1. 提取有效行星
valid_planets = self._extract_valid_planets(planet_positions, result)
if not valid_planets:
result["warnings"].append("No valid planets found")
return result
# 2. 转换为星座内度数(0-30度)
sign_degrees = {p: d % 30.0 for p, d in valid_planets.items()}
# 3. 按度数排序(降序)
sorted_planets = sorted(sign_degrees.items(), key=lambda x: x[1], reverse=True)
result["sorted_planets"] = [(p, round(d, 4)) for p, d in sorted_planets]
# 4. 分配Karaka
result["karakas"] = self._assign_karakas(sorted_planets, result)
# 5. 验证
self._validate_karakas(result)
return result
def _extract_valid_planets(self, positions: Dict[str, float], result: Dict) -> Dict[str, float]:
"""提取有效行星"""
valid = {}
planets = self.SEVEN_PLANETS if self.mode == KarakaMode.BPHS_7_KARAKA else self.EIGHT_PLANETS
for planet in planets:
if planet in positions:
valid[planet] = positions[planet]
else:
result["warnings"].append(f"Missing planet: {planet}")
return valid
def _assign_karakas(self, sorted_planets: List[Tuple[str, float]], result: Dict) -> Dict:
"""分配Karaka"""
karakas = {}
if self.mode == KarakaMode.JH_COMPATIBLE:
# JH模式:强制Rahu为MK
rahu_idx = next((i for i, (p, _) in enumerate(sorted_planets) if p == "Rahu"), None)
if rahu_idx is not None and rahu_idx != 3:
result["warnings"].append(f"JH Mode: Rahu forced to MK (was rank {rahu_idx + 1})")
adjusted = [p for p in sorted_planets if p[0] != "Rahu"]
adjusted.insert(3, sorted_planets[rahu_idx])
sorted_planets = adjusted
# 分配Karaka
karaka_types = [
("AK", "灵魂象征星"),
("AmK", "事业象征星"),
("BK", "兄弟象征星"),
("MK", "母亲象征星"),
("PK", "子女象征星"),
("GK", "敌人/疾病象征星"),
]
if self.mode == KarakaMode.BPHS_8_KARAKA:
karaka_types.append(("XK", "额外象征星"))
karaka_types.append(("DK", "配偶象征星"))
for i, (planet, degree) in enumerate(sorted_planets[:len(karaka_types)]):
code, name = karaka_types[i]
karakas[code] = {
"planet": planet,
"sign_degree": round(degree, 4),
"name": name,
"rank": i + 1
}
return karakas
def _validate_karakas(self, result: Dict):
"""验证Karaka分配"""
expected = 7 if self.mode != KarakaMode.BPHS_8_KARAKA else 8
if len(result["karakas"]) != expected:
result["warnings"].append(f"Expected {expected} Karakas, got {len(result['karakas'])}")
def format_output(self, result: Dict) -> str:
"""格式化输出"""
lines = ["=" * 60, "Chara Karaka Calculation", "=" * 60]
lines.append(f"Mode: {result['mode'].upper()}\n")
lines.append("Karaka Assignment:")
for code, data in result['karakas'].items():
lines.append(f" {code:4s} = {data['planet']:10s} ({data['sign_degree']:6.2f}°) - {data['name']}")
if result['warnings']:
lines.append("\nWarnings:")
for w in result['warnings']:
lines.append(f" ⚠️ {w}")
lines.append("=" * 60)
return "\n".join(lines)
def main():
"""命令行接口"""
import argparse
parser = argparse.ArgumentParser(description="Calculate Jaimini Chara Karaka")
parser.add_argument("--mode", choices=["bphs", "jh", "bphs7"], default="bphs")
parser.add_argument("--planets", type=str, help="Format: Sun:45.5,Moon:120.3,...")
parser.add_argument("--json", action="store_true")
args = parser.parse_args()
# 解析行星位置
if args.planets:
positions = {}
for pair in args.planets.split(","):
planet, degree = pair.split(":")
positions[planet.strip()] = float(degree.strip())
else:
# 示例数据
positions = {
"Sun": 45.5, "Moon": 120.3, "Mars": 200.1,
"Mercury": 50.8, "Jupiter": 180.5, "Venus": 90.2,
"Saturn": 250.7, "Rahu": 150.4
}
print("Using example data\n")
# 计算
mode_map = {"bphs": KarakaMode.BPHS_8_KARAKA, "jh": KarakaMode.JH_COMPATIBLE, "bphs7": KarakaMode.BPHS_7_KARAKA}
calc = KarakaCalculator(mode=mode_map[args.mode])
result = calc.calculate_karaka(positions)
# 输出
if args.json:
import json
print(json.dumps(result, indent=2, ensure_ascii=False))
else:
print(calc.format_output(result))
if __name__ == "__main__":
main()
+315
View File
@@ -0,0 +1,315 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Special Lagnas Calculator - 特殊上升点计算器
印度占星特殊上升点(Bhava/Hora/Ghati/Arudha/Upapada Lagna)
核心功能:
- Bhava Lagna(宫位上升):反映物质层面的实际状况
- Hora Lagna(时辰上升):财富和物质收益的指示器
- Ghati Lagna(Ghati上升):基于Ghati单位的精确上升点
- Arudha Lagna(映像上升):公众形象和社会地位
- Upapada Lagna(配偶映像上升):配偶和婚姻的公众形象
"""
from typing import Dict, Tuple
from datetime import datetime, timedelta
class SpecialLagnasCalculator:
"""特殊上升点计算器"""
SIGNS = ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
"Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"]
def __init__(self):
pass
def calculate_all_lagnas(self, asc_degree: float, sun_degree: float,
moon_degree: float, birth_time: datetime,
sunrise_time: datetime) -> Dict[str, Dict]:
"""
计算所有特殊上升点
Args:
asc_degree: 上升点度数(0-360)
sun_degree: 太阳度数(0-360)
moon_degree: 月亮度数(0-360)
birth_time: 出生时间
sunrise_time: 当天日出时间
Returns:
所有特殊上升点的字典
"""
result = {}
# 1. Bhava Lagna
result["Bhava_Lagna"] = self.calculate_bhava_lagna(asc_degree, sun_degree, moon_degree)
# 2. Hora Lagna
result["Hora_Lagna"] = self.calculate_hora_lagna(asc_degree, sun_degree, birth_time, sunrise_time)
# 3. Ghati Lagna
result["Ghati_Lagna"] = self.calculate_ghati_lagna(asc_degree, birth_time, sunrise_time)
# 4. Arudha Lagna (需要1宫主星位置)
# 注意:这里需要额外的行星位置信息,暂时返回占位符
result["Arudha_Lagna"] = {"note": "Requires 1st house lord position"}
# 5. Upapada Lagna (需要12宫主星位置)
result["Upapada_Lagna"] = {"note": "Requires 12th house lord position"}
return result
def calculate_bhava_lagna(self, asc_degree: float, sun_degree: float,
moon_degree: float) -> Dict:
"""
计算Bhava Lagna(宫位上升)
公式:Bhava Lagna = Asc + (Sun - Moon)
含义:
- 反映物质层面的实际状况
- 显示真实的生活环境和物质条件
- 与上升点的差异揭示表象与实质的差距
"""
# 计算太阳-月亮的度数差
sun_moon_diff = sun_degree - moon_degree
# 如果差值为负,加360度
if sun_moon_diff < 0:
sun_moon_diff += 360
# 计算Bhava Lagna
bhava_lagna = (asc_degree + sun_moon_diff) % 360
# 转换为星座和度数
sign_index = int(bhava_lagna // 30)
sign_degree = bhava_lagna % 30
return {
"degree": round(bhava_lagna, 4),
"sign": self.SIGNS[sign_index],
"sign_degree": round(sign_degree, 4),
"formula": "Asc + (Sun - Moon)",
"meaning": "物质层面的实际状况,真实的生活环境"
}
def calculate_hora_lagna(self, asc_degree: float, sun_degree: float,
birth_time: datetime, sunrise_time: datetime) -> Dict:
"""
计算Hora Lagna(时辰上升)
公式:Hora Lagna = Asc + (出生时间距日出的Hora数 × 15度)
含义:
- 财富和物质收益的指示器
- 显示金钱来源和财富积累方式
- 与2宫(财富宫)密切相关
"""
# 计算出生时间距日出的小时数
time_diff = birth_time - sunrise_time
hours_from_sunrise = time_diff.total_seconds() / 3600
# 计算Hora数(每个Hora = 1小时)
hora_count = hours_from_sunrise
# 计算Hora Lagna(每个Hora推进15度)
hora_lagna = (asc_degree + (hora_count * 15)) % 360
# 转换为星座和度数
sign_index = int(hora_lagna // 30)
sign_degree = hora_lagna % 30
return {
"degree": round(hora_lagna, 4),
"sign": self.SIGNS[sign_index],
"sign_degree": round(sign_degree, 4),
"hours_from_sunrise": round(hours_from_sunrise, 2),
"formula": "Asc + (Hora数 × 15°)",
"meaning": "财富和物质收益的指示器"
}
def calculate_ghati_lagna(self, asc_degree: float, birth_time: datetime,
sunrise_time: datetime) -> Dict:
"""
计算Ghati Lagna(Ghati上升)
公式:Ghati Lagna = Asc + (Ghati数 × 6度)
Ghati单位:
- 1 Ghati = 24分钟
- 1天 = 60 Ghati
- 每个Ghati推进6度(360度 / 60 Ghati = 6度)
含义:
- 基于Ghati单位的精确上升点
- 用于精确的时间矫正和事件预测
- 在Prashna(问事占星)中特别重要
"""
# 计算出生时间距日出的分钟数
time_diff = birth_time - sunrise_time
minutes_from_sunrise = time_diff.total_seconds() / 60
# 计算Ghati数(1 Ghati = 24分钟)
ghati_count = minutes_from_sunrise / 24
# 计算Ghati Lagna(每个Ghati推进6度)
ghati_lagna = (asc_degree + (ghati_count * 6)) % 360
# 转换为星座和度数
sign_index = int(ghati_lagna // 30)
sign_degree = ghati_lagna % 30
return {
"degree": round(ghati_lagna, 4),
"sign": self.SIGNS[sign_index],
"sign_degree": round(sign_degree, 4),
"ghati_count": round(ghati_count, 2),
"formula": "Asc + (Ghati数 × 6°)",
"meaning": "基于Ghati单位的精确上升点,用于精确预测"
}
def calculate_arudha_lagna(self, asc_degree: float, first_lord_degree: float) -> Dict:
"""
计算Arudha Lagna(映像上升/AL)
公式:
1. 计算1宫主星距离上升点的宫位数(A)
2. 从1宫主星再数A个宫位,得到AL
3. 特殊规则:如果AL落在1宫或7宫,则从该位置再数10个宫位
含义:
- 公众形象和社会地位
- 他人如何看待你
- 外在表现与内在本质的差异
"""
# 计算上升点和1宫主星的星座
asc_sign = int(asc_degree // 30)
lord_sign = int(first_lord_degree // 30)
# 计算1宫主星距离上升点的宫位数
distance = (lord_sign - asc_sign) % 12
if distance == 0:
distance = 12
# 从1宫主星再数相同的宫位数
al_sign = (lord_sign + distance - 1) % 12
# 应用1/7宫例外规则
if al_sign == asc_sign or al_sign == (asc_sign + 6) % 12:
al_sign = (al_sign + 9) % 12 # 再数10个宫位(索引+9)
# 计算AL的度数(使用1宫主星的度数)
al_degree = (al_sign * 30 + (first_lord_degree % 30)) % 360
return {
"degree": round(al_degree, 4),
"sign": self.SIGNS[al_sign],
"sign_degree": round(al_degree % 30, 4),
"distance_from_asc": distance,
"formula": "从1宫主星数相同宫位数(1/7宫例外)",
"meaning": "公众形象和社会地位,他人如何看待你"
}
def calculate_upapada_lagna(self, asc_degree: float, twelfth_lord_degree: float) -> Dict:
"""
计算Upapada Lagna(配偶映像上升/UL)
公式:
1. 计算12宫主星距离12宫的宫位数(A)
2. 从12宫主星再数A个宫位,得到UL
3. 特殊规则:如果UL落在12宫或6宫,则从该位置再数10个宫位
含义:
- 配偶的公众形象
- 婚姻在社会中的表现
- 配偶的社会地位和声誉
"""
# 计算12宫的起始度数
asc_sign = int(asc_degree // 30)
twelfth_house_sign = (asc_sign + 11) % 12
# 计算12宫主星的星座
lord_sign = int(twelfth_lord_degree // 30)
# 计算12宫主星距离12宫的宫位数
distance = (lord_sign - twelfth_house_sign) % 12
if distance == 0:
distance = 12
# 从12宫主星再数相同的宫位数
ul_sign = (lord_sign + distance - 1) % 12
# 应用12/6宫例外规则
if ul_sign == twelfth_house_sign or ul_sign == (twelfth_house_sign + 6) % 12:
ul_sign = (ul_sign + 9) % 12 # 再数10个宫位
# 计算UL的度数
ul_degree = (ul_sign * 30 + (twelfth_lord_degree % 30)) % 360
return {
"degree": round(ul_degree, 4),
"sign": self.SIGNS[ul_sign],
"sign_degree": round(ul_degree % 30, 4),
"distance_from_12th": distance,
"formula": "从12宫主星数相同宫位数(12/6宫例外)",
"meaning": "配偶的公众形象和婚姻的社会表现"
}
def format_output(self, lagnas: Dict) -> str:
"""格式化输出所有特殊上升点"""
lines = ["=" * 60, "Special Lagnas Calculation", "=" * 60, ""]
for lagna_name, data in lagnas.items():
lines.append(f"{lagna_name}:")
if "note" in data:
lines.append(f" {data['note']}")
else:
lines.append(f" Position: {data['sign']} {data['sign_degree']:.2f}° ({data['degree']:.2f}°)")
lines.append(f" Formula: {data['formula']}")
lines.append(f" Meaning: {data['meaning']}")
lines.append("")
lines.append("=" * 60)
return "\n".join(lines)
def main():
"""命令行接口"""
import argparse
from datetime import datetime
parser = argparse.ArgumentParser(description="Calculate Special Lagnas")
parser.add_argument("--asc", type=float, required=True, help="Ascendant degree (0-360)")
parser.add_argument("--sun", type=float, required=True, help="Sun degree (0-360)")
parser.add_argument("--moon", type=float, required=True, help="Moon degree (0-360)")
parser.add_argument("--birth-time", type=str, help="Birth time (YYYY-MM-DD HH:MM:SS)")
parser.add_argument("--sunrise-time", type=str, help="Sunrise time (YYYY-MM-DD HH:MM:SS)")
parser.add_argument("--first-lord", type=float, help="1st house lord degree (for AL)")
parser.add_argument("--twelfth-lord", type=float, help="12th house lord degree (for UL)")
args = parser.parse_args()
calc = SpecialLagnasCalculator()
# 解析时间
birth_time = datetime.strptime(args.birth_time, "%Y-%m-%d %H:%M:%S") if args.birth_time else datetime.now()
sunrise_time = datetime.strptime(args.sunrise_time, "%Y-%m-%d %H:%M:%S") if args.sunrise_time else birth_time.replace(hour=6, minute=0, second=0)
# 计算所有特殊上升点
lagnas = calc.calculate_all_lagnas(args.asc, args.sun, args.moon, birth_time, sunrise_time)
# 如果提供了1宫主星位置,计算AL
if args.first_lord is not None:
lagnas["Arudha_Lagna"] = calc.calculate_arudha_lagna(args.asc, args.first_lord)
# 如果提供了12宫主星位置,计算UL
if args.twelfth_lord is not None:
lagnas["Upapada_Lagna"] = calc.calculate_upapada_lagna(args.asc, args.twelfth_lord)
# 输出结果
print(calc.format_output(lagnas))
if __name__ == "__main__":
main()
+306
View File
@@ -0,0 +1,306 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Vimsopaka Bala Calculator - 分盘综合力量计算器
印度占星 Vimsopaka Bala(20分力量)系统
核心功能:
- 计算16种分盘(Shodasavarga)的行星尊严
- 根据BPHS权重系统计算Vimsopaka Bala
- 提供行星在各分盘的综合力量评分
- 支持Dasa Varga(10分盘)和Shodasavarga(16分盘)两种模式
参考文献:
- Brihat Parashara Hora Shastra (BPHS) Chapter 7
- B.V. Raman - "A Manual of Hindu Astrology"
"""
from typing import Dict, List, Tuple
from enum import Enum
class VargaType(Enum):
"""分盘类型"""
D1 = "Rashi" # 本命盘
D2 = "Hora" # 财富
D3 = "Drekkana" # 兄弟姐妹
D4 = "Chaturthamsa" # 财产/运气
D7 = "Saptamsa" # 子女
D9 = "Navamsa" # 配偶/灵性
D10 = "Dasamsa" # 事业
D12 = "Dwadasamsa" # 父母
D16 = "Shodasamsa" # 交通工具
D20 = "Vimsamsa" # 灵性修行
D24 = "Chaturvimsamsa" # 教育/学习
D27 = "Bhamsa" # 力量/弱点
D30 = "Trimsamsa" # 不幸/困难
D40 = "Khavedamsa" # 吉凶效果
D45 = "Akshavedamsa" # 全面判断
D60 = "Shashtiamsa" # 前世业力
class DignityLevel(Enum):
"""行星尊严等级"""
EXALTED = "Exalted" # 入庙(最高)
MOOLATRIKONA = "Moolatrikona" # 根本三角
OWN_SIGN = "Own Sign" # 自己的星座
FRIEND = "Friend" # 友好星座
NEUTRAL = "Neutral" # 中性星座
ENEMY = "Enemy" # 敌对星座
DEBILITATED = "Debilitated" # 落陷(最低)
class VimsopakaBalaCalculator:
"""Vimsopaka Bala计算器"""
# BPHS标准权重系统(Shodasavarga - 16分盘)
SHODASAVARGA_WEIGHTS = {
VargaType.D1: 3.5, # Rashi
VargaType.D2: 1.0, # Hora
VargaType.D3: 1.0, # Drekkana
VargaType.D4: 0.5, # Chaturthamsa
VargaType.D7: 0.5, # Saptamsa
VargaType.D9: 3.5, # Navamsa
VargaType.D10: 0.5, # Dasamsa
VargaType.D12: 0.5, # Dwadasamsa
VargaType.D16: 2.0, # Shodasamsa
VargaType.D20: 0.5, # Vimsamsa
VargaType.D24: 0.5, # Chaturvimsamsa
VargaType.D27: 0.5, # Bhamsa
VargaType.D30: 1.0, # Trimsamsa
VargaType.D40: 0.5, # Khavedamsa
VargaType.D45: 0.5, # Akshavedamsa
VargaType.D60: 4.0 # Shashtiamsa
}
# Dasa Varga权重系统(10分盘 - 简化版)
DASAVARGA_WEIGHTS = {
VargaType.D1: 3.0,
VargaType.D2: 1.5,
VargaType.D3: 1.5,
VargaType.D7: 1.5,
VargaType.D9: 3.0,
VargaType.D10: 1.5,
VargaType.D12: 1.5,
VargaType.D16: 1.5,
VargaType.D30: 1.5,
VargaType.D60: 5.0
}
# 尊严等级对应的Virupas(力量单位)
DIGNITY_VIRUPAS = {
DignityLevel.EXALTED: 20.0,
DignityLevel.MOOLATRIKONA: 18.0,
DignityLevel.OWN_SIGN: 15.0,
DignityLevel.FRIEND: 10.0,
DignityLevel.NEUTRAL: 7.5,
DignityLevel.ENEMY: 5.0,
DignityLevel.DEBILITATED: 2.0
}
# 力量等级分类(基于总分)
STRENGTH_CATEGORIES = {
"Parijatamsa": (18.0, 20.0), # 极强(18-20)
"Uttamamsa": (16.0, 18.0), # 优秀(16-18)
"Gopuramsa": (12.0, 16.0), # 良好(12-16)
"Simhasanamsa": (10.0, 12.0), # 中等偏上(10-12)
"Paravatamsa": (8.0, 10.0), # 中等(8-10)
"Devalokamsa": (6.0, 8.0), # 中等偏下(6-8)
"Brahmalokamsa": (4.0, 6.0), # 较弱(4-6)
"Airavata": (2.0, 4.0), # 弱(2-4)
"Vaiseshikamsa": (0.0, 2.0) # 极弱(0-2)
}
def __init__(self, mode: str = "shodasavarga"):
"""
初始化计算器
Args:
mode: "shodasavarga" (16分盘) 或 "dasavarga" (10分盘)
"""
self.mode = mode
self.weights = self.SHODASAVARGA_WEIGHTS if mode == "shodasavarga" else self.DASAVARGA_WEIGHTS
def calculate_vimsopaka_bala(self, planet_vargas: Dict[str, Dict[VargaType, DignityLevel]]) -> Dict[str, Dict]:
"""
计算所有行星的Vimsopaka Bala
Args:
planet_vargas: {行星名: {分盘类型: 尊严等级}}
Returns:
{行星名: {
"total_score": 总分,
"category": 力量等级,
"varga_scores": {分盘: 得分},
"interpretation": 解读
}}
"""
results = {}
for planet, vargas in planet_vargas.items():
planet_result = self._calculate_planet_vimsopaka(planet, vargas)
results[planet] = planet_result
return results
def _calculate_planet_vimsopaka(self, planet: str, vargas: Dict[VargaType, DignityLevel]) -> Dict:
"""计算单个行星的Vimsopaka Bala"""
varga_scores = {}
total_weighted_score = 0.0
total_weight = 0.0
# 计算每个分盘的得分
for varga_type, dignity in vargas.items():
if varga_type in self.weights:
# 获取尊严对应的Virupas
virupas = self.DIGNITY_VIRUPAS.get(dignity, 0.0)
# 获取分盘权重
weight = self.weights[varga_type]
# 计算加权得分
weighted_score = virupas * weight
varga_scores[varga_type.value] = {
"dignity": dignity.value,
"virupas": virupas,
"weight": weight,
"weighted_score": round(weighted_score, 2)
}
total_weighted_score += weighted_score
total_weight += weight
# 计算最终得分(归一化到20分制)
if total_weight > 0:
final_score = total_weighted_score / total_weight
else:
final_score = 0.0
# 确定力量等级
category = self._get_strength_category(final_score)
# 生成解读
interpretation = self._generate_interpretation(planet, final_score, category, varga_scores)
return {
"planet": planet,
"total_score": round(final_score, 2),
"category": category,
"varga_scores": varga_scores,
"interpretation": interpretation,
"mode": self.mode
}
def _get_strength_category(self, score: float) -> str:
"""根据得分确定力量等级"""
for category, (min_score, max_score) in self.STRENGTH_CATEGORIES.items():
if min_score <= score < max_score:
return category
return "Vaiseshikamsa" # 默认最低等级
def _generate_interpretation(self, planet: str, score: float, category: str, varga_scores: Dict) -> str:
"""生成解读文本"""
interpretation = f"{planet}的Vimsopaka Bala得分为{score:.2f}/20,属于{category}等级。\n\n"
# 根据等级给出解读
if score >= 16:
interpretation += "这是极强的行星力量,表示该行星在生活中能够充分发挥其积极作用,带来显著的成果和成功。"
elif score >= 12:
interpretation += "这是良好的行星力量,表示该行星能够有效发挥作用,在其主管领域带来正面影响。"
elif score >= 8:
interpretation += "这是中等的行星力量,表示该行星的作用较为平衡,既有积极面也有挑战。"
elif score >= 4:
interpretation += "这是较弱的行星力量,表示该行星在发挥作用时会遇到一些困难和阻碍。"
else:
interpretation += "这是极弱的行星力量,表示该行星难以充分发挥其作用,需要通过补救措施来增强。"
# 找出最强和最弱的分盘
if varga_scores:
sorted_vargas = sorted(varga_scores.items(), key=lambda x: x[1]['weighted_score'], reverse=True)
strongest = sorted_vargas[0]
weakest = sorted_vargas[-1]
interpretation += f"\n\n最强分盘:{strongest[0]}({strongest[1]['dignity']},得分{strongest[1]['weighted_score']})"
interpretation += f"\n最弱分盘:{weakest[0]}({weakest[1]['dignity']},得分{weakest[1]['weighted_score']})"
return interpretation
def compare_planets(self, results: Dict[str, Dict]) -> List[Tuple[str, float]]:
"""
比较所有行星的力量,返回排序列表
Args:
results: calculate_vimsopaka_bala的返回结果
Returns:
[(行星名, 得分), ...] 按得分降序排列
"""
planet_scores = [(planet, data["total_score"]) for planet, data in results.items()]
return sorted(planet_scores, key=lambda x: x[1], reverse=True)
def get_remedial_recommendations(self, planet: str, score: float) -> List[str]:
"""
根据Vimsopaka Bala得分提供补救建议
Args:
planet: 行星名
score: Vimsopaka Bala得分
Returns:
补救建议列表
"""
recommendations = []
if score < 8: # 力量较弱,需要补救
recommendations.append(f"建议佩戴{planet}对应的宝石来增强力量")
recommendations.append(f"在{planet}主管的日子进行布施(Daan)")
recommendations.append(f"念诵{planet}的咒语(Mantra)")
recommendations.append(f"在{planet}主管的时辰进行重要活动")
if score < 4: # 极弱,需要额外补救
recommendations.append(f"考虑进行{planet}的火祭仪式(Homa)")
recommendations.append(f"在{planet}主管的日子断食")
return recommendations
# 示例用法
if __name__ == "__main__":
# 创建计算器(使用16分盘模式)
calculator = VimsopakaBalaCalculator(mode="shodasavarga")
# 示例数据:太阳在各分盘的尊严
sun_vargas = {
VargaType.D1: DignityLevel.EXALTED,
VargaType.D2: DignityLevel.OWN_SIGN,
VargaType.D3: DignityLevel.FRIEND,
VargaType.D9: DignityLevel.MOOLATRIKONA,
VargaType.D10: DignityLevel.FRIEND,
VargaType.D12: DignityLevel.NEUTRAL,
VargaType.D16: DignityLevel.OWN_SIGN,
VargaType.D20: DignityLevel.FRIEND,
VargaType.D30: DignityLevel.ENEMY,
VargaType.D60: DignityLevel.EXALTED
}
# 计算所有行星的Vimsopaka Bala
planet_vargas = {
"Sun": sun_vargas
}
results = calculator.calculate_vimsopaka_bala(planet_vargas)
# 打印结果
for planet, data in results.items():
print(f"\n{'='*60}")
print(f"{planet} - Vimsopaka Bala分析")
print(f"{'='*60}")
print(f"总分:{data['total_score']}/20")
print(f"等级:{data['category']}")
print(f"\n{data['interpretation']}")
# 如果需要补救
remedies = calculator.get_remedial_recommendations(planet, data['total_score'])
if remedies:
print(f"\n补救建议:")
for i, remedy in enumerate(remedies, 1):
print(f"{i}. {remedy}")