shepherd-core 2023.8.6__tar.gz → 2023.8.8__tar.gz

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd_core
-Version: 2023.8.6
+Version: 2023.8.8
 Summary: Programming- and CLI-Interface for the h5-dataformat of the Shepherd-Testbed
 Home-page: https://pypi.org/project/shepherd-core/
 Author: Ingmar Splitt, Kai Geissdoerfer
@@ -77,6 +77,13 @@ The Library is available via PyPI and can be installed with
   pip install shepherd-data
 ```
 
+for bleeding-edge-features or dev-work it is possible to install directly from GitHub-Sources (here `dev`-branch):
+
+```Shell
+pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U
+```
+
+
 If you are working with ``.elf``-files (embedding into experiments) you make "objcopy" accessible to python. In Ubuntu, you can either install ``build-essential`` or ``binutils-$ARCH`` with arch being ``msp430`` or ``arm-none-eabi`` for the nRF52.
 
 ```shell

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/README.md

@@ -40,6 +40,13 @@ The Library is available via PyPI and can be installed with
   pip install shepherd-data
 ```
 
+for bleeding-edge-features or dev-work it is possible to install directly from GitHub-Sources (here `dev`-branch):
+
+```Shell
+pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U
+```
+
+
 If you are working with ``.elf``-files (embedding into experiments) you make "objcopy" accessible to python. In Ubuntu, you can either install ``build-essential`` or ``binutils-$ARCH`` with arch being ``msp430`` or ``arm-none-eabi`` for the nRF52.
 
 ```shell

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/setup.cfg

@@ -41,7 +41,7 @@ install_requires =
 	numpy
 	pyYAML
 	chromalog
-	pydantic[email]<2.0.0
+	pydantic[email]>2.0.0
 	tqdm
 	scipy
 	intelhex

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/__init__.py

@@ -21,7 +21,7 @@ from .testbed_client.client import TestbedClient
 from .testbed_client.client import tb_client
 from .writer import BaseWriter
 
-__version__ = "2023.8.6"
+__version__ = "2023.8.8"
 
 __all__ = [
     "BaseReader",

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/__init__.py

@@ -3,6 +3,7 @@ from .base.calibration import CalibrationEmulator
 from .base.calibration import CalibrationHarvester
 from .base.calibration import CalibrationPair
 from .base.calibration import CalibrationSeries
+from .base.calibration import CapeData
 from .base.content import ContentModel
 from .base.shepherd import ShpModel
 from .base.wrapper import Wrapper
@@ -23,6 +24,7 @@ from .experiment.target_config import TargetConfig
 
 __all__ = [
     # Core
+    "CapeData",
     "CalibrationCape",
     "CalibrationEmulator",
     "CalibrationHarvester",
@@ -46,4 +48,4 @@ __all__ = [
     "EnergyDType",
     "VirtualSourceConfig",
     "VirtualHarvesterConfig",
-]  # TODO: for pydantic 2 add @classmethod after @root_validator for cleaner type-checking
+]

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/base/cal_measurement.py

@@ -1,14 +1,17 @@
+from typing import List
 from typing import Optional
 
 import numpy as np
+from pydantic import Field
 from pydantic import PositiveFloat
-from pydantic import conlist
-from pydantic import validate_arguments
+from pydantic import validate_call
+from typing_extensions import Annotated
 
 from .. import CalibrationCape
 from .. import CalibrationEmulator
 from .. import CalibrationHarvester
 from .. import CalibrationPair
+from .calibration import CapeData
 from .shepherd import ShpModel
 
 # TODO: move to shepherd_data to remove scipy-dependency from _core
@@ -19,10 +22,10 @@ class CalMeasurementPair(ShpModel):
     reference_si: float = 0
 
 
-CalMeasPairs = conlist(item_type=CalMeasurementPair, min_items=2)
+CalMeasPairs = Annotated[List[CalMeasurementPair], Field(min_length=2)]
 
 
-@validate_arguments
+@validate_call
 def meas_to_cal(data: CalMeasPairs, component: str) -> CalibrationPair:
     from scipy import stats  # here due to massive delay
 
@@ -51,8 +54,8 @@ class CalMeasurementHarvester(ShpModel):
     adc_C_Hrv: CalMeasPairs
 
     def to_cal(self) -> CalibrationHarvester:
-        dv = self.dict()
-        dcal = CalibrationHarvester().dict()
+        dv = self.model_dump()
+        dcal = CalibrationHarvester().model_dump()
         for key in dv.keys():
             dcal[key] = meas_to_cal(self[key], f"hrv_{key}")
         return CalibrationHarvester(**dcal)
@@ -65,23 +68,23 @@ class CalMeasurementEmulator(ShpModel):
     adc_C_B: CalMeasPairs
 
     def to_cal(self) -> CalibrationEmulator:
-        dv = self.dict()
-        dcal = CalibrationEmulator().dict()
+        dv = self.model_dump()
+        dcal = CalibrationEmulator().model_dump()
         for key in dv.keys():
             dcal[key] = meas_to_cal(self[key], f"emu_{key}")
         return CalibrationEmulator(**dcal)
 
 
 class CalMeasurementCape(ShpModel):
-    harvester: Optional[CalMeasurementHarvester]
-    emulator: Optional[CalMeasurementEmulator]
-
-    cape: Optional[str] = None
+    cape: Optional[CapeData] = None
     host: Optional[str] = None
 
+    harvester: Optional[CalMeasurementHarvester] = None
+    emulator: Optional[CalMeasurementEmulator] = None
+
     def to_cal(self) -> CalibrationCape:
-        dv = self.dict()
-        dcal = CalibrationCape().dict()
+        dv = self.model_dump()
+        dcal = CalibrationCape().model_dump()
         # TODO: is it helpful to default wrong / missing values?
         for key, value in dv.items():
             if key in ["harvester", "emulator"]:

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/base/calibration.py

@@ -1,4 +1,5 @@
 import struct
+from datetime import date
 from typing import Callable
 from typing import Generator
 from typing import Optional
@@ -7,8 +8,11 @@ from typing import Union
 
 import numpy as np
 from numpy.typing import NDArray
+from pydantic import Field
 from pydantic import PositiveFloat
-from pydantic import validate_arguments
+from pydantic import conbytes
+from pydantic import constr
+from pydantic import validate_call
 
 from ...calibration_hw_def import adc_current_to_raw
 from ...calibration_hw_def import adc_voltage_to_raw
@@ -146,6 +150,33 @@ class CalibrationEmulator(ShpModel):
         return cal_set
 
 
+class CapeData(ShpModel):
+    """Representation of Beaglebone Cape information
+        -> just provide serial-number on creation
+
+    According to BeagleBone specifications, each cape should host an EEPROM
+    that contains some standardized information about the type of cape,
+    manufacturer, version etc.
+
+    `See<https://github.com/beagleboard/beaglebone-black/wiki/System-Reference-Manual#824_EEPROM_Data_Format>`_
+    """
+
+    header: conbytes(max_length=4) = b"\xAA\x55\x33\xEE"
+    eeprom_revision: constr(max_length=2) = "A2"
+    board_name: constr(max_length=32) = "BeagleBone SHEPHERD2 Cape"
+    version: constr(max_length=4) = "24B0"
+    manufacturer: constr(max_length=16) = "NES TU DRESDEN"
+    part_number: constr(max_length=16) = "BB-SHPRD"
+
+    serial_number: constr(max_length=12)
+
+    cal_date: constr(max_length=12) = Field(default_factory=date.today().isoformat)
+
+    def __repr__(self) -> str:
+        """string-representation allows print(model)"""
+        return str(self.model_dump())
+
+
 class CalibrationCape(ShpModel):
     """Represents calibration data of shepherd cape.
     Defines the format of calibration data and provides convenient functions
@@ -154,29 +185,31 @@ class CalibrationCape(ShpModel):
     YAML: .to_file() and .from_file() already in ShpModel
     """
 
+    cape: Optional[CapeData] = None
+    host: Optional[str] = None
+
     harvester: CalibrationHarvester = CalibrationHarvester()
     emulator: CalibrationEmulator = CalibrationEmulator()
 
-    cape: Optional[str] = None
-    host: Optional[str] = None
-
     @classmethod
-    def from_bytestr(cls, data: bytes):
+    def from_bytestr(cls, data: bytes, cape: Optional[CapeData] = None):
         """Instantiates calibration data based on byte string.
         This is mainly used to deserialize data read from an EEPROM memory.
 
         Args:
             data: Byte string containing calibration data.
+            cape: data can be supplied
         Returns:
             CalibrationCape object with extracted calibration data.
         """
-        dv = cls().dict(include={"harvester", "emulator"})
+        dv = cls().model_dump(include={"harvester", "emulator"})
         lw = list(dict_generator(dv))
         values = struct.unpack(">" + len(lw) * "d", data)
         # ⤷ X => double float, big endian
         for _i, walk in enumerate(lw):
             # hardcoded fixed depth ... bad but easy
             dv[walk[0]][walk[1]][walk[2]] = float(values[_i])
+        dv["cape"] = cape
         return cls(**dv)
 
     def to_bytestr(self) -> bytes:
@@ -186,7 +219,7 @@ class CalibrationCape(ShpModel):
         Returns:
             Byte string representation of calibration values.
         """
-        lw = list(dict_generator(self.dict(include={"harvester", "emulator"})))
+        lw = list(dict_generator(self.model_dump(include={"harvester", "emulator"})))
         values = [walk[-1] for walk in lw]
         return struct.pack(">" + len(lw) * "d", *values)
 
@@ -200,7 +233,7 @@ class CalibrationSeries(ShpModel):
     # ⤷ default = nanoseconds
 
     @classmethod
-    @validate_arguments
+    @validate_call
     def from_cal(
         cls,
         cal: Union[CalibrationHarvester, CalibrationEmulator],

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/base/content.py

@@ -3,18 +3,20 @@ from datetime import datetime
 from typing import Optional
 
 from pydantic import Field
-from pydantic import conint
-from pydantic import constr
-from pydantic import root_validator
+from pydantic import StringConstraints
+from pydantic import model_validator
+from typing_extensions import Annotated
 
 from .shepherd import ShpModel
 
 # constr -> to_lower=True, max_length=16, regex=r"^[\w]+$"
 # ⤷ Regex = AlphaNum
-IdInt = conint(ge=0, lt=2**128)
-NameStr = constr(max_length=32, regex=r'^[^<>:;,?"*|\/\\]+$')
+IdInt = Annotated[int, Field(ge=0, lt=2**128)]
+NameStr = Annotated[
+    str, StringConstraints(max_length=32, pattern=r'^[^<>:;,?"*|\/\\]+$')
+]
 # ⤷ Regex = FileSystem-Compatible ASCII
-SafeStr = constr(regex=r"^[ -~]+$")
+SafeStr = Annotated[str, StringConstraints(pattern=r"^[ -~]+$")]
 # ⤷ Regex = All Printable ASCII-Characters with Space
 
 
@@ -31,25 +33,27 @@ class ContentModel(ShpModel):
         default_factory=id_default,
     )
     name: NameStr
-    description: Optional[SafeStr] = Field(description="Required when public")
+    description: Annotated[
+        Optional[SafeStr], Field(description="Required when public")
+    ] = None
     comment: Optional[SafeStr] = None
     created: datetime = Field(default_factory=datetime.now)
 
     # Ownership & Access
     owner: NameStr
-    group: NameStr = Field(description="University or Subgroup")
+    group: Annotated[NameStr, Field(description="University or Subgroup")]
     visible2group: bool = False
     visible2all: bool = False
 
     def __str__(self):
         return self.name
 
-    @root_validator(pre=False)
-    def content_validation(cls, values: dict) -> dict:
-        is_visible = values.get("visible2group") or values.get("visible2all")
-        if is_visible and values.get("description") is None:
+    @model_validator(mode="after")
+    def content_validation(self):
+        is_visible = self.visible2group or self.visible2all
+        if is_visible and self.description is None:
             raise ValueError(
                 "Public instances require a description "
                 "(check visible2*- and description-field)"
             )
-        return values
+        return self

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/base/shepherd.py

@@ -8,7 +8,7 @@ from typing import Union
 
 import yaml
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 from yaml import SafeDumper
 
 from .wrapper import Wrapper
@@ -43,36 +43,43 @@ class ShpModel(BaseModel):
     - schema cls.schema() can also be stored to yaml with .schema_to_file()
     """
 
-    class Config:
-        allow_mutation = False  # const after creation
-        frozen = True  # -> hashable! but currently manually with .get_hash()
-        extra = Extra.forbid  # no unnamed attributes allowed
-        validate_all = True  # also checks defaults
-        validate_assignment = True  # not relevant for the frozen model
-        min_anystr_length = 4  # force more meaningful descriptors
-        max_anystr_length = 512
+    model_config = ConfigDict(
+        frozen=True,  # -> const after creation, hashable! but currently manually with .get_hash()
+        extra="forbid",  # no unnamed attributes allowed
+        validate_default=True,
+        validate_assignment=True,  # not relevant for the frozen model
+        str_min_length=1,  # force more meaningful descriptors,
+        # ⤷ TODO: was 4 but localizing constraints works different with pydantic2
+        #       - might be solvable with "use_enum_values=True"
+        str_max_length=512,
         # ⤷ local str-length constraints overrule global ones!
-        anystr_strip_whitespace = True  # strip leading & trailing whitespaces
-        use_enum_values = True  # cleaner export of enum-parameters
-        allow_inf_nan = False  # float without +-inf or NaN
-        underscore_attrs_are_private = True  # allows using them
-        # Options:
-        # - https://docs.pydantic.dev/usage/schema/#field-customization
-        # - https://docs.pydantic.dev/usage/model_config/
-        # "fields["name"].description = ... should be usable to modify model
+        str_strip_whitespace=True,  # strip leading & trailing whitespaces
+        use_enum_values=True,  # cleaner export of enum-parameters
+        allow_inf_nan=False,  # float without +-inf or NaN
+        # defer_build, possible speedup -> but it triggers a bug
+    )
 
     def __repr__(self) -> str:
         """string-representation allows print(model)"""
-        return str(self.dict(exclude_unset=True, exclude_defaults=True))
+        return str(self.model_dump(exclude_unset=True, exclude_defaults=True))
 
     def __getitem__(self, key):
         """allows dict access -> model["key"], in addition to model.key"""
         return self.__getattribute__(key)
 
+    def keys(self):
+        """Fn of dict"""
+        return self.model_dump().keys()
+
+    def items(self):
+        """Fn of dict"""
+        for key in self.keys():
+            yield key, self[key]
+
     @classmethod
     def schema_to_file(cls, path: Union[str, Path]) -> None:
         """store schema to yaml (for frontend-generators)"""
-        model_dict = cls.schema()
+        model_dict = cls.model_json_schema()
         model_yaml = yaml.safe_dump(
             model_dict, default_flow_style=False, sort_keys=False
         )
@@ -89,7 +96,7 @@ class ShpModel(BaseModel):
         minimal: stores minimal set (filters out unset & default parameters)
         comment: documentation
         """
-        model_dict = self.dict(exclude_unset=minimal, exclude_defaults=minimal)
+        model_dict = self.model_dump(exclude_unset=minimal, exclude_defaults=minimal)
         model_wrap = Wrapper(
             datatype=type(self).__name__,
             comment=comment,
@@ -97,7 +104,7 @@ class ShpModel(BaseModel):
             parameters=model_dict,
         )
         model_yaml = yaml.safe_dump(
-            model_wrap.dict(exclude_unset=minimal, exclude_defaults=minimal),
+            model_wrap.model_dump(exclude_unset=minimal, exclude_defaults=minimal),
             default_flow_style=False,
             sort_keys=False,
         )
@@ -118,4 +125,4 @@ class ShpModel(BaseModel):
         return cls(**shp_wrap.parameters)
 
     def get_hash(self):
-        return hashlib.sha3_224(str(self.dict()).encode("utf-8")).hexdigest()
+        return hashlib.sha3_224(str(self.model_dump()).encode("utf-8")).hexdigest()

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/base/wrapper.py

@@ -2,9 +2,10 @@ from datetime import datetime
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import constr
+from pydantic import StringConstraints
+from typing_extensions import Annotated
 
-SafeStrClone = constr(regex=r"^[ -~]+$")
+SafeStrClone = Annotated[str, StringConstraints(pattern=r"^[ -~]+$")]
 # ⤷ copy avoids circular import
 
 
@@ -15,8 +16,8 @@ class Wrapper(BaseModel):
 
     datatype: str
     # ⤷ model-name
-    comment: Optional[SafeStrClone]
-    created: Optional[datetime]
+    comment: Optional[SafeStrClone] = None
+    created: Optional[datetime] = None
     # ⤷ Optional metadata
     parameters: dict
     # ⤷ ShpModel

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/content/energy_environment.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import Optional
 
 from pydantic import PositiveFloat
-from pydantic import root_validator
+from pydantic import model_validator
 
 from ...testbed_client import tb_client
 from ..base.content import ContentModel
@@ -37,7 +37,8 @@ class EnergyEnvironment(ContentModel):
     indoor: Optional[bool] = None
     location: Optional[str] = None
 
-    @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 tb_client.fill_in_user_data(values)

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/content/firmware.py

@@ -2,9 +2,10 @@ from pathlib import Path
 from typing import Optional
 from typing import Union
 
-from pydantic import constr
-from pydantic import root_validator
-from pydantic import validate_arguments
+from pydantic import StringConstraints
+from pydantic import model_validator
+from pydantic import validate_call
+from typing_extensions import Annotated
 
 from ... import fw_tools
 from ... import logger
@@ -32,6 +33,8 @@ arch_to_mcu: dict = {
     "nrf52": {"name": "nrf52"},
 }
 
+FirmwareStr = Annotated[str, StringConstraints(min_length=3, max_length=8_000_000)]
+
 
 class Firmware(ContentModel, title="Firmware of Target"):
     """meta-data representation of a data-component"""
@@ -40,13 +43,14 @@ class Firmware(ContentModel, title="Firmware of Target"):
 
     mcu: MCU
 
-    data: Union[constr(min_length=3, max_length=8_000_000), Path]
+    data: Union[FirmwareStr, Path]
     data_type: FirmwareDType
     data_hash: Optional[str] = None
 
     # TODO: a data-hash would be awesome
 
-    @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 tb_client.fill_in_user_data(values)
@@ -101,7 +105,7 @@ class Firmware(ContentModel, title="Firmware of Target"):
             logger.warning("FW-Hash does not match with stored value!")
         return match
 
-    @validate_arguments
+    @validate_call
     def extract_firmware(self, file: Path) -> Path:
         """stores embedded data in file
         - file-suffix is derived from data-type and adapted

{shepherd_core-2023.8.6 → shepherd_core-2023.8.8}/shepherd_core/data_models/content/virtual_harvester.py

@@ -2,9 +2,9 @@ from enum import Enum
 from typing import Optional
 from typing import Tuple
 
-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 ...commons import samplerate_sps_default
 from ...logger import logger
@@ -39,32 +39,33 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     algorithm: AlgorithmDType
     # ⤷ used to harvest energy
 
-    samples_n: conint(ge=8, le=2_000) = 8
+    samples_n: Annotated[int, Field(ge=8, le=2_000)] = 8
     # ⤷ for & of ivcurve (and more?`)
 
-    voltage_mV: confloat(ge=0, le=5_000) = 2_500
+    voltage_mV: Annotated[float, Field(ge=0, le=5_000)] = 2_500
     # ⤷ starting-point for some algorithms (mppt_po)
-    voltage_min_mV: confloat(ge=0, le=5_000) = 0
-    voltage_max_mV: confloat(ge=0, le=5_000) = 5_000
-    current_limit_uA: confloat(ge=1, le=50_000) = 50_000
+    voltage_min_mV: Annotated[float, Field(ge=0, le=5_000)] = 0
+    voltage_max_mV: Annotated[float, Field(ge=0, le=5_000)] = 5_000
+    current_limit_uA: Annotated[float, Field(ge=1, le=50_000)] = 50_000
     # ⤷ allows to keep trajectory in special region (or constant current tracking)
     # ⤷ boundary for detecting open circuit in emulated version (working on IV-Curves)
-    voltage_step_mV: Optional[confloat(ge=1, le=1_000_000)] = None
+    voltage_step_mV: Optional[Annotated[float, Field(ge=1, le=1_000_000)]] = None
 
-    setpoint_n: confloat(ge=0, le=1.0) = 0.70
+    setpoint_n: Annotated[float, Field(ge=0, le=1.0)] = 0.70
     # ⤷ ie. for mppt_voc
-    interval_ms: confloat(ge=0.01, le=1_000_000) = 100
+    interval_ms: Annotated[float, Field(ge=0.01, le=1_000_000)] = 100
     # ⤷ between start of measurements (ie. V_OC)
-    duration_ms: confloat(ge=0.01, le=1_000_000) = 0.1
+    duration_ms: Annotated[float, Field(ge=0.01, le=1_000_000)] = 0.1
     # ⤷ of (open voltage) measurement
     rising: bool = True
     # ⤷ direction of sawtooth
 
     # Underlying recorder
-    wait_cycles: conint(ge=0, le=100) = 1
+    wait_cycles: Annotated[int, Field(ge=0, le=100)] = 1
     # ⤷ first cycle: ADC-Sampling & DAC-Writing, further steps: waiting
 
-    @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)
@@ -72,27 +73,18 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
             # TODO: same test is later done in calc_algorithm_num() again
             raise ValueError("Resulting Harvester can't be neutral")
         logger.debug("VHrv-Inheritances: %s", chain)
-        return values
-
-    @root_validator(pre=False)
-    def post_validation(cls, values: dict) -> dict:
-        if values.get("voltage_min_mV") > values.get("voltage_max_mV"):
-            raise ValueError("Voltage min > max")
-        if values.get("voltage_mV") < values.get("voltage_min_mV"):
-            raise ValueError("Voltage below min")
-        if values.get("voltage_mV") > values.get("voltage_max_mV"):
-            raise ValueError("Voltage above max")
 
+        # post corrections -> should be in separate validator
         cal = CalibrationHarvester()  # todo: as argument?
-        values["current_limit_uA"] = max(
-            10**6 * cal.adc_C_Hrv.raw_to_si(4), values["current_limit_uA"]
-        )
+        c_limit = values.get("current_limit_uA", 50_000)  # cls.current_limit_uA)
+        values["current_limit_uA"] = max(10**6 * cal.adc_C_Hrv.raw_to_si(4), c_limit)
 
         if values.get("voltage_step_mV") is None:
             # algo includes min & max!
-            values["voltage_step_mV"] = abs(
-                values["voltage_max_mV"] - values["voltage_min_mV"]
-            ) / (values["samples_n"] - 1)
+            v_max = values.get("voltage_max_mV", 5_000)  # cls.voltage_max_mV)
+            v_min = values.get("voltage_min_mV", 0)  # cls.voltage_min_mV)
+            samples_n = values.get("samples_n", 8)  # cls.samples_n) TODO
+            values["voltage_step_mV"] = abs(v_max - v_min) / (samples_n - 1)
 
         values["voltage_step_mV"] = max(
             10**3 * cal.dac_V_Hrv.raw_to_si(4), values["voltage_step_mV"]
@@ -100,6 +92,17 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
 
         return values
 
+    @model_validator(mode="after")
+    def post_validation(self):
+        if self.voltage_min_mV > self.voltage_max_mV:
+            raise ValueError("Voltage min > max")
+        if self.voltage_mV < self.voltage_min_mV:
+            raise ValueError("Voltage below min")
+        if self.voltage_mV > self.voltage_max_mV:
+            raise ValueError("Voltage above max")
+
+        return self
+
     def calc_hrv_mode(self, for_emu: bool) -> int:
         return 1 * int(for_emu) + 2 * self.rising
 
@@ -154,7 +157,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
         return self.samples_n
 
 
-u32 = conint(ge=0, lt=2**32)
+u32 = Annotated[int, Field(ge=0, lt=2**32)]
 
 
 # Currently implemented harvesters
@@ -230,13 +233,13 @@ class HarvesterPRUConfig(ShpModel):
             window_size=window_size
             if window_size is not None
             else data.calc_window_size(for_emu, dtype_in),
-            voltage_uV=data.voltage_mV * 10**3,
-            voltage_min_uV=data.voltage_min_mV * 10**3,
-            voltage_max_uV=data.voltage_max_mV * 10**3,
-            voltage_step_uV=data.voltage_step_mV * 10**3,
-            current_limit_nA=data.current_limit_uA * 10**3,
-            setpoint_n8=min(255, data.setpoint_n * 2**8),
-            interval_n=interval_ms * samplerate_sps_default * 1e-3,
-            duration_n=duration_ms * samplerate_sps_default * 1e-3,
+            voltage_uV=round(data.voltage_mV * 10**3),
+            voltage_min_uV=round(data.voltage_min_mV * 10**3),
+            voltage_max_uV=round(data.voltage_max_mV * 10**3),
+            voltage_step_uV=round(data.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),
             wait_cycles_n=data.wait_cycles,
         )