snk-cli 0.0.1__tar.gz

snk_cli-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: publish
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  workflow_dispatch:
+permissions:
+  contents: write
+jobs:
+  pypi:
+    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
+      - name: Install hatch
+        run: pip install hatch
+      - name: Build & publish
+        env:
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          hatch build
+          hatch publish -u __token__ -a $PYPI_TOKEN

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

@@ -0,0 +1,38 @@
+
+name: tests 
+on:
+  push:
+    branches:
+      - master 
+      - main
+permissions:
+  contents: write
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        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/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 cov
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+
+

snk_cli-0.0.1/.gitignore

@@ -0,0 +1,13 @@
+/.coverage
+/.pytest_cache
+/dist
+*.pyc
+.snakemake
+reads
+Note.md
+tests/data/workflow/bin/workflow
+hello.txt
+__pycache__
+tests/data/workflow/.conda
+.DS_Store
+.conda

snk_cli-0.0.1/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024-present Wytamma Wirth <wytamma.wirth@me.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

snk_cli-0.0.1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: snk-cli
+Version: 0.0.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
+Author-email: Wytamma Wirth <wytamma.wirth@me.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+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 :: 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: gitpython~=3.1
+Requires-Dist: makefun~=1.15
+Requires-Dist: pulp<2.8
+Requires-Dist: snakemake<9,>=7
+Requires-Dist: typer[all]~=0.9.0
+Description-Content-Type: text/markdown
+
+# snk-cli

snk_cli-0.0.1/README.md

@@ -0,0 +1 @@
+# snk-cli

snk_cli-0.0.1/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "snk-cli"
+dynamic = ["version"]
+description = ''
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = []
+authors = [
+  { name = "Wytamma Wirth", email = "wytamma.wirth@me.com" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "snakemake>=7,<9",
+  "typer[all]~=0.9.0",
+  "GitPython~=3.1",
+  "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]
+Documentation = "https://github.com/unknown/snk-cli#readme"
+Issues = "https://github.com/unknown/snk-cli/issues"
+Source = "https://github.com/unknown/snk-cli"
+
+[tool.hatch.version]
+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.default]
+dependencies = [
+  "coverage[toml]>=6.5",
+  "pytest",
+]
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+  "- coverage combine",
+  "coverage report",
+]
+cov = [
+  "test-cov",
+  "cov-report",
+]
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
+
+[tool.hatch.envs.types]
+dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:src/snk_cli tests}"
+
+[tool.coverage.run]
+source_pkgs = ["snk_cli", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/snk_cli/__about__.py",
+]
+
+[tool.coverage.paths]
+snk_cli = ["src/snk_cli", "*/snk-cli/src/snk_cli"]
+tests = ["tests", "*/snk-cli/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

snk_cli-0.0.1/src/snk_cli/__about__.py

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

snk_cli-0.0.1/src/snk_cli/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2024-present Wytamma Wirth <wytamma.wirth@me.com>
+#
+# SPDX-License-Identifier: MIT
+from .cli import CLI
+from .validate import validate_config

snk_cli-0.0.1/src/snk_cli/cli.py

@@ -0,0 +1,231 @@
+import inspect
+import platform
+
+import typer
+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
+from snk_cli.subcommands import EnvApp, ConfigApp, RunApp, ScriptApp, ProfileApp
+
+from snk_cli.config.config import (
+    SnkConfig,
+    load_workflow_snakemake_config,
+)
+from snk_cli.options.utils import build_dynamic_cli_options
+from snk_cli.workflow import Workflow
+
+
+class CLI(DynamicTyper):
+    """
+    Constructor for the dynamic Snk CLI class.
+    Args:
+      workflow_dir_path (Path): Path to the workflow directory.
+    Side Effects:
+      Initializes the CLI class.
+    Examples:
+      >>> CLI(Path('/path/to/workflow'))
+    """
+
+    def __init__(self, workflow_dir_path: Path = None, *, pipeline_dir_path: Path = None, snk_config: SnkConfig = None) -> None:
+        if pipeline_dir_path is not None:
+            # raise a deprecation warning
+            import warnings
+            warnings.warn(
+                "The `pipeline_dir_path` argument is deprecated and will be removed in a future release. Use `workflow_dir_path` instead.",
+                DeprecationWarning,
+            )
+            workflow_dir_path = pipeline_dir_path
+        if workflow_dir_path is None:
+            # get the calling frame (the frame of the function that called this function)
+            calling_frame = inspect.currentframe().f_back
+            # get the file path from the calling frame
+            workflow_dir_path = Path(calling_frame.f_globals["__file__"])
+        else:
+            workflow_dir_path = Path(workflow_dir_path)
+        if workflow_dir_path.is_file():
+            workflow_dir_path = workflow_dir_path.parent
+        self.workflow = Workflow(path=workflow_dir_path)
+        self.snakemake_config = load_workflow_snakemake_config(workflow_dir_path)
+        if snk_config is None:
+            self.snk_config = SnkConfig.from_workflow_dir(
+                workflow_dir_path, create_if_not_exists=True
+            )
+        else:
+            self.snk_config = snk_config
+        if self.snk_config.version:
+            self.version = self.snk_config.version
+        else: 
+            self.version = self.workflow.version
+        self.options = build_dynamic_cli_options(self.snakemake_config, self.snk_config)
+        self.snakefile = self._find_snakefile()
+        self.conda_prefix_dir = self.workflow.conda_prefix_dir
+        self.singularity_prefix_dir = self.workflow.singularity_prefix_dir
+        self.name = self.workflow.name
+        self.verbose = False
+        if (
+            platform.system() == "Darwin"
+            and platform.processor() == "arm"
+            and not os.environ.get("CONDA_SUBDIR")
+        ):
+            os.environ["CONDA_SUBDIR"] = "osx-64"
+
+        # dynamically create the logo
+        self.logo = self._create_logo(
+            tagline=self.snk_config.tagline, font=self.snk_config.font
+        )
+        callback = self._create_callback()
+        callback.__doc__ = self.logo
+
+        # registration
+        self.register_callback(
+            callback,
+            invoke_without_command=True,
+            context_settings={"help_option_names": ["-h", "--help"]},
+        )
+        self.register_command(self.info, help="Show information about the workflow.")
+
+        run_app = RunApp(
+            conda_prefix_dir=self.conda_prefix_dir,
+            snk_config=self.snk_config,
+            singularity_prefix_dir=self.singularity_prefix_dir,
+            snakefile=self.snakefile,
+            workflow=self.workflow,
+            verbose=self.verbose,
+            logo=self.logo,
+            dynamic_run_options=self.options,
+        )
+        # Subcommands
+        self.register_command(
+            run_app,
+            name="run",
+        )
+        self.register_command(
+            ConfigApp(
+                workflow=self.workflow,
+                options=self.options,
+            ),
+            name="config",
+        )
+        if self.workflow.environments:
+            self.register_group(
+                EnvApp(
+                    workflow=self.workflow,
+                    conda_prefix_dir=self.conda_prefix_dir,
+                    snakemake_config=self.snakemake_config,
+                    snakefile=self.snakefile,
+                ),
+                name="env",
+                help="Access the workflow conda environments.",
+            )
+        if self.workflow.scripts:
+            self.register_group(
+                ScriptApp(
+                    workflow=self.workflow,
+                    conda_prefix_dir=self.conda_prefix_dir,
+                    snakemake_config=self.snakemake_config,
+                    snakefile=self.snakefile,
+                ),
+                name="script",
+                help="Access the workflow scripts.",
+            )
+        if self.workflow.profiles:
+            self.register_group(
+                ProfileApp(
+                    workflow=self.workflow,
+                ),
+                name="profile",
+                help="Access the workflow profiles.",
+            )
+
+    def _print_pipline_version(self, ctx: typer.Context, value: bool):
+        if value:
+            typer.echo(self.version)
+            raise typer.Exit()
+
+    def _print_pipline_path(self, ctx: typer.Context, value: bool):
+        if value:
+            typer.echo(self.workflow.path)
+            raise typer.Exit()
+
+    def _create_callback(self):
+        def callback(
+            ctx: typer.Context,
+            version: Optional[bool] = typer.Option(
+                None,
+                "-v",
+                "--version",
+                help="Show the workflow version and exit.",
+                is_eager=True,
+                callback=self._print_pipline_version,
+                show_default=False,
+            ),
+            path: Optional[bool] = typer.Option(
+                None,
+                "-p",
+                "--path",
+                help="Show the workflow path and exit.",
+                is_eager=True,
+                callback=self._print_pipline_path,
+                show_default=False,
+            ),
+        ):
+            if ctx.invoked_subcommand is None:
+                typer.echo(f"{ctx.get_help()}")
+
+        return callback
+
+    def _create_logo(
+        self, tagline="A Snakemake workflow CLI generated with snk", font="small"
+    ):
+        """
+        Create a logo for the CLI.
+        Args:
+          font (str): The font to use for the logo.
+        Returns:
+          str: The logo.
+        Examples:
+          >>> CLI._create_logo()
+        """
+        if self.snk_config.art:
+            art = self.snk_config.art
+        else:
+            logo = self.snk_config.logo if self.snk_config.logo else self.name
+            art = text2art(logo, font=font)
+        doc = f"""\b{art}\b{tagline}"""
+        return doc
+
+    def _find_snakefile(self):
+        """
+        Search possible snakefile locations.
+        Returns:
+          Path: The path to the snakefile.
+        Examples:
+          >>> CLI._find_snakefile()
+        """
+        for path in SNAKEFILE_CHOICES:
+            if (self.workflow.path / path).exists():
+                return self.workflow.path / path
+        raise FileNotFoundError("Snakefile not found!")
+
+    def info(self):
+        """
+        Display information about current workflow install.
+        Returns:
+          str: A JSON string containing information about the current workflow install.
+        Examples:
+          >>> CLI.info()
+        """
+        import json
+
+        info_dict = {}
+        info_dict["name"] = self.workflow.path.name
+        info_dict["version"] = self.version
+        info_dict["workflow_dir_path"] = str(self.workflow.path)
+        typer.echo(json.dumps(info_dict, indent=2))
+

snk_cli-0.0.1/src/snk_cli/config/__init__.py

@@ -0,0 +1 @@
+from .config import SnkConfig

snk_cli-0.0.1/src/snk_cli/config/config.py

@@ -0,0 +1,219 @@
+from pathlib import Path
+from typing import List, Optional
+import snakemake
+from dataclasses import dataclass, field
+from .utils import get_version_from_config
+import yaml
+
+
+class SnkConfigError(Exception):
+    """Base class for all SNK config exceptions"""
+
+class InvalidSnkConfigError(SnkConfigError, ValueError):
+    """Thrown if the given SNK config appears to have an invalid format."""
+
+class MissingSnkConfigError(SnkConfigError, FileNotFoundError):
+    """Thrown if the given SNK config file cannot be found."""
+
+@dataclass
+class SnkConfig:
+    """
+    A dataclass for storing Snakemake workflow configuration.
+    """
+
+    art: str = None
+    logo: str = None
+    tagline: str = "A Snakemake workflow CLI generated with Snk"
+    font: str = "small"
+    version: Optional[str] = None
+    conda: bool = True
+    resources: List[Path] = field(default_factory=list)
+    skip_missing: bool = False # skip any missing cli options (i.e. those not in the snk file)
+    additional_snakemake_args: List[str] = field(default_factory=list)
+    cli: dict = field(default_factory=dict)
+    symlink_resources: bool = False
+    _snk_config_path: Path = None
+
+    @classmethod
+    def from_path(cls, snk_config_path: Path):
+        """
+        Load and validate Snk config from file.
+        Args:
+          snk_config_path (Path): Path to the SNK config file.
+        Returns:
+          SnkConfig: A SnkConfig object.
+        Raises:
+          FileNotFoundError: If the SNK config file is not found.
+        Examples:
+          >>> SnkConfig.from_path(Path("snk.yaml"))
+          SnkConfig(art=None, logo=None, tagline='A Snakemake workflow CLI generated with Snk', font='small', resources=[], annotations={}, symlink_resources=False, _snk_config_path=PosixPath('snk.yaml'))
+        """
+        if not snk_config_path.exists():
+            raise MissingSnkConfigError(
+                f"Could not find SNK config file: {snk_config_path}"
+            ) from FileNotFoundError
+        # raise error if file is empty
+        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["version"] = get_version_from_config(snk_config_path, snk_config_dict)
+        if "annotations" in snk_config_dict:
+            # TODO: remove annotations in the future
+            snk_config_dict["cli"] = snk_config_dict["annotations"]
+            del snk_config_dict["annotations"]
+        if "conda_required" in snk_config_dict:
+            # TODO: remove conda_required in the future
+            snk_config_dict["conda"] = snk_config_dict["conda_required"]
+            del snk_config_dict["conda_required"]
+        snk_config = cls(**snk_config_dict)
+        snk_config.resources = [
+            snk_config_path.parent / resource for resource in snk_config.resources
+        ]
+        snk_config.validate_resources(snk_config.resources)
+        snk_config._snk_config_path = snk_config_path
+        return snk_config
+  
+    @classmethod
+    def from_workflow_dir(
+        cls, workflow_dir_path: Path, create_if_not_exists: bool = False
+    ):
+        """
+        Load and validate SNK config from workflow directory.
+        Args:
+          workflow_dir_path (Path): Path to the workflow directory.
+          create_if_not_exists (bool): Whether to create a SNK config file if one does not exist.
+        Returns:
+          SnkConfig: A SnkConfig object.
+        Raises:
+          FileNotFoundError: If the SNK config file is not found.
+        Examples:
+          >>> SnkConfig.from_workflow_dir(Path("workflow"))
+          SnkConfig(art=None, logo=None, tagline='A Snakemake workflow CLI generated with Snk', font='small', resources=[], annotations={}, symlink_resources=False, _snk_config_path=PosixPath('workflow/snk.yaml'))
+        """
+        if (workflow_dir_path / "snk.yaml").exists():
+            return cls.from_path(workflow_dir_path / "snk.yaml")
+        elif (workflow_dir_path / ".snk").exists():
+            import warnings
+
+            warnings.warn(
+                "Use of .snk will be deprecated in the future. Please use snk.yaml instead.",
+                DeprecationWarning,
+            )
+            return cls.from_path(workflow_dir_path / ".snk")
+        elif create_if_not_exists:
+            snk_config = cls(_snk_config_path=workflow_dir_path / "snk.yaml")
+            return snk_config
+        else:
+            raise FileNotFoundError(
+                f"Could not find SNK config file in workflow directory: {workflow_dir_path}"
+            )
+
+    def validate_resources(self, resources):
+        """
+        Validate resources.
+        Args:
+          resources (List[Path]): List of resources to validate.
+        Raises:
+          FileNotFoundError: If a resource is not found.
+        Notes:
+          This function does not modify the resources list.
+        Examples:
+          >>> SnkConfig.validate_resources([Path("resource1.txt"), Path("resource2.txt")])
+        """
+        for resource in resources:
+            if not resource.exists():
+                raise FileNotFoundError(f"Could not find resource: {resource}")
+
+    def add_resources(self, resources: List[Path], workflow_dir_path: Path = None):
+        """
+        Add resources to the SNK config.
+        Args:
+          resources (List[Path]): List of resources to add.
+          workflow_dir_path (Path): Path to the workflow directory.
+        Returns:
+          None
+        Side Effects:
+          Adds the resources to the SNK config.
+        Examples:
+          >>> snk_config = SnkConfig()
+          >>> snk_config.add_resources([Path("resource1.txt"), Path("resource2.txt")], Path("workflow"))
+        """
+        processed = []
+        for resource in resources:
+            if workflow_dir_path and not resource.is_absolute():
+                resource = workflow_dir_path / resource
+            processed.append(resource)
+        self.validate_resources(processed)
+        self.resources.extend(processed)
+
+    def to_yaml(self, path: Path) -> None:
+        """
+        Write SNK config to YAML file.
+        Args:
+          path (Path): Path to write the YAML file to.
+        Returns:
+          None
+        Side Effects:
+          Writes the SNK config to the specified path.
+        Examples:
+          >>> snk_config = SnkConfig()
+          >>> snk_config.to_yaml(Path("snk.yaml"))
+        """
+        config_dict = {k: v for k, v in vars(self).items() if not k.startswith("_")}
+        with open(path, "w") as f:
+            yaml.dump(config_dict, f)
+
+    def save(self) -> None:
+        """
+        Save SNK config.
+        Args:
+          path (Path): Path to write the YAML file to.
+        Returns:
+          None
+        Side Effects:
+          Writes the SNK config to the path specified by _snk_config_path.
+        Examples:
+          >>> snk_config = SnkConfig()
+          >>> snk_config.save()
+        """
+        self.to_yaml(self._snk_config_path)
+
+
+def get_config_from_workflow_dir(workflow_dir_path: Path):
+    """
+    Get the config file from a workflow directory.
+    Args:
+      workflow_dir_path (Path): Path to the workflow directory.
+    Returns:
+      Path: Path to the config file, or None if not found.
+    Examples:
+      >>> get_config_from_workflow_dir(Path("workflow"))
+      PosixPath('workflow/config.yaml')
+    """
+    for path in [
+        Path("config") / "config.yaml",
+        Path("config") / "config.yml",
+        "config.yaml",
+        "config.yml",
+    ]:
+        if (workflow_dir_path / path).exists():
+            return workflow_dir_path / path
+    return None
+
+
+def load_workflow_snakemake_config(workflow_dir_path: Path):
+    """
+    Load the Snakemake config from a workflow directory.
+    Args:
+      workflow_dir_path (Path): Path to the workflow directory.
+    Returns:
+      dict: The Snakemake config.
+    Examples:
+      >>> load_workflow_snakemake_config(Path("workflow"))
+      {'inputs': {'data': 'data.txt'}, 'outputs': {'results': 'results.txt'}}
+    """
+    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)