divicast 0.1.1__py3-none-any.whl

divicast/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "0.1.1"
+
+from .sixline.divinatory_symbol import DivinatorySymbol
+
+__all__ = [
+    "DivinatorySymbol",
+    "__version__"
+]

divicast/base/symbol.py

@@ -0,0 +1,113 @@
+from enum import Enum
+from typing import Any, Iterator, List, Self, Type, TypeVar
+
+T = TypeVar("T", bound="ValuedMultiton")
+
+
+class ValuedMultiton(Enum):
+    """
+    一个功能丰富的枚举基类，旨在通过继承来使用。
+
+    它提供了多种方式来定义和访问枚举成员，每个成员都包含一个整数值和一个中文描述。
+
+    特性:
+    - 通过 `(整数, "中文名")` 的元组形式来定义成员。
+    - 实例可以通过名称、整数值或中文名进行检索。
+    - 提供了清晰的 `__str__` 和 `__repr__` 表示。
+    - 支持迭代、比较，并提供了 `next()` 方法用于循环遍历。
+    - 提供了 `all()` 和 `iterator_from()` 等便利的类方法。
+
+    """
+
+    def __init__(self, num: int, chinese_name: str | None = None):
+        if not isinstance(num, int) or not isinstance(chinese_name, str):
+            raise TypeError(
+                "Enum members must be defined as a tuple of (int, str).")
+        self.num = num
+        self.chinese_name = chinese_name
+
+    @classmethod
+    def _missing_(cls: Type[T], value: Any) -> T | None:
+        """
+        实现通过整数值查找实例，例如 `Color(1)`。
+        """
+        if isinstance(value, int):
+            for member in cls:
+                if member.num == value:
+                    return member
+        return None
+
+    @classmethod
+    def from_chinese_name(cls: Type[T], chinese_name: str) -> T:
+        """通过中文名查找枚举成员。"""
+        for member in cls:
+            if member.chinese_name == chinese_name:
+                return member
+        raise ValueError(
+            f"'{chinese_name}' is not a valid chinese_name for {cls.__name__}"
+        )
+
+    @classmethod
+    def all(cls: Type[T]) -> List[T]:
+        """以列表形式返回所有枚举成员，按定义顺序排列。"""
+        return list(cls)
+
+    def next(self, step: int = 1) -> Self:
+        """返回后`step`个枚举成员。如果是最后一个，则循环回到第一个。"""
+        members = self.all()
+        index = members.index(self)
+        return members[(index + step) % len(members)]
+
+    @classmethod
+    def iterator_from(cls: Type[T], start_member: T) -> Iterator[T]:
+        """创建一个从指定成员开始并循环一次的迭代器。"""
+        if not isinstance(start_member, cls):
+            raise TypeError(
+                f"start_member must be an instance of {cls.__name__}")
+
+        current = start_member
+        while True:
+            yield current
+            current = current.next()
+            if current == start_member:
+                break
+
+    def __str__(self) -> str:
+        """返回用户的友好字符串表示（中文名）。"""
+        return self.chinese_name
+
+    def __repr__(self) -> str:
+        """返回开发者的清晰、无歧义的表示。"""
+        return f"<{self.__class__.__name__}.{self.name}: {self.num} ('{self.chinese_name}')>"
+
+    def __eq__(self, other: Any) -> bool:
+        """
+        允许枚举成员与整数值进行比较。
+        例如 `Color.RED == 1`。
+        """
+        if isinstance(other, int):
+            return self.num == other
+        # 对于其他类型，使用 `enum.Enum` 的默认比较逻辑
+        return super().__eq__(other)
+
+    def __hash__(self) -> int:
+        """确保枚举成员是可哈希的，以便在字典键或集合中使用。"""
+        return hash(self.num)
+
+    # --- 序列化 ---
+
+    def to_dict(self) -> str:
+        """
+        返回一个简单的、可序列化的表示（成员名称）。
+        """
+        return self.name
+
+
+class BelongsTo:
+    """
+    继承此类以创建一个属于另一个类的类。
+    """
+
+    def belongs_to(self, _: type[T], map_name: str) -> T:
+        a = getattr(self, map_name)[self]
+        return a

divicast/entities/daemon.py

@@ -0,0 +1,21 @@
+from divicast.base.symbol import ValuedMultiton
+
+
+class Daemon(ValuedMultiton):
+    """
+    神煞
+    """
+
+    Tianyiguiren = (0, "天乙贵人")
+    Yima = (1, "驿马")
+    Taohua = (2, "桃花")
+    Wenchang = (3, "文昌")
+    Lushen = (4, "禄神")
+    Jiesha = (5, "劫煞")
+    Huagai = (6, "华盖")
+    Jiangxing = (7, "将星")
+    Tianxi = (8, "天喜")
+    Tianyi = (9, "天医")
+    Yangren = (10, "阳刃")
+    Zaisha = (11, "灾煞")
+    Mouxing = (12, "谋星")

divicast/entities/dizhi.py

@@ -0,0 +1,78 @@
+from __future__ import annotations  # 用于前向引用
+
+from typing import ClassVar, Dict, List
+
+from divicast.base.symbol import ValuedMultiton
+from divicast.entities.wuxing import *
+
+
+class Dizhi(BelongsToYinYang, BelongsToWuxing, ValuedMultiton):
+    """
+    地支
+    """
+
+    _WUXING_MAP: Dict['Dizhi', 'Wuxing']
+
+    Zi = (0, "子")
+    Chou = (1, "丑")
+    Yin = (2, "寅")
+    Mou = (3, "卯")
+    Chen = (4, "辰")
+    Si = (5, "巳")
+    Wu = (6, "午")
+    Wei = (7, "未")
+    Shen = (8, "申")
+    You = (9, "酉")
+    Xu = (10, "戌")
+    Hai = (11, "亥")
+
+    def is_chong(self, d: Dizhi) -> bool:
+        """判断地支相冲"""
+        return abs(self.num - d.num) == 6
+
+    def chong(self) -> Dizhi:
+        """返回相冲的地支"""
+        return Dizhi((self.num + 6) % 12)
+
+    def is_he(self, d: Dizhi) -> bool:
+        """判断地支相合"""
+        return (self.num + d.num) % 12 == 1
+
+    def he(self) -> Dizhi:
+        """返回相合的地支"""
+        return Dizhi((13 - self.num) % 12)
+
+    def belongs_to_yinyang(self) -> YinYang:
+        return YinYang((self.num+1) % 2)
+
+    def generate(self) -> List[Dizhi]:
+        r = []
+        w = self.belongs_to_wuxing().generate()
+        for d in self.all():
+            if d.belongs_to_wuxing() == w:
+                r.append(d)
+        return r
+
+    def restrain(self) -> List[Dizhi]:
+        r = []
+        w = self.belongs_to_wuxing().restrain()
+        for d in self.all():
+            if d.belongs_to_wuxing() == w:
+                r.append(d)
+        return r
+
+
+Dizhi._WUXING_MAP = {
+    Dizhi.Zi: Wuxing.Water,
+    Dizhi.Chou: Wuxing.Earth,
+    Dizhi.Yin: Wuxing.Wood,
+    Dizhi.Mou: Wuxing.Wood,
+    Dizhi.Chen: Wuxing.Earth,
+    Dizhi.Si: Wuxing.Fire,
+    Dizhi.Wu: Wuxing.Fire,
+    Dizhi.Wei: Wuxing.Earth,
+    Dizhi.Shen: Wuxing.Metal,
+    Dizhi.You: Wuxing.Metal,
+    Dizhi.Xu: Wuxing.Earth,
+    Dizhi.Hai: Wuxing.Water,
+}

divicast/entities/liushen.py

@@ -0,0 +1,14 @@
+from divicast.base.symbol import ValuedMultiton
+
+
+class Liushen(ValuedMultiton):
+    """
+    六神
+    """
+
+    QingLong = (0, "青龙")
+    ZhuQue = (1, "朱雀")
+    GouChen = (2, "勾陈")
+    TengShe = (3, "腾蛇")
+    BaiHu = (4, "白虎")
+    XuanWu = (5, "玄武")

divicast/entities/relative.py

@@ -0,0 +1,14 @@
+from divicast.base.symbol import ValuedMultiton
+from divicast.entities.wuxing import Wuxing
+
+
+class Relative(ValuedMultiton):
+    """
+    六亲
+    """
+
+    Brother = (0, "兄弟")
+    Descendant = (1, "子孙")
+    Parent = (2, "父母")
+    Governer = (3, "官鬼")
+    Wife = (4, "妻财")

divicast/entities/tiangan.py

@@ -0,0 +1,104 @@
+from __future__ import annotations  # 用于前向引用
+
+from typing import ClassVar, Dict, Self
+
+from divicast.base.symbol import ValuedMultiton
+from divicast.entities.wuxing import (BelongsToWuxing, BelongsToYinYang,
+                                      Wuxing, YinYang)
+
+
+class Shishen(ValuedMultiton):
+    """
+    十神
+    """
+
+    BiJian = (0, "比肩")
+    JieCai = (1, "劫财")
+    ShiShen = (2, "食神")
+    ShangGuan = (3, "伤官")
+    PianCai = (4, "偏财")
+    ZhengCai = (5, "正财")
+    QiSha = (6, "七杀")  # 也叫偏官
+    ZhengGuan = (7, "正官")
+    PianYin = (8, "偏印")  # 也叫枭神
+    ZhengYin = (9, "正印")
+
+
+class Tiangan(BelongsToWuxing, BelongsToYinYang, ValuedMultiton):
+    """
+    天干
+    """
+    _WUXING_MAP: ClassVar[Dict[Tiangan, Wuxing]]
+
+    Jia = (0, "甲")
+    Yi = (1, "乙")
+    Bing = (2, "丙")
+    Ding = (3, "丁")
+    Wu = (4, "戊")
+    Ji = (5, "己")
+    Geng = (6, "庚")
+    Xin = (7, "辛")
+    Ren = (8, "壬")
+    Gui = (9, "癸")
+
+    def belongs_to_yinyang(self) -> YinYang:
+        """
+        获取天干所属的阴阳
+        """
+        return YinYang((self.num+1) % 2)
+
+    def get_shishen(self, other: Self) -> Shishen:
+        """
+        获取对应的十神
+        """
+        if self.belongs_to_wuxing() == other.belongs_to_wuxing():
+            # 同五行
+            return (
+                Shishen.BiJian
+                if self.belongs_to_yinyang() == other.belongs_to_yinyang()
+                else Shishen.JieCai  # type: ignore
+            )
+        elif self.belongs_to_wuxing().generate() == other.belongs_to_wuxing():
+            # 我生对方
+            return (
+                Shishen.ShiShen
+                if self.belongs_to_yinyang() == other.belongs_to_yinyang()
+                else Shishen.ShangGuan  # type: ignore
+            )
+        elif self.belongs_to_wuxing().restrain() == other.belongs_to_wuxing():
+            # 我克对方
+            return (
+                Shishen.PianCai
+                if self.belongs_to_yinyang() == other.belongs_to_yinyang()
+                else Shishen.ZhengCai  # type: ignore
+            )
+        elif self.belongs_to_wuxing() == other.belongs_to_wuxing().restrain():
+            # 对方克我
+            return (
+                Shishen.QiSha
+                if self.belongs_to_yinyang() == other.belongs_to_yinyang()
+                else Shishen.ZhengGuan  # type: ignore
+            )
+        elif self.belongs_to_wuxing() == other.belongs_to_wuxing().generate():
+            # 对方生我
+            return (
+                Shishen.PianYin
+                if self.belongs_to_yinyang() == other.belongs_to_yinyang()
+                else Shishen.ZhengYin  # type: ignore
+            )
+        else:
+            raise ValueError("无法计算对应的十神关系")
+
+
+Tiangan._WUXING_MAP = {
+    Tiangan.Jia: Wuxing.Wood,
+    Tiangan.Yi: Wuxing.Wood,
+    Tiangan.Bing: Wuxing.Fire,
+    Tiangan.Ding: Wuxing.Fire,
+    Tiangan.Wu: Wuxing.Earth,
+    Tiangan.Ji: Wuxing.Earth,
+    Tiangan.Geng: Wuxing.Metal,
+    Tiangan.Xin: Wuxing.Metal,
+    Tiangan.Ren: Wuxing.Water,
+    Tiangan.Gui: Wuxing.Water,
+}

divicast/entities/trigram.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from typing import ClassVar, Dict, List
+
+from divicast.base.symbol import ValuedMultiton
+from divicast.entities.wuxing import *
+from divicast.entities.wuxing import Wuxing
+
+
+class Line(ValuedMultiton):
+    """
+    爻
+    """
+
+    YinYao = (0, "⚋")
+    YangYao = (1, "⚊")
+
+
+class Trigram(BelongsToWuxing, ValuedMultiton):
+    """
+    八卦
+    """
+    _WUXING_MAP: ClassVar[Dict[Trigram, Wuxing]]
+    _PRIMARY_IMAGE_MAP: ClassVar[Dict[Trigram, str]]
+    lines: List[Line]
+
+    Kun = (0, "坤")
+    Zhen = (1, "震")
+    Kan = (2, "坎")
+    Dui = (3, "兑")
+    Gen = (4, "艮")
+    Li = (5, "离")
+    Xun = (6, "巽")
+    Qian = (7, "乾")
+
+    def __init__(self, num: int, chinese_name: str | None = None):
+        """
+        :param num: 0-7
+        :param name: 可选, 如果不提供则使用类名
+        :param chinese_name: 可选, 如果不提供则使用类名
+        """
+        ValuedMultiton.__init__(self, num, chinese_name)
+        self.lines = [Line((num >> 0) & 1), Line(
+            (num >> 1) & 1), Line((num >> 2) & 1)]
+
+    @property
+    def primary_image(self) -> str:
+        """
+        主象
+        """
+        return self._PRIMARY_IMAGE_MAP[self]
+
+
+Trigram._WUXING_MAP = {
+    Trigram.Qian: Wuxing.Metal,
+    Trigram.Dui: Wuxing.Metal,
+    Trigram.Kan: Wuxing.Water,
+    Trigram.Gen: Wuxing.Earth,
+    Trigram.Li: Wuxing.Fire,
+    Trigram.Xun: Wuxing.Wood,
+    Trigram.Zhen: Wuxing.Wood,
+    Trigram.Kun: Wuxing.Earth,
+}
+Trigram._PRIMARY_IMAGE_MAP = {
+    Trigram.Qian: '天',
+    Trigram.Dui: '泽',
+    Trigram.Kan: '水',
+    Trigram.Gen: '山',
+    Trigram.Li: '火',
+    Trigram.Xun: '风',
+    Trigram.Zhen: '雷',
+    Trigram.Kun: '地'
+}
+
+
+class Hexagram(ValuedMultiton):
+    """六十四卦"""
+
+    H63 = (63, "乾")
+    H0 = (0, "坤")
+    H17 = (17, "屯")
+    H34 = (34, "蒙")
+    H23 = (23, "需")
+    H58 = (58, "讼")
+    H2 = (2, "师")
+    H16 = (16, "比")
+    H55 = (55, "小畜")
+    H59 = (59, "履")
+    H7 = (7, "泰")
+    H56 = (56, "否")
+    H61 = (61, "同人")
+    H47 = (47, "大有")
+    H4 = (4, "谦")
+    H8 = (8, "豫")
+    H25 = (25, "随")
+    H38 = (38, "蛊")
+    H3 = (3, "临")
+    H48 = (48, "观")
+    H41 = (41, "噬嗑")
+    H37 = (37, "贲")
+    H32 = (32, "剥")
+    H1 = (1, "复")
+    H57 = (57, "无妄")
+    H39 = (39, "大畜")
+    H33 = (33, "颐")
+    H30 = (30, "大过")
+    H18 = (18, "坎")
+    H45 = (45, "离")
+    H28 = (28, "咸")
+    H14 = (14, "恒")
+    H60 = (60, "遁")
+    H15 = (15, "大壮")
+    H40 = (40, "晋")
+    H5 = (5, "明夷")
+    H53 = (53, "家人")
+    H43 = (43, "睽")
+    H20 = (20, "蹇")
+    H10 = (10, "解")
+    H35 = (35, "损")
+    H49 = (49, "益")
+    H31 = (31, "夬")
+    H62 = (62, "姤")
+    H24 = (24, "萃")
+    H6 = (6, "升")
+    H26 = (26, "困")
+    H22 = (22, "井")
+    H29 = (29, "革")
+    H46 = (46, "鼎")
+    H9 = (9, "震")
+    H36 = (36, "艮")
+    H52 = (52, "渐")
+    H11 = (11, "归妹")
+    H13 = (13, "丰")
+    H44 = (44, "旅")
+    H54 = (54, "巽")
+    H27 = (27, "兑")
+    H50 = (50, "涣")
+    H19 = (19, "节")
+    H51 = (51, "中孚")
+    H12 = (12, "小过")
+    H21 = (21, "既济")
+    H42 = (42, "未济")
+
+    def inside_trigram(self) -> Trigram:
+        return Trigram(self.num % 8)
+
+    def outside_trigram(self) -> Trigram:
+        return Trigram(self.num // 8)
+
+    def belongs_to_trigram(self) -> Trigram:
+        """
+        归宫
+        """
+
+        if self.belongs_to_trigram_seq() in [1, 2, 3, 6]:  # 一二三六外卦宫
+            return self.outside_trigram()
+        elif self.belongs_to_trigram_seq() in [4, 5, 7]:  # 四五游魂内变更
+            return Trigram(self.inside_trigram().num ^ 0b111)
+        elif self.belongs_to_trigram_seq() == 8:  # 归魂内卦是本宫
+            return self.inside_trigram()
+        else:
+            raise AssertionError("Unexpected belongs_to_trigram_seq")
+
+    def belongs_to_trigram_seq(self) -> int:
+        """
+        归宫的序号
+        CAVEAT: 这里的序号是从1开始的, 方便口诀计算
+        """
+
+        _0 = (self.num & 0b000001) ^ ((self.num & 0b001000) >> 3) == 0  # 地
+        _1 = (self.num & 0b000010) ^ ((self.num & 0b010000) >> 3) == 0  # 人
+        _2 = (self.num & 0b000100) ^ ((self.num & 0b100000) >> 3) == 0  # 天
+        seq = 0
+
+        if _2 and not _1 and not _0:  # 天同二世
+            seq = 2
+        elif not _2 and _1 and _0:  # 天变五
+            seq = 5
+        elif not _2 and not _1 and _0:  # 地同四世
+            seq = 4
+        elif _2 and _1 and not _0:  # 地变一
+            seq = 1
+        elif _2 and _1 and _0:  # 本宫六世
+            seq = 6
+        elif not _2 and not _1 and not _0:  # 三世异
+            seq = 3
+        elif not _2 and _1 and not _0:  # 人同游魂
+            seq = 7  # 游魂
+        elif _2 and not _1 and _0:  # 人变归
+            seq = 8  # 归魂
+        else:
+            raise ValueError("无法判断归宫的序号")
+        return seq

divicast/entities/wuxing.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from divicast.base.symbol import BelongsTo, ValuedMultiton
+
+
+class YinYang(ValuedMultiton):
+    """阴阳"""
+
+    Yin = (0, "阴")
+    Yang = (1, "阳")
+
+
+class BelongsToYinYang(BelongsTo):
+    """
+    实现了`BelongsTo`接口的类，表示属于某个阴阳
+    通过定义`_YINYANG_MAP`，可以自动返回所属阴阳
+    """
+
+    def belongs_to_yinyang(self) -> YinYang:
+        """
+        默认实现，通过定义`_YINYANG_MAP`，返回所属阴阳
+        """
+        return self.belongs_to(YinYang, "_YINYANG_MAP")
+
+
+class Wuxing(ValuedMultiton):
+    """五行"""
+
+    Wood = (0, "木")
+    Fire = (1, "火")
+    Earth = (2, "土")
+    Metal = (3, "金")
+    Water = (4, "水")
+
+    def restrain(self) -> Wuxing:
+        """
+        表示五行相克
+        """
+        return Wuxing((self.num + 2) % 5)
+
+    def generate(self) -> Wuxing:
+        """
+        表示五行相生
+        """
+        return Wuxing((self.num + 1) % 5)
+
+
+class BelongsToWuxing(BelongsTo):
+    """
+    这是一个协议，它定义了一个“可以转化为五行”的契约。
+    """
+
+    def belongs_to_wuxing(
+        self,
+    ) -> Wuxing:
+        return self.belongs_to(Wuxing, "_WUXING_MAP")