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

shepherd_core/inventory/system.py

@@ -53,11 +53,7 @@ class SystemInventory(ShpModel):
             )
         else:
             ifs1 = psutil.net_if_addrs().items()
-            ifs2 = {
-                name: (_if[1].address, _if[0].address)
-                for name, _if in ifs1
-                if len(_if) > 1
-            }
+            ifs2 = {name: (_if[1].address, _if[0].address) for name, _if in ifs1 if len(_if) > 1}
             uptime = time.time() - psutil.boot_time()
 
         model_dict = {
@@ -69,6 +65,7 @@ class SystemInventory(ShpModel):
             "processor": platform.processor(),
             "hostname": platform.node(),
             "interfaces": ifs2,
+            # TODO: add free space on /
         }
 
         with suppress(FileNotFoundError):

shepherd_core/logger.py

@@ -15,9 +15,7 @@ def get_verbose_level() -> int:
     return verbose_level
 
 
-def set_log_verbose_level(
-    log_: Union[logging.Logger, logging.Handler], verbose: int
-) -> None:
+def set_log_verbose_level(log_: Union[logging.Logger, logging.Handler], verbose: int) -> None:
     if verbose == 0:
         log_.setLevel(logging.ERROR)
         logging.basicConfig(level=logging.ERROR)

shepherd_core/reader.py

@@ -95,9 +95,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 +107,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 +116,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)
 
@@ -167,12 +161,11 @@ class Reader:
         """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,6 +178,7 @@ 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
@@ -195,25 +189,27 @@ class Reader:
             :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]),
                 )
@@ -339,20 +335,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'",
@@ -409,10 +405,10 @@ class Reader:
 
         :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 +416,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
@@ -439,9 +435,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 +453,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 {}
@@ -519,9 +512,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"]:
@@ -599,9 +590,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:
@@ -637,9 +626,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 +642,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/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,9 +40,7 @@ class TestbedClient:
         TestbedClient._instance = None
 
     @validate_call
-    def connect(
-        self, server: Optional[str] = None, token: Union[str, Path, None] = None
-    ) -> bool:
+    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
@@ -74,9 +70,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)
@@ -134,16 +128,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

@@ -148,16 +148,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,9 +168,7 @@ 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:
@@ -182,11 +176,7 @@ class Fixtures:
         self.components: Dict[str, Fixture] = {}
         save_path = self.file_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
             with save_path.open("rb", buffering=-1) as fd:
                 self.components = pickle.load(fd)  # noqa: S301

shepherd_core/testbed_client/user_model.py

@@ -19,9 +19,7 @@ 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(

shepherd_core/vsource/virtual_converter_model.py

@@ -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

@@ -93,9 +93,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

@@ -37,9 +37,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 +51,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
 

shepherd_core/writer.py

@@ -39,9 +39,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())))
 
 
 yaml.add_representer(pathlib.PosixPath, path2str, SafeDumper)
@@ -130,23 +128,20 @@ class Writer(Reader):
             base_dir = file_path.resolve().parents[0]
             self.file_path = unique_path(base_dir / file_path.stem, file_path.suffix)
             self._logger.warning(
-                "File '%s' already exists -> " "storing under '%s' instead",
+                "File '%s' already exists -> storing under '%s' instead",
                 file_path,
                 self.file_path.name,
             )
 
         if isinstance(mode, str) and mode not in self.mode_dtype_dict:
-            raise ValueError(
-                f"Can't handle mode '{mode}' " f"(choose one of {self.mode_dtype_dict})"
-            )
+            raise ValueError(f"Can't handle mode '{mode}' (choose one of {self.mode_dtype_dict})")
 
         _dtypes = self.mode_dtype_dict[mode if mode else self.mode_default]
         if isinstance(datatype, str):
             datatype = EnergyDType[datatype]
         if isinstance(datatype, EnergyDType) and datatype not in _dtypes:
             raise ValueError(
-                f"Can't handle value '{datatype}' of datatype "
-                f"(choose one of {_dtypes})"
+                f"Can't handle value '{datatype}' of datatype (choose one of {_dtypes})"
             )
 
         if self._modify:
@@ -158,9 +153,7 @@ class Writer(Reader):
             self._datatype = (
                 datatype if isinstance(datatype, EnergyDType) else self.datatype_default
             )
-            self._window_samples = (
-                window_samples if isinstance(window_samples, int) else 0
-            )
+            self._window_samples = window_samples if isinstance(window_samples, int) else 0
 
         if isinstance(cal_data, (CalEmu, CalHrv)):
             self._cal = CalSeries.from_cal(cal_data)
@@ -181,9 +174,7 @@ class Writer(Reader):
 
         # show key parameters for h5-performance
         settings = list(self.h5file.id.get_access_plist().get_cache())
-        self._logger.debug(
-            "H5Py Cache_setting=%s (_mdc, _nslots, _nbytes, _w0)", settings
-        )
+        self._logger.debug("H5Py Cache_setting=%s (_mdc, _nslots, _nbytes, _w0)", settings)
 
         # Store the mode in order to allow user to differentiate harvesting vs emulation data
         if isinstance(self._mode, str) and self._mode in self.mode_dtype_dict:
@@ -257,9 +248,7 @@ class Writer(Reader):
             compression=self._compression,
         )
         grp_data["time"].attrs["unit"] = "s"
-        grp_data["time"].attrs[
-            "description"
-        ] = "system time [s] = value * gain + (offset)"
+        grp_data["time"].attrs["description"] = "system time [s] = value * gain + (offset)"
 
         grp_data.create_dataset(
             "current",
@@ -309,7 +298,7 @@ class Writer(Reader):
         else:
             raise ValueError("timestamp-data was not usable")
 
-        len_old = self.ds_time.shape[0]
+        len_old = self.ds_voltage.shape[0]
 
         # resize dataset
         self.ds_time.resize((len_old + len_new,))
@@ -346,15 +335,15 @@ class Writer(Reader):
     def _align(self) -> None:
         """Align datasets with buffer-size of shepherd"""
         self._refresh_file_stats()
-        n_buff = self.ds_time.size / self.samples_per_buffer
+        n_buff = self.ds_voltage.size / self.samples_per_buffer
         size_new = int(math.floor(n_buff) * self.samples_per_buffer)
-        if size_new < self.ds_time.size:
+        if size_new < self.ds_voltage.size:
             if self.samplerate_sps != samplerate_sps_default:
                 self._logger.debug("skipped alignment due to altered samplerate")
                 return
             self._logger.info(
                 "aligning with buffer-size, discarding last %d entries",
-                self.ds_time.size - size_new,
+                self.ds_voltage.size - size_new,
             )
             self.ds_time.resize((size_new,))
             self.ds_voltage.resize((size_new,))

{shepherd_core-2023.11.1.dist-info → shepherd_core-2023.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd-core
-Version: 2023.11.1
+Version: 2023.12.1
 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
@@ -42,9 +42,6 @@ Requires-Dist: requests
 Requires-Dist: pyelftools
 Requires-Dist: zstandard
 Provides-Extra: dev
-Requires-Dist: black ; extra == 'dev'
-Requires-Dist: pylint ; extra == 'dev'
-Requires-Dist: flake8 ; extra == 'dev'
 Requires-Dist: twine ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'
 Requires-Dist: pyright ; extra == 'dev'
@@ -64,7 +61,7 @@ Requires-Dist: coverage ; extra == 'test'
 [![PyPiVersion](https://img.shields.io/pypi/v/shepherd_core.svg)](https://pypi.org/project/shepherd_core)
 [![image](https://img.shields.io/pypi/pyversions/shepherd_core.svg)](https://pypi.python.org/pypi/shepherd-core)
 [![Pytest](https://github.com/orgua/shepherd-datalib/actions/workflows/py_unittest.yml/badge.svg)](https://github.com/orgua/shepherd-datalib/actions/workflows/py_unittest.yml)
-[![CodeStyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![CodeStyle](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 **Documentation**: <https://orgua.github.io/shepherd/external/shepherd_core.html>