shepherd-core 2025.10.1__py3-none-any.whl → 2026.2.1__py3-none-any.whl

shepherd_core/inventory/__init__.py

@@ -10,6 +10,7 @@ from datetime import datetime
 from datetime import timedelta
 from pathlib import Path
 from typing import Annotated
+from typing import final
 
 from pydantic import Field
 from typing_extensions import Self
@@ -29,6 +30,7 @@ __all__ = [
 ]
 
 
+@final
 class Inventory(PythonInventory, SystemInventory, TargetInventory):
     """Complete inventory for one device.
 
@@ -65,7 +67,7 @@ class InventoryList(ShpModel):
         np.concatenate(content).reshape((len(content), len(content[0]))).
         """
         if path.is_dir():
-            path = path / "inventory.yaml"
+            path /= "inventory.yaml"
         with path.resolve().open("w") as fd:
             fd.write(", ".join(self.elements[0].model_dump().keys()) + "\r\n")
             for item in self.elements:
@@ -75,28 +77,28 @@ class InventoryList(ShpModel):
 
     def warn(self) -> dict:
         warnings = {}
-        ts_earl = min([_e.created.timestamp() for _e in self.elements])
-        for _e in self.elements:
-            if _e.uptime > timedelta(hours=30).total_seconds():
-                warnings["uptime"] = f"[{self.hostname}] restart is recommended"
-            if (_e.created.timestamp() - ts_earl) > 10:
-                warnings["time_delta"] = f"[{self.hostname}] time-sync has failed"
+        ts_earl = min(e_.created.timestamp() for e_ in self.elements)
+        for e_ in self.elements:
+            if e_.uptime > timedelta(hours=30).total_seconds():
+                warnings["uptime"] = f"[{e_.hostname}] restart is recommended"
+            if (e_.created.timestamp() - ts_earl) > 10:
+                warnings["time_delta"] = f"[{e_.hostname}] time-sync has failed"
 
         # turn  dict[hostname][type] = val
         # to    dict[type][val] = list[hostnames]
-        _inp = {
-            _e.hostname: _e.model_dump(exclude_unset=True, exclude_defaults=True)
-            for _e in self.elements
+        inp_ = {
+            e_.hostname: e_.model_dump(exclude_unset=True, exclude_defaults=True)
+            for e_ in self.elements
         }
         result = {}
-        for _host, _types in _inp.items():
-            for _type, _val in _types.items():
-                if _type not in result:
-                    result[_type] = {}
-                if _val not in result[_type]:
-                    result[_type][_val] = []
-                result[_type][_val].append(_host)
-        rescnt = {_key: len(_val) for _key, _val in result.items()}
+        for host_, types_ in inp_.items():
+            for type_, val_ in types_.items():
+                if type_ not in result:
+                    result[type_] = {}
+                if val_ not in result[type_]:
+                    result[type_][val_] = []
+                result[type_][val_].append(host_)
+        rescnt = {key_: len(val_) for key_, val_ in result.items()}
         t_unique = [
             "h5py",
             "numpy",
@@ -107,9 +109,9 @@ class InventoryList(ShpModel):
             "yaml",
             "zstandard",
         ]
-        for _key in t_unique:
-            if rescnt[_key] > 1:
-                warnings[_key] = f"[{_key}] VersionMismatch - {result[_key]}"
+        for key_ in t_unique:
+            if rescnt[key_] > 1:
+                warnings[key_] = f"[{key_}] VersionMismatch - {result[key_]}"
 
         # TODO: finish with more potential warnings
         return warnings

shepherd_core/inventory/system.py

@@ -63,12 +63,12 @@ class SystemInventory(ShpModel):
             uptime = 0
             log.warning(
                 "Inventory-Parameters will be missing. "
-                "Please install functionality with "
+                "Please install functionality with i.e."
                 "'pip install shepherd_core[inventory] -U' first"
             )
         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()
 
         fs_cmd = ["/usr/bin/df", "-h", "/"]

shepherd_core/logger.py

@@ -1,7 +1,6 @@
 """Log handler of shepherd."""
 
 import logging
-import logging.handlers
 
 import chromalog
 

shepherd_core/reader.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from types import MappingProxyType
 from typing import TYPE_CHECKING
 from typing import Any
+from typing import final
 
 import h5py
 import numpy as np
@@ -26,7 +27,7 @@ from .config import config
 from .data_models.base.calibration import CalibrationPair
 from .data_models.base.calibration import CalibrationSeries
 from .data_models.base.timezone import local_tz
-from .data_models.content.energy_environment import EnergyDType
+from .data_models.content.enum_datatypes import EnergyDType
 from .decoder_waveform import Uart
 
 if TYPE_CHECKING:
@@ -46,7 +47,7 @@ class Reader:
 
     """
 
-    CHUNK_SAMPLES_N: int = 10_000
+    CHUNK_SAMPLES_N: final[int] = 10_000
 
     MODE_TO_DTYPE: Mapping[str, Sequence[EnergyDType]] = MappingProxyType(
         {
@@ -101,9 +102,9 @@ class Reader:
             try:
                 self.h5file = h5py.File(self.file_path, "r")  # = readonly
                 self._reader_opened = True
-            except OSError as _xcp:
+            except OSError as xcp:
                 msg = f"Unable to open HDF5-File '{self.file_path.name}'"
-                raise TypeError(msg) from _xcp
+                raise TypeError(msg) from xcp
 
             if self.is_valid():
                 self._logger.debug("File is available now")
@@ -209,13 +210,14 @@ class Reader:
         Generator - can be configured on first call
 
         Args:
-        ----
-            :param start_n: (int) Index of first chunk to be read
-            :param end_n: (int) Index of last chunk to be read
-            :param n_samples_per_chunk: (int) allows changing
-            :param is_raw: (bool) output original data, not transformed to SI-Units
-            :param omit_timestamps: (bool) optimize reading if timestamp is never used
-        Yields: chunks between start and end (tuple with time, voltage, current)
+            start_n: (int) Index of first chunk to be read
+            end_n: (int) Index of last chunk to be read
+            n_samples_per_chunk: (int) allows changing
+            is_raw: (bool) output original data, not transformed to SI-Units
+            omit_timestamps: (bool) optimize reading if timestamp is never used
+
+        Yields:
+            chunks between start and end (tuple with time, voltage, current)
 
         """
         if n_samples_per_chunk is None:
@@ -223,21 +225,21 @@ class Reader:
         end_max = int(self.samples_n // n_samples_per_chunk)
         end_n = end_max if end_n is None else min(end_n, end_max)
         self._logger.debug("Reading chunk %d to %d from source-file", start_n, end_n)
-        _raw = is_raw
-        _wts = not omit_timestamps
+        raw_ = is_raw
+        wts_ = not omit_timestamps
 
         for i in range(start_n, end_n):
             idx_start = i * n_samples_per_chunk
             idx_end = idx_start + n_samples_per_chunk
-            if _raw:
+            if raw_:
                 yield (
-                    self.ds_time[idx_start:idx_end] if _wts else None,
+                    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]) if _wts else None,
+                    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]),
                 )
@@ -315,11 +317,11 @@ class Reader:
             self.get_config().get("virtual_harvester", {}).get("voltage_step_mV", None)
         )
         if voltage_step is not None:  # convert mV to V
-            voltage_step = 1e-3 * voltage_step
+            voltage_step *= 1e-3
         if voltage_step is None:
             dsv = self._cal.voltage.raw_to_si(self.ds_voltage[0:2000])
             diffs_np = np.unique(dsv[1:] - dsv[0:-1], return_counts=False)
-            diffs_ls = [_e for _e in list(np.array(diffs_np)) if _e > 0]
+            diffs_ls = [e_ for e_ in list(np.array(diffs_np)) if e_ > 0]
             # static voltages have 0 steps, so
             if len(diffs_ls) == 0:
                 self._logger.warning("Voltage-Step could not be determined from source-material")
@@ -457,11 +459,11 @@ class Reader:
                 "[FileValidation] Hostname was not set in '%s'", self.file_path.name
             )
         # errors during execution
-        _err = self.count_errors_in_log()
-        if _err > 0:
+        err_ = self.count_errors_in_log()
+        if err_ > 0:
             self._logger.warning(
                 "[FileValidation] Sheep reported %d errors during execution -> check logs in '%s'",
-                _err,
+                err_,
                 self.file_path.name,
             )
         return True
@@ -484,6 +486,8 @@ class Reader:
         # multiprocessing: https://stackoverflow.com/a/71898911
         # -> failed with multiprocessing.pool and pathos.multiprocessing.ProcessPool.
 
+        TODO: add optional duration argument to allow calculating mean energy of a spatial EEnv
+
         :return: sampled energy in Ws (watt-seconds)
         """
         iterations = math.ceil(self.samples_n / self.max_elements)
@@ -603,11 +607,11 @@ class Reader:
             return 0
         if "level" not in self.h5file[group_name]:
             return 0
-        _lvl = self.h5file[group_name]["level"]
-        if _lvl.shape[0] < 1:
+        lvl_ = self.h5file[group_name]["level"]
+        if lvl_.shape[0] < 1:
             return 0
-        _items = [1 for _x in _lvl[:] if _x >= min_level]
-        return len(_items)
+        items_ = [1 for x_ in lvl_[:] if x_ >= min_level]
+        return len(items_)
 
     def get_metadata(
         self,

shepherd_core/testbed_client/cache_path.py

@@ -5,10 +5,10 @@ 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 == "":
+    value_ = os.environ.get(variable_name)
+    if not value_:  # catches None and ""
         return default_path
-    return Path(_value)
+    return Path(value_)
 
 
 user_path = Path("~").expanduser()

shepherd_core/testbed_client/client_abc_fix.py

@@ -18,9 +18,11 @@ TODO: Comfort functions missing
 from abc import ABC
 from abc import abstractmethod
 from typing import Any
+from typing import final
 
 from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.data_models.base.wrapper import Wrapper
+from shepherd_core.logger import log
 
 from .fixtures import Fixtures
 
@@ -58,6 +60,7 @@ class AbcClient(ABC):
         # TODO: maybe internal? yes
         pass
 
+    @final
     def try_completing_model(
         self, model_type: str, values: dict[str, Any]
     ) -> tuple[dict[str, Any], list[str]]:
@@ -71,14 +74,18 @@ class AbcClient(ABC):
             except ValueError as err:
                 msg = f"Query {model_type} by name / ID failed - {values} is unknown!"
                 raise ValueError(msg) from err
+            except KeyError:
+                log.error(f"Query failed - model-type {model_type} is unknown")
+                return values, []
         return self.try_inheritance(model_type, values)
 
     @abstractmethod
     def fill_in_user_data(self, values: dict[str, Any]) -> dict[str, Any]:
-        # TODO: is it really helpful and needed?
+        # TODO: is it really needed and helpful?
         pass
 
 
+@final
 class FixturesClient(AbcClient):
     """Client-Class to access the file based fixtures."""
 
@@ -110,12 +117,16 @@ class FixturesClient(AbcClient):
     def try_inheritance(
         self, model_type: str, values: dict[str, Any]
     ) -> tuple[dict[str, Any], list[str]]:
-        return self._fixtures[model_type].inheritance(values)
+        try:
+            return self._fixtures[model_type].inheritance(values)
+        except KeyError:
+            log.error(f"Query failed - model-type {model_type} is unknown")
+            return values, []
 
     def fill_in_user_data(self, values: dict[str, Any]) -> dict[str, Any]:
         """Add fake user-data when offline-client is used.
 
-        Hotfix until WebClient is working.
+        Workaround until WebClient is working.
         """
         if values.get("owner") is None:
             values["owner"] = "unknown"

shepherd_core/testbed_client/client_web.py

@@ -3,6 +3,7 @@
 from importlib import import_module
 from pathlib import Path
 from typing import Any
+from typing import final
 
 from pydantic import validate_call
 
@@ -14,6 +15,7 @@ from .client_abc_fix import AbcClient
 from .user_model import User
 
 
+@final
 class WebClient(AbcClient):
     """Client-Class to access a testbed instance over the web.
 
@@ -125,26 +127,26 @@ class WebClient(AbcClient):
         return False
 
     def submit_experiment(self, xp: ShpModel) -> str:
-        """Transmit XP to server to validate its feasibility.
+        """Transmit experiment to server to validate its feasibility.
 
         - Experiment will be added to DB (if not present)
-            - if the same experiment is resubmitted it will just return the ID of that XP
+            - if the same experiment is resubmitted it will just return the ID of that experiment
         - Experiment will be validated by converting it into a task-set (additional validation)
         - optional: the scheduler should validate there are no time-collisions
 
         Will return an ID if valid, otherwise an empty string.
         TODO: maybe its better to throw specific errors if validation fails
-        TODO: is it better to include these experiment-related FNs in Xp-Class?
+        TODO: is it better to include these experiment-related FNs in experiment-Class?
         TODO: Experiment-typehint for argument triggers circular import
         """
         raise NotImplementedError("TODO")
 
     def schedule_experiment(self, id_xp: str) -> bool:
-        """Enqueue XP on testbed."""
+        """Enqueue experiment on testbed."""
         raise NotImplementedError("TODO")
 
     def get_experiment_status(self, id_xp: str) -> str:
-        """Ask server about current state of XP.
+        """Ask server about current state of experiment.
 
         - after valid submission: disabled / deactivated
         - after scheduling: scheduled

shepherd_core/testbed_client/fixtures.py

@@ -48,10 +48,10 @@ class Fixture:
         if "name" not in data.parameters:
             return
         name = str(data.parameters["name"]).lower()
-        _id = data.parameters["id"]
+        id_ = data.parameters["id"]
         data_model = data.parameters
         self.elements_by_name[name] = data_model
-        self.elements_by_id[_id] = data_model
+        self.elements_by_id[id_] = data_model
         # update iterator
         self._iter_list: list[dict[str, Any]] = list(self.elements_by_name.values())
 
@@ -84,7 +84,7 @@ class Fixture:
         return self.elements_by_name.keys()
 
     def refs(self) -> dict:
-        return {_i["id"]: _i["name"] for _i in self.elements_by_id.values()}
+        return {i_["id"]: i_["name"] for i_ in self.elements_by_id.values()}
 
     def inheritance(
         self, values: dict[str, Any], chain: list[str] | None = None
@@ -123,8 +123,8 @@ class Fixture:
             post_process = True
 
         elif values.get("id") in self.elements_by_id:
-            _id = values["id"]
-            fixture_base = copy.copy(self.elements_by_id[_id])
+            id_ = values["id"]
+            fixture_base = copy.copy(self.elements_by_id[id_])
             post_process = True
 
         if post_process:
@@ -218,7 +218,7 @@ class Fixtures:
 
     @validate_call
     def insert_file(self, file: Path) -> None:
-        with file.open() as fd:
+        with file.open(encoding="utf-8-sig") as fd:
             fixtures = yaml.safe_load(fd)
             for fixture in fixtures:
                 if not isinstance(fixture, dict):
@@ -237,7 +237,7 @@ class Fixtures:
         if key in self.components:
             return self.components[key]
         msg = f"Component '{key}' not found!"
-        raise ValueError(msg)
+        raise KeyError(msg)
 
     def keys(self) -> Iterable[str]:
         return self.components.keys()

shepherd_core/version.py

@@ -1,3 +1,3 @@
 """Separated string avoids circular imports."""
 
-version: str = "2025.10.1"
+version: str = "2026.02.1"

shepherd_core/vsource/virtual_converter_model.py

@@ -35,7 +35,7 @@ class PruCalibration:
     negative_residue_nA = 0
 
     def __init__(self, cal_emu: CalibrationEmulator | None = None) -> None:
-        self.cal = cal_emu if cal_emu else CalibrationEmulator()
+        self.cal = cal_emu or CalibrationEmulator()
 
     def conv_adc_raw_to_nA(self, current_raw: int) -> float:
         I_nA = self.cal.adc_C_A.raw_to_si(current_raw) * (10**9)
@@ -44,7 +44,7 @@ class PruCalibration:
                 I_nA -= self.negative_residue_nA
                 self.negative_residue_nA = 0
             else:
-                self.negative_residue_nA = self.negative_residue_nA - I_nA
+                self.negative_residue_nA -= I_nA
                 self.negative_residue_nA = min(self.negative_residue_nA, self.RESIDUE_MAX_nA)
                 I_nA = 0
         return I_nA

shepherd_core/vsource/virtual_harvester_model.py

@@ -152,7 +152,7 @@ class VirtualHarvesterModel:
         return self.voltage_hold, self.current_hold
 
     def ivcurve_2_mppt_voc(self, _voltage_uV: int, _current_nA: int) -> tuple[int, int]:
-        self.interval_step = self.interval_step + 1
+        self.interval_step += 1
         if self.interval_step >= self._cfg.interval_n:
             self.interval_step = 0
         self.age_nxt += 1
@@ -183,7 +183,7 @@ class VirtualHarvesterModel:
         return _voltage_uV, _current_nA
 
     def ivcurve_2_mppt_po(self, _voltage_uV: int, _current_nA: int) -> tuple[int, int]:
-        self.interval_step = self.interval_step + 1
+        self.interval_step += 1
         if self.interval_step >= self._cfg.interval_n:
             self.interval_step = 0
 

shepherd_core/vsource/virtual_harvester_simulation.py

@@ -52,20 +52,20 @@ def simulate_harvester(
         hrv = VirtualHarvesterModel(hrv_pru)
         e_out_Ws = 0.0
 
-        for _t, v_inp, i_inp in tqdm(
+        for t_, v_inp, i_inp in tqdm(
             file_inp.read(is_raw=True), total=file_inp.chunks_n, desc="Chunk", leave=False
         ):
             v_uV = cal_inp.voltage.raw_to_si(v_inp) * 1e6
             i_nA = cal_inp.current.raw_to_si(i_inp) * 1e9
             length = min(v_uV.size, i_nA.size)
-            for _n in range(length):
-                v_uV[_n], i_nA[_n] = hrv.ivcurve_sample(
-                    _voltage_uV=int(v_uV[_n]), _current_nA=int(i_nA[_n])
+            for n_ in range(length):
+                v_uV[n_], i_nA[n_] = hrv.ivcurve_sample(
+                    _voltage_uV=int(v_uV[n_]), _current_nA=int(i_nA[n_])
                 )
             e_out_Ws += (v_uV * i_nA).sum() * 1e-15 * file_inp.sample_interval_s
             if path_output:
                 v_out = cal_out.voltage.si_to_raw(v_uV / 1e6)
                 i_out = cal_out.current.si_to_raw(i_nA / 1e9)
-                file_out.append_iv_data_raw(_t, v_out, i_out)
+                file_out.append_iv_data_raw(t_, v_out, i_out)
 
     return e_out_Ws

shepherd_core/vsource/virtual_source_model.py

@@ -11,7 +11,7 @@ NOTE: DO NOT OPTIMIZE -> stay close to original code-base
 """
 
 from shepherd_core.data_models.base.calibration import CalibrationEmulator
-from shepherd_core.data_models.content.energy_environment import EnergyDType
+from shepherd_core.data_models.content.enum_datatypes import EnergyDType
 from shepherd_core.data_models.content.virtual_harvester_config import HarvesterPRUConfig
 from shepherd_core.data_models.content.virtual_source_config import ConverterPRUConfig
 from shepherd_core.data_models.content.virtual_source_config import VirtualSourceConfig

shepherd_core/vsource/virtual_source_simulation.py

@@ -72,24 +72,24 @@ def simulate_source(
         else:
             stats_internal = None
 
-        for _t, v_inp, i_inp in tqdm(
+        for t_, v_inp, i_inp in tqdm(
             file_inp.read(is_raw=True), total=file_inp.chunks_n, desc="Chunk", leave=False
         ):
             v_uV = 1e6 * cal_inp.voltage.raw_to_si(v_inp)
             i_nA = 1e9 * cal_inp.current.raw_to_si(i_inp)
 
-            for _n in range(len(_t)):
-                v_uV[_n] = src.iterate_sampling(
-                    V_inp_uV=int(v_uV[_n]),
-                    I_inp_nA=int(i_nA[_n]),
+            for n_ in range(len(t_)):
+                v_uV[n_] = src.iterate_sampling(
+                    V_inp_uV=int(v_uV[n_]),
+                    I_inp_nA=int(i_nA[n_]),
                     I_out_nA=i_out_nA,
                 )
-                i_out_nA = target.step(int(v_uV[_n]), pwr_good=src.cnv.get_power_good())
-                i_nA[_n] = i_out_nA
+                i_out_nA = target.step(int(v_uV[n_]), pwr_good=src.cnv.get_power_good())
+                i_nA[n_] = i_out_nA
 
                 if stats_internal is not None:
                     stats_internal[stats_sample] = [
-                        _t[_n] * 1e-9,  # s
+                        t_[n_] * 1e-9,  # s
                         src.hrv.voltage_hold * 1e-6,
                         src.cnv.V_input_request_uV * 1e-6,  # V
                         src.hrv.voltage_set_uV * 1e-6,
@@ -107,7 +107,7 @@ def simulate_source(
             if path_output:
                 v_out = cal_out.voltage.si_to_raw(1e-6 * v_uV)
                 i_out = cal_out.current.si_to_raw(1e-9 * i_nA)
-                file_out.append_iv_data_raw(_t, v_out, i_out)
+                file_out.append_iv_data_raw(t_, v_out, i_out)
 
     if stats_internal is not None:
         stats_internal = stats_internal[:stats_sample, :]

shepherd_core/vsource/virtual_storage_models_kibam.py

@@ -161,7 +161,7 @@ class ModelKiBaM(ModelStorage):
 
         # Step 2: Calculate SoC after dt (equation 6; modified for discrete operation)
         # ⤷ MODIFIED: clamp both SoC to 0..1
-        self.SoC = self.SoC - 1 / self.cfg.q_As * (I_cell * self.dt_s)
+        self.SoC -= 1 / self.cfg.q_As * (I_cell * self.dt_s)
         self.SoC = min(max(self.SoC, 0.0), 1.0)
         SoC_eff = self.SoC - 1 / self.cfg.q_As * self.C_unavailable
         SoC_eff = max(SoC_eff, 0.0)
@@ -278,7 +278,7 @@ class ModelKiBaMPlus(ModelStorage):
 
         # Step 2: Calculate SoC after dt (equation 6; modified for discrete operation)
         # ⤷ MODIFIED: clamp both SoC to 0..1
-        self.SoC = self.SoC - (I_cell + I_leak) * self.dt_s / self.cfg.q_As
+        self.SoC -= (I_cell + I_leak) * self.dt_s / self.cfg.q_As
         self.SoC = min(max(self.SoC, 0.0), 1.0)
         SoC_eff = self.SoC - 1 / self.cfg.q_As * self.C_unavailable
         SoC_eff = min(max(SoC_eff, 0.0), 1.0)
@@ -380,7 +380,7 @@ class ModelKiBaMSimple(ModelStorage):
 
         # Step 2: Calculate SoC after dt (equation 6; modified for discrete operation)
         #       = SoC - 1 / C * (i_cell * dt)
-        self.SoC = self.SoC - (I_cell + I_leak) * self.Constant_s_per_As
+        self.SoC -= (I_cell + I_leak) * self.Constant_s_per_As
         SoC_eff = self.SoC = min(max(self.SoC, 0.0), 1.0)
         # ⤷ MODIFIED: removed term due to omission of rate capacity effect
         # ⤷ MODIFIED: clamp SoC to 0..1

shepherd_core/writer.py

@@ -22,7 +22,7 @@ from .config import config
 from .data_models.base.calibration import CalibrationEmulator as CalEmu
 from .data_models.base.calibration import CalibrationHarvester as CalHrv
 from .data_models.base.calibration import CalibrationSeries as CalSeries
-from .data_models.content.energy_environment import EnergyDType
+from .data_models.content.enum_datatypes import EnergyDType
 from .data_models.task import Compression
 from .data_models.task.emulation import c_translate
 from .reader import Reader
@@ -116,11 +116,12 @@ class Writer(Reader):
 
         if not hasattr(self, "_logger"):
             self._logger: logging.Logger = logging.getLogger("SHPCore.Writer")
+            self._logger.setLevel(logging.DEBUG if verbose else logging.INFO)
         # -> logger gets configured in reader()
 
         if self._modify or force_overwrite or not file_path.exists():
             file_path = file_path.resolve()
-            self._logger.info("Storing data to   '%s'", file_path)
+            self._logger.debug("Storing data to   '%s'", file_path)
         elif file_path.exists() and not file_path.is_file():
             msg = f"Path is not a file ({file_path})"
             raise TypeError(msg)
@@ -154,22 +155,22 @@ class Writer(Reader):
         if "mode" not in self.h5file.attrs:
             self.h5file.attrs["mode"] = self.MODE_DEFAULT
 
-        _dtypes = self.MODE_TO_DTYPE[self.get_mode()]
+        dtypes_ = self.MODE_TO_DTYPE[self.get_mode()]
 
         # Handle Datatype
         if isinstance(datatype, str):
             datatype = EnergyDType[datatype]
-        if isinstance(datatype, EnergyDType) and datatype not in _dtypes:
-            msg = f"Can't handle value '{datatype}' of datatype (choose one of {_dtypes})"
+        if isinstance(datatype, EnergyDType) and datatype not in dtypes_:
+            msg = f"Can't handle value '{datatype}' of datatype (choose one of {dtypes_})"
             raise ValueError(msg)
 
         if isinstance(datatype, EnergyDType):
             self.h5file["data"].attrs["datatype"] = datatype.name
         if "datatype" not in self.h5file["data"].attrs:
             self.h5file["data"].attrs["datatype"] = self.DATATYPE_DEFAULT.name
-        if self.get_datatype() not in _dtypes:
+        if self.get_datatype() not in dtypes_:
             msg = (
-                f"Can't handle value '{self.get_datatype()}' of datatype (choose one of {_dtypes})"
+                f"Can't handle value '{self.get_datatype()}' of datatype (choose one of {dtypes_})"
             )
             raise ValueError(msg)
 
@@ -183,6 +184,12 @@ class Writer(Reader):
             raise ValueError("Window Size argument needed for ivcurve-Datatype")
 
         # Handle Cal
+        if isinstance(cal_data, CalEmu):
+            msg = (
+                "Writer got a CalibrationEmulator()-object without information "
+                "about the TargetPort. Possibly wrong cal-data stored in hdf5!"
+            )
+            self._logger.warning(msg)
         if isinstance(cal_data, (CalEmu, CalHrv)):
             cal_data = CalSeries.from_cal(cal_data)
 
@@ -215,7 +222,7 @@ class Writer(Reader):
     ) -> None:
         self._align()
         self._refresh_file_stats()
-        self._logger.info(
+        self._logger.debug(
             "closing hdf5 file, %.1f s iv-data, size = %.3f MiB, rate = %.0f KiB/s",
             self.runtime_s,
             self.file_size / 2**20,
@@ -296,7 +303,7 @@ class Writer(Reader):
             timestamp = int(timestamp)
         if isinstance(timestamp, int):
             time_series_ns = self.sample_interval_ns * np.arange(len_new).astype("u8")
-            timestamp = timestamp + time_series_ns
+            timestamp += time_series_ns
         if isinstance(timestamp, np.ndarray):
             len_new = min(len_new, timestamp.size)
         else: