shepherd-core 2023.10.3__py3-none-any.whl → 2023.12.1__py3-none-any.whl

shepherd_core/data_models/testbed/target_fixture.yaml

@@ -3,8 +3,8 @@
 # https://github.com/orgua/shepherd_v2_planning/blob/main/doc_testbed/Target_pre-deployment-tests.xlsx
 - datatype: target
   parameters:
-    id: 6
-    name: nRF52_FRAM_001
+    id: 6  # Outer ID - selected by user - can be rearranged
+    name: nRF52_FRAM_001  # inner ID - used to link all parts together
     version: v1.0
     description: nRF52 as MCU + Radio, MSP430FR as SPI-FRAM or additional MCU
     comment: Test3 21nA sleep, msp-programming was flaky before -> monitor!
@@ -34,29 +34,31 @@
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
-    id: 1
+    id: 13
     name: nRF52_FRAM_005
-    comment: Test3 21nA sleep
+    comment: Test3 21nA sleep, changed Antenna to lambda/4
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
-    id: 7
+    id: 14
     name: nRF52_FRAM_006
-    comment: Test3 21nA sleep
+    comment: Test3 21nA sleep, changed Antenna to lambda/4
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
-    id: 1307
+    id: 12
     name: nRF52_FRAM_007
-    comment: msp-programming is failing -> defective
-    active: false
+    comment: msp-programming is failing -> defective, msp removed & changed Antenna to lambda/4
+    mcu2: null
+    active: true
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
-    id: 1308
+    id: 8
     name: nRF52_FRAM_008
-    comment: msp-programming is failing -> defective
-    active: false
+    comment: msp-programming is failing -> defective, msp removed & changed Antenna to lambda/4
+    mcu2: null
+    active: true
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
@@ -72,15 +74,15 @@
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
-    id: 12
+    id: 1
     name: nRF52_FRAM_011
-    comment: Test3 21nA sleep
+    comment: Test3 21nA sleep, changed Antenna to lambda/4
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
     id: 1312
     name: nRF52_FRAM_012
-    comment: msp-programming is failing -> defective
+    comment: msp-programming is failing -> defective, Antenna-Port destroyed
     active: false
 - datatype: target
   parameters:
@@ -111,7 +113,7 @@
 - datatype: target
   parameters:
     inherit_from: nRF52_FRAM_001
-    id: 8
+    id: 7
     name: nRF52_FRAM_017
     comment: Test3 21nA sleep, nrf was miss-aligned -> hot air rework
 - datatype: target

shepherd_core/data_models/testbed/testbed.py

@@ -87,6 +87,4 @@ class Testbed(ShpModel):
                 continue
             if _observer.has_target(target_id):
                 return _observer
-        raise ValueError(
-            f"Target-ID {target_id} was not found in Testbed '{self.name}'"
-        )
+        raise ValueError(f"Target-ID {target_id} was not found in Testbed '{self.name}'")

shepherd_core/data_models/testbed/testbed_fixture.yaml

@@ -21,3 +21,5 @@
       - name: sheep10
       - name: sheep11
       - name: sheep12
+      - name: sheep13
+      - name: sheep14

shepherd_core/decoder_waveform/uart.py

@@ -56,9 +56,7 @@ class Uart:
           (some detectors still missing)
         """
         if isinstance(content, Path):
-            self.events_sig: np.ndarray = np.loadtxt(
-                content.as_posix(), delimiter=",", skiprows=1
-            )
+            self.events_sig: np.ndarray = np.loadtxt(content.as_posix(), delimiter=",", skiprows=1)
             # TODO: if float fails load as str -
             #  cast first col as np.datetime64 with ns-resolution, convert to delta
         else:
@@ -66,9 +64,7 @@ class Uart:
 
         # verify table
         if self.events_sig.shape[1] != 2:
-            raise TypeError(
-                "Input file should have 2 rows -> (comma-separated) timestamp & value"
-            )
+            raise TypeError("Input file should have 2 rows -> (comma-separated) timestamp & value")
         if self.events_sig.shape[0] < 8:
             raise TypeError("Input file is too short (< state-changes)")
         # verify timestamps
@@ -80,23 +76,17 @@ class Uart:
         self._convert_analog2digital()
         self._filter_redundant_states()
 
-        self.baud_rate: int = (
-            baud_rate if baud_rate is not None else self.detect_baud_rate()
-        )
+        self.baud_rate: int = baud_rate if baud_rate is not None else self.detect_baud_rate()
         self.dur_tick: float = 1.0 / self.baud_rate
 
         self._add_duration()
 
-        self.inversion: bool = (
-            inversion if inversion is not None else self.detect_inversion()
-        )
+        self.inversion: bool = inversion if inversion is not None else self.detect_inversion()
         self.half_stop: bool = self.detect_half_stop()  # not needed ATM
 
         # TODO: add detectors
         self.parity: Parity = parity if parity is not None else Parity.no
-        self.bit_order: BitOrder = (
-            bit_order if bit_order is not None else BitOrder.lsb_first
-        )
+        self.bit_order: BitOrder = bit_order if bit_order is not None else BitOrder.lsb_first
         self.frame_length: int = frame_length if frame_length is not None else 8
 
         if not (0 < self.frame_length <= 64):
@@ -146,14 +136,10 @@ class Uart:
             logger.warning("Tried to add state-duration, but it seems already present")
             return
         if not hasattr(self, "dur_tick"):
-            raise ValueError(
-                "Make sure that baud-rate was calculated before running add_dur()"
-            )
+            raise ValueError("Make sure that baud-rate was calculated before running add_dur()")
         dur_steps = self.events_sig[1:, 0] - self.events_sig[:-1, 0]
         dur_steps = np.reshape(dur_steps, (dur_steps.size, 1))
-        self.events_sig = np.append(
-            self.events_sig[:-1, :], dur_steps / self.dur_tick, axis=1
-        )
+        self.events_sig = np.append(self.events_sig[:-1, :], dur_steps / self.dur_tick, axis=1)
 
     def detect_inversion(self) -> bool:
         """Analyze bit-state during long pauses (unchanged states)
@@ -182,16 +168,12 @@ class Uart:
     def detect_half_stop(self) -> bool:
         """Looks into the spacing between time-steps"""
         events = self.events_sig[:1000, :]  # speedup for large datasets
-        return (
-            np.sum((events > 1.333 * self.dur_tick) & (events < 1.667 * self.dur_tick))
-            > 0
-        )
+        return np.sum((events > 1.333 * self.dur_tick) & (events < 1.667 * self.dur_tick)) > 0
 
     def detect_dataframe_length(self) -> int:
         """Look after longest pauses
         - accumulate steps until a state with uneven step-size is found
         """
-        pass
 
     def get_symbols(self, *, force_redo: bool = False) -> np.ndarray:
         """Ways to detect EOF:

shepherd_core/fw_tools/__init__.py

@@ -25,9 +25,7 @@ except ImportError:
         "cffi",
     ]
     # only update when module is not avail
-    MOCK_MODULES = [
-        mod_name for mod_name in MOCK_MODULES if find_spec(mod_name) is None
-    ]
+    MOCK_MODULES = [mod_name for mod_name in MOCK_MODULES if find_spec(mod_name) is None]
     sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
 
 from .converter import base64_to_file

shepherd_core/fw_tools/converter.py

@@ -22,9 +22,7 @@ def firmware_to_hex(file_path: Path) -> Path:
         return elf_to_hex(file_path)
     if is_hex(file_path):
         return file_path
-    raise ValueError(
-        "FW2Hex: unknown file '%s', it should be ELF or HEX", file_path.name
-    )
+    raise ValueError("FW2Hex: unknown file '%s', it should be ELF or HEX", file_path.name)
 
 
 @validate_call
@@ -72,9 +70,7 @@ def base64_to_hash(content: str) -> str:
 
 
 @validate_call
-def extract_firmware(
-    data: Union[str, Path], data_type: FirmwareDType, file_path: Path
-) -> Path:
+def extract_firmware(data: Union[str, Path], data_type: FirmwareDType, file_path: Path) -> Path:
     """- base64-string will be transformed into file
     - if data is a path the file will be copied to the destination
     """
@@ -90,14 +86,10 @@ def extract_firmware(
         elif data_type == FirmwareDType.path_hex:
             file = file_path.with_suffix(".hex")
         else:
-            raise ValueError(
-                "FW-Extraction failed due to unknown datatype '%s'", data_type
-            )
+            raise ValueError("FW-Extraction failed due to unknown datatype '%s'", data_type)
         if not file.parent.exists():
             file.parent.mkdir(parents=True)
         shutil.copy(data, file)
     else:
-        raise ValueError(
-            "FW-Extraction failed due to unknown data-type '%s'", type(data)
-        )
+        raise ValueError("FW-Extraction failed due to unknown data-type '%s'", type(data))
     return file

shepherd_core/fw_tools/patcher.py

@@ -46,9 +46,7 @@ def find_symbol(file_elf: Path, symbol: str) -> bool:
 
 
 @validate_call
-def read_symbol(
-    file_elf: Path, symbol: str, length: int = uid_len_default
-) -> Optional[int]:
+def read_symbol(file_elf: Path, symbol: str, length: int = uid_len_default) -> Optional[int]:
     """Interpreted as int"""
     if not find_symbol(file_elf, symbol):
         return None
@@ -99,9 +97,7 @@ def modify_symbol_value(
     value_raw = elf.read(address=addr, count=uid_len_default)[-uid_len_default:]
     # ⤷ cutting needed -> msp produces 4b instead of 2
     value_old = int.from_bytes(bytes=value_raw, byteorder=elf.endian, signed=False)
-    value_raw = value.to_bytes(
-        length=uid_len_default, byteorder=elf.endian, signed=False
-    )
+    value_raw = value.to_bytes(length=uid_len_default, byteorder=elf.endian, signed=False)
     try:
         elf.write(address=addr, data=value_raw)
     except AttributeError:
@@ -110,9 +106,7 @@ def modify_symbol_value(
     if overwrite:
         file_new = file_elf
     else:
-        file_new = file_elf.with_name(
-            file_elf.stem + "_" + str(value) + file_elf.suffix
-        )
+        file_new = file_elf.with_name(file_elf.stem + "_" + str(value) + file_elf.suffix)
         # could be simplified, but py3.8-- doesn't know .with_stem()
     elf.save(path=file_new)
     elf.close()
@@ -127,6 +121,4 @@ def modify_symbol_value(
 
 
 def modify_uid(file_elf: Path, value: int) -> Optional[Path]:
-    return modify_symbol_value(
-        file_elf, symbol=uid_str_default, value=value, overwrite=True
-    )
+    return modify_symbol_value(file_elf, symbol=uid_str_default, value=value, overwrite=True)

shepherd_core/fw_tools/validation.py

@@ -92,7 +92,7 @@ def is_elf(file: Path) -> bool:
     return True
 
 
-def is_elf_msp430(file: Path) -> bool:
+def is_elf_msp430(file: Path) -> bool:  # TODO: allow detection without conversion
     if is_elf(file):
         with tempfile.TemporaryDirectory() as path:
             file_hex = Path(path) / "file.hex"
@@ -103,7 +103,7 @@ def is_elf_msp430(file: Path) -> bool:
     return False
 
 
-def is_elf_nrf52(file: Path) -> bool:
+def is_elf_nrf52(file: Path) -> bool:  # TODO: allow detection without conversion
     if is_elf(file):
         with tempfile.TemporaryDirectory() as path:
             file_hex = Path(path) / "file.hex"

shepherd_core/inventory/__init__.py

@@ -30,15 +30,9 @@ class Inventory(PythonInventory, SystemInventory, TargetInventory):
     @classmethod
     def collect(cls) -> Self:
         # one by one for more precise error messages
-        pid = PythonInventory.collect().model_dump(
-            exclude_unset=True, exclude_defaults=True
-        )
-        sid = SystemInventory.collect().model_dump(
-            exclude_unset=True, exclude_defaults=True
-        )
-        tid = TargetInventory.collect().model_dump(
-            exclude_unset=True, exclude_defaults=True
-        )
+        pid = PythonInventory.collect().model_dump(exclude_unset=True, exclude_defaults=True)
+        sid = SystemInventory.collect().model_dump(exclude_unset=True, exclude_defaults=True)
+        tid = TargetInventory.collect().model_dump(exclude_unset=True, exclude_defaults=True)
         model = {**pid, **sid, **tid}
         return cls(**model)
 

shepherd_core/inventory/python.py

@@ -11,13 +11,14 @@ from ..data_models import ShpModel
 
 class PythonInventory(ShpModel):
     # program versions
-    python: Optional[str] = None
-    numpy: Optional[str] = None
     h5py: Optional[str] = None
+    numpy: Optional[str] = None
     pydantic: Optional[str] = None
-    yaml: Optional[str] = None
+    python: Optional[str] = None
     shepherd_core: Optional[str] = None
     shepherd_sheep: Optional[str] = None
+    yaml: Optional[str] = None
+    zstandard: Optional[str] = None
 
     model_config = ConfigDict(str_min_length=0)
 
@@ -25,12 +26,13 @@ class PythonInventory(ShpModel):
     def collect(cls) -> Self:
         model_dict = {"python": platform.python_version()}
         module_names = [
-            "numpy",
             "h5py",
+            "numpy",
             "pydantic",
-            "yaml",
             "shepherd_core",
             "shepherd_sheep",
+            "yaml",
+            "zstandard",
         ]
 
         for module_name in module_names:

shepherd_core/inventory/system.py

@@ -53,11 +53,7 @@ class SystemInventory(ShpModel):
             )
         else:
             ifs1 = psutil.net_if_addrs().items()
-            ifs2 = {
-                name: (_if[1].address, _if[0].address)
-                for name, _if in ifs1
-                if len(_if) > 1
-            }
+            ifs2 = {name: (_if[1].address, _if[0].address) for name, _if in ifs1 if len(_if) > 1}
             uptime = time.time() - psutil.boot_time()
 
         model_dict = {
@@ -69,6 +65,7 @@ class SystemInventory(ShpModel):
             "processor": platform.processor(),
             "hostname": platform.node(),
             "interfaces": ifs2,
+            # TODO: add free space on /
         }
 
         with suppress(FileNotFoundError):

shepherd_core/logger.py

@@ -15,9 +15,7 @@ def get_verbose_level() -> int:
     return verbose_level
 
 
-def set_log_verbose_level(
-    log_: Union[logging.Logger, logging.Handler], verbose: int
-) -> None:
+def set_log_verbose_level(log_: Union[logging.Logger, logging.Handler], verbose: int) -> None:
     if verbose == 0:
         log_.setLevel(logging.ERROR)
         logging.basicConfig(level=logging.ERROR)

shepherd_core/reader.py

@@ -95,9 +95,7 @@ class Reader:
                 self.h5file = h5py.File(self.file_path, "r")  # = readonly
                 self._reader_opened = True
             except OSError as _xcp:
-                raise TypeError(
-                    f"Unable to open HDF5-File '{self.file_path.name}'"
-                ) from _xcp
+                raise TypeError(f"Unable to open HDF5-File '{self.file_path.name}'") from _xcp
 
             if self.is_valid():
                 self._logger.debug("File is available now")
@@ -109,9 +107,7 @@ class Reader:
                 )
 
         if not isinstance(self.h5file, h5py.File):
-            raise TypeError(
-                "Type of opened file is not h5py.File, for %s", self.file_path.name
-            )
+            raise TypeError("Type of opened file is not h5py.File, for %s", self.file_path.name)
 
         self.ds_time: h5py.Dataset = self.h5file["data"]["time"]
         self.ds_voltage: h5py.Dataset = self.h5file["data"]["voltage"]
@@ -120,9 +116,7 @@ class Reader:
         # retrieve cal-data
         if not hasattr(self, "_cal"):
             cal_dict = CalibrationSeries().model_dump()
-            for ds, param in product(
-                ["current", "voltage", "time"], ["gain", "offset"]
-            ):
+            for ds, param in product(["current", "voltage", "time"], ["gain", "offset"]):
                 cal_dict[ds][param] = self.h5file["data"][ds].attrs[param]
             self._cal = CalibrationSeries(**cal_dict)
 
@@ -167,12 +161,11 @@ class Reader:
         """update internal states, helpful after resampling or other changes in data-group"""
         self.h5file.flush()
         if (self.ds_time.shape[0] > 1) and (self.ds_time[1] != self.ds_time[0]):
-            self.sample_interval_s = self._cal.time.raw_to_si(
-                self.ds_time[1] - self.ds_time[0]
-            )
+            # this assumes isochronal sampling
+            self.sample_interval_s = self._cal.time.raw_to_si(self.ds_time[1] - self.ds_time[0])
             self.sample_interval_ns = int(10**9 * self.sample_interval_s)
             self.samplerate_sps = max(int(10**9 // self.sample_interval_ns), 1)
-        self.runtime_s = round(self.ds_time.shape[0] / self.samplerate_sps, 1)
+        self.runtime_s = round(self.ds_voltage.shape[0] / self.samplerate_sps, 1)
         if isinstance(self.file_path, Path):
             self.file_size = self.file_path.stat().st_size
         else:
@@ -185,6 +178,7 @@ class Reader:
         end_n: Optional[int] = None,
         *,
         is_raw: bool = False,
+        omit_ts: bool = False,
     ) -> Generator[tuple, None, None]:
         """Generator that reads the specified range of buffers from the hdf5 file.
         can be configured on first call
@@ -195,27 +189,27 @@ class Reader:
             :param start_n: (int) Index of first buffer to be read
             :param end_n: (int) Index of last buffer to be read
             :param is_raw: (bool) output original data, not transformed to SI-Units
+            :param omit_ts: (bool) optimize reading if timestamp is never used
         Yields: Buffers between start and end (tuple with time, voltage, current)
         """
         if end_n is None:
-            end_n = int(self.ds_time.shape[0] // self.samples_per_buffer)
-        self._logger.debug(
-            "Reading blocks from %d to %d from source-file", start_n, end_n
-        )
+            end_n = int(self.ds_voltage.shape[0] // self.samples_per_buffer)
+        self._logger.debug("Reading blocks %d to %d from source-file", start_n, end_n)
         _raw = is_raw
+        _wts = not omit_ts
 
         for i in range(start_n, end_n):
             idx_start = i * self.samples_per_buffer
             idx_end = idx_start + self.samples_per_buffer
             if _raw:
                 yield (
-                    self.ds_time[idx_start:idx_end],
+                    self.ds_time[idx_start:idx_end] if _wts else None,
                     self.ds_voltage[idx_start:idx_end],
                     self.ds_current[idx_start:idx_end],
                 )
             else:
                 yield (
-                    self._cal.time.raw_to_si(self.ds_time[idx_start:idx_end]),
+                    self._cal.time.raw_to_si(self.ds_time[idx_start:idx_end]) if _wts else None,
                     self._cal.voltage.raw_to_si(self.ds_voltage[idx_start:idx_end]),
                     self._cal.current.raw_to_si(self.ds_current[idx_start:idx_end]),
                 )
@@ -341,20 +335,20 @@ class Reader:
                 self.file_path.name,
             )
         # same length of datasets:
-        ds_time_size = self.h5file["data"]["time"].shape[0]
-        for dset in ["current", "voltage"]:
+        ds_volt_size = self.h5file["data"]["voltage"].shape[0]
+        for dset in ["current", "time"]:
             ds_size = self.h5file["data"][dset].shape[0]
-            if ds_time_size != ds_size:
+            if ds_volt_size != ds_size:
                 self._logger.warning(
                     "[FileValidation] dataset '%s' has different size (=%d), "
                     "compared to time-ds (=%d), in '%s'",
                     dset,
                     ds_size,
-                    ds_time_size,
+                    ds_volt_size,
                     self.file_path.name,
                 )
         # dataset-length should be multiple of buffersize
-        remaining_size = ds_time_size % self.samples_per_buffer
+        remaining_size = ds_volt_size % self.samples_per_buffer
         if remaining_size != 0:
             self._logger.warning(
                 "[FileValidation] datasets are not aligned with buffer-size in '%s'",
@@ -382,6 +376,14 @@ class Reader:
             self._logger.warning(
                 "[FileValidation] Hostname was not set in '%s'", self.file_path.name
             )
+        # errors during execution
+        _err = self.count_errors_in_log()
+        if _err > 0:
+            self._logger.warning(
+                "[FileValidation] Sheep reported %d errors during execution -> check logs in '%s'",
+                _err,
+                self.file_path.name,
+            )
         return True
 
     def __getitem__(self, key: str) -> Any:
@@ -403,10 +405,10 @@ class Reader:
 
         :return: sampled energy in Ws (watt-seconds)
         """
-        iterations = math.ceil(self.ds_time.shape[0] / self.max_elements)
+        iterations = math.ceil(self.ds_voltage.shape[0] / self.max_elements)
         job_iter = trange(
             0,
-            self.ds_time.shape[0],
+            self.ds_voltage.shape[0],
             self.max_elements,
             desc="energy",
             leave=False,
@@ -414,7 +416,7 @@ class Reader:
         )
 
         def _calc_energy(idx_start: int) -> float:
-            idx_stop = min(idx_start + self.max_elements, self.ds_time.shape[0])
+            idx_stop = min(idx_start + self.max_elements, self.ds_voltage.shape[0])
             vol_v = self._cal.voltage.raw_to_si(self.ds_voltage[idx_start:idx_stop])
             cur_a = self._cal.current.raw_to_si(self.ds_current[idx_start:idx_stop])
             return (vol_v[:] * cur_a[:]).sum() * self.sample_interval_s
@@ -433,9 +435,7 @@ class Reader:
         si_converted = True
         if not isinstance(cal, CalibrationPair):
             if "gain" in dset.attrs and "offset" in dset.attrs:
-                cal = CalibrationPair(
-                    gain=dset.attrs["gain"], offset=dset.attrs["offset"]
-                )
+                cal = CalibrationPair(gain=dset.attrs["gain"], offset=dset.attrs["offset"])
             else:
                 cal = CalibrationPair(gain=1)
                 si_converted = False
@@ -453,8 +453,7 @@ class Reader:
             return [np.mean(data), np.min(data), np.max(data), np.std(data)]
 
         stats_list = [
-            _calc_statistics(cal.raw_to_si(dset[i : i + self.max_elements]))
-            for i in job_iter
+            _calc_statistics(cal.raw_to_si(dset[i : i + self.max_elements])) for i in job_iter
         ]
         if len(stats_list) < 1:
             return {}
@@ -513,6 +512,17 @@ class Reader:
             )
         return (len(diffs) <= 1) and diffs[0] == round(0.1 / self.samples_per_buffer, 6)
 
+    def count_errors_in_log(self, group_name: str = "sheep", min_level: int = 40) -> int:
+        if group_name not in self.h5file:
+            return 0
+        if "level" not in self.h5file["sheep"]:
+            return 0
+        _lvl = self.h5file["sheep"]["level"]
+        if _lvl.shape[0] < 1:
+            return 0
+        _items = [1 for _x in _lvl[:] if _x >= min_level]
+        return len(_items)
+
     def get_metadata(
         self,
         node: Union[h5py.Dataset, h5py.Group, None] = None,
@@ -580,9 +590,7 @@ class Reader:
             if yaml_path.exists():
                 self._logger.info("File already exists, will skip '%s'", yaml_path.name)
                 return {}
-            metadata = self.get_metadata(
-                node
-            )  # {"h5root": self.get_metadata(self.h5file)}
+            metadata = self.get_metadata(node)  # {"h5root": self.get_metadata(self.h5file)}
             with yaml_path.open("w", encoding="utf-8-sig") as yfd:
                 yaml.safe_dump(metadata, yfd, default_flow_style=False, sort_keys=False)
         else:
@@ -618,9 +626,7 @@ class Reader:
         gpio_vs = self.h5file["gpio"]["value"]
 
         if name is None:
-            descriptions = yaml.safe_load(
-                self.h5file["gpio"]["value"].attrs["description"]
-            )
+            descriptions = yaml.safe_load(self.h5file["gpio"]["value"].attrs["description"])
             pin_dict = {value["name"]: key for key, value in descriptions.items()}
         else:
             pin_dict = {name: self.get_gpio_pin_num(name)}
@@ -636,9 +642,7 @@ class Reader:
             )
         return waveforms
 
-    def waveform_to_csv(
-        self, pin_name: str, pin_wf: np.ndarray, separator: str = ","
-    ) -> None:
+    def waveform_to_csv(self, pin_name: str, pin_wf: np.ndarray, separator: str = ",") -> None:
         path_csv = self.file_path.with_suffix(f".waveform.{pin_name}.csv")
         if path_csv.exists():
             self._logger.info("File already exists, will skip '%s'", path_csv.name)

shepherd_core/testbed_client/client.py

@@ -18,9 +18,7 @@ from .user_model import User
 class TestbedClient:
     _instance: Optional[Self] = None
 
-    def __init__(
-        self, server: Optional[str] = None, token: Union[str, Path, None] = None
-    ) -> None:
+    def __init__(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> None:
         if not hasattr(self, "_token"):
             self._token: str = "null"
             self._server: Optional[str] = testbed_server_default
@@ -42,9 +40,7 @@ class TestbedClient:
         TestbedClient._instance = None
 
     @validate_call
-    def connect(
-        self, server: Optional[str] = None, token: Union[str, Path, None] = None
-    ) -> bool:
+    def connect(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> bool:
         """
         server: either "local" to use demo-fixtures or something like "https://HOST:PORT"
         token: your account validation
@@ -74,9 +70,7 @@ class TestbedClient:
             parameters=data.model_dump(),
         )
         if self._connected:
-            r = self._req.post(
-                self._server + "/add", data=wrap.model_dump_json(), timeout=2
-            )
+            r = self._req.post(self._server + "/add", data=wrap.model_dump_json(), timeout=2)
             r.raise_for_status()
         else:
             self._fixtures.insert_model(wrap)
@@ -134,16 +128,11 @@ class TestbedClient:
                 and value.lower() in self._fixtures[model_type].elements_by_name
             ):
                 values = self.query_item(model_type, name=value)
-            elif (
-                isinstance(value, int)
-                and value in self._fixtures[model_type].elements_by_id
-            ):
+            elif isinstance(value, int) and value in self._fixtures[model_type].elements_by_id:
                 # TODO: still depending on _fixture
                 values = self.query_item(model_type, uid=value)
             else:
-                raise ValueError(
-                    f"Query {model_type} by name / ID failed - " f"{values} is unknown!"
-                )
+                raise ValueError(f"Query {model_type} by name / ID failed - {values} is unknown!")
         return self.try_inheritance(model_type, values)
 
     def fill_in_user_data(self, values: dict) -> dict: