Coverage for typer/core.py: 100%
265 statements
« prev ^ index » next coverage.py v7.5.4, created at 2024-06-24 00:17 +0000
1import errno 1hbfaecdg
2import inspect 1hbfaecdg
3import os 1hbfaecdg
4import sys 1hbfaecdg
5from enum import Enum 1hbfaecdg
6from gettext import gettext as _ 1hbfaecdg
7from typing import ( 1hbfaecdg
8 Any,
9 Callable,
10 Dict,
11 List,
12 MutableMapping,
13 Optional,
14 Sequence,
15 TextIO,
16 Tuple,
17 Union,
18 cast,
19)
21import click 1hbfaecdg
22import click.core 1hbfaecdg
23import click.formatting 1hbfaecdg
24import click.parser 1hbfaecdg
25import click.shell_completion 1hbfaecdg
26import click.types 1hbfaecdg
27import click.utils 1hbfaecdg
29if sys.version_info >= (3, 8): 1hbfaecdg
30 from typing import Literal 1bfaecdg
31else:
32 from typing_extensions import Literal 1h
34try: 1hbfaecdg
35 import rich 1hbfaecdg
37 from . import rich_utils 1hbfaecdg
39except ImportError: # pragma: no cover
40 rich = None # type: ignore
42MarkupMode = Literal["markdown", "rich", None] 1hbfaecdg
45# Copy from click.parser._split_opt
46def _split_opt(opt: str) -> Tuple[str, str]: 1hbfaecdg
47 first = opt[:1] 1hbfaecdg
48 if first.isalnum(): 1hbfaecdg
49 return "", opt 1hbfaecdg
50 if opt[1:2] == first: 1hbfaecdg
51 return opt[:2], opt[2:] 1hbfaecdg
52 return first, opt[1:] 1hbfaecdg
55def _typer_param_setup_autocompletion_compat( 1bfaecdg
56 self: click.Parameter,
57 *,
58 autocompletion: Optional[
59 Callable[[click.Context, List[str], str], List[Union[Tuple[str, str], str]]]
60 ] = None,
61) -> None:
62 if autocompletion is not None and self._custom_shell_complete is None: 1hbfaecdg
63 import warnings 1hbfaecdg
65 warnings.warn( 1hbfaecdg
66 "'autocompletion' is renamed to 'shell_complete'. The old name is"
67 " deprecated and will be removed in Click 8.1. See the docs about"
68 " 'Parameter' for information about new behavior.",
69 DeprecationWarning,
70 stacklevel=2,
71 )
73 def compat_autocompletion( 1bfaecdg
74 ctx: click.Context, param: click.core.Parameter, incomplete: str
75 ) -> List["click.shell_completion.CompletionItem"]:
76 from click.shell_completion import CompletionItem 1hbfaecdg
78 out = [] 1hbfaecdg
80 for c in autocompletion(ctx, [], incomplete): 1hbfaecdg
81 if isinstance(c, tuple): 1hbfaecdg
82 use_completion = CompletionItem(c[0], help=c[1]) 1hbfaecdg
83 else:
84 assert isinstance(c, str) 1hbfaecdg
85 use_completion = CompletionItem(c) 1hbfaecdg
87 if use_completion.value.startswith(incomplete): 1hbfaecdg
88 out.append(use_completion) 1hbfaecdg
90 return out 1hbfaecdg
92 self._custom_shell_complete = compat_autocompletion 1hbfaecdg
95def _get_default_string( 1bfaecdg
96 obj: Union["TyperArgument", "TyperOption"],
97 *,
98 ctx: click.Context,
99 show_default_is_str: bool,
100 default_value: Union[List[Any], Tuple[Any, ...], str, Callable[..., Any], Any],
101) -> str:
102 # Extracted from click.core.Option.get_help_record() to be reused by
103 # rich_utils avoiding RegEx hacks
104 if show_default_is_str: 1hbfaecdg
105 default_string = f"({obj.show_default})" 1hbfaecdg
106 elif isinstance(default_value, (list, tuple)): 1hbfaecdg
107 default_string = ", ".join( 1hbfaecdg
108 _get_default_string(
109 obj, ctx=ctx, show_default_is_str=show_default_is_str, default_value=d
110 )
111 for d in default_value
112 )
113 elif isinstance(default_value, Enum): 1hbfaecdg
114 default_string = str(default_value.value) 1hbfaecdg
115 elif inspect.isfunction(default_value): 1hbfaecdg
116 default_string = _("(dynamic)") 1hbfaecdg
117 elif isinstance(obj, TyperOption) and obj.is_bool_flag and obj.secondary_opts: 1hbfaecdg
118 # For boolean flags that have distinct True/False opts,
119 # use the opt without prefix instead of the value.
120 # Typer override, original commented
121 # default_string = click.parser.split_opt(
122 # (self.opts if self.default else self.secondary_opts)[0]
123 # )[1]
124 if obj.default: 1hbfaecdg
125 if obj.opts: 1hbfaecdg
126 default_string = _split_opt(obj.opts[0])[1] 1hbfaecdg
127 else:
128 default_string = str(default_value) 1hbfaecdg
129 else:
130 default_string = _split_opt(obj.secondary_opts[0])[1] 1hbfaecdg
131 # Typer override end
132 elif ( 1bacd
133 isinstance(obj, TyperOption)
134 and obj.is_bool_flag
135 and not obj.secondary_opts
136 and not default_value
137 ):
138 default_string = "" 1hbfaecdg
139 else:
140 default_string = str(default_value) 1hbfaecdg
141 return default_string 1hbfaecdg
144def _extract_default_help_str( 1bfaecdg
145 obj: Union["TyperArgument", "TyperOption"], *, ctx: click.Context
146) -> Optional[Union[Any, Callable[[], Any]]]:
147 # Extracted from click.core.Option.get_help_record() to be reused by
148 # rich_utils avoiding RegEx hacks
149 # Temporarily enable resilient parsing to avoid type casting
150 # failing for the default. Might be possible to extend this to
151 # help formatting in general.
152 resilient = ctx.resilient_parsing 1hbfaecdg
153 ctx.resilient_parsing = True 1hbfaecdg
155 try: 1hbfaecdg
156 default_value = obj.get_default(ctx, call=False) 1hbfaecdg
157 finally:
158 ctx.resilient_parsing = resilient 1hbfaecdg
159 return default_value 1hbfaecdg
162def _main( 1bfaecdg
163 self: click.Command,
164 *,
165 args: Optional[Sequence[str]] = None,
166 prog_name: Optional[str] = None,
167 complete_var: Optional[str] = None,
168 standalone_mode: bool = True,
169 windows_expand_args: bool = True,
170 **extra: Any,
171) -> Any:
172 # Typer override, duplicated from click.main() to handle custom rich exceptions
173 # Verify that the environment is configured correctly, or reject
174 # further execution to avoid a broken script.
175 if args is None: 1hbfaecdg
176 args = sys.argv[1:] 1hbfaecdg
178 # Covered in Click tests
179 if os.name == "nt" and windows_expand_args: # pragma: no cover 1hbfaecdg
180 args = click.utils._expand_args(args) 1ae
181 else:
182 args = list(args) 1hbfaecdg
184 if prog_name is None: 1hbfaecdg
185 prog_name = click.utils._detect_program_name() 1hbfaecdg
187 # Process shell completion requests and exit early.
188 self._main_shell_completion(extra, prog_name, complete_var) 1hbfaecdg
190 try: 1hbfaecdg
191 try: 1hbfaecdg
192 with self.make_context(prog_name, args, **extra) as ctx: 1hbfaecdg
193 rv = self.invoke(ctx) 1hbfaecdg
194 if not standalone_mode: 1hbfaecdg
195 return rv 1hbfaecdg
196 # it's not safe to `ctx.exit(rv)` here!
197 # note that `rv` may actually contain data like "1" which
198 # has obvious effects
199 # more subtle case: `rv=[None, None]` can come out of
200 # chained commands which all returned `None` -- so it's not
201 # even always obvious that `rv` indicates success/failure
202 # by its truthiness/falsiness
203 ctx.exit() 1hbfaecdg
204 except (EOFError, KeyboardInterrupt) as e: 1hbfaecdg
205 click.echo(file=sys.stderr) 1hbfaecdg
206 raise click.Abort() from e 1hbfaecdg
207 except click.ClickException as e: 1hbfaecdg
208 if not standalone_mode: 1hbfaecdg
209 raise 1hbfaecdg
210 # Typer override
211 if rich: 1hbfaecdg
212 rich_utils.rich_format_error(e) 1hbfaecdg
213 else:
214 e.show() 1hbfaecdg
215 # Typer override end
216 sys.exit(e.exit_code) 1hbfaecdg
217 except OSError as e: 1hbfaecdg
218 if e.errno == errno.EPIPE: 1hbfaecdg
219 sys.stdout = cast(TextIO, click.utils.PacifyFlushWrapper(sys.stdout)) 1hbfaecdg
220 sys.stderr = cast(TextIO, click.utils.PacifyFlushWrapper(sys.stderr)) 1hbfaecdg
221 sys.exit(1) 1hbfaecdg
222 else:
223 raise 1hbfaecdg
224 except click.exceptions.Exit as e: 1hbfaecdg
225 if standalone_mode: 1hbfaecdg
226 sys.exit(e.exit_code) 1hbfaecdg
227 else:
228 # in non-standalone mode, return the exit code
229 # note that this is only reached if `self.invoke` above raises
230 # an Exit explicitly -- thus bypassing the check there which
231 # would return its result
232 # the results of non-standalone execution may therefore be
233 # somewhat ambiguous: if there are codepaths which lead to
234 # `ctx.exit(1)` and to `return 1`, the caller won't be able to
235 # tell the difference between the two
236 return e.exit_code 1hbfaecdg
237 except click.Abort: 1hbfaecdg
238 if not standalone_mode: 1hbfaecdg
239 raise 1hbfaecdg
240 # Typer override
241 if rich: 1hbfaecdg
242 rich_utils.rich_abort_error() 1hbfaecdg
243 else:
244 click.echo(_("Aborted!"), file=sys.stderr) 1hbfaecdg
245 # Typer override end
246 sys.exit(1) 1hbfaecdg
249class TyperArgument(click.core.Argument): 1hbfaecdg
250 def __init__( 1bfaecdg
251 self,
252 *,
253 # Parameter
254 param_decls: List[str],
255 type: Optional[Any] = None,
256 required: Optional[bool] = None,
257 default: Optional[Any] = None,
258 callback: Optional[Callable[..., Any]] = None,
259 nargs: Optional[int] = None,
260 metavar: Optional[str] = None,
261 expose_value: bool = True,
262 is_eager: bool = False,
263 envvar: Optional[Union[str, List[str]]] = None,
264 shell_complete: Optional[
265 Callable[
266 [click.Context, click.Parameter, str],
267 Union[List["click.shell_completion.CompletionItem"], List[str]],
268 ]
269 ] = None,
270 autocompletion: Optional[Callable[..., Any]] = None,
271 # TyperArgument
272 show_default: Union[bool, str] = True,
273 show_choices: bool = True,
274 show_envvar: bool = True,
275 help: Optional[str] = None,
276 hidden: bool = False,
277 # Rich settings
278 rich_help_panel: Union[str, None] = None,
279 ):
280 self.help = help 1hbfaecdg
281 self.show_default = show_default 1hbfaecdg
282 self.show_choices = show_choices 1hbfaecdg
283 self.show_envvar = show_envvar 1hbfaecdg
284 self.hidden = hidden 1hbfaecdg
285 self.rich_help_panel = rich_help_panel 1hbfaecdg
287 super().__init__( 1hbfaecdg
288 param_decls=param_decls,
289 type=type,
290 required=required,
291 default=default,
292 callback=callback,
293 nargs=nargs,
294 metavar=metavar,
295 expose_value=expose_value,
296 is_eager=is_eager,
297 envvar=envvar,
298 shell_complete=shell_complete,
299 )
300 _typer_param_setup_autocompletion_compat(self, autocompletion=autocompletion) 1hbfaecdg
302 def _get_default_string( 1bfaecdg
303 self,
304 *,
305 ctx: click.Context,
306 show_default_is_str: bool,
307 default_value: Union[List[Any], Tuple[Any, ...], str, Callable[..., Any], Any],
308 ) -> str:
309 return _get_default_string( 1hbfaecdg
310 self,
311 ctx=ctx,
312 show_default_is_str=show_default_is_str,
313 default_value=default_value,
314 )
316 def _extract_default_help_str( 1bfaecdg
317 self, *, ctx: click.Context
318 ) -> Optional[Union[Any, Callable[[], Any]]]:
319 return _extract_default_help_str(self, ctx=ctx) 1hbfaecdg
321 def get_help_record(self, ctx: click.Context) -> Optional[Tuple[str, str]]: 1hbfaecdg
322 # Modified version of click.core.Option.get_help_record()
323 # to support Arguments
324 if self.hidden: 1hbfaecdg
325 return None 1hbfaecdg
326 name = self.make_metavar() 1hbfaecdg
327 help = self.help or "" 1hbfaecdg
328 extra = [] 1hbfaecdg
329 if self.show_envvar: 1hbfaecdg
330 envvar = self.envvar 1hbfaecdg
331 # allow_from_autoenv is currently not supported in Typer for CLI Arguments
332 if envvar is not None: 1hbfaecdg
333 var_str = ( 1bfaecdg
334 ", ".join(str(d) for d in envvar)
335 if isinstance(envvar, (list, tuple))
336 else envvar
337 )
338 extra.append(f"env var: {var_str}") 1hbfaecdg
340 # Typer override:
341 # Extracted to _extract_default_help_str() to allow re-using it in rich_utils
342 default_value = self._extract_default_help_str(ctx=ctx) 1hbfaecdg
343 # Typer override end
345 show_default_is_str = isinstance(self.show_default, str) 1hbfaecdg
347 if show_default_is_str or ( 1hbfaecdg
348 default_value is not None and (self.show_default or ctx.show_default)
349 ):
350 # Typer override:
351 # Extracted to _get_default_string() to allow re-using it in rich_utils
352 default_string = self._get_default_string( 1hbfaecdg
353 ctx=ctx,
354 show_default_is_str=show_default_is_str,
355 default_value=default_value,
356 )
357 # Typer override end
358 if default_string: 1hbfaecdg
359 extra.append(_("default: {default}").format(default=default_string)) 1hbfaecdg
360 if self.required: 1hbfaecdg
361 extra.append(_("required")) 1hbfaecdg
362 if extra: 1hbfaecdg
363 extra_str = ";".join(extra) 1hbfaecdg
364 help = f"{help} [{extra_str}]" if help else f"[{extra_str}]" 1hbfaecdg
365 return name, help 1hbfaecdg
367 def make_metavar(self) -> str: 1hbfaecdg
368 # Modified version of click.core.Argument.make_metavar()
369 # to include Argument name
370 if self.metavar is not None: 1hbfaecdg
371 return self.metavar 1hbfaecdg
372 var = (self.name or "").upper() 1hbfaecdg
373 if not self.required: 1hbfaecdg
374 var = f"[{var}]" 1hbfaecdg
375 type_var = self.type.get_metavar(self) 1hbfaecdg
376 if type_var: 1hbfaecdg
377 var += f":{type_var}" 1hbfaecdg
378 if self.nargs != 1: 1hbfaecdg
379 var += "..." 1hbfaecdg
380 return var 1hbfaecdg
383class TyperOption(click.core.Option): 1hbfaecdg
384 def __init__( 1bfaecdg
385 self,
386 *,
387 # Parameter
388 param_decls: List[str],
389 type: Optional[Union[click.types.ParamType, Any]] = None,
390 required: Optional[bool] = None,
391 default: Optional[Any] = None,
392 callback: Optional[Callable[..., Any]] = None,
393 nargs: Optional[int] = None,
394 metavar: Optional[str] = None,
395 expose_value: bool = True,
396 is_eager: bool = False,
397 envvar: Optional[Union[str, List[str]]] = None,
398 shell_complete: Optional[
399 Callable[
400 [click.Context, click.Parameter, str],
401 Union[List["click.shell_completion.CompletionItem"], List[str]],
402 ]
403 ] = None,
404 autocompletion: Optional[Callable[..., Any]] = None,
405 # Option
406 show_default: Union[bool, str] = False,
407 prompt: Union[bool, str] = False,
408 confirmation_prompt: Union[bool, str] = False,
409 prompt_required: bool = True,
410 hide_input: bool = False,
411 is_flag: Optional[bool] = None,
412 flag_value: Optional[Any] = None,
413 multiple: bool = False,
414 count: bool = False,
415 allow_from_autoenv: bool = True,
416 help: Optional[str] = None,
417 hidden: bool = False,
418 show_choices: bool = True,
419 show_envvar: bool = False,
420 # Rich settings
421 rich_help_panel: Union[str, None] = None,
422 ):
423 super().__init__( 1hbfaecdg
424 param_decls=param_decls,
425 type=type,
426 required=required,
427 default=default,
428 callback=callback,
429 nargs=nargs,
430 metavar=metavar,
431 expose_value=expose_value,
432 is_eager=is_eager,
433 envvar=envvar,
434 show_default=show_default,
435 prompt=prompt,
436 confirmation_prompt=confirmation_prompt,
437 hide_input=hide_input,
438 is_flag=is_flag,
439 flag_value=flag_value,
440 multiple=multiple,
441 count=count,
442 allow_from_autoenv=allow_from_autoenv,
443 help=help,
444 hidden=hidden,
445 show_choices=show_choices,
446 show_envvar=show_envvar,
447 prompt_required=prompt_required,
448 shell_complete=shell_complete,
449 )
450 _typer_param_setup_autocompletion_compat(self, autocompletion=autocompletion) 1hbfaecdg
451 self.rich_help_panel = rich_help_panel 1hbfaecdg
453 def _get_default_string( 1bfaecdg
454 self,
455 *,
456 ctx: click.Context,
457 show_default_is_str: bool,
458 default_value: Union[List[Any], Tuple[Any, ...], str, Callable[..., Any], Any],
459 ) -> str:
460 return _get_default_string( 1hbfaecdg
461 self,
462 ctx=ctx,
463 show_default_is_str=show_default_is_str,
464 default_value=default_value,
465 )
467 def _extract_default_help_str( 1bfaecdg
468 self, *, ctx: click.Context
469 ) -> Optional[Union[Any, Callable[[], Any]]]:
470 return _extract_default_help_str(self, ctx=ctx) 1hbfaecdg
472 def get_help_record(self, ctx: click.Context) -> Optional[Tuple[str, str]]: 1hbfaecdg
473 # Duplicate all of Click's logic only to modify a single line, to allow boolean
474 # flags with only names for False values as it's currently supported by Typer
475 # Ref: https://typer.tiangolo.com/tutorial/parameter-types/bool/#only-names-for-false
476 if self.hidden: 1hbfaecdg
477 return None 1hbfaecdg
479 any_prefix_is_slash = False 1hbfaecdg
481 def _write_opts(opts: Sequence[str]) -> str: 1hbfaecdg
482 nonlocal any_prefix_is_slash
484 rv, any_slashes = click.formatting.join_options(opts) 1hbfaecdg
486 if any_slashes: 1hbfaecdg
487 any_prefix_is_slash = True 1hbfaecdg
489 if not self.is_flag and not self.count: 1hbfaecdg
490 rv += f" {self.make_metavar()}" 1hbfaecdg
492 return rv 1hbfaecdg
494 rv = [_write_opts(self.opts)] 1hbfaecdg
496 if self.secondary_opts: 1hbfaecdg
497 rv.append(_write_opts(self.secondary_opts)) 1hbfaecdg
499 help = self.help or "" 1hbfaecdg
500 extra = [] 1hbfaecdg
502 if self.show_envvar: 1hbfaecdg
503 envvar = self.envvar 1hbfaecdg
505 if envvar is None: 1hbfaecdg
506 if ( 1bacd
507 self.allow_from_autoenv
508 and ctx.auto_envvar_prefix is not None
509 and self.name is not None
510 ):
511 envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}" 1hbfaecdg
513 if envvar is not None: 1hbfaecdg
514 var_str = ( 1bfaecdg
515 envvar
516 if isinstance(envvar, str)
517 else ", ".join(str(d) for d in envvar)
518 )
519 extra.append(_("env var: {var}").format(var=var_str)) 1hbfaecdg
521 # Typer override:
522 # Extracted to _extract_default() to allow re-using it in rich_utils
523 default_value = self._extract_default_help_str(ctx=ctx) 1hbfaecdg
524 # Typer override end
526 show_default_is_str = isinstance(self.show_default, str) 1hbfaecdg
528 if show_default_is_str or ( 1hbfaecdg
529 default_value is not None and (self.show_default or ctx.show_default)
530 ):
531 # Typer override:
532 # Extracted to _get_default_string() to allow re-using it in rich_utils
533 default_string = self._get_default_string( 1hbfaecdg
534 ctx=ctx,
535 show_default_is_str=show_default_is_str,
536 default_value=default_value,
537 )
538 # Typer override end
539 if default_string: 1hbfaecdg
540 extra.append(_("default: {default}").format(default=default_string)) 1hbfaecdg
542 if isinstance(self.type, click.types._NumberRangeBase): 1hbfaecdg
543 range_str = self.type._describe_range() 1hbfaecdg
545 if range_str: 1hbfaecdg
546 extra.append(range_str) 1hbfaecdg
548 if self.required: 1hbfaecdg
549 extra.append(_("required")) 1hbfaecdg
551 if extra: 1hbfaecdg
552 extra_str = "; ".join(extra) 1hbfaecdg
553 help = f"{help} [{extra_str}]" if help else f"[{extra_str}]" 1hbfaecdg
555 return ("; " if any_prefix_is_slash else " / ").join(rv), help 1hbfaecdg
558def _typer_format_options( 1bfaecdg
559 self: click.core.Command, *, ctx: click.Context, formatter: click.HelpFormatter
560) -> None:
561 args = [] 1hbfaecdg
562 opts = [] 1hbfaecdg
563 for param in self.get_params(ctx): 1hbfaecdg
564 rv = param.get_help_record(ctx) 1hbfaecdg
565 if rv is not None: 1hbfaecdg
566 if param.param_type_name == "argument": 1hbfaecdg
567 args.append(rv) 1hbfaecdg
568 elif param.param_type_name == "option": 1hbfaecdg
569 opts.append(rv) 1hbfaecdg
571 if args: 1hbfaecdg
572 with formatter.section(_("Arguments")): 1hbfaecdg
573 formatter.write_dl(args) 1hbfaecdg
574 if opts: 1hbfaecdg
575 with formatter.section(_("Options")): 1hbfaecdg
576 formatter.write_dl(opts) 1hbfaecdg
579def _typer_main_shell_completion( 1bfaecdg
580 self: click.core.Command,
581 *,
582 ctx_args: MutableMapping[str, Any],
583 prog_name: str,
584 complete_var: Optional[str] = None,
585) -> None:
586 if complete_var is None: 1hbfaecdg
587 complete_var = f"_{prog_name}_COMPLETE".replace("-", "_").upper() 1hbfaecdg
589 instruction = os.environ.get(complete_var) 1hbfaecdg
591 if not instruction: 1hbfaecdg
592 return 1hbfaecdg
594 from .completion import shell_complete 1hbfaecdg
596 rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction) 1hbfaecdg
597 sys.exit(rv) 1hbfaecdg
600class TyperCommand(click.core.Command): 1hbfaecdg
601 def __init__( 1bfaecdg
602 self,
603 name: Optional[str],
604 *,
605 context_settings: Optional[Dict[str, Any]] = None,
606 callback: Optional[Callable[..., Any]] = None,
607 params: Optional[List[click.Parameter]] = None,
608 help: Optional[str] = None,
609 epilog: Optional[str] = None,
610 short_help: Optional[str] = None,
611 options_metavar: Optional[str] = "[OPTIONS]",
612 add_help_option: bool = True,
613 no_args_is_help: bool = False,
614 hidden: bool = False,
615 deprecated: bool = False,
616 # Rich settings
617 rich_markup_mode: MarkupMode = None,
618 rich_help_panel: Union[str, None] = None,
619 ) -> None:
620 super().__init__( 1hbfaecdg
621 name=name,
622 context_settings=context_settings,
623 callback=callback,
624 params=params,
625 help=help,
626 epilog=epilog,
627 short_help=short_help,
628 options_metavar=options_metavar,
629 add_help_option=add_help_option,
630 no_args_is_help=no_args_is_help,
631 hidden=hidden,
632 deprecated=deprecated,
633 )
634 self.rich_markup_mode: MarkupMode = rich_markup_mode 1hbfaecdg
635 self.rich_help_panel = rich_help_panel 1hbfaecdg
637 def format_options( 1bfaecdg
638 self, ctx: click.Context, formatter: click.HelpFormatter
639 ) -> None:
640 _typer_format_options(self, ctx=ctx, formatter=formatter) 1hbfaecdg
642 def _main_shell_completion( 1bfaecdg
643 self,
644 ctx_args: MutableMapping[str, Any],
645 prog_name: str,
646 complete_var: Optional[str] = None,
647 ) -> None:
648 _typer_main_shell_completion( 1hbfaecdg
649 self, ctx_args=ctx_args, prog_name=prog_name, complete_var=complete_var
650 )
652 def main( 1bfaecdg
653 self,
654 args: Optional[Sequence[str]] = None,
655 prog_name: Optional[str] = None,
656 complete_var: Optional[str] = None,
657 standalone_mode: bool = True,
658 windows_expand_args: bool = True,
659 **extra: Any,
660 ) -> Any:
661 return _main( 1hbfaecdg
662 self,
663 args=args,
664 prog_name=prog_name,
665 complete_var=complete_var,
666 standalone_mode=standalone_mode,
667 windows_expand_args=windows_expand_args,
668 **extra,
669 )
671 def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None: 1hbfaecdg
672 if not rich: 1hbfaecdg
673 return super().format_help(ctx, formatter) 1hbfaecdg
674 return rich_utils.rich_format_help( 1hbfaecdg
675 obj=self,
676 ctx=ctx,
677 markup_mode=self.rich_markup_mode,
678 )
681class TyperGroup(click.core.Group): 1hbfaecdg
682 def __init__( 1bfaecdg
683 self,
684 *,
685 name: Optional[str] = None,
686 commands: Optional[
687 Union[Dict[str, click.Command], Sequence[click.Command]]
688 ] = None,
689 # Rich settings
690 rich_markup_mode: MarkupMode = None,
691 rich_help_panel: Union[str, None] = None,
692 **attrs: Any,
693 ) -> None:
694 super().__init__(name=name, commands=commands, **attrs) 1hbfaecdg
695 self.rich_markup_mode: MarkupMode = rich_markup_mode 1hbfaecdg
696 self.rich_help_panel = rich_help_panel 1hbfaecdg
698 def format_options( 1bfaecdg
699 self, ctx: click.Context, formatter: click.HelpFormatter
700 ) -> None:
701 _typer_format_options(self, ctx=ctx, formatter=formatter) 1hbfaecdg
702 self.format_commands(ctx, formatter) 1hbfaecdg
704 def _main_shell_completion( 1bfaecdg
705 self,
706 ctx_args: MutableMapping[str, Any],
707 prog_name: str,
708 complete_var: Optional[str] = None,
709 ) -> None:
710 _typer_main_shell_completion( 1hbfaecdg
711 self, ctx_args=ctx_args, prog_name=prog_name, complete_var=complete_var
712 )
714 def main( 1bfaecdg
715 self,
716 args: Optional[Sequence[str]] = None,
717 prog_name: Optional[str] = None,
718 complete_var: Optional[str] = None,
719 standalone_mode: bool = True,
720 windows_expand_args: bool = True,
721 **extra: Any,
722 ) -> Any:
723 return _main( 1hbfaecdg
724 self,
725 args=args,
726 prog_name=prog_name,
727 complete_var=complete_var,
728 standalone_mode=standalone_mode,
729 windows_expand_args=windows_expand_args,
730 **extra,
731 )
733 def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None: 1hbfaecdg
734 if not rich: 1hbfaecdg
735 return super().format_help(ctx, formatter) 1hbfaecdg
736 return rich_utils.rich_format_help( 1hbfaecdg
737 obj=self,
738 ctx=ctx,
739 markup_mode=self.rich_markup_mode,
740 )