.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/stdlib/2and3/argparse.pyi

   1 # Stubs for argparse (Python 2.7 and 3.4)\r
   2 \r
   3 from typing import (\r
   4     Any, Callable, Dict, Generator, Iterable, List, IO, NoReturn, Optional,\r
   5     Pattern, Sequence, Tuple, Type, Union, TypeVar, overload\r
   6 )\r
   7 import sys\r
   8 \r
   9 _T = TypeVar('_T')\r
  10 _ActionT = TypeVar('_ActionT', bound='Action')\r
  11 \r
  12 if sys.version_info >= (3,):\r
  13     _Text = str\r
  14 else:\r
  15     _Text = Union[str, unicode]\r
  16 \r
  17 ONE_OR_MORE: str\r
  18 OPTIONAL: str\r
  19 PARSER: str\r
  20 REMAINDER: str\r
  21 SUPPRESS: str\r
  22 ZERO_OR_MORE: str\r
  23 _UNRECOGNIZED_ARGS_ATTR: str  # undocumented\r
  24 \r
  25 class ArgumentError(Exception): ...\r
  26 \r
  27 # undocumented\r
  28 class _AttributeHolder:\r
  29     def _get_kwargs(self) -> List[Tuple[str, Any]]: ...\r
  30     def _get_args(self) -> List[Any]: ...\r
  31 \r
  32 # undocumented\r
  33 class _ActionsContainer:\r
  34     description: Optional[_Text]\r
  35     prefix_chars: _Text\r
  36     argument_default: Optional[_Text]\r
  37     conflict_handler: _Text\r
  38 \r
  39     _registries: Dict[_Text, Dict[Any, Any]]\r
  40     _actions: List[Action]\r
  41     _option_string_actions: Dict[_Text, Action]\r
  42     _action_groups: List[_ArgumentGroup]\r
  43     _mutually_exclusive_groups: List[_MutuallyExclusiveGroup]\r
  44     _defaults: Dict[str, Any]\r
  45     _negative_number_matcher: Pattern[str]\r
  46     _has_negative_number_optionals: List[bool]\r
  47 \r
  48     def __init__(self, description: Optional[_Text], prefix_chars: _Text,\r
  49                  argument_default: Optional[_Text], conflict_handler: _Text) -> None: ...\r
  50     def register(self, registry_name: _Text, value: Any, object: Any) -> None: ...\r
  51     def _registry_get(self, registry_name: _Text, value: Any, default: Any = ...) -> Any: ...\r
  52     def set_defaults(self, **kwargs: Any) -> None: ...\r
  53     def get_default(self, dest: _Text) -> Any: ...\r
  54     def add_argument(self,\r
  55                      *name_or_flags: _Text,\r
  56                      action: Union[_Text, Type[Action]] = ...,\r
  57                      nargs: Union[int, _Text] = ...,\r
  58                      const: Any = ...,\r
  59                      default: Any = ...,\r
  60                      type: Union[Callable[[str], _T], FileType] = ...,\r
  61                      choices: Iterable[_T] = ...,\r
  62                      required: bool = ...,\r
  63                      help: Optional[_Text] = ...,\r
  64                      metavar: Union[_Text, Tuple[_Text, ...]] = ...,\r
  65                      dest: Optional[_Text] = ...,\r
  66                      version: _Text = ...) -> Action: ...\r
  67     def add_argument_group(self, *args: Any, **kwargs: Any) -> _ArgumentGroup: ...\r
  68     def add_mutually_exclusive_group(self, **kwargs: Any) -> _MutuallyExclusiveGroup: ...\r
  69     def _add_action(self, action: _ActionT) -> _ActionT: ...\r
  70     def _remove_action(self, action: Action) -> None: ...\r
  71     def _add_container_actions(self, container: _ActionsContainer) -> None: ...\r
  72     def _get_positional_kwargs(self, dest: _Text, **kwargs: Any) -> Dict[str, Any]: ...\r
  73     def _get_optional_kwargs(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: ...\r
  74     def _pop_action_class(self, kwargs: Any, default: Optional[Type[Action]] = ...) -> Type[Action]: ...\r
  75     def _get_handler(self) -> Callable[[Action, Iterable[Tuple[_Text, Action]]], Any]: ...\r
  76     def _check_conflict(self, action: Action) -> None: ...\r
  77     def _handle_conflict_error(self, action: Action, conflicting_actions: Iterable[Tuple[_Text, Action]]) -> NoReturn: ...\r
  78     def _handle_conflict_resolve(self, action: Action, conflicting_actions: Iterable[Tuple[_Text, Action]]) -> None: ...\r
  79 \r
  80 class ArgumentParser(_AttributeHolder, _ActionsContainer):\r
  81     prog: _Text\r
  82     usage: Optional[_Text]\r
  83     epilog: Optional[_Text]\r
  84     formatter_class: Type[HelpFormatter]\r
  85     fromfile_prefix_chars: Optional[_Text]\r
  86     add_help: bool\r
  87 \r
  88     if sys.version_info >= (3, 5):\r
  89         allow_abbrev: bool\r
  90 \r
  91     # undocumented\r
  92     _positionals: _ArgumentGroup\r
  93     _optionals: _ArgumentGroup\r
  94     _subparsers: Optional[_ArgumentGroup]\r
  95 \r
  96     if sys.version_info >= (3, 5):\r
  97         def __init__(self,\r
  98                      prog: Optional[str] = ...,\r
  99                      usage: Optional[str] = ...,\r
 100                      description: Optional[str] = ...,\r
 101                      epilog: Optional[str] = ...,\r
 102                      parents: Sequence[ArgumentParser] = ...,\r
 103                      formatter_class: Type[HelpFormatter] = ...,\r
 104                      prefix_chars: _Text = ...,\r
 105                      fromfile_prefix_chars: Optional[str] = ...,\r
 106                      argument_default: Optional[str] = ...,\r
 107                      conflict_handler: _Text = ...,\r
 108                      add_help: bool = ...,\r
 109                      allow_abbrev: bool = ...) -> None: ...\r
 110     else:\r
 111         def __init__(self,\r
 112                      prog: Optional[_Text] = ...,\r
 113                      usage: Optional[_Text] = ...,\r
 114                      description: Optional[_Text] = ...,\r
 115                      epilog: Optional[_Text] = ...,\r
 116                      parents: Sequence[ArgumentParser] = ...,\r
 117                      formatter_class: Type[HelpFormatter] = ...,\r
 118                      prefix_chars: _Text = ...,\r
 119                      fromfile_prefix_chars: Optional[_Text] = ...,\r
 120                      argument_default: Optional[_Text] = ...,\r
 121                      conflict_handler: _Text = ...,\r
 122                      add_help: bool = ...) -> None: ...\r
 123     def parse_args(self, args: Optional[Sequence[_Text]] = ...,\r
 124                    namespace: Optional[Namespace] = ...) -> Namespace: ...\r
 125     def add_subparsers(self, title: _Text = ...,\r
 126                        description: Optional[_Text] = ...,\r
 127                        prog: _Text = ...,\r
 128                        parser_class: Type[ArgumentParser] = ...,\r
 129                        action: Type[Action] = ...,\r
 130                        option_string: _Text = ...,\r
 131                        dest: Optional[_Text] = ...,\r
 132                        help: Optional[_Text] = ...,\r
 133                        metavar: Optional[_Text] = ...) -> _SubParsersAction: ...\r
 134     def print_usage(self, file: Optional[IO[str]] = ...) -> None: ...\r
 135     def print_help(self, file: Optional[IO[str]] = ...) -> None: ...\r
 136     def format_usage(self) -> str: ...\r
 137     def format_help(self) -> str: ...\r
 138     def parse_known_args(self, args: Optional[Sequence[_Text]] = ...,\r
 139                          namespace: Optional[Namespace] = ...) -> Tuple[Namespace, List[str]]: ...\r
 140     def convert_arg_line_to_args(self, arg_line: _Text) -> List[str]: ...\r
 141     def exit(self, status: int = ..., message: Optional[_Text] = ...) -> NoReturn: ...\r
 142     def error(self, message: _Text) -> NoReturn: ...\r
 143     if sys.version_info >= (3, 7):\r
 144         def parse_intermixed_args(self, args: Optional[Sequence[_Text]] = ...,\r
 145                                   namespace: Optional[Namespace] = ...) -> Namespace: ...\r
 146         def parse_known_intermixed_args(self,\r
 147                                         args: Optional[Sequence[_Text]] = ...,\r
 148                                         namespace: Optional[Namespace] = ...) -> Tuple[Namespace, List[str]]: ...\r
 149     # undocumented\r
 150     def _get_optional_actions(self) -> List[Action]: ...\r
 151     def _get_positional_actions(self) -> List[Action]: ...\r
 152     def _parse_known_args(self, arg_strings: List[_Text], namespace: Namespace) -> Tuple[Namespace, List[str]]: ...\r
 153     def _read_args_from_files(self, arg_strings: List[_Text]) -> List[_Text]: ...\r
 154     def _match_argument(self, action: Action, arg_strings_pattern: _Text) -> int: ...\r
 155     def _match_arguments_partial(self, actions: Sequence[Action], arg_strings_pattern: _Text) -> List[int]: ...\r
 156     def _parse_optional(self, arg_string: _Text) -> Optional[Tuple[Optional[Action], _Text, Optional[_Text]]]: ...\r
 157     def _get_option_tuples(self, option_string: _Text) -> List[Tuple[Action, _Text, Optional[_Text]]]: ...\r
 158     def _get_nargs_pattern(self, action: Action) -> _Text: ...\r
 159     def _get_values(self, action: Action, arg_strings: List[_Text]) -> Any: ...\r
 160     def _get_value(self, action: Action, arg_string: _Text) -> Any: ...\r
 161     def _check_value(self, action: Action, value: Any) -> None: ...\r
 162     def _get_formatter(self) -> HelpFormatter: ...\r
 163     def _print_message(self, message: str, file: Optional[IO[str]] = ...) -> None: ...\r
 164 \r
 165 class HelpFormatter:\r
 166     # undocumented\r
 167     _prog: _Text\r
 168     _indent_increment: int\r
 169     _max_help_position: int\r
 170     _width: int\r
 171     _current_indent: int\r
 172     _level: int\r
 173     _action_max_length: int\r
 174     _root_section: Any\r
 175     _current_section: Any\r
 176     _whitespace_matcher: Pattern[str]\r
 177     _long_break_matcher: Pattern[str]\r
 178     _Section: Type[Any]  # Nested class\r
 179     def __init__(self, prog: _Text, indent_increment: int = ...,\r
 180                  max_help_position: int = ...,\r
 181                  width: Optional[int] = ...) -> None: ...\r
 182     def _indent(self) -> None: ...\r
 183     def _dedent(self) -> None: ...\r
 184     def _add_item(self, func: Callable[..., _Text], args: Iterable[Any]) -> None: ...\r
 185     def start_section(self, heading: Optional[_Text]) -> None: ...\r
 186     def end_section(self) -> None: ...\r
 187     def add_text(self, text: Optional[_Text]) -> None: ...\r
 188     def add_usage(self, usage: _Text, actions: Iterable[Action], groups: Iterable[_ArgumentGroup], prefix: Optional[_Text] = ...) -> None: ...\r
 189     def add_argument(self, action: Action) -> None: ...\r
 190     def add_arguments(self, actions: Iterable[Action]) -> None: ...\r
 191     def format_help(self) -> _Text: ...\r
 192     def _join_parts(self, part_strings: Iterable[_Text]) -> _Text: ...\r
 193     def _format_usage(self, usage: _Text, actions: Iterable[Action], groups: Iterable[_ArgumentGroup], prefix: Optional[_Text]) -> _Text: ...\r
 194     def _format_actions_usage(self, actions: Iterable[Action], groups: Iterable[_ArgumentGroup]) -> _Text: ...\r
 195     def _format_text(self, text: _Text) -> _Text: ...\r
 196     def _format_action(self, action: Action) -> _Text: ...\r
 197     def _format_action_invocation(self, action: Action) -> _Text: ...\r
 198     def _metavar_formatter(self, action: Action, default_metavar: _Text) -> Callable[[int], Tuple[_Text, ...]]: ...\r
 199     def _format_args(self, action: Action, default_metavar: _Text) -> _Text: ...\r
 200     def _expand_help(self, action: Action) -> _Text: ...\r
 201     def _iter_indented_subactions(self, action: Action) -> Generator[Action, None, None]: ...\r
 202     def _split_lines(self, text: _Text, width: int) -> List[_Text]: ...\r
 203     def _fill_text(self, text: _Text, width: int, indent: int) -> _Text: ...\r
 204     def _get_help_string(self, action: Action) -> Optional[_Text]: ...\r
 205     def _get_default_metavar_for_optional(self, action: Action) -> _Text: ...\r
 206     def _get_default_metavar_for_positional(self, action: Action) -> _Text: ...\r
 207 \r
 208 class RawDescriptionHelpFormatter(HelpFormatter): ...\r
 209 class RawTextHelpFormatter(HelpFormatter): ...\r
 210 class ArgumentDefaultsHelpFormatter(HelpFormatter): ...\r
 211 if sys.version_info >= (3,):\r
 212     class MetavarTypeHelpFormatter(HelpFormatter): ...\r
 213 \r
 214 class Action(_AttributeHolder):\r
 215     option_strings: Sequence[_Text]\r
 216     dest: _Text\r
 217     nargs: Optional[Union[int, _Text]]\r
 218     const: Any\r
 219     default: Any\r
 220     type: Union[Callable[[str], Any], FileType, None]\r
 221     choices: Optional[Iterable[Any]]\r
 222     required: bool\r
 223     help: Optional[_Text]\r
 224     metavar: Union[_Text, Tuple[_Text, ...]]\r
 225 \r
 226     def __init__(self,\r
 227                  option_strings: Sequence[_Text],\r
 228                  dest: _Text,\r
 229                  nargs: Optional[Union[int, _Text]] = ...,\r
 230                  const: Any = ...,\r
 231                  default: Any = ...,\r
 232                  type: Optional[Union[Callable[[str], _T], FileType]] = ...,\r
 233                  choices: Optional[Iterable[_T]] = ...,\r
 234                  required: bool = ...,\r
 235                  help: Optional[_Text] = ...,\r
 236                  metavar: Optional[Union[_Text, Tuple[_Text, ...]]] = ...) -> None: ...\r
 237     def __call__(self, parser: ArgumentParser, namespace: Namespace,\r
 238                  values: Union[_Text, Sequence[Any], None],\r
 239                  option_string: Optional[_Text] = ...) -> None: ...\r
 240 \r
 241 class Namespace(_AttributeHolder):\r
 242     def __init__(self, **kwargs: Any) -> None: ...\r
 243     def __getattr__(self, name: _Text) -> Any: ...\r
 244     def __setattr__(self, name: _Text, value: Any) -> None: ...\r
 245     def __contains__(self, key: str) -> bool: ...\r
 246 \r
 247 class FileType:\r
 248     # undocumented\r
 249     _mode: _Text\r
 250     _bufsize: int\r
 251     if sys.version_info >= (3, 4):\r
 252         _encoding: Optional[_Text]\r
 253         _errors: Optional[_Text]\r
 254     if sys.version_info >= (3, 4):\r
 255         def __init__(self, mode: _Text = ..., bufsize: int = ...,\r
 256                      encoding: Optional[_Text] = ...,\r
 257                      errors: Optional[_Text] = ...) -> None: ...\r
 258     elif sys.version_info >= (3,):\r
 259         def __init__(self,\r
 260                      mode: _Text = ..., bufsize: int = ...) -> None: ...\r
 261     else:\r
 262         def __init__(self,\r
 263                      mode: _Text = ..., bufsize: Optional[int] = ...) -> None: ...\r
 264     def __call__(self, string: _Text) -> IO[Any]: ...\r
 265 \r
 266 # undocumented\r
 267 class _ArgumentGroup(_ActionsContainer):\r
 268     title: Optional[_Text]\r
 269     _group_actions: List[Action]\r
 270     def __init__(self, container: _ActionsContainer,\r
 271                  title: Optional[_Text] = ...,\r
 272                  description: Optional[_Text] = ..., **kwargs: Any) -> None: ...\r
 273 \r
 274 # undocumented\r
 275 class _MutuallyExclusiveGroup(_ArgumentGroup):\r
 276     required: bool\r
 277     _container: _ActionsContainer\r
 278     def __init__(self, container: _ActionsContainer, required: bool = ...) -> None: ...\r
 279 \r
 280 # undocumented\r
 281 class _StoreAction(Action): ...\r
 282 \r
 283 # undocumented\r
 284 class _StoreConstAction(Action):\r
 285     def __init__(self,\r
 286                  option_strings: Sequence[_Text],\r
 287                  dest: _Text,\r
 288                  const: Any,\r
 289                  default: Any = ...,\r
 290                  required: bool = ...,\r
 291                  help: Optional[_Text] = ...,\r
 292                  metavar: Optional[Union[_Text, Tuple[_Text, ...]]] = ...) -> None: ...\r
 293 \r
 294 # undocumented\r
 295 class _StoreTrueAction(_StoreConstAction):\r
 296     def __init__(self,\r
 297                  option_strings: Sequence[_Text],\r
 298                  dest: _Text,\r
 299                  default: bool = ...,\r
 300                  required: bool = ...,\r
 301                  help: Optional[_Text] = ...) -> None: ...\r
 302 \r
 303 # undocumented\r
 304 class _StoreFalseAction(_StoreConstAction):\r
 305     def __init__(self,\r
 306                  option_strings: Sequence[_Text],\r
 307                  dest: _Text,\r
 308                  default: bool = ...,\r
 309                  required: bool = ...,\r
 310                  help: Optional[_Text] = ...) -> None: ...\r
 311 \r
 312 # undocumented\r
 313 class _AppendAction(Action): ...\r
 314 \r
 315 # undocumented\r
 316 class _AppendConstAction(Action):\r
 317     def __init__(self,\r
 318                  option_strings: Sequence[_Text],\r
 319                  dest: _Text,\r
 320                  const: Any,\r
 321                  default: Any = ...,\r
 322                  required: bool = ...,\r
 323                  help: Optional[_Text] = ...,\r
 324                  metavar: Optional[Union[_Text, Tuple[_Text, ...]]] = ...) -> None: ...\r
 325 \r
 326 # undocumented\r
 327 class _CountAction(Action):\r
 328     def __init__(self,\r
 329                  option_strings: Sequence[_Text],\r
 330                  dest: _Text,\r
 331                  default: Any = ...,\r
 332                  required: bool = ...,\r
 333                  help: Optional[_Text] = ...) -> None: ...\r
 334 \r
 335 # undocumented\r
 336 class _HelpAction(Action):\r
 337     def __init__(self,\r
 338                  option_strings: Sequence[_Text],\r
 339                  dest: _Text = ...,\r
 340                  default: _Text = ...,\r
 341                  help: Optional[_Text] = ...) -> None: ...\r
 342 \r
 343 # undocumented\r
 344 class _VersionAction(Action):\r
 345     version: Optional[_Text]\r
 346     def __init__(self,\r
 347                  option_strings: Sequence[_Text],\r
 348                  version: Optional[_Text] = ...,\r
 349                  dest: _Text = ...,\r
 350                  default: _Text = ...,\r
 351                  help: _Text = ...) -> None: ...\r
 352 \r
 353 # undocumented\r
 354 class _SubParsersAction(Action):\r
 355     _ChoicesPseudoAction: Type[Any]  # nested class\r
 356     _prog_prefix: _Text\r
 357     _parser_class: Type[ArgumentParser]\r
 358     _name_parser_map: Dict[_Text, ArgumentParser]\r
 359     _choices_actions: List[Action]\r
 360     def __init__(self,\r
 361                  option_strings: Sequence[_Text],\r
 362                  prog: _Text,\r
 363                  parser_class: Type[ArgumentParser],\r
 364                  dest: _Text = ...,\r
 365                  required: bool = ...,\r
 366                  help: Optional[_Text] = ...,\r
 367                  metavar: Optional[Union[_Text, Tuple[_Text, ...]]] = ...) -> None: ...\r
 368     # TODO: Type keyword args properly.\r
 369     def add_parser(self, name: _Text, **kwargs: Any) -> ArgumentParser: ...\r
 370     def _get_subactions(self) -> List[Action]: ...\r
 371 \r
 372 # undocumented\r
 373 class ArgumentTypeError(Exception): ...\r
 374 \r
 375 if sys.version_info < (3, 7):\r
 376     # undocumented\r
 377     def _ensure_value(namespace: Namespace, name: _Text, value: Any) -> Any: ...\r
 378 \r
 379 # undocumented\r
 380 def _get_action_name(argument: Optional[Action]) -> Optional[str]: ...\r