shepherd-core 2025.4.2__py3-none-any.whl → 2025.5.2__py3-none-any.whl

shepherd_core/data_models/task/programming.py

@@ -43,7 +43,8 @@ class ProgrammingTask(ShpModel):
     def post_validation(self) -> Self:
         d_type = suffix_to_DType.get(self.firmware_file.suffix.lower())
         if d_type != FirmwareDType.base64_hex:
-            raise ValueError("Firmware is not intel-.hex ('%s')", self.firmware_file.as_posix())
+            msg = (f"Firmware is not intel-hex ({self.firmware_file.as_posix()})",)
+            raise ValueError(msg)
         return self
 
     @classmethod

shepherd_core/data_models/testbed/mcu_fixture.yaml

@@ -3,17 +3,17 @@
   parameters:
     id: 1001
     name: nRF52
-    description: Panasonic PAN1780, ENW-89854A1KF, Bluetooth 5 Low Energy Module
+    description: MCU with RF, 802.15.4, Bluetooth v5.0, 2.4GHz
     platform: nRF52
     core: nRF52840
     prog_protocol: SWD
-    fw_name_default: nrf52_demo_rf
+    fw_name_default: nrf52_deep_sleep
 - datatype: mcu
   parameters:
     id: 1002
     name: MSP430FR
-    description: 16MHz Ultra-Low-Pwr MCU with 128 KB FRAM
+    description: 16MHz Ultra-Low-Pwr MCU with 256 KB FRAM
     platform: MSP430
-    core: MSP430FR5962
+    core: MSP430FR5994
     prog_protocol: SBW
     fw_name_default: msp430_deep_sleep

shepherd_core/data_models/virtual_source_doc.txt

@@ -35,14 +35,14 @@ class VirtualSourceDoc(ShpModel, title="Virtual Source (Documented, Testversion)
     )
 
     interval_startup_delay_drain_ms: float = Field(
-        description="Model begins running but Target is not draining the buffer",
+        description="Model begins running but Target is not draining the storage capacitor",
         default=0,
         ge=0,
         le=10e3,
     )
 
     harvester: VirtualHarvesterConfig = Field(
-        description="Only active / needed if input is 'ivcurves'",
+        description="Only active / needed if input is ivsurface / curves,
         default=VirtualHarvesterConfig(name="mppt_opt"),
     )
 
@@ -85,7 +85,7 @@ class VirtualSourceDoc(ShpModel, title="Virtual Source (Documented, Testversion)
         le=10_000,
     )
     I_intermediate_leak_nA: float = Field(
-        description="Current leakage of intermediate buffer capacitor",
+        description="Current leakage of intermediate storage capacitor",
         default=0,
         ge=0,
         le=4.29e9,

shepherd_core/fw_tools/converter.py

@@ -28,7 +28,8 @@ def firmware_to_hex(file_path: Path) -> Path:
         return elf_to_hex(file_path)
     if is_hex(file_path):
         return file_path
-    raise FileNotFoundError("FW2Hex: unknown file '%s', it should be ELF or HEX", file_path.name)
+    msg = (f"FW2Hex: unknown file '{file_path.name}', it should be ELF or HEX",)
+    raise FileNotFoundError(msg)
 
 
 @validate_call
@@ -98,10 +99,12 @@ def extract_firmware(data: Union[str, Path], data_type: FirmwareDType, file_path
         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)
+            msg = "FW-Extraction failed due to unknown datatype '{data_type}'"
+            raise ValueError(msg)
         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))
+        msg = f"FW-Extraction failed due to unknown data-type '{type(data)}'"
+        raise ValueError(msg)
     return file

shepherd_core/fw_tools/validation.py

@@ -137,7 +137,8 @@ def determine_type(file: Path) -> FirmwareDType:
         return FirmwareDType.path_hex
     if is_elf(file):
         return FirmwareDType.path_elf
-    raise ValueError("Type of file '%s' could not be determined", file.name)
+    msg = f"Type of file '{file.name}' could not be determined"
+    raise ValueError(msg)
 
 
 def determine_arch(file: Path) -> str:
@@ -148,11 +149,14 @@ def determine_arch(file: Path) -> str:
             return "msp430"
         if is_elf_nrf52(file):
             return "nrf52"
-        raise ValueError("Arch of ELF '%s' could not be determined", file.name)
+        msg = f"Arch of ELF '{file.name}' could not be determined"
+        raise ValueError(msg)
     if file_t == FirmwareDType.path_hex:
         if is_hex_msp430(file):
             return "msp430"
         if is_hex_nrf52(file):
             return "nrf52"
-        raise ValueError("Arch of HEX '%s' could not be determined", file.name)
-    raise ValueError("Arch of file '%s' could not be determined", file.name)
+        msg = f"Arch of HEX '{file.name}' could not be determined"
+        raise ValueError(msg)
+    msg = f"Arch of file '{file.name}' could not be determined"
+    raise ValueError(msg)

shepherd_core/reader.py

@@ -11,6 +11,7 @@ from itertools import product
 from pathlib import Path
 from types import MappingProxyType
 from typing import TYPE_CHECKING
+from typing import Annotated
 from typing import Any
 from typing import Optional
 from typing import Union
@@ -21,6 +22,7 @@ import yaml
 from pydantic import validate_call
 from tqdm import trange
 from typing_extensions import Self
+from typing_extensions import deprecated
 
 from .commons import SAMPLERATE_SPS_DEFAULT
 from .data_models.base.calibration import CalibrationPair
@@ -45,7 +47,7 @@ class Reader:
 
     """
 
-    BUFFER_SAMPLES_N: int = 10_000
+    CHUNK_SAMPLES_N: int = 10_000
 
     MODE_TO_DTYPE: Mapping[str, Sequence[EnergyDType]] = MappingProxyType(
         {
@@ -82,10 +84,13 @@ class Reader:
 
         # init stats
         self.runtime_s: float = 0
-        self.buffers_n: int = 0
+        self.samples_n: int = 0
+        self.chunks_n: int = 0
         self.file_size: int = 0
         self.data_rate: float = 0
 
+        self.buffers_n: Annotated[int, deprecated("use .chunk_n instead")] = 0
+
         # open file (if not already done by writer)
         self._reader_opened: bool = False
         if not hasattr(self, "h5file"):
@@ -113,7 +118,8 @@ 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)
+            msg = (f"Type of opened file is not h5py.File, for {self.file_path.name}",)
+            raise TypeError(msg)
 
         self.ds_time: h5py.Dataset = self.h5file["data"]["time"]
         self.ds_voltage: h5py.Dataset = self.h5file["data"]["voltage"]
@@ -169,59 +175,63 @@ class Reader:
     def _refresh_file_stats(self) -> None:
         """Update internal states, helpful after resampling or other changes in data-group."""
         self.h5file.flush()
-        sample_count = self.ds_time.shape[0]
+        self.samples_n = min(
+            self.ds_time.shape[0], self.ds_current.shape[0], self.ds_voltage.shape[0]
+        )
         duration_raw = (
-            (int(self.ds_time[sample_count - 1]) - int(self.ds_time[0])) if sample_count > 0 else 0
+            (int(self.ds_time[self.samples_n - 1]) - int(self.ds_time[0]))
+            if self.samples_n > 0
+            else 0
         )
         # above's typecasting prevents overflow in u64-format
-        if (sample_count > 0) and (duration_raw > 0):
-            # this assumes iso-chronous sampling
+        if (self.samples_n > 0) and (duration_raw > 0):
+            # this assumes iso-chronous sampling, TODO: not the best choice?
             duration_s = self._cal.time.raw_to_si(duration_raw)
-            self.sample_interval_s = duration_s / sample_count
+            self.sample_interval_s = duration_s / self.samples_n
             self.sample_interval_ns = round(10**9 * self.sample_interval_s)
-            self.samplerate_sps = max(round((sample_count - 1) / duration_s), 1)
-        self.runtime_s = round(self.ds_voltage.shape[0] / self.samplerate_sps, 1)
-        self.buffers_n = int(self.ds_voltage.shape[0] // self.BUFFER_SAMPLES_N)
+            self.samplerate_sps = max(round((self.samples_n - 1) / duration_s), 1)
+        self.runtime_s = round(self.samples_n / self.samplerate_sps, 1)
+        self.chunks_n = self.buffers_n = int(self.samples_n // self.CHUNK_SAMPLES_N)
         if isinstance(self.file_path, Path):
             self.file_size = self.file_path.stat().st_size
         else:
             self.file_size = 0
         self.data_rate = self.file_size / self.runtime_s if self.runtime_s > 0 else 0
 
-    def read_buffers(
+    def read(
         self,
         start_n: int = 0,
         end_n: Optional[int] = None,
-        n_samples_per_buffer: Optional[int] = None,
+        n_samples_per_chunk: Optional[int] = None,
         *,
         is_raw: bool = False,
-        omit_ts: bool = False,
+        omit_timestamps: bool = False,
     ) -> Generator[tuple, None, None]:
-        """Read the specified range of buffers from the hdf5 file.
+        """Read the specified range of chunks from the hdf5 file.
 
         Generator - can be configured on first call
 
         Args:
         ----
-            :param start_n: (int) Index of first buffer to be read
-            :param end_n: (int) Index of last buffer to be read
-            :param n_samples_per_buffer: (int) allows changing
+            :param start_n: (int) Index of first chunk to be read
+            :param end_n: (int) Index of last chunk to be read
+            :param n_samples_per_chunk: (int) allows changing
             :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)
+            :param omit_timestamps: (bool) optimize reading if timestamp is never used
+        Yields: chunks between start and end (tuple with time, voltage, current)
 
         """
-        if n_samples_per_buffer is None:
-            n_samples_per_buffer = self.BUFFER_SAMPLES_N
-        end_max = int(self.ds_voltage.shape[0] // n_samples_per_buffer)
+        if n_samples_per_chunk is None:
+            n_samples_per_chunk = self.CHUNK_SAMPLES_N
+        end_max = int(self.samples_n // n_samples_per_chunk)
         end_n = end_max if end_n is None else min(end_n, end_max)
-        self._logger.debug("Reading blocks %d to %d from source-file", start_n, end_n)
+        self._logger.debug("Reading chunk %d to %d from source-file", start_n, end_n)
         _raw = is_raw
-        _wts = not omit_ts
+        _wts = not omit_timestamps
 
         for i in range(start_n, end_n):
-            idx_start = i * n_samples_per_buffer
-            idx_end = idx_start + n_samples_per_buffer
+            idx_start = i * n_samples_per_chunk
+            idx_end = idx_start + n_samples_per_chunk
             if _raw:
                 yield (
                     self.ds_time[idx_start:idx_end] if _wts else None,
@@ -235,6 +245,24 @@ class Reader:
                     self._cal.current.raw_to_si(self.ds_current[idx_start:idx_end]),
                 )
 
+    @deprecated("use .read() instead")
+    def read_buffers(
+        self,
+        start_n: int = 0,
+        end_n: Optional[int] = None,
+        n_samples_per_buffer: Optional[int] = None,
+        *,
+        is_raw: bool = False,
+        omit_ts: bool = False,
+    ) -> Generator[tuple, None, None]:
+        return self.read(
+            start_n=start_n,
+            end_n=end_n,
+            n_samples_per_chunk=n_samples_per_buffer,
+            is_raw=is_raw,
+            omit_timestamps=omit_ts,
+        )
+
     def get_calibration_data(self) -> CalibrationSeries:
         """Read calibration-data from hdf5 file.
 
@@ -384,23 +412,22 @@ class Reader:
                 self.file_path.name,
             )
         # same length of datasets:
-        ds_volt_size = self.h5file["data"]["voltage"].shape[0]
         for dset in ["current", "time"]:
             ds_size = self.h5file["data"][dset].shape[0]
-            if ds_volt_size != ds_size:
+            if ds_size != self.samples_n:
                 self._logger.warning(
                     "[FileValidation] dataset '%s' has different size (=%d), "
-                    "compared to time-ds (=%d), in '%s'",
+                    "compared to smallest set (=%d), in '%s'",
                     dset,
                     ds_size,
-                    ds_volt_size,
+                    self.samples_n,
                     self.file_path.name,
                 )
-        # dataset-length should be multiple of buffersize
-        remaining_size = ds_volt_size % self.BUFFER_SAMPLES_N
+        # dataset-length should be multiple of chunk-size
+        remaining_size = self.samples_n % self.CHUNK_SAMPLES_N
         if remaining_size != 0:
             self._logger.warning(
-                "[FileValidation] datasets are not aligned with buffer-size in '%s'",
+                "[FileValidation] datasets are not aligned with chunk-size in '%s'",
                 self.file_path.name,
             )
         # check compression
@@ -455,10 +482,10 @@ class Reader:
 
         :return: sampled energy in Ws (watt-seconds)
         """
-        iterations = math.ceil(self.ds_voltage.shape[0] / self.max_elements)
+        iterations = math.ceil(self.samples_n / self.max_elements)
         job_iter = trange(
             0,
-            self.ds_voltage.shape[0],
+            self.samples_n,
             self.max_elements,
             desc="energy",
             leave=False,
@@ -466,7 +493,7 @@ class Reader:
         )
 
         def _calc_energy(idx_start: int) -> float:
-            idx_stop = min(idx_start + self.max_elements, self.ds_voltage.shape[0])
+            idx_stop = min(idx_start + self.max_elements, self.samples_n)
             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
@@ -520,16 +547,18 @@ class Reader:
         return stats
 
     def _data_timediffs(self) -> list[float]:
-        """Calculate list of unique time-deltas [s] between buffers.
+        """Calculate list of unique time-deltas [s] between chunks.
 
-        Optimized version that only looks at the start of each buffer.
+        Optimized version that only looks at the start of each chunk.
+        Timestamps get converted to signed (it still fits > 100 years)
+        to allow calculating negative diffs.
 
-        :return: list of (unique) time-deltas between buffers [s]
+        :return: list of (unique) time-deltas between chunks [s]
         """
-        iterations = math.ceil(self.ds_time.shape[0] / self.max_elements)
+        iterations = math.ceil(self.samples_n / self.max_elements)
         job_iter = trange(
             0,
-            self.h5file["data"]["time"].shape[0],
+            self.samples_n,
             self.max_elements,
             desc="timediff",
             leave=False,
@@ -538,14 +567,14 @@ class Reader:
 
         def calc_timediffs(idx_start: int) -> list:
             ds_time = self.ds_time[
-                idx_start : (idx_start + self.max_elements) : self.BUFFER_SAMPLES_N
-            ]
+                idx_start : (idx_start + self.max_elements) : self.CHUNK_SAMPLES_N
+            ].astype(np.int64)
             diffs_np = np.unique(ds_time[1:] - ds_time[0:-1], return_counts=False)
             return list(np.array(diffs_np))
 
         diffs_ll = [calc_timediffs(i) for i in job_iter]
         diffs = {
-            round(self._cal.time.raw_to_si(j) / self.BUFFER_SAMPLES_N, 6)
+            round(self._cal.time.raw_to_si(j) / self.CHUNK_SAMPLES_N, 6)
             for i in diffs_ll
             for j in i
         }
@@ -563,7 +592,7 @@ class Reader:
             self._logger.warning(
                 "Time-jumps detected -> expected equal steps, but got: %s s", diffs
             )
-        return (len(diffs) <= 1) and diffs[0] == round(0.1 / self.BUFFER_SAMPLES_N, 6)
+        return (len(diffs) <= 1) and diffs[0] == round(0.1 / self.CHUNK_SAMPLES_N, 6)
 
     def count_errors_in_log(self, group_name: str = "sheep", min_level: int = 40) -> int:
         if group_name not in self.h5file:

shepherd_core/testbed_client/client_abc_fix.py

@@ -72,9 +72,8 @@ class AbcClient(ABC):
             try:
                 values = self.query_item(model_type, name=values.get("name"), uid=values.get("id"))
             except ValueError as err:
-                raise ValueError(
-                    "Query %s by name / ID failed - %s is unknown!", model_type, values
-                ) from err
+                msg = f"Query {model_type} by name / ID failed - {values} is unknown!"
+                raise ValueError(msg) from err
         return self.try_inheritance(model_type, values)
 
     @abstractmethod

shepherd_core/testbed_client/fixtures.py

@@ -101,14 +101,10 @@ class Fixture:
                 base_name = values.get("name")
                 if base_name in chain:
                     msg = f"Inheritance-Circle detected ({base_name} already in {chain})"
-                    raise ValueError(
-                        msg,
-                    )
+                    raise ValueError(msg)
                 if base_name == fixture_name:
                     msg = f"Inheritance-Circle detected ({base_name} == {fixture_name})"
-                    raise ValueError(
-                        msg,
-                    )
+                    raise ValueError(msg)
                 chain.append(base_name)
             fixture_base = copy.copy(self[fixture_name])
             logger.debug("'%s' will inherit from '%s'", self.model_type, fixture_name)

shepherd_core/version.py

@@ -1,3 +1,3 @@
 """Separated string avoids circular imports."""
 
-version: str = "2025.04.2"
+version: str = "2025.05.2"

shepherd_core/vsource/virtual_harvester_simulation.py

@@ -54,7 +54,7 @@ def simulate_harvester(
     e_out_Ws = 0.0
 
     for _t, v_inp, i_inp in tqdm(
-        file_inp.read_buffers(is_raw=True), total=file_inp.buffers_n, desc="Buffers", leave=False
+        file_inp.read(is_raw=True), total=file_inp.chunks_n, desc="Chunk", leave=False
     ):
         v_uV = cal_inp.voltage.raw_to_si(v_inp) * 1e6
         i_nA = cal_inp.current.raw_to_si(i_inp) * 1e9

shepherd_core/vsource/virtual_source_simulation.py

@@ -74,7 +74,7 @@ def simulate_source(
         stats_internal = None
 
     for _t, v_inp, i_inp in tqdm(
-        file_inp.read_buffers(is_raw=True), total=file_inp.buffers_n, desc="Buffers", leave=False
+        file_inp.read(is_raw=True), total=file_inp.chunks_n, desc="Chunk", leave=False
     ):
         v_uV = 1e6 * cal_inp.voltage.raw_to_si(v_inp)
         i_nA = 1e9 * cal_inp.current.raw_to_si(i_inp)

shepherd_core/writer.py

@@ -94,7 +94,7 @@ class Writer(Reader):
     MODE_DEFAULT: str = "harvester"
     DATATYPE_DEFAULT: EnergyDType = EnergyDType.ivsample
 
-    _CHUNK_SHAPE: tuple = (Reader.BUFFER_SAMPLES_N,)
+    _CHUNK_SHAPE: tuple = (Reader.CHUNK_SAMPLES_N,)
 
     @validate_call
     def __init__(
@@ -240,7 +240,7 @@ class Writer(Reader):
         # Store voltage and current samples in the data group,
         # both are stored as 4 Byte unsigned int
         grp_data = self.h5file.create_group("data")
-        # the size of window_samples-attribute in harvest-data indicates ivcurves as input
+        # the size of window_samples-attribute in harvest-data indicates ivsurface / curves as input
         # -> emulator uses virtual-harvester, field will be adjusted by .embed_config()
         grp_data.attrs["window_samples"] = 0
 
@@ -287,7 +287,7 @@ class Writer(Reader):
 
         Args:
         ----
-            timestamp: just start of buffer or whole ndarray
+            timestamp: just start of chunk (1 timestamp) or whole ndarray
             voltage: ndarray as raw unsigned integers
             current: ndarray as raw unsigned integers
 
@@ -331,7 +331,7 @@ class Writer(Reader):
         Args:
         ----
             timestamp: python timestamp (time.time()) in seconds (si-unit)
-                       -> provide start of buffer or whole ndarray
+                       -> provide start of chunk (1 timestamp) or whole ndarray
             voltage: ndarray in physical-unit V
             current: ndarray in physical-unit A
 
@@ -343,16 +343,16 @@ class Writer(Reader):
         self.append_iv_data_raw(timestamp, voltage, current)
 
     def _align(self) -> None:
-        """Align datasets with buffer-size of shepherd."""
+        """Align datasets with chunk-size of shepherd."""
         self._refresh_file_stats()
-        n_buff = self.ds_voltage.size / self.BUFFER_SAMPLES_N
-        size_new = int(math.floor(n_buff) * self.BUFFER_SAMPLES_N)
+        chunks_n = self.ds_voltage.size / self.CHUNK_SAMPLES_N
+        size_new = int(math.floor(chunks_n) * self.CHUNK_SAMPLES_N)
         if size_new < self.ds_voltage.size:
             if self.samplerate_sps != SAMPLERATE_SPS_DEFAULT:
                 self._logger.debug("skipped alignment due to altered samplerate")
                 return
             self._logger.info(
-                "aligning with buffer-size, discarding last %d entries",
+                "aligning with chunk-size, discarding last %d entries",
                 self.ds_voltage.size - size_new,
             )
             self.ds_time.resize((size_new,))

{shepherd_core-2025.4.2.dist-info → shepherd_core-2025.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shepherd_core
-Version: 2025.4.2
+Version: 2025.5.2
 Summary: Programming- and CLI-Interface for the h5-dataformat of the Shepherd-Testbed
 Author-email: Ingmar Splitt <ingmar.splitt@tu-dresden.de>
 Maintainer-email: Ingmar Splitt <ingmar.splitt@tu-dresden.de>

{shepherd_core-2025.4.2.dist-info → shepherd_core-2025.5.2.dist-info}/RECORD

@@ -2,12 +2,12 @@ shepherd_core/__init__.py,sha256=fCld2mcl0y0h6kRyPal3DP-sWXnKl_0aYWYBdg4QuUk,127
 shepherd_core/calibration_hw_def.py,sha256=aL94bA1Sf14L5A3PLdVvQVYtGi28S4NUWA65wbim8bw,2895
 shepherd_core/commons.py,sha256=rTxtndtiJ4cOHYRPRbdZdqp6T90CKFFN-I-YAFzhm4Q,200
 shepherd_core/logger.py,sha256=i8j3alm8icAx_h1_IZ6SgVgC9W5J7S-bDc31mPDWl-w,1812
-shepherd_core/reader.py,sha256=Xu_MSADsR4Xzh8YH-N50mKIHZlhPyFigv8umQSsYsJ0,28320
-shepherd_core/version.py,sha256=dd_uzGz0uQwh1pttFJSjXzIKovnBzMAXJGgpRa5QR34,76
-shepherd_core/writer.py,sha256=HRiCnJRM4hIBT6UBZJZ5ZOZ79OyBpBN4a2kX-XmOYRE,14574
-shepherd_core/data_models/__init__.py,sha256=bnHSP_HBOYm4WuoiHs_vyiRsWlvkyDjsarMNfKedN-Q,1836
+shepherd_core/reader.py,sha256=EYgpL09DMrACiDHoG3LbgSJrci4pCPY3r13X0XVNVLI,29179
+shepherd_core/version.py,sha256=p9ZnvPFg9wu9KOtST8r_-f6-9CC_FMIG7IhKqfjDez4,76
+shepherd_core/writer.py,sha256=_ji3X2bb4JKZZm4uz8DO9uG_WoHL5Zpg6_Na36WAF5o,14609
+shepherd_core/data_models/__init__.py,sha256=Fl9Lhdo32mrdF232ZjOnkawQYeFsUbTS4FOUrvmSzlM,1909
 shepherd_core/data_models/readme.md,sha256=DHPVmkWqDksWomRHRTVWVHy9wXF9oMJrITgKs4Pnz2g,2494
-shepherd_core/data_models/virtual_source_doc.txt,sha256=KizMcfGKj7BnHIbaJHT7KeTF01SV__UXv01qV_DGHSs,6057
+shepherd_core/data_models/virtual_source_doc.txt,sha256=OK_7zYbLvr6cEj3KaUcWwZJ9naoFB2KwAaXudbhzouQ,6076
 shepherd_core/data_models/base/__init__.py,sha256=PSJ6acWViqBm0Eiom8DIgKfFVrp5lzYr8OsDvP79vwI,94
 shepherd_core/data_models/base/cal_measurement.py,sha256=c-vjACNxsQY8LU2Msw0COrsTY-8pToJ5ZWkOztJ9tVY,3380
 shepherd_core/data_models/base/calibration.py,sha256=oUTfY6iUWUbBbOw5aMCRkdEfHzIV8aUrhwqek0QzPJM,10849
@@ -16,25 +16,25 @@ shepherd_core/data_models/base/shepherd.py,sha256=P1xW10_vIbGNyQ3Ary67vyovw9kmDt
 shepherd_core/data_models/base/timezone.py,sha256=2T6E46hJ1DAvmqKfu6uIgCK3RSoAKjGXRyzYNaqKyjY,665
 shepherd_core/data_models/base/wrapper.py,sha256=7QwvI30GuORH7WmyGLnRMsZ3xkRRkXIAvZ-pYRAL-WI,755
 shepherd_core/data_models/content/__init__.py,sha256=69aiNG0h5t1OF7HsLg_ke5eaQKsKyMK8o6Kfaby5vlY,525
-shepherd_core/data_models/content/_external_fixtures.yaml,sha256=0CH7YSWT_hzL-jcg4JjgN9ryQOzbS8S66_pd6GbMnHw,12259
-shepherd_core/data_models/content/energy_environment.py,sha256=emlVFbcPA0-_jgpYI0Xwebm81_gWLYD8Tex0XVtJr4c,1618
+shepherd_core/data_models/content/_external_fixtures.yaml,sha256=Iv0T5cN8BFVELuLtmxml2-xwcMDMZWF7LOu_TM3RIJ8,12184
+shepherd_core/data_models/content/energy_environment.py,sha256=DSTB3CE3XEBXaL16z4FVaHSyLnp0bfxUgw3SnQrUpf0,1628
 shepherd_core/data_models/content/energy_environment_fixture.yaml,sha256=UBXTdGT7MK98zx5w_RBCu-f9uNCKxRgiFBQFbmDUxPc,1301
 shepherd_core/data_models/content/firmware.py,sha256=KLByo1GuUMJ8ZbM6WccB8IJArorNetBxqOpuUb2_QIE,5926
 shepherd_core/data_models/content/firmware_datatype.py,sha256=XPU9LOoT3h5qFOlE8WU0vAkw-vymNxzor9kVFyEqsWg,255
-shepherd_core/data_models/content/virtual_harvester.py,sha256=PQ3CykoMgMoklmb_vypRdU512BuVhV-KjPTmBPKTzCM,11227
-shepherd_core/data_models/content/virtual_harvester_fixture.yaml,sha256=LZe5ue1xYhXZwB3a32sva-L4uKhkQA5AtG9JzW4B2hQ,4564
-shepherd_core/data_models/content/virtual_source.py,sha256=ftCcWCYKHw854lGwuxLf_ZIOY6O9vLixHHC77BqcSQA,15441
-shepherd_core/data_models/content/virtual_source_fixture.yaml,sha256=1o-31mGgn7eyCNidKoOUp9vZh3K4Al0kJgmz54Q2DAE,11191
+shepherd_core/data_models/content/virtual_harvester.py,sha256=QLyOLH0Q1E8NKWgWyMd4e65iEA13CVHmdf7kLf4SqFk,11287
+shepherd_core/data_models/content/virtual_harvester_fixture.yaml,sha256=4eNQyFI9LozpButOTlBQ07T0MFCaPEYIxwtedMjUf3U,4575
+shepherd_core/data_models/content/virtual_source.py,sha256=4TAk7jgXCQh6MMnT0Ijw_AdE6YPgrbSwFfb8F1V6RVE,15565
+shepherd_core/data_models/content/virtual_source_fixture.yaml,sha256=tsSJ1mM4OSPSeNkqVoZlDQ8Az3N8KeTXd0oA2JKd-hk,11201
 shepherd_core/data_models/experiment/__init__.py,sha256=lorsx0M-JWPIrt_UZfexsLwaITv5slFb3krBOt0idm8,618
-shepherd_core/data_models/experiment/experiment.py,sha256=h24HaZltat0mKbOT1h9O58B5noTIUcGQbBIzmPi4oo8,4232
-shepherd_core/data_models/experiment/observer_features.py,sha256=u6nJthpluZrxw9ym_rvkTrlOQTKlc1TY5b1HPqbO4Jg,5185
-shepherd_core/data_models/experiment/target_config.py,sha256=ZODI4_MwBLxKTQ1DwFrLZAuKprxDiLyg5-JYOQxXp_w,3808
-shepherd_core/data_models/task/__init__.py,sha256=3wTIJ1L5wcRDLR6JRaT0bNh7vABckSoOd5erPwhhCGI,3331
-shepherd_core/data_models/task/emulation.py,sha256=PfSWci9V47EWpJRTKyHBxQZodHs3yQXMce0Mslm_-Ns,6665
+shepherd_core/data_models/experiment/experiment.py,sha256=oFOpyxHmwCZmbJAejyoqAAjarA2ZgnNYEx6Qf7TPjqU,4178
+shepherd_core/data_models/experiment/observer_features.py,sha256=xCaN2wymG-ygEy19jTIvY9YyitdjPWepDH5UjXdq8Y8,8315
+shepherd_core/data_models/experiment/target_config.py,sha256=nlOZvLC5C6Pjn-ZEXLMr5WZlC1edixL_l3rWi93UPZE,4082
+shepherd_core/data_models/task/__init__.py,sha256=m7_OK05djkoDt-XwKQ6gPT7qIcCUoyBxZgSXvD3HmzQ,3386
+shepherd_core/data_models/task/emulation.py,sha256=-JzRm-xRp421Xl4lBkT52AEhTkb8ZqH9C1Z8CeHPHF8,7380
 shepherd_core/data_models/task/firmware_mod.py,sha256=WLmevU9-Q5QnyANbkrSCdFbnVuSi8N8fXdQ2l_Um9e8,3034
 shepherd_core/data_models/task/harvest.py,sha256=rQ5Aq40m4WHpEFfiwn309GjLIPu4aKzF4Fvbo4j7PLs,3470
 shepherd_core/data_models/task/observer_tasks.py,sha256=icUPtoIqic8IpE0U9Fc7btMj4CpYx1PoAu_wAqqZkU8,3608
-shepherd_core/data_models/task/programming.py,sha256=6UHb8rT1M3bglt_3fHql6MsHE8sTvi9ii7Uhug5O4PM,2552
+shepherd_core/data_models/task/programming.py,sha256=jX_5biD6BGkBdIS652CajXWm0KOgY3w1Z3AOJIFgTws,2573
 shepherd_core/data_models/task/testbed_tasks.py,sha256=J3aOSVVG1KvEI_83j0TK0gc5rN_v_T-URFRhrEs8czY,2176
 shepherd_core/data_models/testbed/__init__.py,sha256=t9nwml5pbu7ZWghimOyZ8ujMIgnRgFkl23pNb5d_KdU,581
 shepherd_core/data_models/testbed/cape.py,sha256=vfS05D0rC1-_wMiHeLw69VE9PxXC6PHl9ndtrv219_k,1396
@@ -42,7 +42,7 @@ shepherd_core/data_models/testbed/cape_fixture.yaml,sha256=uwZxe6hsqvofn5tzg4sff
 shepherd_core/data_models/testbed/gpio.py,sha256=pOY_7Zs32sRGuqJZrZDrjvr69QkFXC8iXgav7kk2heY,2334
 shepherd_core/data_models/testbed/gpio_fixture.yaml,sha256=yXvoXAau2hancKi2yg1xIkErPWQa6gIxNUG3y8JuF9Y,3076
 shepherd_core/data_models/testbed/mcu.py,sha256=fuq2AWbVFbbzPRPCgIeMNFhJhVNCIsmpjFagnOXkjbY,1514
-shepherd_core/data_models/testbed/mcu_fixture.yaml,sha256=lRZMLs27cTeERSFGkbMt5xgxbn11Gh9G1mQqOZK136I,522
+shepherd_core/data_models/testbed/mcu_fixture.yaml,sha256=bOYXdQY-6JYesxOkZAT8WvuGsdUc_MW4dkAmopLL8RM,507
 shepherd_core/data_models/testbed/observer.py,sha256=RO7i9TmHcxx69P-EHN59M9MAJetoHZg5qJUD5SEtrcg,3386
 shepherd_core/data_models/testbed/observer_fixture.yaml,sha256=jqAatTebWrShXBlhqkCUQIrtVqEjl7RVDR9mosS2LJQ,4807
 shepherd_core/data_models/testbed/target.py,sha256=W7U9nCz_xWMRCCgaGuqOV4dGi4ZeQ1SAp7W2FqCkanU,1978
@@ -53,29 +53,29 @@ shepherd_core/data_models/testbed/testbed_fixture.yaml,sha256=LaaU8mXLQboYWYNPpA
 shepherd_core/decoder_waveform/__init__.py,sha256=-ohGz0fA2tKxUJk4FAQXKtI93d6YGdy0CrkdhOod1QU,120
 shepherd_core/decoder_waveform/uart.py,sha256=vuw9fKwZb_1mMtQ5fdiZN8Cr1YWSgYKar9FIMK8Bogo,11084
 shepherd_core/fw_tools/__init__.py,sha256=D9GGj9TzLWZfPjG_iV2BsF-Q1TGTYTgEzWTUI5ReVAA,2090
-shepherd_core/fw_tools/converter.py,sha256=F06iJlYYG2w-OCKayrgeO870lOX87xWVTYTAi1X3UPU,3604
+shepherd_core/fw_tools/converter.py,sha256=V74V-82VVkvkZ2i4HI7K_291_FGZNjxVdX6eO7Y3Zks,3657
 shepherd_core/fw_tools/converter_elf.py,sha256=GQDVqIqMW4twNMvZIV3sowFMezhs2TN-IYREjRP7Xt4,1089
 shepherd_core/fw_tools/patcher.py,sha256=ISbnA2ZLTIV2JZh_b3GorNDGNrLaBN0fFnFnyh-smNU,3946
-shepherd_core/fw_tools/validation.py,sha256=GWm_T3xmRde-jQ8cf27kPosBTFTK3E2M2LSb24pT2g8,4732
+shepherd_core/fw_tools/validation.py,sha256=KxOBtAgqUemZC_Lj1_xtV6AMpGLU04_epxihMF3RX7U,4792
 shepherd_core/inventory/__init__.py,sha256=yQxP55yV61xXWfZSSzekQQYopPZCspFpHSyG7VTqtpg,3819
 shepherd_core/inventory/python.py,sha256=pvugNgLZaDllIXX_KiuvpcWUWlJtD2IUKYDRjcTGQss,1262
 shepherd_core/inventory/system.py,sha256=qFTRVXClQZoCeV2KM8RAbst8XL7IaJwwV0pGHPZSJs4,3325
 shepherd_core/inventory/target.py,sha256=zLUNQs2FE7jMDsiRtbeAwqRVcit4e2F1UUOF04xw-XY,520
 shepherd_core/testbed_client/__init__.py,sha256=QtbsBUzHwOoM6rk0qa21ywuz63YV7af1fwUtWW8Vg_4,234
 shepherd_core/testbed_client/cache_path.py,sha256=tS0er9on5fw8wddMCt1jkc2uyYOdSTvX_UmfmYJf6tY,445
-shepherd_core/testbed_client/client_abc_fix.py,sha256=3oDg2RSEP88mygtX820Y-685kYKvqQK_hwp2iFylLUU,4265
+shepherd_core/testbed_client/client_abc_fix.py,sha256=xMch4y6vMMLRiqFEry2zSnYuLM6Ay-fY0dunXMz9Hws,4250
 shepherd_core/testbed_client/client_web.py,sha256=zqY4MGMWfTl2_0T1qrQl5Vz9SPjl-wMj8O5yMMQyo9I,6044
-shepherd_core/testbed_client/fixtures.py,sha256=OyL50wEuJ8336RPtinxOFbUsIVtLrgyO2_ROOyiBTEE,9317
+shepherd_core/testbed_client/fixtures.py,sha256=ftPJwiOn-USroIee2Al3evR3WxsA1SxERusoZ-jbkVk,9223
 shepherd_core/testbed_client/user_model.py,sha256=f4WZ8IvSCt3s1RG_Bhi43ojiJQsZYyolJ3Ft8HNRYas,2175
 shepherd_core/vsource/__init__.py,sha256=vTvFWuJn4eurPNzEiMd15c1Rd6o3DTWzCfbhOomflZU,771
 shepherd_core/vsource/target_model.py,sha256=BjOlwX_gIOJ91e4OOLB4_OsCpuhq9vm57ERjM-iBhAM,5129
 shepherd_core/vsource/virtual_converter_model.py,sha256=jUnJwP-FFDMtXm1NCLUJfZTvImYH4_A9rc_lXVAZ33I,11628
 shepherd_core/vsource/virtual_harvester_model.py,sha256=8uPTMDth4KI5XarkX9EJtMRZ_8eWUeWCZxgmx4be3Fs,9763
-shepherd_core/vsource/virtual_harvester_simulation.py,sha256=H4m9lB4Hk_sskGi3LoFYARBpq1uY3WsJj-ktF3nk2Ck,2558
+shepherd_core/vsource/virtual_harvester_simulation.py,sha256=eK9uCn-j_8xSTa7BQhG879ep0oZDeatlnF31LeWEDiM,2547
 shepherd_core/vsource/virtual_source_model.py,sha256=-8RwBrkIdO0g4zpo7XHnqv8F_qNh_qf5hxEUJoIuAmg,3164
-shepherd_core/vsource/virtual_source_simulation.py,sha256=6FKbaO-zaODp0nf-ksnl-nRAVpFKGQrpxpIBrGIhD0I,5284
-shepherd_core-2025.4.2.dist-info/METADATA,sha256=SD_1RcpaF_Pb-IbG2uAh7xkWHJv8TOaqy8c0zQI7Q1o,7756
-shepherd_core-2025.4.2.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-shepherd_core-2025.4.2.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
-shepherd_core-2025.4.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-shepherd_core-2025.4.2.dist-info/RECORD,,
+shepherd_core/vsource/virtual_source_simulation.py,sha256=6voU1TAB2P0xuVu1bnyKa-xW9rwYXUC6f06gYtUDHTs,5273
+shepherd_core-2025.5.2.dist-info/METADATA,sha256=nACqRWB12RTUhFeUPiKcnw7UvP2YEV4ZNg-kKRGkWSw,7756
+shepherd_core-2025.5.2.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+shepherd_core-2025.5.2.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
+shepherd_core-2025.5.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+shepherd_core-2025.5.2.dist-info/RECORD,,

{shepherd_core-2025.4.2.dist-info → shepherd_core-2025.5.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any