horiba-sdk 0.5.4__tar.gz → 0.7.0__tar.gz

{horiba_sdk-0.5.4 → horiba_sdk-0.7.0}/PKG-INFO

@@ -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.5.4 → horiba_sdk-0.7.0}/horiba_sdk/communication/messages.py

@@ -1,6 +1,6 @@
 import json
 from itertools import count
-from typing import Any, Dict, List, Optional, final
+from typing import Any, Optional, Union, final
 
 
 class Command:
@@ -21,7 +21,7 @@ class Command:
 
     _id_counter = count(start=1)  # Starts counting from 1
 
-    def __init__(self, command: str, parameters: Dict[str, Any]):
+    def __init__(self, command: str, parameters: dict[str, Any]):
         self.id = next(self._id_counter)  # Automatically assigns the next unique ID
         self.command = command
         self.parameters = parameters
@@ -43,7 +43,11 @@ class Response:
     """
 
     def __init__(
-        self, id: int, command: str, results: Optional[Dict[str, Any]] = None, errors: Optional[List[str]] = None
+        self,
+        id: int,
+        command: str,
+        results: Optional[Union[dict[str, Any], Any]] = None,
+        errors: Optional[list[str]] = None,
     ):
         self.id = id
         self.command = command

{horiba_sdk-0.5.4 → horiba_sdk-0.7.0}/horiba_sdk/communication/websocket_communicator.py

@@ -63,7 +63,7 @@ class WebsocketCommunicator(AbstractCommunicator):
             raise CommunicationException(None, 'websocket already opened')
 
         try:
-            self.websocket = await websockets.connect(self.uri)
+            self.websocket = await websockets.connect(self.uri, max_size=None)  # type: ignore
             # self.flush_incoming_messages(self)  # Flush any incoming messages (if any
 
         except websockets.WebSocketException as e:

{horiba_sdk-0.5.4 → horiba_sdk-0.7.0}/horiba_sdk/core/acquisition_format.py

@@ -14,7 +14,6 @@ class AcquisitionFormat(Enum):
 
     """
 
-    SPECTRA = 0
-    IMAGE = 1
+    SPECTRA_IMAGE = 1
     CROP = 2
     FAST_KINETICS = 3

horiba_sdk-0.7.0/horiba_sdk/core/stitching/__init__.py

@@ -0,0 +1,6 @@
+from .linear_spectra_stitch import LinearSpectraStitch
+from .simple_cut_spectra_stitch import SimpleCutSpectraStitch
+from .spectra_stitch import SpectraStitch
+from .y_displacement_spectra_stitch import YDisplacementSpectraStitch
+
+__all__ = ['LinearSpectraStitch', 'SimpleCutSpectraStitch', 'YDisplacementSpectraStitch', 'SpectraStitch']

horiba_sdk-0.7.0/horiba_sdk/core/stitching/labspec6_spectra_stitch.py

@@ -0,0 +1,90 @@
+from typing import Any, List
+
+from loguru import logger
+from numpy import array, concatenate, dtype, ndarray
+from overrides import override
+
+from horiba_sdk.core.stitching.spectra_stitch import SpectraStitch
+
+
+class LabSpec6SpectraStitch(SpectraStitch):
+    """Stitches a list of spectra using a weighted average as in LabSpec6"""
+
+    def __init__(self, spectra_list: List[List[List[float]]]) -> None:
+        """Constructs a linear stitch of spectra.
+
+        .. warning:: The spectra in the list must overlap
+
+        Parameters
+            spectra_list : List[List[List[float]]] List of spectra to stitch in the form [[x1_values, y1_values],
+            [x2_values, y2_values], etc].
+        """
+        stitched_spectrum = spectra_list[0]
+
+        for i in range(1, len(spectra_list)):
+            stitched_spectrum = self._stitch_spectra(stitched_spectrum, spectra_list[i])
+
+        self._stitched_spectrum: List[List[float]] = stitched_spectrum
+
+    @override
+    def stitch_with(self, other_stitch: SpectraStitch) -> SpectraStitch:
+        """Stitches this stitch with another stitch.
+
+        Parameters
+            other_stitch : SpectraStitch The other stitch to stitch with
+
+        Returns:
+            SpectraStitch: The stitched spectra.
+        """
+        new_stitch = LabSpec6SpectraStitch([self.stitched_spectra(), other_stitch.stitched_spectra()])
+        return new_stitch
+
+    @override
+    def stitched_spectra(self) -> Any:
+        """Returns the raw data of the stitched spectra.
+
+        Returns:
+            Any: The stitched spectra.
+        """
+        return self._stitched_spectrum
+
+    def _stitch_spectra(self, spectrum1: List[List[float]], spectrum2: List[List[float]]) -> List[List[float]]:
+        fx1, fy1 = spectrum1
+        fx2, fy2 = spectrum2
+
+        x1: ndarray[Any, dtype[Any]] = array(fx1)
+        x2: ndarray[Any, dtype[Any]] = array(fx2)
+        y1: ndarray[Any, dtype[Any]] = array(fy1)
+        y2: ndarray[Any, dtype[Any]] = array(fy2)
+
+        overlap_start = max(x1[0], x2[0])
+        overlap_end = min(x1[-1], x2[-1])
+
+        if overlap_start >= overlap_end:
+            logger.error(f'No overlap between two spectra: {spectrum1}, {spectrum2}')
+            raise Exception('No overlapping region between spectra')
+
+        mask1 = (x1 >= overlap_start) & (x1 <= overlap_end)
+        mask2 = (x2 >= overlap_start) & (x2 <= overlap_end)
+
+        x1_overlap = x1[mask1]
+        y1_overlap = y1[mask1]
+
+        x2_overlap = x2[mask2]
+        y2_overlap = y2[mask2]
+
+        A = (x1_overlap - overlap_start) / (overlap_end - overlap_start)
+        B = (overlap_end - x2_overlap) / (overlap_end - overlap_start)
+
+        y_stitched = (y1_overlap * A + y2_overlap * B) / (A + B)
+
+        x_before = x1[x1 < overlap_start]
+        y_before = y1[x1 < overlap_start]
+
+        x_after = x2[x2 > overlap_end]
+        y_after = y2[x2 > overlap_end]
+
+        x_stitched = concatenate([x_before, x1_overlap, x_after])
+        y_stitched_final = concatenate([y_before, y_stitched, y_after])
+
+        return [x_stitched.tolist(), y_stitched_final.tolist()]

horiba_sdk-0.7.0/horiba_sdk/core/stitching/linear_spectra_stitch.py

@@ -0,0 +1,107 @@
+from typing import Any
+
+from loguru import logger
+from numpy import argsort, array, concatenate, dtype, interp, ndarray
+from overrides import override
+
+from horiba_sdk.core.stitching.spectra_stitch import SpectraStitch
+
+
+class LinearSpectraStitch(SpectraStitch):
+    """Stitches a list of spectra using a linear model"""
+
+    def __init__(self, spectra_list: list[list[list[float]]]) -> None:
+        """Constructs a linear stitch of spectra.
+
+        .. warning:: The spectra in the list must overlap
+
+        Parameters
+            spectra_list : List[List[List[float]]] List of spectra to stitch in the form [[x1_values, y1_values],
+            [x2_values, y2_values], etc].
+        """
+        stitched_spectrum = spectra_list[0]
+
+        for i in range(1, len(spectra_list)):
+            stitched_spectrum = self._stitch_spectra(stitched_spectrum, spectra_list[i])
+
+        self._stitched_spectrum: list[list[float]] = stitched_spectrum
+
+    @override
+    def stitch_with(self, other_stitch: SpectraStitch) -> SpectraStitch:
+        """Stitches this stitch with another stitch.
+
+        Parameters
+            other_stitch : SpectraStitch The other stitch to stitch with
+
+        Returns:
+            SpectraStitch: The stitched spectra.
+        """
+        new_stitch = LinearSpectraStitch([self.stitched_spectra(), other_stitch.stitched_spectra()])
+        return new_stitch
+
+    @override
+    def stitched_spectra(self) -> Any:
+        """Returns the raw data of the stitched spectra.
+
+        Returns:
+            Any: The stitched spectra.
+        """
+        return self._stitched_spectrum
+
+    def _stitch_spectra(self, spectrum1: list[list[float]], spectrum2: list[list[float]]) -> list[list[float]]:
+        fx1 = spectrum1[0]
+        fy1 = spectrum1[1][0]
+        fx2 = spectrum2[0]
+        fy2 = spectrum2[1][0]
+
+        # Convert to numpy arrays
+        x1: ndarray[Any, dtype[Any]] = array(fx1)
+        x2: ndarray[Any, dtype[Any]] = array(fx2)
+        y1: ndarray[Any, dtype[Any]] = array(fy1)
+        y2: ndarray[Any, dtype[Any]] = array(fy2)
+
+        # Sort spectra while maintaining x-y correspondence
+        sort1 = argsort(x1)
+        sort2 = argsort(x2)
+
+        # Create sorted views of both arrays
+        x1_sorted = x1[sort1]
+        y1_sorted = y1[sort1]
+        x2_sorted = x2[sort2]
+        y2_sorted = y2[sort2]
+
+        # Calculate true overlap region
+        x1_min, x1_max = x1_sorted[0], x1_sorted[-1]
+        x2_min, x2_max = x2_sorted[0], x2_sorted[-1]
+
+        overlap_start = max(x1_min, x2_min)
+        overlap_end = min(x1_max, x2_max)
+
+        logger.debug(f'Spectrum 1 range: {x1_min} to {x1_max}')
+        logger.debug(f'Spectrum 2 range: {x2_min} to {x2_max}')
+        logger.debug(f'Overlap region: {overlap_start} to {overlap_end}')
+
+        if overlap_start >= overlap_end:
+            logger.error(f'No overlap between spectra: [{x1_min}, {x1_max}] and [{x2_min}, {x2_max}]')
+            raise Exception('No overlapping region between spectra')
+
+        # Create masks for overlapping regions using sorted arrays
+        mask1 = (x1_sorted >= overlap_start) & (x1_sorted <= overlap_end)
+        mask2 = (x2_sorted >= overlap_start) & (x2_sorted <= overlap_end)
+
+        # Interpolate second spectrum onto first spectrum's x points in overlap region
+        y2_interp = interp(x1_sorted[mask1], x2_sorted[mask2], y2_sorted[mask2])
+
+        # Average the overlapping region
+        y_combined_overlap = (y1_sorted[mask1] + y2_interp) / 2
+
+        # Combine non-overlapping and overlapping regions
+        x_combined = concatenate((x1_sorted[~mask1], x1_sorted[mask1], x2_sorted[~mask2]))
+        y_combined = concatenate((y1_sorted[~mask1], y_combined_overlap, y2_sorted[~mask2]))
+
+        # Ensure final result is sorted
+        sort_indices = argsort(x_combined)
+        x_combined = x_combined[sort_indices]
+        y_combined = y_combined[sort_indices]
+
+        return [x_combined.tolist(), [y_combined.tolist()]]

horiba_sdk-0.7.0/horiba_sdk/core/stitching/simple_cut_spectra_stitch.py

@@ -0,0 +1,84 @@
+from typing import Any, List
+
+from loguru import logger
+from numpy import array, concatenate, dtype, ndarray
+from overrides import override
+
+from horiba_sdk.core.stitching.spectra_stitch import SpectraStitch
+
+
+class SimpleCutSpectraStitch(SpectraStitch):
+    """Stitches a list of spectra by always keeping the values from the next spectrum in the overlap region.
+
+    .. warning:: Produces a stitched spectrum with stairs
+    """
+
+    def __init__(self, spectra_list: List[List[List[float]]]) -> None:
+        """Constructs a linear stitch of spectra.
+
+        .. warning:: The spectra in the list must overlap
+
+        Parameters
+            spectra_list : List[List[List[float]]] List of spectra to stitch in the form [[x1_values, y1_values],
+            [x2_values, y2_values], etc].
+        """
+        stitched_spectrum = spectra_list[0]
+
+        for i in range(1, len(spectra_list)):
+            stitched_spectrum = self._stitch_spectra(stitched_spectrum, spectra_list[i])
+
+        self._stitched_spectrum: List[List[float]] = stitched_spectrum
+
+    @override
+    def stitch_with(self, other_stitch: SpectraStitch) -> SpectraStitch:
+        """Stitches this stitch with another stitch.
+
+        Parameters
+            other_stitch : SpectraStitch The other stitch to stitch with
+
+        Returns:
+            SpectraStitch: The stitched spectra.
+        """
+        new_stitch = SimpleCutSpectraStitch([self.stitched_spectra(), other_stitch.stitched_spectra()])
+        return new_stitch
+
+    @override
+    def stitched_spectra(self) -> Any:
+        """Returns the raw data of the stitched spectra.
+
+        Returns:
+            Any: The stitched spectra.
+        """
+        return self._stitched_spectrum
+
+    def _stitch_spectra(self, spectrum1: List[List[float]], spectrum2: List[List[float]]) -> List[List[float]]:
+        fx1, fy1 = spectrum1
+        fx2, fy2 = spectrum2
+
+        x1: ndarray[Any, dtype[Any]] = array(fx1)
+        x2: ndarray[Any, dtype[Any]] = array(fx2)
+        y1: ndarray[Any, dtype[Any]] = array(fy1)
+        y2: ndarray[Any, dtype[Any]] = array(fy2)
+
+        overlap_start = max(x1[0], x2[0])
+        overlap_end = min(x1[-1], x2[-1])
+
+        if overlap_start >= overlap_end:
+            logger.error(f'No overlap between two spectra: {spectrum1}, {spectrum2}')
+            raise Exception('No overlapping region between spectra')
+
+        mask2 = (x2 >= overlap_start) & (x2 <= overlap_end)
+
+        x2_overlap = x2[mask2]
+        y2_overlap = y2[mask2]
+
+        x1_before_overlap = x1[x1 < overlap_start]
+        y1_before_overlap = y1[x1 < overlap_start]
+
+        x2_after_overlap = x2[x2 > overlap_end]
+        y2_after_overlap = y2[x2 > overlap_end]
+
+        x_stitched = concatenate([x1_before_overlap, x2_overlap, x2_after_overlap])
+        y_stitched = concatenate([y1_before_overlap, y2_overlap, y2_after_overlap])
+
+        return [x_stitched.tolist(), y_stitched.tolist()]

horiba_sdk-0.7.0/horiba_sdk/core/stitching/spectra_stitch.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class SpectraStitch(ABC):
+    """Stitches multiple spectra into a single spectrum."""
+
+    @abstractmethod
+    def stitch_with(self, other_stitch: 'SpectraStitch') -> 'SpectraStitch':
+        """Stitches this stitch with another stitch."""
+        pass
+
+    @abstractmethod
+    def stitched_spectra(self) -> Any:
+        """Returns the raw data of the stitched spectra."""
+        pass

horiba_sdk-0.7.0/horiba_sdk/core/stitching/y_displacement_spectra_stitch.py

@@ -0,0 +1,87 @@
+from typing import Any, List
+
+from loguru import logger
+from numpy import array, concatenate, dtype, ndarray
+from overrides import override
+
+from horiba_sdk.core.stitching.spectra_stitch import SpectraStitch
+
+
+class YDisplacementSpectraStitch(SpectraStitch):
+    """Stiches a list of spectra using a linear model"""
+
+    def __init__(self, spectrum1: List[List[float]], spectrum2: List[List[float]], y_displacement_count: int) -> None:
+        """Constructs a linear stitch of spectra.
+
+        .. warning:: The spectra in the list must overlap
+
+        Parameters
+            spectra_list : List[List[List[float]]] List of spectra to stitch in the form [[x1_values, y1_values],
+            [x2_values, y2_values], etc].
+            y_displacement_count : int The amount of displacement in the y direction for the second spectrum
+        """
+        self._y_displacement_count = y_displacement_count
+        stitched_spectrum = self._stitch_spectra(spectrum1, spectrum2)
+
+        self._stitched_spectrum: List[List[float]] = stitched_spectrum
+
+    @override
+    def stitch_with(self, other_stitch: SpectraStitch) -> SpectraStitch:
+        """Stitches this stitch with another stitch.
+
+        Parameters
+            other_stitch : SpectraStitch The other stitch to stitch with
+
+        Returns:
+            SpectraStitch: The stitched spectra.
+        """
+        new_stitch = YDisplacementSpectraStitch([self.stitched_spectra(), other_stitch.stitched_spectra()])
+        return new_stitch
+
+    @override
+    def stitched_spectra(self) -> Any:
+        """Returns the raw data of the stitched spectra.
+
+        Returns:
+            Any: The stitched spectra.
+        """
+        return self._stitched_spectrum
+
+    def _stitch_spectra(self, spectrum1: List[List[float]], spectrum2: List[List[float]]) -> List[List[float]]:
+        fx1, fy1 = spectrum1
+        fx2, fy2 = spectrum2
+
+        x1: ndarray[Any, dtype[Any]] = array(fx1)
+        x2: ndarray[Any, dtype[Any]] = array(fx2)
+        y1: ndarray[Any, dtype[Any]] = array(fy1)
+        y2: ndarray[Any, dtype[Any]] = array(fy2)
+
+        overlap_start = max(x1[0], x2[0])
+        overlap_end = min(x1[-1], x2[-1])
+
+        if overlap_start >= overlap_end:
+            logger.error(f'No overlap between two spectra: {spectrum1}, {spectrum2}')
+            raise Exception('No overlapping region between spectra')
+
+        # Masks for overlapping region
+        mask1 = (x1 >= overlap_start) & (x1 <= overlap_end)
+        mask2 = (x2 >= overlap_start) & (x2 <= overlap_end)
+
+        x1_overlap = x1[mask1]
+        y1_overlap = y1[mask1]
+
+        y2_displaced = y2 + self._y_displacement_count
+        y2_overlap = y2_displaced[mask2]
+
+        y_stitched_overlap = (y1_overlap + y2_overlap) / 2
+
+        x1_before_overlap = x1[x1 < overlap_start]
+        y1_before_overlap = y1[x1 < overlap_start]
+
+        x2_after_overlap = x2[x2 > overlap_end]
+        y2_after_overlap = y2_displaced[x2 > overlap_end]
+
+        x_stitched = concatenate([x1_before_overlap, x1_overlap, x2_after_overlap])
+        y_stitched = concatenate([y1_before_overlap, y_stitched_overlap, y2_after_overlap])
+
+        return [x_stitched.tolist(), y_stitched.tolist()]

horiba_sdk-0.7.0/horiba_sdk/core/trigger_input_polarity.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class TriggerInputPolarity(Enum):
+    ACTIVE_LOW = 0
+    ACTIVE_HIGH = 1

{horiba_sdk-0.5.4 → horiba_sdk-0.7.0}/horiba_sdk/devices/device_manager.py

@@ -50,7 +50,8 @@ from horiba_sdk.communication import (
 from horiba_sdk.devices import AbstractDeviceManager
 from horiba_sdk.devices.ccd_discovery import ChargeCoupledDevicesDiscovery
 from horiba_sdk.devices.monochromator_discovery import MonochromatorsDiscovery
-from horiba_sdk.devices.single_devices import ChargeCoupledDevice, Monochromator
+from horiba_sdk.devices.single_devices import ChargeCoupledDevice, Monochromator, SpectrAcq3
+from horiba_sdk.devices.spectracq3_discovery import SpectrAcq3Discovery
 from horiba_sdk.icl_error import AbstractError, AbstractErrorDB, ICLErrorDB
 
 
@@ -66,7 +67,7 @@ class DeviceManager(AbstractDeviceManager):
         icl_ip: str = '127.0.0.1',
         icl_port: str = '25010',
         enable_binary_messages: bool = True,
-        enable_logging: bool = False
+        enable_logging: bool = False,
     ):
         """
         Initializes the DeviceManager with the specified communicator class.
@@ -81,7 +82,7 @@ class DeviceManager(AbstractDeviceManager):
         # By default, logging is disabled for a library, so if desired it can be enabled
         root_name_space: str = __name__.split('.')[0]
         if enable_logging:
-            logger.info(f"Initializing logger for namespace: {root_name_space}")
+            logger.info(f'Initializing logger for namespace: {root_name_space}')
             logger.enable(root_name_space)
         else:
             logger.disable(root_name_space)
@@ -95,6 +96,7 @@ class DeviceManager(AbstractDeviceManager):
         self._binary_messages: bool = enable_binary_messages
         self._charge_coupled_devices: list[ChargeCoupledDevice] = []
         self._monochromators: list[Monochromator] = []
+        self._spectracq3_devices: list[SpectrAcq3] = []
 
         error_list_path: Path = Path(str(importlib.resources.files('horiba_sdk.icl_error') / 'error_list.json'))
         self._icl_error_db: AbstractErrorDB = ICLErrorDB(error_list_path)
@@ -230,6 +232,10 @@ class DeviceManager(AbstractDeviceManager):
         await monochromators_discovery.execute(error_on_no_device)
         self._monochromators = monochromators_discovery.monochromators()
 
+        spectracq3_discovery: SpectrAcq3Discovery = SpectrAcq3Discovery(self._icl_communicator, self._icl_error_db)
+        await spectracq3_discovery.execute(error_on_no_device)
+        self._spectracq3_devices = spectracq3_discovery.spectracq3_devices()
+
     @property
     @override
     def communicator(self) -> AbstractCommunicator:
@@ -262,3 +268,13 @@ class DeviceManager(AbstractDeviceManager):
             List[ChargeCoupledDevice]: The detected CCDS.
         """
         return self._charge_coupled_devices
+
+    @property
+    def spectracq3_devices(self) -> list[SpectrAcq3]:
+        """
+        The detected SpectrAcq3 devices, should be called after :meth:`discover_devices`
+
+        Returns:
+            List[SpectrAcq3]: The detected SpectrAcq3 devices.
+        """
+        return self._spectracq3_devices

{horiba_sdk-0.5.4 → horiba_sdk-0.7.0}/horiba_sdk/devices/fake_icl_server.py

@@ -26,6 +26,10 @@ class FakeICLServer:
         with open(ccd_fake_responses_path) as json_file:
             self.ccd_responses = json.load(json_file)
 
+        spectracq3_fake_responses_path = os.path.join(fake_responses_path, 'spectracq3.json')
+        with open(spectracq3_fake_responses_path) as json_file:
+            self.spectracq3_responses = json.load(json_file)
+
     async def echo(self, websocket):
         async for message in websocket:
             logger.info('received: {message}', message=message)
@@ -43,6 +47,9 @@ class FakeICLServer:
             elif command['command'].startswith('ccd_'):
                 response = json.dumps(self.ccd_responses[command['command']])
                 await websocket.send(response)
+            elif command['command'].startswith('saq3_'):
+                response = json.dumps(self.spectracq3_responses[command['command']])
+                await websocket.send(response)
             else:
                 logger.info('unknown command, responding with message')
                 await websocket.send(message)