Elep

import argparse
import shlex
import sys

from copy import deepcopy

from ..config import Configuration
from ..setting import BooleanSetting, ChoiceSetting, ListSetting
from .base import Source

__all__ = ("CommandLineSource",)

# pylint: disable=R0201

class CommandLineSource(Source):
    # pylint: disable=R0913
    def __init__(
        self,
        arguments=None,
        options=None,
        version=None,
        parser_options=None,
        positional=None,
    ):
        super(CommandLineSource, self).__init__()

if arguments is None:
            self.arguments = sys.argv[1:]
        elif isinstance(arguments, str):
            self.arguments = shlex.split(arguments)
        elif isinstance(arguments, (list, tuple)):
            self.arguments = arguments
        else:
            raise TypeError("arguments must be a string or list of strings")

self.version = version
        self.options = options or {}
        self.parser_options = parser_options or {}
        self.positional = positional or ()

def get_flags(self, setting):
        if setting.name in self.options:
            if "flags" in self.options[setting.name]:
                return self.options[setting.name]["flags"]

flags = []
        flag = "--%s" % setting.name.lower().replace("_", "-")
        flags.append(flag)
        return flags

def get_action(self, setting):
        if isinstance(setting, BooleanSetting):
            return "store_false" if setting.default else "store_true"
        elif isinstance(setting, ListSetting):
            return "append"
        else:
            return "store"

# pylint: disable=W0613
    def get_default(self, setting):
        # Caveat: Returning something other than SUPPRESS probably won't
        # work the way you'd think.
        return argparse.SUPPRESS

def get_type(self, setting):
        if isinstance(setting, (ListSetting, BooleanSetting)):
            return None
        elif isinstance(setting, ChoiceSetting):
            return setting.subtype.sanitize
        else:
            return setting.sanitize

def get_dest(self, setting):
        return setting.name

def get_choices(self, setting):
        if isinstance(setting, ChoiceSetting):
            return setting.choices
        else:
            return None

def get_help(self, setting):
        if setting.name in self.options:
            if "help" in self.options[setting.name]:
                return self.options[setting.name]["help"]
        return None

def get_metavar(self, setting):
        if setting.name in self.options:
            if "metavar" in self.options[setting.name]:
                return self.options[setting.name]["metavar"]
        return None

def build_argument(self, setting):
        flags = self.get_flags(setting)
        action = self.get_action(setting)
        default = self.get_default(setting)
        argtype = self.get_type(setting)
        dest = self.get_dest(setting)
        choices = self.get_choices(setting)
        arghelp = self.get_help(setting)
        metavar = self.get_metavar(setting)

argument_kwargs = {
            "action": action,
            "default": default,
            "dest": dest,
            "help": arghelp,
        }
        if argtype:
            argument_kwargs["type"] = argtype
        if choices:
            argument_kwargs["choices"] = choices
        if metavar:
            argument_kwargs["metavar"] = metavar

return flags, argument_kwargs

def build_parser(self, settings, manager):
        parser_options = deepcopy(self.parser_options)
        if not parser_options.get("prog") and manager:
            parser_options["prog"] = manager.name
        parser = argparse.ArgumentParser(**parser_options)

add_version = self.version is not None

for setting in settings:
            flags, argument_kwargs = self.build_argument(setting)
            parser.add_argument(*flags, **argument_kwargs)

if add_version and setting.name == "version":
                # Don't want to conflict with the desired setting
                add_version = False

if add_version:
            parser.add_argument(
                "--version", action="version", version="%(prog)s " + self.version
            )

if self.positional:
            for name, options in self.positional:
                parser.add_argument(name, **options)

return parser

def get_config(self, settings, manager=None, parent=None):
        parser = self.build_parser(settings, manager)
        parsed = parser.parse_args(self.arguments)

for setting in settings:
            if hasattr(parsed, setting.name):
                setting.value = getattr(parsed, setting.name)

if self.positional and manager:
            arguments = {}
            for name, _ in self.positional:
                if hasattr(parsed, name):
                    arguments[name] = getattr(parsed, name)
            setattr(manager, "arguments", arguments)

return Configuration(settings=settings, parent=parent)