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

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)

tests/vsource/test_converter.py

@@ -1,161 +0,0 @@
-from pathlib import Path
-from typing import Optional
-
-import pytest
-from pytest import approx
-
-from shepherd_core import CalibrationEmulator
-from shepherd_core import Reader
-from shepherd_core.data_models import EnergyDType
-from shepherd_core.data_models import VirtualSourceConfig
-from shepherd_core.vsource import VirtualSourceModel
-
-# virtual_converter_model gets tested below with vsrc_model
-
-src_list = [
-    "direct",
-    "diode+capacitor",
-    "diode+resistor+capacitor",
-    "BQ25504",
-    "BQ25504s",
-    "BQ25570",
-    "BQ25570s",
-]
-
-
-def src_model(
-    name: str,
-    dtype_in: EnergyDType = EnergyDType.ivsample,
-    window_size: Optional[int] = None,
-) -> VirtualSourceModel:
-    src_config = VirtualSourceConfig(name=name)
-    cal_emu = CalibrationEmulator()
-    return VirtualSourceModel(
-        src_config,
-        cal_emu,
-        log_intermediate=False,
-        dtype_in=dtype_in,
-        window_size=window_size,
-    )
-
-
-def c_leak_fWs(src: VirtualSourceModel, iterations: int) -> float:
-    return iterations * src.cnv.V_mid_uV * src.cfg_src.I_intermediate_leak_nA
-
-
-@pytest.mark.parametrize("src_name", src_list)
-def test_vsource_vsrc_min(src_name: str) -> None:
-    src = src_model(src_name)
-    src.iterate_sampling()
-
-
-def test_vsource_vsrc_static1() -> None:
-    iterations = 2_000
-    src = src_model("BQ25504")
-    for _ in range(iterations):
-        src.iterate_sampling(V_inp_uV=3_000_000, I_inp_nA=0)
-    assert src.W_inp_fWs == 0.0
-    assert src.W_out_fWs == approx(c_leak_fWs(src, iterations), rel=1e-4, abs=1e-6)
-
-
-def test_vsource_vsrc_static2() -> None:
-    iterations = 2_000
-    src = src_model("BQ25504")
-    for _ in range(iterations):
-        src.iterate_sampling(V_inp_uV=0, I_inp_nA=3_000_000)
-    assert src.W_inp_fWs == 0.0
-    assert src.W_out_fWs == approx(c_leak_fWs(src, iterations), rel=1e-4, abs=1e-6)
-
-
-@pytest.mark.parametrize("src_name", src_list[2:])
-def test_vsource_charge(src_name: str) -> None:
-    iterations = 4_000
-    src = src_model(src_name)
-    for v_mV in range(iterations):
-        src.iterate_sampling(V_inp_uV=v_mV * 1000, I_inp_nA=1_000_000)
-    v_out = src.iterate_sampling(V_inp_uV=1_000_000, I_inp_nA=1_000_000)
-    assert src.W_inp_fWs > 0.0
-    assert src.W_out_fWs == approx(c_leak_fWs(src, iterations), rel=0.12, abs=1e-3)
-    assert v_out > 0.0
-
-
-@pytest.mark.parametrize("src_name", src_list[4:])
-def test_vsource_drain(src_name: str) -> None:
-    iterations = 4_000
-    src = src_model(src_name)
-    for c_uA in range(iterations):
-        src.iterate_sampling(I_out_nA=c_uA * 1000)
-    v_out = src.iterate_sampling()
-    assert src.W_inp_fWs == 0.0
-    assert src.W_out_fWs > c_leak_fWs(src, iterations)
-    assert v_out >= 0.0
-
-
-def test_vsource_vsrc_over_voltage() -> None:
-    iterations = 100
-    src = src_model("BQ25504")
-    for _ in range(iterations):
-        src.iterate_sampling(V_inp_uV=10 * 10**6, I_inp_nA=3_000_000)
-    assert src.cnv.V_input_uV <= 5 * 10**6
-    assert src.W_inp_fWs > 0.0
-
-
-def test_vsource_vsrc_over_current() -> None:
-    iterations = 100
-    src = src_model("BQ25504")
-    for _ in range(iterations):
-        src.iterate_sampling(V_inp_uV=5 * 10**6, I_inp_nA=100 * 10**6)
-    assert src.W_inp_fWs > 0.0
-
-
-def test_vsource_vsrc_cycle() -> None:
-    iterations = 2000
-    src = src_model("BQ25504s")
-
-    for _ in range(iterations):
-        src.iterate_sampling(V_inp_uV=5 * 10**6, I_inp_nA=4 * 10**6)
-    v_out = src.iterate_sampling()
-    assert v_out > 0
-
-    for _ in range(iterations):
-        src.iterate_sampling(I_out_nA=40 * 10**6)
-    v_out = src.iterate_sampling()
-    assert v_out == 0
-
-    for _ in range(iterations):
-        src.iterate_sampling(V_inp_uV=5 * 10**6, I_inp_nA=4 * 10**6)
-    v_out = src.iterate_sampling()
-    assert v_out > 0
-
-    assert src.W_out_fWs > 3 * c_leak_fWs(src, iterations)
-    assert src.W_inp_fWs > src.W_out_fWs
-
-
-def test_vsource_vsrc_create_files(
-    file_ivcurve: Path, file_ivsample: Path, file_isc_voc: Path
-) -> None:
-    pass
-
-
-@pytest.mark.parametrize("src_name", src_list)
-def test_vsource_vsrc_sim_curve(src_name: str, file_ivcurve: Path) -> None:
-    with Reader(file_ivcurve) as file:
-        window_size = file.get_window_samples()
-        dtype = file.get_datatype()
-        src = src_model("BQ25504s", dtype_in=dtype, window_size=window_size)
-        for _t, _v, _i in file.read_buffers():
-            length = max(_v.size, _i.size)
-            for _n in range(length):
-                src.iterate_sampling(V_inp_uV=_v[_n] * 10**6, I_inp_nA=_i[_n] * 10**9)
-
-
-@pytest.mark.parametrize("src_name", src_list)
-def test_vsource_vsrc_sim_sample(src_name: str, file_ivsample: Path) -> None:
-    with Reader(file_ivsample) as file:
-        window_size = file.get_window_samples()
-        dtype = file.get_datatype()
-        src = src_model("BQ25504s", dtype_in=dtype, window_size=window_size)
-        for _t, _v, _i in file.read_buffers():
-            length = max(_v.size, _i.size)
-            for _n in range(length):
-                src.iterate_sampling(V_inp_uV=_v[_n] * 10**6, I_inp_nA=_i[_n] * 10**9)

tests/vsource/test_harvester.py

@@ -1,73 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import Reader
-from shepherd_core.data_models import EnergyDType
-from shepherd_core.data_models import VirtualHarvesterConfig
-from shepherd_core.data_models.content.virtual_harvester import HarvesterPRUConfig
-from shepherd_core.vsource import VirtualHarvesterModel
-
-hrv_list = [
-    "ivcurve",
-    "iv1000",
-    "isc_voc",
-    "cv20",
-    "mppt_voc",
-    "mppt_bq",
-    "mppt_bq_solar",
-    "mppt_po",
-    "mppt_opt",
-]
-
-
-@pytest.mark.parametrize("hrv_name", hrv_list)
-def test_vsource_hrv_min(hrv_name: str) -> None:
-    hrv_config = VirtualHarvesterConfig(name=hrv_name)
-    hrv_pru = HarvesterPRUConfig.from_vhrv(hrv_config)
-    _ = VirtualHarvesterModel(hrv_pru)
-
-
-def test_vsource_hrv_create_files(
-    file_ivcurve: Path, file_ivsample: Path, file_isc_voc: Path
-) -> None:
-    pass
-
-
-@pytest.mark.parametrize("hrv_name", hrv_list[:3])
-def test_vsource_hrv_fail_ivcurve(hrv_name: str) -> None:
-    # the first algos are not usable for ivcurve
-    with pytest.raises(ValueError):
-        hrv_config = VirtualHarvesterConfig(name=hrv_name)
-        _ = HarvesterPRUConfig.from_vhrv(hrv_config, for_emu=True, dtype_in=EnergyDType.ivcurve)
-
-
-@pytest.mark.parametrize("hrv_name", hrv_list[3:])
-def test_vsource_hrv_sim(hrv_name: str, file_ivcurve: Path) -> None:
-    with Reader(file_ivcurve) as file:
-        hrv_config = VirtualHarvesterConfig(name=hrv_name)
-        hrv_pru = HarvesterPRUConfig.from_vhrv(
-            hrv_config,
-            for_emu=True,
-            dtype_in=file.get_datatype(),
-            window_size=file.get_window_samples(),
-        )
-        hrv = VirtualHarvesterModel(hrv_pru)
-        for _t, _v, _i in file.read_buffers():
-            length = max(_v.size, _i.size)
-            for _n in range(length):
-                hrv.ivcurve_sample(_voltage_uV=_v[_n] * 10**6, _current_nA=_i[_n] * 10**9)
-
-
-@pytest.mark.parametrize("hrv_name", hrv_list[3:])
-def test_vsource_hrv_fail_isc_voc(hrv_name: str) -> None:
-    # not implemented ATM
-    with pytest.raises(ValueError):
-        hrv_config = VirtualHarvesterConfig(name=hrv_name)
-        _ = HarvesterPRUConfig.from_vhrv(hrv_config, for_emu=True, dtype_in=EnergyDType.isc_voc)
-
-
-def test_vsource_hrv_fail_unknown_type() -> None:
-    with pytest.raises(KeyError):
-        hrv_config = VirtualHarvesterConfig(name="mppt_voc")
-        _ = HarvesterPRUConfig.from_vhrv(hrv_config, for_emu=True, dtype_in="xyz")

tests/vsource/test_z.py

@@ -1,5 +0,0 @@
-from pathlib import Path
-
-
-def test_vsource_cleanup(file_cleanup: Path) -> None:
-    pass