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

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,23 @@ class Reader:
                 self.file_path.name,
             )
         # same length of datasets:
-        ds_volt_size = self.h5file["data"]["voltage"].shape[0]
-        for dset in ["current", "time"]:
+        samples_n = self.h5file["data"]["time"].shape[0]
+        for dset in ["voltage", "current"]:
             ds_size = self.h5file["data"][dset].shape[0]
-            if ds_volt_size != ds_size:
+            if ds_size != samples_n:
                 self._logger.warning(
                     "[FileValidation] dataset '%s' has different size (=%d), "
-                    "compared to time-ds (=%d), in '%s'",
+                    "compared to time (=%d), in '%s'",
                     dset,
                     ds_size,
-                    ds_volt_size,
+                    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 = 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 +483,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 +494,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 +548,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 +568,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 +593,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

@@ -2,6 +2,7 @@
 
 import copy
 import pickle
+from collections.abc import Iterable
 from collections.abc import Mapping
 from datetime import datetime
 from datetime import timedelta
@@ -34,11 +35,11 @@ class Fixture:
 
     def __init__(self, model_type: str) -> None:
         self.model_type: str = model_type.lower()
-        self.elements_by_name: dict[str, dict] = {}
-        self.elements_by_id: dict[int, dict] = {}
+        self.elements_by_name: dict[str, dict[str, Any]] = {}
+        self.elements_by_id: dict[int, dict[str, Any]] = {}
         # Iterator reset
         self._iter_index: int = 0
-        self._iter_list: list = list(self.elements_by_name.values())
+        self._iter_list: list[dict[str, Any]] = list(self.elements_by_name.values())
 
     def insert(self, data: Wrapper) -> None:
         # ⤷ TODO: could get easier
@@ -54,9 +55,10 @@ class Fixture:
         self.elements_by_name[name] = data_model
         self.elements_by_id[_id] = data_model
         # update iterator
-        self._iter_list = list(self.elements_by_name.values())
+        self._iter_list: list[dict[str, Any]] = list(self.elements_by_name.values())
 
-    def __getitem__(self, key: Union[str, int]) -> dict:
+    def __getitem__(self, key: Union[str, int]) -> dict[str, Any]:
+        original_key = key
         if isinstance(key, str):
             key = key.lower()
             if key in self.elements_by_name:
@@ -65,7 +67,7 @@ class Fixture:
                 key = int(key)
         if key in self.elements_by_id:
             return self.elements_by_id[int(key)]
-        msg = f"{self.model_type} '{key}' not found!"
+        msg = f"{self.model_type} '{original_key}' not found!"
         raise ValueError(msg)
 
     def __iter__(self) -> Self:
@@ -73,14 +75,14 @@ class Fixture:
         self._iter_list = list(self.elements_by_name.values())
         return self
 
-    def __next__(self) -> Any:
+    def __next__(self) -> dict[str, Any]:
         if self._iter_index < len(self._iter_list):
             member = self._iter_list[self._iter_index]
             self._iter_index += 1
             return member
         raise StopIteration
 
-    def keys(self):  # noqa: ANN201
+    def keys(self) -> Iterable[str]:
         return self.elements_by_name.keys()
 
     def refs(self) -> dict:
@@ -101,14 +103,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)
@@ -153,13 +151,13 @@ class Fixture:
             base[key] = value
         return base
 
-    def query_id(self, _id: int) -> dict:
+    def query_id(self, _id: int) -> dict[str, Any]:
         if isinstance(_id, int) and _id in self.elements_by_id:
             return self.elements_by_id[_id]
         msg = f"Initialization of {self.model_type} by ID failed - {_id} is unknown!"
         raise ValueError(msg)
 
-    def query_name(self, name: str) -> dict:
+    def query_name(self, name: str) -> dict[str, Any]:
         if isinstance(name, str) and name.lower() in self.elements_by_name:
             return self.elements_by_name[name.lower()]
         msg = f"Initialization of {self.model_type} by name failed - {name} is unknown!"
@@ -243,7 +241,7 @@ class Fixtures:
         msg = f"Component '{key}' not found!"
         raise ValueError(msg)
 
-    def keys(self):  # noqa: ANN201
+    def keys(self) -> Iterable[str]:
         return self.components.keys()
 
     @staticmethod

shepherd_core/testbed_client/user_model.py

@@ -5,10 +5,7 @@ from hashlib import pbkdf2_hmac
 from typing import Annotated
 from typing import Any
 from typing import Optional
-from typing import Union
-from uuid import uuid4
 
-from pydantic import UUID4
 from pydantic import EmailStr
 from pydantic import Field
 from pydantic import SecretBytes
@@ -19,6 +16,7 @@ from pydantic import validate_call
 
 from shepherd_core.data_models.base.content import NameStr
 from shepherd_core.data_models.base.content import SafeStr
+from shepherd_core.data_models.base.content import id_default
 from shepherd_core.data_models.base.shepherd import ShpModel
 
 
@@ -41,10 +39,9 @@ def hash_password(pw: Annotated[str, StringConstraints(min_length=20, max_length
 class User(ShpModel):
     """meta-data representation of a testbed-component (physical object)."""
 
-    # id: UUID4 = Field(  # TODO: db-migration - temp fix for documentation
-    id: Union[UUID4, int] = Field(
+    id: int = Field(
         description="Unique ID",
-        default_factory=uuid4,
+        default_factory=id_default,
     )
     name: NameStr
     description: Optional[SafeStr] = None

shepherd_core/version.py

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

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.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shepherd_core
-Version: 2025.4.2
+Version: 2025.5.3
 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>