pymodaq_plugins_oceaninsight 5.3.0__py3-none-any.whl

pymodaq_plugins_oceaninsight/__init__.py

@@ -0,0 +1,12 @@
+from pymodaq_utils.utils import get_version, PackageNotFoundError
+from pathlib import Path
+from pymodaq.utils.logger import set_logger  # to be imported by other modules.
+
+from .utils import Config
+config = Config()
+
+
+try:
+    __version__ = get_version(__package__)
+except PackageNotFoundError:
+    __version__ = '0.0.0dev'

pymodaq_plugins_oceaninsight/daq_move_plugins/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from .. import set_logger
+logger = set_logger('move_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight/daq_viewer_plugins/__init__.py

@@ -0,0 +1,3 @@
+
+
+

pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_0D/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer0D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer1D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/daq_1Dviewer_Omnidriver.py

@@ -0,0 +1,177 @@
+from qtpy import QtWidgets
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+
+import numpy as np
+from collections import OrderedDict
+from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
+from pymodaq.utils.data import DataFromPlugins, Axis, DataToExport
+import sys
+import clr
+from easydict import EasyDict as edict
+
+from pymodaq_plugins_oceaninsight.utils import Config
+
+plugin_config = Config()
+
+omnidriver_path = plugin_config('omnidriver_path')
+try:
+    sys.path.append(omnidriver_path)
+    clr.AddReference("NETOmniDriver-NET40")
+    import OmniDriver as omnidriver
+
+except:
+    omnidriver = None
+
+
+class DAQ_1DViewer_Omnidriver(DAQ_Viewer_base):
+    """PyMoDAQ plugin controlling spectrometers from OceanOptics and using their OmniDriver wrapper ('NETOmniDriver-NET40')
+    The wrapper is interfaced using the clr package and then importing Omnidriver as a standart python package
+    https://oceanoptics.com/api/omnidriver/index.html?overview-summary.html
+
+    The plugin enables the discovery of any connected usb spectrometers and can control them in parallel. It extracts the
+    calibrated wavelength and will export datas that will be plotted with respect to this wavelengths vector.
+
+    Used methods from the wrapper:
+    ------------------------------
+     setIntegrationTime
+     getIntegrationTime
+
+    See Also
+    --------
+    utility_classes.DAQ_Viewer_base
+    """
+
+    params = comon_parameters + [
+        {'title': 'N spectrometers:', 'name': 'Nspectrometers', 'type': 'int', 'value': 0,
+         'default': 0, 'min': 0, 'readonly': True},
+        {'title': 'Spectrometers:', 'name': 'spectrometers', 'type': 'group', 'children': []},
+        ]
+
+    hardware_averaging = True
+
+    def ini_attributes(self):
+
+        self.controller: omnidriver.NETWrapper = None
+        self.spectro_names = [] #contains the spectro name as returned from the wrapper
+        self.spectro_id = [] # contains the spectro id as set by the ini_detector method and equal to the Parameter name
+
+
+    def commit_settings(self, param):
+        """
+        """
+        if param.name() == 'exposure_time':
+            ind_spectro = self.spectro_id.index(param.parent().name())
+            self.controller.setIntegrationTime(ind_spectro, param.value() * 1000)
+
+            param.setValue(self.controller.getIntegrationTime(ind_spectro) / 1000)
+
+    def ini_detector(self, controller=None):
+        """
+            Initialisation procedure of the detector updating the status dictionnary.
+
+            See Also
+            --------
+            set_Mock_data, daq_utils.ThreadCommand
+        """
+        self.ini_detector_init(controller, None)
+
+        if self.is_master:
+            self.controller = omnidriver.NETWrapper()
+
+            N = self.controller.openAllSpectrometers()
+            self.settings.child('Nspectrometers').setValue(N)
+            self.spectro_names = []
+            self.spectro_id = []
+
+            data_init = DataToExport('Spectro')
+
+            for ind_spectro in range(N):
+                name = self.controller.getName(ind_spectro)
+                self.spectro_names.append(name)
+                self.spectro_id.append('spectro{:d}'.format(ind_spectro))
+
+                exp_max = self.controller.getMaximumIntegrationTime(ind_spectro)
+                exp_min = self.controller.getMinimumIntegrationTime(ind_spectro)
+                exp = self.controller.getIntegrationTime(ind_spectro) / 1000
+                wavelengths = self.get_xaxis(ind_spectro)
+
+                data_init.append(DataFromPlugins(name=name, data=[np.zeros_like(wavelengths)],
+                                                 dim='Data1D',
+                                                 x_axis=Axis(data=wavelengths, label='Wavelength',
+                                                             units='nm')))
+
+                for ind in range(2): #this is to take into account that adding it once doen't work (see pyqtgraph Parameter...)
+                    try:
+                        self.settings.child('spectrometers').addChild(
+                            {'title': name,'name': 'spectro{:d}'.format(ind_spectro),
+                             'type': 'group', 'children':[
+                                {'title': 'grab spectrum:','name': 'grab', 'type': 'bool',
+                                 'value': True},
+                            {'title': 'Exposure time (ms):','name': 'exposure_time', 'type': 'int',
+                             'value': int(exp), 'min': int(exp_min/1000), 'max': int(exp_max/1000)},
+
+                            ]
+                             })
+                    except:
+                        pass
+
+                QtWidgets.QApplication.processEvents()
+
+            #init viewers
+
+            if N == 0:
+                raise Exception('No detected hardware')
+            self.dte_signal_temp.emit(data_init)
+
+        initialized = True
+        info = 'Ocean Insight Spectrometers initialized'
+        return info, initialized
+
+    def get_xaxis(self, ind_spectro):
+        wavelengths_chelou = self.controller.getWavelengths(ind_spectro)
+        wavelengths = np.array([wavelengths_chelou[ind] for ind in range(len(wavelengths_chelou))])
+
+        return wavelengths
+
+    def close(self):
+        """
+        """
+        if self.controller is not None:
+            self.controller.closeAllSpectrometers()
+
+    def grab_data(self, Naverage=1, **kwargs):
+        """
+
+        """
+        try:
+            dte = DataToExport('Spectro')
+            for ind_spectro in range(len(self.spectro_names)):
+                if self.settings.child('spectrometers', 'spectro{:d}'.format(ind_spectro), 'grab').value():
+                    self.controller.setScansToAverage(ind_spectro, Naverage)
+                    data_chelou = self.controller.getSpectrum(ind_spectro)
+                    data_array = np.array([data_chelou[ind] for ind in range(len(data_chelou))])
+                    dte.append(
+                      DataFromPlugins(name=self.spectro_names[ind_spectro],
+                                      data=[data_array], dim='Data1D',
+                                      axes=[Axis('wavelength',
+                                                 units='m',
+                                                 data=self.get_xaxis(ind_spectro)
+                                                      * 1e-9)]))
+                    QtWidgets.QApplication.processEvents()
+
+            self.dte_signal.emit(dte)
+
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), "log"]))
+
+    def stop(self):
+        """
+
+        """
+        for ind_spec, name in enumerate(self.spectro_names):
+            self.controller.stopAveraging(ind_spec)
+
+
+if __name__ == '__main__':
+    main(__file__, init=False)

pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/daq_1Dviewer_Seabreeze.py

@@ -0,0 +1,164 @@
+import numpy as np
+from easydict import EasyDict as edict
+from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
+from pymodaq.utils.data import DataFromPlugins, Axis, DataToExport
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+from timeit import timeit
+
+# explicitly request cseabreeze
+import seabreeze
+seabreeze.use('cseabreeze')
+from seabreeze.spectrometers import Spectrometer, list_devices
+
+
+class DAQ_1DViewer_Seabreeze(DAQ_Viewer_base):
+    """PyMoDAQ 1DViewer class for devices supported by the Seabreeze library."""
+
+    # Upon initialisation
+    devices = list_devices()
+
+    # Supports pseudo hardware-averaging
+    hardware_averaging = True
+
+    # Adjustable parameters
+    params = comon_parameters + [
+        {'title': 'Device:', 'name': 'device', 'type': 'list', 'limits': devices},
+        {'title': 'Integration (ms):', 'name': 'integration', 'type': 'float', 'value': 1.0},
+        {'title': 'Advanced:', 'name': 'advanced', 'type': 'group', 'children': [
+            {'title': 'Serial Number:', 'name': 'serial_number', 'type': 'str', 'value': "", 'readonly': True},
+            {'title': 'Non Linearity correction:', 'name': 'correct_non_linearity', 'type': 'bool', 'value': False},
+            {'title': 'Max Intensity', 'name': 'max_intensity', 'type': "float", 'value': 65535, 'readonly': True},
+            {'title': 'Pixels:', 'name': 'pixels', 'type': 'int', 'value': 2048, 'readonly': True},
+            {'title': 'Dark Channels:', 'name': 'dark_channels', 'type': 'str', 'value': '', 'readonly': True},
+            {'title': 'Readout Time (ms)', 'name': 'readout_time', 'type': 'float', 'value': 666, 'readonly': True},
+        ]}
+    ]
+
+    def ini_attributes(self):
+        self.controller: Spectrometer = None
+
+    def commit_settings(self, param):
+        """
+        """
+        if param.name() == "integration":
+            self.controller.integration_time_micros(param.value() * 1000)
+            # There is no way to get feedback from the spectrometer on the currently set integration time
+        # elif ...
+        ##
+
+    def ini_detector(self, controller=None):
+        """Detector communication initialization
+
+        Parameters
+        ----------
+        controller: (object) custom object of a PyMoDAQ plugin (Slave case). None if only one detector by controller (Master case)
+
+        Returns
+        -------
+        self.status (edict): with initialization status: three fields:
+            * info (str)
+            * controller (object) initialized controller
+            *initialized: (bool): False if initialization failed otherwise True
+        """
+        if self.is_master:
+            # From what I understand this will just get the spectro currently selected in the list
+            dvc = self.settings['device']
+            self.controller = Spectrometer(dvc)
+            #self.controller.open()
+
+        else:
+            self.controller = controller
+
+        # Oceanoptics spectrometers (at least the ones i Know) have fixed axis
+        # get index of inactive pixels
+        dark_indices = self.controller.f.spectrometer.get_electric_dark_pixel_indices()
+        self.settings.child('advanced').child('dark_channels').setValue(", ".join([str(x) for x in dark_indices]))
+        # get the x_axis
+        data_x_axis = self.controller.wavelengths()  # Way to get the x axis
+        # keep range without dark pixels
+        x_indices = np.arange(data_x_axis.shape[0])
+        self.valid_range = np.setdiff1d(x_indices, dark_indices)
+        data_x_axis = data_x_axis[self.valid_range]
+        # generate PyMoDAQ axis
+        self.x_axis = Axis(data=data_x_axis * 1e-9, label='wavelength', units='m', index=0)
+
+        # Get the name
+        specname = f"Ocean Insight {self.controller.model}"
+
+        # initialize viewers pannel with the future type of data
+
+        self.data_grabed_signal_temp.emit([
+            DataFromPlugins(name=specname,
+                            data=[np.zeros_like(data_x_axis)],
+                            dim='Data1D',
+                            labels=['Intensity'],
+                            axes=[self.x_axis]), ])
+
+
+        # Update the parameters
+        # Here we need to do a few things. Get the integration time limits and set it in the settings
+        tlimits = np.array(self.controller.integration_time_micros_limits) / 1000
+        self.settings.child('integration').setLimits(tlimits)
+        # Here we need to update the advanced parameters
+        advanced_settings = self.settings.child('advanced')
+        sn = self.controller.serial_number
+        advanced_settings.child('serial_number').setValue(sn)
+        # non linearity coefficients
+        nlc_feat = self.controller.f.nonlinearity_coefficients
+        if nlc_feat is not None and not any(np.isnan(nlc_feat.get_nonlinearity_coefficients())):
+            advanced_settings.child('correct_non_linearity').setValue(True)
+        else:
+            advanced_settings.child('correct_non_linearity').setValue(False)
+            advanced_settings.child('correct_non_linearity').setOpts(enabled=False)
+
+        # measure the readout time
+        Nperf = 200
+        self.settings.child('integration').setValue(tlimits[0])  # Update the parameter value to the lower limit
+        self.controller.integration_time_micros(tlimits[0]*1000)  # Set the readout time to lower limit
+        perf = timeit(lambda: self.controller.intensities(), number=Nperf)  # time the execution of code in [s]
+        self.settings.child('advanced').child('readout_time').setValue(1000*perf/Nperf)  # set the settings
+
+        ##############################
+
+        info = f"Initialized {specname} spectrometer"
+        initialized = True
+        return info, initialized
+
+    def close(self):
+        """
+        Terminate the communication protocol
+        """
+        if self.controller is not None:
+            self.controller.close()
+
+    def grab_data(self, Naverage = 1, **kwargs):
+        """
+        Parameters
+        ----------
+        Naverage: (int) Number of hardware averaging
+        kwargs: (dict) of others optionals arguments
+        """
+        nlc = self.settings.child('advanced').child('correct_non_linearity').value()
+        #c0 = self.settings.child('advanced').child('dark_channels').value()
+
+        # synchrone version (blocking function)
+        # Pseudo-hardware-averaging
+        if Naverage > 1:
+            data = [self.controller.intensities(correct_nonlinearity=nlc)[self.valid_range]
+                    for i in range(Naverage)]
+            data = np.array(data)
+            data = data.mean(0)
+        # Otherwise normal single-acquisition
+        else:
+            data = self.controller.intensities(correct_nonlinearity=nlc)[self.valid_range]
+
+        self.dte_signal.emit(DataToExport('Spectro', data=[
+            DataFromPlugins(name='oceanseabreeze', data=[data], dim='Data1D',
+                            labels=['spectrum'], axes=[self.x_axis.copy()])]))
+
+    def stop(self):
+        pass
+
+
+if __name__ == '__main__':
+    main(__file__, init=False)

pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_2D/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer2D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+
+

pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_ND/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from pymodaq.utils.logger import set_logger
+logger = set_logger('viewerND_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight/resources/config_template.toml

@@ -0,0 +1,3 @@
+title = "this is the configuration file of the plugin OceanInsight"
+
+omnidriver_path = 'C:\\Program Files\\Ocean Optics\\OmniDriver\\OOI_HOME'

pymodaq_plugins_oceaninsight/utils.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 31/08/2023
+
+@author: Sebastien Weber
+"""
+from pathlib import Path
+
+from pymodaq.utils.config import BaseConfig, USER
+
+
+class Config(BaseConfig):
+    """Main class to deal with configuration values for this plugin"""
+    config_template_path = Path(__file__).parent.joinpath('resources/config_template.toml')
+    config_name = f"config_{__package__.split('pymodaq_plugins_')[1]}"

pymodaq_plugins_oceaninsight-5.3.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.5
+Name: pymodaq_plugins_oceaninsight
+Version: 5.3.0
+Summary: Set of PyMoDAQ plugins for OceanInsight (OceanOptics) spectrometers
+Project-URL: Homepage, https://pymodaq.cnrs.fr
+Project-URL: Documentation , https://pymodaq.cnrs.fr
+Project-URL: Repository , https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight
+Author-email: Sébastien Weber <sebastien.weber@cemes.fr>
+Maintainer-email: Sébastien Weber <sebastien.weber@cemes.fr>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.10
+Requires-Dist: pymodaq-data>=5.3.0
+Requires-Dist: pymodaq-gui>=5.3.0
+Requires-Dist: pymodaq-utils>=5.3.1
+Requires-Dist: pymodaq>=5.3.2
+Requires-Dist: pythonnet
+Requires-Dist: seabreeze
+Description-Content-Type: text/x-rst
+
+pymodaq_plugins_oceaninsight (Ocean Insight (Optics) Spectrometers)
+###################################################################
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_oceaninsight.svg
+   :target: https://pypi.org/project/pymodaq_plugins_oceaninsight/
+   :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
+   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
+   :alt: Documentation Status
+
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight/workflows/Upload%20Python%20Package/badge.svg
+    :target: https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight
+
+PyMoDAQ plugin for OceanInsight (OceanOptics) spectrometers
+
+
+Authors
+=======
+
+* Sebastien J. Weber
+* Nicolas Tappy
+* Arnaud Meyer
+
+Instruments
+===========
+Below is the list of instruments included in this plugin.
+Url: https://www.oceaninsight.com/products/spectrometers/
+
+Viewer1D
+++++++++
+
+* **Omnidriver**: Control of Spectrometer using the Omnidriver library (should be installed)
+* **Seabreeze** : If the Omnidriver library is not available, a plugin implementation based on seabreeze is provided: https://python-seabreeze.readthedocs.io/en/latest/index.html

pymodaq_plugins_oceaninsight-5.3.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+pymodaq_plugins_oceaninsight/__init__.py,sha256=eYXRGQL-ki6WZPuho77NZS1atZeiy6oC53wtVZeNiQo,324
+pymodaq_plugins_oceaninsight/utils.py,sha256=MWgdJVYqFcG2r7MeHRixkCQv4zi-_-zCbTBn6gRsMVE,419
+pymodaq_plugins_oceaninsight/daq_move_plugins/__init__.py,sha256=H-DnuGG6lezGyUjuhavlXRbzoQqzMbZaT3mfMNnAhHk,454
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_0D/__init__.py,sha256=ooWW3pJyqQ8lk_bgXe8RXvCZLzl41Cm5gJxwSc-vaCc,459
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/__init__.py,sha256=R2Z_g54zfMJ16Kj3dA7MRj3TF8rjK8lWVAqwJ_yPYTA,459
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/daq_1Dviewer_Omnidriver.py,sha256=BY8kGZaDwpZJFsHHl0FedIWpo6A4gS7MEU_ISyOVGHs,6849
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/daq_1Dviewer_Seabreeze.py,sha256=BrlmBAflRPNRPVjqvtjN7G1dgBihMoIsZoyJXCZ_yb4,7092
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_2D/__init__.py,sha256=U43pcyA6aNdltDFbW0TbxpQ2MWYJy3BW-dNucGTjoBc,460
+pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_ND/__init__.py,sha256=oM12KPv4VvQRB8hlLtB-Uff1FYxAgMzLzPq7yY0j2-s,476
+pymodaq_plugins_oceaninsight/hardware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_plugins_oceaninsight/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_plugins_oceaninsight/resources/config_template.toml,sha256=9mXHAdfSzhd-Asr3P_oCfWaLUNnl1K4msz5UMudhKJE,143
+pymodaq_plugins_oceaninsight-5.3.0.dist-info/METADATA,sha256=wOc65wnK2_lJy7KuKYoz508xNBwEAEyl-o72YNN0fMQ,3935
+pymodaq_plugins_oceaninsight-5.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pymodaq_plugins_oceaninsight-5.3.0.dist-info/entry_points.txt,sha256=NiMMYTem-oc0YMU6b9QMcZpWcK2Vbb7eSSNQeKjSBbE,129
+pymodaq_plugins_oceaninsight-5.3.0.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq_plugins_oceaninsight-5.3.0.dist-info/RECORD,,

pymodaq_plugins_oceaninsight-5.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pymodaq_plugins_oceaninsight-5.3.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[pymodaq.instruments]
+oceaninsight = pymodaq_plugins_oceaninsight
+
+[pymodaq.plugins]
+oceaninsight = pymodaq_plugins_oceaninsight

pymodaq_plugins_oceaninsight-5.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.