csst.py

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],
)