snakemake-interface-software-deployment-plugins 0.7.0__tar.gz → 0.7.2__tar.gz

{snakemake_interface_software_deployment_plugins-0.7.0 → snakemake_interface_software_deployment_plugins-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snakemake-interface-software-deployment-plugins
-Version: 0.7.0
+Version: 0.7.2
 Summary: This package provides a stable interface for interactions between Snakemake and its software deployment plugins.
 License: MIT
 Author: Johannes Köster

{snakemake_interface_software_deployment_plugins-0.7.0 → snakemake_interface_software_deployment_plugins-0.7.2}/pyproject.toml

@@ -5,7 +5,7 @@ license = "MIT"
 name = "snakemake-interface-software-deployment-plugins"
 packages = [{include = "snakemake_interface_software_deployment_plugins"}]
 readme = "README.md"
-version = "0.7.0"
+version = "0.7.2"
 
 [tool.poetry.dependencies]
 argparse-dataclass = "^2.0.0"

{snakemake_interface_software_deployment_plugins-0.7.0 → snakemake_interface_software_deployment_plugins-0.7.2}/snakemake_interface_software_deployment_plugins/__init__.py

@@ -247,7 +247,7 @@ class PinnableEnvBase(ABC):
     def pinfile_extension(cls) -> str: ...
 
     @abstractmethod
-    def pin(self) -> None:
+    async def pin(self) -> None:
         """Pin the environment to potentially more concrete versions than defined.
         Only implement this base class if pinning makes sense for your kind of
         environment. Pinfile has to be written to self.pinfile.
@@ -269,7 +269,7 @@ class CacheableEnvBase(ABC):
     async def get_cache_assets(self) -> Iterable[str]: ...
 
     @abstractmethod
-    def cache_assets(self) -> None:
+    async def cache_assets(self) -> None:
         """Determine environment assets and store any associated information or data to
         self.cache_path.
         """

{snakemake_interface_software_deployment_plugins-0.7.0 → snakemake_interface_software_deployment_plugins-0.7.2}/snakemake_interface_software_deployment_plugins/tests.py

@@ -1,18 +1,18 @@
 from abc import ABC, abstractmethod
 import asyncio
 from copy import deepcopy
-import tempfile
 from typing import Optional, Type
 import subprocess as sp
 
 import pytest
 
 from snakemake_interface_software_deployment_plugins import (
-    ArchiveableEnvBase,
+    CacheableEnvBase,
     DeployableEnvBase,
     EnvBase,
     EnvSpecBase,
     EnvSpecSourceFile,
+    PinnableEnvBase,
     SoftwareReport,
 )
 from snakemake_interface_software_deployment_plugins.settings import (
@@ -52,10 +52,22 @@ class TestSoftwareDeploymentBase(ABC):
         ...
 
     @abstractmethod
-    def get_software_deployment_provider_settings(
+    def get_settings(
         self,
     ) -> Optional[SoftwareDeploymentSettingsBase]: ...
 
+    @abstractmethod
+    def get_settings_cls(self) -> Optional[Type[SoftwareDeploymentSettingsBase]]: ...
+
+    def test_envspec_str(self):
+        print("env spec", str(self.get_env_spec()))
+
+    def test_default_settings(self):
+        settings_cls = self.get_settings_cls()
+        if settings_cls is None:
+            pytest.skip("No settings class defined.")
+        settings_cls()
+
     def test_shellcmd(self, tmp_path):
         env = self._get_env(tmp_path)
 
@@ -80,13 +92,24 @@ class TestSoftwareDeploymentBase(ABC):
 
     def test_archive(self, tmp_path):
         env = self._get_env(tmp_path)
-        if not isinstance(env, ArchiveableEnvBase):
-            pytest.skip("Environment either not deployable or not archiveable.")
+        if not isinstance(env, CacheableEnvBase):
+            pytest.skip("Environment either not deployable or not cacheable.")
+
+        asyncio.run(env.cache_assets())
 
         self._deploy(env, tmp_path)
 
-        asyncio.run(env.archive())
-        assert any((tmp_path / "archives").iterdir())
+        assert any(env.cache_path.iterdir())
+
+    def test_pin(self, tmp_path):
+        env = self._get_env(tmp_path)
+        if not isinstance(env, PinnableEnvBase):
+            pytest.skip("Environment is not pinnable.")
+
+        asyncio.run(env.pin())
+        assert env.pinfile.exists()
+        print("Pinfile content:", env.pinfile.read_text(), sep="\n")
+        self._deploy(env, tmp_path)
 
     def test_report_software(self, tmp_path):
         env = self._get_env(tmp_path)
@@ -113,22 +136,32 @@ class TestSoftwareDeploymentBase(ABC):
         spec = deepcopy(self.get_env_spec())
         for attr in spec.source_path_attributes():
             source_file = getattr(spec, attr)
-            source_file.cached = source_file.path_or_uri
+            if source_file is not None:
+                source_file.cached = source_file.path_or_uri
         return spec
 
     def _get_env(self, tmp_path) -> EnvBase:
         env_cls = self.get_env_cls()
         spec = self._get_cached_env_spec()
-        args = {
-            "settings": self.get_software_deployment_provider_settings(),
-            "tempdir": tempfile.gettempdir(),
-        }
-        if issubclass(env_cls, DeployableEnvBase):
-            args["deployment_prefix"] = tmp_path / "deployments"
-        if issubclass(env_cls, ArchiveableEnvBase):
-            args["archive_prefix"] = tmp_path / "archives"
+
+        tempdir = tmp_path / "temp"
+        deployment_prefix = tmp_path / "deployments"
+        cache_prefix = tmp_path / "cache"
+        pinfile_prefix = tmp_path / "pinfiles"
+        tempdir.mkdir(parents=True, exist_ok=True)
+        deployment_prefix.mkdir(parents=True, exist_ok=True)
+        cache_prefix.mkdir(parents=True, exist_ok=True)
+        pinfile_prefix.mkdir(parents=True, exist_ok=True)
+
         return env_cls(
-            spec=spec, within=None, shell_executable=self.shell_executable, **args
+            spec=spec,
+            within=None,
+            settings=self.get_settings(),
+            shell_executable=self.shell_executable,
+            tempdir=tempdir,
+            deployment_prefix=deployment_prefix,
+            cache_prefix=cache_prefix,
+            pinfile_prefix=pinfile_prefix,
         )
 
     def _deploy(self, env: DeployableEnvBase, tmp_path):