horiba-sdk 0.3.2__py3-none-any.whl

horiba_sdk/devices/fake_responses/monochromator.json

@@ -0,0 +1,187 @@
+{
+  "mono_discover": {
+    "id": 1234,
+    "command": "mono_discover",
+    "results": {
+      "count": 1
+
+    },
+    "errors": []
+  },
+  "mono_list": {
+    "id": 1234,
+    "command": "mono_list",
+    "results": {
+      "list": [
+        "0;iHR550;sn12345",
+        "1;iHR320;snabscde"
+      ]
+    },
+    "errors": []
+  },
+  "mono_listCount": {
+    "id": 1234,
+    "command": "mono_listCount",
+    "results": {
+      "count": 2
+    },
+    "errors": []
+  },
+  "mono_open": {
+    "id": 1234,
+    "command": "mono_open",
+    "errors": []
+  },
+  "mono_close": {
+    "id": 1234,
+    "command": "mono_close",
+    "errors": []
+  },
+  "mono_isOpen": {
+    "id": 1234,
+    "command": "mono_isOpen",
+    "results":{
+      "open": true
+    },
+    "errors": []
+  },
+  "mono_isBusy": {
+    "id": 1234,
+    "command": "mono_isBusy",
+    "results":{
+      "busy": false
+    },
+    "errors": []
+  },
+  "mono_init": {
+    "id": 1234,
+    "command": "mono_init",
+    "errors": []
+  },
+  "mono_getConfig": {
+    "id": 1234,
+    "command": "mono_getConfig",
+    "results":{
+    },
+    "errors": []
+
+  },
+  "mono_setConfig": {},
+  "mono_getPosition": {
+    "id": 1234,
+    "command": "mono_getPosition",
+    "results":{
+      "wavelength": 320.0
+    },
+    "errors": []
+  },
+  "mono_setPosition": {
+    "id": 1234,
+    "command": "mono_setPosition",
+    "errors": []
+  },
+  "mono_moveToPosition": {
+    "id": 1234,
+    "command": "mono_moveToPosition",
+    "errors": []
+  },
+  "mono_getGratingPosition": {
+    "id": 1234,
+    "command": "mono_getPosition",
+    "results":{
+      "position": 1
+    },
+    "errors": []
+  },
+  "mono_moveGrating": {
+    "id": 1234,
+    "command": "mono_getPosition",
+    "results":{
+      "position": 1
+    },
+    "errors": []
+  },
+  "mono_getFilterWheelPosition": {
+    "id": 1234,
+    "command": "mono_getFilterWheelPosition",
+    "results":{
+      "position": 0
+    },
+    "errors": []
+  },
+  "mono_moveFilterWheel": {
+    "id": 1234,
+    "command": "mono_moveFilterWheel",
+    "results":{
+    },
+    "errors": []
+  },
+  "mono_getMirrorPosition": {
+    "id": 1234,
+    "command": "mono_getMirrorPosition",
+    "results": {
+      "position": 0
+    },
+    "errors": []
+  },
+  "mono_moveMirror": {
+    "id": 1234,
+    "command": "mono_moveMirror",
+    "results": {},
+    "errors": []
+  },
+  "mono_getSlitPositionInMM": {
+    "id": 1234,
+    "command": "mono_getSlitPositionInMM",
+    "results": {
+      "position": 0
+    },
+    "errors": []
+  },
+  "mono_moveSlitMM": {
+    "id": 1234,
+    "command": "mono_moveSlitMM",
+    "results": {},
+    "errors": []
+  },
+  "mono_shutterOpen": {
+    "id": 1234,
+    "command": "mono_shutterOpen",
+    "results": {},
+    "errors": []
+  },
+  "mono_shutterClose": {
+    "id": 1234,
+    "command": "mono_shutterClose",
+    "results": {},
+    "errors": []
+  },
+  "mono_getShutterStatus": {
+    "id": 1234,
+    "command": "mono_getShutterStatus",
+    "results": {
+      "position": 0
+    },
+    "errors": []
+  },
+  "mono_getSlitStepPosition": {
+    "command": "mono_getSlitStepPosition",
+    "id": 1234,
+    "results": {
+      "position":0
+    },
+    "errors":[]
+  },
+  "mono_moveSlit": {
+    "id": 1234,
+    "command": "mono_moveSlit",
+    "results": {},
+    "errors": []
+  },
+  "mono_enableLaser": {},
+  "mono_getLaserStatus": {},
+  "mono_setLaserPower": {},
+  "mono_getLaserPower": {},
+  "mono_getLidStatus": {},
+  "mono_getSwitchStatus": {}
+}

horiba_sdk/devices/monochromator_discovery.py

@@ -0,0 +1,48 @@
+from typing import Any, final
+
+from loguru import logger
+from overrides import override
+
+from horiba_sdk.communication import AbstractCommunicator, Command, Response
+from horiba_sdk.devices.abstract_device_discovery import AbstractDeviceDiscovery
+from horiba_sdk.devices.single_devices import Monochromator
+from horiba_sdk.icl_error import AbstractErrorDB
+
+
+@final
+class MonochromatorsDiscovery(AbstractDeviceDiscovery):
+    def __init__(self, communicator: AbstractCommunicator, error_db: AbstractErrorDB):
+        self._communicator: AbstractCommunicator = communicator
+        self._monochromators: list[Monochromator] = []
+        self._error_db: AbstractErrorDB = error_db
+
+    @override
+    async def execute(self, error_on_no_device: bool = False) -> None:
+        """
+        Discovers the connected Monochromators and saves them internally.
+        """
+        if not self._communicator.opened():
+            await self._communicator.open()
+
+        response: Response = await self._communicator.request_with_response(Command('mono_discover', {}))
+        if response.results.get('count', 0) == 0 and error_on_no_device:
+            raise Exception('No Monochromators connected')
+
+        response = await self._communicator.request_with_response(Command('mono_list', {}))
+        raw_device_list = response.results['list']
+        self._monochromators = self._parse_monos(raw_device_list)
+        logger.info(f'Found {len(self._monochromators)} Monochromator devices: {self._monochromators}')
+
+    def _parse_monos(self, raw_device_list: dict[str, Any]) -> list[Monochromator]:
+        detected_monos = []
+        for device_string in raw_device_list:
+            mono_index: int = int(device_string.split(';')[0])
+            mono_type: str = device_string.split(';')[1]
+
+            logger.info(f'Detected Monochromator: {mono_type}')
+            detected_monos.append(Monochromator(mono_index, self._communicator, self._error_db))
+
+        return detected_monos
+
+    def monochromators(self) -> list[Monochromator]:
+        return self._monochromators

horiba_sdk/devices/single_devices/__init__.py

@@ -0,0 +1,5 @@
+from .abstract_device import AbstractDevice
+from .ccd import ChargeCoupledDevice
+from .monochromator import Monochromator
+
+__all__ = ['AbstractDevice', 'Monochromator', 'ChargeCoupledDevice']

horiba_sdk/devices/single_devices/abstract_device.py

@@ -0,0 +1,79 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from horiba_sdk.communication import AbstractCommunicator, Command, Response
+from horiba_sdk.icl_error import AbstractError, AbstractErrorDB
+
+
+class AbstractDevice(ABC):
+    """
+    Abstract base class representing a generic device.
+
+    This class provides an interface for device-specific operations. Concrete implementations should provide specific
+    functionalities for each of the abstract methods.
+
+    Attributes:
+        _id (int):
+        _communicator (WebsocketCommunicator):
+    """
+
+    def __init__(self, device_id: int, communicator: AbstractCommunicator, error_db: AbstractErrorDB) -> None:
+        self._id: int = device_id
+        self._error_db: AbstractErrorDB = error_db
+        self._communicator: AbstractCommunicator = communicator
+
+    @abstractmethod
+    async def open(self) -> None:
+        """
+        Open a connection to the device.
+
+        Returns:
+            Result: Result object indicating success or failure.
+        """
+        if not self._communicator.opened():
+            await self._communicator.open()
+
+    @abstractmethod
+    async def close(self) -> None:
+        """
+        Close the connection to the device.
+
+        Returns:
+            Result: Result object indicating success or failure.
+        """
+        pass
+
+    async def _execute_command(self, command_name: str, parameters: dict[Any, Any], timeout: int = 5) -> Response:
+        """
+        Creates a command from the command name, and it's parameters
+        Executes a command and handles the response.
+
+        Args:
+            command_name (str): The name of the command to execute.
+            parameters (dict): The parameters for the command.
+
+        Returns:
+            Response: The response from the device.
+
+        Raises:
+            Exception: When an error occurred on the device side.
+        """
+        response: Response = await self._communicator.request_with_response(
+            Command(command_name, parameters), timeout=timeout
+        )
+        if response.errors:
+            self._handle_errors(response.errors)
+        return response
+
+    def _handle_errors(self, errors: list[str]) -> None:
+        """
+        Handles errors, logs them, and may take corrective actions.
+
+        Args:
+            errors (Exception): The exception or error to handle.
+        """
+        for error in errors:
+            icl_error: AbstractError = self._error_db.error_from(error)
+            icl_error.log()
+            # TODO: [saga] only throw depending on the log level, tbd
+            raise Exception(f'Error from the ICL: {icl_error.message()}')