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

shepherd_core/data_models/content/firmware.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Annotated
 from typing import Any
 from typing import TypedDict
+from typing import final
 
 from pydantic import StringConstraints
 from pydantic import model_validator
@@ -20,7 +21,7 @@ from shepherd_core.data_models.testbed.mcu import MCU
 from shepherd_core.logger import log
 from shepherd_core.testbed_client import tb_client
 
-from .firmware_datatype import FirmwareDType
+from .enum_datatypes import FirmwareDType
 
 suffix_to_DType: dict = {
     # derived from wikipedia
@@ -49,17 +50,18 @@ arch_to_mcu: dict = {
 FirmwareStr = Annotated[str, StringConstraints(min_length=3, max_length=8_000_000)]
 
 
+@final
 class Firmware(ContentModel, title="Firmware of Target"):
     """meta-data representation of a data-component."""
 
-    # General Metadata & Ownership -> ContentModel
+    # General Metadata & Ownership -> see ContentModel
 
     mcu: MCU
 
     data: FirmwareStr | Path
     data_type: FirmwareDType
     data_hash: str | None = None
-    data_local: bool = True
+    data_2_copy: bool = True
     """ ⤷ signals that file has to be copied to testbed"""
 
     @model_validator(mode="before")
@@ -67,18 +69,18 @@ class Firmware(ContentModel, title="Firmware of Target"):
     def query_database(cls, values: dict[str, Any]) -> dict[str, Any]:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         # crosscheck type with actual data
-        _type = values.get("data_type")
-        if _type in {
+        dtype = values.get("data_type")
+        if dtype in {
             FirmwareDType.base64_hex,
             FirmwareDType.base64_elf,
         }:
             try:
-                _hash = fw_tools.base64_to_hash(values.get("data"))
+                dhash = fw_tools.base64_to_hash(values.get("data"))
             except ValueError:
                 raise ValueError("Embedded Firmware seems to be faulty") from None
-            if values.get("data_hash") is not None and _hash != values.get("data_hash"):
+            if values.get("data_hash") is not None and dhash != values.get("data_hash"):
                 raise ValueError("Embedded Firmware and Hash do not match!")
-        elif _type in {
+        elif dtype in {
             FirmwareDType.path_hex,
             FirmwareDType.path_elf,
         }:
@@ -105,10 +107,10 @@ class Firmware(ContentModel, title="Firmware of Target"):
         kwargs["data_hash"] = fw_tools.file_to_hash(file)
         if embed:
             kwargs["data"] = fw_tools.file_to_base64(file)
-            kwargs["data_local"] = False
+            kwargs["data_2_copy"] = False
         else:
             kwargs["data"] = Path(file).as_posix()
-            kwargs["data_local"] = True
+            kwargs["data_2_copy"] = True
 
         if "data_type" not in kwargs:
             kwargs["data_type"] = suffix_to_DType[file.suffix.lower()]
@@ -145,16 +147,22 @@ class Firmware(ContentModel, title="Firmware of Target"):
             kwargs["name"] = file.name
         return cls(**kwargs)
 
-    def compare_hash(self, path: Path | None = None) -> bool:
+    def compare_hash(self, data: Path | str | None = None) -> bool:
         if self.data_hash is None:
             return True
 
-        if path is not None and path.is_file():
-            hash_new = fw_tools.file_to_hash(path)
+        if data is None:
+            # use included data if nothing is provided
+            data = self.data
+
+        if isinstance(data, Path) and data.is_file():
+            hash_new = fw_tools.file_to_hash(data)
             match = self.data_hash == hash_new
-        else:
-            hash_new = fw_tools.base64_to_hash(self.data)
+        elif isinstance(data, str):
+            hash_new = fw_tools.base64_to_hash(data)
             match = self.data_hash == hash_new
+        else:
+            match = False
 
         if not match:
             log.warning("FW-Hash does not match with stored value!")
@@ -169,7 +177,27 @@ class Firmware(ContentModel, title="Firmware of Target"):
         - if provided path is a directory, the firmware-name is used
         """
         if file.is_dir():
-            file = file / self.name
+            file /= self.name
         file_new = fw_tools.extract_firmware(self.data, self.data_type, file)
         self.compare_hash(file_new)
         return file_new
+
+    def exists(self) -> bool:
+        """Check if embedded file exists."""
+        if self.data_type in [FirmwareDType.path_hex, FirmwareDType.path_elf]:
+            if not isinstance(self.data, Path):
+                raise ValueError("Firmware.data is not a Path (but type-property claims so)")
+            return self.data.exists()
+        return True
+
+    def check(self) -> bool:
+        """Check if embedded file is still valid or unchanged."""
+        valid = True
+        if self.data_type in [FirmwareDType.path_hex, FirmwareDType.path_elf]:
+            valid &= isinstance(self.data, Path) and self.data.exists()
+        if self.data_type in [FirmwareDType.base64_elf, FirmwareDType.base64_hex]:
+            valid &= isinstance(self.data, str)
+            # TODO: could also begin unpacking base64
+            # TODO: could also verify hex, elf
+
+        return valid & self.compare_hash()

shepherd_core/data_models/content/virtual_harvester_config.py

@@ -1,9 +1,9 @@
 """Generalized energy harvester data models."""
 
 from collections.abc import Mapping
-from enum import Enum
 from typing import Annotated
 from typing import Any
+from typing import final
 
 from pydantic import Field
 from pydantic import model_validator
@@ -16,95 +16,11 @@ from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.logger import log
 from shepherd_core.testbed_client import tb_client
 
-from .energy_environment import EnergyDType
-
-
-class AlgorithmDType(str, Enum):
-    """Options for choosing a harvesting algorithm."""
-
-    direct = disable = neutral = "neutral"
-    """
-    Reads an energy environment as is without selecting a harvesting
-    voltage.
-
-    Used to play "constant-power" energy environments or simple
-    "on-off-patterns". Generally, not useful for virtual source
-    emulation.
-
-    Not applicable to real harvesting, only emulation with IVTrace / samples.
-    """
-
-    isc_voc = "isc_voc"
-    """
-    Short Circuit Current, Open Circuit Voltage.
-
-    This is not relevant for emulation, but used to configure recording of
-    energy environments.
-
-    This mode samples the two extremes of an IV curve, which may be
-    interesting to characterize a transducer/energy environment.
-
-    Not applicable to emulation - only recordable during harvest-recording ATM.
-    """
-
-    ivcurve = ivcurves = ivsurface = "ivcurve"
-    """
-    Used during harvesting to record the full IV surface.
-
-    When configuring the energy environment recording, this algorithm
-    records the IV surface by repeatedly recording voltage and current
-    while ramping the voltage.
-
-    Cannot be used as output of emulation.
-    """
-
-    constant = cv = "cv"
-    """
-    Harvest energy at a fixed predefined voltage ('voltage_mV').
-
-    For harvesting, this records the IV samples at the specified voltage.
-    For emulation, this virtually harvests the IV surface at the specified voltage.
-
-    In addition to constant voltage harvesting, this can be used together
-    with the 'feedback_to_hrv' flag to implement a "Capacitor and Diode"
-    topology, where the harvesting voltage depends dynamically on the
-    capacitor voltage.
-    """
-
-    # ci .. constant current -> is this desired?
-
-    mppt_voc = "mppt_voc"
-    """
-    Emulate a harvester with maximum power point (MPP) tracking based on
-    open circuit voltage measurements.
-
-    This MPPT heuristic estimates the MPP as a constant ratio of the open
-    circuit voltage.
-
-    Used in conjunction with 'setpoint_n', 'interval_ms', and 'duration_ms'.
-    """
-
-    mppt_po = perturb_observe = "mppt_po"
-    """
-    Emulate a harvester with perturb and observe maximum power point
-    tracking.
-
-    This MPPT heuristic adjusts the harvesting voltage by small amounts and
-    checks if the power increases. Eventually, the tracking changes the
-    direction of adjustments and oscillates around the MPP.
-    """
-
-    mppt_opt = optimal = "mppt_opt"
-    """
-    A theoretical harvester that identifies the MPP by reading it from the
-    IV curve during emulation.
-
-    Note that this is not possible for real-world harvesting as the system would
-    not know the entire IV curve. In that case a very fast and detailed mppt_po is
-    used.
-    """
+from .enum_datatypes import EnergyDType
+from .enum_datatypes import HarvestAlgorithmDType
 
 
+@final
 class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     """The virtual harvester configuration characterizes usage of an energy environment.
 
@@ -150,9 +66,9 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     storage.
     """
 
-    # General Metadata & Ownership -> ContentModel
+    # General Metadata & Ownership -> see ContentModel
 
-    algorithm: AlgorithmDType
+    algorithm: HarvestAlgorithmDType
     """The algorithm determines how the harvester chooses the harvesting voltage.
     """
 
@@ -369,12 +285,12 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
 
         interval_ms = min(max(self.interval_ms, time_min_ms), 1_000_000)
         duration_ms = min(max(self.duration_ms, time_min_ms), interval_ms)
-        _ratio = (duration_ms / interval_ms) / (self.duration_ms / self.interval_ms)
-        if (_ratio - 1) > 0.1:
+        ratio = (duration_ms / interval_ms) / (self.duration_ms / self.interval_ms)
+        if (ratio - 1) > 0.1:
             log.debug(
                 "Ratio between interval & duration has changed "
                 "more than 10%% due to constraints (%.4f)",
-                _ratio,
+                ratio,
             )
         return interval_ms, duration_ms
 
@@ -436,6 +352,7 @@ ALGO_TO_DTYPE: Mapping[str, EnergyDType] = {
 }
 
 
+@final
 class HarvesterPRUConfig(ShpModel):
     """Map settings-list to internal state-vars struct HarvesterConfig for PRU.
 

shepherd_core/data_models/content/virtual_source_config.py

@@ -2,6 +2,7 @@
 
 from typing import Annotated
 from typing import Any
+from typing import final
 
 from pydantic import Field
 from pydantic import model_validator
@@ -13,7 +14,7 @@ from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.logger import log
 from shepherd_core.testbed_client import tb_client
 
-from .energy_environment import EnergyDType
+from .enum_datatypes import EnergyDType
 from .virtual_harvester_config import HarvesterPRUConfig
 from .virtual_harvester_config import VirtualHarvesterConfig
 from .virtual_storage_config import VirtualStorageConfig
@@ -28,6 +29,7 @@ LUT2D = Annotated[list[LUT1D], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
 vhrv_mppt_opt = VirtualHarvesterConfig(name="mppt_opt")
 
 
+@final
 class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     """The vSrc uses the energy environment (file) for supplying the Target Node.
 
@@ -42,7 +44,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
     # TODO: I,V,R should be in regular unit (V, A, Ohm)
 
-    # General Metadata & Ownership -> ContentModel
+    # General Metadata & Ownership -> see ContentModel
 
     enable_boost: bool = False
     """ ⤷ if false -> v_intermediate = v_input, output-switch-hysteresis is still usable"""
@@ -165,6 +167,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         - the converter always turns on with "V_storage_enable_threshold_uV".
 
         TODO: currently neglecting delay after disabling converter, boost
+        TODO: warn and explain when altering config due to boundaries (transparency)
         only has simpler formula, second enabling when V_Cap >= V_out
 
         Math behind this calculation:
@@ -292,6 +295,7 @@ lut_i = Annotated[
 lut_o = Annotated[list[u32], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
 
 
+@final
 class ConverterPRUConfig(ShpModel):
     """Map settings-list to internal state-vars struct ConverterConfig.
 
@@ -386,3 +390,18 @@ class ConverterPRUConfig(ShpModel):
                 for value in data.LUT_output_efficiency
             ],
         )
+
+    def storage_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 1)
+
+    def boost_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 2)
+
+    def buck_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 4)
+
+    def logging_intermediate_node_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 8)
+
+    def feedback_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 16)

shepherd_core/data_models/content/virtual_storage_config.py

@@ -16,6 +16,7 @@ from collections.abc import Sequence
 from datetime import timedelta
 from typing import Annotated
 from typing import Any
+from typing import final
 
 from annotated_types import Ge
 from annotated_types import Gt
@@ -38,6 +39,7 @@ soc_t = Annotated[float, Ge(0.0), Le(1.0)]
 # TODO: do we need to set initial voltage, or is SoC ok? add V_OC_to_SoC()
 
 
+@final
 class VirtualStorageConfig(ContentModel, title="Config for the virtual energy storage"):
     """KiBaM Battery model based on two papers.
 
@@ -129,7 +131,7 @@ class VirtualStorageConfig(ContentModel, title="Config for the virtual energy st
         if description is None:
             description = "Model of a LiPo battery (3 to 4.2 V) with adjustable capacity"
         return cls(
-            SoC_init=SoC_init if SoC_init else cls.model_fields["SoC_init"].default,
+            SoC_init=SoC_init or cls.model_fields["SoC_init"].default,
             q_As=q_mAh * 3600 / 1000,
             p_VOC=[-0.852, 63.867, 3.6297, 0.559, 0.51, 0.508],
             p_Rs=[0.1463, 30.27, 0.1037, 0.0584, 0.1747, 0.1288],
@@ -176,7 +178,7 @@ class VirtualStorageConfig(ContentModel, title="Config for the virtual energy st
         if description is None:
             description = "Model of a 12V lead acid battery with adjustable capacity"
         return cls(
-            SoC_init=SoC_init if SoC_init else cls.model_fields["SoC_init"].default,
+            SoC_init=SoC_init or cls.model_fields["SoC_init"].default,
             q_As=q_mAh * 3600 / 1000,
             p_VOC=[5.429, 117.5, 11.32, 2.706, 2.04, 1.026],
             p_Rs=[1.578, 8.527, 0.7808, -1.887, -2.404, -0.649],
@@ -222,14 +224,14 @@ class VirtualStorageConfig(ContentModel, title="Config for the virtual energy st
         if R_series_Ohm is not None:
             description += f", R_serial = {R_series_Ohm:.0f} Ohm"
         return cls(
-            SoC_init=SoC_init if SoC_init else cls.model_fields["SoC_init"].default,
+            SoC_init=SoC_init or cls.model_fields["SoC_init"].default,
             q_As=1e-6 * C_uF * V_rated,
             p_VOC=[0, 0, 0, V_rated, 0, 0],  # 100% SoC is @V_rated,
             # no transients per default
             p_Rs=[0, 0, R_series_Ohm, 0, 0, 0]
             if R_series_Ohm
             else cls.model_fields["p_Rs"].default,  # const series resistance
-            R_leak_Ohm=R_leak_Ohm if R_leak_Ohm else cls.model_fields["R_leak_Ohm"].default,
+            R_leak_Ohm=R_leak_Ohm or cls.model_fields["R_leak_Ohm"].default,
             # content-fields below
             name="_".join(name_lmnts),
             description=description,
@@ -378,6 +380,7 @@ u32 = Annotated[int, Field(ge=0, lt=2**32)]
 lut_storage = Annotated[list[u32], Field(min_length=LuT_SIZE, max_length=LuT_SIZE)]
 
 
+@final
 class StoragePRUConfig(ShpModel):
     """Map settings-list to internal state-vars struct StorageConfig.
 

shepherd_core/data_models/content/virtual_storage_fixture_creator.py

@@ -19,7 +19,7 @@ dsc_super = "SuperCapacitor with typically 1000 hours / 500 k cycles (not modele
 # typical voltage-ratings: 2.5, 4.0, 6.3, 10, 16, 20 V
 E6: list[int] = [10, 15, 22, 33, 47, 68, 100, 150, 220, 330, 470, 680, 1000]
 fixture_ideal: list[VirtualStorageConfig] = [
-    VirtualStorageConfig.capacitor(C_uF=_v, V_rated=10.0, description=dsc_ideal) for _v in E6
+    VirtualStorageConfig.capacitor(C_uF=v_, V_rated=10.0, description=dsc_ideal) for v_ in E6
 ]
 
 # Tantal Capacitors, E6 row

shepherd_core/data_models/content/virtual_storage_fixture_param_experiments.py

@@ -46,7 +46,7 @@ def experiment_self_discharge_lead_acid() -> None:
 
     sim.run(fn=step, duration_s=duration.total_seconds())
     sim.plot(
-        f"XP {cfg1.name}, self-discharge, "
+        f"Experiment {cfg1.name}, self-discharge, "
         f"SoC {SoC_init:.3f} to {SoC_final:.3f} in {duration.total_seconds()} s"
     )
 
@@ -83,7 +83,7 @@ def experiment_self_discharge_lipo() -> None:
 
     sim.run(fn=step, duration_s=duration.total_seconds())
     sim.plot(
-        f"XP {cfg1.name}, self-discharge, "
+        f"Experiment {cfg1.name}, self-discharge, "
         f"SoC {SoC_init:.3f} to {SoC_final:.3f} in {duration.total_seconds()} s"
     )
 
@@ -112,7 +112,7 @@ def experiment_self_discharge_tantal_avx() -> None:
         return 0
 
     sim.run(fn=step, duration_s=duration.total_seconds())
-    sim.plot(f"XP Tantal AVX, self-discharge {duration.total_seconds()} s")
+    sim.plot(f"Experiment Tantal AVX, self-discharge {duration.total_seconds()} s")
 
 
 def experiment_self_discharge_mlcc_tayo() -> None:
@@ -141,7 +141,7 @@ def experiment_self_discharge_mlcc_tayo() -> None:
         return 0
 
     sim.run(fn=step, duration_s=duration.total_seconds())
-    sim.plot(f"XP MLCC Tayo, self-discharge {duration.total_seconds()} s")
+    sim.plot(f"Experiment MLCC Tayo, self-discharge {duration.total_seconds()} s")
 
 
 if __name__ == "__main__":

shepherd_core/data_models/experiment/experiment.py

@@ -3,7 +3,9 @@
 from collections.abc import Iterable
 from datetime import datetime
 from datetime import timedelta
+from typing import TYPE_CHECKING
 from typing import Annotated
+from typing import final
 
 from pydantic import Field
 from pydantic import model_validator
@@ -16,15 +18,20 @@ from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.data_models.base.timezone import local_now
 from shepherd_core.data_models.testbed.target import Target
 from shepherd_core.data_models.testbed.testbed import Testbed
+from shepherd_core.logger import log
 from shepherd_core.version import version
 
 from .observer_features import SystemLogging
 from .target_config import TargetConfig
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 # defaults (pre-init complex types)
 sys_log_all = SystemLogging()  # = all active
 
 
+@final
 class Experiment(ShpModel, title="Config of an Experiment"):
     """Config for experiments on the testbed emulating energy environments for target nodes."""
 
@@ -54,6 +61,7 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     def post_validation(self) -> Self:
         self._validate_observers(self.target_configs)
         self._validate_targets(self.target_configs)
+        self._validate_eenvs(self.target_configs)
         if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Duration of experiment can't be negative.")
         return self
@@ -62,16 +70,16 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     def _validate_targets(configs: Iterable[TargetConfig]) -> None:
         target_ids: list[int] = []
         custom_ids: list[int] = []
-        for _config in configs:
-            for _id in _config.target_IDs:
-                target_ids.append(_id)
+        for config_ in configs:
+            for id_ in config_.target_IDs:
+                target_ids.append(id_)
                 if config.VALIDATE_INFRA:
-                    Target(id=_id)
+                    Target(id=id_)
                     # ⤷ this can raise exception for non-existing targets
-            if _config.custom_IDs is not None:
-                custom_ids = custom_ids + _config.custom_IDs[: len(_config.target_IDs)]
+            if config_.custom_IDs is not None:
+                custom_ids += config_.custom_IDs[: len(config_.target_IDs)]
             else:
-                custom_ids = custom_ids + _config.target_IDs
+                custom_ids += config_.target_IDs
         if len(target_ids) > len(set(target_ids)):
             raise ValueError("Target-ID used more than once in Experiment!")
         if len(target_ids) > len(set(custom_ids)):
@@ -82,20 +90,37 @@ class Experiment(ShpModel, title="Config of an Experiment"):
         if not config.VALIDATE_INFRA:
             return
         testbed = Testbed()
-        target_ids = [_id for _config in configs for _id in _config.target_IDs]
-        obs_ids = [testbed.get_observer(_id).id for _id in target_ids]
+        target_ids = [id_ for config_ in configs for id_ in config_.target_IDs]
+        obs_ids = [testbed.get_observer(id_).id for id_ in target_ids]
         if len(target_ids) > len(set(obs_ids)):
             raise ValueError(
                 "Observer is used more than once in Experiment -> only 1 target per observer!"
             )
 
+    @staticmethod
+    def _validate_eenvs(configs: Iterable[TargetConfig]) -> None:
+        """Make sure eenvs are usable."""
+        # TODO: these individual validations should go to class itself (decoupling)
+        # TODO: data_2_copy means the data itself must be locally available
+        paths_all: list[Path] = [
+            path
+            for cfg in configs
+            for path in cfg.get_critical_paths(warn_reuse=False)
+            # direct warning inside cfg is disabled here as it is done during cfg.__init__()
+        ]
+        if len(paths_all) != len(set(paths_all)):
+            log.warning(
+                "Detected re-usage of non-repeatable EnergyProfiles "
+                "in Experiment across TargetConfigs"
+            )
+
     def get_target_ids(self) -> list:
-        return [_id for _config in self.target_configs for _id in _config.target_IDs]
+        return [id_ for config_ in self.target_configs for id_ in config_.target_IDs]
 
     def get_target_config(self, target_id: int) -> TargetConfig:
-        for _config in self.target_configs:
-            if target_id in _config.target_IDs:
-                return _config
+        for config_ in self.target_configs:
+            if target_id in config_.target_IDs:
+                return config_
         # gets already caught in target_config - but keep:
         msg = f"Target-ID {target_id} was not found in Experiment '{self.name}'"
         raise ValueError(msg)

shepherd_core/data_models/experiment/observer_features.py

@@ -3,6 +3,7 @@
 from datetime import timedelta
 from enum import Enum
 from typing import Annotated
+from typing import final
 
 import numpy as np
 from annotated_types import Interval
@@ -19,12 +20,17 @@ from shepherd_core.logger import log
 zero_duration = timedelta(seconds=0)
 
 
+@final
 class PowerTracing(ShpModel, title="Config for Power-Tracing"):
-    """Configuration for recording the Power-Consumption of the Target Nodes."""
+    """Configuration for recording the Power-Consumption of the Target Nodes.
+
+    With the default configuration voltage and current are sampled with 100 kHz.
+    """
 
     intermediate_voltage: bool = False
     """
-    ⤷ for EMU: record storage capacitor instead of output (good for V_out = const)
+    ⤷ for EMU: record output-path of intermediate energy storage (capacitor, battery)
+               instead of direct target voltage-output (good for V_out = const)
                this also includes current!
     """
     # time
@@ -38,7 +44,8 @@ class PowerTracing(ShpModel, title="Config for Power-Tracing"):
     # further processing of IV-Samples
     only_power: bool = False
     """ ⤷ reduce file-size by calculating power and automatically discard I&V
-        Caution: increases cpu-utilization on observer - power @ 100 kHz is not recommended
+        Caution: increases cpu-utilization on observer
+                 sampling power @ 100 kHz is not recommended
     """
     samplerate: Annotated[int, Field(ge=10, le=100_000)] = 100_000
     """ ⤷ reduce file-size by re-sampling (mean over x samples)
@@ -107,6 +114,7 @@ STOPBITS_ONE, STOPBITS_ONE_POINT_FIVE, STOPBITS_TWO = (1, 1.5, 2)
 STOPBITS = (STOPBITS_ONE, STOPBITS_ONE_POINT_FIVE, STOPBITS_TWO)
 
 
+@final
 class UartLogging(ShpModel, title="Config for UART Logging"):
     """Configuration for recording UART-Output of the Target Nodes.
 
@@ -139,6 +147,7 @@ GpioList = Annotated[list[GpioInt], Field(min_length=1, max_length=18)]
 all_gpio = list(range(18))
 
 
+@final
 class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
     """Configuration for recording the GPIO-Output of the Target Nodes.
 
@@ -194,6 +203,7 @@ class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
         return mask
 
 
+@final
 class GpioLevel(str, Enum):
     """Options for setting the gpio-level or state."""
 
@@ -202,6 +212,7 @@ class GpioLevel(str, Enum):
     toggle = "X"  # TODO: not the smartest decision for writing a converter
 
 
+@final
 class GpioEvent(ShpModel, title="Config for a GPIO-Event"):
     """Configuration for a single GPIO-Event (Actuation)."""
 
@@ -228,6 +239,7 @@ class GpioEvent(ShpModel, title="Config for a GPIO-Event"):
         return np.arange(self.delay, stop, self.period)
 
 
+@final
 class GpioActuation(ShpModel, title="Config for GPIO-Actuation"):
     """Configuration for a GPIO-Actuation-Sequence."""
 
@@ -242,9 +254,10 @@ class GpioActuation(ShpModel, title="Config for GPIO-Actuation"):
         raise ValueError(msg)
 
     def get_gpios(self) -> set:
-        return {_ev.gpio for _ev in self.events}
+        return {ev_.gpio for ev_ in self.events}
 
 
+@final
 class SystemLogging(ShpModel, title="Config for System-Logging"):
     """Configuration for recording Debug-Output of the Observers System-Services."""