snk-cli 0.7.1__tar.gz → 0.8.0__tar.gz

{snk_cli-0.7.1 → snk_cli-0.8.0}/.github/workflows/publish.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/setup-python@v4
         with:
           python-version: 3.x
-      - uses: actions/cache@v2
+      - uses: actions/cache@v5
         with:
           key: ${{ github.ref }}
           path: .cache

snk_cli-0.8.0/.github/workflows/tests.yml

@@ -0,0 +1,66 @@
+name: tests
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+    branches:
+      - "*"
+
+permissions:
+  contents: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        snakemake-version: ["==7.32.4", ">8,<9", ">=9,<10"]
+        exclude:
+          # Exclude incompatible combinations
+          - python-version: "3.10"
+            snakemake-version: ">8,<9"
+          - python-version: "3.10"
+            snakemake-version: ">=9,<10"
+        include:
+          - python-version: "3.14"
+            snakemake-version: ">=9.22,<10"
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up conda
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-activate-base: false
+          channels: conda-forge,bioconda,defaults
+          channel-priority: strict
+
+      - name: Install pip dependencies
+        run: |
+          pip install hatch
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y llvm clang build-essential graphviz
+
+      - name: Run tests
+        env:
+          AR: /usr/bin/ar
+        shell: bash
+        run: |
+          hatch python install ${{ matrix.python-version }}
+          hatch --env "snakemake.py${{ matrix.python-version }}-${{ matrix.snakemake-version }}" run cov
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          files: ./coverage.xml
+          flags: ${{ matrix.python-version }}-snakemake-${{ matrix.snakemake-version }}

{snk_cli-0.7.1 → snk_cli-0.8.0}/PKG-INFO

@@ -1,11 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: snk-cli
-Version: 0.7.1
+Version: 0.8.0
 Project-URL: Documentation, https://github.com/wytamma/snk-cli#readme
 Project-URL: Issues, https://github.com/wytamma/snk-cli/issues
 Project-URL: Source, https://github.com/wytamma/snk-cli
 Author-email: Wytamma Wirth <wytamma.wirth@me.com>
-License: MIT
+License-Expression: MIT
+License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.8
@@ -13,16 +14,18 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
 Requires-Dist: art~=5.9
-Requires-Dist: datrie>=0.8.2
 Requires-Dist: makefun~=1.15
 Requires-Dist: pulp<2.8
 Requires-Dist: rich>=10.11.0
 Requires-Dist: shellingham>=1.3.0
-Requires-Dist: snakemake>=7
+Requires-Dist: snakemake>=7; python_version < '3.14'
+Requires-Dist: snakemake>=9.22; python_version >= '3.14'
 Requires-Dist: typer~=0.9
 Description-Content-Type: text/markdown
 

{snk_cli-0.7.1 → snk_cli-0.8.0}/pyproject.toml

@@ -21,18 +21,20 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "snakemake>=7",
+  "snakemake>=7; python_version < '3.14'",
+  "snakemake>=9.22; python_version >= '3.14'",
   "typer~=0.9",
   "shellingham >=1.3.0",
   "rich >=10.11.0",
   "pulp<2.8",  # Pin pulp <2.8 for snakemake: https://github.com/snakemake/snakemake/issues/2607
   "art~=5.9",
   "makefun~=1.15",
-  "datrie>=0.8.2",
 ]
 
 [project.urls]
@@ -45,7 +47,16 @@ path = "src/snk_cli/__about__.py"
 
 
 [[tool.hatch.envs.snakemake.matrix]]
-snakemake = ["==7.32.4", ">8"]
+snakemake = ["==7.32.4"]  # Compatible with Python 3.10–3.13
+python = ["3.10", "3.11", "3.12", "3.13"]
+
+[[tool.hatch.envs.snakemake.matrix]]
+snakemake = [">8,<9", ">=9,<10"]
+python = ["3.11", "3.12", "3.13"]
+
+[[tool.hatch.envs.snakemake.matrix]]
+snakemake = [">=9.22,<10"]  # Python 3.14 support starts with Snakemake 9.22
+python = ["3.14"]
 
 [tool.hatch.envs.default]
 dependencies = [
@@ -64,9 +75,10 @@ cov = [
   "test-cov",
   "cov-report",
 ]
+list-deps = "pip list"
 
 [[tool.hatch.envs.all.matrix]]
-python = ["3.9", "3.10", "3.11", "3.12"]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
 [tool.hatch.envs.types]
 dependencies = [

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Wytamma Wirth <wytamma.wirth@me.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.7.1"
+__version__ = "0.8.0"

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/conda.py

@@ -1,21 +1,22 @@
 # This file contains functions to create and manage conda environments for snakemake workflows
-# it needs to work with v 7 and 8 of snakemake
+# it needs to work with v 7, 8 and 9 of snakemake
 # 
 from pathlib import Path
 from packaging import version
 from dataclasses import dataclass
+import inspect
 import os
 
 from snk_cli.utils import check_command_available
 from snakemake.deployment.conda import Env
-from snakemake.persistence import Persistence
 import snakemake
 
 snakemake_version = version.parse(snakemake.__version__)
 is_snakemake_version_8_or_above = snakemake_version >= version.parse('8')
+is_snakemake_version_9_or_above = snakemake_version >= version.parse('9')
 
 @dataclass
-class PersistenceMock(Persistence):
+class PersistenceMock:
     """
     Mock for workflow.persistence
     """
@@ -27,9 +28,14 @@ class PersistenceMock(Persistence):
     container_img_path: Path = None
     aux_path: Path = None
 
+    def __post_init__(self):
+        for path in (self.conda_env_path, self.conda_env_archive_path):
+            if path:
+                Path(path).mkdir(parents=True, exist_ok=True)
+
 
 def get_frontend():
-    if check_command_available("mamba"):
+    if check_command_available("mamba") and not is_snakemake_version_9_or_above:
         conda_frontend = "mamba"
     else:
         conda_frontend = "conda"
@@ -70,6 +76,7 @@ def create_workflow_v8(
         WorkflowSettings,
         StorageSettings,
     )
+    workflow_kwargs = {"logger_manager": None} if "logger_manager" in inspect.signature(Workflow).parameters else {}
     conda_frontend = get_frontend()
     workflow = Workflow(
         config_settings=ConfigSettings(),
@@ -80,6 +87,7 @@ def create_workflow_v8(
             conda_frontend=conda_frontend, 
             conda_prefix=conda_prefix
         ),
+        **workflow_kwargs,
     )
     persistence = PersistenceMock(
         conda_env_path=Path(conda_prefix).resolve() if conda_prefix else None,

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/config/config.py

@@ -117,7 +117,7 @@ class SnkConfig:
         invalid_config_keys = set(snk_config_dict.keys()) - fields
         if invalid_config_keys:
             import warnings
-            warnings.warn(f"invalid keys in `snk.yaml` file: {invalid_config_keys}.")
+            warnings.warn(f"""invalid keys '{" ".join(invalid_config_keys)}' in {snk_config_path}.""")
         # filer out any invalid keys
         snk_config_dict = {k: v for k, v in snk_config_dict.items() if k in fields}
         snk_config = cls(**snk_config_dict)

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/dynamic_typer.py

@@ -1,6 +1,5 @@
 import typer
-from click import Tuple
-from typing import List, Callable, get_origin
+from typing import List, Callable, get_args, get_origin
 from inspect import signature, Parameter
 from makefun import with_signature
 from enum import Enum
@@ -159,10 +158,7 @@ class DynamicTyper:
             annotation_type = Enum(f'{option.name}', {str(e): annotation_type(e) for e in option.choices})
         click_type = None
         if get_origin(annotation_type) is dict or annotation_type is dict:
-            click_type = Tuple([str, str])
-            if hasattr(annotation_type, '__args__') and len(annotation_type.__args__) == 2:
-                click_type = Tuple([str, annotation_type.__args__[1]])
-            annotation_type = List[Tuple]
+            annotation_type, click_type = self._get_dict_cli_types(annotation_type)
             if type(default) is dict:
                 default = [[k, v] for k, v in default.items()]
         return Parameter(
@@ -179,6 +175,20 @@ class DynamicTyper:
             annotation=annotation_type,
         )
 
+    @staticmethod
+    def _get_dict_cli_types(dict_type):
+        """
+        Return the annotation and parser type for a repeatable key-value option.
+
+        Typer uses the outer List to make an option repeatable, but does not
+        support parameterized tuples inside a List. The unparameterized tuple
+        accurately describes each parsed value, while click_type supplies the
+        concrete key and value parsers.
+        """
+        type_args = get_args(dict_type)
+        value_type = type_args[1] if len(type_args) == 2 else str
+        return List[tuple], (str, value_type)
+
     def check_if_option_passed_via_command_line(self, option: Option):
         """
         Check if an option is passed via the command line.

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/options/utils.py

@@ -1,11 +1,10 @@
-from typing import List, Tuple, get_origin
+from typing import Dict, List, Tuple, get_origin
 from ..config.config import SnkConfig
 from ..utils import get_default_type, flatten
 from .option import Option
 from pathlib import Path
-from enum import Enum
 
-types = {
+allowed_option_types = {
     "int": int,
     "integer": int,
     "float": float,
@@ -21,8 +20,8 @@ types = {
     "list[float]": List[float],
     "pair": Tuple[str, str],
     "dict": dict,
-    "dict[str, str]": dict[str, str],
-    "dict[str, int]": dict[str, int],
+    "dict[str,str]": Dict[str, str],
+    "dict[str,int]": Dict[str, int],
 }
 
 # Define the basic types for the combinations
@@ -31,7 +30,7 @@ basic_types = [int, str, bool, float]
 # Add the combinations of the basic types to the `types` dictionary
 for t1 in basic_types:
     for t2 in basic_types:
-        types[f"pair[{t1.__name__}, {t2.__name__}]"] = Tuple[t1, t2]
+        allowed_option_types[f"pair[{t1.__name__},{t2.__name__}]"] = Tuple[t1, t2]
 
 def get_keys_from_annotation(annotations):
     # Get the unique keys from the annotations
@@ -68,10 +67,10 @@ def create_option_from_annotation(
         updated = True
     annotation_type = annotation_values.get(f"{annotation_key}:type", None) 
     if annotation_type is not None:
-        annotation_type = annotation_type.lower()
-        assert annotation_type in types, f"Type '{annotation_type}' not supported."
+        annotation_type = annotation_type.lower().replace(" ", "")
+        assert annotation_type in allowed_option_types, f"Type '{annotation_type}' for '{annotation_key}' is not supported."
     annotation_type = (annotation_type or get_default_type(default)).lower()
-    annotation_type = types.get(
+    annotation_type = allowed_option_types.get(
         annotation_type, List[str] if "list" in annotation_type else str
     )
     name = annotation_values.get(

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/subcommands/env.py

@@ -12,6 +12,10 @@ from ..workflow import Workflow
 from rich.console import Console
 from rich.syntax import Syntax
 from snakemake.deployment.conda import Conda, CreateCondaEnvironmentException
+try:
+    from snakemake_interface_common.exceptions import WorkflowError
+except ImportError:
+    from snakemake.exceptions import WorkflowError
 
 from concurrent.futures import ProcessPoolExecutor
 
@@ -30,7 +34,7 @@ def create_conda_environment_wrapper(args):
     env_path = Path(env_path_str).resolve()
     try:
         conda_environment_factory(env_path, conda_prefix_dir).create()
-    except CreateCondaEnvironmentException as e:
+    except (CreateCondaEnvironmentException, WorkflowError) as e:
         typer.secho(str(e), fg="red", err=True)
         return 1
     return 0
@@ -160,8 +164,13 @@ class EnvApp(DynamicTyper):
             )
             for path in env_paths 
         ]
-        with ProcessPoolExecutor(max_workers=max_workers) as executor:
-            status_codes = executor.map(create_conda_environment_wrapper, env_args)
+        if max_workers == 1:
+            status_codes = [
+                create_conda_environment_wrapper(args) for args in env_args
+            ]
+        else:
+            with ProcessPoolExecutor(max_workers=max_workers) as executor:
+                status_codes = list(executor.map(create_conda_environment_wrapper, env_args))
         if any(status_codes):
             self.error("Failed to create all conda environments!")
         if names:

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/subcommands/run.py

@@ -5,7 +5,10 @@ from contextlib import contextmanager
 
 from snk_cli.dynamic_typer import DynamicTyper
 from snk_cli.options.option import Option
-from snk_cli.conda import is_snakemake_version_8_or_above
+from snk_cli.conda import (
+    is_snakemake_version_8_or_above,
+    is_snakemake_version_9_or_above,
+)
 from ..workflow import Workflow
 from snk_cli.utils import (
     parse_config_args,
@@ -219,21 +222,24 @@ class RunApp(DynamicTyper):
             )
 
         if conda_found and self.snk_config.conda and not no_conda:
-            args.extend(
-                [
-                    "--use-conda",
-                    f"--conda-prefix={self.conda_prefix_dir}",
-                ]
-            )
-            if not check_command_available("mamba"):
-                if verbose:
-                    self.log(
-                        "Could not find mamba, using conda instead...",
-                        color=typer.colors.MAGENTA,
-                    )
-                args.append("--conda-frontend=conda")
+            if is_snakemake_version_9_or_above: # support for mamba deprecated since v8.20.6(#3121)
+                args.extend(["--software-deployment-method", "conda"])
             else:
-                args.append("--conda-frontend=mamba")
+                args.extend(
+                    [
+                        "--use-conda",
+                        f"--conda-prefix={self.conda_prefix_dir}",
+                    ]
+                )
+                if not check_command_available("mamba"):
+                    if verbose:
+                        self.log(
+                            "Could not find mamba, using conda instead...",
+                            color=typer.colors.MAGENTA,
+                        )
+                    args.append("--conda-frontend=conda")
+                else:
+                    args.append("--conda-frontend=mamba")
 
         if verbose:
             args.insert(0, "--verbose")
@@ -395,16 +401,15 @@ class RunApp(DynamicTyper):
                     )
             yield
         finally:
-            if not cleanup:
-                return
-            for copied_resource in copied_resources:
-                if copied_resource.exists():
-                    if self.verbose:
-                        self.log(
-                            f"Deleting '{copied_resource.name}' resource...",
-                            color=typer.colors.MAGENTA,
-                        )
-                    remove_resource(copied_resource)
+            if cleanup:
+                for copied_resource in copied_resources:
+                    if copied_resource.exists():
+                        if self.verbose:
+                            self.log(
+                                f"Deleting '{copied_resource.name}' resource...",
+                                color=typer.colors.MAGENTA,
+                            )
+                        remove_resource(copied_resource)
 
 def execute_snakemake(args):
     """

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/testing.py

@@ -17,11 +17,12 @@ class SnkCliRunner:
     """
 
     cli: CLI
-    runner = CliRunner(mix_stderr=False)
+    runner = CliRunner()
 
     def invoke(self, args: List[str]) -> Result:
+        args = [str(arg) for arg in args]
         old_argv = sys.argv
         sys.argv = ['cli'] + args  # ensure that the CLI is invoked with the correct arguments
         result = self.runner.invoke(self.cli.app, args)
         sys.argv = old_argv
-        return result
+        return result

{snk_cli-0.7.1 → snk_cli-0.8.0}/src/snk_cli/validate.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 from typing import Any, Dict, Union, get_origin
 from .config import SnkConfig
-from .options.utils import types
+from .options.utils import allowed_option_types
 import inspect
 
 class ValidationError(Exception):
@@ -52,24 +52,35 @@ def validate_and_transform_in_place(config: Dict[str, Any], validation: Validati
         val_info = validation[key]
         if isinstance(val_info, dict) and 'type' in val_info:
             # Direct type validation
-            val_type = types.get(val_info["type"].lower(), None)
+            val_type = allowed_option_types.get(val_info["type"].lower().replace(" ", ""), None)
             if val_type is None:
                 raise ValueError(f"Unknown type '{val_info['type']}'")
             try:
                 if getattr(val_type, "__origin__", None) is list:
+                    # List e.g. List[str]
                     val_type = val_type.__args__[0]
                     if not isinstance(value, list):
                         raise ValueError(f"Expected a list for key '{key}'")
                     config[key] = [val_type(v) for v in value]
                 elif get_origin(val_type) is tuple:
-                    assert len(value) == 2, f"Expected a list of length 2 for key '{key}'"
+                    # Tuple e.g. Tuple[str, int]
+                    assert len(value) == 2, f"Tuple type should have 2 elements for key '{key}'"
                     key_type = val_type.__args__[0]
                     val_type = val_type.__args__[1]
                     config[key] = [key_type(value[0]), val_type(value[1])]
+                elif get_origin(val_type) is dict:
+                    # Dict e.g. Dict[str, int]
+                    if val_type.__args__ is None:
+                        config[key] = value
+                        continue
+                    assert len(val_type.__args__) == 2, f"Dict type should have 2 arguments for key '{key}'"
+                    val_type = val_type.__args__[1]
+                    config[key] = {k: val_type(v) for k, v in value.items()}
                 else:
+                    # basic
                     config[key] = val_type(value)
             except (ValueError, TypeError) as e:
-                raise ValueError(f"Type conversion error for key '{key}': {e}")
+                raise ValueError(f"Type conversion error for key '{key}' ({val_info['type']}). Could not convert value '{value}' to type '{val_type}'.") from e
         elif isinstance(value, dict):
             # Nested dictionary validation
             validate_and_transform_in_place(value, val_info)

{snk_cli-0.7.1 → snk_cli-0.8.0}/tests/conftest.py

@@ -1,10 +1,7 @@
-from typing import Tuple
 import pytest
 from pathlib import Path
 from .utils import SnkCliRunner
-from snk_cli.config import SnkConfig
 from snk_cli import CLI
-import yaml
 
 @pytest.fixture()
 def example_config():

{snk_cli-0.7.1 → snk_cli-0.8.0}/tests/test_cli/test_run.py

@@ -47,4 +47,4 @@ def test_snakemake_help(local_runner: SnkCliRunner):
 def test_snakemake_version(local_runner: SnkCliRunner):
     res = local_runner(["run", "--snake-v"])
     assert res.exit_code == 0, res.stderr
-    assert res.stdout.startswith("7.32.4") or res.stdout.startswith("8.")
+    assert res.stdout.startswith("7.32.4") or res.stdout.startswith("8.") or res.stdout.startswith("9.")

snk_cli-0.8.0/tests/test_conda_env.py

@@ -0,0 +1,24 @@
+from snk_cli.conda import conda_environment_factory
+from snakemake.deployment.conda import Env
+from pathlib import Path
+
+
+def test_conda_env(tmp_path):
+    env = conda_environment_factory("tests/data/workflow/workflow/envs/wget.yml", tmp_path)
+    assert isinstance(env, Env)
+    assert not Path(env.address).exists()
+    env.create()
+    assert Path(env.address).exists()
+
+
+def test_conda_env_content(tmp_path):
+    env_file = Path("tests/data/workflow/workflow/envs/wget.yml").resolve()
+    env = conda_environment_factory(env_file, tmp_path)
+    assert env.content == env_file.read_bytes()
+
+
+def test_conda_env_factory_creates_prefix(tmp_path):
+    env_file = Path("tests/data/workflow/workflow/envs/wget.yml").resolve()
+    conda_prefix = tmp_path / "conda"
+    conda_environment_factory(env_file, conda_prefix)
+    assert conda_prefix.exists()

{snk_cli-0.7.1 → snk_cli-0.8.0}/tests/test_dynamic_typer.py

@@ -4,6 +4,7 @@ from snk_cli.dynamic_typer import DynamicTyper
 from snk_cli.options import Option
 from inspect import signature, Parameter
 import typer
+from typing import Dict, List
 
 class SubApp(DynamicTyper):
     def __init__(self):
@@ -94,6 +95,27 @@ def test_create_cli_parameter(dynamic_typer):
     assert param.kind == Parameter.POSITIONAL_OR_KEYWORD
 
 
+def test_create_dict_cli_parameter(dynamic_typer):
+    option = Option(
+        name="labels",
+        type=Dict[str, int],
+        required=False,
+        default={"first": 1},
+        help="Labels",
+        short=None,
+        updated=False,
+        original_key="labels",
+        flag="--labels",
+        short_flag=None,
+    )
+
+    param = dynamic_typer._create_cli_parameter(option)
+
+    assert param.annotation == List[tuple]
+    assert param.default.click_type == (str, int)
+    assert param.default.default == [["first", 1]]
+
+
 
 def test_add_dynamic_options(dynamic_typer):
     def func(name: str):
@@ -145,4 +167,4 @@ def test_calling_cli_produces_help(dynamic_app: DynamicTyper, capsys):
     except SystemExit:
         pass
     captured = capsys.readouterr()
-    assert "Usage" in captured.out
+    assert "Usage" in captured.out

snk_cli-0.7.1/.github/workflows/tests.yml

@@ -1,41 +0,0 @@
-
-name: tests 
-on:
-  push:
-    branches:
-      - master 
-      - main
-permissions:
-  contents: write
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: "conda-incubator/setup-miniconda@v2"
-        with:
-          python-version: 3.11
-          auto-activate-base: false
-          miniforge-variant: Mambaforge
-          channels: conda-forge,bioconda,defaults
-          channel-priority: strict
-          auto-update-conda: true
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11' 
-      - uses: actions/cache@v2
-        with:
-          key: ${{ github.ref }}
-          path: .cache
-      - run: pip install hatch
-      - run: sudo apt-get update && sudo apt-get install -y llvm
-      - run: sudo apt-get -y install graphviz
-      - name: Run tests
-        shell: bash
-        run: hatch run snakemake:cov
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
-
-

snk_cli-0.7.1/tests/test_conda_env.py

@@ -1,11 +0,0 @@
-from snk_cli.conda import conda_environment_factory
-from snakemake.deployment.conda import Env
-from pathlib import Path
-
-
-def test_conda_env(tmp_path):
-    env = conda_environment_factory("tests/data/workflow/workflow/envs/wget.yml", tmp_path)
-    assert isinstance(env, Env)
-    assert not Path(env.address).exists()
-    env.create()
-    assert Path(env.address).exists()