fix gangzhi again

Author: kentang2017

astro/beiji/calculator.py

@@ -114,10 +114,11 @@ def get_year_ganzhi(year: int) -> tuple[str, str]:
     """
     try:
         from sxtwl import fromSolar
-        # sxtwl 以農曆年干支為準；以1月1日對應年份取得大致干支
-        day = fromSolar(year, 6, 1)  # 取6月1日避免年初歲末邊界問題
-        stem = TIANGAN[day.getLunarYear(False).tg]
-        branch = DIZHI[day.getLunarYear(False).dz]
+        # 使用 getYearGZ(False) 以立春為準（與 bazi 等一致）
+        d = fromSolar(year, 6, 1)
+        ygz = d.getYearGZ(False)
+        stem = TIANGAN[ygz.tg]
+        branch = DIZHI[ygz.dz]
         return stem, branch
     except Exception:
         pass

astro/chinese/taixuan/taixuan_calculator.py

@@ -17,6 +17,12 @@
 from datetime import datetime, date
 from typing import Optional, Dict, List, Tuple
 
+try:
+    from sxtwl import fromSolar as _fromSolar
+    _HAS_SXTWL = True
+except Exception:
+    _HAS_SXTWL = False
+
 # ── 載入太玄字典 ────────────────────────────────────────────
 try:
     from taixuanshifa.taixuanshifa import qigua as _taixuan_qigua, qigua_number as _taixuan_qigua_number
@@ -151,30 +157,48 @@ def _hour_to_sishi(hour: int) -> str:
         return "夜中"
 
 
-def _ganzhi_year(year: int) -> Tuple[str, str]:
-    """計算某年的天干地支"""
+def _ganzhi_year(year: int, month: int = 7, day: int = 1) -> Tuple[str, str]:
+    """使用 sxtwl 計算年干支（立春分界）。"""
+    if _HAS_SXTWL:
+        try:
+            c = _fromSolar(year, month, day)
+            y = c.getYearGZ(False)
+            return TIANGAN[y.tg], DIZHI[y.dz]
+        except Exception:
+            pass
     tg_idx = (year - 4) % 10
     dz_idx = (year - 4) % 12
     return TIANGAN[tg_idx], DIZHI[dz_idx]
 
 
-def _ganzhi_month(year: int, month: int) -> Tuple[str, str]:
-    """計算農曆月的天干地支（簡化節氣法）"""
-    # 地支：寅月對應 calendar month 2，申月對應 calendar month 8，以此類推
-    dz_idx = month % 12
-    # 月干取決於年干；五虎遁年起月法：甲/己年起丙寅，乙/庚年起戊寅，以此類推
+def _ganzhi_month(year: int, month: int, day: int = 15) -> Tuple[str, str]:
+    """使用 sxtwl 計算月干支（節氣）。"""
+    if _HAS_SXTWL:
+        try:
+            c = _fromSolar(year, month, day)
+            m = c.getMonthGZ()
+            return TIANGAN[m.tg], DIZHI[m.dz]
+        except Exception:
+            pass
+    # fallback approx
+    dz_idx = (month + 1) % 12   # rough
     year_tg_idx = (year - 4) % 10
-    tg_base = ((year_tg_idx % 5) * 2 + 2) % 10  # 寅月干支起始天干
-    month_idx = (month - 2) % 12               # 距寅月的月數（0-based）
-    tg_idx = (tg_base + month_idx) % 10
+    tg_base = ((year_tg_idx % 5) * 2 + 2) % 10
+    tg_idx = (tg_base + (month - 2) % 12) % 10
     return TIANGAN[tg_idx], DIZHI[dz_idx]
 
 
 def _ganzhi_day(year: int, month: int, day: int) -> Tuple[str, str]:
-    """計算日柱天干地支"""
+    """使用 sxtwl 計算日干支。"""
+    if _HAS_SXTWL:
+        try:
+            c = _fromSolar(year, month, day)
+            d = c.getDayGZ()
+            return TIANGAN[d.tg], DIZHI[d.dz]
+        except Exception:
+            pass
+    # old jd fallback
     jd = _julian_day(year, month, day)
-    # _julian_day 回傳的儒略日以正午為起點，午夜值帶 .5 小數；
-    # 加 0.5 後取整可得整數儒略日（以午夜為基準）。
     idx = int(jd + 0.5) + 49
     tg_idx = idx % 10
     dz_idx = idx % 12
@@ -353,8 +377,8 @@ def _calc_natal(self) -> TaiXuanResult:
         # 7. 取首資料（含星宿度數）
         shou = self._build_shou(serial, sishi, zhan_idx, days_precise)
         # 8. 干支四柱
-        year_tg, year_dz = _ganzhi_year(self.year)
-        month_tg, month_dz = _ganzhi_month(self.year, self.month)
+        year_tg, year_dz = _ganzhi_year(self.year, self.month, self.day)
+        month_tg, month_dz = _ganzhi_month(self.year, self.month, self.day)
         day_tg, day_dz = _ganzhi_day(self.year, self.month, self.day)
         hour_tg, hour_dz = _ganzhi_hour(self.hour, day_tg)
         # 9. 行年大限（未來 81 年，每 4.5 年一首）
@@ -503,7 +527,7 @@ def _calc_annual_shous(self, natal_serial: int, birth_year: int) -> List[Dict]:
             if key and key in _TAIXUAN_DICT:
                 gua_dict = _TAIXUAN_DICT[key].get("卦", {})
                 gua_title = next(iter(gua_dict.keys()), "——")
-            year_tg, year_dz = _ganzhi_year(year)
+            year_tg, year_dz = _ganzhi_year(year, month, day)
             result.append({
                 "年份": year,
                 "年齡": offset,

astro/chinstar/chinstar.py

@@ -293,9 +293,14 @@ def hour_to_branch_idx(hour: int) -> int:
         """
         return ((hour + 1) // 2) % 12
 
-    def get_branch_idx(self, year: int) -> int:
-        """年支索引（子=0）"""
-        return (year - 4) % 12
+    def get_branch_idx(self, year: int, month: int = 7, day: int = 1) -> int:
+        """年支索引（子=0），優先 sxtwl。"""
+        try:
+            from sxtwl import fromSolar
+            c = fromSolar(year, month, day)
+            return c.getYearGZ(False).dz
+        except Exception:
+            return (year - 4) % 12
 
     def get_host_idx(self, qin: str) -> int:
         """取禽對應的宿序號（0-27）"""
@@ -346,7 +351,7 @@ def calc_tai_gong_idx(self, year: int, month: int, day: int, hour: int) -> int:
         Returns:
             胎宮地支索引 0=子 … 11=亥
         """
-        branch_idx = self.get_branch_idx(year)
+        branch_idx = self.get_branch_idx(year, month, day)
         pos = branch_idx
         pos = (pos + month - 1) % 12
         pos = (pos + day - 1) % 12

astro/nine_star_ki.py

@@ -26,6 +26,12 @@
 from datetime import date, datetime
 from typing import Optional
 
+try:
+    from sxtwl import fromSolar as _sxtwl_fromSolar
+    _HAS_SXTWL = True
+except Exception:
+    _HAS_SXTWL = False
+
 # ============================================================
 # 九星定義 (Nine Star Definitions)
 # ============================================================
@@ -191,22 +197,19 @@ def _fly_star_ccw(start: int, steps: int) -> int:
 # ============================================================
 
 def _li_chun_date(year: int) -> date:
-    """Approximate Li Chun (立春) date for *year*.
-
-    Li Chun falls on Feb 3, 4, or 5 each year. The exact date shifts
-    slightly due to the tropical year. This approximation uses a simple
-    formula that is accurate within ±1 day for 1901–2100.
-    """
-    # Standard approximation: Feb 4 or 5 depending on the year's position
-    # in the 4-year cycle (leap year offsets)
-    # More precise: JDE ≈ 2451623.80984 + 365.242189623 * (Y - 2000 + 0/12)
-    # For Li Chun (315° ecliptic lon), offset from Spring equinox ~ -44.7 days
-    # Simple empirical formula (accurate to ±1 day 1901-2100):
-    #   day = int(4.6295 + 0.2422 * (year - 1900) - int((year - 1900) / 4))
-    # But we clamp to [3, 5] and use Feb 4 as default fallback.
+    """Li Chun (立春) date. Uses sxtwl for precision when available."""
+    if _HAS_SXTWL:
+        try:
+            for dtry in range(3, 6):
+                dd = _sxtwl_fromSolar(year, 2, dtry)
+                if dd.hasJieQi() and dd.getJieQi() == 3:  # 立春
+                    return date(year, 2, dtry)
+            # If not exact match in scan, fall to sxtwl-based effective year logic later
+        except Exception:
+            pass
+    # Fallback approx (good enough)
     offset = 4.6295 + 0.2422 * (year - 1900) - (year - 1900) // 4
-    day = int(offset)
-    day = max(3, min(5, day))
+    day = max(3, min(5, int(offset)))
     return date(year, 2, day)
 
 
@@ -266,28 +269,35 @@ def compute_year_star(birth_date: date) -> int:
 
 
 def _solar_month_index(d: date) -> int:
-    """Return the solar month index (0–11) for date *d*.
+    """Return the solar month index (0–11) for date *d* using sxtwl when available.
 
-    Index 0 = 寅月 (starts ~Feb 4, Li Chun).
-    Index 11 = 丑月 (starts ~Jan 6).
+    Index 0 = 寅月 (立春), matches getMonthGZ().dz convention in project.
     """
-    # Try matching from month 11 (January) down to find the current 節
-    # We need to find which solar month the date falls in.
-    # Build a list of (date, index) for the current and surrounding years
+    if _HAS_SXTWL:
+        try:
+            c = _sxtwl_fromSolar(d.year, d.month, d.day)
+            mgz = c.getMonthGZ()
+            # dz: 0=子 ... but project solar month often 寅=2 mapped. 
+            # For nine star, the _YEAR... expects index aligned to their list.
+            # Their list _SOLAR_TERM_STARTS[0] = 寅 (Feb)
+            # sxtwl month branch: 寅 usually dz=2
+            # Map: common in bazi month_gz.dz 寅=2 -> our solar 0
+            dz = mgz.dz
+            # 寅=2 -> 0, 卯=3->1, ..., 丑=1 ->11
+            return (dz - 2) % 12
+        except Exception:
+            pass
+    # Fallback to old approx logic
     year = d.year
     boundaries = []
     for idx, (m, day) in enumerate(_SOLAR_TERM_STARTS):
         if m == 1:
-            # 丑月 starts in January — belongs to the current year's cycle
             boundaries.append((date(year, 1, day), idx))
         else:
             boundaries.append((date(year, m, day), idx))
-        # Also add previous year's December (子月) boundary
-    # Add next year January too
     boundaries.append((date(year + 1, 1, _SOLAR_TERM_STARTS[11][1]), 11))
-    # Sort and find the latest boundary ≤ d
     boundaries.sort()
-    result = 11  # default 丑月
+    result = 11
     for bd, idx in boundaries:
         if d >= bd:
             result = idx

astro/qizheng/qizheng_dasha.py

@@ -147,9 +147,15 @@ def compute_dasha(
             current_period_idx = idx
             break
 
-    # 計算流年 (flow year)：
-    # 流年地支 = 流年太歲地支 = (year - 4) % 12
-    flow_year_branch = (current_year - 4) % 12 if current_year else -1
+    # 計算流年 (flow year)：使用 sxtwl 精確年支
+    flow_year_branch = -1
+    if current_year:
+        try:
+            from sxtwl import fromSolar
+            c = fromSolar(current_year, 7, 1)
+            flow_year_branch = c.getYearGZ(False).dz
+        except Exception:
+            flow_year_branch = (current_year - 4) % 12
     flow_year_palace = ""
     if flow_year_branch >= 0:
         fh = branch_to_house.get(flow_year_branch)

astro/shaozi/calculator.py

@@ -18,6 +18,12 @@
 from datetime import datetime
 from typing import Dict, Optional, Tuple
 
+try:
+    from sxtwl import fromSolar as _fromSolar
+    _HAS_SXTWL = True
+except Exception:
+    _HAS_SXTWL = False
+
 from astro.shaozi.constants import (
     HEAVENLY_STEMS,
     EARTHLY_BRANCHES,
@@ -162,44 +168,55 @@ def count(self) -> int:
 # 干支計算工具
 # ============================================================================
 
-def _year_ganzhi(year: int) -> str:
-    """從西元年份計算年柱干支（以甲子 1984 為基準）"""
-    base = 1984  # 甲子年
+def _year_ganzhi(year: int, month: int = 7, day: int = 1) -> str:
+    """sxtwl 精確年柱（立春）。"""
+    if _HAS_SXTWL:
+        try:
+            c = _fromSolar(year, month, day)
+            y = c.getYearGZ(False)
+            return HEAVENLY_STEMS[y.tg] + EARTHLY_BRANCHES[y.dz]
+        except Exception:
+            pass
+    base = 1984
     stem_idx = (year - base) % 10
     branch_idx = (year - base) % 12
     return HEAVENLY_STEMS[stem_idx] + EARTHLY_BRANCHES[branch_idx]
 
 
-def _month_ganzhi(year: int, month: int) -> str:
-    """
-    計算月柱干支（簡化版，以節氣月份為準）
-    月支：寅(2月) 卯(3月) … 丑(1月)  index = month % 12
-    月干：由年干推算，甲己年從丙寅起
-    """
+def _month_ganzhi(year: int, month: int, day: int = 15) -> str:
+    """sxtwl 精確月柱。"""
+    if _HAS_SXTWL:
+        try:
+            c = _fromSolar(year, month, day)
+            m = c.getMonthGZ()
+            return HEAVENLY_STEMS[m.tg] + EARTHLY_BRANCHES[m.dz]
+        except Exception:
+            pass
     year_stem_idx = (year - 1984) % 10
-    # 月干循環：甲己年→丙寅起 (stem_base=2)；每年差2
     stem_base = ((year_stem_idx % 5) * 2 + 2) % 10
-    # 月支：二月(2) → 寅(2), 三月(3) → 卯(3), …, 八月(8) → 申(8), …, 一月(1) → 丑(1)
     month_branch_idx = month % 12
     month_stem_idx = (stem_base + month - 2) % 10
     return HEAVENLY_STEMS[month_stem_idx] + EARTHLY_BRANCHES[month_branch_idx]
 
 
 def _day_ganzhi(year: int, month: int, day: int) -> str:
-    """
-    計算日柱干支（Julian Day Number 法）
-    參考點：2000-01-01 (JD=2451545) = 戊午日
-    """
+    """sxtwl 精確日柱。"""
+    if _HAS_SXTWL:
+        try:
+            c = _fromSolar(year, month, day)
+            d = c.getDayGZ()
+            return HEAVENLY_STEMS[d.tg] + EARTHLY_BRANCHES[d.dz]
+        except Exception:
+            pass
     if month <= 2:
         year -= 1
         month += 12
     a = year // 100
     b = 2 - a + a // 4
     jd = int(365.25 * (year + 4716)) + int(30.6001 * (month + 1)) + day + b - 1524
-    # 2451545 = 2000-01-01 = 戊午：stem 戊(4), branch 午(6)
     ref_jd = 2451545
-    ref_stem = 4    # 戊
-    ref_branch = 6  # 午
+    ref_stem = 4
+    ref_branch = 6
     delta = jd - ref_jd
     stem_idx = (ref_stem + delta) % 10
     branch_idx = (ref_branch + delta) % 12
@@ -220,8 +237,8 @@ def _hour_ganzhi(day_stem: str, hour: int) -> str:
 
 def calculate_ganzhi_from_datetime(birth_dt: datetime) -> Dict[str, str]:
     """從西曆日期時間計算四柱干支"""
-    year_gz = _year_ganzhi(birth_dt.year)
-    month_gz = _month_ganzhi(birth_dt.year, birth_dt.month)
+    year_gz = _year_ganzhi(birth_dt.year, birth_dt.month, birth_dt.day)
+    month_gz = _month_ganzhi(birth_dt.year, birth_dt.month, birth_dt.day)
     day_gz = _day_ganzhi(birth_dt.year, birth_dt.month, birth_dt.day)
     hour_gz = _hour_ganzhi(day_gz[0], birth_dt.hour)
     return {