yixueServer/LocalModel.py

from enum import Enum
from typing import List

from pydantic import BaseModel

import Common


class SiZhuWeiZhi(Enum):
    extra = -1
    unknown = 0
    niangan = 1
    yuegan = 2
    rigan = 3
    shigan = 4
    nianzhi = 5
    yuezhi = 6
    rizhi = 7
    shizhi = 8
    nianzhu = 11
    yuezhu = 12
    rizhu = 13
    shizhu = 14
    liu_niangan = 21
    liu_yuegan = 22
    liu_rigan = 23
    liu_shigan = 24
    liu_nianzhi = 25
    liu_yuezhi = 26
    liu_rizhi = 27
    liu_shizhi = 28


class SiZhuInfoRequest(BaseModel):
    mode: int
    texts: List[str]
    datetime: str
    startDate: str
    location: str
    sheng: str
    shi: str
    qu: str
    weidu: float
    jingdu: float
    qiankun: str


class CustomLogin(BaseModel):
    user: str
    psd: str


class SaveUser(BaseModel):
    name: str
    beizhu: str
    isMan: bool
    leibie: int
    year: int
    month: int
    day: int
    hour: int
    minute: int
    sheng: str
    shi: str
    qu: str
    niangan: str
    nianzhi: str
    yuegan: str
    yuezhi: str
    rigan: str
    rizhi: str
    shigan: str
    shizhi: str
    customer: str

    def to_db_data(self):
        from datetime import datetime
        tm = datetime.now()
        return {
            "name": self.name,
            "beizhu": self.beizhu,
            "man": self.isMan,
            "leibie": self.leibie,
            "year": self.year,
            "month": self.month,
            "day": self.day,
            "hour": self.hour,
            "minute": self.minute,
            "sheng": self.sheng,
            "shi": self.shi,
            "qu": self.qu,
            "niangan": self.niangan,
            "nianzhi": self.nianzhi,
            "yuegan": self.yuegan,
            "yuezhi": self.yuezhi,
            "rigan": self.rigan,
            "rizhi": self.rizhi,
            "shigan": self.shigan,
            "shizhi": self.shizhi,
            "customer": self.customer,
            "joinTime": tm.strftime("%Y-%m-%d %H:%M:%S"),
            "enabled": 1,
        }


class QueryUser(BaseModel):
    customer: str
    filter: str


class DeleteUser(BaseModel):
    customer: str
    id: int


class LiuZhu():
    text: str
    weizhi: int
    shishen: str
    isTianGan: bool
    gan1: str
    gan2: str
    gan3: str
    gan1ShiShen: str
    gan2ShiShen: str
    gan3ShiShen: str


class ContentGaoNeng():
    arg1: str
    arg2: str
    arg3: str
    text: str
    zhu1: int
    zhu2: int
    zhu3: int
    key: str
    shishen1: str
    shishen2: str
    shishen3: str
    guanxi: str
    tip: str
    fangxiang: str
    fromCangGan: bool
    fromGongHe: bool
    fromXing: bool

    def __init__(self):
        self.fromCangGan = False
        self.fromGongHe = False
        self.fromXing = False


class ContentInfo():
    year: int
    month: int
    day: int
    riyuan: str
    text: str
    tip: str
    arg1: str
    arg2: str
    arg3: str
    shishen1: str
    shishen2: str
    shishen3: str
    guanxi: str
    times: int
    jiedu1: str
    jiedu2: str
    jiedu3: str
    jiedu4: str
    jiedu5: str
    fangxiang: str
    fromCangGan: bool
    fromGongHe: bool
    fromXing: bool

    def __init__(self):
        self.jiedu1 = None
        self.jiedu2 = None
        self.jiedu3 = None
        self.jiedu4 = None
        self.jiedu5 = None

    def to_db_data(self):
        return {
            "year": self.year,
            "month": self.month,
            "day": self.day,
            "riyuan": self.riyuan,
            "desc": self.shishen1 + self.shishen2 + self.guanxi,
            "tip": self.tip,
            "jiedu1": self.jiedu1,
            "jiedu2": self.jiedu2,
            "jiedu3": self.jiedu3,
            "jiedu4": self.jiedu4,
            "jiedu5": self.jiedu5,
        }


class GaoNeng():
    arg1: str
    arg2: str
    arg3: str
    guanxi: str
    text: str
    father: str
    leibie: str
    wuxing1: str
    wuxing2: str
    wuxing3: str
    shishen1: str
    shishen2: str
    shishen3: str
    power1: float
    power2: float
    power3: float
    extraPower1: float
    extraPower2: float
    extraPower3: float
    zhu1: int
    zhu2: int
    zhu3: int
    hehua: str
    fangxiang: str
    fangxiangTip: str
    key: str
    banheZengQiang: str
    banheZengQiangWuXing: str
    banheZengQiangShiShen: str
    banheZengQiangPower: int
    gongheZengQiang: str
    gongheZengQiangWuXing: str
    gongheZengQiangShiShen: str
    gongheZengQiangPower: int
    sanhuiZengQiang: str
    sanhuiZengQiangWuXing: str
    sanhuiZengQiangShiShen: str
    sanhuiZengQiangPower: int
    zixingZengQiang: str
    zixingZengQiangWuXing: str
    zixingZengQiangShiShen: str
    zixingZengQiangPower: int
    xingchu1: str
    xingchu2: str
    xingchu1WuXing: str
    xingchu2WuXing: str
    xingchu1ShiShen: str
    xingchu2ShiShen: str
    xingchu1Power: int
    xingchu2Power: int
    xingchong: str
    xingchongArg1: str
    xingchongArg2: str
    xingchongArg1ShiShen: str
    xingchongArg2ShiShen: str
    xingchongArg1Power: int
    xingchongArg2Power: int
    isFromCangGan: bool
    isFromGongHe: bool
    tip: str

    def __init__(self):
        self.isFromGongHe = False
        self.isFromCangGan = False
        self.extraPower1 = 0
        self.extraPower2 = 0
        self.extraPower3 = 0

    def copySelf(self):
        gn = GaoNeng()
        for key in dir(self):
            if not key.startswith("__"):
                value = getattr(self, key)
                if not callable(value):
                    setattr(gn, key, value)
        return gn


class MuKu():
    text: str
    lock: str
    isLock: bool
    chong: str
    gonghe: str
    zixing: str
    sanhui: str
    anhe: str
    hasChong: bool
    hasGongHe: bool
    hasZiXing: bool
    hasSanHui: bool
    hasAnHe: bool
    state: str
    isOpen: bool

    def __init__(self):
        self.isOpen = False


class Score():
    key: str
    he: int
    anHe: int
    chong: int
    chuan: int
    po: int
    total: int

    def __init__(self, key: str):
        self.key = key
        self.he = 0
        self.anHe = 0
        self.chong = 0
        self.chuan = 0
        self.po = 0
        self.total = 0

    def calcTotal(self):
        if self.he == 0:
            self.he = 1
        if self.anHe == 0:
            self.anHe = 1
        if self.chong == 0:
            self.chong = 1
        if self.chuan == 0:
            self.chuan = 1
        if self.po == 0:
            self.po = 1
        self.total = self.he * self.anHe * self.chong * self.chuan * self.po


class PingJia():
    mubiao: [Score]
    genji: [Score]
    zhuli: [Score]
    mubiaoScore: int
    genjiScore: int
    zhuliScore: int
    shouhuScore: int
    lushenScore: int
    totalScore: int

    def __init__(self):
        self.mubiao = []
        self.genji = []
        self.zhuli = []
        self.mubiaoScore = 0
        self.genjiScore = 0
        self.zhuliScore = 0
        self.shouhuScore = 0
        self.lushenScore = 0
        self.totalScore = 0

    def calc_scores(self):
        self.mubiaoScore = 0
        self.genjiScore = 0
        self.genjiScore = 0
        self.totalScore = 0
        for mb in self.mubiao:
            self.mubiaoScore += mb.total
        for gj in self.genji:
            self.genjiScore += gj.total
        for zl in self.zhuli:
            self.zhuliScore += zl.total
        self.totalScore = self.mubiaoScore + self.genjiScore + self.zhuliScore + self.shouhuScore + self.lushenScore


class SiZhu():
    qiankun: str
    text: str
    wuXing: str
    shiShen: str
    yinYang: str
    isTianGan: bool
    isLuShen: bool
    isBanLu: bool
    weiZhi: int
    cangGan1: str
    cangGan2: str
    cangGan3: str
    gan1WuXing: str
    gan2WuXing: str
    gan3WuXing: str
    gan1ShiShen: str
    gan2ShiShen: str
    gan3ShiShen: str
    tongzhuZhangSheng: str
    riyuanZhangSheng: str
    gaonengs: [GaoNeng]
    power: int  # 这个是总力量，用来冲、穿的时候使用
    selfPower: int  # 这个是单独自身的力量，用来计算半合三会等力量支援
    muku: MuKu
    # 天干地支共用
    muPower: int
    huoPower: int
    tuPower: int
    jinPower: int
    shuiPower: int
    # 墓库专用
    biKuMuPower: int
    biKuHuoPower: int
    biKuTuPower: int
    biKuJinPower: int
    biKuShuiPower: int
    kaiKuMuPower: int
    kaiKuHuoPower: int
    kaiKuTuPower: int
    kaiKuJinPower: int
    kaiKuShuiPower: int
    extraGaoNengMap: {}
    pingjia: PingJia

    def __init__(self, qiankun: str, isTianGan: bool, text: str, weizhi: SiZhuWeiZhi):
        self.qiankun = qiankun
        self.isTianGan = isTianGan
        self.isLuShen = False
        self.text = text
        self.weiZhi = weizhi.value
        self.selfPower = 0
        self.tuPower = 0
        self.huoPower = 0
        self.tuPower = 0
        self.jinPower = 0
        self.shuiPower = 0
        self.biKuMuPower = 0
        self.biKuHuoPower = 0
        self.biKuTuPower = 0
        self.biKuJinPower = 0
        self.biKuShuiPower = 0
        self.kaiKuMuPower = 0
        self.kaiKuHuoPower = 0
        self.kaiKuTuPower = 0
        self.kaiKuJinPower = 0
        self.kaiKuShuiPower = 0
        self.gaonengs = []
        self.muku = None
        self.isBanLu = False
        if not isTianGan:
            if text == "辰":
                self.muku = MuKu()
                self.muku.text = text
                self.muku.wuxing = "水"
            elif text == "戌":
                self.muku = MuKu()
                self.muku.text = text
                self.muku.wuxing = "火"
            elif text == "丑":
                self.muku = MuKu()
                self.muku.text = text
                self.muku.wuxing = "金"
            elif text == "未":
                self.muku = MuKu()
                self.muku.text = text
                self.muku.wuxing = "木"

    def getCangGanShiShens(self):
        result = []
        if self.cangGan1 is not None:
            result.append(self.gan1ShiShen)
        if self.cangGan2 is not None:
            result.append(self.gan2ShiShen)
        if self.cangGan3 is not None:
            result.append(self.gan3ShiShen)
        return result

    def findGaoNeng(self, guanxi: str):
        result = None
        for gn in self.gaonengs:
            if gn.guanxi == guanxi:
                result = gn
                break
        return result

    def check_lushen(self, riyuan: str):
        self.isLuShen = Common.is_lushen(self.text, riyuan)
        self.isBanLu = Common.is_banlu(self.text, riyuan)

    def get_weizhi_as_zhu(self):
        if self.weiZhi == SiZhuWeiZhi.niangan.value or self.weiZhi == SiZhuWeiZhi.nianzhi.value:
            return SiZhuWeiZhi.nianzhu.value
        if self.weiZhi == SiZhuWeiZhi.yuegan.value or self.weiZhi == SiZhuWeiZhi.yuezhi.value:
            return SiZhuWeiZhi.yuezhu.value
        if self.weiZhi == SiZhuWeiZhi.rigan.value or self.weiZhi == SiZhuWeiZhi.rizhi.value:
            return SiZhuWeiZhi.rizhu.value
        if self.weiZhi == SiZhuWeiZhi.shigan.value or self.weiZhi == SiZhuWeiZhi.shizhi.value:
            return SiZhuWeiZhi.shizhu.value
        return SiZhuWeiZhi.unknown.value

    def update_canggan_powers(self, percentanges: [int]):
        if self.isTianGan is True:
            self.set_wuxing_power(self.wuXing, self.power)
        else:
            # 普通地支
            if self.muku is None:
                self.set_wuxing_power(self.gan1WuXing, self.power * percentanges[0])
                self.set_wuxing_power(self.gan2WuXing, self.power * percentanges[1])
                self.set_wuxing_power(self.gan3WuXing, self.power * percentanges[2])
            else:
                # 墓库地支
                self.set_wuxing_power_of_muku(self.gan1WuXing, self.power * percentanges[0])
                self.set_wuxing_power_of_muku(self.gan2WuXing, self.power * percentanges[1])
                self.set_wuxing_power_of_muku(self.gan3WuXing, self.power * percentanges[2])

    def set_wuxing_power(self, wuxing: str, value: int):
        if wuxing is None:
            return
        value = round(value, 0)
        if wuxing == "木":
            self.muPower = value
        elif wuxing == "火":
            self.huoPower = value
        elif wuxing == "土":
            self.tuPower = value
        elif wuxing == "金":
            self.jinPower = value
        elif wuxing == "水":
            self.shuiPower = value

    def set_wuxing_power_of_muku(self, wuxing: str, value: int):
        if self.muku is None:
            return
        value = round(value, 0)
        if self.muku.isOpen:
            if wuxing == "木":
                self.kaiKuMuPower = value
            elif wuxing == "火":
                self.kaiKuHuoPower = value
            elif wuxing == "土":
                self.kaiKuTuPower = value
            elif wuxing == "金":
                self.kaiKuJinPower = value
            elif wuxing == "水":
                self.kaiKuShuiPower = value
        else:
            if wuxing == "木":
                self.biKuMuPower = value
            elif wuxing == "火":
                self.biKuHuoPower = value
            elif wuxing == "土":
                self.biKuTuPower = value
            elif wuxing == "金":
                self.biKuJinPower = value
            elif wuxing == "水":
                self.biKuShuiPower = value

    def get_canggan_power_by_wuxing(self, wuxing: str):
        result = 0
        state = 0  # 天干地支 = 0, 1：闭库 2:开库
        if self.isTianGan is False:
            if self.muku is not None:
                if self.muku.isOpen is False:
                    state = 1
                else:
                    state = 2

        if state == 0:
            if wuxing == "木":
                result = self.muPower
            elif wuxing == "火":
                result = self.huoPower
            elif wuxing == "土":
                result = self.tuPower
            elif wuxing == "金":
                result = self.jinPower
            elif wuxing == "水":
                result = self.shuiPower
        elif state == 1:
            if wuxing == "木":
                result = self.biKuMuPower
            elif wuxing == "火":
                result = self.biKuHuoPower
            elif wuxing == "土":
                result = self.biKuTuPower
            elif wuxing == "金":
                result = self.biKuJinPower
            elif wuxing == "水":
                result = self.biKuShuiPower
        elif state == 2:
            if wuxing == "木":
                result = self.kaiKuMuPower
            elif wuxing == "火":
                result = self.kaiKuHuoPower
            elif wuxing == "土":
                result = self.kaiKuTuPower
            elif wuxing == "金":
                result = self.kaiKuJinPower
            elif wuxing == "水":
                result = self.kaiKuShuiPower
        return result


class ShenShaInfo():
    fenbu: {}  # key 是柱的位置

    def __init__(self):
        self.fenbu = {}
        self.fenbu[SiZhuWeiZhi.nianzhu.value] = []
        self.fenbu[SiZhuWeiZhi.yuezhu.value] = []
        self.fenbu[SiZhuWeiZhi.rizhu.value] = []
        self.fenbu[SiZhuWeiZhi.shizhu.value] = []


class ShenSha():
    name: str
    tip: str
    effect: str

    def __init__(self, name: str, tip: str):
        self.name = name
        self.tip = tip


class GuanXiInfo():
    shishen: {}
    dizhi: {}
    tiangan: {}

    def __init__(self):
        self.shishen = {}
        self.dizhi = {}
        self.tiangan = {}


class WangShuaiPower():
    text: str
    wuxing: str
    amount: int
    value: int
    percentage: float
    shishen1: str
    shishenAmount1: int
    shishenValue1: int
    shishenPercentage1: float
    shishenPercentage1InTotal: float
    shishen2: str
    shishenAmount2: int
    shishenValue2: int
    shishenPercentage2: float
    shishenPercentage2InTotal: float
    zengqiang: int
    shishen1ZengQiang: int
    shishen2ZengQiang: int
    shishen1ValueAfterZengQiang: int
    shishen2ValueAfterZengQiang: int
    valueAfterZengQiang: int

    def __init__(self, wuxing: str, tag: str):
        self.wuxing = wuxing
        self.text = self.wuxing + tag
        self.zengqiang = 0
        self.shishen1ZengQiang = 0
        self.shishen2ZengQiang = 0

    def calcPercentage(self, count: float):
        self.percentage = round(self.valueAfterZengQiang / count * 100, 0)
        self.shishenPercentage1InTotal = round(self.shishenPercentage1 * self.percentage / 100, 0)
        self.shishenPercentage2InTotal = round(self.shishenPercentage2 * self.percentage / 100, 0)


class PowerInfo():
    wangShuaiPowers: [WangShuaiPower]
    tongdang: int
    yidang: int

    def __init__(self):
        self.wangShuaiPowers = []


class XingGeDesc():
    key: str
    state: str
    low: str
    middle: str
    strong: str
    value: int
    zuozhi: bool

    def __init__(self):
        self.zuozhi = False


class GeJu():
    key: str
    tip: str
    isChong: bool
    isChuan: bool
    isPo: bool
    isBaoHu: bool

    def __init__(self):
        self.isChong = False
        self.isChuan = False
        self.isPo = False
        self.isBaoHu = False


class ZhenJia():
    key: str
    zhenValue: int
    jiaValue: int
    zhenTip: str
    jiaTip: str


class ShiShenXiongJi():
    key: str
    isGood: bool
    eft: str
    solve: str
    tip: str


class MangPaiGong():
    he: int = 0
    po: int = 0
    total: float = 0
    zihe: float
    tip: str

    def __init__(self):
        self.tip = "1层功，1000万-1亿，科级；2层功，1e-10e，处级；3层功，10e-100e，厅级；4层功，100e-1000e，部级；更高功，国级"

    def calcTotal(self):
        self.total = self.he - self.po * 0.5 + self.zihe


class GeJuInfo():
    nianlu: GeJu = None
    jianlu: GeJu = None
    zhuanlu: GeJu = None
    guiLu: GeJu = None
    banlu: GeJu = None
    zhenjia: [ZhenJia]
    xushi: bool = False
    shishen: [ShiShenXiongJi]
    gong: MangPaiGong
    zuozhi: str

    def hasKeyInZhenJiaList(self, key: str):
        result = False
        if self.zhenjia is not None:
            for zj in self.zhenjia:
                if zj.key == key:
                    result = True
                    break
        return result


class JieGou():
    arg1: str
    arg2: str
    guanxi: str
    level: int
    shishen1: str
    shishen2: str
    isTianGan: bool
    baohu: bool

    def __init__(self, arg1: str, arg2: str, guanxi: str, level: int, shishen1: str, shishen2: str, isTianGan: bool):
        self.arg1 = arg1
        self.arg2 = arg2
        self.guanxi = guanxi
        self.level = level
        self.shishen1 = shishen1
        self.shishen2 = shishen2
        self.isTianGan = isTianGan
        self.baohu = False


class JieGouInfo():
    guanHe: [JieGou]
    guanAnHe: [JieGou]
    guanChong: [JieGou]
    guanChuan: [JieGou]
    guanPo: [JieGou]
    shaHe: [JieGou]
    shaAnHe: [JieGou]
    shaChong: [JieGou]
    shaChuan: [JieGou]
    shaPo: [JieGou]
    cai1He: [JieGou]
    cai1AnHe: [JieGou]
    cai1Chong: [JieGou]
    cai1Chuan: [JieGou]
    cai1Po: [JieGou]
    cai2He: [JieGou]
    cai2AnHe: [JieGou]
    cai2Chong: [JieGou]
    cai2Chuan: [JieGou]
    cai2Po: [JieGou]
    yinHe: [JieGou]
    yinAnHe: [JieGou]
    yinChong: [JieGou]
    yinChuan: [JieGou]
    yinPo: [JieGou]
    xiaoHe: [JieGou]
    xiaoAnHe: [JieGou]
    xiaoChong: [JieGou]
    xiaoChuan: [JieGou]
    xiaoPo: [JieGou]
    shiHe: [JieGou]
    shiAnHe: [JieGou]
    shiChong: [JieGou]
    shiChuan: [JieGou]
    shiPo: [JieGou]
    shangHe: [JieGou]
    shangAnHe: [JieGou]
    shangChong: [JieGou]
    shangChuan: [JieGou]
    shangPo: [JieGou]
    biHe: [JieGou]
    biAnHe: [JieGou]
    biChong: [JieGou]
    biChuan: [JieGou]
    biPo: [JieGou]
    jieHe: [JieGou]
    jieAnHe: [JieGou]
    jieChong: [JieGou]
    jieChuan: [JieGou]
    jiePo: [JieGou]
    baohu: {}

    def __init__(self):
        self.guanHe = []
        self.guanAnHe = []
        self.guanChong = []
        self.guanChuan = []
        self.guanPo = []
        self.shaHe = []
        self.shaAnHe = []
        self.shaChong = []
        self.shaChuan = []
        self.shaPo = []
        self.cai1He = []
        self.cai1AnHe = []
        self.cai1Chong = []
        self.cai1Chuan = []
        self.cai1Po = []
        self.cai2He = []
        self.cai2AnHe = []
        self.cai2Chong = []
        self.cai2Chuan = []
        self.cai2Po = []
        self.yinHe = []
        self.yinAnHe = []
        self.yinChong = []
        self.yinChuan = []
        self.yinPo = []
        self.xiaoHe = []
        self.xiaoAnHe = []
        self.xiaoChong = []
        self.xiaoChuan = []
        self.xiaoPo = []
        self.shiHe = []
        self.shiAnHe = []
        self.shiChong = []
        self.shiChuan = []
        self.shiPo = []
        self.shangHe = []
        self.shangAnHe = []
        self.shangChong = []
        self.shangChuan = []
        self.shangPo = []
        self.biHe = []
        self.biAnHe = []
        self.biChong = []
        self.biChuan = []
        self.biPo = []
        self.jieHe = []
        self.jieAnHe = []
        self.jieChong = []
        self.jieChuan = []
        self.jiePo = []
        self.baohu = {}
        for key in ["官", "杀", "财", "才", "印", "枭", "食", "伤", "比", "劫"]:
            self.baohu[key] = False


class GaoNengInfo():
    heList: [GaoNeng]
    chongList: [GaoNeng]
    poList: [GaoNeng]
    chuanList: [GaoNeng]
    banHeList: [GaoNeng]
    gongHeList: [GaoNeng]
    anHeList: [GaoNeng]
    sanHuiList: [GaoNeng]
    ziXingList: [GaoNeng]
    xingList: [GaoNeng]

    def __init__(self):
        self.heList = []
        self.chongList = []
        self.poList = []
        self.chuanList = []
        self.banHeList = []
        self.gongHeList = []
        self.anHeList = []
        self.sanHuiList = []
        self.ziXingList = []
        self.xingList = []


class LuckyDayInfo():
    year: int
    month: int
    day: int
    niangan: SiZhu
    yuegan: SiZhu
    rigan: SiZhu
    nianzhi: SiZhu
    yuezhi: SiZhu
    rizhi: SiZhu

    def all_gans(self):
        return [self.niangan, self.yuegan, self.rigan]

    def all_zhis(self):
        return [self.nianzhi, self.yuezhi, self.rizhi]

    def all_zhus(self):
        return [self.niangan, self.nianzhi, self.yuegan, self.yuezhi, self.rigan, self.rizhi]


class BaZi():
    qiankun: str
    taiyangshi: str
    nianGan: SiZhu
    nianZhi: SiZhu
    yueGan: SiZhu
    yueZhi: SiZhu
    riGan: SiZhu
    riZhi: SiZhu
    shiGan: SiZhu
    shiZhi: SiZhu
    powerInfo: PowerInfo
    shenshaInfo: ShenShaInfo
    guanxiInfo: GuanXiInfo
    xinggeInfo: {}
    gejuInfo: GeJuInfo
    fangans: [SiZhu]
    gaonengInfo: GaoNengInfo
    jiankang: {}
    jiegouInfo: JieGouInfo
    luckyDays: [LuckyDayInfo]

    def __has_shensha(self, wz: SiZhuWeiZhi, name: str):
        result = False
        lst = self.shenshaInfo.fenbu[wz.value]
        for dt in lst:
            if dt.name == name:
                result = True
                break
        return result

    # 这里传入的wz要转换成柱位置
    def add_shensha(self, wz: SiZhuWeiZhi, name: str, tip: str, eft: str = None):
        if not self.__has_shensha(wz, name):
            info = ShenSha()
            info.name = name
            info.tip = tip
            info.effect = eft
            self.shenshaInfo.fenbu[wz.value].append(info)

    def sizhu_tiangans(self):
        return [self.nianGan, self.yueGan, self.riGan, self.shiGan]

    def sizhu_dizhis(self):
        return [self.nianZhi, self.yueZhi, self.riZhi, self.shiZhi]

    def sizhu_all(self):
        return [self.nianGan, self.nianZhi, self.yueGan, self.yueZhi, self.riGan, self.riZhi, self.shiGan, self.shiZhi]

    def getTianGanDiZhiByZhu(self, wz: int):
        if wz == SiZhuWeiZhi.nianzhu:
            return [self.nianGan, self.nianZhi]
        if wz == SiZhuWeiZhi.yuezhu:
            return [self.yueGan, self.yueZhi]
        if wz == SiZhuWeiZhi.rizhu:
            return [self.riGan, self.riZhi]
        if wz == SiZhuWeiZhi.shizhu:
            return [self.shiGan, self.shiZhi]
        return None

    def findTianGanDiZhiInZhu(self, tiangan: str, dizhi: str):
        result = []
        if self.nianGan.text == tiangan and self.nianZhi.text == dizhi:
            result.append(SiZhuWeiZhi.nianzhu.value)
        elif self.yueGan.text == tiangan and self.yueZhi.text == dizhi:
            result.append(SiZhuWeiZhi.yuezhu.value)
        elif self.riGan.text == tiangan and self.riZhi.text == dizhi:
            result.append(SiZhuWeiZhi.rizhu.value)
        elif self.shiGan.text == tiangan and self.shiZhi.text == dizhi:
            result.append(SiZhuWeiZhi.shizhu.value)
        return result

    def findGaoNengByShiShen(self, shishen1: str, shishen2: str, guanxi: str):
        lst = []
        temp = self.__get_gaoneng_list_by_guanxi(guanxi)
        for dt in temp:
            if dt.shishen1 == shishen1 and dt.shishen2 == shishen2:
                lst.append(dt)
            elif dt.shishen1 == shishen2 and dt.shishen2 == shishen1:
                lst.append(dt)
        return lst

    def findGaoNengByArgs(self, arg1: str, arg2: str, guanxi: str):
        lst = []
        temp = self.__get_gaoneng_list_by_guanxi(guanxi)
        for dt in temp:
            if dt.arg1 == arg1 and dt.arg2 == arg2:
                lst.append(dt)
            elif dt.arg1 == arg2 and dt.arg2 == arg1:
                lst.append(dt)
        return lst

    def findGaoNengByGuanXis(self, shishen1: str, shishen2: str, guanxis: [str]):
        lst = []
        for guanxi in guanxis:
            temp = self.__get_gaoneng_list_by_guanxi(guanxi)
            for dt in temp:
                if dt.shishen1 == shishen1 and dt.shishen2 == shishen2:
                    lst.append(dt)
                elif dt.shishen1 == shishen2 and dt.shishen2 == shishen1:
                    lst.append(dt)
        return lst

    def hasGaoNeng(self, gaoneng: str, wz: SiZhuWeiZhi):
        result = False
        zhu = self.getZhuByWeiZhi(wz.value)
        if zhu is not None:
            for gn in zhu.gaonengs:
                if gn.text == gaoneng:
                    result = True
                    break
        return result

    # 用来检查某位置是否包含合、冲、穿、刑等关键字的高能关系
    def hasGaoNengKey(self, key: str, wz: SiZhuWeiZhi):
        result = False
        zhu = self.getZhuByWeiZhi(wz.value)
        if zhu is not None:
            for gn in zhu.gaonengs:
                if gn.guanxi == key:
                    result = True
                    break
        return result

    # 这里的位置是以柱为单位的
    def hasShenSha(self, name: str, wz: SiZhuWeiZhi):
        result = False
        lst = self.shenshaInfo.fenbu[wz]
        if lst is not None:
            for info in lst:
                if info.name == name:
                    result = True
                    break
        return result

    def hasShiShen(self, key: str):
        # dc.has_all_shishen 替代
        result = False
        for sz in self.sizhu_all():
            if sz.shiShen == key:
                result = True
                break
        return result

    # 通过五行查找对应的2个十神
    def getShiShensByWuXing(self, wuxing: str):
        result = []
        if self.guanxiInfo.shishen.keys().__contains__(wuxing):
            result = self.guanxiInfo.shishen.get(wuxing)
        return result

    def getPowerOfShiShen(self, shishen: str):
        # dc.get_shishen_power 替代
        result = 0
        for wsp in self.powerInfo.wangShuaiPowers:
            if wsp.shishen1 == shishen:
                result = wsp.shishenValue1
                break
            elif wsp.shishen2 == shishen:
                result = wsp.shishenValue2
                break
        return round(result)

    def getPowerOfWuXing(self, wuxing: str):
        result = 0
        for wsp in self.powerInfo.wangShuaiPowers:
            if wsp.wuxing == wuxing:
                result = wsp.value
                break
        return round(result)

    # 从xingge info 中查找五行的状态，返回：过旺、旺、衰
    def getWuXingState(self, wuxing: str):
        result = None
        for xg in self.xinggeInfo["wuxing"]:
            if xg.key == wuxing:
                result = xg.state
                break
        return result

    def __get_gaoneng_list_by_guanxi(self, guanxi: str):
        lst = []
        if guanxi == "合":
            lst = self.gaonengInfo.heList
        elif guanxi == "暗合":
            lst = self.gaonengInfo.anHeList
        elif guanxi == "半合":
            lst = self.gaonengInfo.banHeList
        elif guanxi == "拱合":
            lst = self.gaonengInfo.gongHeList
        elif guanxi == "三会":
            lst = self.gaonengInfo.sanHuiList
        elif guanxi == "刑":
            lst = self.gaonengInfo.xingList
        elif guanxi == "自刑":
            lst = self.gaonengInfo.ziXingList
        elif guanxi == "冲":
            lst = self.gaonengInfo.chongList
        elif guanxi == "破":
            lst = self.gaonengInfo.poList
        elif guanxi == "穿":
            lst = self.gaonengInfo.chuanList
        return lst

    def countGaoNeng(self, guanxi: str):
        lst = self.__get_gaoneng_list_by_guanxi(guanxi)
        return len(lst)

    def getZhuByWeiZhi(self, weizhi: int):
        if weizhi == SiZhuWeiZhi.niangan.value:
            return self.nianGan
        if weizhi == SiZhuWeiZhi.nianzhi.value:
            return self.nianZhi
        if weizhi == SiZhuWeiZhi.yuegan.value:
            return self.yueGan
        if weizhi == SiZhuWeiZhi.yuezhi.value:
            return self.yueZhi
        if weizhi == SiZhuWeiZhi.rigan.value:
            return self.riGan
        if weizhi == SiZhuWeiZhi.rizhi.value:
            return self.riZhi
        if weizhi == SiZhuWeiZhi.shigan.value:
            return self.shiGan
        if weizhi == SiZhuWeiZhi.shizhi.value:
            return self.shiZhi
        return None

    def __init__(self, request: SiZhuInfoRequest):
        self.qiankun = request.qiankun
        self.nianGan = SiZhu(request.qiankun, True, request.texts[0], SiZhuWeiZhi.niangan)
        self.yueGan = SiZhu(request.qiankun, True, request.texts[1], SiZhuWeiZhi.yuegan)
        self.riGan = SiZhu(request.qiankun, True, request.texts[2], SiZhuWeiZhi.rigan)
        self.shiGan = SiZhu(request.qiankun, True, request.texts[3], SiZhuWeiZhi.shigan)
        self.nianZhi = SiZhu(request.qiankun, False, request.texts[4], SiZhuWeiZhi.nianzhi)
        self.yueZhi = SiZhu(request.qiankun, False, request.texts[5], SiZhuWeiZhi.yuezhi)
        self.riZhi = SiZhu(request.qiankun, False, request.texts[6], SiZhuWeiZhi.rizhi)
        self.shiZhi = SiZhu(request.qiankun, False, request.texts[7], SiZhuWeiZhi.shizhi)
        self.nianZhi.check_lushen(self.riGan.text)
        self.yueZhi.check_lushen(self.riGan.text)
        self.riZhi.check_lushen(self.riGan.text)
        self.shiZhi.check_lushen(self.riGan.text)

        self.powerInfo = PowerInfo()
        self.guanxiInfo = GuanXiInfo()
        self.shenshaInfo = ShenShaInfo()
        self.xinggeInfo = {}
        self.gejuInfo = GeJuInfo()
        self.fangans = []
        self.gaonengInfo = GaoNengInfo()
        self.jiankang = {}
        self.jiegouInfo = JieGouInfo()