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

shepherd_core/calibration_hw_def.py

@@ -10,26 +10,26 @@ currently configured for cape v2.4c
 """
 
 # both current channels have a 0.1 % shunt resistance of
-R_SHT = 2.0  # [ohm]
+R_SHT: float = 2.0  # [ohm]
 # the instrumentation amplifiers are configured for gain of
-G_INST_AMP = 48  # [n]
+G_INST_AMP: int = 48  # [n]
 # we use the ADC's internal reference with
-V_REF_ADC = 4.096  # [V]
+V_REF_ADC: float = 4.096  # [V]
 # range of current channels is
-G_ADC_I = 1.25  # [gain / V_REF]
+G_ADC_I: float = 1.25  # [gain / V_REF]
 # range of voltage channels is
-G_ADC_V = 1.25  # [gain / V_REF]
+G_ADC_V: float = 1.25  # [gain / V_REF]
 # bit resolution of ADC
-M_ADC = 18  # [bit]
+M_ADC: int = 18  # [bit]
 # DACs use internal reference with
-V_REF_DAC = 2.5  # [V]
+V_REF_DAC: float = 2.5  # [V]
 # gain of DAC is set to
-G_DAC = 2  # [n]
+G_DAC: int = 2  # [n]
 # bit resolution of DAC
-M_DAC = 16  # [bit]
+M_DAC: int = 16  # [bit]
 # DERIVED VARIABLES
-RAW_MAX_ADC = 2**M_ADC - 1
-RAW_MAX_DAC = 2**M_DAC - 1
+RAW_MAX_ADC: int = 2**M_ADC - 1
+RAW_MAX_DAC: int = 2**M_DAC - 1
 
 
 def adc_current_to_raw(current: float, *, limited: bool = True) -> int:

shepherd_core/commons.py

@@ -1,8 +1,8 @@
 """Container for commonly shared constants."""
 
-samplerate_sps_default: int = 100_000
+SAMPLERATE_SPS_DEFAULT: int = 100_000
 
-uid_str_default: str = "SHEPHERD_NODE_ID"
-uid_len_default: int = 2
+UID_NAME: str = "SHEPHERD_NODE_ID"
+UID_SIZE: int = 2
 
-testbed_server_default: str = "http://127.0.0.1:8000/shepherd"
+TESTBED_SERVER_URI: str = "http://127.0.0.1:8000/shepherd"

shepherd_core/data_models/base/cal_measurement.py

@@ -1,13 +1,12 @@
 """Models for the process of calibration a device by measurements."""
 
-from typing import List
+from typing import Annotated
 from typing import Optional
 
 import numpy as np
 from pydantic import Field
 from pydantic import PositiveFloat
 from pydantic import validate_call
-from typing_extensions import Annotated
 
 from .calibration import CalibrationCape
 from .calibration import CalibrationEmulator
@@ -24,7 +23,7 @@ class CalMeasurementPair(ShpModel):
     reference_si: float = 0
 
 
-CalMeasPairs = Annotated[List[CalMeasurementPair], Field(min_length=2)]
+CalMeasPairs = Annotated[list[CalMeasurementPair], Field(min_length=2)]
 
 
 @validate_call
@@ -37,16 +36,16 @@ def meas_to_cal(data: CalMeasPairs, component: str) -> CalibrationPair:
         y[i] = pair.reference_si
 
     model = np.polyfit(x, y, 1)
-    offset = model[1]
-    gain = model[0]
+    offset: float = float(model[1])
+    gain: float = float(model[0])
 
     # r-squared, Pearson correlation coefficient
-    p = np.poly1d(model)
-    yhat = p(x)
-    ybar = np.sum(y) / len(y)
-    ssreg = np.sum((yhat - ybar) ** 2)
-    sstot = np.sum((y - ybar) ** 2)
-    rval = ssreg / sstot
+    _p = np.poly1d(model)
+    yhat = _p(x)
+    ybar: float = np.sum(y) / len(y)
+    ssreg: float = np.sum((yhat - ybar) ** 2)
+    sstot: float = np.sum((y - ybar) ** 2)
+    rval: float = ssreg / sstot
 
     if rval < 0.999:
         msg = (

shepherd_core/data_models/base/calibration.py

@@ -1,11 +1,11 @@
 """Models for the calibration-data to convert between raw & SI-Values."""
 
 import struct
+from collections.abc import Generator
+from collections.abc import Mapping
+from collections.abc import Sequence
 from typing import Callable
-from typing import Generator
-from typing import Mapping
 from typing import Optional
-from typing import Sequence
 from typing import TypeVar
 from typing import Union
 
@@ -18,9 +18,10 @@ from pydantic import constr
 from pydantic import validate_call
 from typing_extensions import Self
 
-from ...calibration_hw_def import adc_current_to_raw
-from ...calibration_hw_def import adc_voltage_to_raw
-from ...calibration_hw_def import dac_voltage_to_raw
+from shepherd_core.calibration_hw_def import adc_current_to_raw
+from shepherd_core.calibration_hw_def import adc_voltage_to_raw
+from shepherd_core.calibration_hw_def import dac_voltage_to_raw
+
 from .shepherd import ShpModel
 from .timezone import local_iso_date
 

shepherd_core/data_models/base/content.py

@@ -2,6 +2,7 @@
 
 import hashlib
 from datetime import datetime
+from typing import Annotated
 from typing import Optional
 from typing import Union
 from uuid import uuid4
@@ -10,7 +11,6 @@ from pydantic import UUID4
 from pydantic import Field
 from pydantic import StringConstraints
 from pydantic import model_validator
-from typing_extensions import Annotated
 from typing_extensions import Self
 from typing_extensions import deprecated
 

shepherd_core/data_models/base/shepherd.py

@@ -2,11 +2,11 @@
 
 import hashlib
 import pathlib
+from collections.abc import Generator
 from datetime import timedelta
 from ipaddress import IPv4Address
 from pathlib import Path
 from typing import Any
-from typing import Generator
 from typing import Optional
 from typing import Union
 from uuid import UUID
@@ -15,27 +15,26 @@ import yaml
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from typing_extensions import Self
-from yaml import Dumper
+from yaml import Node
 from yaml import SafeDumper
-from yaml import ScalarNode
 
 from .timezone import local_now
 from .wrapper import Wrapper
 
 
 def path2str(
-    dumper: Dumper, data: Union[pathlib.Path, pathlib.WindowsPath, pathlib.PosixPath]
-) -> ScalarNode:
+    dumper: SafeDumper, data: Union[pathlib.Path, pathlib.WindowsPath, pathlib.PosixPath]
+) -> Node:
     """Add a yaml-representation for a specific datatype."""
     return dumper.represent_scalar("tag:yaml.org,2002:str", str(data.as_posix()))
 
 
-def time2int(dumper: Dumper, data: timedelta) -> ScalarNode:
+def time2int(dumper: SafeDumper, data: timedelta) -> Node:
     """Add a yaml-representation for a specific datatype."""
     return dumper.represent_scalar("tag:yaml.org,2002:int", str(int(data.total_seconds())))
 
 
-def generic2str(dumper: Dumper, data: Any) -> ScalarNode:
+def generic2str(dumper: SafeDumper, data: Any) -> Node:
     """Add a yaml-representation for a specific datatype."""
     return dumper.represent_scalar("tag:yaml.org,2002:str", str(data))
 

shepherd_core/data_models/base/wrapper.py

@@ -1,13 +1,13 @@
 """Wrapper-related ecosystem for transferring models."""
 
 from datetime import datetime
+from typing import Annotated
 from typing import Optional
 
 from pydantic import BaseModel
 from pydantic import StringConstraints
-from typing_extensions import Annotated
 
-from ...version import version
+from shepherd_core.version import version
 
 SafeStrClone = Annotated[str, StringConstraints(pattern=r"^[ -~]+$")]
 # ⤷ copy avoids circular import

shepherd_core/data_models/content/energy_environment.py

@@ -2,13 +2,14 @@
 
 from enum import Enum
 from pathlib import Path
+from typing import Any
 from typing import Optional
 
 from pydantic import PositiveFloat
 from pydantic import model_validator
 
-from ...testbed_client import tb_client
-from ..base.content import ContentModel
+from shepherd_core.data_models.base.content import ContentModel
+from shepherd_core.testbed_client import tb_client
 
 
 class EnergyDType(str, Enum):
@@ -46,7 +47,7 @@ class EnergyEnvironment(ContentModel):
 
     @model_validator(mode="before")
     @classmethod
-    def query_database(cls, values: dict) -> dict:
+    def query_database(cls, values: dict[str, Any]) -> dict[str, Any]:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         # TODO: figure out a way to crosscheck type with actual data
         return tb_client.fill_in_user_data(values)

shepherd_core/data_models/content/firmware.py

@@ -4,6 +4,8 @@ TODO: should be more generalized - currently only supports msp & nRF
 """
 
 from pathlib import Path
+from typing import Annotated
+from typing import Any
 from typing import Optional
 from typing import TypedDict
 from typing import Union
@@ -11,15 +13,15 @@ from typing import Union
 from pydantic import StringConstraints
 from pydantic import model_validator
 from pydantic import validate_call
-from typing_extensions import Annotated
 from typing_extensions import Self
 from typing_extensions import Unpack
 
-from ... import fw_tools
-from ...logger import logger
-from ...testbed_client import tb_client
-from ..base.content import ContentModel
-from ..testbed.mcu import MCU
+from shepherd_core import fw_tools
+from shepherd_core.data_models.base.content import ContentModel
+from shepherd_core.data_models.testbed.mcu import MCU
+from shepherd_core.logger import logger
+from shepherd_core.testbed_client import tb_client
+
 from .firmware_datatype import FirmwareDType
 
 suffix_to_DType: dict = {
@@ -64,7 +66,7 @@ class Firmware(ContentModel, title="Firmware of Target"):
 
     @model_validator(mode="before")
     @classmethod
-    def query_database(cls, values: dict) -> dict:
+    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")

shepherd_core/data_models/content/virtual_harvester.py

@@ -1,20 +1,22 @@
 """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 Optional
-from typing import Tuple
 
 from pydantic import Field
 from pydantic import model_validator
-from typing_extensions import Annotated
 from typing_extensions import Self
 
-from ...commons import samplerate_sps_default
-from ...logger import logger
-from ...testbed_client import tb_client
-from ..base.calibration import CalibrationHarvester
-from ..base.content import ContentModel
-from ..base.shepherd import ShpModel
+from shepherd_core.commons import SAMPLERATE_SPS_DEFAULT
+from shepherd_core.data_models.base.calibration import CalibrationHarvester
+from shepherd_core.data_models.base.content import ContentModel
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.logger import logger
+from shepherd_core.testbed_client import tb_client
+
 from .energy_environment import EnergyDType
 
 
@@ -73,7 +75,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
 
     @model_validator(mode="before")
     @classmethod
-    def query_database(cls, values: dict) -> dict:
+    def query_database(cls, values: dict[str, Any]) -> dict[str, Any]:
         values, chain = tb_client.try_completing_model(cls.__name__, values)
         values = tb_client.fill_in_user_data(values)
         if values["name"] == "neutral":
@@ -114,14 +116,14 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
         return 1 * int(for_emu) + 2 * self.rising + 4 * self.enable_linear_extrapolation
 
     def calc_algorithm_num(self, *, for_emu: bool) -> int:
-        num = algo_to_num.get(self.algorithm)
+        num: int = ALGO_TO_NUM.get(self.algorithm, ALGO_TO_NUM["neutral"])
         if for_emu and self.get_datatype() != EnergyDType.ivsample:
             msg = (
                 f"[{self.name}] Select valid harvest-algorithm for emulator, "
                 f"current usage = {self.algorithm}"
             )
             raise ValueError(msg)
-        if not for_emu and num < algo_to_num["isc_voc"]:
+        if not for_emu and num < ALGO_TO_NUM["isc_voc"]:
             msg = (
                 f"[{self.name}] Select valid harvest-algorithm for harvester, "
                 f"current usage = {self.algorithm}"
@@ -129,12 +131,12 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
             raise ValueError(msg)
         return num
 
-    def calc_timings_ms(self, *, for_emu: bool) -> Tuple[float, float]:
+    def calc_timings_ms(self, *, for_emu: bool) -> tuple[float, float]:
         """factor-in model-internal timing-constraints."""
         window_length = self.samples_n * (1 + self.wait_cycles)
-        time_min_ms = (1 + self.wait_cycles) * 1_000 / samplerate_sps_default
+        time_min_ms = (1 + self.wait_cycles) * 1_000 / SAMPLERATE_SPS_DEFAULT
         if for_emu:
-            window_ms = window_length * 1_000 / samplerate_sps_default
+            window_ms = window_length * 1_000 / SAMPLERATE_SPS_DEFAULT
             time_min_ms = max(time_min_ms, window_ms)
 
         interval_ms = min(max(self.interval_ms, time_min_ms), 1_000_000)
@@ -149,7 +151,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
         return interval_ms, duration_ms
 
     def get_datatype(self) -> EnergyDType:
-        return algo_to_dtype[self.algorithm]
+        return ALGO_TO_DTYPE[self.algorithm]
 
     def calc_window_size(
         self,
@@ -184,7 +186,7 @@ u32 = Annotated[int, Field(ge=0, lt=2**32)]
 # - harvesting on "neutral" is not possible - direct pass-through
 # - emulation with "ivcurve" or lower is also resulting in Error
 # - "_opt" has its own algo for emulation, but is only a fast mppt_po for harvesting
-algo_to_num = {
+ALGO_TO_NUM: Mapping[str, int] = {
     "neutral": 2**0,
     "isc_voc": 2**3,
     "ivcurve": 2**4,
@@ -195,7 +197,7 @@ algo_to_num = {
     "mppt_opt": 2**14,
 }
 
-algo_to_dtype = {
+ALGO_TO_DTYPE: Mapping[str, EnergyDType] = {
     "neutral": EnergyDType.ivsample,
     "isc_voc": EnergyDType.isc_voc,
     "ivcurve": EnergyDType.ivcurve,
@@ -266,9 +268,15 @@ class HarvesterPRUConfig(ShpModel):
             if window_size is not None
             else data.calc_window_size(dtype_in, for_emu=for_emu)
         )
-        voltage_step_mV = (
-            1e3 * voltage_step_V if voltage_step_V is not None else data.voltage_step_mV
-        )
+        if voltage_step_V is not None:
+            voltage_step_mV = 1e3 * voltage_step_V
+        elif data.voltage_step_mV is not None:
+            voltage_step_mV = data.voltage_step_mV
+        else:
+            raise ValueError(
+                "For correct emulation specify voltage_step used by harvester "
+                "e.g. via file_src.get_voltage_step()"
+            )
 
         return cls(
             algorithm=data.calc_algorithm_num(for_emu=for_emu),
@@ -280,7 +288,7 @@ class HarvesterPRUConfig(ShpModel):
             voltage_step_uV=round(voltage_step_mV * 10**3),
             current_limit_nA=round(data.current_limit_uA * 10**3),
             setpoint_n8=round(min(255, data.setpoint_n * 2**8)),
-            interval_n=round(interval_ms * samplerate_sps_default * 1e-3),
-            duration_n=round(duration_ms * samplerate_sps_default * 1e-3),
+            interval_n=round(interval_ms * SAMPLERATE_SPS_DEFAULT * 1e-3),
+            duration_n=round(duration_ms * SAMPLERATE_SPS_DEFAULT * 1e-3),
             wait_cycles_n=data.wait_cycles,
         )

shepherd_core/data_models/content/virtual_source.py

@@ -1,17 +1,18 @@
 """Generalized virtual source data models."""
 
-from typing import List
+from typing import Annotated
+from typing import Any
 
 from pydantic import Field
 from pydantic import model_validator
-from typing_extensions import Annotated
 from typing_extensions import Self
 
-from ...commons import samplerate_sps_default
-from ...logger import logger
-from ...testbed_client import tb_client
-from ..base.content import ContentModel
-from ..base.shepherd import ShpModel
+from shepherd_core.commons import SAMPLERATE_SPS_DEFAULT
+from shepherd_core.data_models.base.content import ContentModel
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.logger import logger
+from shepherd_core.testbed_client import tb_client
+
 from .energy_environment import EnergyDType
 from .virtual_harvester import HarvesterPRUConfig
 from .virtual_harvester import VirtualHarvesterConfig
@@ -19,8 +20,8 @@ from .virtual_harvester import VirtualHarvesterConfig
 # Custom Types
 LUT_SIZE: int = 12
 NormedNum = Annotated[float, Field(ge=0.0, le=1.0)]
-LUT1D = Annotated[List[NormedNum], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
-LUT2D = Annotated[List[LUT1D], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
+LUT1D = Annotated[list[NormedNum], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
+LUT2D = Annotated[list[LUT1D], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
 
 
 class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
@@ -113,7 +114,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
     @model_validator(mode="before")
     @classmethod
-    def query_database(cls, values: dict) -> dict:
+    def query_database(cls, values: dict[str, Any]) -> dict[str, Any]:
         values, chain = tb_client.try_completing_model(cls.__name__, values)
         values = tb_client.fill_in_user_data(values)
         logger.debug("VSrc-Inheritances: %s", chain)
@@ -238,19 +239,19 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         dV[uV] = constant[us/nF] * current[nA] = constant[us*V/nAs] * current[nA]
         """
         C_cap_uF = max(self.C_intermediate_uF, 0.001)
-        return int((10**3 * (2**28)) // (C_cap_uF * samplerate_sps_default))
+        return int((10**3 * (2**28)) // (C_cap_uF * SAMPLERATE_SPS_DEFAULT))
 
 
 u32 = Annotated[int, Field(ge=0, lt=2**32)]
 u8 = Annotated[int, Field(ge=0, lt=2**8)]
 lut_i = Annotated[
-    List[Annotated[List[u8], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]],
+    list[Annotated[list[u8], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]],
     Field(
         min_length=LUT_SIZE,
         max_length=LUT_SIZE,
     ),
 ]
-lut_o = Annotated[List[u32], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
+lut_o = Annotated[list[u32], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
 
 
 class ConverterPRUConfig(ShpModel):
@@ -313,7 +314,7 @@ class ConverterPRUConfig(ShpModel):
                 dtype_in, log_intermediate_node=log_intermediate_node
             ),
             interval_startup_delay_drain_n=round(
-                data.interval_startup_delay_drain_ms * samplerate_sps_default * 1e-3
+                data.interval_startup_delay_drain_ms * SAMPLERATE_SPS_DEFAULT * 1e-3
             ),
             V_input_max_uV=round(data.V_input_max_mV * 1e3),
             I_input_max_nA=round(data.I_input_max_mA * 1e6),
@@ -326,7 +327,7 @@ class ConverterPRUConfig(ShpModel):
             V_disable_output_threshold_uV=round(states["V_disable_output_threshold_mV"] * 1e3),
             dV_enable_output_uV=round(states["dV_enable_output_mV"] * 1e3),
             interval_check_thresholds_n=round(
-                data.interval_check_thresholds_ms * samplerate_sps_default * 1e-3
+                data.interval_check_thresholds_ms * SAMPLERATE_SPS_DEFAULT * 1e-3
             ),
             V_pwr_good_enable_threshold_uV=round(data.V_pwr_good_enable_threshold_mV * 1e3),
             V_pwr_good_disable_threshold_uV=round(data.V_pwr_good_disable_threshold_mV * 1e3),

shepherd_core/data_models/experiment/experiment.py

@@ -1,9 +1,9 @@
 """Config for testbed experiments."""
 
+from collections.abc import Iterable
 from datetime import datetime
 from datetime import timedelta
-from typing import Iterable
-from typing import List
+from typing import Annotated
 from typing import Optional
 from typing import Union
 from uuid import uuid4
@@ -11,16 +11,16 @@ from uuid import uuid4
 from pydantic import UUID4
 from pydantic import Field
 from pydantic import model_validator
-from typing_extensions import Annotated
 from typing_extensions import Self
 
-from ...version import version
-from ..base.content import IdInt
-from ..base.content import NameStr
-from ..base.content import SafeStr
-from ..base.shepherd import ShpModel
-from ..testbed.target import Target
-from ..testbed.testbed import Testbed
+from shepherd_core.data_models.base.content import IdInt
+from shepherd_core.data_models.base.content import NameStr
+from shepherd_core.data_models.base.content import SafeStr
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.data_models.testbed.target import Target
+from shepherd_core.data_models.testbed.testbed import Testbed
+from shepherd_core.version import version
+
 from .observer_features import SystemLogging
 from .target_config import TargetConfig
 
@@ -54,7 +54,7 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     abort_on_error: bool = False
 
     # targets
-    target_configs: Annotated[List[TargetConfig], Field(min_length=1, max_length=128)]
+    target_configs: Annotated[list[TargetConfig], Field(min_length=1, max_length=128)]
 
     # for debug-purposes and later comp-checks
     lib_ver: Optional[str] = version
@@ -70,8 +70,8 @@ class Experiment(ShpModel, title="Config of an Experiment"):
 
     @staticmethod
     def _validate_targets(configs: Iterable[TargetConfig]) -> None:
-        target_ids = []
-        custom_ids = []
+        target_ids: list[int] = []
+        custom_ids: list[int] = []
         for _config in configs:
             for _id in _config.target_IDs:
                 target_ids.append(_id)

shepherd_core/data_models/experiment/observer_features.py

@@ -2,18 +2,17 @@
 
 from datetime import timedelta
 from enum import Enum
-from typing import List
+from typing import Annotated
 from typing import Optional
 
 import numpy as np
 from pydantic import Field
 from pydantic import PositiveFloat
 from pydantic import model_validator
-from typing_extensions import Annotated
 from typing_extensions import Self
 
-from ..base.shepherd import ShpModel
-from ..testbed.gpio import GPIO
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.data_models.testbed.gpio import GPIO
 
 
 class PowerTracing(ShpModel, title="Config for Power-Tracing"):
@@ -27,7 +26,7 @@ class PowerTracing(ShpModel, title="Config for Power-Tracing"):
     #            this also includes current!
 
     # time
-    delay: timedelta = 0  # seconds
+    delay: timedelta = timedelta(seconds=0)
     duration: Optional[timedelta] = None  # till EOF
 
     # post-processing
@@ -61,11 +60,11 @@ class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
     # initial recording
     mask: Annotated[int, Field(ge=0, lt=2**10)] = 0b11_1111_1111  # all
     # ⤷ TODO: custom mask not implemented in PRU, ATM
-    gpios: Optional[Annotated[List[GPIO], Field(min_length=1, max_length=10)]] = None  # = all
+    gpios: Optional[Annotated[list[GPIO], Field(min_length=1, max_length=10)]] = None  # = all
     # ⤷ TODO: list of GPIO to build mask, one of both should be internal / computed field
 
     # time
-    delay: timedelta = 0  # seconds
+    delay: timedelta = timedelta(seconds=0)
     duration: Optional[timedelta] = None  # till EOF
 
     # post-processing,
@@ -125,7 +124,7 @@ class GpioActuation(ShpModel, title="Config for GPIO-Actuation"):
     # TODO: not implemented ATM - decide if pru control sys-gpio or
     # TODO: not implemented ATM - reverses pru-gpio (preferred if possible)
 
-    events: Annotated[List[GpioEvent], Field(min_length=1, max_length=1024)]
+    events: Annotated[list[GpioEvent], Field(min_length=1, max_length=1024)]
 
     def get_gpios(self) -> set:
         return {_ev.gpio for _ev in self.events}

shepherd_core/data_models/experiment/target_config.py

@@ -1,20 +1,20 @@
 """Configuration related to Target Nodes (DuT)."""
 
-from typing import List
+from typing import Annotated
 from typing import Optional
 
 from pydantic import Field
 from pydantic import model_validator
-from typing_extensions import Annotated
 from typing_extensions import Self
 
-from ..base.content import IdInt
-from ..base.shepherd import ShpModel
-from ..content.energy_environment import EnergyEnvironment
-from ..content.firmware import Firmware
-from ..content.virtual_source import VirtualSourceConfig
-from ..testbed.target import IdInt16
-from ..testbed.target import Target
+from shepherd_core.data_models.base.content import IdInt
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.data_models.content.energy_environment import EnergyEnvironment
+from shepherd_core.data_models.content.firmware import Firmware
+from shepherd_core.data_models.content.virtual_source import VirtualSourceConfig
+from shepherd_core.data_models.testbed.target import IdInt16
+from shepherd_core.data_models.testbed.target import Target
+
 from .observer_features import GpioActuation
 from .observer_features import GpioTracing
 from .observer_features import PowerTracing
@@ -23,15 +23,15 @@ from .observer_features import PowerTracing
 class TargetConfig(ShpModel, title="Target Config"):
     """Configuration related to Target Nodes (DuT)."""
 
-    target_IDs: Annotated[List[IdInt], Field(min_length=1, max_length=128)]
-    custom_IDs: Optional[Annotated[List[IdInt16], Field(min_length=1, max_length=128)]] = None
+    target_IDs: Annotated[list[IdInt], Field(min_length=1, max_length=128)]
+    custom_IDs: Optional[Annotated[list[IdInt16], Field(min_length=1, max_length=128)]] = None
     # ⤷ will replace 'const uint16_t SHEPHERD_NODE_ID' in firmware
     #   if no custom ID is provided, the original ID of target is used
 
     energy_env: EnergyEnvironment  # alias: input
     virtual_source: VirtualSourceConfig = VirtualSourceConfig(name="neutral")
     target_delays: Optional[
-        Annotated[List[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=128)]
+        Annotated[list[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=128)]
     ] = None
     # ⤷ individual starting times -> allows to use the same environment
     # TODO: delays not used ATM