Esempio n. 1
0
 def add_argument(self, argument_parser: ArgumentParser, name: str,
                  default: Any, prefixes: Tuple[str, ...],
                  domain: Tuple[str, ...]) -> None:
     prefixes_name = join_names(prefixes, name)
     argument_parser.add_argument(
         f'--{prefixes_name}',
         dest=join_dests(domain, name),
         help=prefixes_name,
         type=register_homo_tuple(self.tp, argument_parser),
         choices=self.choices,
         required=None if default == SUPPRESS else False,
         action=StoreAction,
         default=default,
         metavar=f'({self.tp.__name__.lower()}, ...)',
     )
Esempio n. 2
0
    def add_argument(self, argument_parser: ArgumentParser, name: str,
                     default: Any, prefixes: Tuple[str, ...],
                     domain: Tuple[str, ...]) -> None:

        if name is not None:
            domain = domain + (name, )
            if name.endswith('_'):
                _, argument_parser = get_action_group(
                    argument_parser, join_names(prefixes, name))
                prefixes = prefixes + (name[:-1], )

        argument_parser.set_defaults(
            **{join_dests(domain, AKU_FN): (self.tp, name)})

        for arg, tp, df in tp_iter(self.tp):
            AkuTp[tp].add_argument(
                argument_parser=argument_parser,
                name=arg,
                prefixes=prefixes,
                domain=domain,
                default=df,
            )
Esempio n. 3
0
    def add_argument(self, argument_parser: ArgumentParser, name: str,
                     default: Any, prefixes: Tuple[str, ...],
                     domain: Tuple[str, ...]) -> None:
        choices = {c.__name__: c for c in self.choices}

        class UnionAction(Action):
            def __call__(self,
                         parser: ArgumentParser,
                         namespace: Namespace,
                         values,
                         option_string=None):
                setattr(namespace, self.dest, (choices[values], values))
                self.required = False

                delay = parser._registries.get('delay')['@aku']
                delay.append(
                    functools.partial(
                        AkuFn(choices[values], None).add_argument,
                        argument_parser=parser,
                        name=name,
                        prefixes=prefixes,
                        domain=domain,
                        default=None,
                    ))

        prefixes_name = join_names(prefixes, name)
        argument_parser.add_argument(
            f'--{prefixes_name}',
            dest=join_dests(domain + (name, ), AKU_FN),
            help=prefixes_name,
            type=self.tp,
            choices=tuple(choices.keys()),
            required=None,
            default=SUPPRESS,
            action=UnionAction,
            metavar=f'fn{{{", ".join(choices.keys())}}}')