dvt-core 1.11.0b4__py3-none-any.whl

dvt/cli/option_types.py

@@ -0,0 +1,121 @@
+from typing import Optional
+
+import pytz
+from click import Choice, Context, Parameter, ParamType
+from dvt.config.utils import normalize_warn_error_options, parse_cli_yaml_string
+from dvt.event_time.sample_window import SampleWindow
+from dvt.events import ALL_EVENT_NAMES
+from dvt.exceptions import OptionNotYamlDictError, ValidationError
+
+from dbt_common.exceptions import DbtValidationError
+from dbt_common.helper_types import WarnErrorOptionsV2
+
+
+class YAML(ParamType):
+    """The Click YAML type. Converts YAML strings into objects."""
+
+    name = "YAML"
+
+    def convert(self, value, param, ctx):
+        # assume non-string values are a problem
+        if not isinstance(value, str):
+            self.fail(f"Cannot load YAML from type {type(value)}", param, ctx)
+        try:
+            param_option_name = param.opts[0] if param.opts else param.name
+            return parse_cli_yaml_string(value, param_option_name.strip("-"))
+        except (ValidationError, DbtValidationError, OptionNotYamlDictError):
+            self.fail(f"String '{value}' is not valid YAML", param, ctx)
+
+
+class Package(ParamType):
+    """The Click STRING type. Converts string into dict with package name and version.
+    Example package:
+        package-name@1.0.0
+        package-name
+    """
+
+    name = "NewPackage"
+
+    def convert(self, value, param, ctx):
+        # assume non-string values are a problem
+        if not isinstance(value, str):
+            self.fail(f"Cannot load Package from type {type(value)}", param, ctx)
+        try:
+            package_name, package_version = value.split("@")
+            return {"name": package_name, "version": package_version}
+        except ValueError:
+            return {"name": value, "version": None}
+
+
+class WarnErrorOptionsType(YAML):
+    """The Click WarnErrorOptions type. Converts YAML strings into objects."""
+
+    name = "WarnErrorOptionsType"
+
+    def convert(self, value, param, ctx):
+        # this function is being used by param in click
+        warn_error_options = super().convert(value, param, ctx)
+        normalize_warn_error_options(warn_error_options)
+
+        return WarnErrorOptionsV2(
+            error=warn_error_options.get("error", []),
+            warn=warn_error_options.get("warn", []),
+            silence=warn_error_options.get("silence", []),
+            valid_error_names=ALL_EVENT_NAMES,
+        )
+
+
+class Truthy(ParamType):
+    """The Click Truthy type.  Converts strings into a "truthy" type"""
+
+    name = "TRUTHY"
+
+    def convert(self, value, param, ctx):
+        # assume non-string / non-None values are a problem
+        if not isinstance(value, (str, None)):
+            self.fail(f"Cannot load TRUTHY from type {type(value)}", param, ctx)
+
+        if value is None or value.lower() in ("0", "false", "f"):
+            return None
+        else:
+            return value
+
+
+class ChoiceTuple(Choice):
+    name = "CHOICE_TUPLE"
+
+    def convert(self, value, param, ctx):
+        if not isinstance(value, str):
+            for value_item in value:
+                super().convert(value_item, param, ctx)
+        else:
+            super().convert(value, param, ctx)
+
+        return value
+
+
+class SampleType(ParamType):
+    name = "SAMPLE"
+
+    def convert(
+        self, value, param: Optional[Parameter], ctx: Optional[Context]
+    ) -> Optional[SampleWindow]:
+        if value is None:
+            return None
+
+        if isinstance(value, str):
+            try:
+                # Try and identify if it's a "dict" or a "str"
+                if value.lstrip()[0] == "{":
+                    param_option_name: str = param.opts[0] if param.opts else param.name  # type: ignore
+                    parsed_dict = parse_cli_yaml_string(value, param_option_name.strip("-"))
+                    sample_window = SampleWindow.from_dict(parsed_dict)
+                    sample_window.start = sample_window.start.replace(tzinfo=pytz.UTC)
+                    sample_window.end = sample_window.end.replace(tzinfo=pytz.UTC)
+                    return sample_window
+                else:
+                    return SampleWindow.from_relative_string(value)
+            except Exception as e:
+                self.fail(e.__str__(), param, ctx)
+        else:
+            self.fail(f"Cannot load SAMPLE_WINDOW from type {type(value)}", param, ctx)

dvt/cli/options.py

@@ -0,0 +1,79 @@
+import inspect
+import typing as t
+
+import click
+from click import Context
+from click.parser import _OptionParser, _ParsingState
+from dvt.cli.option_types import ChoiceTuple
+
+
+# Implementation from: https://stackoverflow.com/a/48394004
+# Note MultiOption options must be specified with type=tuple or type=ChoiceTuple (https://github.com/pallets/click/issues/2012)
+class MultiOption(click.Option):
+    def __init__(self, *args, **kwargs) -> None:
+        self.save_other_options = kwargs.pop("save_other_options", True)
+        nargs = kwargs.pop("nargs", -1)
+        assert nargs == -1, "nargs, if set, must be -1 not {}".format(nargs)
+        super(MultiOption, self).__init__(*args, **kwargs)
+        # this makes mypy happy, setting these to None causes mypy failures
+        self._previous_parser_process = lambda *args, **kwargs: None
+        self._eat_all_parser = lambda *args, **kwargs: None
+
+        # validate that multiple=True
+        multiple = kwargs.pop("multiple", None)
+        msg = f"MultiOption named `{self.name}` must have multiple=True (rather than {multiple})"
+        assert multiple, msg
+
+        # validate that type=tuple or type=ChoiceTuple
+        option_type = kwargs.pop("type", None)
+        msg = f"MultiOption named `{self.name}` must be tuple or ChoiceTuple (rather than {option_type})"
+        if inspect.isclass(option_type):
+            assert issubclass(option_type, tuple), msg
+        else:
+            assert isinstance(option_type, ChoiceTuple), msg
+
+    def add_to_parser(self, parser: _OptionParser, ctx: Context):
+        def parser_process(value: str, state: _ParsingState):
+            # method to hook to the parser.process
+            done = False
+            value_list = str.split(value, " ")
+            if self.save_other_options:
+                # grab everything up to the next option
+                while state.rargs and not done:
+                    for prefix in self._eat_all_parser.prefixes:  # type: ignore[attr-defined]
+                        if state.rargs[0].startswith(prefix):
+                            done = True
+                    if not done:
+                        value_list.append(state.rargs.pop(0))
+            else:
+                # grab everything remaining
+                value_list += state.rargs
+                state.rargs[:] = []
+            value_tuple = tuple(value_list)
+            # call the actual process
+            self._previous_parser_process(value_tuple, state)
+
+        retval = super(MultiOption, self).add_to_parser(parser, ctx)
+        for name in self.opts:
+            our_parser = parser._long_opt.get(name) or parser._short_opt.get(name)
+            if our_parser:
+                self._eat_all_parser = our_parser  # type: ignore[assignment]
+                self._previous_parser_process = our_parser.process
+                # mypy doesnt like assingment to a method see https://github.com/python/mypy/issues/708
+                our_parser.process = parser_process  # type: ignore[method-assign]
+                break
+        return retval
+
+    def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any:
+        def flatten(data):
+            if isinstance(data, tuple):
+                for x in data:
+                    yield from flatten(x)
+            else:
+                yield data
+
+        # there will be nested tuples to flatten when multiple=True
+        value = super(MultiOption, self).type_cast_value(ctx, value)
+        if value:
+            value = tuple(flatten(value))
+        return value