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

shepherd_core/exit_handler.py

@@ -0,0 +1,22 @@
+"""Generalized exit handler for Shepherd."""
+
+import signal
+import sys
+from collections.abc import Callable
+from types import FrameType
+
+from .logger import log
+
+
+def exit_gracefully(_signum: int, _frame: FrameType | None) -> None:
+    """Usual exit handler for single-processing applications."""
+    log.warning("Exiting!")
+    sys.exit(0)
+
+
+def activate_exit_handler(custom: Callable = exit_gracefully) -> None:
+    """Register the provided exit handler or use the default one."""
+    signal.signal(signal.SIGTERM, custom)
+    signal.signal(signal.SIGINT, custom)
+    if hasattr(signal, "SIGALRM"):
+        signal.signal(signal.SIGALRM, custom)

shepherd_core/fw_tools/converter.py

@@ -8,7 +8,7 @@ from pathlib import Path
 import zstandard as zstd
 from pydantic import validate_call
 
-from shepherd_core.data_models.content.firmware_datatype import FirmwareDType
+from shepherd_core.data_models.content.enum_datatypes import FirmwareDType
 
 from .converter_elf import elf_to_hex
 from .validation import is_elf
@@ -98,7 +98,7 @@ def extract_firmware(data: str | Path, data_type: FirmwareDType, file_path: Path
         elif data_type == FirmwareDType.path_hex:
             file = file_path.with_suffix(".hex")
         else:
-            msg = "FW-Extraction failed due to unknown datatype '{data_type}'"
+            msg = f"FW-Extraction failed due to unknown datatype '{data_type}'"
             raise ValueError(msg)
         if not file.parent.exists():
             file.parent.mkdir(parents=True)

shepherd_core/fw_tools/validation.py

@@ -13,7 +13,7 @@ from intelhex import IntelHex
 from intelhex import IntelHexError
 from pydantic import validate_call
 
-from shepherd_core.data_models.content.firmware_datatype import FirmwareDType
+from shepherd_core.data_models.content.enum_datatypes import FirmwareDType
 from shepherd_core.logger import log
 
 from .converter_elf import elf_to_hex

shepherd_core/inventory/__init__.py

@@ -10,6 +10,7 @@ from datetime import datetime
 from datetime import timedelta
 from pathlib import Path
 from typing import Annotated
+from typing import final
 
 from pydantic import Field
 from typing_extensions import Self
@@ -29,6 +30,7 @@ __all__ = [
 ]
 
 
+@final
 class Inventory(PythonInventory, SystemInventory, TargetInventory):
     """Complete inventory for one device.
 
@@ -65,7 +67,7 @@ class InventoryList(ShpModel):
         np.concatenate(content).reshape((len(content), len(content[0]))).
         """
         if path.is_dir():
-            path = path / "inventory.yaml"
+            path /= "inventory.yaml"
         with path.resolve().open("w") as fd:
             fd.write(", ".join(self.elements[0].model_dump().keys()) + "\r\n")
             for item in self.elements:
@@ -75,28 +77,28 @@ class InventoryList(ShpModel):
 
     def warn(self) -> dict:
         warnings = {}
-        ts_earl = min([_e.created.timestamp() for _e in self.elements])
-        for _e in self.elements:
-            if _e.uptime > timedelta(hours=30).total_seconds():
-                warnings["uptime"] = f"[{self.hostname}] restart is recommended"
-            if (_e.created.timestamp() - ts_earl) > 10:
-                warnings["time_delta"] = f"[{self.hostname}] time-sync has failed"
+        ts_earl = min(e_.created.timestamp() for e_ in self.elements)
+        for e_ in self.elements:
+            if e_.uptime > timedelta(hours=30).total_seconds():
+                warnings["uptime"] = f"[{e_.hostname}] restart is recommended"
+            if (e_.created.timestamp() - ts_earl) > 10:
+                warnings["time_delta"] = f"[{e_.hostname}] time-sync has failed"
 
         # turn  dict[hostname][type] = val
         # to    dict[type][val] = list[hostnames]
-        _inp = {
-            _e.hostname: _e.model_dump(exclude_unset=True, exclude_defaults=True)
-            for _e in self.elements
+        inp_ = {
+            e_.hostname: e_.model_dump(exclude_unset=True, exclude_defaults=True)
+            for e_ in self.elements
         }
         result = {}
-        for _host, _types in _inp.items():
-            for _type, _val in _types.items():
-                if _type not in result:
-                    result[_type] = {}
-                if _val not in result[_type]:
-                    result[_type][_val] = []
-                result[_type][_val].append(_host)
-        rescnt = {_key: len(_val) for _key, _val in result.items()}
+        for host_, types_ in inp_.items():
+            for type_, val_ in types_.items():
+                if type_ not in result:
+                    result[type_] = {}
+                if val_ not in result[type_]:
+                    result[type_][val_] = []
+                result[type_][val_].append(host_)
+        rescnt = {key_: len(val_) for key_, val_ in result.items()}
         t_unique = [
             "h5py",
             "numpy",
@@ -107,9 +109,9 @@ class InventoryList(ShpModel):
             "yaml",
             "zstandard",
         ]
-        for _key in t_unique:
-            if rescnt[_key] > 1:
-                warnings[_key] = f"[{_key}] VersionMismatch - {result[_key]}"
+        for key_ in t_unique:
+            if rescnt[key_] > 1:
+                warnings[key_] = f"[{key_}] VersionMismatch - {result[key_]}"
 
         # TODO: finish with more potential warnings
         return warnings

shepherd_core/inventory/system.py

@@ -21,7 +21,7 @@ except ImportError:
     psutil = None
 
 from pydantic import ConfigDict
-from pydantic.types import PositiveInt
+from pydantic import PositiveInt
 
 from shepherd_core.data_models import ShpModel
 
@@ -63,12 +63,12 @@ class SystemInventory(ShpModel):
             uptime = 0
             log.warning(
                 "Inventory-Parameters will be missing. "
-                "Please install functionality with "
+                "Please install functionality with i.e."
                 "'pip install shepherd_core[inventory] -U' first"
             )
         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()
 
         fs_cmd = ["/usr/bin/df", "-h", "/"]

shepherd_core/logger.py

@@ -1,7 +1,6 @@
 """Log handler of shepherd."""
 
 import logging
-import logging.handlers
 
 import chromalog
 

shepherd_core/reader.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from types import MappingProxyType
 from typing import TYPE_CHECKING
 from typing import Any
+from typing import final
 
 import h5py
 import numpy as np
@@ -26,7 +27,7 @@ from .config import config
 from .data_models.base.calibration import CalibrationPair
 from .data_models.base.calibration import CalibrationSeries
 from .data_models.base.timezone import local_tz
-from .data_models.content.energy_environment import EnergyDType
+from .data_models.content.enum_datatypes import EnergyDType
 from .decoder_waveform import Uart
 
 if TYPE_CHECKING:
@@ -46,7 +47,7 @@ class Reader:
 
     """
 
-    CHUNK_SAMPLES_N: int = 10_000
+    CHUNK_SAMPLES_N: final[int] = 10_000
 
     MODE_TO_DTYPE: Mapping[str, Sequence[EnergyDType]] = MappingProxyType(
         {
@@ -101,9 +102,9 @@ class Reader:
             try:
                 self.h5file = h5py.File(self.file_path, "r")  # = readonly
                 self._reader_opened = True
-            except OSError as _xcp:
+            except OSError as xcp:
                 msg = f"Unable to open HDF5-File '{self.file_path.name}'"
-                raise TypeError(msg) from _xcp
+                raise TypeError(msg) from xcp
 
             if self.is_valid():
                 self._logger.debug("File is available now")
@@ -209,13 +210,14 @@ class Reader:
         Generator - can be configured on first call
 
         Args:
-        ----
-            :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_timestamps: (bool) optimize reading if timestamp is never used
-        Yields: chunks between start and end (tuple with time, voltage, current)
+            start_n: (int) Index of first chunk to be read
+            end_n: (int) Index of last chunk to be read
+            n_samples_per_chunk: (int) allows changing
+            is_raw: (bool) output original data, not transformed to SI-Units
+            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_chunk is None:
@@ -223,21 +225,21 @@ class Reader:
         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 chunk %d to %d from source-file", start_n, end_n)
-        _raw = is_raw
-        _wts = not omit_timestamps
+        raw_ = is_raw
+        wts_ = not omit_timestamps
 
         for i in range(start_n, end_n):
             idx_start = i * n_samples_per_chunk
             idx_end = idx_start + n_samples_per_chunk
-            if _raw:
+            if raw_:
                 yield (
-                    self.ds_time[idx_start:idx_end] if _wts else None,
+                    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]) if _wts else None,
+                    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]),
                 )
@@ -314,16 +316,17 @@ class Reader:
         voltage_step: float | None = (
             self.get_config().get("virtual_harvester", {}).get("voltage_step_mV", None)
         )
+        if voltage_step is not None:  # convert mV to V
+            voltage_step *= 1e-3
         if voltage_step is None:
-            dsv = self.ds_voltage[0:2000]
+            dsv = self._cal.voltage.raw_to_si(self.ds_voltage[0:2000])
             diffs_np = np.unique(dsv[1:] - dsv[0:-1], return_counts=False)
-            diffs_ls = [_e for _e in list(np.array(diffs_np)) if _e > 0]
+            diffs_ls = [e_ for e_ in list(np.array(diffs_np)) if e_ > 0]
             # static voltages have 0 steps, so
             if len(diffs_ls) == 0:
+                self._logger.warning("Voltage-Step could not be determined from source-material")
                 return None  # or is 0 better? that may provoke div0
             voltage_step = min(diffs_ls)
-        if voltage_step is not None:
-            voltage_step = 1e-3 * voltage_step
         return voltage_step
 
     def get_hrv_config(self) -> dict:
@@ -456,11 +459,11 @@ class Reader:
                 "[FileValidation] Hostname was not set in '%s'", self.file_path.name
             )
         # errors during execution
-        _err = self.count_errors_in_log()
-        if _err > 0:
+        err_ = self.count_errors_in_log()
+        if err_ > 0:
             self._logger.warning(
                 "[FileValidation] Sheep reported %d errors during execution -> check logs in '%s'",
-                _err,
+                err_,
                 self.file_path.name,
             )
         return True
@@ -483,6 +486,8 @@ class Reader:
         # multiprocessing: https://stackoverflow.com/a/71898911
         # -> failed with multiprocessing.pool and pathos.multiprocessing.ProcessPool.
 
+        TODO: add optional duration argument to allow calculating mean energy of a spatial EEnv
+
         :return: sampled energy in Ws (watt-seconds)
         """
         iterations = math.ceil(self.samples_n / self.max_elements)
@@ -602,11 +607,11 @@ class Reader:
             return 0
         if "level" not in self.h5file[group_name]:
             return 0
-        _lvl = self.h5file[group_name]["level"]
-        if _lvl.shape[0] < 1:
+        lvl_ = self.h5file[group_name]["level"]
+        if lvl_.shape[0] < 1:
             return 0
-        _items = [1 for _x in _lvl[:] if _x >= min_level]
-        return len(_items)
+        items_ = [1 for x_ in lvl_[:] if x_ >= min_level]
+        return len(items_)
 
     def get_metadata(
         self,

shepherd_core/testbed_client/cache_path.py

@@ -5,10 +5,10 @@ from pathlib import Path
 
 
 def _get_xdg_path(variable_name: str, default_path: Path) -> Path:
-    _value = os.environ.get(variable_name)
-    if _value is None or _value == "":
+    value_ = os.environ.get(variable_name)
+    if not value_:  # catches None and ""
         return default_path
-    return Path(_value)
+    return Path(value_)
 
 
 user_path = Path("~").expanduser()

shepherd_core/testbed_client/client_abc_fix.py

@@ -18,9 +18,11 @@ TODO: Comfort functions missing
 from abc import ABC
 from abc import abstractmethod
 from typing import Any
+from typing import final
 
 from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.data_models.base.wrapper import Wrapper
+from shepherd_core.logger import log
 
 from .fixtures import Fixtures
 
@@ -58,6 +60,7 @@ class AbcClient(ABC):
         # TODO: maybe internal? yes
         pass
 
+    @final
     def try_completing_model(
         self, model_type: str, values: dict[str, Any]
     ) -> tuple[dict[str, Any], list[str]]:
@@ -71,14 +74,18 @@ class AbcClient(ABC):
             except ValueError as err:
                 msg = f"Query {model_type} by name / ID failed - {values} is unknown!"
                 raise ValueError(msg) from err
+            except KeyError:
+                log.error(f"Query failed - model-type {model_type} is unknown")
+                return values, []
         return self.try_inheritance(model_type, values)
 
     @abstractmethod
     def fill_in_user_data(self, values: dict[str, Any]) -> dict[str, Any]:
-        # TODO: is it really helpful and needed?
+        # TODO: is it really needed and helpful?
         pass
 
 
+@final
 class FixturesClient(AbcClient):
     """Client-Class to access the file based fixtures."""
 
@@ -110,12 +117,16 @@ class FixturesClient(AbcClient):
     def try_inheritance(
         self, model_type: str, values: dict[str, Any]
     ) -> tuple[dict[str, Any], list[str]]:
-        return self._fixtures[model_type].inheritance(values)
+        try:
+            return self._fixtures[model_type].inheritance(values)
+        except KeyError:
+            log.error(f"Query failed - model-type {model_type} is unknown")
+            return values, []
 
     def fill_in_user_data(self, values: dict[str, Any]) -> dict[str, Any]:
         """Add fake user-data when offline-client is used.
 
-        Hotfix until WebClient is working.
+        Workaround until WebClient is working.
         """
         if values.get("owner") is None:
             values["owner"] = "unknown"

shepherd_core/testbed_client/client_web.py

@@ -3,6 +3,7 @@
 from importlib import import_module
 from pathlib import Path
 from typing import Any
+from typing import final
 
 from pydantic import validate_call
 
@@ -14,6 +15,7 @@ from .client_abc_fix import AbcClient
 from .user_model import User
 
 
+@final
 class WebClient(AbcClient):
     """Client-Class to access a testbed instance over the web.
 
@@ -125,26 +127,26 @@ class WebClient(AbcClient):
         return False
 
     def submit_experiment(self, xp: ShpModel) -> str:
-        """Transmit XP to server to validate its feasibility.
+        """Transmit experiment to server to validate its feasibility.
 
         - Experiment will be added to DB (if not present)
-            - if the same experiment is resubmitted it will just return the ID of that XP
+            - if the same experiment is resubmitted it will just return the ID of that experiment
         - Experiment will be validated by converting it into a task-set (additional validation)
         - optional: the scheduler should validate there are no time-collisions
 
         Will return an ID if valid, otherwise an empty string.
         TODO: maybe its better to throw specific errors if validation fails
-        TODO: is it better to include these experiment-related FNs in Xp-Class?
+        TODO: is it better to include these experiment-related FNs in experiment-Class?
         TODO: Experiment-typehint for argument triggers circular import
         """
         raise NotImplementedError("TODO")
 
     def schedule_experiment(self, id_xp: str) -> bool:
-        """Enqueue XP on testbed."""
+        """Enqueue experiment on testbed."""
         raise NotImplementedError("TODO")
 
     def get_experiment_status(self, id_xp: str) -> str:
-        """Ask server about current state of XP.
+        """Ask server about current state of experiment.
 
         - after valid submission: disabled / deactivated
         - after scheduling: scheduled

shepherd_core/testbed_client/fixtures.py

@@ -48,10 +48,10 @@ class Fixture:
         if "name" not in data.parameters:
             return
         name = str(data.parameters["name"]).lower()
-        _id = data.parameters["id"]
+        id_ = data.parameters["id"]
         data_model = data.parameters
         self.elements_by_name[name] = data_model
-        self.elements_by_id[_id] = data_model
+        self.elements_by_id[id_] = data_model
         # update iterator
         self._iter_list: list[dict[str, Any]] = list(self.elements_by_name.values())
 
@@ -84,7 +84,7 @@ class Fixture:
         return self.elements_by_name.keys()
 
     def refs(self) -> dict:
-        return {_i["id"]: _i["name"] for _i in self.elements_by_id.values()}
+        return {i_["id"]: i_["name"] for i_ in self.elements_by_id.values()}
 
     def inheritance(
         self, values: dict[str, Any], chain: list[str] | None = None
@@ -123,8 +123,8 @@ class Fixture:
             post_process = True
 
         elif values.get("id") in self.elements_by_id:
-            _id = values["id"]
-            fixture_base = copy.copy(self.elements_by_id[_id])
+            id_ = values["id"]
+            fixture_base = copy.copy(self.elements_by_id[id_])
             post_process = True
 
         if post_process:
@@ -218,7 +218,7 @@ class Fixtures:
 
     @validate_call
     def insert_file(self, file: Path) -> None:
-        with file.open() as fd:
+        with file.open(encoding="utf-8-sig") as fd:
             fixtures = yaml.safe_load(fd)
             for fixture in fixtures:
                 if not isinstance(fixture, dict):
@@ -237,7 +237,7 @@ class Fixtures:
         if key in self.components:
             return self.components[key]
         msg = f"Component '{key}' not found!"
-        raise ValueError(msg)
+        raise KeyError(msg)
 
     def keys(self) -> Iterable[str]:
         return self.components.keys()

shepherd_core/version.py

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

shepherd_core/vsource/__init__.py

@@ -9,15 +9,19 @@ from .virtual_harvester_model import VirtualHarvesterModel
 from .virtual_harvester_simulation import simulate_harvester
 from .virtual_source_model import VirtualSourceModel
 from .virtual_source_simulation import simulate_source
+from .virtual_storage_model import VirtualStorageModel
+from .virtual_storage_simulator import StorageSimulator
 
 __all__ = [
     "ConstantCurrentTarget",
     "ConstantPowerTarget",
     "PruCalibration",
     "ResistiveTarget",
+    "StorageSimulator",
     "VirtualConverterModel",
     "VirtualHarvesterModel",
     "VirtualSourceModel",
+    "VirtualStorageModel",
     "simulate_harvester",
     "simulate_source",
 ]

shepherd_core/vsource/virtual_converter_model.py

@@ -17,8 +17,11 @@ Compromises:
 import math
 
 from shepherd_core.data_models import CalibrationEmulator
-from shepherd_core.data_models.content.virtual_source import LUT_SIZE
-from shepherd_core.data_models.content.virtual_source import ConverterPRUConfig
+from shepherd_core.data_models.content.virtual_source_config import LUT_SIZE
+from shepherd_core.data_models.content.virtual_source_config import ConverterPRUConfig
+from shepherd_core.data_models.content.virtual_storage_config import StoragePRUConfig
+
+from .virtual_storage_model import VirtualStorageModelPRU
 
 
 class PruCalibration:
@@ -32,7 +35,7 @@ class PruCalibration:
     negative_residue_nA = 0
 
     def __init__(self, cal_emu: CalibrationEmulator | None = None) -> None:
-        self.cal = cal_emu if cal_emu else CalibrationEmulator()
+        self.cal = cal_emu or CalibrationEmulator()
 
     def conv_adc_raw_to_nA(self, current_raw: int) -> float:
         I_nA = self.cal.adc_C_A.raw_to_si(current_raw) * (10**9)
@@ -41,7 +44,7 @@ class PruCalibration:
                 I_nA -= self.negative_residue_nA
                 self.negative_residue_nA = 0
             else:
-                self.negative_residue_nA = self.negative_residue_nA - I_nA
+                self.negative_residue_nA -= I_nA
                 self.negative_residue_nA = min(self.negative_residue_nA, self.RESIDUE_MAX_nA)
                 I_nA = 0
         return I_nA
@@ -59,13 +62,16 @@ class PruCalibration:
 class VirtualConverterModel:
     """Ported python version of the pru vCnv."""
 
-    def __init__(self, cfg: ConverterPRUConfig, cal: PruCalibration) -> None:
+    def __init__(
+        self, cfg: ConverterPRUConfig, cal: PruCalibration, storage_cfg: StoragePRUConfig
+    ) -> None:
         self._cal: PruCalibration = cal
         self._cfg: ConverterPRUConfig = cfg
 
+        self.storage = VirtualStorageModelPRU(storage_cfg)
+
         # simplifications for python
         self.R_input_kOhm = float(self._cfg.R_input_kOhm_n22) / 2**22
-        self.Constant_us_per_nF = float(self._cfg.Constant_us_per_nF_n28) / 2**28
 
         # boost internal state
         self.V_input_uV: float = 0.0
@@ -74,7 +80,7 @@ class VirtualConverterModel:
         self.interval_startup_disabled_drain_n: int = self._cfg.interval_startup_delay_drain_n
 
         # container for the stored energy
-        self.V_mid_uV: float = self._cfg.V_intermediate_init_uV
+        self.V_mid_uV: float = self.storage.calc_V_OC_uV()
 
         # buck internal state
         self.enable_storage: bool = (int(self._cfg.converter_mode) & 0b0001) > 0
@@ -83,19 +89,19 @@ class VirtualConverterModel:
         self.enable_log_mid: bool = (int(self._cfg.converter_mode) & 0b1000) > 0
         # back-channel to hrv
         self.feedback_to_hrv: bool = (int(self._cfg.converter_mode) & 0b1_0000) > 0
-        self.V_input_request_uV: int = self._cfg.V_intermediate_init_uV
+        self.V_input_request_uV: int = int(self.V_mid_uV)
 
         self.V_out_dac_uV: float = self._cfg.V_output_uV
         self.V_out_dac_raw: int = self._cal.conv_uV_to_dac_raw(self._cfg.V_output_uV)
         self.power_good: bool = True
 
         # prepare hysteresis-thresholds
-        self.dV_enable_output_uV: float = self._cfg.dV_enable_output_uV
-        self.V_enable_output_threshold_uV: float = self._cfg.V_enable_output_threshold_uV
-        self.V_disable_output_threshold_uV: float = self._cfg.V_disable_output_threshold_uV
+        self.dV_mid_enable_output_uV: float = self._cfg.dV_mid_enable_output_uV
+        self.V_mid_enable_output_threshold_uV: float = self._cfg.V_mid_enable_output_threshold_uV
+        self.V_mid_disable_output_threshold_uV: float = self._cfg.V_mid_disable_output_threshold_uV
 
-        self.V_enable_output_threshold_uV = max(
-            self.dV_enable_output_uV, self.V_enable_output_threshold_uV
+        self.V_mid_enable_output_threshold_uV = max(
+            self.dV_mid_enable_output_uV, self.V_mid_enable_output_threshold_uV
         )
 
         # pulled from update_states_and_output() due to easier static init
@@ -125,7 +131,7 @@ class VirtualConverterModel:
                 input_voltage_uV = 0.0
             # TODO: vdrop in case of v_input > v_storage (non-boost)
         elif self.enable_storage:
-            # no boost, but cap, for ie. diode+cap (+resistor)
+            # no boost, but cap, for i.e. diode+cap (+resistor)
             V_diff_uV = (
                 (input_voltage_uV - self.V_mid_uV) if (input_voltage_uV >= self.V_mid_uV) else 0
             )
@@ -162,14 +168,14 @@ class VirtualConverterModel:
         current_adc_raw = max(0, current_adc_raw)
         current_adc_raw = min((2**18) - 1, current_adc_raw)
 
-        P_leak_fW = self.V_mid_uV * self._cfg.I_intermediate_leak_nA
+        # TODO: remove P_leak in C-Code
         I_out_nA = self._cal.conv_adc_raw_to_nA(current_adc_raw)
         if self.enable_buck:  # noqa: SIM108
             eta_inv_out = self.get_output_inv_efficiency(I_out_nA)
         else:
             eta_inv_out = 1.0
 
-        self.P_out_fW = eta_inv_out * self.V_out_dac_uV * I_out_nA + P_leak_fW
+        self.P_out_fW = eta_inv_out * self.V_out_dac_uV * I_out_nA
 
         if self.interval_startup_disabled_drain_n > 0:
             self.interval_startup_disabled_drain_n -= 1
@@ -177,17 +183,12 @@ class VirtualConverterModel:
 
         return round(self.P_out_fW)  # Python-specific, added for easier testing
 
-    # TODO: add range-checks for add, sub Ops
     def update_cap_storage(self) -> int:
-        # TODO: this calculation is wrong for everything beside boost-cnv
         if self.enable_storage:
-            V_mid_prot_uV = max(1.0, self.V_mid_uV)
-            P_sum_fW = self.P_inp_fW - self.P_out_fW
-            I_mid_nA = P_sum_fW / V_mid_prot_uV
-            dV_mid_uV = I_mid_nA * self.Constant_us_per_nF
-            self.V_mid_uV += dV_mid_uV
-
-        self.V_mid_uV = min(self.V_mid_uV, self._cfg.V_intermediate_max_uV)
+            I_delta_nA = abs((self.P_inp_fW - self.P_out_fW) / self.V_mid_uV)
+            is_charging: bool = self.P_inp_fW >= self.P_out_fW
+            self.V_mid_uV = self.storage.step(2**4 * I_delta_nA, is_charging=is_charging)
+        self.V_mid_uV = min(self.V_mid_uV, self._cfg.V_mid_max_uV)
         self.V_mid_uV = max(self.V_mid_uV, 1)
         return round(self.V_mid_uV)  # Python-specific, added for easier testing
 
@@ -200,11 +201,11 @@ class VirtualConverterModel:
         if check_thresholds:
             self.sample_count = 0
             if self.is_outputting:
-                if V_mid_uV_now < self.V_disable_output_threshold_uV:
+                if V_mid_uV_now < self.V_mid_disable_output_threshold_uV:
                     self.is_outputting = False
-            elif V_mid_uV_now >= self.V_enable_output_threshold_uV:
+            elif V_mid_uV_now >= self.V_mid_enable_output_threshold_uV:
                 self.is_outputting = True
-                self.V_mid_uV -= self.dV_enable_output_uV
+                self.V_mid_uV -= self.dV_mid_enable_output_uV
 
         if check_thresholds or self._cfg.immediate_pwr_good_signal:
             # generate power-good-signal