Public Member Functions
	__init__ (self)

	print_help (self)

	get_option_names (self, *flatten=False, without_dash=False)

	check_if_valid_option_name (self, args, *kwargs)

	add_argument (self, args, *kwargs)

List	make_cmd (self, SimpleNamespace cfg_args)

Data Fields
	driver

	target

Static Protected Attributes
list	_SUPPORTED_ACTION_TYPE = [DriverName, NormalOption, TargetOption]

Detailed Description

Definition at line 118 of file argumentparse.py.

Constructor & Destructor Documentation

◆ init()

argumentparse.ArgumentParser.__init__ ( self )

Definition at line 121 of file argumentparse.py.

    def __init__(self):
        # List[args, action type, data type, option type]
        self._actions: List[Tuple[Tuple[str], Action, Union[Type[str],
                                                            Type[bool]]]] = list()
        self.driver: str = None
        self.target: str = None
 

References argumentparse.ArgumentParser.driver, Command.Command.driver, argumentparse.ArgumentParser.target, and CfgRunner.CfgRunner.target.

Member Function Documentation

◆ add_argument()

argumentparse.ArgumentParser.add_argument	(		self,
		*	args,
		**	kwargs
	)

Definition at line 199 of file argumentparse.py.

    def add_argument(self, *args, **kwargs):
        self.check_if_valid_option_name(*args, **kwargs)
 
        action = kwargs['action']
        dtype = kwargs.get('dtype', str)
        if action == DriverName:
            assert len(args) == 1
            self.driver = args[0]
        else:
            if all(a.startswith('-') for a in args):
                otype = Optional
            elif all(not a.startswith('-') for a in args):
                otype = Positional
            else:
                raise RuntimeError(
                    'Invalid option names. Only either of option type is allowed: positional or optional'
                )
            self._actions.append((args, kwargs['action'], dtype, otype))
 

References argumentparse.ArgumentParser.check_if_valid_option_name().

◆ check_if_valid_option_name()

argumentparse.ArgumentParser.check_if_valid_option_name	(		self,
		*	args,
		**	kwargs
	)

Definition at line 177 of file argumentparse.py.

    def check_if_valid_option_name(self, *args, **kwargs):
        existing_options = self.get_option_names(flatten=True, without_dash=True)
        args_without_dash = [arg.lstrip('-') for arg in args]
        if any(arg in existing_options for arg in args_without_dash):
            raise RuntimeError('Duplicate option names')
        if not 'action' in kwargs:
            raise RuntimeError('"action" keyword argument is required')
 
        action = kwargs['action']
        if not action in self._SUPPORTED_ACTION_TYPE:
            raise RuntimeError('Invalid action')
        if not args:
            raise RuntimeError('Invalid option name')
        if action == DriverName and len(args) >= 2:
            raise RuntimeError('onecc doesn\'t support multiple driver name')
 
        dtype = kwargs.get('dtype', str)
        if dtype == bool and action != NormalOption:
            raise RuntimeError('Only normal option can be boolean type')
        if dtype == bool and not all(a.startswith('-') for a in args):
            raise RuntimeError('Boolean type option should start with dash("-")')
 

References argumentparse.ArgumentParser._SUPPORTED_ACTION_TYPE, and argumentparse.ArgumentParser.get_option_names().

Referenced by argumentparse.ArgumentParser.add_argument().

◆ get_option_names()

argumentparse.ArgumentParser.get_option_names	(		self,
		*	flatten = `False`,
			without_dash = `False`
	)

Get registered option names.

:param flatten: single option can have multiple names. 
  If it is True, such options are returned after flattened.
:param without_dash: optional argument has leading dash on its names. 
  If it is True, option names are returned without such dashes.

For example, say there are options like these.

  parser.add_argument("--verbose", action=NormalOption, dtype=bool)
  parser.add_argument("--output", "--output_path", action=NormalOption)

[EXAMPLES]
  get_option_names()
    [[--verbose], [--output, --output_path]]
  get_option_names(without_dash=True)
    [[verbose], [output, output_path]]
  get_option_names(flatten=True)
    [--verbose, --output, --output_path]
  get_option_names(flatten=True, without_dash=True)
    [verbose, output, output_path]

Definition at line 142 of file argumentparse.py.

    def get_option_names(self, *, flatten=False, without_dash=False):
        """
        Get registered option names.
 
        :param flatten: single option can have multiple names. 
          If it is True, such options are returned after flattened.
        :param without_dash: optional argument has leading dash on its names. 
          If it is True, option names are returned without such dashes.
 
        For example, say there are options like these.
 
          parser.add_argument("--verbose", action=NormalOption, dtype=bool)
          parser.add_argument("--output", "--output_path", action=NormalOption)
        
        [EXAMPLES]
          get_option_names()
            [[--verbose], [--output, --output_path]]
          get_option_names(without_dash=True)
            [[verbose], [output, output_path]]
          get_option_names(flatten=True)
            [--verbose, --output, --output_path]
          get_option_names(flatten=True, without_dash=True)
            [verbose, output, output_path]
        """
        names = []
        for action in self._actions:
            names.append(action[0])
 
        if flatten:
            names = [name for name_l in names for name in name_l]
        if without_dash:
            names = [name.lstrip('-') for name in names]
 
        return names
 

Referenced by argumentparse.ArgumentParser.check_if_valid_option_name().

◆ make_cmd()

List argumentparse.ArgumentParser.make_cmd	(		self,
		SimpleNamespace	cfg_args
	)

Definition at line 218 of file argumentparse.py.

    def make_cmd(self, cfg_args: SimpleNamespace) -> List:
        assert self.target, "Target should be set before making commands"
        assert self.driver, "Driver should be set before making commands"
        # find driver path
        driver_name = self.driver
        driver_list = backends.get_list(driver_name)
        if not driver_list:
            driver_list = [shutil.which(driver_name)]
            if not driver_list:
                raise FileNotFoundError(f'{driver_name} not found')
        # use first driver
        driver_path = driver_list[0]
        cmd: List = [driver_path]
        invalid_options = list(cfg_args.__dict__.keys())
        # traverse the action in order and make commands
        for action in self._actions:
            args, act, dtype, otype = action
            assert act in [NormalOption, TargetOption]
            if otype == Optional:
                option_names = []
                for arg in args:
                    if arg.startswith('--'):
                        option_names.append(arg[len('--'):])
                    elif arg.startswith('-'):
                        option_names.append(arg[len('-'):])
            elif otype == Positional:
                option_names = args
            else:
                assert False
 
            given_option = None
            if act == NormalOption:
                for option_name in option_names:
                    if oneutils.is_valid_attr(cfg_args, option_name):
                        given_option = option_name
                        break
                if not given_option:
                    continue
                if dtype == bool and given_option.lower() == "false":
                    continue
            if otype == Optional:
                # use first option
                cmd += [args[0]]
            if act == TargetOption:
                cmd += [self.target]
            else:
                assert act == NormalOption
                if dtype == str:
                    cmd += [getattr(cfg_args, given_option)]
                invalid_options.remove(given_option)
 
        if len(invalid_options):
            print(f'WARNING: there are invalid options {invalid_options}')
            self.print_help()
        return cmd

◆ print_help()

argumentparse.ArgumentParser.print_help ( self )

Definition at line 128 of file argumentparse.py.

    def print_help(self):
        backends_list = backends.get_list(self.driver)
        driver_path = None
        for cand in backends_list:
            if ntpath.basename(cand) == self.driver:
                driver_path = cand
        if not driver_path:
            driver_path = shutil.which(self.driver)
 
        if not driver_path:
            raise FileNotFoundError(self.driver + ' not found')
 
        oneutils.run([driver_path, '-h'], err_prefix=self.driver)
 

References argumentparse.ArgumentParser.driver, Command.Command.driver, and backends.get_list().

Field Documentation

◆ _SUPPORTED_ACTION_TYPE

list argumentparse.ArgumentParser._SUPPORTED_ACTION_TYPE = [DriverName, NormalOption, TargetOption]

staticprotected

Definition at line 119 of file argumentparse.py.

Referenced by argumentparse.ArgumentParser.check_if_valid_option_name().

◆ driver

argumentparse.ArgumentParser.driver

Definition at line 206 of file argumentparse.py.

Referenced by argumentparse.ArgumentParser.__init__(), argumentparse.ArgumentParser.print_help(), and Command.Command.run().

◆ target

argumentparse.ArgumentParser.target

Definition at line 219 of file argumentparse.py.

Referenced by argumentparse.ArgumentParser.__init__(), CfgRunner.CfgRunner.run(), and CfgRunner.CfgRunner.set_target().

The documentation for this class was generated from the following file:

compiler/one-cmds/onelib/argumentparse.py

Public Member Functions

Data Fields

Static Protected Attributes