How to use argcomplete - 10 common examples

def try_argcomplete(parser):
        argcomplete.autocomplete(parser, always_complete_options=False)
else:

def try_argcomplete(parser):
        argcomplete.autocomplete(parser, always_complete_options=False)

def finalize_options(self, available_targets: list, **kwargs):
        target_option = self._parser.add_argument("targets", metavar="TARGET", nargs=argparse.OPTIONAL,
                                                  help="The target to build",
                                                  choices=available_targets + [EXTRACT_SDK_TARGET])
        if self._completing_arguments:
            try:
                import argcomplete
            except ImportError:
                sys.exit("argcomplete missing")
            target_completer = argcomplete.completers.ChoicesCompleter(available_targets)
            target_option.completer = target_completer
            argcomplete.autocomplete(
                self._parser,
                always_complete_options=None,  # don't print -/-- by default
                print_suppressed=True,  # also include target-specific options
                )

for p in [run_parser, io_parser, convert_parser, generate_parser]:
        p.error = single_error_message(p)

    # Do not want stderr message
    def silent_msg(x):
        pass

    parser.error = silent_msg

    """
    Parse the command and check that everything went fine
    """
    args = None
    unknown_args = None
    try:
        argcomplete.autocomplete(parser)
        args, unknown_args = parser.parse_known_args()
        if unknown_args:
            if ('--verbose' in unknown_args) or ('-v' in unknown_args):
                cprint("Verbose detected")
                args.verbose = True
            unknown_args = [i for i in unknown_args if i != '-v']
            unknown_args = [i for i in unknown_args if i != '--verbose']
            if unknown_args:
                print('%s[Warning] Unknown flag(s) detected: %s. This will be ignored by Clinica%s' %
                      (Fore.YELLOW, unknown_args, Fore.RESET))
    except SystemExit:
        exit(0)
    except Exception:
        print("%s\n[Error] You wrote wrong arguments on the command line. Clinica will now exit.\n%s" % (Fore.RED, Fore.RESET))
        parser.print_help()
        exit(-1)

def main():
    parser = argparse.ArgumentParser(description="provides various info about components")
    parser.add_argument('argument', nargs='?', choices=['list'])
    
    argcomplete.autocomplete(parser)
    args = parser.parse_args()

    if args.argument=='list':
        components = WS.list_packages(WS.workspace_paths)
        componentsname=[]
        for component in components:
            componentsname.append(component.split('/')[ len(component.split('/')) -1 ])
        opstring = "   ".join(componentsname)
        print(opstring)
    else:
        parser.error("sorry no such option is available ")

feature_subs = feature.add_subparsers(dest='action')

    fstart = feature_subs.add_parser('start',
        help="start a new feature branch")
    fstart.add_argument('name', help="name of the feature")
    fstart.add_argument('--track', default=False, action='store_true',
        help="set up a tracking branch on your github immediately.")
    fstart.add_argument('-i', '--issue-number', type=int,
        action='store', default=None,
        help="prepend an issue number to the feature name")

    fwork = feature_subs.add_parser('work',
        help="switch to a different feature (by name)")
    fwork_name = fwork.add_argument('identifier', help="name of feature to switch to")
    if offline_engine is not None:
        fwork_name.completer = argcomplete.completers.ChoicesCompleter(
            [branch.name.split(FEATURE_PREFIX)[1] for branch in repo.branches
                if branch.name.startswith(FEATURE_PREFIX)],
        )
    fwork.add_argument('--issue', '-i',
        action='store_true', default=False,
        help='switch to a branch by issue number instead of by name')

    fpublish = feature_subs.add_parser('publish',
        help="send the current feature branch to origin and create a pull-request")
    fpublish_name = fpublish.add_argument('name', nargs='?',
        default=None,
        help='name of feature to publish. If not given, uses current feature',
    )
    if offline_engine is not None:
        fpublish_name.completer = argcomplete.completers.ChoicesCompleter(
            [branch.name.split(FEATURE_PREFIX)[1] for branch in repo.branches

${PARAM:4:2} # start:len
    ${PARAM/substr/replace}
    ${PARAM^} # upper initial
    ${PARAM,} # lower initial
    ${PARAM^^} # upper
    ${PARAM,,} # lower

    Comment lines start with '#'
    Lines can be continued by adding '\' at the end

    See https://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_10_03.html
    (arrays not supported)
    """
    parser = get_parser(formatter=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("component", nargs="?", help="Compenent to descend into").completer = \
        ChoicesCompleter([c.name for c in Project().get_components()])
    parser.add_argument("--branch", "-b", help="Branch to get active parameters for").completer = \
        ChoicesCompleter(Git().get_branches())
    parser.add_argument("--resolve-images", "-r", action="store_true", help="Also resolve subcomponent AMI IDs and docker repo urls")
    subcomponent_group = parser.add_mutually_exclusive_group()
    subcomponent_group.add_argument("--stack", "-s", help="CloudFormation subcomponent to descent into").completer = \
        lambda prefix, parsed_args, **kwargs: component_typed_subcomponents("stack", prefix, parsed_args, **kwargs)
    subcomponent_group.add_argument("--serverless", "-l", help="Serverless subcomponent to descent into").completer = \
        lambda prefix, parsed_args, **kwargs: component_typed_subcomponents("serverless", prefix, parsed_args, **kwargs)
    subcomponent_group.add_argument("--docker", "-d", help="Docker image subcomponent to descent into").completer = \
        lambda prefix, parsed_args, **kwargs: component_typed_subcomponents("docker", prefix, parsed_args, **kwargs)
    subcomponent_group.add_argument("--image", "-i", const="", nargs="?", help="AMI image subcomponent to descent into").completer = \
        lambda prefix, parsed_args, **kwargs: component_typed_subcomponents("image", prefix, parsed_args, **kwargs)
    subcomponent_group.add_argument("--cdk", "-c", help="CDK subcomponent to descent into").completer = \
        lambda prefix, parsed_args, **kwargs: component_typed_subcomponents("cdk", prefix, parsed_args, **kwargs)
    subcomponent_group.add_argument("--terraform", "-t", help="Terraform subcomponent to descent into").completer = \
        lambda prefix, parsed_args, **kwargs: component_typed_subcomponents("terraform", prefix, parsed_args, **kwargs)

"""Returns a list of all the products available in the current repo source
    tree."""

    products = []
    product_globpat = os.path.join(repo_root_path(), "products", "*")
    try:
        for product_path in glob.glob(product_globpat):
            if not os.path.isdir(product_path):
                continue
            _product_path_split = os.path.normpath(product_path).split("/")
            product_name = _product_path_split[-1]
            try:
                product_obj = Product(product_name)
            except Exception as exc:
                exctype = exc.__class__.__name__
                argcomplete.warn(line("""
                    An exception {!r} occured when evaluating product
                    {!r}.""").format(exctype, product_name))
                continue
            products.append(product_name)
    except Exception as exc:
        exctype = exc.__class__.__name__
        argcomplete.warn(line("""
            An exception {!r} occured when enumerating all the available
            products.""").format(exctype))

    return products

if not os.path.isdir(product_path):
                continue
            _product_path_split = os.path.normpath(product_path).split("/")
            product_name = _product_path_split[-1]
            try:
                product_obj = Product(product_name)
            except Exception as exc:
                exctype = exc.__class__.__name__
                argcomplete.warn(line("""
                    An exception {!r} occured when evaluating product
                    {!r}.""").format(exctype, product_name))
                continue
            products.append(product_name)
    except Exception as exc:
        exctype = exc.__class__.__name__
        argcomplete.warn(line("""
            An exception {!r} occured when enumerating all the available
            products.""").format(exctype))

    return products

def complete_command(self, command):
        """
        Given a command string, return a list of suggestions to complete the last token.
        """
        parser = Commands.build_parser(self)
        cf = argcomplete.CompletionFinder(parser)
        cword_prequote, cword_prefix, _, comp_words, first_colon_pos = argcomplete.split_line(command, len(command))

        # Strip whitespace and parse according to shell escaping rules
        try:
            clean = lambda s: shlex.split(s.strip())[0] if s else ''
        except ValueError as e:
            raise UsageError(e.message)
        return map(clean, cf._get_completions(comp_words, cword_prefix, cword_prequote, first_colon_pos))