snk-cli 0.1.4__tar.gz → 0.2.1__tar.gz

{snk_cli-0.1.4 → snk_cli-0.2.1}/.github/workflows/tests.yml

@@ -31,7 +31,7 @@ jobs:
       - run: sudo apt-get -y install graphviz
       - name: Run tests
         shell: bash
-        run: hatch run cov
+        run: hatch run snakemake:cov
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v3
 

{snk_cli-0.1.4 → snk_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snk-cli
-Version: 0.1.4
+Version: 0.2.1
 Project-URL: Documentation, https://github.com/unknown/snk-cli#readme
 Project-URL: Issues, https://github.com/unknown/snk-cli/issues
 Project-URL: Source, https://github.com/unknown/snk-cli
@@ -22,7 +22,7 @@ Requires-Dist: datrie>=0.8.2
 Requires-Dist: gitpython~=3.1
 Requires-Dist: makefun~=1.15
 Requires-Dist: pulp<2.8
-Requires-Dist: snakemake<8,>=7
+Requires-Dist: snakemake>=7
 Requires-Dist: typer[all]~=0.9.0
 Description-Content-Type: text/markdown
 

{snk_cli-0.1.4 → snk_cli-0.2.1}/pyproject.toml

@@ -25,7 +25,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "snakemake>=7,<8",
+  "snakemake>=7",
   "typer[all]~=0.9.0",
   "GitPython~=3.1",
   "pulp<2.8",  # Pin pulp <2.8 for snakemake: https://github.com/snakemake/snakemake/issues/2607
@@ -43,24 +43,14 @@ Source = "https://github.com/unknown/snk-cli"
 path = "src/snk_cli/__about__.py"
 
 
-[[tool.hatch.envs.test.matrix]]
-python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
-snakemake = ["7.32.4"]
-
-# [[tool.hatch.envs.test.matrix]]
-# python = ["3.11", "3.12"]
-# snakemake = ["8.5.5"]
-
-[tool.hatch.envs.test]
-dependencies = [
-  "coverage[toml]>=6.5",
-  "pytest",
-  "snakemake=={matrix:snakemake}"]
+[[tool.hatch.envs.snakemake.matrix]]
+snakemake = ["7.32.4", "8.10.8"]
 
 [tool.hatch.envs.default]
 dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
+  "snakemake=={matrix:snakemake:7.32.4}",
 ]
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"
@@ -75,7 +65,7 @@ cov = [
 ]
 
 [[tool.hatch.envs.all.matrix]]
-python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
+python = ["3.9", "3.10", "3.11", "3.12"]
 
 [tool.hatch.envs.types]
 dependencies = [

{snk_cli-0.1.4 → snk_cli-0.2.1}/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.1.4"
+__version__ = "0.2.1"

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/cli.py

@@ -6,8 +6,6 @@ from pathlib import Path
 from typing import Optional
 import os
 
-
-from snakemake import SNAKEFILE_CHOICES
 from art import text2art
 
 from snk_cli.dynamic_typer import DynamicTyper
@@ -224,6 +222,17 @@ class CLI(DynamicTyper):
         Examples:
           >>> CLI._find_snakefile()
         """
+        SNAKEFILE_CHOICES = list(
+            map(
+                Path,
+                (
+                    "Snakefile",
+                    "snakefile",
+                    "workflow/Snakefile",
+                    "workflow/snakefile",
+                ),
+            )
+        )
         for path in SNAKEFILE_CHOICES:
             if (self.workflow.path / path).exists():
                 return self.workflow.path / path
@@ -244,6 +253,9 @@ class CLI(DynamicTyper):
         info_dict = {}
         info_dict["name"] = self.workflow.path.name
         info_dict["version"] = self.version
+        info_dict["snakefile"] = str(self.snakefile)
+        info_dict["conda_prefix_dir"] = str(self.conda_prefix_dir)
+        info_dict["singularity_prefix_dir"] = str(self.singularity_prefix_dir)
         info_dict["workflow_dir_path"] = str(self.workflow.path)
         typer.echo(json.dumps(info_dict, indent=2))
 

snk_cli-0.2.1/src/snk_cli/conda.py

@@ -0,0 +1,106 @@
+# This file contains functions to create and manage conda environments for snakemake workflows
+# it needs to work with v 7 and 8 of snakemake
+# 
+from pathlib import Path
+from packaging import version
+from dataclasses import dataclass
+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')
+
+@dataclass
+class PersistenceMock(Persistence):
+    """
+    Mock for workflow.persistence
+    """
+    conda_env_path: Path = None
+    _metadata_path: Path = None
+    _incomplete_path: Path = None
+    shadow_path: Path = None
+    conda_env_archive_path: Path = None
+    container_img_path: Path = None
+    aux_path: Path = None
+
+
+def get_frontend():
+    if check_command_available("mamba"):
+        conda_frontend = "mamba"
+    else:
+        conda_frontend = "conda"
+    return conda_frontend
+
+def create_workflow_v7(conda_prefix):
+    from snakemake.workflow import Workflow
+    
+    conda_frontend = get_frontend()
+    workflow = Workflow(
+        snakefile=Path(),
+        overwrite_config=dict(),
+        overwrite_workdir=None,
+        overwrite_configfiles=[],
+        overwrite_clusterconfig=dict(),
+        conda_frontend=conda_frontend,
+        use_conda=True,
+    )
+
+    persistence = PersistenceMock(
+        conda_env_path=Path(conda_prefix).resolve() if conda_prefix else None,
+        conda_env_archive_path=os.path.join(Path(".snakemake"), "conda-archive"),
+    )
+    if hasattr(workflow, "_persistence"):
+        workflow._persistence = persistence
+    else:
+        workflow.persistence = persistence
+    return workflow
+
+def create_workflow_v8(
+        conda_prefix
+    ):
+    from snakemake.api import Workflow
+    from snakemake.settings import (
+        ConfigSettings,
+        DeploymentSettings,
+        ResourceSettings,
+        WorkflowSettings,
+        StorageSettings,
+    )
+    conda_frontend = get_frontend()
+    workflow = Workflow(
+        config_settings=ConfigSettings(),
+        resource_settings=ResourceSettings(),
+        workflow_settings=WorkflowSettings(),
+        storage_settings=StorageSettings(),
+        deployment_settings=DeploymentSettings(
+            conda_frontend=conda_frontend, 
+            conda_prefix=conda_prefix
+        ),
+    )
+    persistence = PersistenceMock(
+        conda_env_path=Path(conda_prefix).resolve() if conda_prefix else None,
+        conda_env_archive_path=os.path.join(Path(".snakemake"), "conda-archive"),
+    )
+    if hasattr(workflow, "_persistence"):
+        workflow._persistence = persistence
+    else:
+        workflow.persistence = persistence
+    return workflow
+
+def conda_environment_factory(env_file_path: Path, conda_prefix_dir_path: Path) -> Env:
+    """
+    Create a snakemake environment object from a given environment file and conda prefix directory
+    """
+    if is_snakemake_version_8_or_above:
+        snakemake_workflow = create_workflow_v8(
+            conda_prefix_dir_path
+        )
+    else:
+        snakemake_workflow = create_workflow_v7(conda_prefix_dir_path)
+    env_file_path = Path(env_file_path).resolve()
+    env = Env(snakemake_workflow, env_file=env_file_path)
+    return env

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/config/config.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from typing import List, Optional
 import snakemake
 from dataclasses import dataclass, field
-from .utils import get_version_from_config
+from .utils import get_version_from_config, load_configfile
 import yaml
 
 
@@ -97,7 +97,7 @@ class SnkConfig:
         if snk_config_path.stat().st_size == 0:
             raise InvalidSnkConfigError(f"SNK config file is empty: {snk_config_path}") from ValueError
 
-        snk_config_dict = snakemake.load_configfile(snk_config_path)
+        snk_config_dict = load_configfile(snk_config_path)
         snk_config_dict["version"] = get_version_from_config(snk_config_path, snk_config_dict)
         if "annotations" in snk_config_dict:
             # TODO: remove annotations in the future
@@ -257,4 +257,4 @@ def load_workflow_snakemake_config(workflow_dir_path: Path):
     workflow_config_path = get_config_from_workflow_dir(workflow_dir_path)
     if not workflow_config_path or not workflow_config_path.exists():
         return {}
-    return snakemake.load_configfile(workflow_config_path)
+    return load_configfile(workflow_config_path)

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/config/utils.py

@@ -1,5 +1,9 @@
 from pathlib import Path
-from snakemake import load_configfile
+try:
+    # snakemake < 8.0.0
+    from snakemake import load_configfile
+except ImportError:
+    from snakemake.common.configfile import _load_configfile as load_configfile  # noqa: F401
 
 def get_version_from_config(config_path: Path, config_dict: dict = None) -> str:
     """

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/dynamic_typer.py

@@ -217,8 +217,8 @@ class DynamicTyper:
             flat_config = None
 
             if kwargs.get("configfile"):
-                from snakemake import load_configfile
                 from .utils import flatten
+                from snk_cli.config.utils import load_configfile
 
                 snakemake_config = load_configfile(kwargs["configfile"])
                 flat_config = flatten(snakemake_config)

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/subcommands/env.py

@@ -7,7 +7,7 @@ from typing import List, Optional
 import typer
 
 from snk_cli.dynamic_typer import DynamicTyper
-from .utils import create_snakemake_workflow
+from snk_cli.conda import conda_environment_factory
 from ..workflow import Workflow
 from rich.console import Console
 from rich.syntax import Syntax
@@ -22,22 +22,15 @@ def get_num_cores(default=4):
     except:
         return default
 
-def create_conda_environment(args):
-    # unpack args
-    env_path_str, snakefile, snakemake_config, configfiles, conda_prefix_dir_str = args
-    # Reconstruct the snakemake_workflow configuration
+def create_conda_environment_wrapper(args):
+    """
+    This wrapper is designed to be submitted to a ProcessPoolExecutor
+    """
+    env_path_str, conda_prefix_dir_str = args
     conda_prefix_dir = Path(conda_prefix_dir_str).resolve()
-    snakemake_workflow = create_snakemake_workflow(
-        snakefile,
-        config=snakemake_config,
-        configfiles=configfiles,
-        use_conda=True,
-        conda_prefix=conda_prefix_dir,
-    )
     env_path = Path(env_path_str).resolve()
-    env = Env(snakemake_workflow, env_file=env_path)
     try:
-        env.create()
+        conda_environment_factory(env_path, conda_prefix_dir).create()
     except CreateCondaEnvironmentException as e:
         typer.secho(str(e), fg="red", err=True)
         return 1
@@ -57,13 +50,6 @@ class EnvApp(DynamicTyper):
         self.snakemake_config = snakemake_config
         self.snakefile = snakefile
         self.configfile = get_config_from_workflow_dir(self.workflow.path)
-        self.snakemake_workflow = create_snakemake_workflow(
-            self.snakefile,
-            config=self.snakemake_config,
-            configfiles=[self.configfile] if self.configfile else None,
-            use_conda=True,
-            conda_prefix=self.conda_prefix_dir.resolve(),
-        )
         self.register_command(self.list, help="List the environments in the workflow.")
         self.register_command(self.show, help="Show the contents of an environment.")
         self.register_command(
@@ -86,7 +72,7 @@ class EnvApp(DynamicTyper):
 
         table = Table("Name", "CMD", "Env", show_header=True, show_lines=True)
         for env in self.workflow.environments:
-            conda = Env(self.snakemake_workflow, env_file=env.resolve())
+            conda = conda_environment_factory(env, self.conda_prefix_dir)
             # address relative to cwd
             address = Path(conda.address)
             if address.exists():
@@ -137,7 +123,7 @@ class EnvApp(DynamicTyper):
         cmd: List[str] = typer.Argument(..., help="The command to run in environment."),
     ):
         env_path = self._get_conda_env_path(name)
-        env = Env(self.snakemake_workflow, env_file=env_path.resolve())
+        env = conda_environment_factory(env_path, self.conda_prefix_dir)
         env.create()
         cmd = self._shellcmd(env.address, " ".join(cmd))
         if verbose:
@@ -154,7 +140,7 @@ class EnvApp(DynamicTyper):
     ):
         if name:
             env_path = self._get_conda_env_path(name)
-            env = Env(self.snakemake_workflow, env_file=env_path.resolve())
+            env = conda_environment_factory(env_path, self.conda_prefix_dir)
             path = Path(env.address)
             if not path.exists():
                 self.error(f"Environment {name} not created!")
@@ -176,15 +162,12 @@ class EnvApp(DynamicTyper):
         env_args = [
             (
                 path,
-                self.snakefile,
-                self.snakemake_config,
-                [self.configfile] if self.configfile else None,
                 self.conda_prefix_dir.resolve(),
             )
             for path in env_paths 
         ]
         with ProcessPoolExecutor(max_workers=max_workers) as executor:
-            status_codes = executor.map(create_conda_environment, env_args)
+            status_codes = executor.map(create_conda_environment_wrapper, env_args)
         if any(status_codes):
             self.error("Failed to create all conda environments!")
         if names:
@@ -201,7 +184,7 @@ class EnvApp(DynamicTyper):
     ):
         env_path = self._get_conda_env_path(name)
         self.log(f"Activating {name} environment... (type 'exit' to deactivate)")
-        env = Env(self.snakemake_workflow, env_file=env_path.resolve())
+        env = conda_environment_factory(env_path, self.conda_prefix_dir)
         env.create()
         user_shell = os.environ.get("SHELL", "/bin/bash")
         activate_cmd = self._shellcmd(env.address, user_shell)

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/subcommands/run.py

@@ -5,6 +5,7 @@ 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 ..workflow import Workflow
 from snk_cli.utils import (
     parse_config_args,
@@ -64,9 +65,7 @@ class RunApp(DynamicTyper):
           >>> RunApp._print_snakemake_help(True)
         """
         if value:
-            import snakemake
-
-            snakemake.main("-h")
+            execute_snakemake("-h")
 
     def run(
         self,
@@ -167,7 +166,6 @@ class RunApp(DynamicTyper):
         Examples:
           >>> RunApp.run(target='my_target', configfile=Path('/path/to/config.yaml'), resource=[Path('/path/to/resource')], verbose=True)
         """
-        import snakemake
         import shutil
         import sys
 
@@ -274,8 +272,7 @@ class RunApp(DynamicTyper):
             if dag:
                 return self._save_dag(snakemake_args=args, filename=dag)
             try:
-                snakemake.parse_config = parse_config_monkeypatch
-                snakemake.main(args)
+                execute_snakemake(args)
             except SystemExit as e:
                 status = int(str(e))
                 if status:
@@ -286,7 +283,6 @@ class RunApp(DynamicTyper):
 
     def _save_dag(self, snakemake_args: List[str], filename: Path):
         from contextlib import redirect_stdout
-        import snakemake
         import subprocess
         import io
 
@@ -300,8 +296,7 @@ class RunApp(DynamicTyper):
         with redirect_stdout(snakemake_output):
             # Capture the output of snakemake.main(args) using a try-except block
             try:
-                snakemake.parse_config = parse_config_monkeypatch
-                snakemake.main(snakemake_args)
+                execute_snakemake(snakemake_args)
             except SystemExit:  # Catch SystemExit exception to prevent termination
                 pass
         try:
@@ -415,6 +410,24 @@ class RunApp(DynamicTyper):
                         )
                     remove_resource(copied_resource)
 
+def execute_snakemake(args):
+    """
+    Execute snakemake with the given arguments.
+
+    Args:
+      args: The arguments to pass to snakemake.
+
+    Side Effects:
+      Executes snakemake with the given arguments.
+    """
+    import snakemake
+    if is_snakemake_version_8_or_above:
+        from snakemake import cli
+        cli.parse_config = parse_config_monkeypatch
+        cli.main(args)
+    else:
+        snakemake.parse_config = parse_config_monkeypatch
+        snakemake.main(args)
 
 def parse_config_monkeypatch(args):
     """
@@ -427,8 +440,13 @@ def parse_config_monkeypatch(args):
       dict: The parsed config.
     """
     import yaml
-    import snakemake
     import re
+    if is_snakemake_version_8_or_above:
+        from snakemake.cli import parse_key_value_arg, update_config, _bool_parser
+        entries = args
+    else:
+        from snakemake import parse_key_value_arg, update_config, _bool_parser
+        entries = args.config
 
     class NoDatesSafeLoader(yaml.SafeLoader):
         @classmethod
@@ -465,12 +483,12 @@ def parse_config_monkeypatch(args):
         s = s.replace(": None", ": null")
         return yaml.load(s, Loader=NoDatesSafeLoader)
 
-    parsers = [int, float, snakemake._bool_parser, _yaml_safe_load, str]
+    parsers = [int, float, _bool_parser, _yaml_safe_load, str]
     config = dict()
-    if args.config is not None:
+    if entries is not None:
         valid = re.compile(r"[a-zA-Z_]\w*$")
-        for entry in args.config:
-            key, val = snakemake.parse_key_value_arg(
+        for entry in entries:
+            key, val = parse_key_value_arg(
                 entry,
                 errmsg="Invalid config definition: Config entries have to be defined as name=value pairs.",
             )
@@ -480,7 +498,7 @@ def parse_config_monkeypatch(args):
                 )
             v = None
             if val == "" or val == "None":
-                snakemake.update_config(config, {key: v})
+                update_config(config, {key: v})
                 continue
             for parser in parsers:
                 try:
@@ -491,5 +509,5 @@ def parse_config_monkeypatch(args):
                 except:
                     pass
             assert v is not None
-            snakemake.update_config(config, {key: v})
+            update_config(config, {key: v})
     return config

{snk_cli-0.1.4 → snk_cli-0.2.1}/src/snk_cli/subcommands/script.py

@@ -6,11 +6,11 @@ from typing import List
 import typer
 
 from ..dynamic_typer import DynamicTyper
-from .utils import create_snakemake_workflow
+from snk_cli.conda import conda_environment_factory
 from ..workflow import Workflow
 from rich.console import Console
 from rich.syntax import Syntax
-from snakemake.deployment.conda import Conda, Env
+from snakemake.deployment.conda import Conda
 from snk_cli.config.config import get_config_from_workflow_dir
 
 
@@ -116,14 +116,7 @@ class ScriptApp(DynamicTyper):
         cmd = [executor, f'"{script_path}"'] + args
         if env:
             env_path = self._get_conda_env_path(env)
-            workflow = create_snakemake_workflow(
-                self.snakefile,
-                config=self.snakemake_config,
-                configfiles=[self.configfile] if self.configfile else None,
-                use_conda=True,
-                conda_prefix=self.conda_prefix_dir.resolve(),
-            )
-            env = Env(workflow, env_file=env_path.resolve())
+            env = conda_environment_factory(env_path, self.conda_prefix_dir)
             env.create()
             cmd = self._shellcmd(env.address, " ".join(cmd))
         else:

{snk_cli-0.1.4 → snk_cli-0.2.1}/tests/test_cli/test_run.py

@@ -39,3 +39,12 @@ def test_run_with_config(tmp_path):
     assert res.exit_code == 0, res.stderr
     assert "cli" in res.stdout, res.stderr
 
+def test_snakemake_help(local_runner: SnkCliRunner):
+    res = local_runner(["run", "-hs"])
+    assert res.exit_code == 0, res.stderr
+    assert "snakemake" in res.stdout
+
+def test_snakemake_version(local_runner: SnkCliRunner):
+    res = local_runner(["run", "--snake-v"])
+    assert res.exit_code == 0, res.stderr
+    assert res.stdout in ["7.32.4\n", "8.10.8\n"]

{snk_cli-0.1.4 → snk_cli-0.2.1}/tests/test_cli/test_subcommands.py

@@ -13,6 +13,7 @@ import pytest
     (["env", "run", "python", "which python"], ["bin/python"], []),
     (["env", "activate", "python"], [], ["Activating python environment...", "Exiting python environment..."]),
     (["env", "remove", "-f"], ["Deleted"], []),
+    (["info"], ["name", "version", "snakefile", "conda_prefix_dir", "singularity_prefix_dir", "workflow_dir_path"], []),
 ])
 def test_snk_cli_command(capfd, local_runner, cmd, expected_in_stdout, expected_in_stderr):
     res = local_runner(cmd)

{snk_cli-0.1.4 → snk_cli-0.2.1}/tests/test_cli/test_workflow_cli.py

@@ -1,12 +1,11 @@
 from pathlib import Path
 from snk_cli.utils import flatten, convert_key_to_snakemake_format
-import snakemake
 import pytest
 from ..utils import SnkCliRunner
-
+from snk_cli.config.utils import load_configfile
 
 def test_flatten(example_config: Path):
-    config = snakemake.load_configfile(example_config)
+    config = load_configfile(example_config)
     flat_config = flatten(config)
     assert flat_config["diffexp:contrasts:A-vs-B"] == ["A", "B"]
 

snk_cli-0.2.1/tests/test_conda_env.py

@@ -0,0 +1,11 @@
+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/python.yml", tmp_path)
+    assert isinstance(env, Env)
+    assert not Path(env.address).exists()
+    env.create()
+    assert Path(env.address).exists()

snk_cli-0.1.4/.github/workflows/mkdocs.yml

@@ -1,23 +0,0 @@
-
-name: mkdocs 
-on:
-  push:
-    branches:
-      - master 
-      - main
-permissions:
-  contents: write
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.x
-      - uses: actions/cache@v2
-        with:
-          key: ${{ github.ref }}
-          path: .cache
-      - run: pip install "mkdocstrings==0.22.0" "mkdocstrings-python==1.3.*" "mkdocs-material"
-      - run: mkdocs gh-deploy --force

snk_cli-0.1.4/src/snk_cli/subcommands/utils.py

@@ -1,175 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from snakemake import (
-    Workflow,
-    update_config,
-    load_configfile,
-    dict_to_key_value_args,
-    common,
-)
-from snakemake.persistence import Persistence
-from ..utils import check_command_available
-import os
-
-@dataclass
-class PersistenceMock(Persistence):
-    """
-    Mock for workflow.persistence
-    """
-
-    conda_env_path: Path = None
-    _metadata_path: Path = None
-    _incomplete_path: Path = None
-    shadow_path: Path = None
-    conda_env_archive_path: Path = None
-    container_img_path: Path = None
-    aux_path: Path = None
-
-def create_snakemake_workflow(
-    snakefile,
-    cache=None,
-    lint=None,
-    cores=1,
-    nodes=None,
-    max_threads=None,
-    resources=dict(),
-    overwrite_threads=None,
-    overwrite_scatter=None,
-    overwrite_resource_scopes=None,
-    default_resources=None,
-    overwrite_resources=None,
-    config=dict(),
-    configfiles=None,
-    config_args=None,
-    workdir=None,
-    printshellcmds=False,
-    rerun_triggers=["mtime", "params", "input", "software-env", "code"],
-    conda_cleanup_envs=False,
-    latency_wait=3,
-    print_compilation=False,
-    debug=False,
-    all_temp=False,
-    jobscript=None,
-    overwrite_shellcmd=None,
-    restart_times=0,
-    attempt=1,
-    verbose=False,
-    use_conda=False,
-    use_singularity=False,
-    use_env_modules=False,
-    singularity_args="",
-    conda_frontend="conda",
-    conda_prefix=None,
-    conda_cleanup_pkgs=None,
-    list_conda_envs=False,
-    singularity_prefix=None,
-    shadow_prefix=None,
-    scheduler="ilp",
-    scheduler_ilp_solver=None,
-    mode=common.Mode.default,
-    wrapper_prefix=None,
-    default_remote_prefix="",
-    assume_shared_fs=True,
-    keep_metadata=True,
-    edit_notebook=None,
-    envvars=None,
-    overwrite_groups=None,
-    group_components=None,
-    max_inventory_wait_time=20,
-    execute_subworkflows=True,
-    conda_not_block_search_path_envvars=False,
-    scheduler_solver_path=None,
-    conda_base_path=None,
-    local_groupid="local",
-):
-    overwrite_config = dict()
-    if configfiles is None:
-        configfiles = []
-    for f in configfiles:
-        # get values to override. Later configfiles override earlier ones.
-        update_config(overwrite_config, load_configfile(f))
-    # convert provided paths to absolute paths
-    configfiles = list(map(os.path.abspath, configfiles))
-
-    # directly specified elements override any configfiles
-    if config:
-        update_config(overwrite_config, config)
-        if config_args is None:
-            config_args = dict_to_key_value_args(config)
-
-    if workdir:
-        if not os.path.exists(workdir):
-            os.makedirs(workdir)
-        workdir = os.path.abspath(workdir)
-        os.chdir(workdir)
-    
-    if check_command_available("mamba"):
-        conda_frontend = "mamba"
-
-    workflow = Workflow(
-        snakefile=snakefile,
-        rerun_triggers=rerun_triggers,
-        jobscript=jobscript,
-        overwrite_shellcmd=overwrite_shellcmd,
-        overwrite_config=overwrite_config,
-        overwrite_workdir=workdir,
-        overwrite_configfiles=configfiles,
-        overwrite_clusterconfig=dict(),
-        overwrite_threads=overwrite_threads,
-        max_threads=max_threads,
-        overwrite_scatter=overwrite_scatter,
-        overwrite_groups=overwrite_groups,
-        overwrite_resources=overwrite_resources,
-        overwrite_resource_scopes=overwrite_resource_scopes,
-        group_components=group_components,
-        config_args=config_args,
-        debug=debug,
-        verbose=verbose,
-        use_conda=use_conda or list_conda_envs or conda_cleanup_envs,
-        use_singularity=use_singularity,
-        use_env_modules=use_env_modules,
-        conda_frontend=conda_frontend,
-        conda_prefix=conda_prefix,
-        conda_cleanup_pkgs=conda_cleanup_pkgs,
-        singularity_prefix=singularity_prefix,
-        shadow_prefix=shadow_prefix,
-        singularity_args=singularity_args,
-        scheduler_type=scheduler,
-        scheduler_ilp_solver=scheduler_ilp_solver,
-        mode=mode,
-        wrapper_prefix=wrapper_prefix,
-        printshellcmds=printshellcmds,
-        restart_times=restart_times,
-        attempt=attempt,
-        default_remote_provider=None,
-        default_remote_prefix=default_remote_prefix,
-        run_local=True,
-        assume_shared_fs=assume_shared_fs,
-        default_resources=default_resources,
-        cache=cache,
-        cores=cores,
-        nodes=nodes,
-        resources=resources,
-        edit_notebook=edit_notebook,
-        envvars=envvars,
-        max_inventory_wait_time=max_inventory_wait_time,
-        conda_not_block_search_path_envvars=conda_not_block_search_path_envvars,
-        execute_subworkflows=execute_subworkflows,
-        scheduler_solver_path=scheduler_solver_path,
-        conda_base_path=conda_base_path,
-        check_envvars=not lint,  # for linting, we do not need to check whether requested envvars exist
-        all_temp=all_temp,
-        local_groupid=local_groupid,
-        keep_metadata=keep_metadata,
-        latency_wait=latency_wait,
-    )
-
-    persistence = PersistenceMock(
-        conda_env_path=Path(conda_prefix).resolve() if conda_prefix else None,
-        conda_env_archive_path=os.path.join(Path(".snakemake"), "conda-archive"),
-    )
-    if hasattr(workflow, "_persistence"):
-        workflow._persistence = persistence
-    else:
-        workflow.persistence = persistence
-    return workflow