shepherd-core 2023.8.6__py3-none-any.whl → 2023.8.8__py3-none-any.whl

shepherd_core/data_models/content/virtual_source.py

@@ -1,7 +1,8 @@
-from pydantic import confloat
-from pydantic import conint
-from pydantic import conlist
-from pydantic import root_validator
+from typing import List
+
+from pydantic import Field
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ...commons import samplerate_sps_default
 from ...logger import logger
@@ -11,6 +12,12 @@ from ..base.content import ContentModel
 from .virtual_harvester import HarvesterPRUConfig
 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)]
+
 
 class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     """The virtual Source uses the energy environment (file)
@@ -30,89 +37,82 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     enable_buck: bool = False
     # ⤷ if false -> v_output = v_intermediate
 
-    interval_startup_delay_drain_ms: confloat(ge=0, le=10_000) = 0
+    interval_startup_delay_drain_ms: Annotated[float, Field(ge=0, le=10_000)] = 0
 
     harvester: VirtualHarvesterConfig = VirtualHarvesterConfig(name="mppt_opt")
 
-    V_input_max_mV: confloat(ge=0, le=10_000) = 10_000
-    I_input_max_mA: confloat(ge=0, le=4.29e3) = 4_200
-    V_input_drop_mV: confloat(ge=0, le=4.29e6) = 0
+    V_input_max_mV: Annotated[float, Field(ge=0, le=10_000)] = 10_000
+    I_input_max_mA: Annotated[float, Field(ge=0, le=4.29e3)] = 4_200
+    V_input_drop_mV: Annotated[float, Field(ge=0, le=4.29e6)] = 0
     # ⤷ simulate input-diode
-    R_input_mOhm: confloat(ge=0, le=4.29e6) = 0
+    R_input_mOhm: Annotated[float, Field(ge=0, le=4.29e6)] = 0
     # ⤷ resistance only active with disabled boost, range [1 mOhm; 1MOhm]
 
     # primary storage-Cap
-    C_intermediate_uF: confloat(ge=0, le=100_000) = 0
-    V_intermediate_init_mV: confloat(ge=0, le=10_000) = 3_000
+    C_intermediate_uF: Annotated[float, Field(ge=0, le=100_000)] = 0
+    V_intermediate_init_mV: Annotated[float, Field(ge=0, le=10_000)] = 3_000
     # ⤷ allow a proper / fast startup
-    I_intermediate_leak_nA: confloat(ge=0, le=4.29e9) = 0
+    I_intermediate_leak_nA: Annotated[float, Field(ge=0, le=4.29e9)] = 0
 
-    V_intermediate_enable_threshold_mV: confloat(ge=0, le=10_000) = 1
+    V_intermediate_enable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 1
     # ⤷ target gets connected (hysteresis-combo with next value)
-    V_intermediate_disable_threshold_mV: confloat(ge=0, le=10_000) = 0
+    V_intermediate_disable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 0
     # ⤷ target gets disconnected
-    interval_check_thresholds_ms: confloat(ge=0, le=4.29e3) = 0
+    interval_check_thresholds_ms: Annotated[float, Field(ge=0, le=4.29e3)] = 0
     # ⤷ some ICs (BQ) check every 64 ms if output should be disconnected
 
     # pwr-good: target is informed on output-pin (hysteresis) -> for intermediate voltage
-    V_pwr_good_enable_threshold_mV: confloat(ge=0, le=10_000) = 2_800
-    V_pwr_good_disable_threshold_mV: confloat(ge=0, le=10_000) = 2200
+    V_pwr_good_enable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 2_800
+    V_pwr_good_disable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 2200
     immediate_pwr_good_signal: bool = True
     # ⤷ 1: activate instant schmitt-trigger, 0: stay in interval for checking thresholds
 
     # final (always last) stage to compensate undetectable current spikes
     # when enabling power for target
-    C_output_uF: confloat(ge=0, le=4.29e6) = 1.0
+    C_output_uF: Annotated[float, Field(ge=0, le=4.29e6)] = 1.0
 
     # Extra
-    V_output_log_gpio_threshold_mV: confloat(ge=0, le=4.29e6) = 1_400
+    V_output_log_gpio_threshold_mV: Annotated[float, Field(ge=0, le=4.29e6)] = 1_400
     # ⤷ min voltage needed to enable recording changes in gpio-bank
 
     # Boost Converter
-    V_input_boost_threshold_mV: confloat(ge=0, le=10_000) = 0
+    V_input_boost_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 0
     # ⤷ min input-voltage for the boost converter to work
-    V_intermediate_max_mV: confloat(ge=0, le=10_000) = 10_000
+    V_intermediate_max_mV: Annotated[float, Field(ge=0, le=10_000)] = 10_000
     # ⤷ boost converter shuts off
 
-    LUT_input_efficiency: conlist(
-        item_type=conlist(confloat(ge=0.0, le=1.0), min_items=12, max_items=12),
-        min_items=12,
-        max_items=12,
-    ) = 12 * [12 * [1.00]]
+    LUT_input_efficiency: LUT2D = 12 * [12 * [1.00]]
     # ⤷ rows are current -> first row a[V=0][:]
     # input-LUT[12][12] depending on array[inp_voltage][log(inp_current)],
     # influence of cap-voltage is not implemented
-    LUT_input_V_min_log2_uV: conint(ge=0, le=20) = 0
+    LUT_input_V_min_log2_uV: Annotated[int, Field(ge=0, le=20)] = 0
     # ⤷ 2^7 = 128 uV -> LUT[0][:] is for inputs < 128 uV
-    LUT_input_I_min_log2_nA: conint(ge=0, le=20) = 0
+    LUT_input_I_min_log2_nA: Annotated[int, Field(ge=0, le=20)] = 0
     # ⤷ 2^8 = 256 nA -> LUT[:][0] is for inputs < 256 nA
 
     # Buck Converter
-    V_output_mV: confloat(ge=0, le=5_000) = 2_400
-    V_buck_drop_mV: confloat(ge=0, le=5_000) = 0
+    V_output_mV: Annotated[float, Field(ge=0, le=5_000)] = 2_400
+    V_buck_drop_mV: Annotated[float, Field(ge=0, le=5_000)] = 0
     # ⤷ simulate LDO min voltage differential or output-diode
 
-    LUT_output_efficiency: conlist(
-        item_type=confloat(ge=0.0, le=1.0),
-        min_items=12,
-        max_items=12,
-    ) = 12 * [1.00]
+    LUT_output_efficiency: LUT1D = 12 * [1.00]
     # ⤷ array[12] depending on output_current
-    LUT_output_I_min_log2_nA: conint(ge=0, le=20) = 0
+    LUT_output_I_min_log2_nA: Annotated[int, Field(ge=0, le=20)] = 0
     # ⤷ 2^8 = 256 nA -> LUT[0] is for inputs < 256 nA, see notes on LUT_input for explanation
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values, chain = tb_client.try_completing_model(cls.__name__, values)
         values = tb_client.fill_in_user_data(values)
         logger.debug("VSrc-Inheritances: %s", chain)
         return values
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
+    @model_validator(mode="after")
+    def post_validation(self):
         # trigger stricter test of harv-parameters
-        HarvesterPRUConfig.from_vhrv(values.get("harvester"), for_emu=True)
-        return values
+        HarvesterPRUConfig.from_vhrv(self.harvester, for_emu=True)
+        return self
 
     def calc_internal_states(self) -> dict:
         """
@@ -220,15 +220,16 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         return int((10**3 * (2**28)) // (C_cap_uF * samplerate_sps_default))
 
 
-u32 = conint(ge=0, lt=2**32)
-u8 = conint(ge=0, lt=2**8)
-LUT_SIZE: int = 12
-lut_i = conlist(
-    item_type=conlist(u8, min_items=LUT_SIZE, max_items=LUT_SIZE),
-    min_items=LUT_SIZE,
-    max_items=LUT_SIZE,
-)
-lut_o = conlist(u32, min_items=LUT_SIZE, max_items=LUT_SIZE)
+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)]],
+    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):
@@ -282,32 +283,42 @@ class ConverterPRUConfig(ShpModel):
         return cls(
             # General
             converter_mode=data.calc_converter_mode(log_intermediate_node),
-            interval_startup_delay_drain_n=data.interval_startup_delay_drain_ms
-            * samplerate_sps_default
-            * 1e-3,
-            V_input_max_uV=data.V_input_max_mV * 1e3,
-            I_input_max_nA=data.I_input_max_mA * 1e6,
-            V_input_drop_uV=data.V_input_drop_mV * 1e3,
-            R_input_kOhm_n22=data.R_input_mOhm * (1e-6 * 2**22),
+            interval_startup_delay_drain_n=round(
+                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),
+            V_input_drop_uV=round(data.V_input_drop_mV * 1e3),
+            R_input_kOhm_n22=round(data.R_input_mOhm * (1e-6 * 2**22)),
             Constant_us_per_nF_n28=data.calc_cap_constant_us_per_nF_n28(),
-            V_intermediate_init_uV=data.V_intermediate_init_mV * 1e3,
-            I_intermediate_leak_nA=data.I_intermediate_leak_nA,
-            V_enable_output_threshold_uV=states["V_enable_output_threshold_mV"] * 1e3,
-            V_disable_output_threshold_uV=states["V_disable_output_threshold_mV"] * 1e3,
-            dV_enable_output_uV=states["dV_enable_output_mV"] * 1e3,
-            interval_check_thresholds_n=data.interval_check_thresholds_ms
-            * samplerate_sps_default
-            * 1e-3,
-            V_pwr_good_enable_threshold_uV=data.V_pwr_good_enable_threshold_mV * 1e3,
-            V_pwr_good_disable_threshold_uV=data.V_pwr_good_disable_threshold_mV * 1e3,
+            V_intermediate_init_uV=round(data.V_intermediate_init_mV * 1e3),
+            I_intermediate_leak_nA=round(data.I_intermediate_leak_nA),
+            V_enable_output_threshold_uV=round(
+                states["V_enable_output_threshold_mV"] * 1e3
+            ),
+            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
+            ),
+            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
+            ),
             immediate_pwr_good_signal=data.immediate_pwr_good_signal,
-            V_output_log_gpio_threshold_uV=data.V_output_log_gpio_threshold_mV * 1e3,
+            V_output_log_gpio_threshold_uV=round(
+                data.V_output_log_gpio_threshold_mV * 1e3
+            ),
             # Boost-Converter
-            V_input_boost_threshold_uV=data.V_input_boost_threshold_mV * 1e3,
-            V_intermediate_max_uV=data.V_intermediate_max_mV * 1e3,
+            V_input_boost_threshold_uV=round(data.V_input_boost_threshold_mV * 1e3),
+            V_intermediate_max_uV=round(data.V_intermediate_max_mV * 1e3),
             # Buck-Converter
-            V_output_uV=data.V_output_mV * 1e3,
-            V_buck_drop_uV=data.V_buck_drop_mV * 1e3,
+            V_output_uV=round(data.V_output_mV * 1e3),
+            V_buck_drop_uV=round(data.V_buck_drop_mV * 1e3),
             # LUTs
             LUT_input_V_min_log2_uV=data.LUT_input_V_min_log2_uV,
             LUT_input_I_min_log2_nA=data.LUT_input_I_min_log2_nA,

shepherd_core/data_models/doc_virtual_source.py

@@ -1,14 +1,14 @@
 from pathlib import Path
 
 from pydantic import Field
-from pydantic import confloat
-from pydantic import conlist
-from pydantic import root_validator
+from pydantic import model_validator
 
 from .. import logger
 from ..data_models import Fixture
 from ..data_models import ShpModel
 from .content import VirtualHarvesterConfig
+from .content.virtual_source import LUT1D
+from .content.virtual_source import LUT2D
 
 fixture_path = Path(__file__).resolve().with_name("content/virtual_source_fixture.yaml")
 fixtures = Fixture(fixture_path, "content.VirtualSource")
@@ -168,11 +168,7 @@ class VirtualSourceDoc(ShpModel, title="Virtual Source (Documented, Testversion)
         le=10_000,
     )
 
-    LUT_input_efficiency: conlist(
-        item_type=conlist(confloat(ge=0.0, le=1.0), min_items=12, max_items=12),
-        min_items=12,
-        max_items=12,
-    ) = Field(
+    LUT_input_efficiency: LUT2D = Field(
         description="# input-array[12][12] depending on "
         "array[inp_voltage][log(inp_current)], "
         "influence of cap-voltage is not implemented",
@@ -206,11 +202,7 @@ class VirtualSourceDoc(ShpModel, title="Virtual Source (Documented, Testversion)
         le=5_000,
     )
 
-    LUT_output_efficiency: conlist(
-        item_type=confloat(ge=0.0, le=1.0),
-        min_items=12,
-        max_items=12,
-    ) = Field(
+    LUT_output_efficiency: LUT1D = Field(
         description="Output-Array[12] depending on output_current. In & Output is linear",
         default=12 * [1.00],
     )
@@ -222,7 +214,8 @@ class VirtualSourceDoc(ShpModel, title="Virtual Source (Documented, Testversion)
         le=20,
     )
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values = fixtures.try_completing_model(values)
         values, chain = fixtures.try_inheritance(values)

shepherd_core/data_models/experiment/experiment.py

@@ -1,11 +1,12 @@
 from datetime import datetime
 from datetime import timedelta
+from typing import List
 from typing import Optional
 
 from pydantic import EmailStr
 from pydantic import Field
-from pydantic import conlist
-from pydantic import root_validator
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ..base.content import IdInt
 from ..base.content import NameStr
@@ -27,8 +28,11 @@ class Experiment(ShpModel, title="Config of an Experiment"):
         description="Unique ID",
         default_factory=id_default,
     )
+    # ⤷ TODO: automatic ID is problematic for identification by hash
     name: NameStr
-    description: Optional[SafeStr] = Field(description="Required for public instances")
+    description: Annotated[
+        Optional[SafeStr], Field(description="Required for public instances")
+    ] = None
     comment: Optional[SafeStr] = None
     created: datetime = Field(default_factory=datetime.now)
 
@@ -36,7 +40,8 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     owner_id: Optional[IdInt] = 5472  # UUID?
 
     # feedback
-    email_results: Optional[EmailStr]  # TODO: can be bool, as its linked to account
+    email_results: Optional[EmailStr] = None
+    # ⤷ TODO: can be bool, as its linked to account
     sys_logging: SystemLogging = SystemLogging(dmesg=True, ptp=False, shepherd=True)
 
     # schedule
@@ -45,21 +50,21 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     abort_on_error: bool = False
 
     # targets
-    target_configs: conlist(item_type=TargetConfig, min_items=1, max_items=64)
+    target_configs: Annotated[List[TargetConfig], Field(min_length=1, max_length=64)]
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        cls.validate_targets(values)
-        cls.validate_observers(values)
-        if values.get("duration") and values["duration"].total_seconds() < 0:
+    @model_validator(mode="after")
+    def post_validation(self):
+        self.validate_targets(self.target_configs)
+        self.validate_observers(self.target_configs)
+        if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Duration of experiment can't be negative.")
-        return values
+        return self
 
     @staticmethod
-    def validate_targets(values: dict) -> None:
+    def validate_targets(configs: List[TargetConfig]) -> None:
         target_ids = []
         custom_ids = []
-        for _config in values.get("target_configs"):
+        for _config in configs:
             for _id in _config.target_IDs:
                 target_ids.append(_id)
                 Target(id=_id)
@@ -76,9 +81,9 @@ class Experiment(ShpModel, title="Config of an Experiment"):
             )
 
     @staticmethod
-    def validate_observers(values: dict) -> None:
+    def validate_observers(configs: List[TargetConfig]) -> None:
         target_ids = []
-        for _config in values.get("target_configs"):
+        for _config in configs:
             for _id in _config.target_IDs:
                 target_ids.append(_id)
 

shepherd_core/data_models/experiment/observer_features.py

@@ -1,13 +1,13 @@
 from datetime import timedelta
 from enum import Enum
+from typing import List
 from typing import Optional
 
 import numpy as np
+from pydantic import Field
 from pydantic import PositiveFloat
-from pydantic import confloat
-from pydantic import conint
-from pydantic import conlist
-from pydantic import root_validator
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ..base.shepherd import ShpModel
 from ..testbed.gpio import GPIO
@@ -28,26 +28,26 @@ class PowerTracing(ShpModel, title="Config for Power-Tracing"):
 
     # post-processing
     calculate_power: bool = False
-    samplerate: conint(ge=10, le=100_000) = 100_000  # down-sample
+    samplerate: Annotated[int, Field(ge=10, le=100_000)] = 100_000  # down-sample
     discard_current: bool = False
     discard_voltage: bool = False
     # ⤷ reduce file-size by omitting current / voltage
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if values.get("delay") and values["delay"].total_seconds() < 0:
+    @model_validator(mode="after")
+    def post_validation(self):
+        if self.delay and self.delay.total_seconds() < 0:
             raise ValueError("Delay can't be negative.")
-        if values.get("duration") and values["duration"].total_seconds() < 0:
+        if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Duration can't be negative.")
 
-        discard_all = values.get("discard_current") and values.get("discard_voltage")
-        if not values.get("calculate_power") and discard_all:
+        discard_all = self.discard_current and self.discard_voltage
+        if not self.calculate_power and discard_all:
             raise ValueError(
                 "Error in config -> tracing enabled, but output gets discarded"
             )
-        if values.get("calculate_power"):
+        if self.calculate_power:
             raise ValueError("postprocessing not implemented ATM")
-        return values
+        return self
 
 
 class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
@@ -56,10 +56,12 @@ class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
     """
 
     # initial recording
-    mask: conint(ge=0, lt=2**10) = 0b11_1111_1111  # all
+    mask: Annotated[int, Field(ge=0, lt=2**10)] = 0b11_1111_1111  # all
     # ⤷ TODO: custom mask not implemented
-    gpios: Optional[conlist(item_type=GPIO, min_items=1, max_items=10)]  # = all
-    # ⤷ TODO: list of GPIO to build mask, one of both should be internal
+    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
@@ -68,18 +70,18 @@ class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
     # post-processing,
     uart_decode: bool = False  # todo: is currently done online by system-service
     uart_pin: GPIO = GPIO(name="GPIO8")
-    uart_baudrate: conint(ge=2_400, le=921_600) = 115_200
+    uart_baudrate: Annotated[int, Field(ge=2_400, le=921_600)] = 115_200
     # TODO: add a "discard_gpio" (if only uart is wanted)
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if values.get("mask") == 0:
+    @model_validator(mode="after")
+    def post_validation(self):
+        if self.mask == 0:
             raise ValueError("Error in config -> tracing enabled but mask is 0")
-        if values.get("delay") and values["delay"].total_seconds() < 0:
+        if self.delay and self.delay.total_seconds() < 0:
             raise ValueError("Delay can't be negative.")
-        if values.get("duration") and values["duration"].total_seconds() < 0:
+        if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Duration can't be negative.")
-        return values
+        return self
 
 
 class GpioLevel(str, Enum):
@@ -96,17 +98,17 @@ class GpioEvent(ShpModel, title="Config for a GPIO-Event"):
     # ⤷ resolution 10 us (guaranteed, but finer steps are possible)
     gpio: GPIO
     level: GpioLevel
-    period: confloat(ge=10e-6) = 1
+    period: Annotated[float, Field(ge=10e-6)] = 1
     # ⤷ time base of periodicity in s
-    count: conint(ge=1, le=4096) = 1
+    count: Annotated[int, Field(ge=1, le=4096)] = 1
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if not values.get("gpio").user_controllable():
+    @model_validator(mode="after")
+    def post_validation(self):
+        if not self.gpio.user_controllable():
             raise ValueError(
-                f"GPIO '{values.get('gpio').name}' in actuation-event not controllable by user"
+                f"GPIO '{self.gpio.name}' in actuation-event not controllable by user"
             )
-        return values
+        return self
 
     def get_events(self) -> np.ndarray:
         stop = self.delay + self.count * self.period
@@ -120,7 +122,7 @@ class GpioActuation(ShpModel, title="Config for GPIO-Actuation"):
         - reverses pru-gpio (preferred if possible)
     """
 
-    events: conlist(item_type=GpioEvent, min_items=1, max_items=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,8 +1,9 @@
+from typing import List
 from typing import Optional
 
-from pydantic import conint
-from pydantic import conlist
-from pydantic import root_validator
+from pydantic import Field
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ..base.content import IdInt
 from ..base.shepherd import ShpModel
@@ -19,33 +20,38 @@ from .observer_features import PowerTracing
 class TargetConfig(ShpModel, title="Target Config"):
     """Configuration for Target Nodes (DuT)"""
 
-    target_IDs: conlist(item_type=IdInt, min_items=1, max_items=64)
-    custom_IDs: Optional[conlist(item_type=IdInt16, min_items=1, max_items=64)]
+    target_IDs: Annotated[List[IdInt], Field(min_length=1, max_length=64)]
+    custom_IDs: Optional[
+        Annotated[List[IdInt16], Field(min_length=1, max_length=64)]
+    ] = 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[conlist(item_type=conint(ge=0), min_items=1, max_items=64)]
+    target_delays: Optional[
+        Annotated[List[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=64)]
+    ] = None
     # ⤷ individual starting times -> allows to use the same environment
+    # TODO: delays not used ATM
 
     firmware1: Firmware
     firmware2: Optional[Firmware] = None
 
-    power_tracing: Optional[PowerTracing]
-    gpio_tracing: Optional[GpioTracing]
-    gpio_actuation: Optional[GpioActuation]
+    power_tracing: Optional[PowerTracing] = None
+    gpio_tracing: Optional[GpioTracing] = None
+    gpio_actuation: Optional[GpioActuation] = None
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if not values.get("energy_env").valid:
+    @model_validator(mode="after")
+    def post_validation(self):
+        if not self.energy_env.valid:
             raise ValueError(
-                f"EnergyEnv '{values['energy_env'].name}' for target must be valid"
+                f"EnergyEnv '{self.energy_env.name}' for target must be valid"
             )
-        for _id in values.get("target_IDs"):
+        for _id in self.target_IDs:
             target = Target(id=_id)
             for mcu_num in [1, 2]:
-                val_fw = values.get(f"firmware{mcu_num}")
+                val_fw = getattr(self, f"firmware{mcu_num}")
                 has_fw = val_fw is not None
                 tgt_mcu = target[f"mcu{mcu_num}"]
                 has_mcu = tgt_mcu is not None
@@ -65,15 +71,15 @@ class TargetConfig(ShpModel, title="Target Config"):
                         f"is incompatible (={tgt_mcu.name})"
                     )
 
-        c_ids = values.get("custom_IDs")
-        t_ids = values.get("target_IDs")
+        c_ids = self.custom_IDs
+        t_ids = self.target_IDs
         if c_ids is not None and (len(set(c_ids)) < len(set(t_ids))):
             raise ValueError(
                 f"Provided custom IDs {c_ids} not enough "
                 f"to cover target range {t_ids}"
             )
         # TODO: if custom ids present, firmware must be ELF
-        return values
+        return self
 
     def get_custom_id(self, target_id: int) -> Optional[int]:
         if self.custom_IDs is not None and target_id in self.target_IDs:

shepherd_core/data_models/task/__init__.py

@@ -50,16 +50,18 @@ def prepare_task(
     elif isinstance(config, ShpModel):
         shp_wrap = Wrapper(
             datatype=type(config).__name__,
-            parameters=config.dict(),
+            parameters=config.model_dump(),
         )
     else:
         raise ValueError("had unknown input: %s", type(config))
 
     if shp_wrap.datatype == TestbedTasks:
         if observer is None:
-            raise ValueError(
-                "Task-Set contained TestbedTasks -> FN needs a observer-name"
+            logger.debug(
+                "Task-Set contained TestbedTasks & no observer was provided "
+                "-> will return TB-Tasks"
             )
+            return shp_wrap
         tbt = TestbedTasks(**shp_wrap.parameters)
         logger.debug("Loading Testbed-Tasks %s for %s", tbt.name, observer)
         obt = tbt.get_observer_tasks(observer)
@@ -67,12 +69,12 @@ def prepare_task(
             raise ValueError("Observer '%s' is not in TestbedTask-Set", observer)
         shp_wrap = Wrapper(
             datatype=type(obt).__name__,
-            parameters=obt.dict(),
+            parameters=obt.model_dump(),
         )
     return shp_wrap
 
 
-def extract_tasks(shp_wrap: Wrapper) -> List[ShpModel]:
+def extract_tasks(shp_wrap: Wrapper, no_task_sets: bool = True) -> List[ShpModel]:
     """ """
     if shp_wrap.datatype == ObserverTasks:
         obt = ObserverTasks(**shp_wrap.parameters)
@@ -85,6 +87,12 @@ def extract_tasks(shp_wrap: Wrapper) -> List[ShpModel]:
         content = [FirmwareModTask(**shp_wrap.parameters)]
     elif shp_wrap.datatype == ProgrammingTask.__name__:
         content = [ProgrammingTask(**shp_wrap.parameters)]
+    elif shp_wrap.datatype == TestbedTasks.__name__:
+        if no_task_sets:
+            raise ValueError(
+                "Model in Wrapper was TestbedTasks -> Task-Sets not allowed!"
+            )
+        content = [TestbedTasks(**shp_wrap.parameters)]
     else:
         raise ValueError("Extractor had unknown task: %s", shp_wrap.datatype)