snk-cli 0.0.1__py3-none-any.whl

snk_cli/subcommands/utils.py

@@ -0,0 +1,175 @@
+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

snk_cli/testing.py

@@ -0,0 +1,19 @@
+from typer.testing import CliRunner, Result
+from dataclasses import dataclass
+from typing import List
+from snk_cli import CLI
+import sys
+
+@dataclass
+class SnkCliRunner:
+    """Dynamically create a CLI Runner for testing"""
+
+    cli: CLI
+    runner = CliRunner(mix_stderr=False)
+
+    def invoke(self, args: List[str]) -> Result:
+        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

snk_cli/utils.py

@@ -0,0 +1,149 @@
+from typing import List
+from pathlib import Path
+from datetime import datetime
+import typer
+import sys
+import collections  # MutableMapping import hack
+
+if sys.version_info.major == 3 and sys.version_info.minor >= 10:
+    from collections.abc import MutableMapping
+else:
+    from collections import MutableMapping
+from snk_cli.options import Option
+
+
+def check_command_available(command: str):
+    """
+    Check if a command is available.
+    Args:
+      command (str): The command to check.
+    Returns:
+      bool: True if the command is available, False otherwise.
+    Examples:
+      >>> CLI.check_command_available('ls')
+    """
+    from shutil import which
+
+    return which(command) is not None
+
+
+def flatten(d, parent_key="", sep=":"):
+    """
+    Flattens a nested dictionary.
+    Args:
+      d (dict): The dictionary to flatten.
+      parent_key (str, optional): The parent key of the dictionary. Defaults to ''.
+      sep (str, optional): The separator to use between keys. Defaults to ':'.
+    Returns:
+      dict: A flattened dictionary.
+    Examples:
+      >>> d = {'a': {'b': 1, 'c': 2}, 'd': 3}
+      >>> flatten(d)
+      {'a:b': 1, 'a:c': 2, 'd': 3}
+    """
+    items = []
+    for k, v in d.items():
+        new_key = parent_key + sep + k if parent_key else k
+        if isinstance(v, MutableMapping):
+            items.extend(flatten(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def convert_key_to_snakemake_format(key, value, sep=":"):
+    """
+    Convert key to a format that can be passed over the cli to snakemake
+    """
+    result_dict = {}
+    parts = key.split(sep)
+    current_dict = result_dict
+
+    for part in parts[:-1]:
+        current_dict = current_dict.setdefault(part, {})
+
+    current_dict[parts[-1]] = value
+
+    return result_dict
+
+
+def serialise(d):
+    """
+    Serialises a data structure into a string.
+    Args:
+      d (any): The data structure to serialise.
+    Returns:
+      any: The serialised data structure.
+    Examples:
+      >>> serialise({'a': 1, 'b': 2})
+      {'a': '1', 'b': '2'}
+    """
+    if isinstance(d, Path) or isinstance(d, datetime):
+        return str(d)
+
+    if isinstance(d, list):
+        return [serialise(x) for x in d]
+
+    if isinstance(d, dict):
+        for k, v in d.items():
+            d.update({k: serialise(v)})
+
+    # return anything else, like a string or number
+    return d
+
+
+def parse_config_args(args: List[str], options: List[Option]):
+    """
+    Parses a list of arguments and a list of options.
+    Args:
+      args (List[str]): A list of arguments.
+      options (List[Option]): A list of options.
+    Returns:
+      (List[str], List[dict]): A tuple of parsed arguments and config.
+    Examples:
+      >>> parse_config_args(['-name', 'John', '-age', '20'], [{'name': 'name', 'default': '', 'help': '', 'type': 'str', 'required': True}, {'name': 'age', 'default': '', 'help': '', 'type': 'int', 'required': True}])
+      (['John', '20'], [{'name': 'name', 'John'}, {'age': 20}])
+    """
+    names = [op.name for op in options]
+    config = []
+    parsed: List[str] = []
+    flag = None
+    for arg in args:
+        if flag:
+            name = flag.lstrip("-")
+            op = next(op for op in options if op.name == name)
+            if op.updated is False and op.default == serialise(arg):
+                # skip args that don't change
+                flag = None
+                continue
+            if ":" in op.original_key:
+                samkemake_format_config = convert_key_to_snakemake_format(
+                    op.original_key, arg
+                )
+                name = list(samkemake_format_config.keys())[0]
+                arg = samkemake_format_config[name]
+            config.append({name: serialise(arg)})
+            flag = None
+            continue
+        if arg.startswith("-") and arg.lstrip("-") in names:
+            flag = arg
+            continue
+        parsed.append(arg)
+    parsed.sort()
+    return parsed, config
+
+
+def get_default_type(v):
+    default_type = type(v)
+    if default_type == list and len(v) > 0:
+        return f"List[{type(v[0]).__name__}]"
+    return str(default_type.__name__)
+
+
+def dag_filetype_callback(ctx: typer.Context, file: Path):
+    allowed = [".pdf", ".png", ".svg"]
+    if ctx.resilient_parsing or not file:
+        return
+    if file.suffix not in allowed:
+        raise typer.BadParameter(f"Dag file suffix must be one of {','.join(allowed)}!")
+    return file

snk_cli/validate.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from typing import Any, Dict, Union
+from .config import SnkConfig
+from .options.utils import types
+import inspect
+
+class ValidationError(Exception):
+    """Base class for all validation exceptions"""
+
+
+def validate_config(config: Dict[str, Any], snk_config_path: Path) -> None:
+    """
+    Validates the config against the snk config.
+    Will convert values to the correct type if possible.
+    Args:
+        config (dict): The config to validate.
+        snk_config_path (Path): The path to the snk config.
+    """
+    snk_config_path = Path(snk_config_path)
+    # if relative path, make absolute to 
+    if not snk_config_path.is_absolute():
+        frame = inspect.currentframe().f_back
+        workflow = frame.f_globals.get("workflow")
+        snk_config_path = Path(workflow.current_basedir) / snk_config_path
+
+    snk_config = SnkConfig.from_path(snk_config_path)
+    validate_and_transform_in_place(config, snk_config.cli)
+
+ValidationDict = Dict[str, Union["ValidationDict", Dict[str, str]]]
+
+def validate_and_transform_in_place(config: Dict[str, Any], validation: ValidationDict, replace_none: bool = True) -> None:
+    """
+    Validates the config against the snk config.
+    Will convert values to the correct type if possible.
+    Args:
+        config (dict): The config to validate.
+        validation (dict): The validation dict.
+        replace_none (bool): If True, replace 'None' with None.
+    """
+    for key, value in list(config.items()):
+        if key not in validation:
+            continue  # Optionally handle unexpected keys
+        if value == 'None' and replace_none:
+            config[key] = None
+            continue
+        if value is None:
+            continue
+        val_info = validation[key]
+        if isinstance(val_info, dict) and 'type' in val_info:
+            # Direct type validation
+            val_type = types.get(val_info["type"], None)
+            if val_type is None:
+                raise ValueError(f"Unknown type '{val_info['type']}'")
+            try:
+                if getattr(val_type, "__origin__", None) == list:
+                    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]
+                else:
+                    config[key] = val_type(value)
+            except (ValueError, TypeError) as e:
+                raise ValueError(f"Type conversion error for key '{key}': {e}")
+        elif isinstance(value, dict):
+            # Nested dictionary validation
+            validate_and_transform_in_place(value, val_info)

snk_cli/workflow.py

@@ -0,0 +1,177 @@
+from pathlib import Path
+import sys
+from typing import Optional
+from git import Repo, InvalidGitRepositoryError
+import importlib.util
+import os
+
+class Workflow:
+    """
+    Represents a workflow.
+    Attributes:
+      path (Path): The path to the workflow.
+      repo (Repo): The git repository of the workflow.
+      name (str): The name of the workflow.
+    """
+
+    def __init__(self, path: Path) -> None:
+        """
+        Initializes a Workflow object.
+        Args:
+            path (Path): The path to the workflow.
+        Returns:
+            None
+        Notes:
+            Initializes the `repo` and `name` attributes.
+        """
+        self.path = path
+        self.editable = self.check_is_editable()
+        if self.editable:  # editable mode
+            self.repo = None
+        else:
+            try:
+                self.repo = Repo(path)
+            except InvalidGitRepositoryError:
+                self.repo = None
+        self.name = self.path.name
+
+
+    @property
+    def tag(self):
+        """
+        Gets the tag of the workflow.
+        Returns:
+            str: The tag of the workflow, or None if no tag is found.
+        """
+        try:
+            tag = self.repo.git.describe(["--tags", "--exact-match"])
+        except Exception:
+            tag = None
+        return tag
+    
+    @property
+    def commit(self):
+        """
+        Gets the commit SHA of the workflow.
+        Returns:
+            str: The commit SHA of the workflow.
+        """
+        try:
+            sha = self.repo.head.object.hexsha
+            commit = self.repo.git.rev_parse(sha, short=8)
+        except Exception:
+           commit = None
+        return commit
+
+    @property
+    def version(self):
+        """
+        Gets the version of the workflow.
+        Returns:
+            str: The version of the workflow, or None if no version is found.
+        """
+        if self.repo is None:
+            return None
+        if self.tag:
+            version = self.tag
+        else:
+            version = self.commit
+        return version
+
+    @property
+    def executable(self):
+        """
+        Gets the executable of the workflow.
+        Returns:
+            Path: The path to the workflow executable.
+        """
+        workflow_bin_dir = self.path.parent.parent / "bin"
+        name = self.name
+        if sys.platform.startswith("win"):
+            name += ".exe"
+        return workflow_bin_dir / name
+    
+    @property
+    def conda_prefix_dir(self):
+        """
+        Gets the conda prefix directory of the workflow. If in editable mode, the conda prefix directory is
+        located in the .snakemake directory. Otherwise, it is located in the .conda directory in the workflow
+        directory.
+        
+        Returns:
+            Path: The path to the conda prefix directory.
+        """
+        return Path(".snakemake") / "conda" if self.editable else self.path / ".conda"
+
+    @property
+    def singularity_prefix_dir(self):
+        """
+        Gets the singularity prefix directory of the workflow.
+        Returns:
+            Path: The path to the singularity prefix directory.
+        """
+        if " " in str(self.path):
+            # sigh, snakemake singularity does not support spaces in the path
+            # https://github.com/snakemake/snakemake/blob/2ecb21ba04088b9e6850447760f713784cf8b775/snakemake/deployment/singularity.py#L130C1-L131C1
+            return None
+        return Path(".snakemake") / "singularity" if self.editable else self.path / ".singularity"
+    
+    def _is_editable_pip_install(self):
+        # This function now acts as a method within the Workflow class
+        package_spec = importlib.util.find_spec(self.name)
+        if package_spec is None:
+            return False  # Package is not installed
+
+        package_location = package_spec.origin
+        site_packages_paths = [p for p in sys.path if 'site-packages' in p]
+        is_inside_site_packages = any(package_location.startswith(sp) for sp in site_packages_paths)
+
+        if not is_inside_site_packages:
+            return True
+
+        for sp in site_packages_paths:
+            egg_link_path = os.path.join(sp, self.name + '.egg-link')
+            if os.path.isfile(egg_link_path):
+                return True
+
+        return False
+
+    def check_is_editable(self):
+        """Is the workflow editable?"""
+        if self.path.is_symlink():
+            return True
+        try:
+            return self._is_editable_pip_install()
+        except Exception:
+            return False
+
+    def _find_folder(self, name) -> Optional[Path]:
+        """Search for folder"""
+        if (self.path / "workflow" / name).exists():
+            return self.path / "workflow" / name
+        if (self.path / name).exists():
+            return self.path / name
+        return None
+
+    @property
+    def profiles(self):
+        workflow_profile_dir = self._find_folder("profiles")
+        if workflow_profile_dir:
+            return [p for p in workflow_profile_dir.glob("*") if p.is_dir() and (p / "config.yaml").exists()]
+        return []
+
+    @property
+    def environments(self):
+        workflow_environments_dir = self._find_folder("envs")
+        if workflow_environments_dir:
+            return [e for e in workflow_environments_dir.glob("*.yaml")] + [
+                e for e in workflow_environments_dir.glob("*.yml")
+            ]
+        return []
+
+    @property
+    def scripts(self):
+        workflow_environments_dir = self._find_folder("scripts")
+        if workflow_environments_dir:
+            return [s for s in workflow_environments_dir.iterdir() if s.is_file()]
+        return []

snk_cli-0.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,25 @@
+snk_cli/__about__.py,sha256=I1WJyeCzQRHJXTtCdvlSm6jF2FfYm8nKcOMZELFuzCE,131
+snk_cli/__init__.py,sha256=iZGwZ9O_cUMK1OC2v6HxIHeLf-TQ_aKxPbVrtdRU0gI,167
+snk_cli/cli.py,sha256=K6hs5PpThGDPtXYrYxgRcUhwm1MEKcQSKH4rra-Nq1Y,7807
+snk_cli/dynamic_typer.py,sha256=h743N18SYtYXivhDM6yp8fenmNFHKWa5zTGgazPBk40,9137
+snk_cli/testing.py,sha256=F8kElQOM73XAfo5OVmpNU0KILPp88059PTwJkDt9aWc,556
+snk_cli/utils.py,sha256=aFUZjbKNfUtqtPL1SPQ4qae2FkDJQ36QRUA0YRnqfpM,4482
+snk_cli/validate.py,sha256=4VKstHpDmM2AuyPjkvQXenClMskOjZ5dJyW1FPuiqrU,2686
+snk_cli/workflow.py,sha256=fMyZ1nXtDMoLf3Aa3csOC5E1IokV8EcSQp84hSajnIE,5626
+snk_cli/config/__init__.py,sha256=pbFmOEXCm6dG0eIsAoozMmXN9VomL5uuO29oHTmu3Ew,30
+snk_cli/config/config.py,sha256=eK4qh0jSS-hU1CYqFR3JD780Zju3nngOs-AGgjWNf2E,8309
+snk_cli/config/utils.py,sha256=7nhOas6Q1WV7EEdlKbVRkbTprx0SMCzDJ6kbx-vKmZc,1378
+snk_cli/options/__init__.py,sha256=Vz2wNDyY_AacPrU439TteFvEXvBEdmb0dDYlvJN_LzA,41
+snk_cli/options/option.py,sha256=4IzW6l0fMN-ilagkGVmivNm7dkEBvfu5iVuO7WuOx7Y,340
+snk_cli/options/utils.py,sha256=6ofFLX6UbIj0RqwQxfN-sL7oShy2a4RMXEQZrDSoGWk,3838
+snk_cli/subcommands/__init__.py,sha256=Q0kkzHRumlpGQdLSYGcGKZJRtQXYDVx-F_4IvP-274s,140
+snk_cli/subcommands/config.py,sha256=wv-m-gAgK1BnKCeUBLf3XAh_Xmyz7oJMTlafdhpL3NY,2268
+snk_cli/subcommands/env.py,sha256=XHrWbb0IHHA6e7oEyFjt_M-pPovTCDV9ZpvpKN7R_98,8051
+snk_cli/subcommands/profile.py,sha256=4xY6DV7H_Cylx9wsyBtRB7LpNrqydEa-FiU0hS4bodw,2032
+snk_cli/subcommands/run.py,sha256=bgwGbVqpMuw1rsssz051OPHX4FyjYxXbJU-fTq5i6Og,17139
+snk_cli/subcommands/script.py,sha256=2cHbFwpdUhLFC7naPbUxtmdBYYGYUx8-GGF-TZ-jl80,5126
+snk_cli/subcommands/utils.py,sha256=z2UK40oqzDClzhajtTBoRiUmp2A_ztDm3wueIpL0BdA,5470
+snk_cli-0.0.1.dist-info/METADATA,sha256=JEV1XOPqrtkaV9q0scaHhzbkhyUsxtORi6bDWvn_CRY,1095
+snk_cli-0.0.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+snk_cli-0.0.1.dist-info/licenses/LICENSE.txt,sha256=2EtbIEsC6oT0hDoWB8mP643X4l51wwQRdhofPSN0MLc,1101
+snk_cli-0.0.1.dist-info/RECORD,,

snk_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.21.1
+Root-Is-Purelib: true
+Tag: py3-none-any

snk_cli-0.0.1.dist-info/licenses/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.