snk-cli 0.5.4__tar.gz → 0.6.0__tar.gz

{snk_cli-0.5.4 → snk_cli-0.6.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.3
 Name: snk-cli
-Version: 0.5.4
+Version: 0.6.0
 Project-URL: Documentation, https://github.com/wytamma/snk-cli#readme
 Project-URL: Issues, https://github.com/wytamma/snk-cli/issues
 Project-URL: Source, https://github.com/wytamma/snk-cli
 Author-email: Wytamma Wirth <wytamma.wirth@me.com>
-License-Expression: MIT
-License-File: LICENSE.txt
+License: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.8
@@ -27,7 +26,7 @@ Requires-Dist: snakemake>=7
 Requires-Dist: typer~=0.9
 Description-Content-Type: text/markdown
 
-# snk-cli
+# Snk-CLI
 [![PyPI - Version](https://img.shields.io/pypi/v/snk-cli.svg)](https://pypi.org/project/snk-cli)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/snk-cli.svg)](https://pypi.org/project/snk-cli)
 [![write-the - docs](https://badgen.net/badge/write-the/docs/blue?icon=https://raw.githubusercontent.com/Wytamma/write-the/master/images/write-the-icon.svg)](https://write-the.wytamma.com/)

{snk_cli-0.5.4 → snk_cli-0.6.0}/README.md

@@ -1,4 +1,4 @@
-# snk-cli
+# Snk-CLI
 [![PyPI - Version](https://img.shields.io/pypi/v/snk-cli.svg)](https://pypi.org/project/snk-cli)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/snk-cli.svg)](https://pypi.org/project/snk-cli)
 [![write-the - docs](https://badgen.net/badge/write-the/docs/blue?icon=https://raw.githubusercontent.com/Wytamma/write-the/master/images/write-the-icon.svg)](https://write-the.wytamma.com/)

{snk_cli-0.5.4 → snk_cli-0.6.0}/src/snk_cli/__about__.py

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

{snk_cli-0.5.4 → snk_cli-0.6.0}/src/snk_cli/cli.py

@@ -82,10 +82,11 @@ class CLI(DynamicTyper):
         ):
             os.environ["CONDA_SUBDIR"] = "osx-64"
 
-        if platform.system() in ["Linux", "Darwin"] and not os.environ.get("XDG_CACHE_HOME"):
+        user = os.environ.get("USER")
+        if platform.system() in ["Linux", "Darwin"] and not os.environ.get("XDG_CACHE_HOME") and user:
             # this prevents OSError: [Errno 39] Directory not empty: 'envs'
             # on older versions of snakemake
-            os.environ["XDG_CACHE_HOME"] = f"/tmp/.cache/{self.name}"
+            os.environ["XDG_CACHE_HOME"] = f"/tmp/snk-{user}-{self.name}"
 
         # dynamically create the logo
         self.logo = self._create_logo(

{snk_cli-0.5.4 → snk_cli-0.6.0}/src/snk_cli/dynamic_typer.py

@@ -1,5 +1,6 @@
 import typer
-from typing import List, Callable
+from click import Tuple
+from typing import List, Callable, get_origin
 from inspect import signature, Parameter
 from makefun import with_signature
 from enum import Enum
@@ -7,7 +8,9 @@ from enum import Enum
 from .options import Option
 import sys
 
-
+def parse_colon_separated_pair(value: str):
+    return tuple(value.split(sep=':', maxsplit=2))
+    
 class DynamicTyper:
     app: typer.Typer
 
@@ -149,15 +152,20 @@ class DynamicTyper:
         """
         annotation_type = option.type
         default = option.default
-        if option.type is Enum or option.choices:
-            if not option.choices:
-                raise ValueError(f"Enum type {option.name} requires choices to be defined.")
-            annotation_type = Enum(f'{option.name}', {str(e): str(e) for e in option.choices})
+        if option.choices:
             if default:
               try:
                 default = annotation_type(default)
               except ValueError:
-                raise ValueError(f"Default value {default} for option {option.name} is not a valid choice.")
+                raise ValueError(f"Default value '{default}' for option '{option.name}' is not a valid choice.")
+            annotation_type = Enum(f'{option.name}', {str(e): annotation_type(e) for e in option.choices})
+        metavar, parser = None, None
+        if get_origin(annotation_type) is dict or annotation_type is dict:
+            metavar = "KEY:VALUE"
+            parser = parse_colon_separated_pair
+            annotation_type = List[Tuple]
+            if type(default) is dict:
+                default = [f"{k}:{v}" for k, v in default.items()]
         return Parameter(
             option.name,
             kind=Parameter.POSITIONAL_OR_KEYWORD,
@@ -167,6 +175,8 @@ class DynamicTyper:
                 help=f"{option.help}",
                 rich_help_panel="Workflow Configuration",
                 hidden=option.hidden,
+                metavar=metavar,
+                parser=parser,
             ),
             annotation=annotation_type,
         )
@@ -238,8 +248,15 @@ class DynamicTyper:
             for snk_cli_option in options:
 
                 def add_option_to_args():
-                    kwargs["ctx"].args.extend([f"--{snk_cli_option.name}", kwargs[snk_cli_option.name]])
-
+                    value = kwargs[snk_cli_option.name]
+                    if (snk_cli_option.type is dict or get_origin(snk_cli_option.type) is dict) and isinstance(value, list):
+                        # Convert the list of tuples to a dictionary
+                        value = dict(kwargs[snk_cli_option.name])
+                        if get_origin(snk_cli_option.type) is dict:
+                            # get the value type from the type hint
+                            value_type = snk_cli_option.type.__args__[1]
+                            value = {k: value_type(v) for k, v in value.items()}
+                    kwargs["ctx"].args.extend([f"--{snk_cli_option.name}", value])
                 passed_via_command_line = self.check_if_option_passed_via_command_line(
                     snk_cli_option
                 )

{snk_cli-0.5.4 → snk_cli-0.6.0}/src/snk_cli/options/utils.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Tuple, get_origin
 from ..config.config import SnkConfig
 from ..utils import get_default_type, flatten
 from .option import Option
@@ -18,9 +18,21 @@ types = {
     "list[str]": List[str],
     "list[path]": List[Path],
     "list[int]": List[int],
-    "enum": Enum,
+    "list[float]": List[float],
+    "pair": Tuple[str, str],
+    "dict": dict,
+    "dict[str, str]": dict[str, str],
+    "dict[str, int]": dict[str, int],
 }
 
+# Define the basic types for the combinations
+basic_types = [int, str, bool, float]
+
+# Add the combinations of the basic types to the `types` dictionary
+for t1 in basic_types:
+    for t2 in basic_types:
+        types[f"pair[{t1.__name__}, {t2.__name__}]"] = Tuple[t1, t2]
+
 def get_keys_from_annotation(annotations):
     # Get the unique keys from the annotations
     # preserving the order
@@ -50,27 +62,32 @@ def create_option_from_annotation(
       Option: An Option object.
     """
     config_default = default_values.get(annotation_key, None)
-
     default = annotation_values.get(f"{annotation_key}:default", config_default)
     updated = False
     if config_default is None or default != config_default:
         updated = True
-    type = annotation_values.get(f"{annotation_key}:type", get_default_type(default))
-    assert (
-        type is not None
-    ), f"Type for {annotation_key} should be one of {', '.join(types.keys())}."
+    annotation_type = annotation_values.get(f"{annotation_key}:type", None) 
+    if annotation_type is not None: 
+        assert annotation_type in types, f"Type '{annotation_type}' not supported."
+    annotation_type = annotation_type or get_default_type(default)
     annotation_type = types.get(
-        type.lower(), List[str] if "list" in type.lower() else str
+        annotation_type, List[str] if "list" in annotation_type else str
     )
     name = annotation_values.get(
         f"{annotation_key}:name", annotation_key.replace(":", "_")
     ).replace("-", "_")
     short = annotation_values.get(f"{annotation_key}:short", None)
     hidden = annotation_values.get(f"{annotation_key}:hidden", False)
+    default=annotation_values.get(f"{annotation_key}:default", default)
+    if default and get_origin(annotation_type) is tuple:
+        assert len(default) == 2, f"Default value ({default}) for '{annotation_key}' should be a list of length 2."
+    choices = annotation_values.get(f"{annotation_key}:choices", None)
+    if choices:
+        assert isinstance(choices, list), f"Choices should be a list for '{annotation_key}'."
     return Option(
         name=name,
         original_key=annotation_key,
-        default=annotation_values.get(f"{annotation_key}:default", default),
+        default=default,
         updated=updated,
         help=annotation_values.get(f"{annotation_key}:help", ""),
         type=annotation_type,
@@ -97,9 +114,9 @@ def build_dynamic_cli_options(
     Returns:
       List[dict]: A list of options.
     """
-    flat_config = flatten(snakemake_config)
     flat_annotations = flatten(snk_config.cli)
     annotation_keys = get_keys_from_annotation(flat_annotations)
+    flat_config = flatten(snakemake_config, stop_at=annotation_keys)
     options = {}
 
     # For every parameter in the config, create an option from the corresponding annotation

{snk_cli-0.5.4 → snk_cli-0.6.0}/src/snk_cli/utils.py

@@ -30,7 +30,7 @@ def check_command_available(command: str):
     return which(command) is not None
 
 
-def flatten(d, parent_key="", sep=":"):
+def flatten(d, parent_key="", sep=":", stop_at=[]):
     """
     Flattens a nested dictionary.
 
@@ -50,8 +50,11 @@ def flatten(d, parent_key="", sep=":"):
     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())
+        if new_key in stop_at:
+            # this allows dict to be flattened up to a certain level so we can have dict types
+            items.append((new_key, v))
+        elif isinstance(v, MutableMapping):
+            items.extend(flatten(v, new_key, sep=sep, stop_at=stop_at).items())
         else:
             items.append((new_key, v))
     return dict(items)
@@ -97,6 +100,13 @@ def serialise(d):
     """
     if isinstance(d, Path) or isinstance(d, datetime):
         return str(d)
+    
+    # check enum type
+    if hasattr(d, "value"):
+        return d.value
+
+    if isinstance(d, tuple):
+        return list(d) 
 
     if isinstance(d, list):
         return [serialise(x) for x in d]
@@ -155,7 +165,7 @@ def parse_config_args(args: List[str], options: List[Option]):
 
 def get_default_type(v):
     default_type = type(v)
-    if default_type == list and len(v) > 0:
+    if default_type is list and len(v) > 0:
         return f"List[{type(v[0]).__name__}]"
     return str(default_type.__name__)
 

{snk_cli-0.5.4 → snk_cli-0.6.0}/src/snk_cli/validate.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, Dict, Union
+from typing import Any, Dict, Union, get_origin
 from .config import SnkConfig
 from .options.utils import types
 import inspect
@@ -56,11 +56,16 @@ def validate_and_transform_in_place(config: Dict[str, Any], validation: Validati
             if val_type is None:
                 raise ValueError(f"Unknown type '{val_info['type']}'")
             try:
-                if getattr(val_type, "__origin__", None) == list:
+                if getattr(val_type, "__origin__", None) is 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]
+                elif get_origin(val_type) is tuple:
+                    assert len(value) == 2, f"Expected a list of length 2 for key '{key}'"
+                    key_type = val_type.__args__[0]
+                    val_type = val_type.__args__[1]
+                    config[key] = [key_type(value[0]), val_type(value[1])]
                 else:
                     config[key] = val_type(value)
             except (ValueError, TypeError) as e:

{snk_cli-0.5.4 → snk_cli-0.6.0}/tests/data/workflow/snk.yaml

@@ -9,8 +9,17 @@ cli:
     type: bool
   null_annotation:
     default: null
+  KeyValuePair:
+    default: ["key", "value"]
+    help: A key-value pair
+    type: pair 
   enum:
     choices: [a, b, c]
+    default: "a"
+  dict:
+    help: A dictionary
+    type: dict[str, int]
+    default: ["key:1"]
   test:
     another:
       test:

{snk_cli-0.5.4 → snk_cli-0.6.0}/tests/test_cli/test_snk_config.py

@@ -44,7 +44,7 @@ def test_non_standard_configfile(tmp_path):
     assert "config2" in res.stdout, res.stderr
 
 def test_snk_config_with_enums(tmp_path):
-    runner = dynamic_runner({}, SnkConfig(cli={"test": {"choices": ["enum1", "enum2"], "type": "enum"}}), tmp_path=tmp_path)
+    runner = dynamic_runner({}, SnkConfig(cli={"test": {"choices": ["enum1", "enum2"], "type": "str"}}), tmp_path=tmp_path)
     res = runner.invoke(["run", "--help"])
     assert res.exit_code == 0, res.stderr
     assert "enum1" in res.stdout, res.stderr

{snk_cli-0.5.4 → snk_cli-0.6.0}/tests/test_cli/test_validate.py

@@ -73,6 +73,18 @@ import pytest
         {"example": {"type": "list[path]"}},
         {"example": [Path("1"), Path("2")]}
     ),
+    # pair type
+    (
+        {"example": ["1", "2"]},
+        {"example": {"type": "pair[int, int]"}},
+        {"example": [1, 2]}   
+    ),
+    # choices
+    (
+        {"example": "a"},
+        {"example": {"type": "str", "choices": ["a", "b"]}},
+        {"example": "a"}
+    ),
     # nested dictionary
     (
         {"example": {"nested": "1"}},

snk_cli-0.6.0/tests/test_types.py

@@ -0,0 +1,198 @@
+# integration tests for the annotation types from the snk config, snakemake config, and the command line interface
+
+import pytest
+from .utils import dynamic_runner
+from snk_cli.config import SnkConfig
+
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # str
+    (
+        {"example": "1"},
+        {"example": {"type": "str"}},
+        ["--example", "1"],
+        "{'example': '1'}"
+    )])
+def test_str(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+    
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # int
+    (
+        {"example": "1"},
+        {"example": {"type": "int"}},
+        ["--example", "1"],
+        "{'example': 1}"
+    )])
+def test_int(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # float
+    (
+        {"example": "1"},
+        {"example": {"type": "float"}},
+        ["--example", "1"],
+        "{'example': 1.0}"
+    )])
+def test_float(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # bool
+    (
+        {"example": "1"},
+        {"example": {"type": "bool"}},
+        ["--example"],
+        "{'example': True}"
+    )])
+def test_bool(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # path
+    (
+        {"example": "file"},
+        {"example": {"type": "path"}},
+        ["--example", "file"],
+        "{'example': 'file'}"
+    )])
+def test_path(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # list
+    (
+        {"example": [1,2,3]},
+        {"example": {"type": "list"}},
+        ["--example", "1", "--example", "2", "--example", "3"],
+        "{'example': ['1', '2', '3']}"
+    )])
+def test_list(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # pair
+    (
+        {"example": [1, 2]},
+        {"example": {"type": "pair"}},
+        ["--example", "1", "2"],
+        "{'example': ['1', '2']}"
+    ),
+    (
+        {"example": [1, 2]},
+        {"example": {"type": "pair[int, int]"}},
+        ["--example", "1", "2"],
+        "{'example': [1, 2]}"
+    ),
+    (
+        {"example": ["1", "2"]},
+        {"example": {"type": "pair[float, float]"}},
+        ["--example", "1", "2"],
+        "{'example': [1.0, 2.0]}"
+    ),
+    (
+        {"example": ["1", "2"]},
+        {"example": {"type": "pair[str, str]"}},
+        ["--example", "1", "2"],
+        "{'example': ['1', '2']}"
+    ),
+    (
+        {"example": ["1", "2"]},
+        {"example": {"type": "pair[str, int]"}},
+        ["--example", "1", "2"],
+        "{'example': ['1', 2]}"
+    ),
+    (
+        {"example": ["1", "2"]},
+        {"example": {"type": "pair[int, str]"}},
+        ["--example", "1", "2"],
+        "{'example': [1, '2']}"
+    )
+])
+def test_pair(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # choices
+    (
+        {"example": 1},
+        {"example": {"type": "int", "choices": [1, 2, 3]}},
+        ["--example", 1],
+        "{'example': 1}"
+    ),
+    (
+        {"example": 1},
+        {"example": {"type": "int", "choices": [2, 3], "default": 2}},
+        [],
+        "{'example': 2}"
+    ),
+    ])
+def test_choices(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr
+
+@pytest.mark.parametrize("snakemake_config,annotations,cli_args,expected", [
+    # dict
+    (
+        {"example": {"key": "value"}},
+        {"example": {"type": "dict", "default": ["key:value"]}},
+        [],
+        "{'example': {'key': 'value'}}"
+    ),
+    (
+        {"example": {"key": "value"}},
+        {"example": {"type": "dict"}},
+        [],
+        "{'example': {'key': 'value'}}"
+    ),
+    (
+        {"example": {"number": 1}},
+        {"example": {"type": "dict[str, int]"}},
+        [],
+        "{'example': {'number': 1}}"
+    ),
+    (
+        {},
+        {"example": {"type": "dict[str, str]"}},
+        ["--example", "new:2"],
+        "{'example': {'new': '2'}}"
+    )
+    ])
+def test_dict(snakemake_config, annotations, cli_args, expected):
+    snk_config = SnkConfig(cli=annotations)
+    runner = dynamic_runner(snakemake_config, snk_config)
+    res = runner.invoke(["run"] + cli_args)
+    assert res.exit_code == 0, res.stderr
+    assert expected in res.stdout, res.stderr