- #dirnames# and #filenames# words to indicate that we want complete also files and dirs
import argparse
from abc import ABC, abstractmethod # pylint: disable=[no-name-in-module]
from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar
+from typing import Dict, List, Optional, Tuple, Type, TypeVar
from urllib.parse import quote
from knot_resolver.constants import API_SOCK_FILE, CONFIG_FILE
CompWords = Dict[str, Optional[str]]
+COMP_DIRNAMES = "#dirnames#"
+COMP_FILENAMES = "#filenames#"
+
_registered_commands: List[Type["Command"]] = []
-def get_subparsers_words(subparser_actions: List[argparse.Action]) -> CompWords:
+def get_parser_action(name: str, parser_actions: List[argparse.Action]) -> Optional[argparse.Action]:
+ for action in parser_actions:
+ if (action.choices and name in action.choices) or (action.option_strings and name in action.option_strings):
+ return action
+ return None
+
+
+def get_subparser_command(subparser: argparse.ArgumentParser) -> Optional["Command"]:
+ if "command" in subparser._defaults: # noqa: SLF001
+ return subparser._defaults["command"] # noqa: SLF001
+ return None
+
+
+def comp_get_actions_words(parser_actions: List[argparse.Action]) -> CompWords:
words: CompWords = {}
- for action in subparser_actions:
+ for action in parser_actions:
if isinstance(action, argparse._SubParsersAction) and action.choices: # noqa: SLF001
for choice, parser in action.choices.items():
- words[choice] = parser.description
- else:
+ words[choice] = parser.description if isinstance(parser, argparse.ArgumentParser) else None
+ elif action.option_strings:
for opt in action.option_strings:
words[opt] = action.help
+ elif not action.option_strings and action.choices:
+ for choice in action.choices:
+ words[choice] = action.help
+ elif not action.option_strings and not action.choices:
+ words[COMP_DIRNAMES] = None
+ words[COMP_FILENAMES] = None
return words
-def get_action_by_name(name: str, parser_actions: List[argparse.Action]) -> Optional[argparse.Action]:
- for action in parser_actions:
- if (action.choices and name in action.choices) or (action.option_strings and name in action.option_strings):
- return action
- return None
-
+def comp_get_words(args: List[str], parser_actions: List[argparse.Action]) -> CompWords: # noqa: PLR0912
+ words: CompWords = comp_get_actions_words(parser_actions)
+ nargs = len(args)
+
+ skip_arg = False
+ for i, arg in enumerate(args):
+ action: Optional[argparse.Action] = get_parser_action(arg, parser_actions) # noqa: SLF001
+
+ if skip_arg:
+ skip_arg = False
+ continue
+
+ if not action:
+ words = comp_get_actions_words(parser_actions)
+ continue
+
+ if i + 1 >= nargs:
+ return words
+
+ # if not action or action is HelpAction or VersionAction
+ if isinstance(action, (argparse._HelpAction, argparse._VersionAction)): # noqa: SLF001
+ words = {}
+ break
+
+ # if action is StoreTrueAction or StoreFalseAction
+ if isinstance(action, argparse._StoreConstAction): # noqa: SLF001
+ continue
+
+ # if action is StoreAction
+ if isinstance(action, argparse._StoreAction): # noqa: SLF001
+ choices = {}
+ if action.choices:
+ for choice in action.choices:
+ choices[choice] = action.help
+ else:
+ choices[COMP_DIRNAMES] = None
+ choices[COMP_FILENAMES] = None
+ words = choices
+ skip_arg = True
+ continue
+
+ # if action is SubParserAction
+ if isinstance(action, argparse._SubParsersAction): # noqa: SLF001
+ subparser = action.choices[arg]
+ cmd = get_subparser_command(subparser)
+ return cmd.completion(args[i + 1 :], subparser) if cmd else {}
+
+ # delete already used args
+ for arg in args:
+ if arg in words.keys():
+ del words[arg]
-def get_subparser_command(subparser: argparse.ArgumentParser) -> "Command":
- defaults: Dict[str, Any] = subparser._defaults # noqa: SLF001
- if "command" in defaults:
- return defaults["command"]
- raise ValueError(f"missing 'command' default for '{subparser.prog}' parser")
+ return words
def register_command(cls: T) -> T:
from enum import Enum
from typing import Any, Dict, List, Optional, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, get_subparsers_words, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.datamodel.cache_schema import CacheClearRPCSchema
from knot_resolver.utils.modeling.exceptions import AggregateDataValidationError, DataValidationError
from knot_resolver.utils.modeling.parsing import DataFormat, parse_json
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return get_subparsers_words(parser._actions) # noqa: SLF001
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None:
if not self.operation:
import argparse
from enum import Enum
-from typing import List, Optional, Tuple, Type
+from typing import List, Tuple, Type
from knot_resolver.client.command import (
Command,
CommandArgs,
CompWords,
- get_action_by_name,
- get_subparser_command,
- get_subparsers_words,
+ comp_get_words,
register_command,
)
def __init__(self, namespace: argparse.Namespace) -> None:
super().__init__(namespace)
self.shell: Shells = namespace.shell
- self.space = namespace.space
self.args: List[str] = namespace.args
- if self.space:
- self.args.append("")
-
@staticmethod
def register_args_subparser(
subparser: "argparse._SubParsersAction[argparse.ArgumentParser]",
"completion",
help="commands auto-completion",
)
- completion.add_argument(
- "--space",
- help="space after last word, returns all possible folowing options",
- dest="space",
- action="store_true",
- default=False,
- )
shells_dest = "shell"
shells = completion.add_mutually_exclusive_group()
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return get_subparsers_words(parser._actions) # noqa: SLF001
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None: # noqa: PLR0912
- subparsers = args.parser._subparsers # noqa: SLF001
words: CompWords = {}
+ subparsers = args.parser._subparsers # noqa: SLF001
if subparsers:
- words = get_subparsers_words(subparsers._actions) # noqa: SLF001
-
- args_iter = iter(self.args)
- for arg in args_iter:
- action: Optional[argparse.Action] = get_action_by_name(arg, subparsers._actions) # noqa: SLF001
-
- # if action is SubParserAction; complete using the command
- if isinstance(action, argparse._SubParsersAction) and arg in action.choices: # noqa: SLF001
- # remove from words
- for choice in action.choices:
- del words[choice]
-
- subparser = action.choices[arg]
- cmd = get_subparser_command(subparser)
-
- nargs = len(self.args)
- index = self.args.index(arg) + 1
- # check that index is not out of args length
- if index > nargs:
- break
-
- # complete using the command
- words = cmd.completion(self.args[index:], subparser)
- break
-
- # if action is StoreAction; skip number of arguments
- if isinstance(action, argparse._StoreAction) and arg in action.option_strings: # noqa: SLF001
- # remove from words
- for option_string in action.option_strings:
- del words[option_string]
-
- if action.nargs and isinstance(action.nargs, int):
- for _ in range(action.nargs):
- next(args_iter)
- continue
-
- # remove other options from words
- if action and action.option_strings:
- for option_string in action.option_strings:
- del words[option_string]
-
- # if 'arg' is not found in actions
- # there is nothing to complete
- if not action:
- break
+ words = comp_get_words(self.args, subparsers._actions) # noqa: SLF001
# print completion words
# based on required bash/fish shell format
from enum import Enum
from typing import Any, Dict, List, Literal, Optional, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, get_subparsers_words, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.datamodel import KresConfig
from knot_resolver.utils.modeling.parsing import DataFormat, parse_json, try_to_parse
from knot_resolver.utils.requests import request
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- words = get_subparsers_words(parser._actions) # noqa: SLF001
+ words = comp_get_words(args, parser._actions) # noqa: SLF001
if args is None:
return words
from pathlib import Path
from typing import List, Optional, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, get_subparsers_words, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.datamodel import KresConfig
from knot_resolver.datamodel.globals import Context, reset_global_validation_context, set_global_validation_context
from knot_resolver.utils.modeling import try_to_parse
type=str,
help="File with configuration in YAML or JSON format.",
)
-
convert.add_argument(
"output_file",
type=str,
help="Optional, output file for converted configuration in Lua script. If not specified, converted configuration is printed.",
default=None,
)
-
return convert, ConvertCommand
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return get_subparsers_words(parser._actions) # noqa: SLF001
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None:
with open(self.input_file, "r") as f:
from pathlib import Path
from typing import List, Optional, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.utils import which
from knot_resolver.utils.requests import request
"debug",
help="Run GDB on the manager's subprocesses",
)
- debug.add_argument(
- "proc_type",
- help="Optional, the type of process to debug. May be 'kresd' (default), 'gc', or 'all'.",
- type=str,
- nargs="?",
- default="kresd",
- )
debug.add_argument(
"--sudo",
dest="sudo",
action="store_true",
default=False,
)
+ debug.add_argument(
+ "proc_type",
+ help="Optional, the type of process to debug. May be 'kresd', 'gc', or 'all'.",
+ choices=["kresd", "gc", "all"],
+ type=str,
+ nargs="?",
+ default="kresd",
+ )
return debug, DebugCommand
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return {}
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None: # noqa: PLR0912, PLR0915
if self.gdb is None:
import argparse
from typing import List, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
@register_command
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return {}
+ return comp_get_words(args, parser._actions) # noqa: SLF001
@staticmethod
def register_args_subparser(
import sys
from typing import List, Optional, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, get_subparsers_words, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.utils.modeling.parsing import DataFormat, parse_json
from knot_resolver.utils.requests import request
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return get_subparsers_words(parser._actions) # noqa: SLF001
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None:
response = request(args.socket, "GET", "metrics/prometheus" if self.prometheus else "metrics/json")
import sys
from typing import List, Optional, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, get_subparsers_words, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.datamodel import kres_config_json_schema
from knot_resolver.utils.requests import request
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return get_subparsers_words(parser._actions) # noqa: SLF001
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None:
if self.live:
from pathlib import Path
from typing import List, Tuple, Type
-from knot_resolver.client.command import Command, CommandArgs, CompWords, get_subparsers_words, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, comp_get_words, register_command
from knot_resolver.datamodel import KresConfig
from knot_resolver.datamodel.globals import Context, reset_global_validation_context, set_global_validation_context
from knot_resolver.utils.modeling import try_to_parse
@staticmethod
def completion(args: List[str], parser: argparse.ArgumentParser) -> CompWords:
- return get_subparsers_words(parser._actions) # noqa: SLF001
+ return comp_get_words(args, parser._actions) # noqa: SLF001
def run(self, args: CommandArgs) -> None:
if self.input_file:
-#/usr/bin/env bash
+#!/usr/bin/env bash
_kresctl_completion()
{
COMPREPLY=()
+ local args=""
local words=""
- local space_arg=""
local cur="${COMP_WORDS[COMP_CWORD]}"
+ local opts=$(kresctl completion --bash --args "${COMP_WORDS[@]:1}")
- # if the current word is empty
- # we need to inform the kresctl client about it
- if [[ -z "$cur" ]]; then
- space_arg="--space"
+ # filter special opts
+ for opt in $opts
+ do
+ if [[ "$opt" == "#dirnames#" ]]; then
+ args="$args${args:+ }-d"
+ elif [[ "$opt" == "#filenames#" ]]; then
+ args="$args${args:+ }-f"
+ else
+ words="$words${words:+ }$opt"
fi
+ done
- # get words from the kresctl client
- words=$(kresctl completion --bash ${space_arg} --args "${COMP_WORDS[@]:1}")
-
- COMPREPLY=($(compgen -W "${words}" -- "${cur}"))
-
+ COMPREPLY=($(compgen $args -W "${words}" -- "${cur}"))
return 0
}
-complete -o filenames -o dirnames -o nosort -F _kresctl_completion kresctl
+complete -o nosort -F _kresctl_completion kresctl
projects / thirdparty / knot-resolver.git / commitdiff
