Coverage for typer/main.py: 100%

1import inspect 8 ctx1hceafbdg

2import os 8 ctx1hceafbdg

3import sys 8 ctx1hceafbdg

4import traceback 8 ctx1hceafbdg

5from datetime import datetime 8 ctx1hceafbdg

6from enum import Enum 8 ctx1hceafbdg

7from functools import update_wrapper 8 ctx1hceafbdg

8from pathlib import Path 8 ctx1hceafbdg

9from traceback import FrameSummary, StackSummary 8 ctx1hceafbdg

10from types import TracebackType 8 ctx1hceafbdg

11from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type, Union 8 ctx1hceafbdg

12from uuid import UUID 8 ctx1hceafbdg

13 

14import click 8 ctx1hceafbdg

15 

16from .completion import get_completion_inspect_parameters 8 ctx1hceafbdg

17from .core import MarkupMode, TyperArgument, TyperCommand, TyperGroup, TyperOption 8 ctx1hceafbdg

18from .models import ( 8 ctx1hceafbdg

19 AnyType, 

20 ArgumentInfo, 

21 CommandFunctionType, 

22 CommandInfo, 

23 Default, 

24 DefaultPlaceholder, 

25 DeveloperExceptionConfig, 

26 FileBinaryRead, 

27 FileBinaryWrite, 

28 FileText, 

29 FileTextWrite, 

30 NoneType, 

31 OptionInfo, 

32 ParameterInfo, 

33 ParamMeta, 

34 Required, 

35 TyperInfo, 

36) 

37from .utils import get_params_from_function 8 ctx1hceafbdg

38 

39try: 8 ctx1hceafbdg

40 import rich 8 ctx1hceafbdg

41 from rich.console import Console 8 ctx1hceafbdg

42 from rich.traceback import Traceback 8 ctx1hceafbdg

43 

44 console_stderr = Console(stderr=True) 8 ctx1hceafbdg

45 

46except ImportError: # pragma: no cover 

47 rich = None # type: ignore 

48 

49_original_except_hook = sys.excepthook 8 ctx1hceafbdg

50_typer_developer_exception_attr_name = "__typer_developer_exception__" 8 ctx1hceafbdg

51 

52 

53def except_hook( 7 ctx1ceafbdg

54 exc_type: Type[BaseException], exc_value: BaseException, tb: Optional[TracebackType] 

55) -> None: 

56 exception_config: Union[DeveloperExceptionConfig, None] = getattr( 8 ctx1hceafbdg

57 exc_value, _typer_developer_exception_attr_name, None 

58 ) 

59 standard_traceback = os.getenv("_TYPER_STANDARD_TRACEBACK") 8 ctx1hceafbdg

60 if ( 4 ctx1cabd

61 standard_traceback 

62 or not exception_config 

63 or not exception_config.pretty_exceptions_enable 

64 ): 

65 _original_except_hook(exc_type, exc_value, tb) 8 ctx1hceafbdg

66 return 8 ctx1hceafbdg

67 typer_path = os.path.dirname(__file__) 8 ctx1hceafbdg

68 click_path = os.path.dirname(click.__file__) 8 ctx1hceafbdg

69 supress_internal_dir_names = [typer_path, click_path] 8 ctx1hceafbdg

70 exc = exc_value 8 ctx1hceafbdg

71 if rich: 8 ctx1hceafbdg

72 rich_tb = Traceback.from_exception( 8 ctx1hceafbdg

73 type(exc), 

74 exc, 

75 exc.__traceback__, 

76 show_locals=exception_config.pretty_exceptions_show_locals, 

77 suppress=supress_internal_dir_names, 

78 ) 

79 console_stderr.print(rich_tb) 8 ctx1hceafbdg

80 return 8 ctx1hceafbdg

81 tb_exc = traceback.TracebackException.from_exception(exc) 8 ctx1hceafbdg

82 stack: List[FrameSummary] = [] 8 ctx1hceafbdg

83 for frame in tb_exc.stack: 8 ctx1hceafbdg

84 if any(frame.filename.startswith(path) for path in supress_internal_dir_names): 8 ctx1hceafbdg

85 if not exception_config.pretty_exceptions_short: 8 ctx1hceafbdg

86 # Hide the line for internal libraries, Typer and Click 

87 stack.append( 8 ctx1hceafbdg

88 traceback.FrameSummary( 

89 filename=frame.filename, 

90 lineno=frame.lineno, 

91 name=frame.name, 

92 line="", 

93 ) 

94 ) 

95 else: 

96 stack.append(frame) 8 ctx1hceafbdg

97 # Type ignore ref: https://github.com/python/typeshed/pull/8244 

98 final_stack_summary = StackSummary.from_list(stack) 8 ctx1hceafbdg

99 tb_exc.stack = final_stack_summary 8 ctx1hceafbdg

100 for line in tb_exc.format(): 8 ctx1hceafbdg

101 print(line, file=sys.stderr) 8 ctx1hceafbdg

102 return 8 ctx1hceafbdg

103 

104 

105def get_install_completion_arguments() -> Tuple[click.Parameter, click.Parameter]: 8 ctx1hceafbdg

106 install_param, show_param = get_completion_inspect_parameters() 8 ctx1hceafbdg

107 click_install_param, _ = get_click_param(install_param) 8 ctx1hceafbdg

108 click_show_param, _ = get_click_param(show_param) 8 ctx1hceafbdg

109 return click_install_param, click_show_param 8 ctx1hceafbdg

110 

111 

112class Typer: 8 ctx1hceafbdg

113 def __init__( 7 ctx1ceafbdg

114 self, 

115 *, 

116 name: Optional[str] = Default(None), 

117 cls: Optional[Type[TyperGroup]] = Default(None), 

118 invoke_without_command: bool = Default(False), 

119 no_args_is_help: bool = Default(False), 

120 subcommand_metavar: Optional[str] = Default(None), 

121 chain: bool = Default(False), 

122 result_callback: Optional[Callable[..., Any]] = Default(None), 

123 # Command 

124 context_settings: Optional[Dict[Any, Any]] = Default(None), 

125 callback: Optional[Callable[..., Any]] = Default(None), 

126 help: Optional[str] = Default(None), 

127 epilog: Optional[str] = Default(None), 

128 short_help: Optional[str] = Default(None), 

129 options_metavar: str = Default("[OPTIONS]"), 

130 add_help_option: bool = Default(True), 

131 hidden: bool = Default(False), 

132 deprecated: bool = Default(False), 

133 add_completion: bool = True, 

134 # Rich settings 

135 rich_markup_mode: MarkupMode = None, 

136 rich_help_panel: Union[str, None] = Default(None), 

137 pretty_exceptions_enable: bool = True, 

138 pretty_exceptions_show_locals: bool = True, 

139 pretty_exceptions_short: bool = True, 

140 ): 

141 self._add_completion = add_completion 8 ctx1hceafbdg

142 self.rich_markup_mode: MarkupMode = rich_markup_mode 8 ctx1hceafbdg

143 self.rich_help_panel = rich_help_panel 8 ctx1hceafbdg

144 self.pretty_exceptions_enable = pretty_exceptions_enable 8 ctx1hceafbdg

145 self.pretty_exceptions_show_locals = pretty_exceptions_show_locals 8 ctx1hceafbdg

146 self.pretty_exceptions_short = pretty_exceptions_short 8 ctx1hceafbdg

147 self.info = TyperInfo( 8 ctx1hceafbdg

148 name=name, 

149 cls=cls, 

150 invoke_without_command=invoke_without_command, 

151 no_args_is_help=no_args_is_help, 

152 subcommand_metavar=subcommand_metavar, 

153 chain=chain, 

154 result_callback=result_callback, 

155 context_settings=context_settings, 

156 callback=callback, 

157 help=help, 

158 epilog=epilog, 

159 short_help=short_help, 

160 options_metavar=options_metavar, 

161 add_help_option=add_help_option, 

162 hidden=hidden, 

163 deprecated=deprecated, 

164 ) 

165 self.registered_groups: List[TyperInfo] = [] 8 ctx1hceafbdg

166 self.registered_commands: List[CommandInfo] = [] 8 ctx1hceafbdg

167 self.registered_callback: Optional[TyperInfo] = None 8 ctx1hceafbdg

168 

169 def callback( 7 ctx1ceafbdg

170 self, 

171 name: Optional[str] = Default(None), 

172 *, 

173 cls: Optional[Type[TyperGroup]] = Default(None), 

174 invoke_without_command: bool = Default(False), 

175 no_args_is_help: bool = Default(False), 

176 subcommand_metavar: Optional[str] = Default(None), 

177 chain: bool = Default(False), 

178 result_callback: Optional[Callable[..., Any]] = Default(None), 

179 # Command 

180 context_settings: Optional[Dict[Any, Any]] = Default(None), 

181 help: Optional[str] = Default(None), 

182 epilog: Optional[str] = Default(None), 

183 short_help: Optional[str] = Default(None), 

184 options_metavar: str = Default("[OPTIONS]"), 

185 add_help_option: bool = Default(True), 

186 hidden: bool = Default(False), 

187 deprecated: bool = Default(False), 

188 # Rich settings 

189 rich_help_panel: Union[str, None] = Default(None), 

190 ) -> Callable[[CommandFunctionType], CommandFunctionType]: 

191 def decorator(f: CommandFunctionType) -> CommandFunctionType: 8 ctx1hceafbdg

192 self.registered_callback = TyperInfo( 8 ctx1hceafbdg

193 name=name, 

194 cls=cls, 

195 invoke_without_command=invoke_without_command, 

196 no_args_is_help=no_args_is_help, 

197 subcommand_metavar=subcommand_metavar, 

198 chain=chain, 

199 result_callback=result_callback, 

200 context_settings=context_settings, 

201 callback=f, 

202 help=help, 

203 epilog=epilog, 

204 short_help=short_help, 

205 options_metavar=options_metavar, 

206 add_help_option=add_help_option, 

207 hidden=hidden, 

208 deprecated=deprecated, 

209 rich_help_panel=rich_help_panel, 

210 ) 

211 return f 8 ctx1hceafbdg

212 

213 return decorator 8 ctx1hceafbdg

214 

215 def command( 7 ctx1ceafbdg

216 self, 

217 name: Optional[str] = None, 

218 *, 

219 cls: Optional[Type[TyperCommand]] = None, 

220 context_settings: Optional[Dict[Any, Any]] = None, 

221 help: Optional[str] = None, 

222 epilog: Optional[str] = None, 

223 short_help: Optional[str] = None, 

224 options_metavar: str = "[OPTIONS]", 

225 add_help_option: bool = True, 

226 no_args_is_help: bool = False, 

227 hidden: bool = False, 

228 deprecated: bool = False, 

229 # Rich settings 

230 rich_help_panel: Union[str, None] = Default(None), 

231 ) -> Callable[[CommandFunctionType], CommandFunctionType]: 

232 if cls is None: 8 ctx1hceafbdg

233 cls = TyperCommand 8 ctx1hceafbdg

234 

235 def decorator(f: CommandFunctionType) -> CommandFunctionType: 8 ctx1hceafbdg

236 self.registered_commands.append( 8 ctx1hceafbdg

237 CommandInfo( 

238 name=name, 

239 cls=cls, 

240 context_settings=context_settings, 

241 callback=f, 

242 help=help, 

243 epilog=epilog, 

244 short_help=short_help, 

245 options_metavar=options_metavar, 

246 add_help_option=add_help_option, 

247 no_args_is_help=no_args_is_help, 

248 hidden=hidden, 

249 deprecated=deprecated, 

250 # Rich settings 

251 rich_help_panel=rich_help_panel, 

252 ) 

253 ) 

254 return f 8 ctx1hceafbdg

255 

256 return decorator 8 ctx1hceafbdg

257 

258 def add_typer( 7 ctx1ceafbdg

259 self, 

260 typer_instance: "Typer", 

261 *, 

262 name: Optional[str] = Default(None), 

263 cls: Optional[Type[TyperGroup]] = Default(None), 

264 invoke_without_command: bool = Default(False), 

265 no_args_is_help: bool = Default(False), 

266 subcommand_metavar: Optional[str] = Default(None), 

267 chain: bool = Default(False), 

268 result_callback: Optional[Callable[..., Any]] = Default(None), 

269 # Command 

270 context_settings: Optional[Dict[Any, Any]] = Default(None), 

271 callback: Optional[Callable[..., Any]] = Default(None), 

272 help: Optional[str] = Default(None), 

273 epilog: Optional[str] = Default(None), 

274 short_help: Optional[str] = Default(None), 

275 options_metavar: str = Default("[OPTIONS]"), 

276 add_help_option: bool = Default(True), 

277 hidden: bool = Default(False), 

278 deprecated: bool = Default(False), 

279 # Rich settings 

280 rich_help_panel: Union[str, None] = Default(None), 

281 ) -> None: 

282 self.registered_groups.append( 8 ctx1hceafbdg

283 TyperInfo( 

284 typer_instance, 

285 name=name, 

286 cls=cls, 

287 invoke_without_command=invoke_without_command, 

288 no_args_is_help=no_args_is_help, 

289 subcommand_metavar=subcommand_metavar, 

290 chain=chain, 

291 result_callback=result_callback, 

292 context_settings=context_settings, 

293 callback=callback, 

294 help=help, 

295 epilog=epilog, 

296 short_help=short_help, 

297 options_metavar=options_metavar, 

298 add_help_option=add_help_option, 

299 hidden=hidden, 

300 deprecated=deprecated, 

301 rich_help_panel=rich_help_panel, 

302 ) 

303 ) 

304 

305 def __call__(self, *args: Any, **kwargs: Any) -> Any: 8 ctx1hceafbdg

306 if sys.excepthook != except_hook: 8 ctx1hceafbdg

307 sys.excepthook = except_hook 8 ctx1hceafbdg

308 try: 8 ctx1hceafbdg

309 return get_command(self)(*args, **kwargs) 8 ctx1hceafbdg

310 except Exception as e: 8 ctx1hceafbdg

311 # Set a custom attribute to tell the hook to show nice exceptions for user 

312 # code. An alternative/first implementation was a custom exception with 

313 # raise custom_exc from e 

314 # but that means the last error shown is the custom exception, not the 

315 # actual error. This trick improves developer experience by showing the 

316 # actual error last. 

317 setattr( 8 ctx1hceafbdg

318 e, 

319 _typer_developer_exception_attr_name, 

320 DeveloperExceptionConfig( 

321 pretty_exceptions_enable=self.pretty_exceptions_enable, 

322 pretty_exceptions_show_locals=self.pretty_exceptions_show_locals, 

323 pretty_exceptions_short=self.pretty_exceptions_short, 

324 ), 

325 ) 

326 raise e 8 ctx1hceafbdg

327 

328 

329def get_group(typer_instance: Typer) -> TyperGroup: 8 ctx1hceafbdg

330 group = get_group_from_info( 8 ctx1hceafbdg

331 TyperInfo(typer_instance), 

332 pretty_exceptions_short=typer_instance.pretty_exceptions_short, 

333 rich_markup_mode=typer_instance.rich_markup_mode, 

334 ) 

335 return group 8 ctx1hceafbdg

336 

337 

338def get_command(typer_instance: Typer) -> click.Command: 8 ctx1hceafbdg

339 if typer_instance._add_completion: 8 ctx1hceafbdg

340 click_install_param, click_show_param = get_install_completion_arguments() 8 ctx1hceafbdg

341 if ( 4 ctx1cabd

342 typer_instance.registered_callback 

343 or typer_instance.info.callback 

344 or typer_instance.registered_groups 

345 or len(typer_instance.registered_commands) > 1 

346 ): 

347 # Create a Group 

348 click_command: click.Command = get_group(typer_instance) 8 ctx1hceafbdg

349 if typer_instance._add_completion: 8 ctx1hceafbdg

350 click_command.params.append(click_install_param) 8 ctx1hceafbdg

351 click_command.params.append(click_show_param) 8 ctx1hceafbdg

352 return click_command 8 ctx1hceafbdg

353 elif len(typer_instance.registered_commands) == 1: 8 ctx1hceafbdg

354 # Create a single Command 

355 single_command = typer_instance.registered_commands[0] 8 ctx1hceafbdg

356 

357 if not single_command.context_settings and not isinstance( 8 ctx1hceafbdg

358 typer_instance.info.context_settings, DefaultPlaceholder 

359 ): 

360 single_command.context_settings = typer_instance.info.context_settings 8 ctx1hceafbdg

361 

362 click_command = get_command_from_info( 8 ctx1hceafbdg

363 single_command, 

364 pretty_exceptions_short=typer_instance.pretty_exceptions_short, 

365 rich_markup_mode=typer_instance.rich_markup_mode, 

366 ) 

367 if typer_instance._add_completion: 8 ctx1hceafbdg

368 click_command.params.append(click_install_param) 8 ctx1hceafbdg

369 click_command.params.append(click_show_param) 8 ctx1hceafbdg

370 return click_command 8 ctx1hceafbdg

371 raise RuntimeError( 

372 "Could not get a command for this Typer instance" 

373 ) # pragma: no cover 

374 

375 

376def get_group_name(typer_info: TyperInfo) -> Optional[str]: 8 ctx1hceafbdg

377 if typer_info.callback: 8 ctx1hceafbdg

378 # Priority 1: Callback passed in app.add_typer() 

379 return get_command_name(typer_info.callback.__name__) 8 ctx1hceafbdg

380 if typer_info.typer_instance: 8 ctx1hceafbdg

381 registered_callback = typer_info.typer_instance.registered_callback 8 ctx1hceafbdg

382 if registered_callback: 8 ctx1hceafbdg

383 if registered_callback.callback: 8 ctx1hceafbdg

384 # Priority 2: Callback passed in @subapp.callback() 

385 return get_command_name(registered_callback.callback.__name__) 8 ctx1hceafbdg

386 if typer_info.typer_instance.info.callback: 8 ctx1hceafbdg

387 return get_command_name(typer_info.typer_instance.info.callback.__name__) 8 ctx1hceafbdg

388 return None 8 ctx1hceafbdg

389 

390 

391def solve_typer_info_help(typer_info: TyperInfo) -> str: 8 ctx1hceafbdg

392 # Priority 1: Explicit value was set in app.add_typer() 

393 if not isinstance(typer_info.help, DefaultPlaceholder): 8 ctx1hceafbdg

394 return inspect.cleandoc(typer_info.help or "") 8 ctx1hceafbdg

395 # Priority 2: Explicit value was set in sub_app.callback() 

396 try: 8 ctx1hceafbdg

397 callback_help = typer_info.typer_instance.registered_callback.help 8 ctx1hceafbdg

398 if not isinstance(callback_help, DefaultPlaceholder): 8 ctx1hceafbdg

399 return inspect.cleandoc(callback_help or "") 8 ctx1hceafbdg

400 except AttributeError: 8 ctx1hceafbdg

401 pass 8 ctx1hceafbdg

402 # Priority 3: Explicit value was set in sub_app = typer.Typer() 

403 try: 8 ctx1hceafbdg

404 instance_help = typer_info.typer_instance.info.help 8 ctx1hceafbdg

405 if not isinstance(instance_help, DefaultPlaceholder): 8 ctx1hceafbdg

406 return inspect.cleandoc(instance_help or "") 8 ctx1hceafbdg

407 except AttributeError: 8 ctx1hceafbdg

408 pass 8 ctx1hceafbdg

409 # Priority 4: Implicit inference from callback docstring in app.add_typer() 

410 if typer_info.callback: 8 ctx1hceafbdg

411 doc = inspect.getdoc(typer_info.callback) 8 ctx1hceafbdg

412 if doc: 8 ctx1hceafbdg

413 return doc 8 ctx1hceafbdg

414 # Priority 5: Implicit inference from callback docstring in @app.callback() 

415 try: 8 ctx1hceafbdg

416 callback = typer_info.typer_instance.registered_callback.callback 8 ctx1hceafbdg

417 if not isinstance(callback, DefaultPlaceholder): 8 ctx1hceafbdg

418 doc = inspect.getdoc(callback or "") 8 ctx1hceafbdg

419 if doc: 8 ctx1hceafbdg

420 return doc 8 ctx1hceafbdg

421 except AttributeError: 8 ctx1hceafbdg

422 pass 8 ctx1hceafbdg

423 # Priority 6: Implicit inference from callback docstring in typer.Typer() 

424 try: 8 ctx1hceafbdg

425 instance_callback = typer_info.typer_instance.info.callback 8 ctx1hceafbdg

426 if not isinstance(instance_callback, DefaultPlaceholder): 8 ctx1hceafbdg

427 doc = inspect.getdoc(instance_callback) 8 ctx1hceafbdg

428 if doc: 8 ctx1hceafbdg

429 return doc 8 ctx1hceafbdg

430 except AttributeError: 8 ctx1hceafbdg

431 pass 8 ctx1hceafbdg

432 # Value not set, use the default 

433 return typer_info.help.value 8 ctx1hceafbdg

434 

435 

436def solve_typer_info_defaults(typer_info: TyperInfo) -> TyperInfo: 8 ctx1hceafbdg

437 values: Dict[str, Any] = {} 8 ctx1hceafbdg

438 name = None 8 ctx1hceafbdg

439 for name, value in typer_info.__dict__.items(): 8 ctx1hceafbdg

440 # Priority 1: Value was set in app.add_typer() 

441 if not isinstance(value, DefaultPlaceholder): 8 ctx1hceafbdg

442 values[name] = value 8 ctx1hceafbdg

443 continue 8 ctx1hceafbdg

444 # Priority 2: Value was set in @subapp.callback() 

445 try: 8 ctx1hceafbdg

446 callback_value = getattr( 8 ctx1hceafbdg

447 typer_info.typer_instance.registered_callback, # type: ignore 

448 name, 

449 ) 

450 if not isinstance(callback_value, DefaultPlaceholder): 8 ctx1hceafbdg

451 values[name] = callback_value 8 ctx1hceafbdg

452 continue 8 ctx1hceafbdg

453 except AttributeError: 8 ctx1hceafbdg

454 pass 8 ctx1hceafbdg

455 # Priority 3: Value set in subapp = typer.Typer() 

456 try: 8 ctx1hceafbdg

457 instance_value = getattr( 8 ctx1hceafbdg

458 typer_info.typer_instance.info, # type: ignore 

459 name, 

460 ) 

461 if not isinstance(instance_value, DefaultPlaceholder): 8 ctx1hceafbdg

462 values[name] = instance_value 8 ctx1hceafbdg

463 continue 8 ctx1hceafbdg

464 except AttributeError: 8 ctx1hceafbdg

465 pass 8 ctx1hceafbdg

466 # Value not set, use the default 

467 values[name] = value.value 8 ctx1hceafbdg

468 if values["name"] is None: 8 ctx1hceafbdg

469 values["name"] = get_group_name(typer_info) 8 ctx1hceafbdg

470 values["help"] = solve_typer_info_help(typer_info) 8 ctx1hceafbdg

471 return TyperInfo(**values) 8 ctx1hceafbdg

472 

473 

474def get_group_from_info( 7 ctx1ceafbdg

475 group_info: TyperInfo, 

476 *, 

477 pretty_exceptions_short: bool, 

478 rich_markup_mode: MarkupMode, 

479) -> TyperGroup: 

480 assert ( 4 ctx1cabd

481 group_info.typer_instance 

482 ), "A Typer instance is needed to generate a Click Group" 

483 commands: Dict[str, click.Command] = {} 8 ctx1hceafbdg

484 for command_info in group_info.typer_instance.registered_commands: 8 ctx1hceafbdg

485 command = get_command_from_info( 8 ctx1hceafbdg

486 command_info=command_info, 

487 pretty_exceptions_short=pretty_exceptions_short, 

488 rich_markup_mode=rich_markup_mode, 

489 ) 

490 if command.name: 8 ctx1hceafbdg

491 commands[command.name] = command 8 ctx1hceafbdg

492 for sub_group_info in group_info.typer_instance.registered_groups: 8 ctx1hceafbdg

493 sub_group = get_group_from_info( 8 ctx1hceafbdg

494 sub_group_info, 

495 pretty_exceptions_short=pretty_exceptions_short, 

496 rich_markup_mode=rich_markup_mode, 

497 ) 

498 if sub_group.name: 8 ctx1hceafbdg

499 commands[sub_group.name] = sub_group 8 ctx1hceafbdg

500 solved_info = solve_typer_info_defaults(group_info) 8 ctx1hceafbdg

501 ( 7 ctx1ceafbdg

502 params, 

503 convertors, 

504 context_param_name, 

505 ) = get_params_convertors_ctx_param_name_from_function(solved_info.callback) 

506 cls = solved_info.cls or TyperGroup 8 ctx1hceafbdg

507 assert issubclass(cls, TyperGroup) 8 ctx1hceafbdg

508 group = cls( 8 ctx1hceafbdg

509 name=solved_info.name or "", 

510 commands=commands, 

511 invoke_without_command=solved_info.invoke_without_command, 

512 no_args_is_help=solved_info.no_args_is_help, 

513 subcommand_metavar=solved_info.subcommand_metavar, 

514 chain=solved_info.chain, 

515 result_callback=solved_info.result_callback, 

516 context_settings=solved_info.context_settings, 

517 callback=get_callback( 

518 callback=solved_info.callback, 

519 params=params, 

520 convertors=convertors, 

521 context_param_name=context_param_name, 

522 pretty_exceptions_short=pretty_exceptions_short, 

523 ), 

524 params=params, 

525 help=solved_info.help, 

526 epilog=solved_info.epilog, 

527 short_help=solved_info.short_help, 

528 options_metavar=solved_info.options_metavar, 

529 add_help_option=solved_info.add_help_option, 

530 hidden=solved_info.hidden, 

531 deprecated=solved_info.deprecated, 

532 rich_markup_mode=rich_markup_mode, 

533 # Rich settings 

534 rich_help_panel=solved_info.rich_help_panel, 

535 ) 

536 return group 8 ctx1hceafbdg

537 

538 

539def get_command_name(name: str) -> str: 8 ctx1hceafbdg

540 return name.lower().replace("_", "-") 8 ctx1hceafbdg

541 

542 

543def get_params_convertors_ctx_param_name_from_function( 7 ctx1ceafbdg

544 callback: Optional[Callable[..., Any]], 

545) -> Tuple[List[Union[click.Argument, click.Option]], Dict[str, Any], Optional[str]]: 

546 params = [] 8 ctx1hceafbdg

547 convertors = {} 8 ctx1hceafbdg

548 context_param_name = None 8 ctx1hceafbdg

549 if callback: 8 ctx1hceafbdg

550 parameters = get_params_from_function(callback) 8 ctx1hceafbdg

551 for param_name, param in parameters.items(): 8 ctx1hceafbdg

552 if lenient_issubclass(param.annotation, click.Context): 8 ctx1hceafbdg

553 context_param_name = param_name 8 ctx1hceafbdg

554 continue 8 ctx1hceafbdg

555 click_param, convertor = get_click_param(param) 8 ctx1hceafbdg

556 if convertor: 8 ctx1hceafbdg

557 convertors[param_name] = convertor 8 ctx1hceafbdg

558 params.append(click_param) 8 ctx1hceafbdg

559 return params, convertors, context_param_name 8 ctx1hceafbdg

560 

561 

562def get_command_from_info( 7 ctx1ceafbdg

563 command_info: CommandInfo, 

564 *, 

565 pretty_exceptions_short: bool, 

566 rich_markup_mode: MarkupMode, 

567) -> click.Command: 

568 assert command_info.callback, "A command must have a callback function" 8 ctx1hceafbdg

569 name = command_info.name or get_command_name(command_info.callback.__name__) 8 ctx1hceafbdg

570 use_help = command_info.help 8 ctx1hceafbdg

571 if use_help is None: 8 ctx1hceafbdg

572 use_help = inspect.getdoc(command_info.callback) 8 ctx1hceafbdg

573 else: 

574 use_help = inspect.cleandoc(use_help) 8 ctx1hceafbdg

575 ( 7 ctx1ceafbdg

576 params, 

577 convertors, 

578 context_param_name, 

579 ) = get_params_convertors_ctx_param_name_from_function(command_info.callback) 

580 cls = command_info.cls or TyperCommand 8 ctx1hceafbdg

581 command = cls( 8 ctx1hceafbdg

582 name=name, 

583 context_settings=command_info.context_settings, 

584 callback=get_callback( 

585 callback=command_info.callback, 

586 params=params, 

587 convertors=convertors, 

588 context_param_name=context_param_name, 

589 pretty_exceptions_short=pretty_exceptions_short, 

590 ), 

591 params=params, # type: ignore 

592 help=use_help, 

593 epilog=command_info.epilog, 

594 short_help=command_info.short_help, 

595 options_metavar=command_info.options_metavar, 

596 add_help_option=command_info.add_help_option, 

597 no_args_is_help=command_info.no_args_is_help, 

598 hidden=command_info.hidden, 

599 deprecated=command_info.deprecated, 

600 rich_markup_mode=rich_markup_mode, 

601 # Rich settings 

602 rich_help_panel=command_info.rich_help_panel, 

603 ) 

604 return command 8 ctx1hceafbdg

605 

606 

607def determine_type_convertor(type_: Any) -> Optional[Callable[[Any], Any]]: 8 ctx1hceafbdg

608 convertor: Optional[Callable[[Any], Any]] = None 8 ctx1hceafbdg

609 if lenient_issubclass(type_, Path): 8 ctx1hceafbdg

610 convertor = param_path_convertor 8 ctx1hceafbdg

611 if lenient_issubclass(type_, Enum): 8 ctx1hceafbdg

612 convertor = generate_enum_convertor(type_) 8 ctx1hceafbdg

613 return convertor 8 ctx1hceafbdg

614 

615 

616def param_path_convertor(value: Optional[str] = None) -> Optional[Path]: 8 ctx1hceafbdg

617 if value is not None: 8 ctx1hceafbdg

618 return Path(value) 8 ctx1hceafbdg

619 return None 8 ctx1hceafbdg

620 

621 

622def generate_enum_convertor(enum: Type[Enum]) -> Callable[[Any], Any]: 8 ctx1hceafbdg

623 val_map = {str(val.value): val for val in enum} 8 ctx1hceafbdg

624 

625 def convertor(value: Any) -> Any: 8 ctx1hceafbdg

626 if value is not None: 8 ctx1hceafbdg

627 val = str(value) 8 ctx1hceafbdg

628 if val in val_map: 8 ctx1hceafbdg

629 key = val_map[val] 8 ctx1hceafbdg

630 return enum(key) 8 ctx1hceafbdg

631 

632 return convertor 8 ctx1hceafbdg

633 

634 

635def generate_list_convertor( 7 ctx1ceafbdg

636 convertor: Optional[Callable[[Any], Any]], default_value: Optional[Any] 

637) -> Callable[[Sequence[Any]], Optional[List[Any]]]: 

638 def internal_convertor(value: Sequence[Any]) -> Optional[List[Any]]: 8 ctx1hceafbdg

639 if default_value is None and len(value) == 0: 8 ctx1hceafbdg

640 return None 8 ctx1hceafbdg

641 return [convertor(v) if convertor else v for v in value] 8 ctx1hceafbdg

642 

643 return internal_convertor 8 ctx1hceafbdg

644 

645 

646def generate_tuple_convertor( 7 ctx1ceafbdg

647 types: Sequence[Any], 

648) -> Callable[[Optional[Tuple[Any, ...]]], Optional[Tuple[Any, ...]]]: 

649 convertors = [determine_type_convertor(type_) for type_ in types] 8 ctx1hceafbdg

650 

651 def internal_convertor( 7 ctx1ceafbdg

652 param_args: Optional[Tuple[Any, ...]], 

653 ) -> Optional[Tuple[Any, ...]]: 

654 if param_args is None: 8 ctx1hceafbdg

655 return None 8 ctx1hceafbdg

656 return tuple( 8 ctx1hceafbdg

657 convertor(arg) if convertor else arg 

658 for (convertor, arg) in zip(convertors, param_args) 

659 ) 

660 

661 return internal_convertor 8 ctx1hceafbdg

662 

663 

664def get_callback( 7 ctx1ceafbdg

665 *, 

666 callback: Optional[Callable[..., Any]] = None, 

667 params: Sequence[click.Parameter] = [], 

668 convertors: Optional[Dict[str, Callable[[str], Any]]] = None, 

669 context_param_name: Optional[str] = None, 

670 pretty_exceptions_short: bool, 

671) -> Optional[Callable[..., Any]]: 

672 use_convertors = convertors or {} 8 ctx1hceafbdg

673 if not callback: 8 ctx1hceafbdg

674 return None 8 ctx1hceafbdg

675 parameters = get_params_from_function(callback) 8 ctx1hceafbdg

676 use_params: Dict[str, Any] = {} 8 ctx1hceafbdg

677 for param_name in parameters: 8 ctx1hceafbdg

678 use_params[param_name] = None 8 ctx1hceafbdg

679 for param in params: 8 ctx1hceafbdg

680 if param.name: 8 ctx1hceafbdg

681 use_params[param.name] = param.default 8 ctx1hceafbdg

682 

683 def wrapper(**kwargs: Any) -> Any: 8 ctx1hceafbdg

684 _rich_traceback_guard = pretty_exceptions_short # noqa: F841 8 ctx1hceafbdg

685 for k, v in kwargs.items(): 8 ctx1hceafbdg

686 if k in use_convertors: 8 ctx1hceafbdg

687 use_params[k] = use_convertors[k](v) 8 ctx1hceafbdg

688 else: 

689 use_params[k] = v 8 ctx1hceafbdg

690 if context_param_name: 8 ctx1hceafbdg

691 use_params[context_param_name] = click.get_current_context() 8 ctx1hceafbdg

692 return callback(**use_params) 8 ctx1hceafbdg

693 

694 update_wrapper(wrapper, callback) 8 ctx1hceafbdg

695 return wrapper 8 ctx1hceafbdg

696 

697 

698def get_click_type( 7 ctx1ceafbdg

699 *, annotation: Any, parameter_info: ParameterInfo