shepherd-core 2024.7.2__py3-none-any.whl → 2024.7.4__py3-none-any.whl

shepherd_core/__init__.py

@@ -19,11 +19,11 @@ from .logger import get_verbose_level
 from .logger import increase_verbose_level
 from .logger import logger
 from .reader import Reader
-from .testbed_client.client import TestbedClient
-from .testbed_client.client import tb_client
+from .testbed_client.client_web import WebClient
+from .version import version
 from .writer import Writer
 
-__version__ = "2024.7.2"
+__version__ = version
 
 __all__ = [
     "Reader",
@@ -40,7 +40,6 @@ __all__ = [
     "local_now",
     "Calc_t",
     "Compression",
-    "TestbedClient",
-    "tb_client",  # using this (instead of the Class) is the cleaner, but less pythonic way
+    "WebClient",
     "Inventory",
 ]

shepherd_core/calibration_hw_def.py

@@ -32,45 +32,48 @@ RAW_MAX_ADC = 2**M_ADC - 1
 RAW_MAX_DAC = 2**M_DAC - 1
 
 
-def adc_current_to_raw(current: float) -> int:
+def adc_current_to_raw(current: float, *, limited: bool = True) -> int:
     """Convert back a current [A] to raw ADC value."""
     # voltage on input of adc
     val_adc = G_INST_AMP * R_SHT * current
     # digital value according to ADC gain
     val_raw = int(val_adc * (2**M_ADC) / (G_ADC_I * V_REF_ADC))
-    return min(max(val_raw, 0), 2**M_ADC - 1)
+    return min(max(val_raw, 0), 2**M_ADC - 1) if limited else val_raw
 
 
-def adc_raw_to_current(value: int) -> float:
+def adc_raw_to_current(value: int, *, limited: bool = True) -> float:
     """Convert a raw ADC value to a current [A]."""
-    value = min(max(value, 0), 2**M_ADC - 1)
+    if limited:
+        value = min(max(value, 0), 2**M_ADC - 1)
     # voltage on input of adc
     val_adc = float(value) * (G_ADC_I * V_REF_ADC) / (2**M_ADC)
     # current according to adc value
     return val_adc / (R_SHT * G_INST_AMP)
 
 
-def adc_voltage_to_raw(voltage: float) -> int:
+def adc_voltage_to_raw(voltage: float, *, limited: bool = True) -> int:
     """Convert back a voltage [V] to raw ADC value."""
     # digital value according to ADC gain
     val_raw = int(voltage * (2**M_ADC) / (G_ADC_V * V_REF_ADC))
-    return min(max(val_raw, 0), 2**M_ADC - 1)
+    return min(max(val_raw, 0), 2**M_ADC - 1) if limited else val_raw
 
 
-def adc_raw_to_voltage(value: int) -> float:
+def adc_raw_to_voltage(value: int, *, limited: bool = True) -> float:
     """Convert a raw ADC value to a voltage [V]."""
-    value = min(max(value, 0), 2**M_ADC - 1)
+    if limited:
+        value = min(max(value, 0), 2**M_ADC - 1)
     # voltage according to ADC value
     return float(value) * (G_ADC_V * V_REF_ADC) / (2**M_ADC)
 
 
-def dac_raw_to_voltage(value: int) -> float:
+def dac_raw_to_voltage(value: int, *, limited: bool = True) -> float:
     """Convert back a raw DAC value to a voltage [V]."""
-    value = min(max(value, 0), 2**M_DAC - 1)
+    if limited:
+        value = min(max(value, 0), 2**M_DAC - 1)
     return float(value) * (V_REF_DAC * G_DAC) / (2**M_DAC)
 
 
-def dac_voltage_to_raw(voltage: float) -> int:
+def dac_voltage_to_raw(voltage: float, *, limited: bool = True) -> int:
     """Convert a voltage [V] to raw DAC value."""
     val_raw = int(voltage * (2**M_DAC) / (V_REF_DAC * G_DAC))
-    return min(max(val_raw, 0), 2**M_DAC - 1)
+    return min(max(val_raw, 0), 2**M_DAC - 1) if limited else val_raw

shepherd_core/data_models/base/calibration.py

@@ -51,6 +51,7 @@ class CalibrationPair(ShpModel):
 
     gain: PositiveFloat
     offset: float = 0
+    # TODO: add unit
 
     def raw_to_si(self, values_raw: Calc_t, *, allow_negative: bool = True) -> Calc_t:
         """Convert between physical units and raw unsigned integers."""
@@ -79,8 +80,8 @@ class CalibrationPair(ShpModel):
     @classmethod
     def from_fn(cls, fn: Callable) -> Self:
         """Probe linear function to determine scaling values."""
-        offset = fn(0)
-        gain_inv = fn(1.0) - offset
+        offset = fn(0, limited=False)
+        gain_inv = fn(1.0, limited=False) - offset
         return cls(
             gain=1.0 / float(gain_inv),
             offset=-float(offset) / gain_inv,
@@ -274,7 +275,7 @@ class CalibrationSeries(ShpModel):
         emu_port_a: bool = True,
     ) -> Self:
         if isinstance(cal, CalibrationHarvester):
-            return cls(voltage=cal.adc_V_Sense, current=cal.dac_V_Hrv)
+            return cls(voltage=cal.adc_V_Sense, current=cal.adc_C_Hrv)
         if emu_port_a:
             return cls(voltage=cal.dac_V_A, current=cal.adc_C_A)
         return cls(voltage=cal.dac_V_B, current=cal.adc_C_B)

shepherd_core/data_models/base/wrapper.py

@@ -7,6 +7,8 @@ from pydantic import BaseModel
 from pydantic import StringConstraints
 from typing_extensions import Annotated
 
+from ...version import version
+
 SafeStrClone = Annotated[str, StringConstraints(pattern=r"^[ -~]+$")]
 # ⤷ copy avoids circular import
 
@@ -19,5 +21,7 @@ class Wrapper(BaseModel):
     comment: Optional[SafeStrClone] = None
     created: Optional[datetime] = None
     # ⤷ Optional metadata
+    lib_ver: Optional[str] = version
+    # ⤷ for debug-purposes and later comp-checks
     parameters: dict
     # ⤷ ShpModel

shepherd_core/data_models/content/energy_environment.py

@@ -35,7 +35,7 @@ class EnergyEnvironment(ContentModel):
 
     # TODO: scale up/down voltage/current
 
-    # additional descriptive metadata
+    # additional descriptive metadata, TODO: these are very solar-centered -> generalize
     light_source: Optional[str] = None
     weather_conditions: Optional[str] = None
     indoor: Optional[bool] = None

shepherd_core/data_models/content/firmware.py

@@ -152,6 +152,7 @@ class Firmware(ContentModel, title="Firmware of Target"):
 
         if not match:
             logger.warning("FW-Hash does not match with stored value!")
+            # TODO: it might be more appropriate to raise here
         return match
 
     @validate_call

shepherd_core/data_models/experiment/experiment.py

@@ -13,6 +13,7 @@ from pydantic import model_validator
 from typing_extensions import Annotated
 from typing_extensions import Self
 
+from ...version import version
 from ..base.content import IdInt
 from ..base.content import NameStr
 from ..base.content import SafeStr
@@ -54,18 +55,20 @@ class Experiment(ShpModel, title="Config of an Experiment"):
     # targets
     target_configs: Annotated[List[TargetConfig], Field(min_length=1, max_length=128)]
 
-    # TODO: we probably need to remember the lib-version for content &| experiment
+    # for debug-purposes and later comp-checks
+    lib_ver: Optional[str] = version
 
     @model_validator(mode="after")
     def post_validation(self) -> Self:
-        self.validate_targets(self.target_configs)
-        self.validate_observers(self.target_configs)
+        testbed = Testbed()  # this will query the first (and only) entry of client
+        self._validate_targets(self.target_configs)
+        self._validate_observers(self.target_configs, testbed)
         if self.duration and self.duration.total_seconds() < 0:
             raise ValueError("Duration of experiment can't be negative.")
         return self
 
     @staticmethod
-    def validate_targets(configs: List[TargetConfig]) -> None:
+    def _validate_targets(configs: List[TargetConfig]) -> None:
         target_ids = []
         custom_ids = []
         for _config in configs:
@@ -83,10 +86,8 @@ class Experiment(ShpModel, title="Config of an Experiment"):
             raise ValueError("Custom Target-ID are faulty (some form of id-collisions)!")
 
     @staticmethod
-    def validate_observers(configs: List[TargetConfig]) -> None:
+    def _validate_observers(configs: List[TargetConfig], testbed: Testbed) -> None:
         target_ids = [_id for _config in configs for _id in _config.target_IDs]
-
-        testbed = Testbed(name="shepherd_tud_nes")
         obs_ids = [testbed.get_observer(_id).id for _id in target_ids]
         if len(target_ids) > len(set(obs_ids)):
             raise ValueError(

shepherd_core/data_models/task/testbed_tasks.py

@@ -32,8 +32,9 @@ class TestbedTasks(ShpModel):
     @validate_call
     def from_xp(cls, xp: Experiment, tb: Optional[Testbed] = None) -> Self:
         if tb is None:
-            # TODO: just for testing OK
-            tb = Testbed(name="shepherd_tud_nes")
+            # TODO: is tb-argument really needed? prob. not
+            tb = Testbed()  # this will query the first (and only) entry of client
+
         tgt_ids = xp.get_target_ids()
         obs_tasks = [ObserverTasks.from_xp(xp, tb, _id) for _id in tgt_ids]
         return cls(

shepherd_core/data_models/testbed/testbed.py

@@ -11,6 +11,7 @@ from pydantic import model_validator
 from typing_extensions import Annotated
 from typing_extensions import Self
 
+from ... import logger
 from ...testbed_client import tb_client
 from ..base.content import IdInt
 from ..base.content import NameStr
@@ -42,6 +43,14 @@ class Testbed(ShpModel):
     @model_validator(mode="before")
     @classmethod
     def query_database(cls, values: dict) -> dict:
+        # allow instantiating an empty Testbed
+        #   -> query the first (and only) entry of client
+        if len(values) == 0:
+            ids = tb_client.query_ids(cls.__name__)
+            if len(ids) > 1:
+                logger.warning("More than one testbed defined?!?")
+            values = {"id": ids[0]}
+
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         return values
 

shepherd_core/testbed_client/__init__.py

@@ -1,9 +1,11 @@
 """Client to access a testbed-instance for controlling experiments."""
 
-from .client import tb_client
+from .client_abc_fix import tb_client
+from .client_web import WebClient
 from .user_model import User
 
 __all__ = [
     "tb_client",
+    "WebClient",
     "User",
 ]

shepherd_core/testbed_client/client_abc_fix.py

@@ -0,0 +1,126 @@
+"""AbstractBase-Class & Client-Class to access the file based fixtures.
+
+Fixtures == OffLineDemoInstances
+offline:	core  - fixtClient
+webDev:	    core  - webClient  <->	webSrv - fixtClient
+webUser:	core  - webClient  <->  webSrv - DbClient
+webInfra:   core  - webClient+ <->  webSrv - DbClient
+
+Users, Sheep and ServerApps should have access to the same DB via WebClient
+
+Note: ABC and FixClient can't be in separate files when tb_client should
+      default to FixClient (circular import)
+
+TODO: Comfort functions missing
+    - fixtures to DB, and vice versa
+"""
+
+from abc import ABC
+from abc import abstractmethod
+from typing import List
+from typing import Optional
+
+from ..data_models.base.shepherd import ShpModel
+from ..data_models.base.wrapper import Wrapper
+from .fixtures import Fixtures
+
+
+class AbcClient(ABC):
+    """AbstractBase-Class to access a testbed instance."""
+
+    def __init__(self) -> None:
+        global tb_client  # noqa: PLW0603
+        tb_client = self
+
+    @abstractmethod
+    def insert(self, data: ShpModel) -> bool:
+        """Insert (and probably replace) entry.
+
+        TODO: fixtures get replaced, but is that wanted for web?
+        """
+
+    @abstractmethod
+    def query_ids(self, model_type: str) -> List[int]:
+        pass
+
+    @abstractmethod
+    def query_names(self, model_type: str) -> List[str]:
+        pass
+
+    @abstractmethod
+    def query_item(
+        self, model_type: str, uid: Optional[int] = None, name: Optional[str] = None
+    ) -> dict:
+        pass
+
+    @abstractmethod
+    def try_inheritance(self, model_type: str, values: dict) -> (dict, list):
+        # TODO: maybe internal? yes
+        pass
+
+    def try_completing_model(self, model_type: str, values: dict) -> (dict, list):
+        """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).
+        """
+        if len(values) == 1 and next(iter(values.keys())) in {"id", "name"}:
+            try:
+                values = self.query_item(model_type, name=values.get("name"), uid=values.get("id"))
+            except ValueError as err:
+                raise ValueError(
+                    "Query %s by name / ID failed - %s is unknown!", model_type, values
+                ) from err
+        return self.try_inheritance(model_type, values)
+
+    @abstractmethod
+    def fill_in_user_data(self, values: dict) -> dict:
+        # TODO: is it really helpful and needed?
+        pass
+
+
+class FixturesClient(AbcClient):
+    """Client-Class to access the file based fixtures."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._fixtures: Optional[Fixtures] = Fixtures()
+
+    def insert(self, data: ShpModel) -> bool:
+        wrap = Wrapper(
+            datatype=type(data).__name__,
+            parameters=data.model_dump(),
+        )
+        self._fixtures.insert_model(wrap)
+        return True
+
+    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]:
+        return list(self._fixtures[model_type].elements_by_name.keys())
+
+    def query_item(
+        self, model_type: str, uid: Optional[int] = None, name: Optional[str] = None
+    ) -> dict:
+        if uid is not None:
+            return self._fixtures[model_type].query_id(uid)
+        if name is not None:
+            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):
+        return self._fixtures[model_type].inheritance(values)
+
+    def fill_in_user_data(self, values: dict) -> dict:
+        """Add fake user-data when offline-client is used.
+
+        Hotfix until WebClient is working.
+        """
+        if values.get("owner") is None:
+            values["owner"] = "unknown"
+        if values.get("group") is None:
+            values["group"] = "unknown"
+        return values
+
+
+tb_client: AbcClient = FixturesClient()

shepherd_core/testbed_client/client_web.py

@@ -0,0 +1,157 @@
+"""Client-Class to access a testbed instance over the web."""
+
+from importlib import import_module
+from pathlib import Path
+from typing import List
+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 .client_abc_fix import AbcClient
+from .user_model import User
+
+
+class WebClient(AbcClient):
+    """Client-Class to access a testbed instance over the web.
+
+    For online-queries the lib can be connected to the testbed-server.
+    NOTE: there are 3 states:
+    - unconnected -> demo-fixtures are queried (locally)
+    - connected -> publicly available data is queried online
+    - logged in with valid token -> also private data is queried online
+    """
+
+    testbed_server_default = "https://shepherd.cfaed.tu-dresden.de:8000/testbed"
+
+    def __init__(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> None:
+        """Connect to Testbed-Server with optional token and server-address.
+
+        server: optional address to shepherd-server-endpoint
+        token: your account validation. if omitted, only public data is available
+        """
+        super().__init__()
+        if not hasattr(self, "_token"):
+            # add default values
+            self._token: str = "basic_public_access"
+            self._server: str = testbed_server_default
+            self._user: Optional[User] = None
+            self._key: Optional[str] = None
+            self._connected: bool = False
+            self._req = None
+
+        if not self._connected:
+            self._connect(server, token)
+
+    # ABC Functions below
+
+    def insert(self, data: ShpModel) -> bool:
+        wrap = Wrapper(
+            datatype=type(data).__name__,
+            parameters=data.model_dump(),
+        )
+        r = self._req.post(self._server + "/add", data=wrap.model_dump_json(), timeout=2)
+        r.raise_for_status()
+        return True
+
+    def query_ids(self, model_type: str) -> List[int]:
+        raise NotImplementedError("TODO")
+
+    def query_names(self, model_type: str) -> List[str]:
+        raise NotImplementedError("TODO")
+
+    def query_item(
+        self, model_type: str, uid: Optional[int] = None, name: Optional[str] = None
+    ) -> dict:
+        raise NotImplementedError("TODO")
+
+    def try_inheritance(self, model_type: str, values: dict) -> (dict, list):
+        raise NotImplementedError("TODO")
+
+    def fill_in_user_data(self, values: dict) -> dict:
+        if values.get("owner") is None:
+            values["owner"] = self._user.name
+        if values.get("group") is None:
+            values["group"] = self._user.group
+        return values
+
+    # Below are extra FNs not in ABC
+
+    @validate_call
+    def _connect(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> bool:
+        """Establish connection to testbed-server.
+
+        TODO: totally not finished
+        """
+        if isinstance(token, Path):
+            if not token.exists():
+                raise FileNotFoundError("Token-Path does not exist")
+            with token.resolve().open() as file:
+                self._token = file.read()
+        elif isinstance(token, str):
+            self._token = self._token
+
+        if isinstance(server, str):
+            self._server = server.lower()
+
+        self._req = import_module("requests")  # here due to slow startup
+
+        # extended connection-test:
+        self._query_session_key()
+        self._connected = True
+        return self._query_user_data()
+
+    def _query_session_key(self) -> bool:
+        if self._server:
+            r = self._req.get(self._server + "/session_key", timeout=2)
+            r.raise_for_status()
+            self._key = r.json()["value"]  # TODO: not finished
+            return True
+        return False
+
+    def _query_user_data(self) -> bool:
+        if self._server:
+            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()
+            self._user = User(**r.json())
+            return True
+        return False
+
+    def submit_experiment(self, xp: ShpModel) -> str:
+        """Transmit XP 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
+        - 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: Experiment-typehint for argument triggers circular import
+        """
+        raise NotImplementedError("TODO")
+
+    def schedule_experiment(self, id_xp: str) -> bool:
+        """Enqueue XP on testbed."""
+        raise NotImplementedError("TODO")
+
+    def get_experiment_status(self, id_xp: str) -> str:
+        """Ask server about current state of XP.
+
+        - after valid submission: disabled / deactivated
+        - after scheduling: scheduled
+        - before start-time: preparing
+        - during run: active
+        - after run: post-processing (collecting & assembling data)
+        - finished: ready to download
+        """
+        raise NotImplementedError("TODO")
+
+    def get_experiment_results(self, id_xp: str, path: Path) -> bool:
+        """Download resulting files."""
+        raise NotImplementedError("TODO")

shepherd_core/testbed_client/fixtures.py

@@ -183,12 +183,18 @@ class Fixtures:
         else:
             self.file_path = file_path
         self.components: Dict[str, Fixture] = {}
-        save_path = cache_user_path / "fixtures.pickle"
-
-        if save_path.exists() and not file_older_than(save_path, timedelta(hours=24)) and not reset:
-            # speedup
+        cache_file = cache_user_path / "fixtures.pickle"
+        sheep_detect = Path("/lib/firmware/am335x-pru0-fw").exists()
+
+        if (
+            not sheep_detect
+            and cache_file.exists()
+            and not file_older_than(cache_file, timedelta(hours=24))
+            and not reset
+        ):
+            # speedup by loading from cache
             # TODO: also add version as criterion
-            with save_path.open("rb", buffering=-1) as fd:
+            with cache_file.open("rb", buffering=-1) as fd:
                 self.components = pickle.load(fd)  # noqa: S301
             logger.debug(" -> found & used pickled fixtures")
         else:
@@ -204,9 +210,9 @@ class Fixtures:
 
             if len(self.components) < 1:
                 logger.error(f"No fixture-components found at {self.file_path.as_posix()}")
-            else:
-                save_path.parent.mkdir(parents=True, exist_ok=True)
-                with save_path.open("wb", buffering=-1) as fd:
+            elif sheep_detect:
+                cache_file.parent.mkdir(parents=True, exist_ok=True)
+                with cache_file.open("wb", buffering=-1) as fd:
                     pickle.dump(self.components, fd)
 
     @validate_call

shepherd_core/version.py

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

{shepherd_core-2024.7.2.dist-info → shepherd_core-2024.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd_core
-Version: 2024.7.2
+Version: 2024.7.4
 Summary: Programming- and CLI-Interface for the h5-dataformat of the Shepherd-Testbed
 Author-email: Ingmar Splitt <ingmar.splitt@tu-dresden.de>
 Maintainer-email: Ingmar Splitt <ingmar.splitt@tu-dresden.de>
@@ -136,28 +136,30 @@ Notes:
 The Library is available via PyPI and can be installed with
 
 ```shell
-  pip install shepherd-core -U
+pip install shepherd-core -U
 
-  # or for the full experience (includes core)
-  pip install shepherd-data -U
+# or for the full experience (includes core)
+pip install shepherd-data -U
 ```
 
 For bleeding-edge-features or dev-work it is possible to install directly from GitHub-Sources (here `dev`-branch):
 
 ```Shell
 pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U
+# and on sheep with newer debian
+pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U --break-system-packages
 ```
 
 If you are working with ``.elf``-files (embedding into experiments) you make "objcopy" accessible to python. In Ubuntu, you can either install ``build-essential`` or ``binutils-$ARCH`` with arch being ``msp430`` or ``arm-none-eabi`` for the nRF52.
 
 ```shell
-  sudo apt install build-essential
+sudo apt install build-essential
 ```
 
 For more advanced work with ``.elf``-files (modify value of symbols / target-ID) you should install
 
 ```shell
-  pip install shepherd-core[elf]
+pip install shepherd-core[elf]
 ```
 
 and also make sure the prereqs for the [pwntools](https://docs.pwntools.com/en/stable/install.html) are met.
@@ -165,7 +167,7 @@ and also make sure the prereqs for the [pwntools](https://docs.pwntools.com/en/s
 For creating an inventory of the host-system you should install
 
 ```shell
-  pip install shepherd-core[inventory]
+pip install shepherd-core[inventory]
 ```
 
 ## Unittests

{shepherd_core-2024.7.2.dist-info → shepherd_core-2024.7.4.dist-info}/RECORD

@@ -1,31 +1,32 @@
-shepherd_core/__init__.py,sha256=18yq3YRDzCrO_xW5GXUgekF_LRg6kK87V2jnxE38d2E,1385
-shepherd_core/calibration_hw_def.py,sha256=m5HDxHJ_blnn-C0Og5v6by1ApJRDT7RhytFbL-P5730,2548
+shepherd_core/__init__.py,sha256=QyqENyf508XfZQ4vDU5o6UL9rmIqkf8kzwgTF9XU1-Y,1270
+shepherd_core/calibration_hw_def.py,sha256=_nMzgNzSnYyqcLnVCGd4tfA2e0avUXbccjmNpFhiDgo,2830
 shepherd_core/commons.py,sha256=vymKXWcy_1bz7ChzzEATUkJ4p3czCzjIdsSehVjJOY8,218
 shepherd_core/logger.py,sha256=4Q4hTI-nccOZ1_A68fo4UEctfu3pJx3IeHfa9VuDDEo,1804
 shepherd_core/reader.py,sha256=9BuArqou5pmPKUrJH9oiPYlU1DkMxUScL4nftDJuFIs,26790
+shepherd_core/version.py,sha256=nuk8f6h1RBadV7-koFp4yLk1jExaUHnFqMTtxlKZyCo,75
 shepherd_core/writer.py,sha256=xcLCw-YokKaN8TrkwD0IjRmn8xZU0Q8wwWp_1K8JFVY,14475
 shepherd_core/data_models/__init__.py,sha256=IVjKbT2Ilz5bev325EvAuuhd9LfQgQ1u7qKo6dhVA2k,1866
 shepherd_core/data_models/readme.md,sha256=1bdfEypY_0NMhXLxOPRnLAsFca0HuHdq7_01yEWxvUs,2470
 shepherd_core/data_models/virtual_source_doc.txt,sha256=KizMcfGKj7BnHIbaJHT7KeTF01SV__UXv01qV_DGHSs,6057
 shepherd_core/data_models/base/__init__.py,sha256=PSJ6acWViqBm0Eiom8DIgKfFVrp5lzYr8OsDvP79vwI,94
 shepherd_core/data_models/base/cal_measurement.py,sha256=YScPG7QLynbUHdjcznYqU8O5KRh0XiROGxGSk9BETMk,3357
-shepherd_core/data_models/base/calibration.py,sha256=HPhDEaApOCKxfX2q9RD8YCvA3Gqls-2bHqvLLvOM7kY,10415
+shepherd_core/data_models/base/calibration.py,sha256=iy04ajChReqrRNLoNDEH01CM-iCvb5XepBIlyFSWeII,10466
 shepherd_core/data_models/base/content.py,sha256=13j7GSgT73xn27jgDP508thUEJR4U-nCb5n7CJ50c9Y,2463
 shepherd_core/data_models/base/shepherd.py,sha256=DNrx59o1VBuy_liJuUzZRzmTTYB73D_pUWiNyMQyjYY,6112
 shepherd_core/data_models/base/timezone.py,sha256=2T6E46hJ1DAvmqKfu6uIgCK3RSoAKjGXRyzYNaqKyjY,665
-shepherd_core/data_models/base/wrapper.py,sha256=duOdIXJeSOab4lVhe9ujhnjhJv3ue0mhimuUjy1xy3A,635
+shepherd_core/data_models/base/wrapper.py,sha256=Izp17HFCKNAS3TnWcPn3MM9fWdc3A-F7eDyAsYlyWCw,755
 shepherd_core/data_models/content/__init__.py,sha256=wVa5lw6bS-fBgeo-SWydg6rw8AsScxqNgDo81dzteaE,537
 shepherd_core/data_models/content/_external_fixtures.yaml,sha256=0CH7YSWT_hzL-jcg4JjgN9ryQOzbS8S66_pd6GbMnHw,12259
-shepherd_core/data_models/content/energy_environment.py,sha256=HeMcM01fS2YzhvIh5bt6lC9vW2sBrPt7X_jGdEe8k_g,1374
+shepherd_core/data_models/content/energy_environment.py,sha256=bXInmHzlRjBAt7mitig35V-zCfj98ZvGEBio0miSxRg,1425
 shepherd_core/data_models/content/energy_environment_fixture.yaml,sha256=UBXTdGT7MK98zx5w_RBCu-f9uNCKxRgiFBQFbmDUxPc,1301
-shepherd_core/data_models/content/firmware.py,sha256=rv5gAOYq4Al-sAg3v5TuYrxONMKLngBsdln3hbmISTA,5659
+shepherd_core/data_models/content/firmware.py,sha256=MyEiaP6bkOm7i_oihDXTxHC7ajc5aqiIDLn7mhap6YY,5722
 shepherd_core/data_models/content/firmware_datatype.py,sha256=XPU9LOoT3h5qFOlE8WU0vAkw-vymNxzor9kVFyEqsWg,255
 shepherd_core/data_models/content/virtual_harvester.py,sha256=5eEHAZrgHPHZlTxDGaJrckDQgupFNC3Zax67EcCSqR8,9448
 shepherd_core/data_models/content/virtual_harvester_fixture.yaml,sha256=-IRyoQU0HXCEtIIcFmkFdz4snLB7bjFFqNcFVGSMiSA,4332
 shepherd_core/data_models/content/virtual_source.py,sha256=aoD8oam1POid0JG2ppttPA_Jl3y4ko5FNqzoaNKyBD8,14142
 shepherd_core/data_models/content/virtual_source_fixture.yaml,sha256=kx_lpBx0bLKqEHxS09GTnk8kuSbhuGhLgKHeaM6UviE,10481
 shepherd_core/data_models/experiment/__init__.py,sha256=9TE9_aSnCNRhagsIWLTE8XkyjyMGB7kEGdswl-296v0,645
-shepherd_core/data_models/experiment/experiment.py,sha256=QX3-oeBe5dRx1a_RHF6kxjdQAyCRcLiMmSw4gYDjbEg,3949
+shepherd_core/data_models/experiment/experiment.py,sha256=wnn6T3czuh4rz6OSYtMltCTbRpPX55TLVAtQcKO7Uhg,4044
 shepherd_core/data_models/experiment/observer_features.py,sha256=qxnb7anuQz9ZW5IUlPdUXYPIl5U7O9uXkJqZtMnAb0Y,5156
 shepherd_core/data_models/experiment/target_config.py,sha256=XIsjbbo7yn_A4q3GMxWbiNzEGA0Kk5gH7-XfQQ7Kg0E,3674
 shepherd_core/data_models/task/__init__.py,sha256=rZLbgqX-dTWY4026-bqW-IWVHbA6C_xP9y0aeRze8FY,3374
@@ -34,7 +35,7 @@ shepherd_core/data_models/task/firmware_mod.py,sha256=Rw_TA1ykQ7abUd_U0snqZlpZyr
 shepherd_core/data_models/task/harvest.py,sha256=HHnqWwRsJupaZJxuohs7NrK6VaDyoRzGOaG2h9y3s1Y,3360
 shepherd_core/data_models/task/observer_tasks.py,sha256=XlH_-EGRrdodTn0c2pjGvpcauc0a9NOnLhysKw8iRwk,3511
 shepherd_core/data_models/task/programming.py,sha256=Mg9_AZHIdG01FheEJAifIRPSB3iZ0UJITf8zeg2jyws,2323
-shepherd_core/data_models/task/testbed_tasks.py,sha256=yU4YhNN1ObYkcts7UOwkWWhCmW67f_Gjx3dhvzMnKWI,2036
+shepherd_core/data_models/task/testbed_tasks.py,sha256=zvIitq0Ek1Ae7baWiBkSQN8nRugyw0N2P4SeVoj_QaY,2090
 shepherd_core/data_models/testbed/__init__.py,sha256=cL3swgijyIpZIW1vl51OVR2seAlWt6Ke9oB_cBkPniU,612
 shepherd_core/data_models/testbed/cape.py,sha256=D23ZKXpZRPIIOMn6LCoJrwHiRbSaYg-y7B6fAt1ap64,1246
 shepherd_core/data_models/testbed/cape_fixture.yaml,sha256=uwZxe6hsqvofn5tzg4sffjbVtTVUkextL1GCri_z2A4,2197
@@ -46,7 +47,7 @@ shepherd_core/data_models/testbed/observer.py,sha256=hlj6buDzUQKYnlhCJZyxnrAPYKo
 shepherd_core/data_models/testbed/observer_fixture.yaml,sha256=w4VS6lTzaVs5IqWjkHanxcjDhIEydQPCV6z_DlsLFqA,4812
 shepherd_core/data_models/testbed/target.py,sha256=KeJaLradQ3oHeeowCg_X0lDHDqyi3R3La0YPKC5Rv90,1838
 shepherd_core/data_models/testbed/target_fixture.yaml,sha256=6YbCV3aTtDUKzC40kPURq9nFwTjT97LNy7imOb_35sk,3668
-shepherd_core/data_models/testbed/testbed.py,sha256=jLgidZMB0LhoP99s_OOADFPZgCipio1q3kLLiXg9Ekw,3353
+shepherd_core/data_models/testbed/testbed.py,sha256=0uJ3OwqCKDn78OCJOaMa2XWxTLF1ultjmpHVSx3LyhE,3695
 shepherd_core/data_models/testbed/testbed_fixture.yaml,sha256=9i2cmYRrHOHTJG9zp40h8h0LgO9DdrCJz8tyGdiQCzc,714
 shepherd_core/decoder_waveform/__init__.py,sha256=-ohGz0fA2tKxUJk4FAQXKtI93d6YGdy0CrkdhOod1QU,120
 shepherd_core/decoder_waveform/uart.py,sha256=sHsXHOsDU1j9zMSZO7CCMTMinT4U_S5NgsEkl1lJK1U,11029
@@ -59,17 +60,18 @@ shepherd_core/inventory/__init__.py,sha256=nRO11HG4eJ_FaXebSkE0dd1H6qvjrX5n3OQHO
 shepherd_core/inventory/python.py,sha256=OWNnyEt0IDPW9XGW-WloU0FExwgZzYNA05VpRj4cZGc,1250
 shepherd_core/inventory/system.py,sha256=jRzko9QNPLaBiG7urVaeqqvb3GtCEYRwc0DAghRkLVo,3159
 shepherd_core/inventory/target.py,sha256=Lq11j25tWieXheOxIDaQb-lc-2omxYVex5P6uGiLUyk,507
-shepherd_core/testbed_client/__init__.py,sha256=lzi7F5Go-AsbTbiUCf9Rnu6pzmTZqmpIqoS1yCPal_c,175
+shepherd_core/testbed_client/__init__.py,sha256=kV-_g1ZiopWg2Aoq0k7fPD0pDqHrMDVYnNOrMBBWgnY,234
 shepherd_core/testbed_client/cache_path.py,sha256=tS0er9on5fw8wddMCt1jkc2uyYOdSTvX_UmfmYJf6tY,445
-shepherd_core/testbed_client/client.py,sha256=3vbJ9XdWe9YA28AXgzXThHJtYJU5RUUCpDRBH1mDIr8,5917
-shepherd_core/testbed_client/fixtures.py,sha256=TDRVtxorJ5IFlFwwVcSDpAm1g51ok1PPMt1WmdBpzaM,9748
+shepherd_core/testbed_client/client_abc_fix.py,sha256=BsSkpvJHURRejlS-YPF1f6QRPC_X0fYEsJpinzsx6Jc,4079
+shepherd_core/testbed_client/client_web.py,sha256=iMh5T91152uugbFsqr2vvxLser0KIo5g426dp_6QWUE,5774
+shepherd_core/testbed_client/fixtures.py,sha256=4Uk583R4r6I5IB78HxOn-9UNH3sbFha7OPEdcSXvMCU,9939
 shepherd_core/testbed_client/user_model.py,sha256=5M3vWkAGBwdGDUYAanAjrZwpzMBlh3XLOVvNYWiLmms,2107
 shepherd_core/vsource/__init__.py,sha256=dS33KYLq5GQ9_D8HfdP8iWSocWTghCi2ZZG2AJWNfaM,391
 shepherd_core/vsource/virtual_converter_model.py,sha256=ZSoWVLfRmFEjeCNoQCg3BctzhdfayINUBDU_AJK1CR0,10404
 shepherd_core/vsource/virtual_harvester_model.py,sha256=wCbFfsqDRC5Rfu8qANkmkP9XGJOPHJY9-iSnI850JI4,7817
 shepherd_core/vsource/virtual_source_model.py,sha256=fjN8myTY3I_LpikF_aGAcxes3RGu1GP23P7XKC_UIyA,2737
-shepherd_core-2024.7.2.dist-info/METADATA,sha256=StULIM0aTJCmN4b1RQYkQsC5BniVCv7SEO4BJmuGHcg,7630
-shepherd_core-2024.7.2.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-shepherd_core-2024.7.2.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
-shepherd_core-2024.7.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-shepherd_core-2024.7.2.dist-info/RECORD,,
+shepherd_core-2024.7.4.dist-info/METADATA,sha256=zFRCTLQEf-XN8Szx8fxb2JwCA6H0F26oUU5UMgWxVaA,7771
+shepherd_core-2024.7.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+shepherd_core-2024.7.4.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
+shepherd_core-2024.7.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+shepherd_core-2024.7.4.dist-info/RECORD,,

{shepherd_core-2024.7.2.dist-info → shepherd_core-2024.7.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

shepherd_core/testbed_client/client.py

@@ -1,161 +0,0 @@
-"""Client-Class to access a testbed instance."""
-
-from importlib import import_module
-from pathlib import Path
-from typing import Optional
-from typing import TypedDict
-from typing import Union
-
-from pydantic import validate_call
-from typing_extensions import Self
-from typing_extensions import Unpack
-
-from ..commons import testbed_server_default
-from ..data_models.base.shepherd import ShpModel
-from ..data_models.base.wrapper import Wrapper
-from .fixtures import Fixtures
-from .user_model import User
-
-
-class TestbedClient:
-    """Client-Class to access a testbed instance."""
-
-    _instance: Optional[Self] = 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
-            self._user: Optional[User] = None
-            self._key: Optional[str] = None
-            self._fixtures: Optional[Fixtures] = Fixtures()
-            self._connected: bool = False
-            self._req = None
-        if server is not None:
-            self.connect(server=server, token=token)
-
-    @classmethod
-    def __new__(cls, *_args: tuple, **_kwargs: Unpack[TypedDict]) -> Self:
-        if cls._instance is None:
-            cls._instance = object.__new__(cls)
-        return cls._instance
-
-    def __del__(self) -> None:
-        TestbedClient._instance = None
-
-    @validate_call
-    def connect(self, server: Optional[str] = None, token: Union[str, Path, None] = None) -> bool:
-        """Establish connection to testbed-server.
-
-        server: either "local" to use demo-fixtures or something like "https://HOST:PORT"
-        token: your account validation.
-        """
-        if isinstance(token, Path):
-            with token.resolve().open() as file:
-                self._token = file.read()
-        elif isinstance(token, str):
-            self._token = token
-
-        if server:
-            self._server = server.lower()
-
-        if self._server:
-            self._req = import_module("requests")  # here due to slow startup
-
-            # extended connection-test:
-            self._query_session_key()
-            self._connected = True
-            return self._query_user_data()
-
-        return True
-
-    def insert(self, data: ShpModel) -> bool:
-        wrap = Wrapper(
-            datatype=type(data).__name__,
-            parameters=data.model_dump(),
-        )
-        if self._connected:
-            r = self._req.post(self._server + "/add", data=wrap.model_dump_json(), timeout=2)
-            r.raise_for_status()
-        else:
-            self._fixtures.insert_model(wrap)
-        return True
-
-    def query_ids(self, model_type: str) -> list:
-        if self._connected:
-            raise NotImplementedError("TODO")
-        return list(self._fixtures[model_type].elements_by_id.keys())
-
-    def query_names(self, model_type: str) -> list:
-        if self._connected:
-            raise NotImplementedError("TODO")
-        return list(self._fixtures[model_type].elements_by_name.keys())
-
-    def query_item(
-        self, model_type: str, uid: Optional[int] = None, name: Optional[str] = None
-    ) -> dict:
-        if self._connected:
-            raise NotImplementedError("TODO")
-        if uid is not None:
-            return self._fixtures[model_type].query_id(uid)
-        if name is not None:
-            return self._fixtures[model_type].query_name(name)
-        raise ValueError("Query needs either uid or name of object")
-
-    def _query_session_key(self) -> bool:
-        if self._server:
-            r = self._req.get(self._server + "/session_key", timeout=2)
-            r.raise_for_status()
-            self._key = r.json()["value"]  # TODO: not finished
-            return True
-        return False
-
-    def _query_user_data(self) -> bool:
-        if self._server:
-            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()
-            self._user = User(**r.json())
-            return True
-        return False
-
-    def try_inheritance(self, model_type: str, values: dict) -> (dict, list):
-        if self._connected:
-            raise NotImplementedError("TODO")
-        return self._fixtures[model_type].inheritance(values)
-
-    def try_completing_model(self, model_type: str, values: dict) -> (dict, list):
-        """Init by name/id, for none existing instances raise Exception."""
-        if len(values) == 1 and next(iter(values.keys())) in {"id", "name"}:
-            value = next(iter(values.values()))
-            if (
-                isinstance(value, str)
-                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:
-                # TODO: still depending on _fixture
-                values = self.query_item(model_type, uid=value)
-            else:
-                msg = f"Query {model_type} by name / ID failed - {values} is unknown!"
-                raise ValueError(msg)
-        return self.try_inheritance(model_type, values)
-
-    def fill_in_user_data(self, values: dict) -> dict:
-        if self._user:
-            # TODO: this looks wrong, should have "is None", why not always overwrite?
-            if values.get("owner"):
-                values["owner"] = self._user.name
-            if values.get("group"):
-                values["group"] = self._user.group
-
-        # hotfix until testbed.client is working, TODO
-        if values.get("owner") is None:
-            values["owner"] = "unknown"
-        if values.get("group") is None:
-            values["group"] = "unknown"
-
-        return values
-
-
-tb_client = TestbedClient()