shepherd-core 2024.7.2__tar.gz → 2024.7.3__tar.gz

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd_core
-Version: 2024.7.2
+Version: 2024.7.3
 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>

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/examples/experiment_generic_var1.py

@@ -15,7 +15,7 @@ What the code does:
 
 from pathlib import Path
 
-from shepherd_core import TestbedClient
+from shepherd_core import WebClient
 from shepherd_core.data_models import FirmwareDType
 from shepherd_core.data_models import GpioTracing
 from shepherd_core.data_models.content import EnergyEnvironment
@@ -25,16 +25,14 @@ from shepherd_core.data_models.experiment import TargetConfig
 from shepherd_core.data_models.task import TestbedTasks
 from shepherd_core.data_models.testbed import MCU
 
-# for online-queries the lib can be connected to the testbed-server
+# For online-queries the lib can be connected to the testbed-server.
 # NOTE: there are 3 states:
-#    - unconnected -> demo-fixture is queried (locally)
-#    - connected -> publicly available data is queried online
-#    - logged in with token -> also private data is queried online
-tb_client = TestbedClient()
+# - unconnected -> demo-fixtures are queried (locally)
+# - connected -> publicly available data is queried online
+# - logged in with valid token -> also private data is queried online
 do_connect = False
-
 if do_connect:
-    tb_client.connect()
+    WebClient()
 
 xp = Experiment(
     id="4567",

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/examples/experiment_generic_var2.py

@@ -14,7 +14,7 @@
 
 from pathlib import Path
 
-from shepherd_core import TestbedClient
+from shepherd_core import WebClient
 from shepherd_core.data_models import GpioTracing
 from shepherd_core.data_models.content import EnergyEnvironment
 from shepherd_core.data_models.content import Firmware
@@ -22,16 +22,14 @@ from shepherd_core.data_models.experiment import Experiment
 from shepherd_core.data_models.experiment import TargetConfig
 from shepherd_core.data_models.task import TestbedTasks
 
-# for online-queries the lib can be connected to the testbed-server
+# For online-queries the lib can be connected to the testbed-server.
 # NOTE: there are 3 states:
-#    - unconnected -> demo-fixture is queried (locally)
-#    - connected -> publicly available data is queried online
-#    - logged in with token -> also private data is queried online
-tb_client = TestbedClient()
+# - unconnected -> demo-fixtures are queried (locally)
+# - connected -> publicly available data is queried online
+# - logged in with valid token -> also private data is queried online
 do_connect = False
-
 if do_connect:
-    tb_client.connect()
+    WebClient()
 
 xp = Experiment(
     id="4567",

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/examples/experiment_models.py

@@ -18,7 +18,7 @@ How to define an experiment:
 
 """
 
-from shepherd_core import TestbedClient
+from shepherd_core import WebClient
 from shepherd_core.data_models.content import EnergyEnvironment
 from shepherd_core.data_models.content import Firmware
 from shepherd_core.data_models.content import VirtualHarvesterConfig
@@ -30,16 +30,14 @@ from shepherd_core.data_models.task import TestbedTasks
 # generate description for all parameters -> base for web-forms
 Experiment.schema_to_file("experiment_schema.yaml")
 
-# for online-queries the lib can be connected to the testbed-server
+# For online-queries the lib can be connected to the testbed-server.
 # NOTE: there are 3 states:
-#    - unconnected -> demo-fixture is queried (locally)
-#    - connected -> publicly available data is queried online
-#    - logged in with token -> also private data is queried online
-tb_client = TestbedClient()
+# - unconnected -> demo-fixtures are queried (locally)
+# - connected -> publicly available data is queried online
+# - logged in with valid token -> also private data is queried online
 do_connect = False
-
 if do_connect:
-    tb_client.connect()
+    WebClient()
 
 # Defining an Experiment in Python
 hrv = VirtualHarvesterConfig(name="mppt_bq_thermoelectric")

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/examples/firmware_model.py

@@ -6,7 +6,7 @@ or shepherd-core[elf].
 
 from pathlib import Path
 
-from shepherd_core import TestbedClient
+from shepherd_core import WebClient
 from shepherd_core import fw_tools
 from shepherd_core.data_models import Firmware
 from shepherd_core.data_models import FirmwareDType
@@ -41,9 +41,7 @@ print(f"stored firmware to '{path_elf2.name}'")
 
 # Option 3 - fully automatic (with login) -> owner and group get prefilled
 
-tb_client = TestbedClient()
 do_connect = False
-
 if do_connect:
-    tb_client.connect(token="your_personal_login_token")  # noqa: S106
+    WebClient(token="your_personal_login_token")  # noqa: S106
     fw3 = Firmware.from_firmware(file=path_elf, name="msp_deep_sleep3")

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/examples/vharvester_simulation.py

@@ -9,7 +9,6 @@
 from pathlib import Path
 
 from shepherd_core import Reader
-from shepherd_core import TestbedClient
 from shepherd_core.data_models import VirtualHarvesterConfig
 from shepherd_core.data_models.content.virtual_harvester import HarvesterPRUConfig
 from shepherd_core.vsource import VirtualHarvesterModel
@@ -33,17 +32,6 @@ hrv_list = [
     "mppt_opt",
 ]
 
-# for online-queries the lib can be connected to the testbed-server
-# NOTE: there are 3 states:
-#    - unconnected -> demo-fixture is queried (locally)
-#    - connected -> publicly available data is queried online
-#    - logged in with token -> also private data is queried online
-tb_client = TestbedClient()
-do_connect = False
-
-if do_connect:
-    tb_client.connect()
-
 # convert IVonne to IVCurve
 if not file_ivcurve.exists():
     with ivonne.Reader(file_ivonne) as db:

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/examples/vsource_simulation.py

@@ -16,7 +16,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 from shepherd_core import CalibrationEmulator
-from shepherd_core import TestbedClient
+from shepherd_core import WebClient
 from shepherd_core.data_models import VirtualSourceConfig
 from shepherd_core.vsource import VirtualSourceModel
 
@@ -38,16 +38,14 @@ src_list = [
 I_mcu_sleep_A = 200e-9
 I_mcu_active_A = 1e-3
 
-# for online-queries the lib can be connected to the testbed-server
+# For online-queries the lib can be connected to the testbed-server.
 # NOTE: there are 3 states:
-#    - unconnected -> demo-fixture is queried (locally)
-#    - connected -> publicly available data is queried online
-#    - logged in with token -> also private data is queried online
-tb_client = TestbedClient()
+# - unconnected -> demo-fixtures are queried (locally)
+# - connected -> publicly available data is queried online
+# - logged in with valid token -> also private data is queried online
 do_connect = False
-
 if do_connect:
-    tb_client.connect()
+    WebClient()
 
 for vs_name, v_hrv_mV, samples in product(src_list, v_hrv_mV_list, sample_dur_list):
     # prepare simulation

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/pyproject.toml

@@ -94,7 +94,7 @@ shepherd_core = [
 ]
 
 [tool.setuptools.dynamic]
-version = {attr = "shepherd_core.__version__"}
+version = {attr = "shepherd_core.version.version"}
 
 [tool.pytest.ini_options]
 markers = [

{shepherd_core-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.2 → shepherd_core-2024.7.3}/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-2024.7.3/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-2024.7.3/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-2024.7.2 → shepherd_core-2024.7.3}/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