shepherd-core 2025.6.2__py3-none-any.whl → 2025.6.4__py3-none-any.whl

shepherd_core/data_models/base/cal_measurement.py

@@ -1,7 +1,6 @@
 """Models for the process of calibration a device by measurements."""
 
 from typing import Annotated
-from typing import Optional
 
 import numpy as np
 from pydantic import Field
@@ -91,11 +90,11 @@ class CalMeasurementEmulator(ShpModel):
 class CalMeasurementCape(ShpModel):
     """Container for the values of the calibration-measurement."""
 
-    cape: Optional[CapeData] = None
-    host: Optional[str] = None
+    cape: CapeData | None = None
+    host: str | None = None
 
-    harvester: Optional[CalMeasurementHarvester] = None
-    emulator: Optional[CalMeasurementEmulator] = None
+    harvester: CalMeasurementHarvester | None = None
+    emulator: CalMeasurementEmulator | None = None
 
     def to_cal(self) -> CalibrationCape:
         dv = self.model_dump()

shepherd_core/data_models/base/calibration.py

@@ -1,13 +1,11 @@
 """Models for the calibration-data to convert between raw & SI-Values."""
 
 import struct
+from collections.abc import Callable
 from collections.abc import Generator
 from collections.abc import Mapping
 from collections.abc import Sequence
-from typing import Callable
-from typing import Optional
 from typing import TypeVar
-from typing import Union
 
 import numpy as np
 from numpy.typing import NDArray
@@ -29,7 +27,7 @@ Calc_t = TypeVar("Calc_t", NDArray[np.float64], float)
 
 
 def dict_generator(
-    in_dict: Union[Mapping, Sequence], pre: Optional[list] = None
+    in_dict: Mapping | Sequence, pre: list | None = None
 ) -> Generator[list, None, None]:
     """Recursive helper-function to generate a 1D-List(or not?).
 
@@ -54,7 +52,7 @@ class CalibrationPair(ShpModel):
 
     gain: PositiveFloat
     offset: float = 0
-    unit: Optional[str] = None  # TODO: add units when used
+    unit: str | None = None  # TODO: add units when used
 
     def raw_to_si(self, values_raw: Calc_t, *, allow_negative: bool = True) -> Calc_t:
         """Convert between physical units and raw unsigned integers."""
@@ -81,7 +79,7 @@ class CalibrationPair(ShpModel):
         return values_raw
 
     @classmethod
-    def from_fn(cls, fn: Callable, unit: Optional[str] = None) -> Self:
+    def from_fn(cls, fn: Callable, unit: str | None = None) -> Self:
         """Probe linear function to determine scaling values."""
         offset = fn(0, limited=False)
         gain_inv = fn(1.0, limited=False) - offset
@@ -217,14 +215,14 @@ class CalibrationCape(ShpModel):
     YAML: .to_file() and .from_file() already in ShpModel
     """
 
-    cape: Optional[CapeData] = None
-    host: Optional[str] = None
+    cape: CapeData | None = None
+    host: str | None = None
 
     harvester: CalibrationHarvester = CalibrationHarvester()
     emulator: CalibrationEmulator = CalibrationEmulator()
 
     @classmethod
-    def from_bytestr(cls, data: bytes, cape: Optional[CapeData] = None) -> Self:
+    def from_bytestr(cls, data: bytes, cape: CapeData | None = None) -> Self:
         """Instantiate calibration data based on byte string.
 
         This is mainly used to deserialize data read from an EEPROM memory.
@@ -276,7 +274,7 @@ class CalibrationSeries(ShpModel):
     @validate_call(validate_return=False)
     def from_cal(
         cls,
-        cal: Union[CalibrationHarvester, CalibrationEmulator],
+        cal: CalibrationHarvester | CalibrationEmulator,
         *,
         emu_port_a: bool = True,
     ) -> Self:

shepherd_core/data_models/base/content.py

@@ -2,7 +2,6 @@
 
 from datetime import datetime
 from typing import Annotated
-from typing import Optional
 from uuid import uuid4
 
 from pydantic import Field
@@ -37,8 +36,8 @@ class ContentModel(ShpModel):
         default_factory=id_default,
     )
     name: NameStr
-    description: Annotated[Optional[SafeStr], Field(description="Required when public")] = None
-    comment: Optional[SafeStr] = None
+    description: Annotated[SafeStr | None, Field(description="Required when public")] = None
+    comment: SafeStr | None = None
     created: datetime = Field(default_factory=datetime.now)
     updated_last: datetime = Field(default_factory=datetime.now)
 

shepherd_core/data_models/base/shepherd.py

@@ -8,8 +8,6 @@ from datetime import timedelta
 from ipaddress import IPv4Address
 from pathlib import Path
 from typing import Any
-from typing import Optional
-from typing import Union
 from uuid import UUID
 
 import yaml
@@ -24,7 +22,7 @@ from .wrapper import Wrapper
 
 
 def path2str(
-    dumper: SafeDumper, data: Union[pathlib.Path, pathlib.WindowsPath, pathlib.PosixPath]
+    dumper: SafeDumper, data: 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()))
@@ -48,6 +46,24 @@ yaml.add_representer(IPv4Address, generic2str, SafeDumper)
 yaml.add_representer(UUID, generic2str, SafeDumper)
 
 
+def path_to_str(old: dict) -> dict:
+    r"""Allow platform-independent pickling of ShpModel.
+
+    Helper Fn
+    Posix-Paths (/xyz/abc) in WindowsPath gets converted to \\xyz\\abc when exported
+    intended usage: pickle.dump(path_to_str(model.model_dump()))
+    """
+    new: dict = {}
+    for key, value in old.items():
+        if isinstance(value, Path):
+            new[key] = value.as_posix().replace("\\", "/")
+        elif isinstance(value, dict):
+            new[key] = path_to_str(value)
+        else:
+            new[key] = value
+    return new
+
+
 class ShpModel(BaseModel):
     """Pre-configured Pydantic Base-Model (specifically for shepherd).
 
@@ -114,7 +130,7 @@ class ShpModel(BaseModel):
             yield key, self[key]
 
     @classmethod
-    def schema_to_file(cls, path: Union[str, Path]) -> None:
+    def schema_to_file(cls, path: str | Path) -> None:
         """Store schema to yaml (for frontend-generators)."""
         model_dict = cls.model_json_schema()
         model_yaml = yaml.safe_dump(model_dict, default_flow_style=False, sort_keys=False)
@@ -123,8 +139,8 @@ class ShpModel(BaseModel):
 
     def to_file(
         self,
-        path: Union[str, Path],
-        comment: Optional[str] = None,
+        path: str | Path,
+        comment: str | None = None,
         *,
         minimal: bool = True,
         use_pickle: bool = False,
@@ -135,21 +151,21 @@ class ShpModel(BaseModel):
         pickle: uses pickle to serialize data, on BBB >100x faster for large files
         comment: documentation.
         """
-        model_dict = self.model_dump(exclude_unset=minimal)
         model_wrap = Wrapper(
             datatype=type(self).__name__,
             comment=comment,
             created=local_now(),
-            parameters=model_dict,
+            parameters=self.model_dump(exclude_unset=minimal),
         )
+        model_dict = model_wrap.model_dump(exclude_unset=minimal, exclude_defaults=minimal)
         if use_pickle:
-            model_serial = pickle.dumps(model_dict, fix_imports=True)
+            model_serial = pickle.dumps(path_to_str(model_dict))
             model_path = Path(path).resolve().with_suffix(".pickle")
         else:
             # TODO: x64 windows supports CSafeLoader/dumper,
             #       there are examples that replace load if avail
             model_serial = yaml.safe_dump(
-                model_wrap.model_dump(exclude_unset=minimal, exclude_defaults=minimal),
+                model_dict,
                 default_flow_style=False,
                 sort_keys=False,
             )
@@ -158,25 +174,25 @@ class ShpModel(BaseModel):
 
         if not model_path.parent.exists():
             model_path.parent.mkdir(parents=True)
-        with model_path.open("w") as f:
+        with model_path.open("wb" if use_pickle else "w") as f:
             f.write(model_serial)
         return model_path
 
     @classmethod
-    def from_file(cls, path: Union[str, Path]) -> Self:
+    def from_file(cls, path: str | Path) -> Self:
         """Load from YAML or pickle file."""
         path: Path = Path(path)
         if not Path(path).exists():
             raise FileNotFoundError
         if path.suffix.lower() == ".pickle":
             with Path(path).open("rb") as shp_file:
-                shp_wrap = pickle.load(shp_file, fix_imports=True)  # noqa: S301
+                shp_dict = pickle.load(shp_file)  # noqa: S301
         else:
             with Path(path).open() as shp_file:
                 shp_dict = yaml.safe_load(shp_file)
-            shp_wrap = Wrapper(**shp_dict)
+        shp_wrap = Wrapper(**shp_dict)
         if shp_wrap.datatype != cls.__name__:
-            raise ValueError("Model in file does not match the requirement")
+            raise ValueError("Model in file does not match the actual Class")
         return cls(**shp_wrap.parameters)
 
     def get_hash(self) -> str:

shepherd_core/data_models/base/wrapper.py

@@ -2,7 +2,6 @@
 
 from datetime import datetime
 from typing import Annotated
-from typing import Optional
 
 from pydantic import BaseModel
 from pydantic import StringConstraints
@@ -18,10 +17,10 @@ class Wrapper(BaseModel):
 
     datatype: str
     """ ⤷ model-name"""
-    comment: Optional[SafeStrClone] = None
-    created: Optional[datetime] = None
+    comment: SafeStrClone | None = None
+    created: datetime | None = None
     """ ⤷ Optional metadata"""
-    lib_ver: Optional[str] = version
+    lib_ver: str | None = version
     """ ⤷ for debug-purposes and later compatibility-checks"""
     parameters: dict
     """ ⤷ ShpModel"""

shepherd_core/data_models/content/energy_environment.py

@@ -3,7 +3,6 @@
 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
@@ -40,10 +39,10 @@ class EnergyEnvironment(ContentModel):
     # TODO: harvester, transducer
 
     # additional descriptive metadata, TODO: these are very solar-centered -> generalize
-    light_source: Optional[str] = None
-    weather_conditions: Optional[str] = None
-    indoor: Optional[bool] = None
-    location: Optional[str] = None
+    light_source: str | None = None
+    weather_conditions: str | None = None
+    indoor: bool | None = None
+    location: str | None = None
 
     @model_validator(mode="before")
     @classmethod

shepherd_core/data_models/content/firmware.py

@@ -6,9 +6,7 @@ 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
 
 from pydantic import StringConstraints
 from pydantic import model_validator
@@ -58,9 +56,9 @@ class Firmware(ContentModel, title="Firmware of Target"):
 
     mcu: MCU
 
-    data: Union[FirmwareStr, Path]
+    data: FirmwareStr | Path
     data_type: FirmwareDType
-    data_hash: Optional[str] = None
+    data_hash: str | None = None
     data_local: bool = True
     """ ⤷ signals that file has to be copied to testbed"""
 
@@ -147,7 +145,7 @@ class Firmware(ContentModel, title="Firmware of Target"):
             kwargs["name"] = file.name
         return cls(**kwargs)
 
-    def compare_hash(self, path: Optional[Path] = None) -> bool:
+    def compare_hash(self, path: Path | None = None) -> bool:
         if self.data_hash is None:
             return True
 

shepherd_core/data_models/content/virtual_harvester.py

@@ -4,7 +4,6 @@ from collections.abc import Mapping
 from enum import Enum
 from typing import Annotated
 from typing import Any
-from typing import Optional
 
 from pydantic import Field
 from pydantic import model_validator
@@ -214,7 +213,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     (constant current tracking).
     """
 
-    voltage_step_mV: Optional[Annotated[float, Field(ge=1, le=1_000_000)]] = None
+    voltage_step_mV: Annotated[float, Field(ge=1, le=1000000)] | None = None
     """The difference between two adjacent voltage samples.
 
     This value is implicitly derived from the other ramp parameters:
@@ -384,7 +383,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
 
     def calc_window_size(
         self,
-        dtype_in: Optional[EnergyDType] = None,
+        dtype_in: EnergyDType | None = None,
         *,
         for_emu: bool,
     ) -> int:
@@ -468,9 +467,9 @@ class HarvesterPRUConfig(ShpModel):
     def from_vhrv(
         cls,
         data: VirtualHarvesterConfig,
-        dtype_in: Optional[EnergyDType] = EnergyDType.ivsample,
-        window_size: Optional[u32] = None,
-        voltage_step_V: Optional[float] = None,
+        dtype_in: EnergyDType | None = EnergyDType.ivsample,
+        window_size: u32 | None = None,
+        voltage_step_V: float | None = None,
         *,
         for_emu: bool = False,
     ) -> Self:

shepherd_core/data_models/experiment/experiment.py

@@ -4,15 +4,12 @@ from collections.abc import Iterable
 from datetime import datetime
 from datetime import timedelta
 from typing import Annotated
-from typing import Optional
 
 from pydantic import Field
 from pydantic import model_validator
 from typing_extensions import Self
-from typing_extensions import deprecated
 
 from shepherd_core.config import config
-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
@@ -33,10 +30,10 @@ class Experiment(ShpModel, title="Config of an Experiment"):
 
     # General Properties
     name: NameStr
-    description: Annotated[
-        Optional[SafeStr], Field(description="Required for public instances")
-    ] = None
-    comment: Optional[SafeStr] = None
+    description: Annotated[SafeStr | None, Field(description="Required for public instances")] = (
+        None
+    )
+    comment: SafeStr | None = None
 
     # feedback
     email_results: bool = True
@@ -44,20 +41,14 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     sys_logging: SystemLogging = sys_log_all
 
     # schedule
-    time_start: Optional[datetime] = None  # = ASAP
-    duration: Optional[timedelta] = None  # = till EOF
+    time_start: datetime | None = None  # = ASAP
+    duration: timedelta | None = None  # = till EOF
 
     # targets
     target_configs: Annotated[list[TargetConfig], Field(min_length=1, max_length=128)]
 
     # debug
-    lib_ver: Optional[str] = version
-
-    # deprecated fields, TODO: remove before public release
-    id: Annotated[Optional[int], deprecated("not needed")] = None
-    created: Annotated[Optional[datetime], deprecated("not needed")] = None
-    abort_on_error: Annotated[bool, deprecated("has no effect")] = False
-    owner_id: Annotated[Optional[IdInt], deprecated("not needed")] = None
+    lib_ver: str | None = version
 
     @model_validator(mode="after")
     def post_validation(self) -> Self:
@@ -109,7 +100,8 @@ class Experiment(ShpModel, title="Config of an Experiment"):
         msg = f"Target-ID {target_id} was not found in Experiment '{self.name}'"
         raise ValueError(msg)
 
-    def folder_name(self, custom_date: Optional[datetime] = None) -> str:
+    def folder_name(self, custom_date: datetime | None = None) -> str:
+        # TODO: custom date should not overrule time_start
         date = custom_date if custom_date is not None else self.time_start
         timestamp = local_now() if date is None else date
         timestrng = timestamp.strftime("%Y-%m-%d_%H-%M-%S")

shepherd_core/data_models/experiment/observer_features.py

@@ -3,7 +3,6 @@
 from datetime import timedelta
 from enum import Enum
 from typing import Annotated
-from typing import Optional
 
 import numpy as np
 from annotated_types import Interval
@@ -11,7 +10,6 @@ from pydantic import Field
 from pydantic import PositiveFloat
 from pydantic import model_validator
 from typing_extensions import Self
-from typing_extensions import deprecated
 
 from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.data_models.testbed.gpio import GPIO
@@ -22,10 +20,7 @@ zero_duration = timedelta(seconds=0)
 
 
 class PowerTracing(ShpModel, title="Config for Power-Tracing"):
-    """Configuration for recording the Power-Consumption of the Target Nodes.
-
-    TODO: postprocessing not implemented ATM
-    """
+    """Configuration for recording the Power-Consumption of the Target Nodes."""
 
     intermediate_voltage: bool = False
     """
@@ -35,20 +30,20 @@ class PowerTracing(ShpModel, title="Config for Power-Tracing"):
     # time
     delay: timedelta = zero_duration
     """start recording after experiment started"""
-    duration: Optional[timedelta] = None  # till EOF
+    duration: timedelta | None = None  # till EOF
     """duration of recording after delay starts the process.
 
     default is None, recording till EOF"""
 
-    # post-processing
-    calculate_power: bool = False
-    """ ⤷ reduce file-size by calculating power -> not implemented ATM"""
+    # further processing of IV-Samples
+    only_power: bool = False
+    """ ⤷ reduce file-size by calculating power and automatically discard I&V"""
     samplerate: Annotated[int, Field(ge=10, le=100_000)] = 100_000
-    """ ⤷ reduce file-size by down-sampling -> not implemented ATM"""
-    discard_current: bool = False
-    """ ⤷ reduce file-size by omitting current -> not implemented ATM"""
-    discard_voltage: bool = False
-    """ ⤷ reduce file-size by omitting voltage -> not implemented ATM"""
+    """ ⤷ reduce file-size by re-sampling (mean over x samples)
+        Timestamps will be taken from the start of that sample-window.
+        example: 10 Hz samplerate will be binning 10k samples via mean() and
+                 the timestamp for that new sample will be value[0] of the 10k long vector
+    """
 
     @model_validator(mode="after")
     def post_validation(self) -> Self:
@@ -57,22 +52,10 @@ class PowerTracing(ShpModel, title="Config for Power-Tracing"):
         if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Duration can't be negative.")
 
-        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 self.calculate_power:
-            raise NotImplementedError(
-                "Feature PowerTracing.calculate_power reserved for future use."
-            )
-        if self.samplerate != 100_000:
-            raise NotImplementedError("Feature PowerTracing.samplerate reserved for future use.")
-        if self.discard_current:
-            raise NotImplementedError(
-                "Feature PowerTracing.discard_current reserved for future use."
-            )
-        if self.discard_voltage:
-            raise NotImplementedError(
-                "Feature PowerTracing.discard_voltage reserved for future use."
+        rates_allowed = (10, 100, 1_000, 100_000)
+        if self.samplerate not in rates_allowed:
+            raise ValueError(
+                "Feature PowerTracing.samplerate only supports specific rates: %s", rates_allowed
             )
         return self
 
@@ -175,7 +158,7 @@ class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
 
     # time
     delay: timedelta = zero_duration
-    duration: Optional[timedelta] = None  # till EOF
+    duration: timedelta | None = None  # till EOF
 
     # post-processing,
     uart_decode: bool = False
@@ -264,11 +247,6 @@ class SystemLogging(ShpModel, title="Config for System-Logging"):
     sheep: bool = True
     sys_util: bool = True
 
-    # deprecated, TODO: remove lines below before public release
-    dmesg: Annotated[bool, deprecated("for sheep v0.9.0+, use 'kernel' instead")] = True
-    ptp: Annotated[bool, deprecated("for sheep v0.9.0+, use 'time_sync' instead")] = True
-    shepherd: Annotated[bool, deprecated("for sheep v0.9.0+, use 'sheep' instead")] = True
-
 
 # TODO: some more interaction would be good
 #     - execute limited python-scripts

shepherd_core/data_models/experiment/target_config.py

@@ -1,7 +1,6 @@
 """Configuration related to Target Nodes (DuT)."""
 
 from typing import Annotated
-from typing import Optional
 
 from pydantic import Field
 from pydantic import model_validator
@@ -28,7 +27,7 @@ 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
+    custom_IDs: Annotated[list[IdInt16], Field(min_length=1, max_length=128)] | None = None
     """ ⤷ custom ID will replace 'const uint16_t SHEPHERD_NODE_ID' in firmware.
 
     if no custom ID is provided, the original ID of target is used
@@ -37,9 +36,9 @@ class TargetConfig(ShpModel, title="Target Config"):
     energy_env: EnergyEnvironment
     """ input for the virtual source """
     virtual_source: VirtualSourceConfig = vsrc_neutral
-    target_delays: Optional[
-        Annotated[list[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=128)]
-    ] = None
+    target_delays: (
+        Annotated[list[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=128)] | None
+    ) = None
     """ ⤷ individual starting times
 
     - allows to use the same environment
@@ -48,13 +47,13 @@ class TargetConfig(ShpModel, title="Target Config"):
 
     firmware1: Firmware
     """ ⤷ omitted FW gets set to neutral deep-sleep"""
-    firmware2: Optional[Firmware] = None
+    firmware2: Firmware | None = None
     """ ⤷ omitted FW gets set to neutral deep-sleep"""
 
-    power_tracing: Optional[PowerTracing] = None
-    gpio_tracing: Optional[GpioTracing] = None
-    gpio_actuation: Optional[GpioActuation] = None
-    uart_logging: Optional[UartLogging] = None
+    power_tracing: PowerTracing | None = None
+    gpio_tracing: GpioTracing | None = None
+    gpio_actuation: GpioActuation | None = None
+    uart_logging: UartLogging | None = None
 
     @model_validator(mode="after")
     def post_validation(self) -> Self:
@@ -96,7 +95,7 @@ class TargetConfig(ShpModel, title="Target Config"):
             raise NotImplementedError("Feature GpioActuation reserved for future use.")
         return self
 
-    def get_custom_id(self, target_id: int) -> Optional[int]:
+    def get_custom_id(self, target_id: int) -> int | None:
         if self.custom_IDs is not None and target_id in self.target_IDs:
             return self.custom_IDs[self.target_IDs.index(target_id)]
         return None

shepherd_core/data_models/task/__init__.py

@@ -5,8 +5,6 @@ These models import externally from all other model-modules!
 
 import pickle
 from pathlib import Path
-from typing import Optional
-from typing import Union
 
 import yaml
 
@@ -35,7 +33,7 @@ __all__ = [
 ]
 
 
-def prepare_task(config: Union[ShpModel, Path, str], observer: Optional[str] = None) -> Wrapper:
+def prepare_task(config: ShpModel | Path | str, observer: str | None = None) -> Wrapper:
     """Open file and extract tasks.
 
     - Open file (from Path or str of Path)
@@ -47,7 +45,8 @@ def prepare_task(config: Union[ShpModel, Path, str], observer: Optional[str] = N
 
     if isinstance(config, Path) and config.exists() and config.suffix.lower() == ".pickle":
         with config.resolve().open("rb") as shp_file:
-            shp_wrap = pickle.load(shp_file, fix_imports=True)  # noqa: S301
+            shp_dict = pickle.load(shp_file)  # noqa: S301
+        shp_wrap = Wrapper(**shp_dict)
     elif isinstance(config, Path) and config.exists() and config.suffix.lower() == ".yaml":
         with config.resolve().open() as shp_file:
             shp_dict = yaml.safe_load(shp_file)

shepherd_core/data_models/task/emulation.py

@@ -8,14 +8,11 @@ from enum import Enum
 from pathlib import Path
 from pathlib import PurePosixPath
 from typing import Annotated
-from typing import Optional
-from typing import Union
 
 from pydantic import Field
 from pydantic import model_validator
 from pydantic import validate_call
 from typing_extensions import Self
-from typing_extensions import deprecated
 
 from shepherd_core.data_models.base.content import IdInt
 from shepherd_core.data_models.base.shepherd import ShpModel
@@ -55,7 +52,7 @@ class EmulationTask(ShpModel):
     # General config
     input_path: Path
     """ ⤷ hdf5 file containing harvesting data"""
-    output_path: Optional[Path] = None
+    output_path: Path | None = None
     """ ⤷ dir- or file-path for storing the recorded data:
 
     - providing a directory -> file is named emu_timestamp.h5
@@ -65,13 +62,12 @@ class EmulationTask(ShpModel):
     """
     force_overwrite: bool = False
     """ ⤷ Overwrite existing file"""
-    output_compression: Optional[Compression] = Compression.default
+    output_compression: Compression | None = Compression.default
     """ ⤷ should be lzf, 1 (gzip level 1) or None (order of recommendation)"""
-    time_start: Optional[datetime] = None
+    time_start: datetime | None = None
     """ timestamp or unix epoch time, None = ASAP"""
-    duration: Optional[timedelta] = None
+    duration: timedelta | None = None
     """ ⤷ Duration of recording in seconds, None = till EOF"""
-    abort_on_error: Annotated[bool, deprecated("has no effect")] = False
 
     # emulation-specific
     use_cal_default: bool = False
@@ -91,7 +87,7 @@ class EmulationTask(ShpModel):
     - main channel is nnected to virtual Source
     - the other port is aux
     """
-    voltage_aux: Union[Annotated[float, Field(ge=0, le=4.5)], str] = 0
+    voltage_aux: 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),
@@ -104,11 +100,11 @@ class EmulationTask(ShpModel):
     provide parameters or name like BQ25570
     """
 
-    power_tracing: Optional[PowerTracing] = PowerTracing()
-    gpio_tracing: Optional[GpioTracing] = GpioTracing()
-    uart_logging: Optional[UartLogging] = UartLogging()
-    gpio_actuation: Optional[GpioActuation] = None
-    sys_logging: Optional[SystemLogging] = SystemLogging()
+    power_tracing: PowerTracing | None = PowerTracing()
+    gpio_tracing: GpioTracing | None = GpioTracing()
+    uart_logging: UartLogging | None = UartLogging()
+    gpio_actuation: GpioActuation | None = None
+    sys_logging: SystemLogging | None = SystemLogging()
 
     verbose: Annotated[int, Field(ge=0, le=4)] = 2
     """ ⤷ 0=Errors, 1=Warnings, 2=Info, 3=Debug,