HDF5DataModel 0.2.3__py3-none-any.whl

HDF5DataModel/Model/attrsclasses.py

@@ -0,0 +1,96 @@
+from typing import List
+from dataclasses import dataclass, field
+from datetime import datetime
+import numpy as np
+
+
+@dataclass
+class AttrBase:
+    def to_params(self):
+        params = []
+        for key, value in self.__dict__.items():
+            if key == 'start_time':
+                dt = datetime.fromtimestamp(value)
+                params.append({'name': key, 'type': 'str', 'value': dt.strftime('%d/%m/%y %H:%M:%S.%f')})
+            else:
+                typ, value = self.get_type_and_cast(value)
+                # params.append({'name': key, 'type': 'strict', 'value': value, 'opts': {'type': typ}})  # TODO : comprendre le fonctionnement de ParameterItem et parameterTypes
+                params.append({'name': key, 'type': typ, 'value': value})
+        return params
+
+    def get_type_and_cast(self, variable):
+        if isinstance(variable, str):
+            return 'str', variable
+        elif isinstance(variable, (int, np.int32, np.int64)):
+            return 'int', int(variable)
+        elif isinstance(variable, (float, np.float32, np.float64)):
+            return 'float', float(variable)
+        elif isinstance(variable, list):
+            return 'list', variable
+        elif isinstance(variable, bool):
+            return 'bool', bool(variable)
+        else:
+            return 'str', str(variable)
+
+    def set_attrs_from_dict(self, attrs_dict):
+        for key, value in attrs_dict.items():
+            setattr(self, key, value)
+
+
+@dataclass
+class DatasetAttrs(AttrBase):
+    version: str = 'HDF5DataModel 1.0'
+    start_time: float = 0.
+    experimenter: str = ''
+    description: str = ''
+
+
+@dataclass
+class AcquisitionAtrrs(AttrBase):
+    start_time: float = 0.
+    sample: str = ''
+    environment: str = ''
+    description: str = ''
+
+
+@dataclass
+class AcqSigAttrs(AttrBase):
+    type: str = 'Acquisition attributes'
+    start_time: float = 0.
+    traces_number: int = 0
+    position_interval: float = 0
+    position_offset: float = 0
+    hardware: str = ''                                    # hardware used to acquire the trace
+
+
+@dataclass
+class GenSigAttrs(AttrBase):
+    type: str = 'Generation attributes'
+    points_number: int = 0
+    central_freq: int = 0
+    sampling_freq: int = 0
+    duration: float = 0
+    transducer: str = ''
+    hardware: str = ''
+    amplitude: float = 0
+    position_x: float = 0
+    position_y: float = 0
+    position_z: float = 0
+
+
+@dataclass
+class AcqTraceAttrs(AttrBase):
+    columns: List[str] = field(default_factory=list)    # list of column names
+    units: List[str] = field(default_factory=list)      # list of units for each column
+    start_time: float = 0                               # start time of the trace, timestamp in seconds
+    duration: float = 0                                 # duration of the trace, seconds
+    position_x: float = 0.                              # position of the trace, meters
+    position_y: float = 0.                              # position of the trace, meters
+    position_z: float = 0.                              # position of the trace, meters
+    points_number: int = 0                              # number of points in the trace
+    range: float = 0.                                   # range of the trace
+    sampling_freq: int = 0                              # sampling frequency of the trace, Hz
+    channel: int = 0                                    # acquisition channel of the trace
+    index: int = 0                                      # index of the trace in the acquisition signal
+    average_number: int = 0                             # number of averaging
+    pretrig_duration: float = 0.                        # time between first sample and trig, second

HDF5DataModel/Model/h5model.py

@@ -0,0 +1,39 @@
+import warnings
+from PySide6.QtCore import Signal, QObject
+from h5py import File
+from HDF5DataModel.Model.subclasses import Dataset
+from PySide6.QtWidgets import QWidget
+
+
+class H5DataModel(QObject):
+    modelUpdated = Signal()
+
+    def __init__(self, file_path=None):
+        super().__init__()
+        self.file_path = file_path
+        self.file = None   # ???
+        self.datasets = {}
+
+    def add_dataset(self, name):
+        self.datasets[name] = Dataset(name)
+        return self.datasets[name]
+
+    def to_hdf5_file(self):
+        with File(self.file_path, 'w') as f:
+            for name, dataset in self.datasets.items():
+                dataset.to_hdf5_file(f)
+
+    def get_datasets(self):
+        with File(self.file_path, 'r') as f:
+            for key in f.keys():
+                if f[key].attrs['version'][:-4] == 'HDF5DataModel':
+                    dataset = Dataset()
+                    dataset.from_h5(f, key)
+                    self.datasets[key] = dataset
+                else:
+                    warnings.warn('version not recognized')
+
+
+if __name__ == '__main__':
+    h5 = H5DataModel(r'C:\Users\devie\Documents\Programmes\HDF5DataModel\test.h5')
+    h5.get_datasets()

HDF5DataModel/Model/strict_parameter.py

@@ -0,0 +1,28 @@
+from pyqtgraph.parametertree import parameterTypes, ParameterItem
+from PySide6 import QtWidgets
+
+
+class StrictParameterItem(ParameterItem):
+    def __init__(self, param, depth):
+        super().__init__(param, depth)
+
+
+class StrictParameter(parameterTypes.SimpleParameter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(**kwargs)
+
+    def setValue(self, value, block_signal=None):
+        print(self.opts.get('type'), self.opts['type'])
+        if self.opts['type'] == int and not isinstance(value, int):
+            raise ValueError(f"Invalid value type: expected int, got {type(value).__name__}")
+        elif self.opts['type'] == float and not isinstance(value, float):
+            raise ValueError(f"Invalid value type: expected float, got {type(value).__name__}")
+        elif self.opts['type'] == str and not isinstance(value, str):
+            raise ValueError(f"Invalid value type: expected str, got {type(value).__name__}")
+        elif self.opts['type'] == list and not isinstance(value, list):
+            raise ValueError(f"Invalid value type: expected list, got {type(value).__name__}")
+        super().setValue(value, block_signal)
+
+    @property
+    def itemClass(self):
+        return StrictParameterItem

HDF5DataModel/Model/subclasses.py

@@ -0,0 +1,131 @@
+#from typing import Optional
+import os
+import collections
+import numpy as np
+#from HDF5DataModel.Model.h5model import H5DataModel
+from HDF5DataModel.Model.attrsclasses import DatasetAttrs, AcquisitionAtrrs, AcqSigAttrs, GenSigAttrs, AcqTraceAttrs
+
+from pyseg2.rawseg2 import write_raw_seg2
+
+
+class Dataset:
+    def __init__(self, name='default', parent: "H5DataModel"=None):
+        self.name = name
+        self.attrs = DatasetAttrs()
+        self.acquisitions = collections.OrderedDict()
+        self.parent = parent  # the parent H5DataModel of this dataset
+
+    def add_acquisition(self, name):
+        self.acquisitions[name] = Acquisition()
+        return self.acquisitions[name]
+
+    def to_hdf5_file(self, h5file):
+        """Save the experiment to a HDF5 file"""
+        experiment_group = h5file.create_group(self.name)
+        experiment_group.attrs.update(self.attrs.__dict__)
+        for acq_name, acquisition in self.acquisitions.items():
+            acquisition_group = experiment_group.create_group(acq_name)
+            acquisition_group.attrs.update(acquisition.attrs.__dict__)
+            for sig_name, acq_sig in acquisition.acq_sigs.items():
+                acq_sig_group = acquisition_group.create_group(sig_name)
+                acq_sig_group.attrs.update(acq_sig.attrs.__dict__)
+                for trace_name, trace in acq_sig.traces.items():
+                    trace_group = acq_sig_group.create_group(trace_name)
+                    trace_group.attrs.update(trace.attrs.__dict__)
+                    trace_group.create_dataset('signal', data=trace.data)
+            for gen_name, gen_sig in acquisition.gen_sigs.items():
+                gen_sig_group = acquisition_group.create_group(gen_name)
+                gen_sig_group.attrs.update(gen_sig.attrs.__dict__)
+                gen_sig_group.create_dataset('signal', data=gen_sig.signal)
+
+    def from_h5(self, h5file, experiment_name):
+        """Load the experiment from a HDF5 file"""
+        self.name = experiment_name
+        experiment_group = h5file[experiment_name]
+        self.attrs = DatasetAttrs()
+        self.attrs.set_attrs_from_dict(dict(experiment_group.attrs))
+        for acq_name in experiment_group:
+            acquisition_group = experiment_group[acq_name]
+            self.add_acquisition(acq_name)
+            self.acquisitions[acq_name].attrs = AcquisitionAtrrs()
+            self.acquisitions[acq_name].attrs.set_attrs_from_dict(dict(acquisition_group.attrs))
+            for sig_name in acquisition_group:
+                if acquisition_group[sig_name].attrs['type'] == 'Acquisition attributes':
+                    self.acquisitions[acq_name].add_acq_sig(sig_name)
+                    acq_sig_group = acquisition_group[sig_name]
+                    self.acquisitions[acq_name].acq_sigs[sig_name].attrs = AcqSigAttrs()
+                    self.acquisitions[acq_name].acq_sigs[sig_name].attrs.set_attrs_from_dict(dict(acq_sig_group.attrs))
+                    for trace_name in acq_sig_group:
+                        trace_group = acq_sig_group[trace_name]
+                        self.acquisitions[acq_name].acq_sigs[sig_name].add_trace(trace_name)
+                        self.acquisitions[acq_name].acq_sigs[sig_name].traces[trace_name].attrs = AcqTraceAttrs()
+                        self.acquisitions[acq_name].acq_sigs[sig_name].traces[trace_name].attrs.set_attrs_from_dict(dict(trace_group.attrs))
+                        self.acquisitions[acq_name].acq_sigs[sig_name].traces[trace_name].data = np.array(trace_group['signal'])
+                elif acquisition_group[sig_name].attrs['type'] == 'Generation attributes':
+                    self.acquisitions[acq_name].add_gen_sig(sig_name)
+                    gen_sig_group = acquisition_group[sig_name]
+                    self.acquisitions[acq_name].gen_sigs[sig_name].attrs = GenSigAttrs()
+                    self.acquisitions[acq_name].gen_sigs[sig_name].attrs.set_attrs_from_dict(dict(gen_sig_group.attrs))
+                    self.acquisitions[acq_name].gen_sigs[sig_name].signal = np.array(gen_sig_group['signal'])
+
+
+class Acquisition:
+    """An acquisition is a set of one generation signal and multiple acquisition signals with the sample and config"""
+    def __init__(self, parent: "Dataset"=None):
+        self.attrs = AcquisitionAtrrs()
+        self.acq_sigs = collections.OrderedDict()
+        self.gen_sigs = collections.OrderedDict()
+        self.parent = parent  # the Parent Acquisition of self
+
+    def add_acq_sig(self, name):
+        self.acq_sigs[name] = AcqSig()
+        return self.acq_sigs[name]
+
+    def add_gen_sig(self, name):
+        self.gen_sigs[name] = GenSig()
+        return self.gen_sigs[name]
+
+
+class AcqSig:
+    def __init__(self, parent: "Acquisition"=None):
+        self.attrs = AcqSigAttrs()
+        self.traces = collections.OrderedDict()
+        self.parent = parent
+
+    def add_trace(self, name):
+        self.traces[name] = AcqTrace()
+        return self.traces[name]
+
+    def to_seg2(self, filename: str, allow_overwrite: bool=False, include_type_names: bool=False):
+
+        trace_header_and_data = []
+        for trace in self.traces.values():
+            trace: AcqTrace
+
+            # FILL THE MANDATRY ATTRIBUTES
+            trace.attrs.SAMPLE_INTERVAL = 1. / trace.attrs.sampling_freq
+            # ...
+
+            trace_header_and_data.append((trace.attrs.__dict__, trace.data))
+
+        write_raw_seg2(
+            filename=filename,
+            file_header=self.attrs.__dict__,
+            trace_header_and_data=trace_header_and_data,
+            allow_overwrite=allow_overwrite,
+            include_type_names=include_type_names,
+            )
+
+
+class GenSig:
+    def __init__(self, parent: "Acquisition"=None):
+        self.attrs = GenSigAttrs()
+        self.signal = np.zeros(1)
+        self.parent = parent  # the parent Acquisition of self
+
+
+class AcqTrace:
+    def __init__(self, parent: "AcqSig, GenSig"=None):
+        self.data = np.zeros(10)
+        self.attrs = AcqTraceAttrs()
+        self.parent = parent