horiba-sdk 0.5.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

{horiba_sdk-0.5.4.dist-info → horiba_sdk-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: horiba-sdk
-Version: 0.5.4
+Version: 0.7.0
 Summary: 'horiba-sdk' is a package that provides source code for the development with Horiba devices
 Home-page: https://github.com/ThatsTheEnd/horiba-python-sdk
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: overrides (>=7.4.0,<8.0.0)
 Requires-Dist: pint (>=0.23,<0.24)
 Requires-Dist: psutil (>=5.9.7,<6.0.0)
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
 Requires-Dist: websockets (>=12.0,<13.0)
 Project-URL: Repository, https://github.com/ThatsTheEnd/horiba-python-sdk
 Description-Content-Type: text/markdown

horiba_sdk-0.7.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+horiba_sdk/__init__.py,sha256=J8jCV90BJ2SCDFSpacDeAAsJa8PFqBUDpREOJeAgXug,679
+horiba_sdk/communication/__init__.py,sha256=nhS1rw1ZojM8zmRIx0VEFtYge0IH-B_L4zNBUNBJZYE,1564
+horiba_sdk/communication/abstract_communicator.py,sha256=E80dfOjrfuNay3W5jeSn4T2tUas6vygRcF46kSoP5j8,1498
+horiba_sdk/communication/communication_exception.py,sha256=d2ouOoVI6Q69_JL1bUEjjQOmjiO0CEm8K20WsaUuhB0,583
+horiba_sdk/communication/messages.py,sha256=7PCCkIpicq0CbN95nLoxIpsXlPd0c5lKbW92rn8h-6w,2701
+horiba_sdk/communication/websocket_communicator.py,sha256=IFP6dfuqiwGsNymPtT4Hqmii_8n2pO1Jv_k31GfrM8s,8331
+horiba_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+horiba_sdk/core/acquisition_format.py,sha256=CWyLgCotx60-vBAv6ZzMoCpKDXFtS43Q5reiKcYmF6U,350
+horiba_sdk/core/clean_count_mode.py,sha256=7guLd3eUV3Y2Cnj3w0JJ7ry74I8a6MFQiqbK5pTb3oU,185
+horiba_sdk/core/resolution.py,sha256=VOQonjPBqZ2TbtiNVDBT3TI1Aymj1pPYWMoobFaXjG8,1029
+horiba_sdk/core/stitching/__init__.py,sha256=Ih8CHdb9VnoM1DHAO-T3w7IGxZHZqSlnI2AeAuJq7qc,337
+horiba_sdk/core/stitching/labspec6_spectra_stitch.py,sha256=8oc1DoEtnBhYaOXfLFQBBc12DEh_wRVDI_lu9ELnP6Q,3093
+horiba_sdk/core/stitching/linear_spectra_stitch.py,sha256=epA2_pMlJVJ83oBn_4W1IWb3ImIzag61E2XrR-0MpCI,3968
+horiba_sdk/core/stitching/simple_cut_spectra_stitch.py,sha256=yMqy1T_GwViG4pBwZIDg557gFPR8qMhJv8v1-9eQnTY,2920
+horiba_sdk/core/stitching/spectra_stitch.py,sha256=Y63e4_sm2fU6GKYphopCWec1n29yMX-fDIyIrjKRuoc,447
+horiba_sdk/core/stitching/y_displacement_spectra_stitch.py,sha256=YA1RefdJCe5U22gkqQQNi5mLgZ4A7dZxBiezkP0FsAI,3189
+horiba_sdk/core/timer_resolution.py,sha256=V6pXEZMVvUUoqrJmLFFI45pFt_7po6-5r1DmC8jY6gs,300
+horiba_sdk/core/trigger_input_polarity.py,sha256=UDns386W5ecKOHAdEru4dMObX9EF7pZetzY8IvmNufM,97
+horiba_sdk/core/x_axis_conversion_type.py,sha256=SQrdbciTR8x5UWOqLDgxWPy12o0-yIVLrkm7N3gpWpg,449
+horiba_sdk/devices/__init__.py,sha256=YYsJL2CSJwc2vsAjFQEKXjA5_QAnKlxSwlx32EgzFME,336
+horiba_sdk/devices/abstract_device_discovery.py,sha256=04ZCEB5IZkUuJxSisS78eW6lAQNXG4uaDoPv-eBccBA,178
+horiba_sdk/devices/abstract_device_manager.py,sha256=RXj5_pzFHpiolJe3ZfFsofwpD1hlwUMwYD1DyWMmlI0,1717
+horiba_sdk/devices/ccd_discovery.py,sha256=nGuskZ07Y9myI__dU8LeLnrNiJEBpGPby21EEwgSVUk,2376
+horiba_sdk/devices/device_manager.py,sha256=0C5qZK7ekZL7A68yXWiUHRYCVqQ1fjioL3861DP1gkY,11548
+horiba_sdk/devices/fake_device_manager.py,sha256=Tr4Z067smYfy-ya29PO4PK4EWF6Sa1R2UQFZCWfPePE,5015
+horiba_sdk/devices/fake_icl_server.py,sha256=aVmUZfBddz_w6HX2L6KS_9ei-a4SKtkh5Q8MuUV3szA,2757
+horiba_sdk/devices/fake_responses/ccd.json,sha256=sMg-UqU6W1I01n2kEbkFc5J0XF8E3JVdOjB-1MhufzM,17020
+horiba_sdk/devices/fake_responses/icl.json,sha256=ZPKhjx0BmwmqNGwbb7reXSStddgVZetCQQYVeNr9CSU,572
+horiba_sdk/devices/fake_responses/monochromator.json,sha256=I9yBMsJyXXVCLF1J8mNPsfgXasIg60IL-4ToECcoGhw,4308
+horiba_sdk/devices/fake_responses/spectracq3.json,sha256=gnGWGtz4MzifY4NaKtjQ6XaWL73d5lMJM3mOlpdmDtE,4099
+horiba_sdk/devices/monochromator_discovery.py,sha256=KoZ8vfPsI6QRuiD4BiE0YvzO42dQzFZqvoxygDSllE8,2365
+horiba_sdk/devices/single_devices/__init__.py,sha256=JtQYr26ZrSqi3uaralLipw6u3e9f7z-QsXPIrSfdAoQ,241
+horiba_sdk/devices/single_devices/abstract_device.py,sha256=CwCjHJWSp8WGrYsyq0ZhTQVnvYdoCG-kb4BU9SZXJm8,3994
+horiba_sdk/devices/single_devices/ccd.py,sha256=qtXMzEhYs3UJhOsDA2hIajdN1nyvP7eFZaiaBYZ3piY,30083
+horiba_sdk/devices/single_devices/monochromator.py,sha256=r-9bI-ne_iGdfTWBvUnYSxxp1DQNlEt7wBN31cGfZ1E,14538
+horiba_sdk/devices/single_devices/spectracq3.py,sha256=cFNFDbGLQB9HkKfg3TwYTEaLx8gcNu1O_nPjXOjH1hk,13667
+horiba_sdk/devices/spectracq3_discovery.py,sha256=5mrjmZ30F35Jswl3u3yuMnu5Hu5LDOqYZ4rlOJeRvO8,2389
+horiba_sdk/icl_error/__init__.py,sha256=EtqHaUeoaLilpb7L7juuVamJgIZ3Anfnca0AO2o46rg,1053
+horiba_sdk/icl_error/abstract_error.py,sha256=5nQDI6MNfCi4xUx6taJcEWGwANOo8mPEb4kVxrO-DW8,1301
+horiba_sdk/icl_error/abstract_error_db.py,sha256=IJ3wGb6DWxnY35VIUwZX0X80IPi5k4QoQXnVjDy8lH8,589
+horiba_sdk/icl_error/error_list.json,sha256=wyDYZPeH2sYMRPoL-JBoDul4uaYvoqp7SJg0zypfl40,5977
+horiba_sdk/icl_error/icl_error.py,sha256=IElsKl5nvLjprIV_ub9MacJmdSS327iNwOXhSiJXTc0,755
+horiba_sdk/icl_error/icl_error_db.py,sha256=5Jbs_ZlMp8Bjr4u8reIxxfOSFYYkzWTfKIqOQ4oUSXQ,2603
+horiba_sdk-0.7.0.dist-info/LICENSE,sha256=JD-7TpNZoT7emooLwaTU9bJZbFbeM1ba90b8gpCYxzM,1083
+horiba_sdk-0.7.0.dist-info/METADATA,sha256=l-MRWVpfMYjW3dovj-kzSGahIZTe8mQsT5nxh1aaOfw,14391
+horiba_sdk-0.7.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+horiba_sdk-0.7.0.dist-info/RECORD,,

horiba_sdk/sync/communication/__init__.py

@@ -1,7 +0,0 @@
-from .abstract_communicator import AbstractCommunicator
-from .websocket_communicator import WebsocketCommunicator
-
-__all__ = [
-    'AbstractCommunicator',
-    'WebsocketCommunicator',
-]

horiba_sdk/sync/communication/abstract_communicator.py

@@ -1,47 +0,0 @@
-from abc import ABC, abstractmethod
-
-from horiba_sdk.communication.messages import Command, Response
-
-
-class AbstractCommunicator(ABC):
-    """
-    Abstract base class for communication protocols.
-    """
-
-    @abstractmethod
-    def open(self) -> None:
-        """
-        Abstract method to establish a connection.
-        """
-        pass
-
-    @abstractmethod
-    def opened(self) -> bool:
-        """
-        Abstract method that says if the connection is open
-
-        Returns:
-            bool: True if the connection is open, False otherwise
-        """
-        pass
-
-    @abstractmethod
-    def request_with_response(self, command: Command, response_timeout_s: float = 5) -> Response:
-        """
-        Abstract method to fetch a response from a command.
-
-        Args:
-            command (Command): Command for which a response is desired
-            response_timeout_s (float, optional): Timeout in seconds. Defaults to 5.
-
-        Returns:
-            Response: The response corresponding to the sent command.
-        """
-        pass
-
-    @abstractmethod
-    def close(self) -> None:
-        """
-        Abstract method to close the connection.
-        """
-        pass

horiba_sdk/sync/communication/test_client.py

@@ -1,16 +0,0 @@
-# Closing frame is apparently not sent. Here is a minimal example to prove the point:
-# 1. First run icl.exe
-# 2. Then execute this script:
-#    poetry run python ./horiba_sdk/sync/communication/test_client.py
-from websockets.exceptions import ConnectionClosedError, ConnectionClosedOK
-from websockets.sync.client import connect
-
-websocket = connect(uri='ws://localhost:25010')
-try:
-    websocket.send('{"command":"icl_shutdown"}')
-    for message in websocket:
-        print(message)
-except ConnectionClosedOK as e:
-    print(f'Connection normally closed: {e}')
-except ConnectionClosedError as e:
-    print(f'Protocol error or network failure: {e}')

horiba_sdk/sync/communication/websocket_communicator.py

@@ -1,232 +0,0 @@
-import time
-from queue import Queue
-from threading import Thread
-from types import TracebackType
-from typing import Any, Callable, Optional, final
-
-import websockets
-from loguru import logger
-from overrides import override
-from websockets.sync.client import ClientConnection
-
-from horiba_sdk.communication.communication_exception import CommunicationException
-from horiba_sdk.communication.messages import Command, JSONResponse, Response
-from horiba_sdk.sync.communication.abstract_communicator import AbstractCommunicator
-
-
-@final
-class WebsocketCommunicator(AbstractCommunicator):
-    """
-    The WebsocketCommunicator implements the `horiba_sdk.sync.communication.AbstractCommunicator` via websockets.
-    A background thread listens continuously for incoming binary data.
-    """
-
-    def __init__(self, uri: str = 'ws://127.0.0.1:25010') -> None:
-        self.uri: str = uri
-        self.websocket: Optional[ClientConnection] = None
-        self.running_listen_thread: bool = False
-        self.listen_thread: Optional[Thread] = None
-        self.running_binary_message_handling_thread: bool = False
-        self.binary_message_handling_thread: Optional[Thread] = None
-        self.json_message_dict: dict[int, JSONResponse] = {}
-        self.binary_message_queue: Queue[bytes] = Queue()
-        self.binary_message_callback: Optional[Callable[[bytes], Any]] = None
-        self.icl_info: dict[str, Any] = {}
-
-    def __enter__(self) -> 'WebsocketCommunicator':
-        self.open()
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> None:
-        self.close()
-
-    @override
-    def open(self) -> None:
-        """
-        Opens the WebSocket connection and starts listening for binary data.
-
-        Raises:
-            CommunicationException: When the websocket is already opened or
-            there is an issue with the underlying websockets connection attempt.
-        """
-        if self.opened():
-            raise CommunicationException(None, 'websocket already opened')
-
-        try:
-            self.websocket = websockets.sync.client.connect(self.uri)
-        except websockets.WebSocketException as e:
-            raise CommunicationException(None, 'websocket connection issue') from e
-
-        self.running_listen_thread = True
-        self.listen_thread = Thread(target=self._receive_data)
-        self.listen_thread.start()
-
-        logger.debug(f'Websocket connection established to {self.uri}')
-
-    def send(self, command: Command) -> None:
-        """
-        Sends a command to the WebSocket server.
-
-        Args:
-            command (Command): The command to send to the server.
-
-        Raises:
-            CommunicationException: When trying to send a command while the websocket is closed.
-
-        """
-        if not self.opened():
-            raise CommunicationException(None, 'WebSocket is not opened.')
-
-        try:
-            # mypy cannot infer the check from self.opened() done above
-            logger.debug(f'Sending JSON command: {command.json()}')
-            self.websocket.send(command.json())  # type: ignore
-        except websockets.exceptions.ConnectionClosed as e:
-            raise CommunicationException(None, 'Trying to send data while websocket is closed') from e
-
-    @override
-    def opened(self) -> bool:
-        """
-        Returns if the websocket connection is open or not
-
-        Returns:
-            bool: True if the websocket connection is open, False otherwise
-        """
-        return self.websocket is not None
-
-    def response(self, command_id: int, timeout_s: float = 5.0) -> Response:
-        """Fetches the response belonging to the command_id.
-
-        Args:
-            command_id (int): The command id of the command.
-            timeout_s (float): The timeout in seconds.
-
-        Returns:
-            Response: The response from the server
-
-        Raises:
-            CommunicationException: When the connection terminated with an error
-        """
-        waited_time_in_s: float = 0.0
-        sleep_time_in_s: float = 0.1
-        while waited_time_in_s < timeout_s and (
-            not self.json_message_dict
-            or len(self.json_message_dict) == 0
-            or self.json_message_dict.get(command_id) is None
-        ):
-            time.sleep(sleep_time_in_s)
-            waited_time_in_s += sleep_time_in_s
-
-        if not self.json_message_dict or len(self.json_message_dict) == 0:
-            raise CommunicationException(None, 'no message to be received.')
-
-        if self.json_message_dict.get(command_id) is None:
-            raise CommunicationException(None, f'no response with id {command_id}')
-
-        logger.debug(f'#{len(self.json_message_dict)} messages, taking the one with id:{command_id}')
-        response: JSONResponse = self.json_message_dict[command_id]
-        del self.json_message_dict[command_id]
-        logger.debug('retrieved message in dict')
-        return response
-
-    @override
-    def close(self) -> None:
-        """
-        Closes the WebSocket connection.
-
-        Raises:
-            CommunicationException: When the websocket is already closed
-        """
-        if not self.opened():
-            raise CommunicationException(None, 'cannot close already closed websocket')
-        if self.websocket:
-            logger.debug('Waiting websocket close...')
-            self.websocket.close()
-
-        if self.binary_message_handling_thread:
-            logger.debug('Canceling binary listening thread...')
-            self.running_binary_message_handling_thread = False
-            self.binary_message_handling_thread.join()
-            self.binary_message_handling_thread = None
-
-        if self.listen_thread:
-            logger.debug('Canceling listening thread...')
-            self.running_listen_thread = False
-            self.listen_thread.join()
-            self.listen_thread = None
-
-        self.websocket = None
-        logger.debug('Websocket connection closed')
-
-    def register_binary_message_callback(self, callback: Callable[[bytes], Any]) -> None:
-        """Registers a callback to be called with every incoming binary message."""
-        if self.binary_message_callback:
-            raise CommunicationException(None, 'Binary message callback already registered')
-
-        self.binary_message_callback = callback
-        logger.debug('Binary message callback registered.')
-        self.running_binary_message_handling_thread = True
-        self.binary_message_handling_thread = Thread(target=self._run_binary_message_callback)
-        self.binary_message_handling_thread.start()
-        logger.info('Started binary message thread')
-
-    def _receive_data(self) -> None:
-        if not self.websocket:
-            raise CommunicationException(None, 'Websocket is not open')
-
-        while self.running_listen_thread:
-            try:
-                for message in self.websocket:
-                    logger.debug(f'Received message: {message!r}')
-                    if isinstance(message, str):
-                        response: JSONResponse = JSONResponse(message)
-                        self.json_message_dict[response.id] = response
-                    elif isinstance(message, bytes) and self.binary_message_callback:
-                        self.binary_message_queue.put(message)
-                    else:
-                        raise CommunicationException(None, f'Unknown type of message {type(message)}')
-            except websockets.ConnectionClosedOK:
-                logger.debug('websocket connection terminated properly')
-            except websockets.ConnectionClosedError as e:
-                raise CommunicationException(None, 'connection terminated with error') from e
-            except Exception as e:
-                raise CommunicationException(None, 'failure to process binary data') from e
-
-    def _run_binary_message_callback(self) -> None:
-        if not self.binary_message_callback:
-            raise CommunicationException(None, 'No binary message callback registered')
-
-        while self.running_binary_message_handling_thread:
-            while self.binary_message_queue.empty():
-                time.sleep(0.5)
-                if not self.running_binary_message_handling_thread:
-                    return
-
-            binary_message = self.binary_message_queue.get()
-            self.binary_message_callback(binary_message)
-
-    @override
-    def request_with_response(self, command: Command, response_timeout_s: float = 5) -> Response:
-        """
-        Concrete method to fetch a response from a command.
-
-        Args:
-            command (Command): Command for which a response is desired
-            response_timeout_s (float, optional): Timeout in seconds. Defaults to 5.
-
-        Returns:
-            Response: The response corresponding to the sent command.
-        """
-        self.send(command)
-        response: Response = self.response(command.id, response_timeout_s)
-
-        if response.id != command.id:
-            logger.error(f'got wrong response id: {response.id}, command id: {command.id}')
-            raise Exception('got wrong response id')
-
-        return response

horiba_sdk/sync/devices/__init__.py

@@ -1,15 +0,0 @@
-from .abstract_device_discovery import AbstractDeviceDiscovery
-from .abstract_device_manager import AbstractDeviceManager
-from .device_discovery import DeviceDiscovery
-from .device_manager import DeviceManager
-from .fake_device_manager import FakeDeviceManager
-from .fake_icl_server import FakeICLServer
-
-__all__ = [
-    'AbstractDeviceDiscovery',
-    'AbstractDeviceManager',
-    'DeviceDiscovery',
-    'DeviceManager',
-    'FakeDeviceManager',
-    'FakeICLServer',
-]

horiba_sdk/sync/devices/abstract_device_discovery.py

@@ -1,17 +0,0 @@
-from abc import ABC, abstractmethod
-
-from horiba_sdk.sync.devices.single_devices import ChargeCoupledDevice, Monochromator
-
-
-class AbstractDeviceDiscovery(ABC):
-    @abstractmethod
-    def execute(self, error_on_no_device: bool = False) -> None:
-        pass
-
-    @abstractmethod
-    def charge_coupled_devices(self) -> list[ChargeCoupledDevice]:
-        pass
-
-    @abstractmethod
-    def monochromators(self) -> list[Monochromator]:
-        pass

horiba_sdk/sync/devices/abstract_device_manager.py

@@ -1,68 +0,0 @@
-from abc import ABC, abstractmethod
-
-from horiba_sdk.sync.communication import AbstractCommunicator
-from horiba_sdk.sync.devices.single_devices import ChargeCoupledDevice, Monochromator
-
-
-class AbstractDeviceManager(ABC):
-    """
-    DeviceManager class manages the lifecycle and interactions with devices.
-
-    """
-
-    @abstractmethod
-    def start(self) -> None:
-        """
-        Abstract method to start the device manager.
-        """
-        pass
-
-    @abstractmethod
-    def stop(self) -> None:
-        """
-        Abstract method to stop the device manager.
-        """
-        pass
-
-    @abstractmethod
-    def discover_devices(self, error_on_no_device: bool = False) -> None:
-        """
-        Abstract method that discovers and registers devices.
-
-        Args:
-            error_on_no_device (bool): If True, an exception is raised if no device is connected.
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def communicator(self) -> AbstractCommunicator:
-        """
-        Abstract method to get the communicator attribute.
-
-        Returns:
-            AbstractCommunicator: Returns the internal communicator instance.
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def monochromators(self) -> list[Monochromator]:
-        """
-        Abstract method to get the detected monochromators.
-
-        Returns:
-            List[Monochromator]: The detected monochromators
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def charge_coupled_devices(self) -> list[ChargeCoupledDevice]:
-        """
-        Abstract method to get the detected CCDs.
-
-        Returns:
-            List[ChargeCoupledDevice]: The detected CCDS.
-        """
-        pass

horiba_sdk/sync/devices/device_discovery.py

@@ -1,58 +0,0 @@
-from typing import final
-
-from loguru import logger
-from overrides import override
-
-from horiba_sdk.communication import Command, Response
-from horiba_sdk.icl_error import AbstractErrorDB
-from horiba_sdk.sync.communication import AbstractCommunicator
-from horiba_sdk.sync.devices.abstract_device_discovery import AbstractDeviceDiscovery
-from horiba_sdk.sync.devices.single_devices import ChargeCoupledDevice, Monochromator
-
-
-@final
-class DeviceDiscovery(AbstractDeviceDiscovery):
-    def __init__(self, communicator: AbstractCommunicator, error_db: AbstractErrorDB):
-        self._communicator: AbstractCommunicator = communicator
-        self._charge_coupled_devices: list[ChargeCoupledDevice] = []
-        self._monochromators: list[Monochromator] = []
-        self._error_db: AbstractErrorDB = error_db
-        self._discovered_devices: bool = False
-
-    @override
-    def execute(self, error_on_no_device: bool = False) -> None:
-        """
-        Discovers the connected devices and saves them internally.
-        """
-        if not self._communicator.opened():
-            self._communicator.open()
-
-        # Define the commands and device types in a list of tuples for iteration
-        commands_and_types = [('ccd_discover', 'ccd_list', 'CCD'), ('mono_discover', 'mono_list', 'Monochromator')]
-
-        for discover_command, list_command, device_type in commands_and_types:
-            response: Response = self._communicator.request_with_response(Command(discover_command, {}))
-            if response.results.get('count', 0) == 0 and error_on_no_device:
-                raise Exception(f'No {device_type} connected')
-            response = self._communicator.request_with_response(Command(list_command, {}))
-
-            for device in response.results['devices']:
-                if device_type == 'CCD':
-                    ccd = ChargeCoupledDevice(device['index'], self._communicator, self._error_db)
-                    logger.info(f'Detected CCD: {device["deviceType"]}')
-                    self._charge_coupled_devices.append(ccd)
-                elif device_type == 'Monochromator':
-                    mono = Monochromator(device['index'], self._communicator, self._error_db)
-                    logger.info(f'Detected Monochromator: {device["deviceType"]}')
-                    self._monochromators.append(mono)
-
-        logger.info(f'Found {len(self._monochromators)} Monochromator devices')
-        logger.info(f'Found {len(self._charge_coupled_devices)} CCD devices')
-
-    @override
-    def charge_coupled_devices(self) -> list[ChargeCoupledDevice]:
-        return self._charge_coupled_devices
-
-    @override
-    def monochromators(self) -> list[Monochromator]:
-        return self._monochromators