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

shepherd_core/__init__.py

@@ -22,7 +22,7 @@ from .testbed_client.client import TestbedClient
 from .testbed_client.client import tb_client
 from .writer import Writer
 
-__version__ = "2023.11.1"
+__version__ = "2023.12.1"
 
 __all__ = [
     "Reader",

shepherd_core/data_models/base/content.py

@@ -14,9 +14,7 @@ from .timezone import local_now
 # constr -> to_lower=True, max_length=16, regex=r"^[\w]+$"
 # ⤷ Regex = AlphaNum
 IdInt = Annotated[int, Field(ge=0, lt=2**128)]
-NameStr = Annotated[
-    str, StringConstraints(max_length=32, pattern=r'^[^<>:;,?"*|\/\\]+$')
-]
+NameStr = Annotated[str, StringConstraints(max_length=32, pattern=r'^[^<>:;,?"*|\/\\]+$')]
 # ⤷ Regex = FileSystem-Compatible ASCII
 SafeStr = Annotated[str, StringConstraints(pattern=r"^[ -~]+$")]
 # ⤷ Regex = All Printable ASCII-Characters with Space
@@ -35,9 +33,7 @@ class ContentModel(ShpModel):
         default_factory=id_default,
     )
     name: NameStr
-    description: Annotated[
-        Optional[SafeStr], Field(description="Required when public")
-    ] = None
+    description: Annotated[Optional[SafeStr], Field(description="Required when public")] = None
     comment: Optional[SafeStr] = None
     created: datetime = Field(default_factory=datetime.now)
 
@@ -57,7 +53,6 @@ class ContentModel(ShpModel):
         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)"
+                "Public instances require a description (check visible2*- and description-field)"
             )
         return self

shepherd_core/data_models/base/shepherd.py

@@ -27,9 +27,7 @@ def path2str(
 
 
 def time2int(dumper: Dumper, data: timedelta) -> ScalarNode:
-    return dumper.represent_scalar(
-        "tag:yaml.org,2002:int", str(int(data.total_seconds()))
-    )
+    return dumper.represent_scalar("tag:yaml.org,2002:int", str(int(data.total_seconds())))
 
 
 def generic2str(dumper: Dumper, data: Any) -> ScalarNode:
@@ -109,9 +107,7 @@ class ShpModel(BaseModel):
     def schema_to_file(cls, path: Union[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
-        )
+        model_yaml = yaml.safe_dump(model_dict, default_flow_style=False, sort_keys=False)
         with Path(path).resolve().with_suffix(".yaml").open("w") as f:
             f.write(model_yaml)
 

shepherd_core/data_models/content/virtual_source.py

@@ -153,15 +153,9 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
             dV_output_imed_low_mV = 0
 
         # protect from complex solutions (non valid input combinations)
-        if not (
-            isinstance(dV_output_en_thrs_mV, (int, float))
-            and (dV_output_en_thrs_mV >= 0)
-        ):
+        if not (isinstance(dV_output_en_thrs_mV, (int, float)) and (dV_output_en_thrs_mV >= 0)):
             dV_output_en_thrs_mV = 0
-        if not (
-            isinstance(dV_output_imed_low_mV, (int, float))
-            and (dV_output_imed_low_mV >= 0)
-        ):
+        if not (isinstance(dV_output_imed_low_mV, (int, float)) and (dV_output_imed_low_mV >= 0)):
             logger.warning("VSrc: C_output shouldn't be larger than C_intermediate")
             dV_output_imed_low_mV = 0
 
@@ -171,9 +165,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
             if self.V_intermediate_enable_threshold_mV > V_pre_output_mV:
                 values["dV_enable_output_mV"] = dV_output_en_thrs_mV
-                values[
-                    "V_enable_output_threshold_mV"
-                ] = self.V_intermediate_enable_threshold_mV
+                values["V_enable_output_threshold_mV"] = self.V_intermediate_enable_threshold_mV
 
             else:
                 values["dV_enable_output_mV"] = dV_output_imed_low_mV
@@ -182,20 +174,14 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
                 )
 
             if self.V_intermediate_disable_threshold_mV > V_pre_output_mV:
-                values[
-                    "V_disable_output_threshold_mV"
-                ] = self.V_intermediate_disable_threshold_mV
+                values["V_disable_output_threshold_mV"] = self.V_intermediate_disable_threshold_mV
             else:
                 values["V_disable_output_threshold_mV"] = V_pre_output_mV
 
         else:
             values["dV_enable_output_mV"] = dV_output_en_thrs_mV
-            values[
-                "V_enable_output_threshold_mV"
-            ] = self.V_intermediate_enable_threshold_mV
-            values[
-                "V_disable_output_threshold_mV"
-            ] = self.V_intermediate_disable_threshold_mV
+            values["V_enable_output_threshold_mV"] = self.V_intermediate_enable_threshold_mV
+            values["V_disable_output_threshold_mV"] = self.V_intermediate_disable_threshold_mV
         return values
 
     def calc_converter_mode(self, *, log_intermediate_node: bool) -> int:
@@ -286,9 +272,7 @@ class ConverterPRUConfig(ShpModel):
         states = data.calc_internal_states()
         return cls(
             # General
-            converter_mode=data.calc_converter_mode(
-                log_intermediate_node=log_intermediate_node
-            ),
+            converter_mode=data.calc_converter_mode(log_intermediate_node=log_intermediate_node),
             interval_startup_delay_drain_n=round(
                 data.interval_startup_delay_drain_ms * samplerate_sps_default * 1e-3
             ),
@@ -299,26 +283,16 @@ class ConverterPRUConfig(ShpModel):
             Constant_us_per_nF_n28=data.calc_cap_constant_us_per_nF_n28(),
             V_intermediate_init_uV=round(data.V_intermediate_init_mV * 1e3),
             I_intermediate_leak_nA=round(data.I_intermediate_leak_nA),
-            V_enable_output_threshold_uV=round(
-                states["V_enable_output_threshold_mV"] * 1e3
-            ),
-            V_disable_output_threshold_uV=round(
-                states["V_disable_output_threshold_mV"] * 1e3
-            ),
+            V_enable_output_threshold_uV=round(states["V_enable_output_threshold_mV"] * 1e3),
+            V_disable_output_threshold_uV=round(states["V_disable_output_threshold_mV"] * 1e3),
             dV_enable_output_uV=round(states["dV_enable_output_mV"] * 1e3),
             interval_check_thresholds_n=round(
                 data.interval_check_thresholds_ms * samplerate_sps_default * 1e-3
             ),
-            V_pwr_good_enable_threshold_uV=round(
-                data.V_pwr_good_enable_threshold_mV * 1e3
-            ),
-            V_pwr_good_disable_threshold_uV=round(
-                data.V_pwr_good_disable_threshold_mV * 1e3
-            ),
+            V_pwr_good_enable_threshold_uV=round(data.V_pwr_good_enable_threshold_mV * 1e3),
+            V_pwr_good_disable_threshold_uV=round(data.V_pwr_good_disable_threshold_mV * 1e3),
             immediate_pwr_good_signal=data.immediate_pwr_good_signal,
-            V_output_log_gpio_threshold_uV=round(
-                data.V_output_log_gpio_threshold_mV * 1e3
-            ),
+            V_output_log_gpio_threshold_uV=round(data.V_output_log_gpio_threshold_mV * 1e3),
             # Boost-Converter
             V_input_boost_threshold_uV=round(data.V_input_boost_threshold_mV * 1e3),
             V_intermediate_max_uV=round(data.V_intermediate_max_mV * 1e3),
@@ -330,8 +304,7 @@ class ConverterPRUConfig(ShpModel):
             LUT_input_I_min_log2_nA=data.LUT_input_I_min_log2_nA,
             LUT_output_I_min_log2_nA=data.LUT_output_I_min_log2_nA,
             LUT_inp_efficiency_n8=[
-                [min(255, round(256 * ival)) for ival in il]
-                for il in data.LUT_input_efficiency
+                [min(255, round(256 * ival)) for ival in il] for il in data.LUT_input_efficiency
             ],
             LUT_out_inv_efficiency_n4=[
                 min((2**14), round((2**4) / value)) if (value > 0) else int(2**14)

shepherd_core/data_models/experiment/experiment.py

@@ -80,9 +80,7 @@ class Experiment(ShpModel, title="Config of an Experiment"):
         if len(target_ids) > len(set(target_ids)):
             raise ValueError("Target-ID used more than once in Experiment!")
         if len(target_ids) > len(set(custom_ids)):
-            raise ValueError(
-                "Custom Target-ID are faulty (some form of id-collisions)!"
-            )
+            raise ValueError("Custom Target-ID are faulty (some form of id-collisions)!")
 
     @staticmethod
     def validate_observers(configs: List[TargetConfig]) -> None:
@@ -92,8 +90,7 @@ class Experiment(ShpModel, title="Config of an Experiment"):
         obs_ids = [testbed.get_observer(_id).id for _id in target_ids]
         if len(target_ids) > len(set(obs_ids)):
             raise ValueError(
-                "Observer used more than once in Experiment "
-                "-> only 1 target per observer!"
+                "Observer used more than once in Experiment -> only 1 target per observer!"
             )
 
     def get_target_ids(self) -> list:
@@ -104,6 +101,4 @@ class Experiment(ShpModel, title="Config of an Experiment"):
             if target_id in _config.target_IDs:
                 return _config
         # gets already caught in target_config - but keep:
-        raise ValueError(
-            f"Target-ID {target_id} was not found in Experiment '{self.name}'"
-        )
+        raise ValueError(f"Target-ID {target_id} was not found in Experiment '{self.name}'")

shepherd_core/data_models/experiment/observer_features.py

@@ -43,9 +43,7 @@ class PowerTracing(ShpModel, title="Config for Power-Tracing"):
 
         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"
-            )
+            raise ValueError("Error in config -> tracing enabled, but output gets discarded")
         if self.calculate_power:
             raise ValueError("postprocessing not implemented ATM")
         return self
@@ -59,9 +57,7 @@ class GpioTracing(ShpModel, title="Config for GPIO-Tracing"):
     # initial recording
     mask: Annotated[int, Field(ge=0, lt=2**10)] = 0b11_1111_1111  # all
     # ⤷ TODO: custom mask not implemented in PRU, ATM
-    gpios: Optional[
-        Annotated[List[GPIO], Field(min_length=1, max_length=10)]
-    ] = None  # = all
+    gpios: Optional[Annotated[List[GPIO], Field(min_length=1, max_length=10)]] = None  # = all
     # ⤷ TODO: list of GPIO to build mask, one of both should be internal / computed field
 
     # time
@@ -108,9 +104,7 @@ class GpioEvent(ShpModel, title="Config for a GPIO-Event"):
     @model_validator(mode="after")
     def post_validation(self) -> Self:
         if not self.gpio.user_controllable():
-            raise ValueError(
-                f"GPIO '{self.gpio.name}' in actuation-event not controllable by user"
-            )
+            raise ValueError(f"GPIO '{self.gpio.name}' in actuation-event not controllable by user")
         return self
 
     def get_events(self) -> np.ndarray:
@@ -138,6 +132,7 @@ class SystemLogging(ShpModel, title="Config for System-Logging"):
     ptp: bool = True
     shepherd: bool = True
     # TODO: rename to kernel, timesync, sheep
+    # TODO: add utilization as option
 
 
 # TODO: some more interaction would be good

shepherd_core/data_models/experiment/target_config.py

@@ -22,18 +22,14 @@ class TargetConfig(ShpModel, title="Target Config"):
     """Configuration for 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: Optional[Annotated[List[IdInt16], Field(min_length=1, max_length=128)]] = None
     # ⤷ will replace 'const uint16_t SHEPHERD_NODE_ID' in firmware
     #   if no custom ID is provided, the original ID of target is used
 
     energy_env: EnergyEnvironment  # alias: input
     virtual_source: VirtualSourceConfig = VirtualSourceConfig(name="neutral")
     target_delays: Optional[
-        Annotated[
-            List[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=128)
-        ]
+        Annotated[List[Annotated[int, Field(ge=0)]], Field(min_length=1, max_length=128)]
     ] = None
     # ⤷ individual starting times -> allows to use the same environment
     # TODO: delays not used ATM
@@ -48,9 +44,7 @@ class TargetConfig(ShpModel, title="Target Config"):
     @model_validator(mode="after")
     def post_validation(self) -> Self:
         if not self.energy_env.valid:
-            raise ValueError(
-                f"EnergyEnv '{self.energy_env.name}' for target must be valid"
-            )
+            raise ValueError(f"EnergyEnv '{self.energy_env.name}' for target must be valid")
         for _id in self.target_IDs:
             target = Target(id=_id)
             for mcu_num in [1, 2]:
@@ -78,8 +72,7 @@ class TargetConfig(ShpModel, title="Target Config"):
         t_ids = self.target_IDs
         if c_ids is not None and (len(set(c_ids)) < len(set(t_ids))):
             raise ValueError(
-                f"Provided custom IDs {c_ids} not enough "
-                f"to cover target range {t_ids}"
+                f"Provided custom IDs {c_ids} not enough to cover target range {t_ids}"
             )
         # TODO: if custom ids present, firmware must be ELF
         return self

shepherd_core/data_models/task/__init__.py

@@ -32,9 +32,7 @@ __all__ = [
 ]
 
 
-def prepare_task(
-    config: Union[ShpModel, Path, str], observer: Optional[str] = None
-) -> Wrapper:
+def prepare_task(config: Union[ShpModel, Path, str], observer: Optional[str] = None) -> Wrapper:
     """- Opens file (from Path or str of Path)
     - wraps task-model
     - and if it's an TestbedTasks it will extract the correct ObserverTask
@@ -88,9 +86,7 @@ def extract_tasks(shp_wrap: Wrapper, *, no_task_sets: bool = True) -> List[ShpMo
         content = [ProgrammingTask(**shp_wrap.parameters)]
     elif shp_wrap.datatype == TestbedTasks.__name__:
         if no_task_sets:
-            raise ValueError(
-                "Model in Wrapper was TestbedTasks -> Task-Sets not allowed!"
-            )
+            raise ValueError("Model in Wrapper was TestbedTasks -> Task-Sets not allowed!")
         content = [TestbedTasks(**shp_wrap.parameters)]
     else:
         raise ValueError("Extractor had unknown task: %s", shp_wrap.datatype)

shepherd_core/data_models/task/emulation.py

@@ -29,8 +29,9 @@ class Compression(str, Enum):
     lzf = "lzf"  # not native hdf5
     gzip1 = 1  # higher compr & load
     gzip = 1
-    default = 1
+    default = "lzf"
     null = None
+    # NOTE: changed to lzf as BBB needs every straw it can get
 
 
 compressions_allowed: list = [None, "lzf", 1]
@@ -52,8 +53,7 @@ class EmulationTask(ShpModel):
     force_overwrite: bool = False
     # ⤷ Overwrite existing file
     output_compression: Optional[Compression] = Compression.default
-    # ⤷ should be 1 (level 1 gzip), lzf, or None (order of recommendation)
-
+    # ⤷ should be lzf, 1 (gzip level 1) or None (order of recommendation)
     time_start: Optional[datetime] = None
     # timestamp or unix epoch time, None = ASAP
     duration: Optional[timedelta] = None
@@ -98,9 +98,7 @@ class EmulationTask(ShpModel):
         # 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"], tz=local_tz()
-            )
+            values["time_start"] = datetime.fromtimestamp(values["time_start"], tz=local_tz())
         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:
@@ -123,18 +121,14 @@ class EmulationTask(ShpModel):
             "main",
             "buffer",
         }:
-            raise ValueError(
-                "Voltage Aux must be in float (0 - 4.5) or string 'main' / 'mid'."
-            )
+            raise ValueError("Voltage Aux must be in float (0 - 4.5) or string 'main' / 'mid'.")
         if self.gpio_actuation is not None:
             raise ValueError("GPIO Actuation not yet implemented!")
         return self
 
     @classmethod
     @validate_call
-    def from_xp(
-        cls, xp: Experiment, tb: Testbed, tgt_id: IdInt, root_path: Path
-    ) -> Self:
+    def from_xp(cls, xp: Experiment, tb: Testbed, tgt_id: IdInt, root_path: Path) -> Self:
         obs = tb.get_observer(tgt_id)
         tgt_cfg = xp.get_target_config(tgt_id)
 
@@ -144,8 +138,7 @@ class EmulationTask(ShpModel):
             time_start=copy.copy(xp.time_start),
             duration=xp.duration,
             abort_on_error=xp.abort_on_error,
-            enable_io=(tgt_cfg.gpio_tracing is not None)
-            or (tgt_cfg.gpio_actuation is not None),
+            enable_io=(tgt_cfg.gpio_tracing is not None) or (tgt_cfg.gpio_actuation is not None),
             io_port=obs.get_target_port(tgt_id),
             pwr_port=obs.get_target_port(tgt_id),
             virtual_source=tgt_cfg.virtual_source,

shepherd_core/data_models/task/firmware_mod.py

@@ -40,9 +40,7 @@ class FirmwareModTask(ShpModel):
             FirmwareDType.base64_hex,
             FirmwareDType.path_hex,
         }:
-            logger.warning(
-                "Firmware is scheduled to get custom-ID but is not in elf-format"
-            )
+            logger.warning("Firmware is scheduled to get custom-ID but is not in elf-format")
         return self
 
     @classmethod

shepherd_core/data_models/task/harvest.py

@@ -60,9 +60,7 @@ class HarvestTask(ShpModel):
         # 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"], tz=local_tz()
-            )
+            values["time_start"] = datetime.fromtimestamp(values["time_start"], tz=local_tz())
         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:

shepherd_core/data_models/testbed/observer.py

@@ -19,9 +19,7 @@ from .target import Target
 
 MACStr = Annotated[
     str,
-    StringConstraints(
-        max_length=17, pattern=r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
-    ),
+    StringConstraints(max_length=17, pattern=r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"),
 ]
 
 
@@ -65,23 +63,13 @@ class Observer(ShpModel, title="Shepherd-Sheep"):
         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 '{self.name}' is faulty " f"-> has targets but no cape"
-            )
+            raise ValueError(f"Observer '{self.name}' is faulty -> has targets but no cape")
         return self
 
     def has_target(self, target_id: int) -> bool:
-        if (
-            self.target_a is not None
-            and target_id == self.target_a.id
-            and self.target_a.active
-        ):
+        if self.target_a is not None and target_id == self.target_a.id and self.target_a.active:
             return True
-        if (
-            self.target_b is not None
-            and target_id == self.target_b.id
-            and self.target_b.active
-        ):
+        if self.target_b is not None and target_id == self.target_b.id and self.target_b.active:
             return True
         return False
 
@@ -91,9 +79,7 @@ class Observer(ShpModel, title="Shepherd-Sheep"):
                 return TargetPort.A
             if self.target_b is not None and target_id == self.target_b.id:
                 return TargetPort.B
-        raise ValueError(
-            f"Target-ID {target_id} was not found in Observer '{self.name}'"
-        )
+        raise ValueError(f"Target-ID {target_id} was not found in Observer '{self.name}'")
 
     def get_target(self, target_id: int) -> Target:
         if self.has_target(target_id):
@@ -101,6 +87,4 @@ class Observer(ShpModel, title="Shepherd-Sheep"):
                 return self.target_a
             if self.target_b is not None and target_id == self.target_b.id:
                 return self.target_b
-        raise ValueError(
-            f"Target-ID {target_id} was not found in Observer '{self.name}'"
-        )
+        raise ValueError(f"Target-ID {target_id} was not found in Observer '{self.name}'")

shepherd_core/data_models/testbed/testbed.py

@@ -87,6 +87,4 @@ class Testbed(ShpModel):
                 continue
             if _observer.has_target(target_id):
                 return _observer
-        raise ValueError(
-            f"Target-ID {target_id} was not found in Testbed '{self.name}'"
-        )
+        raise ValueError(f"Target-ID {target_id} was not found in Testbed '{self.name}'")

shepherd_core/decoder_waveform/uart.py

@@ -56,9 +56,7 @@ class Uart:
           (some detectors still missing)
         """
         if isinstance(content, Path):
-            self.events_sig: np.ndarray = np.loadtxt(
-                content.as_posix(), delimiter=",", skiprows=1
-            )
+            self.events_sig: np.ndarray = np.loadtxt(content.as_posix(), delimiter=",", skiprows=1)
             # TODO: if float fails load as str -
             #  cast first col as np.datetime64 with ns-resolution, convert to delta
         else:
@@ -66,9 +64,7 @@ class Uart:
 
         # verify table
         if self.events_sig.shape[1] != 2:
-            raise TypeError(
-                "Input file should have 2 rows -> (comma-separated) timestamp & value"
-            )
+            raise TypeError("Input file should have 2 rows -> (comma-separated) timestamp & value")
         if self.events_sig.shape[0] < 8:
             raise TypeError("Input file is too short (< state-changes)")
         # verify timestamps
@@ -80,23 +76,17 @@ class Uart:
         self._convert_analog2digital()
         self._filter_redundant_states()
 
-        self.baud_rate: int = (
-            baud_rate if baud_rate is not None else self.detect_baud_rate()
-        )
+        self.baud_rate: int = baud_rate if baud_rate is not None else self.detect_baud_rate()
         self.dur_tick: float = 1.0 / self.baud_rate
 
         self._add_duration()
 
-        self.inversion: bool = (
-            inversion if inversion is not None else self.detect_inversion()
-        )
+        self.inversion: bool = inversion if inversion is not None else self.detect_inversion()
         self.half_stop: bool = self.detect_half_stop()  # not needed ATM
 
         # TODO: add detectors
         self.parity: Parity = parity if parity is not None else Parity.no
-        self.bit_order: BitOrder = (
-            bit_order if bit_order is not None else BitOrder.lsb_first
-        )
+        self.bit_order: BitOrder = bit_order if bit_order is not None else BitOrder.lsb_first
         self.frame_length: int = frame_length if frame_length is not None else 8
 
         if not (0 < self.frame_length <= 64):
@@ -146,14 +136,10 @@ class Uart:
             logger.warning("Tried to add state-duration, but it seems already present")
             return
         if not hasattr(self, "dur_tick"):
-            raise ValueError(
-                "Make sure that baud-rate was calculated before running add_dur()"
-            )
+            raise ValueError("Make sure that baud-rate was calculated before running add_dur()")
         dur_steps = self.events_sig[1:, 0] - self.events_sig[:-1, 0]
         dur_steps = np.reshape(dur_steps, (dur_steps.size, 1))
-        self.events_sig = np.append(
-            self.events_sig[:-1, :], dur_steps / self.dur_tick, axis=1
-        )
+        self.events_sig = np.append(self.events_sig[:-1, :], dur_steps / self.dur_tick, axis=1)
 
     def detect_inversion(self) -> bool:
         """Analyze bit-state during long pauses (unchanged states)
@@ -182,16 +168,12 @@ class Uart:
     def detect_half_stop(self) -> bool:
         """Looks into the spacing between time-steps"""
         events = self.events_sig[:1000, :]  # speedup for large datasets
-        return (
-            np.sum((events > 1.333 * self.dur_tick) & (events < 1.667 * self.dur_tick))
-            > 0
-        )
+        return np.sum((events > 1.333 * self.dur_tick) & (events < 1.667 * self.dur_tick)) > 0
 
     def detect_dataframe_length(self) -> int:
         """Look after longest pauses
         - accumulate steps until a state with uneven step-size is found
         """
-        pass
 
     def get_symbols(self, *, force_redo: bool = False) -> np.ndarray:
         """Ways to detect EOF:

shepherd_core/fw_tools/__init__.py

@@ -25,9 +25,7 @@ except ImportError:
         "cffi",
     ]
     # only update when module is not avail
-    MOCK_MODULES = [
-        mod_name for mod_name in MOCK_MODULES if find_spec(mod_name) is None
-    ]
+    MOCK_MODULES = [mod_name for mod_name in MOCK_MODULES if find_spec(mod_name) is None]
     sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
 
 from .converter import base64_to_file

shepherd_core/fw_tools/converter.py

@@ -22,9 +22,7 @@ def firmware_to_hex(file_path: Path) -> Path:
         return elf_to_hex(file_path)
     if is_hex(file_path):
         return file_path
-    raise ValueError(
-        "FW2Hex: unknown file '%s', it should be ELF or HEX", file_path.name
-    )
+    raise ValueError("FW2Hex: unknown file '%s', it should be ELF or HEX", file_path.name)
 
 
 @validate_call
@@ -72,9 +70,7 @@ def base64_to_hash(content: str) -> str:
 
 
 @validate_call
-def extract_firmware(
-    data: Union[str, Path], data_type: FirmwareDType, file_path: Path
-) -> Path:
+def extract_firmware(data: Union[str, Path], data_type: FirmwareDType, file_path: Path) -> Path:
     """- base64-string will be transformed into file
     - if data is a path the file will be copied to the destination
     """
@@ -90,14 +86,10 @@ def extract_firmware(
         elif data_type == FirmwareDType.path_hex:
             file = file_path.with_suffix(".hex")
         else:
-            raise ValueError(
-                "FW-Extraction failed due to unknown datatype '%s'", data_type
-            )
+            raise ValueError("FW-Extraction failed due to unknown datatype '%s'", data_type)
         if not file.parent.exists():
             file.parent.mkdir(parents=True)
         shutil.copy(data, file)
     else:
-        raise ValueError(
-            "FW-Extraction failed due to unknown data-type '%s'", type(data)
-        )
+        raise ValueError("FW-Extraction failed due to unknown data-type '%s'", type(data))
     return file

shepherd_core/fw_tools/patcher.py

@@ -46,9 +46,7 @@ def find_symbol(file_elf: Path, symbol: str) -> bool:
 
 
 @validate_call
-def read_symbol(
-    file_elf: Path, symbol: str, length: int = uid_len_default
-) -> Optional[int]:
+def read_symbol(file_elf: Path, symbol: str, length: int = uid_len_default) -> Optional[int]:
     """Interpreted as int"""
     if not find_symbol(file_elf, symbol):
         return None
@@ -99,9 +97,7 @@ def modify_symbol_value(
     value_raw = elf.read(address=addr, count=uid_len_default)[-uid_len_default:]
     # ⤷ cutting needed -> msp produces 4b instead of 2
     value_old = int.from_bytes(bytes=value_raw, byteorder=elf.endian, signed=False)
-    value_raw = value.to_bytes(
-        length=uid_len_default, byteorder=elf.endian, signed=False
-    )
+    value_raw = value.to_bytes(length=uid_len_default, byteorder=elf.endian, signed=False)
     try:
         elf.write(address=addr, data=value_raw)
     except AttributeError:
@@ -110,9 +106,7 @@ def modify_symbol_value(
     if overwrite:
         file_new = file_elf
     else:
-        file_new = file_elf.with_name(
-            file_elf.stem + "_" + str(value) + file_elf.suffix
-        )
+        file_new = file_elf.with_name(file_elf.stem + "_" + str(value) + file_elf.suffix)
         # could be simplified, but py3.8-- doesn't know .with_stem()
     elf.save(path=file_new)
     elf.close()
@@ -127,6 +121,4 @@ def modify_symbol_value(
 
 
 def modify_uid(file_elf: Path, value: int) -> Optional[Path]:
-    return modify_symbol_value(
-        file_elf, symbol=uid_str_default, value=value, overwrite=True
-    )
+    return modify_symbol_value(file_elf, symbol=uid_str_default, value=value, overwrite=True)

shepherd_core/inventory/__init__.py

@@ -30,15 +30,9 @@ class Inventory(PythonInventory, SystemInventory, TargetInventory):
     @classmethod
     def collect(cls) -> Self:
         # one by one for more precise error messages
-        pid = PythonInventory.collect().model_dump(
-            exclude_unset=True, exclude_defaults=True
-        )
-        sid = SystemInventory.collect().model_dump(
-            exclude_unset=True, exclude_defaults=True
-        )
-        tid = TargetInventory.collect().model_dump(
-            exclude_unset=True, exclude_defaults=True
-        )
+        pid = PythonInventory.collect().model_dump(exclude_unset=True, exclude_defaults=True)
+        sid = SystemInventory.collect().model_dump(exclude_unset=True, exclude_defaults=True)
+        tid = TargetInventory.collect().model_dump(exclude_unset=True, exclude_defaults=True)
         model = {**pid, **sid, **tid}
         return cls(**model)