.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2and3/click/core.pyi

   1 from contextlib import contextmanager\r
   2 from typing import (\r
   3     Any,\r
   4     Callable,\r
   5     Dict,\r
   6     Generator,\r
   7     Iterable,\r
   8     List,\r
   9     Mapping,\r
  10     Optional,\r
  11     Sequence,\r
  12     Set,\r
  13     Tuple,\r
  14     TypeVar,\r
  15     Union,\r
  16 )\r
  17 \r
  18 from click.formatting import HelpFormatter\r
  19 from click.parser import OptionParser\r
  20 \r
  21 def invoke_param_callback(\r
  22     callback: Callable[['Context', 'Parameter', Optional[str]], Any],\r
  23     ctx: 'Context',\r
  24     param: 'Parameter',\r
  25     value: Optional[str]\r
  26 ) -> Any:\r
  27     ...\r
  28 \r
  29 \r
  30 @contextmanager\r
  31 def augment_usage_errors(\r
  32     ctx: 'Context', param: Optional['Parameter'] = ...\r
  33 ) -> Generator[None, None, None]:\r
  34     ...\r
  35 \r
  36 \r
  37 def iter_params_for_processing(\r
  38     invocation_order: Sequence['Parameter'],\r
  39     declaration_order: Iterable['Parameter'],\r
  40 ) -> Iterable['Parameter']:\r
  41     ...\r
  42 \r
  43 \r
  44 class Context:\r
  45     parent: Optional['Context']\r
  46     command: 'Command'\r
  47     info_name: Optional[str]\r
  48     params: Dict\r
  49     args: List[str]\r
  50     protected_args: List[str]\r
  51     obj: Any\r
  52     default_map: Mapping[str, Any]\r
  53     invoked_subcommand: Optional[str]\r
  54     terminal_width: Optional[int]\r
  55     max_content_width: Optional[int]\r
  56     allow_extra_args: bool\r
  57     allow_interspersed_args: bool\r
  58     ignore_unknown_options: bool\r
  59     help_option_names: List[str]\r
  60     token_normalize_func: Optional[Callable[[str], str]]\r
  61     resilient_parsing: bool\r
  62     auto_envvar_prefix: Optional[str]\r
  63     color: Optional[bool]\r
  64     _meta: Dict[str, Any]\r
  65     _close_callbacks: List\r
  66     _depth: int\r
  67 \r
  68     # properties\r
  69     meta: Dict[str, Any]\r
  70     command_path: str\r
  71 \r
  72     def __init__(\r
  73         self,\r
  74         command: 'Command',\r
  75         parent: Optional['Context'] = ...,\r
  76         info_name: Optional[str] = ...,\r
  77         obj: Optional[Any] = ...,\r
  78         auto_envvar_prefix: Optional[str] = ...,\r
  79         default_map: Optional[Mapping[str, Any]] = ...,\r
  80         terminal_width: Optional[int] = ...,\r
  81         max_content_width: Optional[int] = ...,\r
  82         resilient_parsing: bool = ...,\r
  83         allow_extra_args: Optional[bool] = ...,\r
  84         allow_interspersed_args: Optional[bool] = ...,\r
  85         ignore_unknown_options: Optional[bool] = ...,\r
  86         help_option_names: Optional[List[str]] = ...,\r
  87         token_normalize_func: Optional[Callable[[str], str]] = ...,\r
  88         color: Optional[bool] = ...\r
  89     ) -> None:\r
  90         ...\r
  91 \r
  92     @contextmanager\r
  93     def scope(self, cleanup: bool = ...) -> Generator['Context', None, None]:\r
  94         ...\r
  95 \r
  96     def make_formatter(self) -> HelpFormatter:\r
  97         ...\r
  98 \r
  99     def call_on_close(self, f: Callable) -> Callable:\r
 100         ...\r
 101 \r
 102     def close(self) -> None:\r
 103         ...\r
 104 \r
 105     def find_root(self) -> 'Context':\r
 106         ...\r
 107 \r
 108     def find_object(self, object_type: type) -> Any:\r
 109         ...\r
 110 \r
 111     def ensure_object(self, object_type: type) -> Any:\r
 112         ...\r
 113 \r
 114     def lookup_default(self, name: str) -> Any:\r
 115         ...\r
 116 \r
 117     def fail(self, message: str) -> None:\r
 118         ...\r
 119 \r
 120     def abort(self) -> None:\r
 121         ...\r
 122 \r
 123     def exit(self, code: Union[int, str] = ...) -> None:\r
 124         ...\r
 125 \r
 126     def get_usage(self) -> str:\r
 127         ...\r
 128 \r
 129     def get_help(self) -> str:\r
 130         ...\r
 131 \r
 132     def invoke(\r
 133         self, callback: Union['Command', Callable], *args, **kwargs\r
 134     ) -> Any:\r
 135         ...\r
 136 \r
 137     def forward(\r
 138         self, callback: Union['Command', Callable], *args, **kwargs\r
 139     ) -> Any:\r
 140         ...\r
 141 \r
 142 class BaseCommand:\r
 143     allow_extra_args: bool\r
 144     allow_interspersed_args: bool\r
 145     ignore_unknown_options: bool\r
 146     name: str\r
 147     context_settings: Dict\r
 148 \r
 149     def __init__(self, name: str, context_settings: Optional[Dict] = ...) -> None:\r
 150         ...\r
 151 \r
 152     def get_usage(self, ctx: Context) -> str:\r
 153         ...\r
 154 \r
 155     def get_help(self, ctx: Context) -> str:\r
 156         ...\r
 157 \r
 158     def make_context(\r
 159         self, info_name: str, args: List[str], parent: Optional[Context] = ..., **extra\r
 160     ) -> Context:\r
 161         ...\r
 162 \r
 163     def parse_args(self, ctx: Context, args: List[str]) -> List[str]:\r
 164         ...\r
 165 \r
 166     def invoke(self, ctx: Context) -> Any:\r
 167         ...\r
 168 \r
 169     def main(\r
 170         self,\r
 171         args: Optional[List[str]] = ...,\r
 172         prog_name: Optional[str] = ...,\r
 173         complete_var: Optional[str] = ...,\r
 174         standalone_mode: bool = ...,\r
 175         **extra\r
 176     ) -> Any:\r
 177         ...\r
 178 \r
 179     def __call__(self, *args, **kwargs) -> Any:\r
 180         ...\r
 181 \r
 182 \r
 183 class Command(BaseCommand):\r
 184     callback: Optional[Callable]\r
 185     params: List['Parameter']\r
 186     help: Optional[str]\r
 187     epilog: Optional[str]\r
 188     short_help: Optional[str]\r
 189     options_metavar: str\r
 190     add_help_option: bool\r
 191 \r
 192     def __init__(\r
 193         self,\r
 194         name: str,\r
 195         context_settings: Optional[Dict] = ...,\r
 196         callback: Optional[Callable] = ...,\r
 197         params: Optional[List['Parameter']] = ...,\r
 198         help: Optional[str] = ...,\r
 199         epilog: Optional[str] = ...,\r
 200         short_help: Optional[str] = ...,\r
 201         options_metavar: str = ...,\r
 202         add_help_option: bool = ...\r
 203     ) -> None:\r
 204         ...\r
 205 \r
 206     def get_params(self, ctx: Context) -> List['Parameter']:\r
 207         ...\r
 208 \r
 209     def format_usage(\r
 210         self,\r
 211         ctx: Context,\r
 212         formatter: HelpFormatter\r
 213     ) -> None:\r
 214         ...\r
 215 \r
 216     def collect_usage_pieces(self, ctx: Context) -> List[str]:\r
 217         ...\r
 218 \r
 219     def get_help_option_names(self, ctx: Context) -> Set[str]:\r
 220         ...\r
 221 \r
 222     def get_help_option(self, ctx: Context) -> Optional['Option']:\r
 223         ...\r
 224 \r
 225     def make_parser(self, ctx: Context) -> OptionParser:\r
 226         ...\r
 227 \r
 228     def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:\r
 229         ...\r
 230 \r
 231     def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:\r
 232         ...\r
 233 \r
 234     def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:\r
 235         ...\r
 236 \r
 237     def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:\r
 238         ...\r
 239 \r
 240 \r
 241 _T = TypeVar('_T')\r
 242 _Decorator = Callable[[_T], _T]\r
 243 \r
 244 \r
 245 class MultiCommand(Command):\r
 246     no_args_is_help: bool\r
 247     invoke_without_command: bool\r
 248     subcommand_metavar: str\r
 249     chain: bool\r
 250     result_callback: Callable\r
 251 \r
 252     def __init__(\r
 253         self,\r
 254         name: Optional[str] = ...,\r
 255         invoke_without_command: bool = ...,\r
 256         no_args_is_help: Optional[bool] = ...,\r
 257         subcommand_metavar: Optional[str] = ...,\r
 258         chain: bool = ...,\r
 259         result_callback: Optional[Callable] = ...,\r
 260         **attrs\r
 261     ) -> None:\r
 262         ...\r
 263 \r
 264     def resultcallback(\r
 265         self, replace: bool = ...\r
 266     ) -> _Decorator:\r
 267         ...\r
 268 \r
 269     def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:\r
 270         ...\r
 271 \r
 272     def resolve_command(\r
 273         self, ctx: Context, args: List[str]\r
 274     ) -> Tuple[str, Command, List[str]]:\r
 275         ...\r
 276 \r
 277     def get_command(self, ctx: Context, cmd_name: str) -> Optional[Command]:\r
 278         ...\r
 279 \r
 280     def list_commands(self, ctx: Context) -> Iterable[Command]:\r
 281         ...\r
 282 \r
 283 \r
 284 class Group(MultiCommand):\r
 285     commands: Dict[str, Command]\r
 286 \r
 287     def __init__(\r
 288         self, name: Optional[str] = ..., commands: Optional[Dict[str, Command]] = ..., **attrs\r
 289     ) -> None:\r
 290         ...\r
 291 \r
 292     def add_command(self, cmd: Command, name: Optional[str] = ...):\r
 293         ...\r
 294 \r
 295     def command(self, *args, **kwargs) -> _Decorator:\r
 296         ...\r
 297 \r
 298     def group(self, *args, **kwargs) -> _Decorator:\r
 299         ...\r
 300 \r
 301 \r
 302 class CommandCollection(MultiCommand):\r
 303     sources: List[MultiCommand]\r
 304 \r
 305     def __init__(\r
 306         self, name: Optional[str] = ..., sources: Optional[List[MultiCommand]] = ..., **attrs\r
 307     ) -> None:\r
 308         ...\r
 309 \r
 310     def add_source(self, multi_cmd: MultiCommand) -> None:\r
 311         ...\r
 312 \r
 313 \r
 314 class _ParamType:\r
 315     name: str\r
 316     is_composite: bool\r
 317     envvar_list_splitter: Optional[str]\r
 318 \r
 319     def __call__(\r
 320         self,\r
 321         value: Optional[str],\r
 322         param: Optional[Parameter] = ...,\r
 323         ctx: Optional[Context] = ...,\r
 324     ) -> Any:\r
 325         ...\r
 326 \r
 327     def get_metavar(self, param: Parameter) -> str:\r
 328         ...\r
 329 \r
 330     def get_missing_message(self, param: Parameter) -> str:\r
 331         ...\r
 332 \r
 333     def convert(\r
 334         self,\r
 335         value: str,\r
 336         param: Optional[Parameter],\r
 337         ctx: Optional[Context],\r
 338     ) -> Any:\r
 339         ...\r
 340 \r
 341     def split_envvar_value(self, rv: str) -> List[str]:\r
 342         ...\r
 343 \r
 344     def fail(self, message: str, param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> None:\r
 345         ...\r
 346 \r
 347 \r
 348 # This type is here to resolve https://github.com/python/mypy/issues/5275\r
 349 _ConvertibleType = Union[type, _ParamType, Tuple[type, ...], Callable[[str], Any], Callable[[Optional[str]], Any]]\r
 350 \r
 351 \r
 352 class Parameter:\r
 353     param_type_name: str\r
 354     name: str\r
 355     opts: List[str]\r
 356     secondary_opts: List[str]\r
 357     type: _ParamType\r
 358     required: bool\r
 359     callback: Optional[Callable[[Context, 'Parameter', str], Any]]\r
 360     nargs: int\r
 361     multiple: bool\r
 362     expose_value: bool\r
 363     default: Any\r
 364     is_eager: bool\r
 365     metavar: Optional[str]\r
 366     envvar: Union[str, List[str], None]\r
 367     # properties\r
 368     human_readable_name: str\r
 369 \r
 370     def __init__(\r
 371         self,\r
 372         param_decls: Optional[List[str]] = ...,\r
 373         type: Optional[_ConvertibleType] = ...,\r
 374         required: bool = ...,\r
 375         default: Optional[Any] = ...,\r
 376         callback: Optional[Callable[[Context, 'Parameter', str], Any]] = ...,\r
 377         nargs: Optional[int] = ...,\r
 378         metavar: Optional[str] = ...,\r
 379         expose_value: bool = ...,\r
 380         is_eager: bool = ...,\r
 381         envvar: Optional[Union[str, List[str]]] = ...\r
 382     ) -> None:\r
 383         ...\r
 384 \r
 385     def make_metavar(self) -> str:\r
 386         ...\r
 387 \r
 388     def get_default(self, ctx: Context) -> Any:\r
 389         ...\r
 390 \r
 391     def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:\r
 392         ...\r
 393 \r
 394     def consume_value(self, ctx: Context, opts: Dict[str, Any]) -> Any:\r
 395         ...\r
 396 \r
 397     def type_cast_value(self, ctx: Context, value: Any) -> Any:\r
 398         ...\r
 399 \r
 400     def process_value(self, ctx: Context, value: Any) -> Any:\r
 401         ...\r
 402 \r
 403     def value_is_missing(self, value: Any) -> bool:\r
 404         ...\r
 405 \r
 406     def full_process_value(self, ctx: Context, value: Any) -> Any:\r
 407         ...\r
 408 \r
 409     def resolve_envvar_value(self, ctx: Context) -> str:\r
 410         ...\r
 411 \r
 412     def value_from_envvar(self, ctx: Context) -> Union[str, List[str]]:\r
 413         ...\r
 414 \r
 415     def handle_parse_result(\r
 416         self, ctx: Context, opts: Dict[str, Any], args: List[str]\r
 417     ) -> Tuple[Any, List[str]]:\r
 418         ...\r
 419 \r
 420     def get_help_record(self, ctx: Context) -> Tuple[str, str]:\r
 421         ...\r
 422 \r
 423     def get_usage_pieces(self, ctx: Context) -> List[str]:\r
 424         ...\r
 425 \r
 426 \r
 427 class Option(Parameter):\r
 428     prompt: str  # sic\r
 429     confirmation_prompt: bool\r
 430     hide_input: bool\r
 431     is_flag: bool\r
 432     flag_value: Any\r
 433     is_bool_flag: bool\r
 434     count: bool\r
 435     multiple: bool\r
 436     allow_from_autoenv: bool\r
 437     help: Optional[str]\r
 438     show_default: bool\r
 439 \r
 440     def __init__(\r
 441         self,\r
 442         param_decls: Optional[List[str]] = ...,\r
 443         show_default: bool = ...,\r
 444         prompt: Union[bool, str] = ...,\r
 445         confirmation_prompt: bool = ...,\r
 446         hide_input: bool = ...,\r
 447         is_flag: Optional[bool] = ...,\r
 448         flag_value: Optional[Any] = ...,\r
 449         multiple: bool = ...,\r
 450         count: bool = ...,\r
 451         allow_from_autoenv: bool = ...,\r
 452         type: Optional[_ConvertibleType] = ...,\r
 453         help: Optional[str] = ...,\r
 454         **attrs\r
 455     ) -> None:\r
 456         ...\r
 457 \r
 458     def prompt_for_value(self, ctx: Context) -> Any:\r
 459         ...\r
 460 \r
 461 \r
 462 class Argument(Parameter):\r
 463     def __init__(\r
 464         self,\r
 465         param_decls: Optional[List[str]] = ...,\r
 466         required: Optional[bool] = ...,\r
 467         **attrs\r
 468     ) -> None:\r
 469         ...\r