snk-cli 0.0.1__py3-none-any.whl

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/__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/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/config/__init__.py

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

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)

snk_cli/config/utils.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from snakemake import load_configfile
+
+def get_version_from_config(config_path: Path, config_dict: dict = None) -> str:
+    """
+    Get the version from config. If dict not provided, load from file.
+    If the version is a path to a __about__ file, load the version from the file.
+    Path must be relative to the config file.
+    Args:
+      config_path (Path): Path to the config file.
+      config_dict (dict): Config dict.
+    Returns:
+      str: Version.
+    Examples:
+      >>> get_version_from_config_dict({"version": "0.1.0"})
+      '0.1.0'
+    """
+    if not config_dict:
+        config_dict = load_configfile(config_path)
+    
+    if "version" not in config_dict:
+        return None 
+    if config_dict["version"] is None:
+        return None
+    version = str(config_dict["version"])
+    if "__about__.py" in version:
+        # load version from __about__.py
+        about_path = config_path.parent / version
+        if not about_path.exists():
+            raise FileNotFoundError(
+                f"Could not find version file: {about_path}"
+            )
+        about = {}
+        exec(about_path.read_text(), about)
+        try:
+            version = about["__version__"]
+        except KeyError as e:
+            raise KeyError(
+                f"Could not find __version__ in file: {about_path}"
+            ) from e
+    return version