shepherd-core 2025.2.2__py3-none-any.whl → 2025.4.2__py3-none-any.whl

shepherd_core/fw_tools/patcher.py

@@ -1,15 +1,16 @@
 """Read and modify symbols in ELF-files."""
 
 from pathlib import Path
+from typing import Annotated
 from typing import Optional
 
 from pydantic import Field
 from pydantic import validate_call
-from typing_extensions import Annotated
 
-from ..commons import uid_len_default
-from ..commons import uid_str_default
-from ..logger import logger
+from shepherd_core.commons import UID_NAME
+from shepherd_core.commons import UID_SIZE
+from shepherd_core.logger import logger
+
 from .validation import is_elf
 
 try:
@@ -49,7 +50,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_SIZE) -> Optional[int]:
     """Read value of symbol in ELF-File.
 
     Will be interpreted as int.
@@ -67,7 +68,7 @@ def read_symbol(file_elf: Path, symbol: str, length: int = uid_len_default) -> O
 
 def read_uid(file_elf: Path) -> Optional[int]:
     """Read value of UID-symbol for shepherd testbed."""
-    return read_symbol(file_elf, symbol=uid_str_default, length=uid_len_default)
+    return read_symbol(file_elf, symbol=UID_NAME, length=UID_SIZE)
 
 
 def read_arch(file_elf: Path) -> Optional[str]:
@@ -87,7 +88,7 @@ def read_arch(file_elf: Path) -> Optional[str]:
 def modify_symbol_value(
     file_elf: Path,
     symbol: str,
-    value: Annotated[int, Field(ge=0, lt=2 ** (8 * uid_len_default))],
+    value: Annotated[int, Field(ge=0, lt=2 ** (8 * UID_SIZE))],
     *,
     overwrite: bool = False,
 ) -> Optional[Path]:
@@ -105,20 +106,18 @@ def modify_symbol_value(
         raise RuntimeError(elf_error_text)
     elf = ELF(path=file_elf)
     addr = elf.symbols[symbol]
-    value_raw = elf.read(address=addr, count=uid_len_default)[-uid_len_default:]
+    value_raw = elf.read(address=addr, count=UID_SIZE)[-UID_SIZE:]
     # ⤷ 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_SIZE, byteorder=elf.endian, signed=False)
+
     try:
         elf.write(address=addr, data=value_raw)
     except AttributeError:
         logger.warning("ELF-Modifier failed @%s for symbol '%s'", f"0x{addr:X}", symbol)
         return None
-    if overwrite:
-        file_new = file_elf
-    else:
-        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()
+
+    file_new = file_elf if overwrite else file_elf.with_stem(file_elf.stem + "_" + str(value))
     elf.save(path=file_new)
     elf.close()
     logger.debug(
@@ -133,4 +132,4 @@ def modify_symbol_value(
 
 def modify_uid(file_elf: Path, value: int) -> Optional[Path]:
     """Replace value of UID-symbol for shepherd testbed."""
-    return modify_symbol_value(file_elf, symbol=uid_str_default, value=value, overwrite=True)
+    return modify_symbol_value(file_elf, symbol=UID_NAME, value=value, overwrite=True)

shepherd_core/fw_tools/validation.py

@@ -12,8 +12,9 @@ from intelhex import IntelHex
 from intelhex import IntelHexError
 from pydantic import validate_call
 
-from ..data_models.content.firmware_datatype import FirmwareDType
-from ..logger import logger
+from shepherd_core.data_models.content.firmware_datatype import FirmwareDType
+from shepherd_core.logger import logger
+
 from .converter_elf import elf_to_hex
 
 try:

shepherd_core/inventory/__init__.py

@@ -9,13 +9,13 @@ This will collect:
 from datetime import datetime
 from datetime import timedelta
 from pathlib import Path
-from typing import List
+from typing import Annotated
 
 from pydantic import Field
-from typing_extensions import Annotated
 from typing_extensions import Self
 
-from ..data_models import ShpModel
+from shepherd_core.data_models import ShpModel
+
 from .python import PythonInventory
 from .system import SystemInventory
 from .target import TargetInventory
@@ -55,7 +55,7 @@ class Inventory(PythonInventory, SystemInventory, TargetInventory):
 class InventoryList(ShpModel):
     """Collection of inventories for several devices."""
 
-    elements: Annotated[List[Inventory], Field(min_length=1)]
+    elements: Annotated[list[Inventory], Field(min_length=1)]
 
     def to_csv(self, path: Path) -> None:
         """Generate a CSV.

shepherd_core/inventory/python.py

@@ -8,7 +8,7 @@ from typing import Optional
 from pydantic import ConfigDict
 from typing_extensions import Self
 
-from ..data_models import ShpModel
+from shepherd_core.data_models import ShpModel
 
 
 class PythonInventory(ShpModel):

shepherd_core/inventory/system.py

@@ -3,15 +3,18 @@
 import platform
 import subprocess
 import time
+from collections.abc import Mapping
+from collections.abc import Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import List
+from types import MappingProxyType
+from typing import Any
 from typing import Optional
 
 from typing_extensions import Self
 
-from ..data_models.base.timezone import local_now
-from ..logger import logger
+from shepherd_core.data_models.base.timezone import local_now
+from shepherd_core.logger import logger
 
 try:
     import psutil
@@ -21,7 +24,7 @@ except ImportError:
 from pydantic import ConfigDict
 from pydantic.types import PositiveInt
 
-from ..data_models import ShpModel
+from shepherd_core.data_models import ShpModel
 
 
 class SystemInventory(ShpModel):
@@ -30,7 +33,7 @@ class SystemInventory(ShpModel):
     uptime: PositiveInt
     # ⤷ seconds
     timestamp: datetime
-    # time_delta: timedelta = timedelta(0)  # noqa: ERA001
+    # time_delta: timedelta = timedelta(seconds=0)  # noqa: ERA001
     # ⤷ lag behind earliest observer, TODO: wrong place
 
     system: str
@@ -44,13 +47,13 @@ class SystemInventory(ShpModel):
 
     hostname: str
 
-    interfaces: dict = {}  # noqa: RUF012
+    interfaces: Mapping[str, Any] = MappingProxyType({})
     # ⤷ tuple with
     #   ip IPvAnyAddress
     #   mac MACStr
 
-    fs_root: List[str] = None
-    beagle: List[str] = None
+    fs_root: Sequence[str] = ()
+    beagle: Sequence[str] = ()
 
     model_config = ConfigDict(str_min_length=0)
 

shepherd_core/inventory/target.py

@@ -1,19 +1,19 @@
 """Hardware related inventory model."""
 
-from typing import List
+from collections.abc import Sequence
 from typing import Optional
 
 from pydantic import ConfigDict
 from typing_extensions import Self
 
-from ..data_models import ShpModel
+from shepherd_core.data_models import ShpModel
 
 
 class TargetInventory(ShpModel):
     """Hardware related inventory model."""
 
     cape: Optional[str] = None
-    targets: List[str] = []  # noqa: RUF012
+    targets: Sequence[str] = ()
 
     model_config = ConfigDict(str_min_length=0)
 

shepherd_core/logger.py

@@ -33,8 +33,8 @@ def set_log_verbose_level(log_: Union[logging.Logger, logging.Handler], verbose:
     if verbose < 3:
         # reduce log-overhead when not debugging, also more user-friendly exceptions
         logging._srcfile = None  # noqa: SLF001
-        logging.logThreads = 0
-        logging.logProcesses = 0
+        logging.logThreads = False
+        logging.logProcesses = False
 
     if verbose > 2:
         chromalog.basicConfig(format="%(name)s %(levelname)s: %(message)s")

shepherd_core/reader.py

@@ -9,14 +9,10 @@ import math
 import os
 from itertools import product
 from pathlib import Path
+from types import MappingProxyType
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import ClassVar
-from typing import Dict
-from typing import Generator
-from typing import List
 from typing import Optional
-from typing import Type
 from typing import Union
 
 import h5py
@@ -26,13 +22,16 @@ from pydantic import validate_call
 from tqdm import trange
 from typing_extensions import Self
 
-from .commons import samplerate_sps_default
+from .commons import SAMPLERATE_SPS_DEFAULT
 from .data_models.base.calibration import CalibrationPair
 from .data_models.base.calibration import CalibrationSeries
 from .data_models.content.energy_environment import EnergyDType
 from .decoder_waveform import Uart
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
+    from collections.abc import Mapping
+    from collections.abc import Sequence
     from types import TracebackType
 
 
@@ -46,28 +45,27 @@ class Reader:
 
     """
 
-    samples_per_buffer: int = 10_000
+    BUFFER_SAMPLES_N: int = 10_000
 
-    mode_dtype_dict: ClassVar[dict] = {
-        "harvester": [
-            EnergyDType.ivsample,
-            EnergyDType.ivcurve,
-            EnergyDType.isc_voc,
-        ],
-        "emulator": [EnergyDType.ivsample],
-    }
+    MODE_TO_DTYPE: Mapping[str, Sequence[EnergyDType]] = MappingProxyType(
+        {
+            "harvester": (
+                EnergyDType.ivsample,
+                EnergyDType.ivcurve,
+                EnergyDType.isc_voc,
+            ),
+            "emulator": (EnergyDType.ivsample,),
+        }
+    )
 
     @validate_call
     def __init__(
         self,
-        file_path: Optional[Path],
+        file_path: Path,
         *,
-        verbose: Optional[bool] = True,
+        verbose: bool = True,
     ) -> None:
-        if not hasattr(self, "file_path"):
-            self.file_path: Optional[Path] = None
-            if isinstance(file_path, (Path, str)):
-                self.file_path = Path(file_path).resolve()
+        self.file_path: Path = file_path.resolve()
 
         if not hasattr(self, "_logger"):
             self._logger: logging.Logger = logging.getLogger("SHPCore.Reader")
@@ -75,7 +73,7 @@ class Reader:
             self._logger.setLevel(logging.DEBUG if verbose else logging.INFO)
 
         if not hasattr(self, "samplerate_sps"):
-            self.samplerate_sps: int = samplerate_sps_default
+            self.samplerate_sps: int = SAMPLERATE_SPS_DEFAULT
         self.sample_interval_ns: int = round(10**9 // self.samplerate_sps)
         self.sample_interval_s: float = 1 / self.samplerate_sps
 
@@ -155,7 +153,7 @@ class Reader:
 
     def __exit__(
         self,
-        typ: Optional[Type[BaseException]] = None,
+        typ: Optional[type[BaseException]] = None,
         exc: Optional[BaseException] = None,
         tb: Optional[TracebackType] = None,
         extra_arg: int = 0,
@@ -183,7 +181,7 @@ class Reader:
             self.sample_interval_ns = round(10**9 * self.sample_interval_s)
             self.samplerate_sps = max(round((sample_count - 1) / duration_s), 1)
         self.runtime_s = round(self.ds_voltage.shape[0] / self.samplerate_sps, 1)
-        self.buffers_n = int(self.ds_voltage.shape[0] // self.samples_per_buffer)
+        self.buffers_n = int(self.ds_voltage.shape[0] // self.BUFFER_SAMPLES_N)
         if isinstance(self.file_path, Path):
             self.file_size = self.file_path.stat().st_size
         else:
@@ -194,6 +192,7 @@ class Reader:
         self,
         start_n: int = 0,
         end_n: Optional[int] = None,
+        n_samples_per_buffer: Optional[int] = None,
         *,
         is_raw: bool = False,
         omit_ts: bool = False,
@@ -201,27 +200,28 @@ class Reader:
         """Read the specified range of buffers from the hdf5 file.
 
         Generator - can be configured on first call
-        TODO: reconstruct - start/end mark samples &
-         each call can request a certain number of samples.
 
         Args:
         ----
             :param start_n: (int) Index of first buffer to be read
             :param end_n: (int) Index of last buffer to be read
+            :param n_samples_per_buffer: (int) allows changing
             :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_voltage.shape[0] // self.samples_per_buffer)
+        if n_samples_per_buffer is None:
+            n_samples_per_buffer = self.BUFFER_SAMPLES_N
+        end_max = int(self.ds_voltage.shape[0] // n_samples_per_buffer)
+        end_n = end_max if end_n is None else min(end_n, end_max)
         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
+            idx_start = i * n_samples_per_buffer
+            idx_end = idx_start + n_samples_per_buffer
             if _raw:
                 yield (
                     self.ds_time[idx_start:idx_end] if _wts else None,
@@ -252,7 +252,7 @@ class Reader:
             return self.h5file.attrs["mode"]
         return ""
 
-    def get_config(self) -> Dict:
+    def get_config(self) -> dict:
         if "config" in self.h5file["data"].attrs:
             return yaml.safe_load(self.h5file["data"].attrs["config"])
         return {}
@@ -327,7 +327,7 @@ class Reader:
                     self.file_path.name,
                 )
                 return False
-            if self.h5file.attrs["mode"] not in self.mode_dtype_dict:
+            if self.h5file.attrs["mode"] not in self.MODE_TO_DTYPE:
                 self._logger.error(
                     "[FileValidation] unsupported mode '%s' in '%s'",
                     attr,
@@ -359,7 +359,7 @@ class Reader:
                         self.file_path.name,
                     )
                     return False
-        if self.get_datatype() not in self.mode_dtype_dict[self.get_mode()]:
+        if self.get_datatype() not in self.MODE_TO_DTYPE[self.get_mode()]:
             self._logger.error(
                 "[FileValidation] unsupported type '%s' for mode '%s'  in '%s'",
                 self.get_datatype(),
@@ -397,7 +397,7 @@ class Reader:
                     self.file_path.name,
                 )
         # dataset-length should be multiple of buffersize
-        remaining_size = ds_volt_size % self.samples_per_buffer
+        remaining_size = ds_volt_size % self.BUFFER_SAMPLES_N
         if remaining_size != 0:
             self._logger.warning(
                 "[FileValidation] datasets are not aligned with buffer-size in '%s'",
@@ -476,7 +476,7 @@ class Reader:
 
     def _dset_statistics(
         self, dset: h5py.Dataset, cal: Optional[CalibrationPair] = None
-    ) -> Dict[str, float]:
+    ) -> dict[str, float]:
         """Create basic stats for a provided dataset.
 
         :param dset: dataset to evaluate
@@ -509,7 +509,7 @@ class Reader:
         if len(stats_list) < 1:
             return {}
         stats_nd = np.stack(stats_list)
-        stats: Dict[str, float] = {
+        stats: dict[str, float] = {
             # TODO: wrong calculation for ndim-datasets with n>1
             "mean": float(stats_nd[:, 0].mean()),
             "min": float(stats_nd[:, 1].min()),
@@ -519,7 +519,7 @@ class Reader:
         }
         return stats
 
-    def _data_timediffs(self) -> List[float]:
+    def _data_timediffs(self) -> list[float]:
         """Calculate list of unique time-deltas [s] between buffers.
 
         Optimized version that only looks at the start of each buffer.
@@ -538,14 +538,14 @@ class Reader:
 
         def calc_timediffs(idx_start: int) -> list:
             ds_time = self.ds_time[
-                idx_start : (idx_start + self.max_elements) : self.samples_per_buffer
+                idx_start : (idx_start + self.max_elements) : self.BUFFER_SAMPLES_N
             ]
             diffs_np = np.unique(ds_time[1:] - ds_time[0:-1], return_counts=False)
             return list(np.array(diffs_np))
 
         diffs_ll = [calc_timediffs(i) for i in job_iter]
         diffs = {
-            round(self._cal.time.raw_to_si(j) / self.samples_per_buffer, 6)
+            round(self._cal.time.raw_to_si(j) / self.BUFFER_SAMPLES_N, 6)
             for i in diffs_ll
             for j in i
         }
@@ -563,7 +563,7 @@ class Reader:
             self._logger.warning(
                 "Time-jumps detected -> expected equal steps, but got: %s s", diffs
             )
-        return (len(diffs) <= 1) and diffs[0] == round(0.1 / self.samples_per_buffer, 6)
+        return (len(diffs) <= 1) and diffs[0] == round(0.1 / self.BUFFER_SAMPLES_N, 6)
 
     def count_errors_in_log(self, group_name: str = "sheep", min_level: int = 40) -> int:
         if group_name not in self.h5file:
@@ -581,7 +581,7 @@ class Reader:
         node: Union[h5py.Dataset, h5py.Group, None] = None,
         *,
         minimal: bool = False,
-    ) -> Dict[str, dict]:
+    ) -> dict[str, dict]:
         """Recursive FN to capture the structure of the file.
 
         :param node: starting node, leave free to go through whole file
@@ -592,7 +592,7 @@ class Reader:
             self._refresh_file_stats()
             return self.get_metadata(self.h5file, minimal=minimal)
 
-        metadata: Dict[str, dict] = {}
+        metadata: dict[str, dict] = {}
         if isinstance(node, h5py.Dataset) and not minimal:
             metadata["_dataset_info"] = {
                 "datatype": str(node.dtype),
@@ -614,7 +614,7 @@ class Reader:
                 with contextlib.suppress(yaml.YAMLError):
                     attr_value = yaml.safe_load(attr_value)
             elif "int" in str(type(attr_value)):
-                # TODO: why not isinstance? can it be List[int] other complex type?
+                # TODO: why not isinstance? can it be list[int] other complex type?
                 attr_value = int(attr_value)
             else:
                 attr_value = float(attr_value)

shepherd_core/testbed_client/client_abc_fix.py

@@ -17,11 +17,12 @@ TODO: Comfort functions missing
 
 from abc import ABC
 from abc import abstractmethod
-from typing import List
+from typing import Any
 from typing import Optional
 
-from ..data_models.base.shepherd import ShpModel
-from ..data_models.base.wrapper import Wrapper
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.data_models.base.wrapper import Wrapper
+
 from .fixtures import Fixtures
 
 
@@ -40,11 +41,11 @@ class AbcClient(ABC):
         """
 
     @abstractmethod
-    def query_ids(self, model_type: str) -> List[int]:
+    def query_ids(self, model_type: str) -> list[int]:
         pass
 
     @abstractmethod
-    def query_names(self, model_type: str) -> List[str]:
+    def query_names(self, model_type: str) -> list[str]:
         pass
 
     @abstractmethod
@@ -54,11 +55,15 @@ class AbcClient(ABC):
         pass
 
     @abstractmethod
-    def try_inheritance(self, model_type: str, values: dict) -> (dict, list):
+    def try_inheritance(
+        self, model_type: str, values: dict[str, Any]
+    ) -> tuple[dict[str, Any], list[str]]:
         # TODO: maybe internal? yes
         pass
 
-    def try_completing_model(self, model_type: str, values: dict) -> (dict, list):
+    def try_completing_model(
+        self, model_type: str, values: dict[str, Any]
+    ) -> tuple[dict[str, Any], list[str]]:
         """Init by name/id, for none existing instances raise Exception.
 
         This is the main entry-point for querying a model (used be the core-lib).
@@ -73,7 +78,7 @@ class AbcClient(ABC):
         return self.try_inheritance(model_type, values)
 
     @abstractmethod
-    def fill_in_user_data(self, values: dict) -> dict:
+    def fill_in_user_data(self, values: dict[str, Any]) -> dict[str, Any]:
         # TODO: is it really helpful and needed?
         pass
 
@@ -83,7 +88,7 @@ class FixturesClient(AbcClient):
 
     def __init__(self) -> None:
         super().__init__()
-        self._fixtures: Optional[Fixtures] = Fixtures()
+        self._fixtures: Fixtures = Fixtures()
 
     def insert(self, data: ShpModel) -> bool:
         wrap = Wrapper(
@@ -93,10 +98,10 @@ class FixturesClient(AbcClient):
         self._fixtures.insert_model(wrap)
         return True
 
-    def query_ids(self, model_type: str) -> List[int]:
+    def query_ids(self, model_type: str) -> list[int]:
         return list(self._fixtures[model_type].elements_by_id.keys())
 
-    def query_names(self, model_type: str) -> List[str]:
+    def query_names(self, model_type: str) -> list[str]:
         return list(self._fixtures[model_type].elements_by_name.keys())
 
     def query_item(
@@ -108,10 +113,12 @@ class FixturesClient(AbcClient):
             return self._fixtures[model_type].query_name(name)
         raise ValueError("Query needs either uid or name of object")
 
-    def try_inheritance(self, model_type: str, values: dict) -> (dict, list):
+    def try_inheritance(
+        self, model_type: str, values: dict[str, Any]
+    ) -> tuple[dict[str, Any], list[str]]:
         return self._fixtures[model_type].inheritance(values)
 
-    def fill_in_user_data(self, values: dict) -> dict:
+    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.

shepherd_core/testbed_client/client_web.py

@@ -2,15 +2,16 @@
 
 from importlib import import_module
 from pathlib import Path
-from typing import List
+from typing import Any
 from typing import Optional
 from typing import Union
 
 from pydantic import validate_call
 
-from ..commons import testbed_server_default
-from ..data_models.base.shepherd import ShpModel
-from ..data_models.base.wrapper import Wrapper
+from shepherd_core.commons import TESTBED_SERVER_URI
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.data_models.base.wrapper import Wrapper
+
 from .client_abc_fix import AbcClient
 from .user_model import User
 
@@ -37,7 +38,7 @@ class WebClient(AbcClient):
         if not hasattr(self, "_token"):
             # add default values
             self._token: str = "basic_public_access"  # noqa: S105
-            self._server: str = testbed_server_default
+            self._server: str = TESTBED_SERVER_URI
             self._user: Optional[User] = None
             self._key: Optional[str] = None
             self._connected: bool = False
@@ -49,6 +50,8 @@ class WebClient(AbcClient):
     # ABC Functions below
 
     def insert(self, data: ShpModel) -> bool:
+        if self._req is None:
+            return False
         wrap = Wrapper(
             datatype=type(data).__name__,
             parameters=data.model_dump(),
@@ -57,10 +60,10 @@ class WebClient(AbcClient):
         r.raise_for_status()
         return True
 
-    def query_ids(self, model_type: str) -> List[int]:
+    def query_ids(self, model_type: str) -> list[int]:
         raise NotImplementedError("TODO")
 
-    def query_names(self, model_type: str) -> List[str]:
+    def query_names(self, model_type: str) -> list[str]:
         raise NotImplementedError("TODO")
 
     def query_item(
@@ -68,10 +71,14 @@ class WebClient(AbcClient):
     ) -> dict:
         raise NotImplementedError("TODO")
 
-    def try_inheritance(self, model_type: str, values: dict) -> (dict, list):
+    def try_inheritance(
+        self, model_type: str, values: dict[str, Any]
+    ) -> tuple[dict[str, Any], list[str]]:
         raise NotImplementedError("TODO")
 
-    def fill_in_user_data(self, values: dict) -> dict:
+    def fill_in_user_data(self, values: dict[str, Any]) -> dict[str, Any]:
+        if self._user is None:
+            return values
         if values.get("owner") is None:
             values["owner"] = self._user.name
         if values.get("group") is None:
@@ -105,7 +112,7 @@ class WebClient(AbcClient):
         return self._query_user_data()
 
     def _query_session_key(self) -> bool:
-        if self._server:
+        if self._server and self._req is not None:
             r = self._req.get(self._server + "/session_key", timeout=2)
             r.raise_for_status()
             self._key = r.json()["value"]  # TODO: not finished
@@ -113,7 +120,7 @@ class WebClient(AbcClient):
         return False
 
     def _query_user_data(self) -> bool:
-        if self._server:
+        if self._server and self._req is not None:
             r = self._req.get(self._server + "/user?token=" + self._token, timeout=2)
             # TODO: possibly a security nightmare (send via json or encrypted via public key?)
             r.raise_for_status()