fix: avoid dependeing on argparse_dataclass fork

Author: johanneskoester

pyproject.toml

@@ -8,7 +8,7 @@ readme = "README.md"
 version = "2.0.0"
 
 [tool.poetry.dependencies]
-argparse-dataclass = {git = "https://github.com/johanneskoester/argparse_dataclass.git"}
+argparse-dataclass = "^2.0.0"
 python = "^3.9"
 throttler = "^1.2.2"
 snakemake-interface-common = "^1.3.1"

snakemake_interface_executor_plugins/_common.py

@@ -3,5 +3,110 @@
 __email__ = "[email protected]"
 __license__ = "MIT"
 
+from dataclasses import MISSING, Field
+from types import NoneType
+from typing import Any, Dict, List, Literal, Tuple, Union, get_args, get_origin
+from argparse_dataclass import _handle_bool_type
+
+
 executor_plugin_prefix = "snakemake-executor-plugin-"
 executor_plugin_module_prefix = executor_plugin_prefix.replace("-", "_")
+
+
+# Taken from https://github.com/mivade/argparse_dataclass/pull/59/files.
+# TODO remove once https://github.com/mivade/argparse_dataclass/pull/59/files is
+# merged and released
+def dataclass_field_to_argument_args(
+    field: Field[Any],
+) -> Tuple[List[str], Dict[str, Any]]:
+    """Extract kwargs of ArgumentParser.add_argument from a dataclass field.
+
+    Returns pair of (args, kwargs) to be passed to ArgumentParser.add_argument.
+    """
+    args = field.metadata.get("args", [f"--{field.name.replace('_', '-')}"])
+    positional = not args[0].startswith("-")
+    kwargs = {
+        "type": field.metadata.get("type", field.type),
+        "help": field.metadata.get("help", None),
+    }
+
+    if field.metadata.get("args") and not positional:
+        # We want to ensure that we store the argument based on the
+        # name of the field and not whatever flag name was provided
+        kwargs["dest"] = field.name
+
+    if field.metadata.get("choices") is not None:
+        kwargs["choices"] = field.metadata["choices"]
+
+    # Support Literal types as an alternative means of specifying choices.
+    if get_origin(field.type) is Literal:
+        # Prohibit a potential collision with the choices field
+        if field.metadata.get("choices") is not None:
+            raise ValueError(
+                f"Cannot infer type of items in field: {field.name}. "
+                "Literal type arguments should not be combined with choices in the "
+                "metadata. "
+                "Remove the redundant choices field from the metadata."
+            )
+
+        # Get the types of the arguments of the Literal
+        types = [type(arg) for arg in get_args(field.type)]
+
+        # Make sure just a single type has been used
+        if len(set(types)) > 1:
+            raise ValueError(
+                f"Cannot infer type of items in field: {field.name}. "
+                "Literal type arguments should contain choices of a single type. "
+                f"Instead, {len(set(types))} types where found: "
+                + ", ".join([type_.__name__ for type_ in set(types)])
+                + "."
+            )
+
+        # Overwrite the type kwarg
+        kwargs["type"] = types[0]
+        # Use the literal arguments as choices
+        kwargs["choices"] = get_args(field.type)
+
+    if field.metadata.get("metavar") is not None:
+        kwargs["metavar"] = field.metadata["metavar"]
+
+    if field.metadata.get("nargs") is not None:
+        kwargs["nargs"] = field.metadata["nargs"]
+        if field.metadata.get("type") is None:
+            # When nargs is specified, field.type should be a list,
+            # or something equivalent, like typing.List.
+            # Using it would most likely result in an error, so if the user
+            # did not specify the type of the elements within the list, we
+            # try to infer it:
+            try:
+                kwargs["type"] = get_args(field.type)[0]  # get_args returns a tuple
+            except IndexError:
+                # get_args returned an empty tuple, type cannot be inferred
+                raise ValueError(
+                    f"Cannot infer type of items in field: {field.name}. "
+                    "Try using a parameterized type hint, or "
+                    "specifying the type explicitly using metadata['type']"
+                )
+
+    if field.default == field.default_factory == MISSING and not positional:
+        kwargs["required"] = True
+    else:
+        kwargs["default"] = MISSING
+
+    if field.type is bool:
+        _handle_bool_type(field, args, kwargs)
+    elif get_origin(field.type) is Union:
+        if field.metadata.get("type") is None:
+            # Optional[X] is equivalent to Union[X, None].
+            f_args = get_args(field.type)
+            if len(f_args) == 2 and NoneType in f_args:
+                arg = next(a for a in f_args if a is not NoneType)
+                kwargs["type"] = arg
+            else:
+                raise TypeError(
+                    "For Union types other than 'Optional', a custom 'type' must be "
+                    "specified using "
+                    "'metadata'."
+                )
+
+    return args, kwargs

snakemake_interface_executor_plugins/registry/plugin.py

@@ -3,7 +3,7 @@
 __email__ = "[email protected]"
 __license__ = "MIT"
 
-from argparse_dataclass import field_to_argument_args, fields
+from argparse_dataclass import fields
 from dataclasses import MISSING, Field, dataclass
 from typing import Any, Optional, Type
 import copy
@@ -12,6 +12,9 @@
 from snakemake_interface_common.exceptions import WorkflowError
 
 from snakemake_interface_executor_plugins.exceptions import InvalidPluginException
+from snakemake_interface_executor_plugins._common import (
+    dataclass_field_to_argument_args,
+)
 
 # Valid Argument types (to distinguish from empty dataclasses)
 ArgTypes = (str, int, float, bool, list)
@@ -67,7 +70,7 @@ def register_cli_args(self, argparser):
         settings = argparser.add_argument_group(f"{self.name} executor settings")
 
         for field in fields(dc):
-            args, kwargs = field_to_argument_args(field)
+            args, kwargs = dataclass_field_to_argument_args(field)
 
             if field.metadata.get("env_var"):
                 kwargs["env_var"] = f"SNAKEMAKE_{prefixed_name.upper()}"