add csst module

class CaseInsensitiveDict(dict):

    def __init__(self, *args, **kwargs):

        self._key_map = {}

        super().__init__(*args, **kwargs)

        # 初始化时处理传入的键

        for key in list(self.keys()):

            self._key_map[key.lower()] = key

    def __setitem__(self, key, value):

        key_lower = key.lower() if isinstance(key, str) else key

        self._key_map[key_lower] = key  # 记录原始键

        super().__setitem__(key_lower, value)

    def __getitem__(self, key):

        key_lower = key.lower() if isinstance(key, str) else key

        return super().__getitem__(key_lower)

    def __delitem__(self, key):

        key_lower = key.lower() if isinstance(key, str) else key

        del self._key_map[key_lower]

        super().__delitem__(key_lower)

    def __contains__(self, key):

        key_lower = key.lower() if isinstance(key, str) else key

        return super().__contains__(key_lower)

    def get(self, key, default=None):

        key_lower = key.lower() if isinstance(key, str) else key

        return super().get(key_lower, default)

    def keys(self):

        return self._key_map.values()  # 返回原始键

    def items(self):

        for key_lower, value in super().items():

            yield (self._key_map.get(key_lower, key_lower), value)

class Detector:

    def __init__(self, name: str = "01", is_effective: bool = True):

        self.name = name

        self.is_effective: bool = is_effective

    def __repr__(self):

        return f"<Detector: {self.name}, is_effective: {self.is_effective}>"

class SimpleInstrument(CaseInsensitiveDict):

    def __init__(

        self,

        name: str,

        detectors: list[Detector],

    ):

        self.name = name

        self._detectors = detectors

        super().__init__()

        for d in detectors:

            self[d.name] = d

    @property

    def detectors(self):

        return self._detectors

    @property

    def detector_names(self):

        return [d.name for d in self._detectors]

    @property

    def effective_detectors(self):

        return [d for d in self._detectors if d.is_effective]

    @property

    def effective_detector_names(self):

        return [d.name for d in self._detectors if d.is_effective]

    @property

    def n_detector(self):

        return len(self.detectors)

    @property

    def n_effective_detector(self):

        return len(self.effective_detectors)

    def __repr__(self):

        return f"<SimpleInstrument: {self.name}, {self.n_detector} detectors, {self.n_effective_detector} effective>"

    def __getitem__(self, item):

        return self[item.upper()]

class ComplexInstrument(CaseInsensitiveDict):

    def __init__(

        self,

        name: str,

        instruments: list[SimpleInstrument],

    ):

        self.name = name

        self.instruments = instruments

        super().__init__()

        for i in self.instruments:

            self[i.name] = i

    @property

    def n_instrument(self):

        return len(self.instruments)

    @property

    def n_detector(self):

        return sum([i.n_detector for i in self.instruments])

    @property

    def n_effective_detector(self):

        return sum([i.n_effective_detector for i in self.instruments])

    @property

    def detectors(self):

        return [d for i in self.instruments for d in i.detectors]

    @property

    def detector_names(self):

        return [d.name for i in self.instruments for d in i.detectors]

    @property

    def effective_detectors(self):

        return [d for i in self.instruments for d in i.effective_detectors]

    @property

    def effective_detector_names(self):

        return [d.name for i in self.instruments for d in i.effective_detectors]

    def __repr__(self):

        str_instruments = ",".join([_.__repr__() for _ in self.instruments])

        return f"[ComplexInstrument: {self.name}, {str_instruments}]"

class Telescope(CaseInsensitiveDict):

    def __init__(

        self,

        name: str,

        instruments: list[SimpleInstrument | ComplexInstrument],

    ):

        self.name = name

        self.instruments = instruments

        super().__init__()

        for i in self.instruments:

            self[i.name] = i

    @property

    def n_instrument(self):

        return len(self.instruments)

mbi = SimpleInstrument(

    name="MBI",

    detectors=[

        Detector(name=_)

        for _ in [

            "06",

            "07",

            "08",

            "09",

            "11",

            "12",

            "13",

            "14",

            "15",

            "16",

            "17",

            "18",

            "19",

            "20",

            "22",

            "23",

            "24",

            "25",

        ]

    ],

)

sls = SimpleInstrument(

    name="SLS",

    detectors=[

        Detector(name=_)

        for _ in [

            "01",

            "02",

            "03",

            "04",

            "05",

            "10",

            "21",

            "26",

            "27",

            "28",

            "29",

            "30",

        ]

    ],

)

ir = SimpleInstrument(

    name="IR",

    detectors=[Detector(name=f"IR{_}{_}", is_effective=False) for _ in range(1, 9)],

)

mci = SimpleInstrument(

    name="MCI",

    detectors=[Detector(name=_) for _ in ["C1", "C2", "C3"]],

)

ifs = SimpleInstrument(

    name="IFS",

    detectors=[Detector(name=_) for _ in ["B", "R"]],

)

cpic = SimpleInstrument(

    name="CPIC",

    detectors=[Detector(name=_) for _ in ["VIS", "NIR"]],

)

hstdm = SimpleInstrument(

    name="HSTDM",

    detectors=[Detector(name=_) for _ in ["sis01", "sis02"]],

)

msc = ComplexInstrument(

    name="MSC",

    instruments=[mbi, sls, ir],

)

csst = Telescope(

    name="CSST",

    instruments=[msc, mci, ifs, cpic, hstdm],

)

# csst.instruments

# csst["msc"].detectors[0]