shepherd-core 2023.11.1__py3-none-any.whl → 2024.4.1__py3-none-any.whl

shepherd_core/reader.py

@@ -1,6 +1,5 @@
-"""
-Reader-Baseclass
-"""
+"""Reader-Baseclass"""
+
 import contextlib
 import errno
 import logging
@@ -36,8 +35,10 @@ class Reader:
     """Sequentially Reads shepherd-data from HDF5 file.
 
     Args:
+    ----
         file_path: Path of hdf5 file containing shepherd data with iv-samples, iv-curves or isc&voc
         verbose: more debug-info during usage, 'None' skips the setter
+
     """
 
     samples_per_buffer: int = 10_000
@@ -95,9 +96,7 @@ class Reader:
                 self.h5file = h5py.File(self.file_path, "r")  # = readonly
                 self._reader_opened = True
             except OSError as _xcp:
-                raise TypeError(
-                    f"Unable to open HDF5-File '{self.file_path.name}'"
-                ) from _xcp
+                raise TypeError(f"Unable to open HDF5-File '{self.file_path.name}'") from _xcp
 
             if self.is_valid():
                 self._logger.debug("File is available now")
@@ -109,9 +108,7 @@ class Reader:
                 )
 
         if not isinstance(self.h5file, h5py.File):
-            raise TypeError(
-                "Type of opened file is not h5py.File, for %s", self.file_path.name
-            )
+            raise TypeError("Type of opened file is not h5py.File, for %s", self.file_path.name)
 
         self.ds_time: h5py.Dataset = self.h5file["data"]["time"]
         self.ds_voltage: h5py.Dataset = self.h5file["data"]["voltage"]
@@ -120,9 +117,7 @@ class Reader:
         # retrieve cal-data
         if not hasattr(self, "_cal"):
             cal_dict = CalibrationSeries().model_dump()
-            for ds, param in product(
-                ["current", "voltage", "time"], ["gain", "offset"]
-            ):
+            for ds, param in product(["current", "voltage", "time"], ["gain", "offset"]):
                 cal_dict[ds][param] = self.h5file["data"][ds].attrs[param]
             self._cal = CalibrationSeries(**cal_dict)
 
@@ -164,15 +159,14 @@ class Reader:
         )
 
     def _refresh_file_stats(self) -> None:
-        """update internal states, helpful after resampling or other changes in data-group"""
+        """Update internal states, helpful after resampling or other changes in data-group"""
         self.h5file.flush()
         if (self.ds_time.shape[0] > 1) and (self.ds_time[1] != self.ds_time[0]):
-            self.sample_interval_s = self._cal.time.raw_to_si(
-                self.ds_time[1] - self.ds_time[0]
-            )
+            # this assumes isochronal sampling
+            self.sample_interval_s = self._cal.time.raw_to_si(self.ds_time[1] - self.ds_time[0])
             self.sample_interval_ns = int(10**9 * self.sample_interval_s)
             self.samplerate_sps = max(int(10**9 // self.sample_interval_ns), 1)
-        self.runtime_s = round(self.ds_time.shape[0] / self.samplerate_sps, 1)
+        self.runtime_s = round(self.ds_voltage.shape[0] / self.samplerate_sps, 1)
         if isinstance(self.file_path, Path):
             self.file_size = self.file_path.stat().st_size
         else:
@@ -185,35 +179,40 @@ class Reader:
         end_n: Optional[int] = None,
         *,
         is_raw: bool = False,
+        omit_ts: bool = False,
     ) -> Generator[tuple, None, None]:
         """Generator that reads the specified range of buffers from the hdf5 file.
         can be configured on first call
-        TODO: reconstruct - start/end mark samples and
-            each call can request a certain number of samples
+        TODO: reconstruct - start/end mark samples &
+         each call can request a certain number of samples
 
         Args:
+        ----
             :param start_n: (int) Index of first buffer to be read
             :param end_n: (int) Index of last buffer to be read
             :param is_raw: (bool) output original data, not transformed to SI-Units
+            :param omit_ts: (bool) optimize reading if timestamp is never used
         Yields: Buffers between start and end (tuple with time, voltage, current)
+
         """
         if end_n is None:
-            end_n = int(self.ds_time.shape[0] // self.samples_per_buffer)
+            end_n = int(self.ds_voltage.shape[0] // self.samples_per_buffer)
         self._logger.debug("Reading blocks %d to %d from source-file", start_n, end_n)
         _raw = is_raw
+        _wts = not omit_ts
 
         for i in range(start_n, end_n):
             idx_start = i * self.samples_per_buffer
             idx_end = idx_start + self.samples_per_buffer
             if _raw:
                 yield (
-                    self.ds_time[idx_start:idx_end],
+                    self.ds_time[idx_start:idx_end] if _wts else None,
                     self.ds_voltage[idx_start:idx_end],
                     self.ds_current[idx_start:idx_end],
                 )
             else:
                 yield (
-                    self._cal.time.raw_to_si(self.ds_time[idx_start:idx_end]),
+                    self._cal.time.raw_to_si(self.ds_time[idx_start:idx_end]) if _wts else None,
                     self._cal.voltage.raw_to_si(self.ds_voltage[idx_start:idx_end]),
                     self._cal.current.raw_to_si(self.ds_current[idx_start:idx_end]),
                 )
@@ -254,7 +253,7 @@ class Reader:
             return None
 
     def get_hrv_config(self) -> dict:
-        """essential info for harvester
+        """Essential info for harvester
         :return: config-dict directly for vHarvester to be used during emulation
         """
         return {
@@ -263,7 +262,7 @@ class Reader:
         }
 
     def is_valid(self) -> bool:
-        """checks file for plausibility
+        """Checks file for plausibility
 
         :return: state of validity
         """
@@ -339,20 +338,20 @@ class Reader:
                 self.file_path.name,
             )
         # same length of datasets:
-        ds_time_size = self.h5file["data"]["time"].shape[0]
-        for dset in ["current", "voltage"]:
+        ds_volt_size = self.h5file["data"]["voltage"].shape[0]
+        for dset in ["current", "time"]:
             ds_size = self.h5file["data"][dset].shape[0]
-            if ds_time_size != ds_size:
+            if ds_volt_size != ds_size:
                 self._logger.warning(
                     "[FileValidation] dataset '%s' has different size (=%d), "
                     "compared to time-ds (=%d), in '%s'",
                     dset,
                     ds_size,
-                    ds_time_size,
+                    ds_volt_size,
                     self.file_path.name,
                 )
         # dataset-length should be multiple of buffersize
-        remaining_size = ds_time_size % self.samples_per_buffer
+        remaining_size = ds_volt_size % self.samples_per_buffer
         if remaining_size != 0:
             self._logger.warning(
                 "[FileValidation] datasets are not aligned with buffer-size in '%s'",
@@ -391,7 +390,7 @@ class Reader:
         return True
 
     def __getitem__(self, key: str) -> Any:
-        """returns attribute or (if none found) a handle for a group or dataset (if found)
+        """Returns attribute or (if none found) a handle for a group or dataset (if found)
 
         :param key: attribute, group, dataset
         :return: value of that key, or handle of object
@@ -403,16 +402,16 @@ class Reader:
         raise KeyError
 
     def energy(self) -> float:
-        """determine the recorded energy of the trace
+        """Determine the recorded energy of the trace
         # multiprocessing: https://stackoverflow.com/a/71898911
         # -> failed with multiprocessing.pool and pathos.multiprocessing.ProcessPool
 
         :return: sampled energy in Ws (watt-seconds)
         """
-        iterations = math.ceil(self.ds_time.shape[0] / self.max_elements)
+        iterations = math.ceil(self.ds_voltage.shape[0] / self.max_elements)
         job_iter = trange(
             0,
-            self.ds_time.shape[0],
+            self.ds_voltage.shape[0],
             self.max_elements,
             desc="energy",
             leave=False,
@@ -420,7 +419,7 @@ class Reader:
         )
 
         def _calc_energy(idx_start: int) -> float:
-            idx_stop = min(idx_start + self.max_elements, self.ds_time.shape[0])
+            idx_stop = min(idx_start + self.max_elements, self.ds_voltage.shape[0])
             vol_v = self._cal.voltage.raw_to_si(self.ds_voltage[idx_start:idx_stop])
             cur_a = self._cal.current.raw_to_si(self.ds_current[idx_start:idx_stop])
             return (vol_v[:] * cur_a[:]).sum() * self.sample_interval_s
@@ -431,7 +430,7 @@ class Reader:
     def _dset_statistics(
         self, dset: h5py.Dataset, cal: Optional[CalibrationPair] = None
     ) -> Dict[str, float]:
-        """some basic stats for a provided dataset
+        """Some basic stats for a provided dataset
         :param dset: dataset to evaluate
         :param cal: calibration (if wanted)
         :return: dict with entries for mean, min, max, std
@@ -439,9 +438,7 @@ class Reader:
         si_converted = True
         if not isinstance(cal, CalibrationPair):
             if "gain" in dset.attrs and "offset" in dset.attrs:
-                cal = CalibrationPair(
-                    gain=dset.attrs["gain"], offset=dset.attrs["offset"]
-                )
+                cal = CalibrationPair(gain=dset.attrs["gain"], offset=dset.attrs["offset"])
             else:
                 cal = CalibrationPair(gain=1)
                 si_converted = False
@@ -459,8 +456,7 @@ class Reader:
             return [np.mean(data), np.min(data), np.max(data), np.std(data)]
 
         stats_list = [
-            _calc_statistics(cal.raw_to_si(dset[i : i + self.max_elements]))
-            for i in job_iter
+            _calc_statistics(cal.raw_to_si(dset[i : i + self.max_elements])) for i in job_iter
         ]
         if len(stats_list) < 1:
             return {}
@@ -476,7 +472,7 @@ class Reader:
         return stats
 
     def _data_timediffs(self) -> List[float]:
-        """calculate list of (unique) time-deltas between buffers [s]
+        """Calculate list of (unique) time-deltas between buffers [s]
             -> optimized version that only looks at the start of each buffer
 
         :return: list of (unique) time-deltas between buffers [s]
@@ -507,7 +503,7 @@ class Reader:
         return list(diffs)
 
     def check_timediffs(self) -> bool:
-        """validate equal time-deltas
+        """Validate equal time-deltas
         -> unexpected time-jumps hint at a corrupted file or faulty measurement
 
         :return: True if OK
@@ -519,9 +515,7 @@ class Reader:
             )
         return (len(diffs) <= 1) and diffs[0] == round(0.1 / self.samples_per_buffer, 6)
 
-    def count_errors_in_log(
-        self, group_name: str = "sheep", min_level: int = 40
-    ) -> int:
+    def count_errors_in_log(self, group_name: str = "sheep", min_level: int = 40) -> int:
         if group_name not in self.h5file:
             return 0
         if "level" not in self.h5file["sheep"]:
@@ -538,7 +532,7 @@ class Reader:
         *,
         minimal: bool = False,
     ) -> Dict[str, dict]:
-        """recursive FN to capture the structure of the file
+        """Recursive FN to capture the structure of the file
         :param node: starting node, leave free to go through whole file
         :param minimal: just provide a bare tree (much faster)
         :return: structure of that node with everything inside it
@@ -589,7 +583,7 @@ class Reader:
         return metadata
 
     def save_metadata(self, node: Union[h5py.Dataset, h5py.Group, None] = None) -> dict:
-        """get structure of file and dump content to yaml-file with same name as original
+        """Get structure of file and dump content to yaml-file with same name as original
 
         :param node: starting node, leave free to go through whole file
         :return: structure of that node with everything inside it
@@ -599,9 +593,7 @@ class Reader:
             if yaml_path.exists():
                 self._logger.info("File already exists, will skip '%s'", yaml_path.name)
                 return {}
-            metadata = self.get_metadata(
-                node
-            )  # {"h5root": self.get_metadata(self.h5file)}
+            metadata = self.get_metadata(node)  # {"h5root": self.get_metadata(self.h5file)}
             with yaml_path.open("w", encoding="utf-8-sig") as yfd:
                 yaml.safe_dump(metadata, yfd, default_flow_style=False, sort_keys=False)
         else:
@@ -620,7 +612,7 @@ class Reader:
 
     @staticmethod
     def get_filter_for_redundant_states(data: np.ndarray) -> np.ndarray:
-        """input is 1D state-vector, kep only first from identical & sequential states
+        """Input is 1D state-vector, kep only first from identical & sequential states
         algo: create an offset-by-one vector and compare against original
         """
         if len(data.shape) > 1:
@@ -637,9 +629,7 @@ class Reader:
         gpio_vs = self.h5file["gpio"]["value"]
 
         if name is None:
-            descriptions = yaml.safe_load(
-                self.h5file["gpio"]["value"].attrs["description"]
-            )
+            descriptions = yaml.safe_load(self.h5file["gpio"]["value"].attrs["description"])
             pin_dict = {value["name"]: key for key, value in descriptions.items()}
         else:
             pin_dict = {name: self.get_gpio_pin_num(name)}
@@ -655,9 +645,7 @@ class Reader:
             )
         return waveforms
 
-    def waveform_to_csv(
-        self, pin_name: str, pin_wf: np.ndarray, separator: str = ","
-    ) -> None:
+    def waveform_to_csv(self, pin_name: str, pin_wf: np.ndarray, separator: str = ",") -> None:
         path_csv = self.file_path.with_suffix(f".waveform.{pin_name}.csv")
         if path_csv.exists():
             self._logger.info("File already exists, will skip '%s'", path_csv.name)

shepherd_core/testbed_client/cache_path.py

@@ -0,0 +1,15 @@
+import os
+from pathlib import Path
+
+
+def _get_xdg_path(variable_name: str, default_path: Path) -> Path:
+    _value = os.environ.get(variable_name)
+    if _value is None or _value == "":
+        return default_path
+    return Path(_value)
+
+
+user_path = Path("~").expanduser()
+
+cache_xdg_path = _get_xdg_path("XDG_CACHE_HOME", user_path / ".cache")
+cache_user_path = cache_xdg_path / "shepherd_datalib"

shepherd_core/testbed_client/client.py

@@ -18,9 +18,7 @@ from .user_model import User
 class TestbedClient:
     _instance: Optional[Self] = None
 
-    def __init__(
-        self, server: Optional[str] = None, token: Union[str, Path, None] = None
-    ) -> None:
+    def __init__(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> None:
         if not hasattr(self, "_token"):
             self._token: str = "null"
             self._server: Optional[str] = testbed_server_default
@@ -42,11 +40,8 @@ class TestbedClient:
         TestbedClient._instance = None
 
     @validate_call
-    def connect(
-        self, server: Optional[str] = None, token: Union[str, Path, None] = None
-    ) -> bool:
-        """
-        server: either "local" to use demo-fixtures or something like "https://HOST:PORT"
+    def connect(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> bool:
+        """server: either "local" to use demo-fixtures or something like "https://HOST:PORT"
         token: your account validation
         """
         if isinstance(token, Path):
@@ -74,9 +69,7 @@ class TestbedClient:
             parameters=data.model_dump(),
         )
         if self._connected:
-            r = self._req.post(
-                self._server + "/add", data=wrap.model_dump_json(), timeout=2
-            )
+            r = self._req.post(self._server + "/add", data=wrap.model_dump_json(), timeout=2)
             r.raise_for_status()
         else:
             self._fixtures.insert_model(wrap)
@@ -126,7 +119,7 @@ class TestbedClient:
         return self._fixtures[model_type].inheritance(values)
 
     def try_completing_model(self, model_type: str, values: dict) -> (dict, list):
-        """init by name/id, for none existing instances raise Exception"""
+        """Init by name/id, for none existing instances raise Exception"""
         if len(values) == 1 and next(iter(values.keys())) in {"id", "name"}:
             value = next(iter(values.values()))
             if (
@@ -134,16 +127,11 @@ class TestbedClient:
                 and value.lower() in self._fixtures[model_type].elements_by_name
             ):
                 values = self.query_item(model_type, name=value)
-            elif (
-                isinstance(value, int)
-                and value in self._fixtures[model_type].elements_by_id
-            ):
+            elif isinstance(value, int) and value in self._fixtures[model_type].elements_by_id:
                 # TODO: still depending on _fixture
                 values = self.query_item(model_type, uid=value)
             else:
-                raise ValueError(
-                    f"Query {model_type} by name / ID failed - " f"{values} is unknown!"
-                )
+                raise ValueError(f"Query {model_type} by name / ID failed - {values} is unknown!")
         return self.try_inheritance(model_type, values)
 
     def fill_in_user_data(self, values: dict) -> dict:

shepherd_core/testbed_client/fixtures.py

@@ -18,6 +18,7 @@ from ..data_models.base.timezone import local_now
 from ..data_models.base.timezone import local_tz
 from ..data_models.base.wrapper import Wrapper
 from ..logger import logger
+from .cache_path import cache_user_path
 
 # Proposed field-name:
 # - inheritance
@@ -148,16 +149,12 @@ class Fixture:
     def query_id(self, _id: int) -> dict:
         if isinstance(_id, int) and _id in self.elements_by_id:
             return self.elements_by_id[_id]
-        raise ValueError(
-            f"Initialization of {self.model_type} by ID failed - {_id} is unknown!"
-        )
+        raise ValueError(f"Initialization of {self.model_type} by ID failed - {_id} is unknown!")
 
     def query_name(self, name: str) -> dict:
         if isinstance(name, str) and name.lower() in self.elements_by_name:
             return self.elements_by_name[name.lower()]
-        raise ValueError(
-            f"Initialization of {self.model_type} by name failed - {name} is unknown!"
-        )
+        raise ValueError(f"Initialization of {self.model_type} by name failed - {name} is unknown!")
 
 
 def file_older_than(file: Path, delta: timedelta) -> bool:
@@ -172,22 +169,17 @@ class Fixtures:
     suffix = ".yaml"
 
     @validate_call
-    def __init__(
-        self, file_path: Optional[Path] = None, *, reset: bool = False
-    ) -> None:
+    def __init__(self, file_path: Optional[Path] = None, *, reset: bool = False) -> None:
         if file_path is None:
             self.file_path = Path(__file__).parent.parent.resolve() / "data_models"
         else:
             self.file_path = file_path
         self.components: Dict[str, Fixture] = {}
-        save_path = self.file_path / "fixtures.pickle"
+        save_path = cache_user_path / "fixtures.pickle"
 
-        if (
-            save_path.exists()
-            and not file_older_than(save_path, timedelta(hours=24))
-            and not reset
-        ):
+        if save_path.exists() and not file_older_than(save_path, timedelta(hours=24)) and not reset:
             # speedup
+            # TODO: also add version as criterion
             with save_path.open("rb", buffering=-1) as fd:
                 self.components = pickle.load(fd)  # noqa: S301
             logger.debug(" -> found & used pickled fixtures")
@@ -202,6 +194,7 @@ class Fixtures:
             for file in files:
                 self.insert_file(file)
 
+            save_path.parent.mkdir(parents=True, exist_ok=True)
             with save_path.open("wb", buffering=-1) as fd:
                 pickle.dump(self.components, fd)
 

shepherd_core/testbed_client/user_model.py

@@ -1,7 +1,10 @@
 import secrets
 from hashlib import pbkdf2_hmac
 from typing import Optional
+from typing import Union
+from uuid import uuid4
 
+from pydantic import UUID4
 from pydantic import EmailStr
 from pydantic import Field
 from pydantic import SecretBytes
@@ -11,17 +14,13 @@ from pydantic import model_validator
 from pydantic import validate_call
 from typing_extensions import Annotated
 
-from ..data_models.base.content import IdInt
 from ..data_models.base.content import NameStr
 from ..data_models.base.content import SafeStr
-from ..data_models.base.content import id_default
 from ..data_models.base.shepherd import ShpModel
 
 
 @validate_call
-def hash_password(
-    pw: Annotated[str, StringConstraints(min_length=20, max_length=100)]
-) -> bytes:
+def hash_password(pw: Annotated[str, StringConstraints(min_length=20, max_length=100)]) -> bytes:
     # TODO: add salt of testbed -> this fn should be part of Testbed-Object
     # NOTE: 1M Iterations need 25s on beaglebone
     return pbkdf2_hmac(
@@ -36,9 +35,10 @@ def hash_password(
 class User(ShpModel):
     """meta-data representation of a testbed-component (physical object)"""
 
-    id: IdInt = Field(  # noqa: A003
+    # id: UUID4 = Field(  # TODO db-migration - temp fix for documentation
+    id: Union[UUID4, int] = Field(
         description="Unique ID",
-        default_factory=id_default,
+        default_factory=uuid4,
     )
     name: NameStr
     description: Optional[SafeStr] = None

shepherd_core/vsource/virtual_converter_model.py

@@ -6,7 +6,7 @@
 NOTE: DO NOT OPTIMIZE -> stay close to original code-base
 
 Compromises:
-- bitshifted values (ie. _n28) are converted to float without shift
+- bitshifted values (i.e. _n28) are converted to float without shift
 
 """
 
@@ -52,9 +52,7 @@ class VirtualConverterModel:
         self.V_input_uV: float = 0.0
         self.P_inp_fW: float = 0.0
         self.P_out_fW: float = 0.0
-        self.interval_startup_disabled_drain_n: int = (
-            self._cfg.interval_startup_delay_drain_n
-        )
+        self.interval_startup_disabled_drain_n: int = self._cfg.interval_startup_delay_drain_n
 
         # container for the stored energy
         self.V_mid_uV: float = self._cfg.V_intermediate_init_uV
@@ -71,12 +69,8 @@ class VirtualConverterModel:
 
         # prepare hysteresis-thresholds
         self.dV_enable_output_uV: float = self._cfg.dV_enable_output_uV
-        self.V_enable_output_threshold_uV: float = (
-            self._cfg.V_enable_output_threshold_uV
-        )
-        self.V_disable_output_threshold_uV: float = (
-            self._cfg.V_disable_output_threshold_uV
-        )
+        self.V_enable_output_threshold_uV: float = self._cfg.V_enable_output_threshold_uV
+        self.V_disable_output_threshold_uV: float = self._cfg.V_disable_output_threshold_uV
 
         if self.dV_enable_output_uV > self.V_enable_output_threshold_uV:
             self.V_enable_output_threshold_uV = self.dV_enable_output_uV
@@ -163,11 +157,7 @@ class VirtualConverterModel:
 
         if self.V_mid_uV > self._cfg.V_intermediate_max_uV:
             self.V_mid_uV = self._cfg.V_intermediate_max_uV
-        if (
-            (not self.enable_boost)
-            and (self.P_inp_fW > 0.0)
-            and (self.V_mid_uV > self.V_input_uV)
-        ):
+        if (not self.enable_boost) and (self.P_inp_fW > 0.0) and (self.V_mid_uV > self.V_input_uV):
             # TODO: obfuscated - no "direct connection"?
             self.V_mid_uV = self.V_input_uV
         elif self.V_mid_uV < 1:

shepherd_core/vsource/virtual_harvester_model.py

@@ -11,6 +11,7 @@ Compromises:
 - Python has no static vars -> FName_reset is handling the class-vars
 
 """
+
 from typing import Tuple
 
 from ..data_models.content.virtual_harvester import HarvesterPRUConfig
@@ -93,9 +94,7 @@ class VirtualHarvesterModel:
             if distance_now < distance_last and distance_now < self.voltage_step_x4_uV:
                 self.voltage_hold = _voltage_uV
                 self.current_hold = _current_nA
-            elif (
-                distance_last < distance_now and distance_last < self.voltage_step_x4_uV
-            ):
+            elif distance_last < distance_now and distance_last < self.voltage_step_x4_uV:
                 self.voltage_hold = self.voltage_last
                 self.current_hold = self.current_last
 

shepherd_core/vsource/virtual_source_model.py

@@ -6,6 +6,7 @@
 NOTE: DO NOT OPTIMIZE -> stay close to original code-base
 
 """
+
 from typing import Optional
 
 from ..data_models import CalibrationEmulator
@@ -37,9 +38,7 @@ class VirtualSourceModel:
         cnv_config = ConverterPRUConfig.from_vsrc(
             self.cfg_src, log_intermediate_node=log_intermediate
         )
-        self.cnv: VirtualConverterModel = VirtualConverterModel(
-            cnv_config, self._cal_pru
-        )
+        self.cnv: VirtualConverterModel = VirtualConverterModel(cnv_config, self._cal_pru)
 
         hrv_config = HarvesterPRUConfig.from_vhrv(
             self.cfg_src.harvester,
@@ -53,9 +52,7 @@ class VirtualSourceModel:
         self.W_inp_fWs: float = 0.0
         self.W_out_fWs: float = 0.0
 
-    def iterate_sampling(
-        self, V_inp_uV: int = 0, I_inp_nA: int = 0, I_out_nA: int = 0
-    ) -> int:
+    def iterate_sampling(self, V_inp_uV: int = 0, I_inp_nA: int = 0, I_out_nA: int = 0) -> int:
         """TEST-SIMPLIFICATION - code below is not part of pru-code,
         but in part sample_emulator() in sampling.c