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

tests/test_examples.py

@@ -1,40 +0,0 @@
-import os
-import subprocess
-from pathlib import Path
-
-import pytest
-
-
-@pytest.fixture
-def example_path() -> Path:
-    path = Path(__file__).resolve().parent.parent / "examples"
-    os.chdir(path)
-    return path
-
-
-examples = [
-    "experiment_generic_var1.py",
-    "experiment_models.py",
-    "inventory.py",
-    "uart_decode_waveform.py",
-    "vharvester_simulation.py",
-    "vsource_simulation.py",
-]
-
-
-@pytest.mark.parametrize("file", examples)
-def test_example_scripts(example_path: Path, file: str) -> None:
-    subprocess.check_call(f"python {example_path / file}", shell=True)
-
-
-examples_fw = [
-    "firmware_model.py",
-    "firmware_modification.py",
-]
-
-
-@pytest.mark.converter
-@pytest.mark.elf
-@pytest.mark.parametrize("file", examples_fw)
-def test_example_scripts_fw(example_path: Path, file: str) -> None:
-    subprocess.check_call(f"python {example_path / file}", shell=True)

tests/test_logger.py

@@ -1,15 +0,0 @@
-import pytest
-
-from shepherd_core import get_verbose_level
-from shepherd_core import increase_verbose_level
-
-
-@pytest.mark.parametrize("log_level", range(-5, 10))
-def test_log_levels(log_level: int) -> None:
-    increase_verbose_level(log_level)
-    if log_level <= 2:
-        assert get_verbose_level() == 2
-    elif log_level <= 3:
-        assert get_verbose_level() == log_level
-    else:
-        assert get_verbose_level() == 3

tests/test_reader.py

@@ -1,283 +0,0 @@
-import sys
-from pathlib import Path
-
-import h5py
-import pytest
-import yaml
-
-from shepherd_core import Reader
-from shepherd_core import Writer
-
-
-def test_reader_metadata(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.energy() > 0
-        assert sfr.is_valid()
-
-        meta_data_a = sfr.save_metadata()
-        meta_path = data_h5.resolve().with_suffix(".yaml")
-        assert meta_path.exists()
-        with meta_path.open() as meta_file:
-            meta_data_b = yaml.safe_load(meta_file)
-            assert len(meta_data_b) == len(meta_data_a)
-            assert sys.getsizeof(meta_data_b) == sys.getsizeof(meta_data_a)
-
-
-def test_reader_items(data_h5: Path) -> None:
-    """Access internal"""
-    with Reader(data_h5, verbose=True) as sfr:
-        _ = sfr["data"]  # group
-        _ = sfr["mode"]  # attribute
-        with pytest.raises(KeyError):
-            _ = sfr["non-existing"]
-
-
-def test_reader_open(tmp_path: Path) -> None:
-    with pytest.raises(TypeError):
-        Reader(file_path=None)
-
-    tmp_file = (tmp_path / "data.h5").resolve()
-
-    with pytest.raises(FileNotFoundError):
-        Reader(file_path=tmp_file)
-
-    with tmp_file.open("w") as tf:
-        tf.write("abc def ghi")
-    with pytest.raises(TypeError):
-        Reader(file_path=tmp_file)
-
-
-def test_reader_meta_repr(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        print(sfr)
-        print(sfr.get_calibration_data())
-        print(sfr.get_hrv_config())
-
-
-def test_reader_read_open_end(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers():
-            print(len(buf[0]))
-
-
-def test_reader_read_5(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers(end_n=5):
-            print(len(buf[0]))
-
-
-def test_reader_read_start_late(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers(start_n=2):
-            print(len(buf[0]))
-
-
-def test_reader_read_raw(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers(is_raw=True):
-            print(len(buf[0]))
-
-
-def test_reader_non_valid(tmp_path: Path) -> None:
-    data_h5 = tmp_path / "data.h5"
-    with h5py.File(data_h5, "w") as h5f:
-        grp_data = h5f.create_group("data")
-        grp_data.create_dataset("time", (0,))
-        grp_data.create_dataset("current", (0,))
-        grp_data.create_dataset("voltage", (0,))
-        grp_data["time"].attrs["gain"] = 1
-        grp_data["current"].attrs["gain"] = 1
-        grp_data["voltage"].attrs["gain"] = 1
-        grp_data["time"].attrs["offset"] = 0
-        grp_data["current"].attrs["offset"] = 0
-        grp_data["voltage"].attrs["offset"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        # try getting metadata -> no exception but safe defaults
-        sfr.get_window_samples()
-        sfr.get_mode()
-        sfr.get_mode()
-        sfr.get_hostname()
-        sfr.get_datatype()
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_path(tmp_path: Path) -> None:
-    with pytest.raises(FileNotFoundError):
-        Reader(tmp_path, verbose=True)
-
-
-def test_reader_fault_no_data(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_mode(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file.attrs["mode"]
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_fake_mode(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file.attrs["mode"] = "burning"
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_no_window_samples(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"].attrs["window_samples"]
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_no_datatype(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"].attrs["datatype"]
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_wrong_datatype(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file["data"].attrs["datatype"] = "apples"
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_wrong_window1(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw["data"].attrs["datatype"] = "ivcurve"
-        sfw["data"].attrs["window_samples"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_wrong_window2(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw["data"].attrs["datatype"] = "ivsample"
-        sfw["data"].attrs["window_samples"] = 1111
-    with Reader(data_h5, verbose=True) as sfr:
-        # only triggers warning
-        assert sfr.is_valid()
-
-
-def test_reader_fault_no_current(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["current"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_voltage(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["voltage"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_gain(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["time"].attrs["gain"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_offset(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["time"].attrs["offset"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_non_eq_time(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file["data"]["time"].resize((0,))
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_unaligned(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        new_size = sfw.samples_per_buffer / 2
-        sfw.h5file["data"]["time"].resize((new_size,))
-        sfw.h5file["data"]["voltage"].resize((new_size,))
-        sfw.h5file["data"]["current"].resize((new_size,))
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_strange_compression(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        time = sfw.h5file["data"]["time"][:]
-        del sfw.h5file["data"]["time"]
-        sfw.h5file["data"].create_dataset(
-            "time",
-            (0,),
-            dtype="u8",
-            maxshape=(None,),
-            compression="lzf",  # something like szip wanted
-        )
-        sfw.h5file["data"]["time"].resize(time.shape)
-        sfw.h5file["data"]["time"][0 : time.shape[0]] = time[: time.shape[0]]
-        sfw.h5file["data"]["time"].attrs["gain"] = 1
-        sfw.h5file["data"]["time"].attrs["offset"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_slow_compression(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        time = sfw.h5file["data"]["time"][:]
-        del sfw.h5file["data"]["time"]
-        sfw.h5file["data"].create_dataset(
-            "time",
-            (0,),
-            dtype="u8",
-            maxshape=(None,),
-            compression="gzip",
-            compression_opts=9,
-        )
-        sfw.h5file["data"]["time"].resize(time.shape)
-        sfw.h5file["data"]["time"][0 : time.shape[0]] = time[: time.shape[0]]
-        sfw.h5file["data"]["time"].attrs["gain"] = 1
-        sfw.h5file["data"]["time"].attrs["offset"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_no_hostname(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file.attrs["hostname"] = "unknown"
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_jumps_timestamp(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.check_timediffs()
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file["data"]["time"][sfw.samples_per_buffer] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.check_timediffs()
-
-
-def test_reader_save_meta(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.save_metadata() != {}
-        # yaml now already exists
-        assert sfr.save_metadata() == {}
-
-
-def test_reader_save_meta_fail(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        sfr.file_path = None
-        assert sfr.save_metadata() == {}

tests/test_writer.py

@@ -1,169 +0,0 @@
-from pathlib import Path
-from typing import Optional
-from typing import Union
-
-import numpy as np
-import pytest
-
-from shepherd_core import Reader
-from shepherd_core import Writer
-from shepherd_core.data_models import CalibrationEmulator as CalEmu
-from shepherd_core.data_models import CalibrationHarvester as CalHrv
-from shepherd_core.data_models import CalibrationSeries as CalSeries
-from shepherd_core.data_models.task import Compression
-
-
-def generate_shp_file(
-    store_path: Path,
-    mode: Optional[str] = None,
-    datatype: Optional[str] = None,
-    window_samples: Optional[int] = None,
-    cal_data: Union[CalSeries, CalEmu, CalHrv, None] = None,
-    config: Optional[dict] = None,
-    compression: Optional[Compression] = Compression.default,
-    hostname: str = "unknown",
-) -> Path:
-    if config is None:
-        config = {}
-    with Writer(
-        store_path,
-        mode=mode,
-        datatype=datatype,
-        window_samples=window_samples,
-        cal_data=cal_data,
-        compression=compression,
-        verbose=True,
-    ) as file:
-        file.store_hostname(hostname)
-        file.store_config(config)
-        duration_s = 2
-        timestamps = np.arange(0.0, duration_s, file.sample_interval_ns / 1e9)
-        voltages = np.linspace(3.60, 1.90, int(file.samplerate_sps * duration_s))
-        currents = np.linspace(100e-6, 2000e-6, int(file.samplerate_sps * duration_s))
-        file.append_iv_data_si(timestamps, voltages, currents)
-    return store_path
-
-
-@pytest.fixture
-def h5_path(tmp_path: Path) -> Path:
-    return tmp_path / "hrv_test.h5"
-
-
-@pytest.fixture
-def h5_file(h5_path: Path) -> Path:
-    generate_shp_file(h5_path)
-    return h5_path
-
-
-def test_writer_basics(h5_path: Path) -> None:
-    generate_shp_file(h5_path)
-    with Reader(h5_path, verbose=True) as file:
-        assert round(file.runtime_s) == 2
-        assert file.get_window_samples() == 0
-        assert file.get_mode() == "harvester"
-        assert file.get_config() == {}
-        assert file.get_datatype() == "ivsample"
-        assert file.get_hostname() == "unknown"
-
-
-def test_writer_compression_1(h5_path: Path) -> None:
-    generate_shp_file(h5_path, compression=Compression.gzip1)
-
-
-def test_writer_unique_path(h5_file: Path) -> None:
-    with Writer(h5_file) as sfw:
-        assert sfw.file_path != h5_path
-
-
-def test_writer_faulty_mode(h5_path: Path) -> None:
-    with pytest.raises(ValueError):
-        generate_shp_file(h5_path, mode="excavator", datatype="ivcurve")
-
-
-def test_writer_faulty_datatype(h5_path: Path) -> None:
-    with pytest.raises(ValueError):
-        generate_shp_file(h5_path, mode="emulator", datatype="ivcurve")
-
-
-def test_writer_faulty_path(tmp_path: Path) -> None:
-    with pytest.raises(TypeError):
-        generate_shp_file(tmp_path)
-
-
-def test_writer_modify(h5_file: Path) -> None:
-    with Writer(h5_file, modify_existing=True) as sfw:
-        sfw.store_hostname("sheep")
-
-
-def test_writer_init_cal_emu(h5_path: Path) -> None:
-    generate_shp_file(h5_path, cal_data=CalEmu())
-
-
-def test_writer_init_cal_hrv(h5_path: Path) -> None:
-    generate_shp_file(h5_path, cal_data=CalHrv())
-
-
-def test_writer_init_cal_series(h5_path: Path) -> None:
-    cs = CalSeries.from_cal(CalHrv())
-    generate_shp_file(h5_path, cal_data=cs)
-
-
-def test_writer_faulty_window(h5_path: Path) -> None:
-    with pytest.raises(ValueError):
-        generate_shp_file(h5_path, mode="harvester", datatype="ivcurve")
-    with pytest.raises(ValueError):
-        generate_shp_file(
-            h5_path,
-            mode="harvester",
-            datatype="ivcurve",
-            window_samples=0,
-        )
-
-
-def test_writer_append_raw(h5_path: Path) -> None:
-    with Writer(h5_path) as sfw:
-        data_nd = np.zeros((sfw.samples_per_buffer,))
-        time_float = 5.5
-        time_int = 3
-        time_nd = 3 + data_nd
-        sfw.append_iv_data_raw(time_float, data_nd, data_nd)
-        sfw.append_iv_data_raw(time_int, data_nd, data_nd)
-        sfw.append_iv_data_raw(time_nd, data_nd, data_nd)
-        with pytest.raises(ValueError):
-            sfw.append_iv_data_raw(None, data_nd, data_nd)
-
-
-def test_writer_align(h5_path: Path) -> None:
-    with Writer(h5_path) as sfw:
-        length = int(5.5 * sfw.samples_per_buffer)
-        time_nd = np.arange(0, length * sfw.sample_interval_ns, sfw.sample_interval_ns)
-        data_nd = np.zeros((int(length),))
-        sfw.append_iv_data_raw(time_nd, data_nd, data_nd)
-    with Reader(h5_path) as sfr:
-        assert sfr.ds_voltage.size < length
-
-
-def test_writer_not_align(h5_path: Path) -> None:
-    with Writer(h5_path) as sfw:
-        length = int(5.5 * sfw.samples_per_buffer)
-        sample_interval = 10 * sfw.sample_interval_ns
-        time_nd = np.arange(0, length * sample_interval, sample_interval)
-        data_nd = np.zeros((int(length),))
-        sfw.append_iv_data_raw(time_nd, data_nd, data_nd)
-    with Reader(h5_path) as sfr:
-        assert sfr.ds_voltage.size == length
-
-
-def test_writer_setter(h5_path: Path) -> None:
-    name = "pingu"
-    with Writer(h5_path) as sfw:
-        sfw["hostname"] = name
-    with Reader(h5_path) as sfr:
-        assert sfr.get_hostname() == name
-
-
-# TODO:
-#  - test writing different and confirming them
-#  - different compressions and their size relative to each other
-#  - also invalid
-#  - read raw-data

tests/vsource/conftest.py

@@ -1,49 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-
-from shepherd_data import ivonne
-from shepherd_data import mppt
-
-
-@pytest.fixture
-def file_ivonne() -> Path:
-    path = Path(__file__).resolve().parent.parent.parent.parent / "shepherd_data/examples"
-    os.chdir(path)
-    return path / "./jogging_10m.iv"
-
-
-@pytest.fixture
-def file_isc_voc(file_ivonne: Path) -> Path:
-    path = file_ivonne.parent / "jogging_10m_isc_voc.h5"
-    if not path.exists():
-        with ivonne.Reader(file_ivonne) as db:
-            db.upsample_2_isc_voc(path, duration_s=1)
-    return path
-
-
-@pytest.fixture
-def file_ivcurve(file_ivonne: Path) -> Path:
-    path = file_ivonne.parent / "jogging_10m_ivcurve.h5"
-    if not path.exists():
-        with ivonne.Reader(file_ivonne) as db:
-            db.convert_2_ivcurves(path, duration_s=1)
-    return path
-
-
-@pytest.fixture
-def file_ivsample(file_ivonne: Path) -> Path:
-    path = file_ivonne.parent / "jogging_10m_ivsample.h5"
-    if not path.exists():
-        with ivonne.Reader(file_ivonne) as db:
-            tr_opt = mppt.OptimalTracker()
-            db.convert_2_ivsamples(path, tracker=tr_opt, duration_s=1)
-    return path
-
-
-@pytest.fixture
-def file_cleanup(file_isc_voc: Path, file_ivcurve: Path, file_ivsample: Path) -> None:
-    file_isc_voc.unlink(missing_ok=True)
-    file_ivcurve.unlink(missing_ok=True)
-    file_ivsample.unlink(missing_ok=True)