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

shepherd_core/data_models/task/emulation.py

@@ -6,10 +6,10 @@ from pathlib import Path
 from typing import Optional
 from typing import Union
 
-from pydantic import confloat
-from pydantic import conint
-from pydantic import root_validator
-from pydantic import validate_arguments
+from pydantic import Field
+from pydantic import model_validator
+from pydantic import validate_call
+from typing_extensions import Annotated
 
 from ..base.content import IdInt
 from ..base.shepherd import ShpModel
@@ -41,12 +41,12 @@ class EmulationTask(ShpModel):
     # General config
     input_path: Path
     # ⤷ hdf5 file containing harvesting data
-    output_path: Optional[Path]
+    output_path: Optional[Path] = None
     # ⤷ dir- or file-path for storing the recorded data:
     #   - providing a directory -> file is named emu_timestamp.h5
     #   - for a complete path the filename is not changed except it exists and
     #     overwrite is disabled -> emu#num.h5
-    # TODO: should the path be mandatory?
+    # TODO: should the output-path be mandatory?
     force_overwrite: bool = False
     # ⤷ Overwrite existing file
     output_compression: Optional[Compression] = Compression.default
@@ -70,7 +70,7 @@ class EmulationTask(ShpModel):
     pwr_port: TargetPort = TargetPort.A
     # ⤷ chosen port will be current-monitored (main, connected to virtual Source),
     #   the other port is aux
-    voltage_aux: Union[confloat(ge=0, le=4.5), str] = 0
+    voltage_aux: Union[Annotated[float, Field(ge=0, le=4.5)], str] = 0
     # ⤷ aux_voltage options:
     #   - 0-4.5 for specific const Voltage (0 V = disabled),
     #   - "buffer" will output intermediate voltage (storage cap of vsource),
@@ -86,35 +86,47 @@ class EmulationTask(ShpModel):
     gpio_actuation: Optional[GpioActuation] = None
     sys_logging: Optional[SystemLogging] = SystemLogging()
 
-    verbose: conint(ge=0, le=4) = 2
+    verbose: Annotated[int, Field(ge=0, le=4)] = 2
     # ⤷ 0=Errors, 1=Warnings, 2=Info, 3=Debug
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        # TODO: limit paths
-        has_start = values.get("time_start") is not None
-        # add local timezone-data
-        if has_start and values["time_start"].tzinfo is None:
+    @model_validator(mode="before")
+    @classmethod
+    def pre_correction(cls, values: dict) -> dict:
+        # convert & add local timezone-data
+        has_time = values.get("time_start") is not None
+        if has_time and isinstance(values["time_start"], (int, float)):
+            values["time_start"] = datetime.fromtimestamp(values["time_start"])
+        if has_time and isinstance(values["time_start"], str):
+            values["time_start"] = datetime.fromisoformat(values["time_start"])
+        if has_time and values["time_start"].tzinfo is None:
             values["time_start"] = values["time_start"].astimezone()
-        if has_start and values.get("time_start") < datetime.now().astimezone():
-            raise ValueError("Start-Time for Emulation can't be in the past.")
-        if values.get("duration") and values["duration"].total_seconds() < 0:
+        return values
+
+    @model_validator(mode="after")
+    def post_validation(self):
+        # TODO: limit paths
+        has_time = self.time_start is not None
+        time_now = datetime.now().astimezone()
+        if has_time and self.time_start < time_now:
+            raise ValueError(
+                "Start-Time for Emulation can't be in the past "
+                f"('{self.time_start}' vs '{time_now}'."
+            )
+        if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Task-Duration can't be negative.")
-        if isinstance(values.get("voltage_aux"), str) and values.get(
-            "voltage_aux"
-        ) not in [
+        if isinstance(self.voltage_aux, str) and self.voltage_aux not in [
             "main",
             "buffer",
         ]:
             raise ValueError(
                 "Voltage Aux must be in float (0 - 4.5) or string 'main' / 'mid'."
             )
-        if values.get("gpio_actuation") is not None:
+        if self.gpio_actuation is not None:
             raise ValueError("GPIO Actuation not yet implemented!")
-        return values
+        return self
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_xp(cls, xp: Experiment, tb: Testbed, tgt_id: IdInt, root_path: Path):
         obs = tb.get_observer(tgt_id)
         tgt_cfg = xp.get_target_config(tgt_id)

shepherd_core/data_models/task/firmware_mod.py

@@ -3,16 +3,17 @@ from pathlib import Path
 from typing import Optional
 from typing import Union
 
-from pydantic import conint
-from pydantic import constr
-from pydantic import root_validator
-from pydantic import validate_arguments
+from pydantic import Field
+from pydantic import model_validator
+from pydantic import validate_call
+from typing_extensions import Annotated
 
 from ...logger import logger
 from ..base.content import IdInt
 from ..base.shepherd import ShpModel
 from ..content.firmware import Firmware
 from ..content.firmware import FirmwareDType
+from ..content.firmware import FirmwareStr
 from ..experiment.experiment import Experiment
 from ..testbed import Testbed
 from ..testbed.target import IdInt16
@@ -22,27 +23,27 @@ from ..testbed.target import MCUPort
 class FirmwareModTask(ShpModel):
     """Config for Task that adds the custom ID to the firmware & stores it into a file"""
 
-    data: Union[constr(min_length=3, max_length=8_000_000), Path]
+    data: Union[FirmwareStr, Path]
     data_type: FirmwareDType
-    custom_id: Optional[IdInt16]
+    custom_id: Optional[IdInt16] = None
     firmware_file: Path
 
-    verbose: conint(ge=0, le=4) = 2
+    verbose: Annotated[int, Field(ge=0, le=4)] = 2
     # ⤷ 0=Errors, 1=Warnings, 2=Info, 3=Debug
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if values.get("data_type") in [
+    @model_validator(mode="after")
+    def post_validation(self):
+        if self.data_type in [
             FirmwareDType.base64_hex,
             FirmwareDType.path_hex,
         ]:
             logger.warning(
                 "Firmware is scheduled to get custom-ID but is not in elf-format"
             )
-        return values
+        return self
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_xp(
         cls,
         xp: Experiment,
@@ -70,7 +71,7 @@ class FirmwareModTask(ShpModel):
         )
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_firmware(cls, fw: Firmware, **kwargs):
         kwargs["data"] = fw.data
         kwargs["data_type"] = fw.data_type

shepherd_core/data_models/task/harvest.py

@@ -3,8 +3,9 @@ from datetime import timedelta
 from pathlib import Path
 from typing import Optional
 
-from pydantic import conint
-from pydantic import root_validator
+from pydantic import Field
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ..base.shepherd import ShpModel
 from ..content.virtual_harvester import VirtualHarvesterConfig
@@ -46,20 +47,34 @@ class HarvestTask(ShpModel):
     power_tracing: PowerTracing = PowerTracing()
     sys_logging: Optional[SystemLogging] = SystemLogging()
 
-    verbose: conint(ge=0, le=4) = 2
+    verbose: Annotated[int, Field(ge=0, le=4)] = 2
     # ⤷ 0=Errors, 1=Warnings, 2=Info, 3=Debug
 
     # TODO: there is an unused DAC-Output patched to the harvesting-port
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        # TODO: limit paths
-        has_start = values.get("time_start") is not None
-        if has_start and values["time_start"].tzinfo is None:
-            # add local timezone-data
+    @model_validator(mode="before")
+    @classmethod
+    def pre_correction(cls, values: dict) -> dict:
+        # convert & add local timezone-data, TODO: used twice, refactor
+        has_time = values.get("time_start") is not None
+        if has_time and isinstance(values["time_start"], (int, float)):
+            values["time_start"] = datetime.fromtimestamp(values["time_start"])
+        if has_time and isinstance(values["time_start"], str):
+            values["time_start"] = datetime.fromisoformat(values["time_start"])
+        if has_time and values["time_start"].tzinfo is None:
             values["time_start"] = values["time_start"].astimezone()
-        if has_start and values["time_start"] < datetime.now().astimezone():
-            raise ValueError("Start-Time for Harvest can't be in the past.")
-        if values.get("duration") and values["duration"].total_seconds() < 0:
-            raise ValueError("Task-Duration can't be negative.")
         return values
+
+    @model_validator(mode="after")
+    def post_validation(self):
+        # TODO: limit paths
+        has_time = self.time_start is not None
+        time_now = datetime.now().astimezone()
+        if has_time and self.time_start < time_now:
+            raise ValueError(
+                "Start-Time for Emulation can't be in the past "
+                f"('{self.time_start}' vs '{time_now}'."
+            )
+        if self.duration and self.duration.total_seconds() < 0:
+            raise ValueError("Task-Duration can't be negative.")
+        return self

shepherd_core/data_models/task/observer_tasks.py

@@ -3,7 +3,8 @@ from pathlib import Path
 from typing import List
 from typing import Optional
 
-from pydantic import validate_arguments
+from pydantic import computed_field
+from pydantic import validate_call
 
 from ..base.content import IdInt
 from ..base.content import NameStr
@@ -27,13 +28,13 @@ class ObserverTasks(ShpModel):
     abort_on_error: bool
 
     # fw mod, store as hex-file and program
-    fw1_mod: Optional[FirmwareModTask]
-    fw2_mod: Optional[FirmwareModTask]
-    fw1_prog: Optional[ProgrammingTask]
-    fw2_prog: Optional[ProgrammingTask]
+    fw1_mod: Optional[FirmwareModTask] = None
+    fw2_mod: Optional[FirmwareModTask] = None
+    fw1_prog: Optional[ProgrammingTask] = None
+    fw2_prog: Optional[ProgrammingTask] = None
 
     # MAIN PROCESS
-    emulation: Optional[EmulationTask]
+    emulation: Optional[EmulationTask] = None
 
     # post_copy / cleanup, Todo: could also just intake emuTask
     #  - delete firmwares
@@ -42,7 +43,7 @@ class ObserverTasks(ShpModel):
     #  - zip it
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_xp(cls, xp: Experiment, tb: Testbed, tgt_id: IdInt):
         if not tb.shared_storage:
             raise ValueError("Implementation currently relies on shared storage!")
@@ -78,3 +79,12 @@ class ObserverTasks(ShpModel):
                 continue
             tasks.append(task)
         return tasks
+
+    @computed_field
+    def output_paths(self) -> dict:
+        values = {}
+        if isinstance(self.emulation, EmulationTask):
+            if self.emulation.output_path is None:
+                raise ValueError("Emu-Task should have a valid output-path")
+            values[self.observer] = self.emulation.output_path
+        return values

shepherd_core/data_models/task/programming.py

@@ -1,10 +1,10 @@
 import copy
 from pathlib import Path
 
-from pydantic import confloat
-from pydantic import conint
-from pydantic import root_validator
-from pydantic import validate_arguments
+from pydantic import Field
+from pydantic import model_validator
+from pydantic import validate_call
+from typing_extensions import Annotated
 
 from ..base.content import IdInt
 from ..base.content import SafeStr
@@ -24,23 +24,23 @@ class ProgrammingTask(ShpModel):
     mcu_port: MCUPort = 1
     mcu_type: SafeStr
     # ⤷ for later
-    voltage: confloat(ge=1, lt=5) = 3
-    datarate: conint(gt=0, le=1_000_000) = 500_000
+    voltage: Annotated[float, Field(ge=1, lt=5)] = 3
+    datarate: Annotated[int, Field(gt=0, le=1_000_000)] = 500_000
     protocol: ProgrammerProtocol
 
     simulate: bool = False
 
-    verbose: conint(ge=0, le=4) = 2
+    verbose: Annotated[int, Field(ge=0, le=4)] = 2
     # ⤷ 0=Errors, 1=Warnings, 2=Info, 3=Debug
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if values.get("firmware_file").suffix.lower() != ".hex":
-            ValueError(f"Firmware is not intel-.hex ('{values['firmware_file']}')")
-        return values
+    @model_validator(mode="after")
+    def post_validation(self):
+        if self.firmware_file.suffix.lower() != ".hex":
+            ValueError(f"Firmware is not intel-.hex ('{self.firmware_file}')")
+        return self
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_xp(
         cls,
         xp: Experiment,

shepherd_core/data_models/task/testbed_tasks.py

@@ -1,8 +1,11 @@
+from typing import List
 from typing import Optional
 
 from pydantic import EmailStr
-from pydantic import conlist
-from pydantic import validate_arguments
+from pydantic import Field
+from pydantic import computed_field
+from pydantic import validate_call
+from typing_extensions import Annotated
 
 from ..base.content import NameStr
 from ..base.shepherd import ShpModel
@@ -15,13 +18,13 @@ class TestbedTasks(ShpModel):
     """Collection of tasks for all observers included in experiment"""
 
     name: NameStr
-    observer_tasks: conlist(item_type=ObserverTasks, min_items=1, max_items=64)
+    observer_tasks: Annotated[List[ObserverTasks], Field(min_length=1, max_length=64)]
 
     # POST PROCESS
-    email: Optional[EmailStr]
+    email: Optional[EmailStr] = None
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_xp(cls, xp: Experiment, tb: Optional[Testbed] = None):
         if tb is None:
             # TODO: just for testing OK
@@ -32,6 +35,13 @@ class TestbedTasks(ShpModel):
 
     def get_observer_tasks(self, observer) -> Optional[ObserverTasks]:
         for tasks in self.observer_tasks:
-            if observer in tasks.observer:
+            if observer == tasks.observer:
                 return tasks
         return None
+
+    @computed_field
+    def output_paths(self) -> dict:
+        values = {}
+        for obt in self.observer_tasks:
+            values = {**values, **obt.output_paths}
+        return values

shepherd_core/data_models/testbed/cape.py

@@ -5,7 +5,7 @@ from typing import Optional
 from typing import Union
 
 from pydantic import Field
-from pydantic import root_validator
+from pydantic import model_validator
 
 from ...testbed_client import tb_client
 from ..base.content import IdInt
@@ -37,7 +37,8 @@ class Cape(ShpModel, title="Shepherd-Cape"):
     def __str__(self):
         return self.name
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         return values

shepherd_core/data_models/testbed/gpio.py

@@ -1,9 +1,10 @@
 from enum import Enum
 from typing import Optional
 
-from pydantic import conint
-from pydantic import constr
-from pydantic import root_validator
+from pydantic import Field
+from pydantic import StringConstraints
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ...testbed_client import tb_client
 from ..base.content import IdInt
@@ -30,31 +31,33 @@ class GPIO(ShpModel, title="GPIO of Observer Node"):
     comment: Optional[SafeStr] = None
 
     direction: Direction = Direction.Input
-    dir_switch: Optional[constr(max_length=32)]
+    dir_switch: Optional[Annotated[str, StringConstraints(max_length=32)]] = None
 
-    reg_pru: Optional[constr(max_length=10)] = None
-    pin_pru: Optional[constr(max_length=10)] = None
-    reg_sys: Optional[conint(ge=0)] = None
-    pin_sys: Optional[constr(max_length=10)] = None
+    reg_pru: Optional[Annotated[str, StringConstraints(max_length=10)]] = None
+    pin_pru: Optional[Annotated[str, StringConstraints(max_length=10)]] = None
+    reg_sys: Optional[Annotated[int, Field(ge=0)]] = None
+    pin_sys: Optional[Annotated[str, StringConstraints(max_length=10)]] = None
 
     def __str__(self):
         return self.name
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         return values
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
+    @model_validator(mode="after")
+    def post_validation(self):
         # ensure that either pru or sys is used, otherwise instance is considered faulty
-        no_pru = (values.get("reg_pru") is None) or (values.get("pin_pru") is None)
-        no_sys = (values.get("reg_sys") is None) or (values.get("pin_sys") is None)
+        no_pru = (self.reg_pru is None) or (self.pin_pru is None)
+        no_sys = (self.reg_sys is None) or (self.pin_sys is None)
         if no_pru and no_sys:
             raise ValueError(
-                f"GPIO-Instance is faulty -> it needs to use pru or sys, content: {values}"
+                "GPIO-Instance is faulty -> "
+                f"it needs to use pru or sys, content: {self.model_dump()}"
             )
-        return values
+        return self
 
     def user_controllable(self) -> bool:
         return ("gpio" in self.name.lower()) and (self.direction in ["IO", "OUT"])

shepherd_core/data_models/testbed/mcu.py

@@ -1,9 +1,9 @@
 from enum import Enum
 from typing import Optional
 
-from pydantic import confloat
-from pydantic import conint
-from pydantic import root_validator
+from pydantic import Field
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ...testbed_client import tb_client
 from ..base.content import IdInt
@@ -34,8 +34,8 @@ class MCU(ShpModel, title="Microcontroller of the Target Node"):
     platform: NameStr
     core: NameStr
     prog_protocol: ProgrammerProtocol
-    prog_voltage: confloat(ge=1, le=5) = 3
-    prog_datarate: conint(gt=0, le=1_000_000) = 500_000
+    prog_voltage: Annotated[float, Field(ge=1, le=5)] = 3
+    prog_datarate: Annotated[int, Field(gt=0, le=1_000_000)] = 500_000
 
     fw_name_default: str
     # ⤷ can't be FW-Object (circular import)
@@ -43,7 +43,8 @@ class MCU(ShpModel, title="Microcontroller of the Target Node"):
     def __str__(self):
         return self.name
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         return values

shepherd_core/data_models/testbed/observer.py

@@ -3,9 +3,9 @@ from typing import Optional
 
 from pydantic import Field
 from pydantic import IPvAnyAddress
-from pydantic import confloat
-from pydantic import constr
-from pydantic import root_validator
+from pydantic import StringConstraints
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ...testbed_client import tb_client
 from ..base.content import IdInt
@@ -16,7 +16,12 @@ from .cape import Cape
 from .cape import TargetPort
 from .target import Target
 
-MACStr = constr(max_length=17, regex=r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$")
+MACStr = Annotated[
+    str,
+    StringConstraints(
+        max_length=17, pattern=r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
+    ),
+]
 
 
 class Observer(ShpModel, title="Shepherd-Sheep"):
@@ -33,36 +38,35 @@ class Observer(ShpModel, title="Shepherd-Sheep"):
     room: NameStr
     eth_port: NameStr
 
-    latitude: confloat(ge=-90, le=90) = 51.026573  # cfaed
-    longitude: confloat(ge=-180, le=180) = 13.723291
+    latitude: Annotated[float, Field(ge=-90, le=90)] = 51.026573
+    longitude: Annotated[float, Field(ge=-180, le=180)] = 13.723291
+    # ⤷ cfaed-floor
 
-    cape: Optional[Cape]
-    target_a: Optional[Target]
+    cape: Optional[Cape] = None
+    target_a: Optional[Target] = None
     target_b: Optional[Target] = None
 
     created: datetime = Field(default_factory=datetime.now)
-    alive_last: Optional[datetime]
+    alive_last: Optional[datetime] = None
 
     def __str__(self):
         return self.name
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         return values
 
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        has_cape = values.get("cape") is not None
-        has_target = (values.get("target_a") is not None) or (
-            values.get("target_b") is not None
-        )
+    @model_validator(mode="after")
+    def post_validation(self):
+        has_cape = self.cape is not None
+        has_target = (self.target_a is not None) or (self.target_b is not None)
         if not has_cape and has_target:
             raise ValueError(
-                f"Observer '{values.get('name')}' is faulty "
-                f"-> has targets but no cape"
+                f"Observer '{self.name}' is faulty " f"-> has targets but no cape"
             )
-        return values
+        return self
 
     def get_target_port(self, target_id: int) -> TargetPort:
         if self.target_a is not None and target_id == self.target_a.id:

shepherd_core/data_models/testbed/target.py

@@ -3,8 +3,8 @@ from typing import Optional
 from typing import Union
 
 from pydantic import Field
-from pydantic import conint
-from pydantic import root_validator
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from ...testbed_client import tb_client
 from ..base.content import IdInt
@@ -13,9 +13,9 @@ from ..base.content import SafeStr
 from ..base.shepherd import ShpModel
 from .mcu import MCU
 
-IdInt16 = conint(ge=0, lt=2**16)
+IdInt16 = Annotated[int, Field(ge=0, lt=2**16)]
 
-MCUPort = conint(ge=1, le=2)
+MCUPort = Annotated[int, Field(ge=1, le=2)]
 
 
 class Target(ShpModel, title="Target Node (DuT)"):
@@ -30,7 +30,7 @@ class Target(ShpModel, title="Target Node (DuT)"):
 
     created: datetime = Field(default_factory=datetime.now)
 
-    fw_id: Optional[IdInt16]
+    fw_id: Optional[IdInt16] = None
     mcu1: Union[MCU, NameStr]
     mcu2: Union[MCU, NameStr, None] = None
     #
@@ -40,18 +40,19 @@ class Target(ShpModel, title="Target Node (DuT)"):
     def __str__(self):
         return self.name
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def query_database(cls, values: dict) -> dict:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
-        return values
 
-    @root_validator(pre=False)
-    def post_correction(cls, values: dict) -> dict:
-        if isinstance(values.get("mcu1"), str):
-            values["mcu1"] = MCU(name=values["mcu1"])
-            # ⤷ this will raise if default is faulty
-        if isinstance(values.get("mcu2"), str):
-            values["mcu2"] = MCU(name=values["mcu2"])
+        # post correction
+        for _mcu in ["mcu1", "mcu2"]:
+            if isinstance(values.get(_mcu), str):
+                values[_mcu] = MCU(name=values[_mcu])
+                # ⤷ this will raise if default is faulty
+            elif isinstance(values.get(_mcu), dict):
+                values[_mcu] = MCU(**values[_mcu])
         if values.get("fw_id") is None:
             values["fw_id"] = values.get("id") % 2**16
+
         return values