shepherd-core 2025.8.1__py3-none-any.whl → 2026.2.1__py3-none-any.whl

shepherd_core/vsource/virtual_storage_models_kibam.py

@@ -0,0 +1,449 @@
+"""Original KiBaM-Models with varying quality of detail."""
+
+import math
+import sys
+from collections.abc import Callable
+
+from pydantic import BaseModel
+from pydantic import PositiveFloat
+from pydantic import PositiveInt
+from pydantic import validate_call
+from typing_extensions import Self
+
+from shepherd_core.data_models.content.virtual_storage_config import LuT_SIZE
+from shepherd_core.data_models.content.virtual_storage_config import TIMESTEP_s_DEFAULT
+from shepherd_core.data_models.content.virtual_storage_config import VirtualStorageConfig
+from shepherd_core.data_models.content.virtual_storage_config import soc_t
+
+from .virtual_storage_model import ModelStorage
+
+
+class LUT(BaseModel):
+    """Dynamic look-up table that can automatically be generated from a function."""
+
+    x_min: float
+    y_values: list[float]
+    length: int
+    interpolate: bool = False
+
+    @classmethod
+    @validate_call
+    def generate(
+        cls,
+        x_min: PositiveFloat,
+        y_fn: Callable,
+        lut_size: PositiveInt = LuT_SIZE,
+        *,
+        optimize_clamp: bool = False,
+        interpolate: bool = False,
+    ) -> Self:
+        """
+        Generate a LUT with a specific width from a provided function.
+
+        It has a minimum value, a size / width and a scale (linear / log2).
+        y_fnc is a function that takes an argument and produces the lookup value.
+        """
+        if interpolate:
+            # Note: dynamically creating .get() with setattr() was not successful
+            optimize_clamp = False
+
+        offset = 0.5 if optimize_clamp else 0
+        x_values = [(i + offset) * x_min for i in range(lut_size)]
+        y_values = [y_fn(x) for x in x_values]
+        return cls(x_min=x_min, y_values=y_values, length=lut_size, interpolate=interpolate)
+
+    def get(self, x_value: float) -> float:
+        return self.get_interpol(x_value) if self.interpolate else self.get_discrete(x_value)
+
+    def get_discrete(self, x_value: float) -> float:
+        """Discrete LuT-lookup with typical stairs."""
+        num = int(x_value / self.x_min)
+        # ⤷ round() would be more appropriate, but in c/pru its just integer math
+        idx = max(0, num)
+        if idx >= self.length:  # len(self.y_values)
+            idx = self.length - 1
+        return self.y_values[idx]
+
+    def get_interpol(self, x_value: float) -> float:
+        """LuT-lookup with additional interpolation.
+
+        Note: optimize-clamp must be disabled, otherwise this produces an offset
+        """
+        num = x_value / self.x_min
+        if num <= 0:
+            return self.y_values[0]
+        if num >= self.length - 1:
+            return self.y_values[self.length - 1]
+
+        idx: int = math.floor(num)
+        # high could be math.ceil(num), but also idx+1
+        num_f: float = num - idx
+        y_base = self.y_values[idx]
+        y_delta = self.y_values[idx + 1] - y_base
+        # TODO: y_delta[idx_l] could be a seconds LuT
+        return y_base + y_delta * num_f
+
+
+class ModelKiBaM(ModelStorage):
+    """Naive implementation of the full hybrid KiBaM model from the paper.
+
+    Introduced in "A Hybrid Battery Model Capable of Capturing Dynamic Circuit
+    Characteristics and Nonlinear Capacity Effects".
+
+    It is mostly focused on discharge, so it won't support
+
+    - rate capacity effect and transients during charging
+    - self discharge (as it was deemed too small)
+    """
+
+    @validate_call
+    def __init__(
+        self,
+        cfg: VirtualStorageConfig,
+        SoC_init: soc_t | None = None,
+        dt_s: PositiveFloat = TIMESTEP_s_DEFAULT,
+    ) -> None:
+        # metadata for simulator
+        self.cfg: VirtualStorageConfig = cfg
+        self.dt_s: float = dt_s
+        # state
+        self.SoC: float = SoC_init if SoC_init is not None else cfg.SoC_init
+        self.time_s: float = 0
+
+        # Rate capacity effect
+        self.C_unavailable: float = 0
+        self.C_unavailable_last: float = 0
+
+        # Transient tracking
+        self.V_transient_S_max: float = 0
+        self.V_transient_L_max: float = 0
+        self.discharge_last: bool = False
+
+        # Modified transient tracking
+        self.V_transient_S: float = 0
+        self.V_transient_L: float = 0
+
+    def step(self, I_charge_A: float) -> tuple[float, float, float, float]:
+        """Calculate the battery SoC & cell-voltage after drawing a current over a time-step."""
+        # Step 1 verified separately using Figure 4
+        # Steps 1 and 2 verified separately using Figure 10
+        # Complete model verified using Figures 8 (a, b) and Figure 9 (a, b)
+        I_cell = -I_charge_A
+
+        # Step 0: Determine whether battery is charging or resting and
+        #         calculate time since last switch
+        if self.discharge_last != (I_cell > 0):  # Reset time delta when current sign changes
+            self.discharge_last = I_cell > 0
+            self.time_s = 0
+            self.C_unavailable_last = self.C_unavailable
+            # ⤷ Save C_unavailable at time of switch
+
+        self.time_s += self.dt_s
+        # ⤷ Consider time delta including this iteration (we want v_trans after the current step)
+
+        # Step 1: Calculate unavailable capacity after dt
+        #         (due to rate capacity and recovery effect) (equation 17)
+        # Note: it seems possible to remove the 2nd branch if
+        #       charging is considered (see Plus-Model)
+        if I_cell > 0:  # Discharging
+            self.C_unavailable = (
+                self.C_unavailable_last * math.pow(math.e, -self.cfg.kdash * self.time_s)
+                + (1 - self.cfg.p_rce)
+                * I_cell
+                / self.cfg.p_rce
+                * (1 - math.pow(math.e, -self.cfg.kdash * self.time_s))
+                / self.cfg.kdash
+            )
+        else:  # Recovering
+            self.C_unavailable = self.C_unavailable_last * math.pow(
+                math.e, -self.cfg.kdash * self.time_s
+            )
+
+        # Step 2: Calculate SoC after dt (equation 6; modified for discrete operation)
+        # ⤷ MODIFIED: clamp both SoC to 0..1
+        self.SoC -= 1 / self.cfg.q_As * (I_cell * self.dt_s)
+        self.SoC = min(max(self.SoC, 0.0), 1.0)
+        SoC_eff = self.SoC - 1 / self.cfg.q_As * self.C_unavailable
+        SoC_eff = max(SoC_eff, 0.0)
+
+        # Step 3: Calculate V_OC after dt (equation 7)
+        V_OC = self.cfg.calc_V_OC(SoC_eff)
+
+        # Step 4: Calculate resistance and capacitance values after dt (equation 12)
+        R_series = self.cfg.calc_R_series(SoC_eff)
+        R_transient_S = self.cfg.calc_R_transient_S(SoC_eff)
+        C_transient_S = self.cfg.calc_C_transient_S(SoC_eff)
+        R_transient_L = self.cfg.calc_R_transient_L(SoC_eff)
+        C_transient_L = self.cfg.calc_C_transient_L(SoC_eff)
+
+        # Step 5: Calculate transient voltages (equations 10 and 11)
+        # ⤷ MODIFIED: prevent both tau_X from becoming 0
+        tau_S = max(R_transient_S * C_transient_S, sys.float_info.min)
+        if I_cell > 0:  # Discharging
+            V_transient_S = R_transient_S * I_cell * (1 - math.pow(math.e, -self.time_s / tau_S))
+            self.V_transient_S_max = V_transient_S
+        else:  # Recovering
+            V_transient_S = self.V_transient_S_max * math.pow(math.e, -self.time_s / tau_S)
+
+        tau_L = max(R_transient_L * C_transient_L, sys.float_info.min)
+        if I_cell > 0:  # Discharging
+            V_transient_L = R_transient_L * I_cell * (1 - math.pow(math.e, -self.time_s / tau_L))
+            self.V_transient_L_max = V_transient_L
+        else:  # Recovering
+            V_transient_L = self.V_transient_L_max * math.pow(math.e, -self.time_s / tau_L)
+
+        # Step 6: Calculate cell voltage (equations 8 and 9)
+        # ⤷ MODIFIED: limit V_cell to >=0
+        V_transient = V_transient_S + V_transient_L
+        V_cell = V_OC - I_cell * R_series - V_transient
+        V_cell = max(V_cell, 0)
+
+        return V_OC, V_cell, self.SoC, SoC_eff
+
+
+class ModelKiBaMPlus(ModelStorage):
+    """Hybrid KiBaM model from the paper with certain extensions.
+
+    Extended by [@jonkub](https://github.com/jonkub) with streamlined math.
+
+    Modifications:
+
+    1. support rate capacity during charging (Step 1)
+    2. support transient tracking during charging (Step 5)
+    3. support self discharge (step 2a) via a parallel leakage resistor
+    4. support signaling 0 % SoC by nulling voltage
+    """
+
+    @validate_call
+    def __init__(
+        self,
+        cfg: VirtualStorageConfig,
+        SoC_init: soc_t | None = None,
+        dt_s: PositiveFloat = TIMESTEP_s_DEFAULT,
+    ) -> None:
+        # metadata for simulator
+        self.cfg: VirtualStorageConfig = cfg
+        self.dt_s: float = dt_s
+        # state
+        self.SoC: float = SoC_init if SoC_init is not None else cfg.SoC_init
+        self.time_s: float = 0
+
+        # Rate capacity effect
+        self.C_unavailable: float = 0
+        self.C_unavailable_last: float = 0
+
+        # Transient tracking
+        self.discharge_last: bool = False
+
+        # Modified transient tracking
+        self.V_transient_S: float = 0
+        self.V_transient_L: float = 0
+
+    def step(self, I_charge_A: float) -> tuple[float, float, float, float]:
+        """Calculate the battery SoC & cell-voltage after drawing a current over a time-step.
+
+        - Step 1 verified separately using Figure 4
+        - Steps 1 and 2 verified separately using Figure 10
+        - Complete model verified using Figures 8 (a, b) and Figure 9 (a, b)
+        """
+        I_cell = -I_charge_A
+
+        # Step 0: Determine whether battery is charging or resting and
+        #         calculate time since last switch
+        if self.discharge_last != (I_cell > 0):  # Reset time delta when current sign changes
+            self.discharge_last = I_cell > 0
+            self.time_s = 0
+            self.C_unavailable_last = self.C_unavailable  # Save C_unavailable at time of switch
+
+        self.time_s += self.dt_s
+        # ⤷ Consider time delta including this iteration (we want v_trans after the current step)
+
+        # Step 1: Calculate unavailable capacity after dt
+        #         (due to rate capacity and recovery effect) (equation 17)
+        # TODO: if this should be used in production, additional verification is required
+        #      (analytically derive versions of eq. 16/17 without time range restrictions)
+        #       parameters for rate effect could only be valid for discharge
+        #       Note: other paper has charging-curves (fig9b) - could be used for verification
+        self.C_unavailable = (
+            self.C_unavailable_last * math.pow(math.e, -self.cfg.kdash * self.time_s)
+            + (1 - self.cfg.p_rce)
+            * I_cell
+            / self.cfg.p_rce
+            * (1 - math.pow(math.e, -self.cfg.kdash * self.time_s))
+            / self.cfg.kdash
+        )
+
+        # Step 2a: Calculate and add self-discharge current to SoC-Eq. below
+        I_leak = self.cfg.calc_V_OC(self.SoC) / self.cfg.R_leak_Ohm
+
+        # Step 2: Calculate SoC after dt (equation 6; modified for discrete operation)
+        # ⤷ MODIFIED: clamp both SoC to 0..1
+        self.SoC -= (I_cell + I_leak) * self.dt_s / self.cfg.q_As
+        self.SoC = min(max(self.SoC, 0.0), 1.0)
+        SoC_eff = self.SoC - 1 / self.cfg.q_As * self.C_unavailable
+        SoC_eff = min(max(SoC_eff, 0.0), 1.0)
+        # ⤷ Note: limiting SoC_eff to <=1 should NOT be needed, but
+        #         C_unavailable can become negative during charging (see assumption in step1).
+
+        # Step 3: Calculate V_OC after dt (equation 7)
+        V_OC = self.cfg.calc_V_OC(SoC_eff)
+
+        # Step 4: Calculate resistance and capacitance values after dt (equation 12)
+        R_series = self.cfg.calc_R_series(SoC_eff)
+        R_transient_S = self.cfg.calc_R_transient_S(SoC_eff)
+        C_transient_S = self.cfg.calc_C_transient_S(SoC_eff)
+        R_transient_L = self.cfg.calc_R_transient_L(SoC_eff)
+        C_transient_L = self.cfg.calc_C_transient_L(SoC_eff)
+
+        # Step 5: Calculate transient voltages (equations 10 and 11)
+        # ⤷ MODIFIED: prevent both tau_X from becoming 0
+        tau_S = max(R_transient_S * C_transient_S, sys.float_info.min)
+        tau_L = max(R_transient_L * C_transient_L, sys.float_info.min)
+        self.V_transient_S = R_transient_S * I_cell + (
+            self.V_transient_S - R_transient_S * I_cell
+        ) * math.pow(math.e, -self.dt_s / tau_S)
+        self.V_transient_L = R_transient_L * I_cell + (
+            self.V_transient_L - R_transient_L * I_cell
+        ) * math.pow(math.e, -self.dt_s / tau_L)
+
+        # Step 6: Calculate cell voltage (equations 8 and 9)
+        # ⤷ MODIFIED: limit V_cell to >=0
+        V_transient = self.V_transient_S + self.V_transient_L
+        V_cell = V_OC - I_cell * R_series - V_transient
+        V_cell = max(V_cell, 0)
+        if self.SoC == 0:
+            V_cell = 0  # make sure no energy can be extracted when empty
+
+        return V_OC, V_cell, self.SoC, SoC_eff
+
+
+class ModelKiBaMSimple(ModelStorage):
+    """PRU-optimized model with a set of simplifications.
+
+    Modifications by [@jonkub](https://github.com/jonkub):
+
+    - omit transient voltages (step 4 & 5, expensive calculation)
+    - omit rate capacity effect (step 1, expensive calculation)
+    - replace two expensive Fn by LuT
+        - mapping SoC to open circuit voltage (step 3)
+        - mapping SoC to series resistance (step 4)
+    - add self discharge resistance (step 2a)
+    - support signaling 0 % SoC by nulling voltage
+
+    Compared to the current shepherd capacitor (charge-based), it:
+
+    - supports emulation of battery types like lipo and lead acid (non-linear SOC-to-V_OC mapping)
+    - has a parallel leakage resistor instead of an oversimplified leakage current
+    - a series resistance is added to improve model matching
+    - as a drawback the open circuit voltage is quantified and shows steps (LuT with 128 entries)
+
+    """
+
+    @validate_call
+    def __init__(
+        self,
+        cfg: VirtualStorageConfig,
+        SoC_init: soc_t | None = None,
+        dt_s: PositiveFloat = TIMESTEP_s_DEFAULT,
+        *,
+        optimize_clamp: bool = False,
+        interpolate: bool = False,
+    ) -> None:
+        # metadata for simulator
+        self.cfg: VirtualStorageConfig = cfg
+        self.dt_s = dt_s
+        # pre-calculate constants
+        self.V_OC_LuT: LUT = LUT.generate(
+            1.0 / LuT_SIZE,
+            y_fn=cfg.calc_V_OC,
+            lut_size=LuT_SIZE,
+            optimize_clamp=optimize_clamp,
+            interpolate=interpolate,
+        )
+        self.R_series_LuT: LUT = LUT.generate(
+            1.0 / LuT_SIZE,
+            y_fn=cfg.calc_R_series,
+            lut_size=LuT_SIZE,
+            optimize_clamp=optimize_clamp,
+            interpolate=interpolate,
+        )
+        self.Constant_s_per_As: float = dt_s / cfg.q_As
+        self.Constant_1_per_Ohm: float = 1.0 / cfg.R_leak_Ohm
+        # state
+        self.SoC: float = SoC_init if SoC_init is not None else cfg.SoC_init
+
+    def step(self, I_charge_A: float) -> tuple[float, float, float, float]:
+        """Calculate the battery SoC & cell-voltage after drawing a current over a time-step."""
+        I_cell = -I_charge_A
+        # Step 2a: Calculate self-discharge (drainage)
+        I_leak = self.V_OC_LuT.get(self.SoC) * self.Constant_1_per_Ohm
+
+        # Step 2: Calculate SoC after dt (equation 6; modified for discrete operation)
+        #       = SoC - 1 / C * (i_cell * dt)
+        self.SoC -= (I_cell + I_leak) * self.Constant_s_per_As
+        SoC_eff = self.SoC = min(max(self.SoC, 0.0), 1.0)
+        # ⤷ MODIFIED: removed term due to omission of rate capacity effect
+        # ⤷ MODIFIED: clamp SoC to 0..1
+
+        # Step 3: Calculate V_OC after dt (equation 7)
+        # MODIFIED to use a lookup table instead
+        V_OC = self.V_OC_LuT.get(SoC_eff)
+
+        # Step 4: Calculate resistance and capacitance values after dt (equation 12)
+        # MODIFIED: removed terms due to omission of transient voltages
+        # MODIFIED to use a lookup table instead
+        R_series = self.R_series_LuT.get(SoC_eff)
+
+        # Step 5: Calculate transient voltages (equations 10 and 11)
+        # MODIFIED: removed due to omission of transient voltages
+
+        # Step 6: Calculate cell voltage (equations 8 and 9)
+        # MODIFIED: removed term due to omission of transient voltages
+        # MODIFIED: limit V_cell to >=0
+        V_cell = V_OC - I_cell * R_series
+        V_cell = max(V_cell, 0.0)
+        if self.SoC == 0:
+            V_cell = 0  # make sure no energy can be extracted when empty
+
+        return V_OC, V_cell, self.SoC, SoC_eff
+
+
+class ModelShpCap(ModelStorage):
+    """A derived model from shepherd-codebase for comparing to KiBaM-capacitor.
+
+    This model was used for the intermediate storage capacitor until
+    the battery-model was implemented.
+    """
+
+    @validate_call
+    def __init__(
+        self,
+        cfg: VirtualStorageConfig,
+        SoC_init: soc_t | None = None,
+        dt_s: PositiveFloat = TIMESTEP_s_DEFAULT,
+    ) -> None:
+        # metadata for simulator
+        self.cfg: VirtualStorageConfig = cfg
+        self.dt_s = dt_s
+        # pre-calculate constants
+        self.V_mid_max_V = cfg.calc_V_OC(1.0)
+        C_mid_uF = 1e6 * cfg.q_As / self.V_mid_max_V
+        C_mid_uF = max(C_mid_uF, 0.001)
+        SAMPLERATE_SPS = 1.0 / dt_s
+        self.Constant_s_per_F = 1e6 / (C_mid_uF * SAMPLERATE_SPS)
+        self.Constant_1_per_Ohm: float = 1.0 / cfg.R_leak_Ohm
+        # state
+        SoC_init = SoC_init if SoC_init is not None else cfg.SoC_init
+        self.V_mid_V = cfg.calc_V_OC(SoC_init)
+
+    def step(self, I_charge_A: float) -> tuple[float, float, float, float]:
+        # in PRU P_inp and P_out are calculated and combined to determine current
+        # similar to: P_sum_W = P_inp_W - P_out_W, I_mid_A = P_sum_W / V_mid_V
+        I_mid_A = I_charge_A - self.V_mid_V * self.Constant_1_per_Ohm
+        dV_mid_V = I_mid_A * self.Constant_s_per_F
+        self.V_mid_V += dV_mid_V
+
+        self.V_mid_V = min(self.V_mid_V, self.V_mid_max_V)
+        self.V_mid_V = max(self.V_mid_V, sys.float_info.min)
+        SoC = self.V_mid_V / self.V_mid_max_V
+        return self.V_mid_V, self.V_mid_V, SoC, SoC

shepherd_core/vsource/virtual_storage_simulator.py

@@ -0,0 +1,104 @@
+"""Simulator for the virtual storage models / algorithms."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import numpy as np
+from pydantic import PositiveFloat
+from pydantic import validate_call
+
+from shepherd_core import log
+
+from .virtual_storage_model import ModelStorage
+
+
+class StorageSimulator:
+    """The simulator benchmarks a set of storage-models.
+
+    - monitors cell-current and voltage, open circuit voltage, state of charge and time
+    - takes config with a list of storage-models and timebase
+    - runs with a total step-count as config and a current-providing function
+        taking time, cell-voltage and SoC as arguments
+
+    The recorded data can be visualized by generating plots.
+    """
+
+    def __init__(self, models: list[ModelStorage], dt_s: PositiveFloat) -> None:
+        self.models = models
+        self.dt_s = dt_s
+        for model in self.models:
+            if self.dt_s != model.dt_s:
+                raise ValueError("timebase on models do not match")
+        self.t_s: np.ndarray | None = None
+
+        # models return V_cell, SoC_eff, V_OC
+        self.I_input: np.ndarray | None = None
+        self.V_OC: np.ndarray | None = None
+        self.V_cell: np.ndarray | None = None
+        self.SoC: np.ndarray | None = None
+        self.SoC_eff: np.ndarray | None = None
+
+    @validate_call
+    def run(self, fn: Callable, duration_s: PositiveFloat) -> None:
+        self.t_s = np.arange(0, duration_s, self.dt_s)
+        self.I_input = np.zeros((len(self.models), self.t_s.shape[0]))
+        self.V_OC = np.zeros((len(self.models), self.t_s.shape[0]))
+        self.V_cell = np.zeros((len(self.models), self.t_s.shape[0]))
+        self.SoC = np.zeros((len(self.models), self.t_s.shape[0]))
+        self.SoC_eff = np.zeros((len(self.models), self.t_s.shape[0]))
+        for i, model in enumerate(self.models):
+            SoC = 1.0
+            V_cell = 0.0
+            for j, t_s in enumerate(self.t_s):
+                I_charge = fn(t_s, SoC, V_cell)
+                V_OC, V_cell, SoC, SoC_eff = model.step(I_charge)
+                self.I_input[i, j] = I_charge
+                self.V_OC[i, j] = V_OC
+                self.V_cell[i, j] = V_cell
+                self.SoC[i, j] = SoC
+                self.SoC_eff[i, j] = SoC_eff
+
+    @validate_call
+    def plot(self, path: Path, title: str, *, plot_delta_v: bool = False) -> None:
+        try:
+            # keep dependencies low
+            from matplotlib import pyplot as plt  # noqa: PLC0415
+        except ImportError:
+            log.warning("Matplotlib not installed, plotting of results disabled")
+            return
+
+        offset = 1 if plot_delta_v else 0
+        fig, axs = plt.subplots(4 + offset, 1, sharex="all", figsize=(10, 2 * 6), layout="tight")
+        axs[0].set_title(title)
+        axs[0].set_ylabel("State of Charge [n]")
+        # ⤷ Note: SoC-eff is also available, but unused
+        axs[0].grid(visible=True)
+        axs[1].set_ylabel("Open-circuit voltage [V]")
+        axs[1].grid(visible=True)
+        axs[2].set_ylabel("Cell voltage [V]")
+        axs[2].grid(visible=True)
+        if plot_delta_v:
+            axs[3].set_ylabel("Cell voltage delta [V]")
+            axs[3].grid(visible=True)
+        axs[3 + offset].set_ylabel("Charge current [A]")
+        axs[3 + offset].set_xlabel("time [s]")
+        axs[3 + offset].grid(visible=True)
+
+        for i, model in enumerate(self.models):
+            axs[0].plot(
+                self.t_s, self.SoC[i], label=f"{type(model).__name__} {model.cfg.name}", alpha=0.7
+            )
+            axs[1].plot(self.t_s, self.V_OC[i], label=type(model).__name__, alpha=0.7)
+            axs[2].plot(self.t_s, self.V_cell[i], label=type(model).__name__, alpha=0.7)
+            if plot_delta_v:  # assumes that timestamps are identical
+                axs[3].plot(
+                    self.t_s,
+                    [v - ref for v, ref in zip(self.V_cell[i], self.V_cell[0], strict=False)],
+                    label=type(model).__name__,
+                    alpha=0.7,
+                )
+            axs[3 + offset].plot(self.t_s, self.I_input[i], label=type(model).__name__, alpha=0.7)
+        axs[0].legend()
+        plt.savefig(path / f"{title}.png")
+        plt.close(fig)
+        plt.clf()

shepherd_core/writer.py

@@ -22,7 +22,7 @@ from .config import config
 from .data_models.base.calibration import CalibrationEmulator as CalEmu
 from .data_models.base.calibration import CalibrationHarvester as CalHrv
 from .data_models.base.calibration import CalibrationSeries as CalSeries
-from .data_models.content.energy_environment import EnergyDType
+from .data_models.content.enum_datatypes import EnergyDType
 from .data_models.task import Compression
 from .data_models.task.emulation import c_translate
 from .reader import Reader
@@ -116,11 +116,12 @@ class Writer(Reader):
 
         if not hasattr(self, "_logger"):
             self._logger: logging.Logger = logging.getLogger("SHPCore.Writer")
+            self._logger.setLevel(logging.DEBUG if verbose else logging.INFO)
         # -> logger gets configured in reader()
 
         if self._modify or force_overwrite or not file_path.exists():
             file_path = file_path.resolve()
-            self._logger.info("Storing data to   '%s'", file_path)
+            self._logger.debug("Storing data to   '%s'", file_path)
         elif file_path.exists() and not file_path.is_file():
             msg = f"Path is not a file ({file_path})"
             raise TypeError(msg)
@@ -154,22 +155,22 @@ class Writer(Reader):
         if "mode" not in self.h5file.attrs:
             self.h5file.attrs["mode"] = self.MODE_DEFAULT
 
-        _dtypes = self.MODE_TO_DTYPE[self.get_mode()]
+        dtypes_ = self.MODE_TO_DTYPE[self.get_mode()]
 
         # Handle Datatype
         if isinstance(datatype, str):
             datatype = EnergyDType[datatype]
-        if isinstance(datatype, EnergyDType) and datatype not in _dtypes:
-            msg = f"Can't handle value '{datatype}' of datatype (choose one of {_dtypes})"
+        if isinstance(datatype, EnergyDType) and datatype not in dtypes_:
+            msg = f"Can't handle value '{datatype}' of datatype (choose one of {dtypes_})"
             raise ValueError(msg)
 
         if isinstance(datatype, EnergyDType):
             self.h5file["data"].attrs["datatype"] = datatype.name
         if "datatype" not in self.h5file["data"].attrs:
             self.h5file["data"].attrs["datatype"] = self.DATATYPE_DEFAULT.name
-        if self.get_datatype() not in _dtypes:
+        if self.get_datatype() not in dtypes_:
             msg = (
-                f"Can't handle value '{self.get_datatype()}' of datatype (choose one of {_dtypes})"
+                f"Can't handle value '{self.get_datatype()}' of datatype (choose one of {dtypes_})"
             )
             raise ValueError(msg)
 
@@ -183,6 +184,12 @@ class Writer(Reader):
             raise ValueError("Window Size argument needed for ivcurve-Datatype")
 
         # Handle Cal
+        if isinstance(cal_data, CalEmu):
+            msg = (
+                "Writer got a CalibrationEmulator()-object without information "
+                "about the TargetPort. Possibly wrong cal-data stored in hdf5!"
+            )
+            self._logger.warning(msg)
         if isinstance(cal_data, (CalEmu, CalHrv)):
             cal_data = CalSeries.from_cal(cal_data)
 
@@ -215,7 +222,7 @@ class Writer(Reader):
     ) -> None:
         self._align()
         self._refresh_file_stats()
-        self._logger.info(
+        self._logger.debug(
             "closing hdf5 file, %.1f s iv-data, size = %.3f MiB, rate = %.0f KiB/s",
             self.runtime_s,
             self.file_size / 2**20,
@@ -296,7 +303,7 @@ class Writer(Reader):
             timestamp = int(timestamp)
         if isinstance(timestamp, int):
             time_series_ns = self.sample_interval_ns * np.arange(len_new).astype("u8")
-            timestamp = timestamp + time_series_ns
+            timestamp += time_series_ns
         if isinstance(timestamp, np.ndarray):
             len_new = min(len_new, timestamp.size)
         else:

{shepherd_core-2025.8.1.dist-info → shepherd_core-2026.2.1.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
-Name: shepherd_core
-Version: 2025.8.1
+Name: shepherd-core
+Version: 2026.2.1
 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>
+License-Expression: MIT
 Project-URL: Documentation, https://github.com/nes-lab/shepherd-tools/blob/main/README.md
 Project-URL: Issues, https://github.com/nes-lab/shepherd-tools/issues
 Project-URL: Source, https://pypi.org/project/shepherd-core/
@@ -22,11 +23,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Natural Language :: English
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: h5py
 Requires-Dist: numpy
 Requires-Dist: pyYAML
@@ -49,6 +51,7 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"
 Provides-Extra: all
 Requires-Dist: shepherd-core[dev,elf,inventory,test]; extra == "all"
+Dynamic: license-file
 
 # Core Library