Coverage for src / derivepassphrase / _internals / cli_machinery.py: 100.000%

1# SPDX-FileCopyrightText: 2026 Marco Ricci <software@the13thletter.info> 

2# 

3# SPDX-License-Identifier: Zlib 

4 

5 

6"""Command-line machinery for derivepassphrase. 

7 

8Warning: 

9 Non-public module (implementation detail), provided for didactical and 

10 educational purposes only. Subject to change without notice, including 

11 removal. 

12 

13""" 

14 

15from __future__ import annotations (empty)

16 

17import collections (empty)

18import importlib.metadata (empty)

19import inspect (empty)

20import logging (empty)

21import warnings (empty)

22from typing import TYPE_CHECKING, Callable, Literal, TextIO, TypeVar (empty)

23 

24import click (empty)

25import click.shell_completion (empty)

26from typing_extensions import Any, ParamSpec, override (empty)

27 

28from derivepassphrase import _internals, _types (empty)

29from derivepassphrase._internals import cli_messages as _msg (empty)

30 

31if TYPE_CHECKING: (empty)

32 import types 

33 from collections.abc import ( 

34 MutableSequence, 

35 ) 

36 

37 from typing_extensions import Self 

38 

39PROG_NAME = _internals.PROG_NAME (empty)

40VERSION = _internals.VERSION (empty)

41VERSION_OUTPUT_WRAPPING_WIDTH = 72 (empty)

42 

43# Error messages 

44NOT_AN_INTEGER = "not an integer" (empty)

45NOT_A_NONNEGATIVE_INTEGER = "not a non-negative integer" (empty)

46NOT_A_POSITIVE_INTEGER = "not a positive integer" (empty)

47 

48 

49# Logging 

50# ======= 

51 

52 

53class ClickEchoStderrHandler(logging.Handler): (empty)

54 """A [`logging.Handler`][] for `click` applications. 

55 

56 Outputs log messages to [`sys.stderr`][] via [`click.echo`][]. 

57 

58 """ 

59 

60 def emit(self, record: logging.LogRecord) -> None: (empty)

61 """Emit a log record. 

62 

63 Format the log record, then emit it via [`click.echo`][] to 

64 [`sys.stderr`][]. 

65 

66 """ 

67 click.echo( 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

68 self.format(record), 

69 err=True, 

70 color=getattr(record, "color", None), 

71 ) 

72 

73 

74class CLIofPackageFormatter(logging.Formatter): (empty)

75 """A [`logging.LogRecord`][] formatter for the CLI of a Python package. 

76 

77 Assuming a package `PKG` and loggers within the same hierarchy 

78 `PKG`, format all log records from that hierarchy for proper user 

79 feedback on the console. Intended for use with [`click`][CLICK] and 

80 when `PKG` provides a command-line tool `PKG` and when logs from 

81 that package should show up as output of the command-line tool. 

82 

83 Essentially, this prepends certain short strings to the log message 

84 lines to make them readable as standard error output. 

85 

86 Because this log output is intended to be displayed on standard 

87 error as high-level diagnostic output, you are strongly discouraged 

88 from changing the output format to include more tokens besides the 

89 log message. Use a dedicated log file handler instead, without this 

90 formatter. 

91 

92 [CLICK]: https://pypi.org/projects/click/ 

93 

94 """ 

95 

96 def __init__( (empty)

97 self, 

98 *, 

99 prog_name: str = PROG_NAME, 

100 package_name: str | None = None, 

101 ) -> None: 

102 self.prog_name = prog_name (empty)

103 self.package_name = ( (empty)

104 package_name 

105 if package_name is not None 

106 else prog_name.lower().replace(" ", "_").replace("-", "_") 

107 ) 

108 

109 def format(self, record: logging.LogRecord) -> str: (empty)

110 """Format a log record suitably for standard error console output. 

111 

112 Prepend the formatted string `"PROG_NAME: LABEL"` to each line 

113 of the message, where `PROG_NAME` is the program name, and 

114 `LABEL` depends on the record's level and on the logger name as 

115 follows: 

116 

117 * For records at level [`logging.DEBUG`][], `LABEL` is 

118 `"Debug: "`. 

119 * For records at level [`logging.INFO`][], `LABEL` is the 

120 empty string. 

121 * For records at level [`logging.WARNING`][], `LABEL` is 

122 `"Deprecation warning: "` if the logger is named 

123 `PKG.deprecation` (where `PKG` is the package name), else 

124 `"Warning: "`. 

125 * For records at level [`logging.ERROR`][] and 

126 [`logging.CRITICAL`][] `"Error: "`, `LABEL` is the empty 

127 string. 

128 

129 The level indication strings at level `WARNING` or above are 

130 highlighted. Use [`click.echo`][] to output them and remove 

131 color output if necessary. 

132 

133 Args: 

134 record: A log record. 

135 

136 Returns: 

137 A formatted log record. 

138 

139 Raises: 

140 AssertionError: 

141 The log level is not supported. 

142 

143 """ 

144 preliminary_result = record.getMessage() 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

145 prefix = f"{self.prog_name}: " 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

146 if record.levelname == "DEBUG": # pragma: no cover [unused] 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

147 level_indicator = "Debug: " 

148 elif record.levelname == "INFO": 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

149 level_indicator = "" 1 ctx1G

150 elif record.levelname == "WARNING": 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

151 level_indicator = ( 24 ctx2i E x n j w h p G U fb= k V l W q X Y Z 0 1 C 2

152 f"{click.style('Deprecation warning', bold=True)}: " 

153 if record.name.endswith(".deprecation") 

154 else f"{click.style('Warning', bold=True)}: " 

155 ) 

156 elif record.levelname in {"ERROR", "CRITICAL"}: 24 ctx1DxyFHzIJKLMNOPQRorSsABTC

157 level_indicator = "" 24 ctx1DxyFHzIJKLMNOPQRorSsABTC

158 else: # pragma: no cover [failsafe] 

159 msg = f"Unsupported logging level: {record.levelname}" 

160 raise AssertionError(msg) 

161 parts = [ 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

162 "".join( 

163 prefix + level_indicator + line 

164 for line in preliminary_result.splitlines(True) # noqa: FBT003 

165 ) 

166 ] 

167 if record.exc_info: 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

168 parts.append(self.formatException(record.exc_info) + "\n") 5 ctx1yzoAB

169 return "".join(parts) 46 ctx2i D E x y F n j w h p G U fb= k V l W q H X z I J K L M N Y O P Q R o r S s A B Z 0 T 1 C 2

170 

171 

172class StandardCLILogging: (empty)

173 """Set up CLI logging handlers upon instantiation.""" 

174 

175 prog_name = PROG_NAME (empty)

176 package_name = PROG_NAME.lower().replace(" ", "_").replace("-", "_") (empty)

177 cli_formatter = CLIofPackageFormatter( (empty)

178 prog_name=prog_name, package_name=package_name 

179 ) 

180 cli_handler = ClickEchoStderrHandler() (empty)

181 cli_handler.addFilter(logging.Filter(name=package_name)) (empty)

182 cli_handler.setFormatter(cli_formatter) (empty)

183 cli_handler.setLevel(logging.WARNING) (empty)

184 warnings_handler = ClickEchoStderrHandler() (empty)

185 warnings_handler.addFilter(logging.Filter(name="py.warnings")) (empty)

186 warnings_handler.setFormatter(cli_formatter) (empty)

187 warnings_handler.setLevel(logging.WARNING) (empty)

188 

189 @classmethod (empty)

190 def ensure_standard_logging(cls) -> StandardLoggingContextManager: (empty)

191 """Return a context manager to ensure standard logging is set up.""" 

192 return StandardLoggingContextManager( 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb$ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

193 handler=cls.cli_handler, 

194 root_logger=cls.package_name, 

195 ) 

196 

197 @classmethod (empty)

198 def ensure_standard_warnings_logging( (empty)

199 cls, 

200 ) -> StandardWarningsLoggingContextManager: 

201 """Return a context manager to ensure warnings logging is set up.""" 

202 return StandardWarningsLoggingContextManager( 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

203 handler=cls.warnings_handler, 

204 ) 

205 

206 

207class StandardLoggingContextManager: (empty)

208 """A reentrant context manager setting up standard CLI logging. 

209 

210 Ensures that the given handler (defaulting to the CLI logging 

211 handler) is added to the named logger (defaulting to the root 

212 logger), and if it had to be added, then that it will be removed 

213 upon exiting the context. 

214 

215 Reentrant, but not thread safe, because it temporarily modifies 

216 global state. 

217 

218 """ 

219 

220 def __init__( (empty)

221 self, 

222 handler: logging.Handler, 

223 root_logger: str | None = None, 

224 ) -> None: 

225 self.handler = handler 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

226 self.root_logger_name = root_logger 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

227 self.base_logger = logging.getLogger(self.root_logger_name) 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

228 self.action_required: MutableSequence[bool] = collections.deque() 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

229 

230 def __enter__(self) -> Self: (empty)

231 self.action_required.append( 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

232 self.handler not in self.base_logger.handlers 

233 ) 

234 if self.action_required[-1]: 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

235 self.base_logger.addHandler(self.handler) 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

236 return self 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

237 

238 def __exit__( (empty)

239 self, 

240 exc_type: type[BaseException] | None, 

241 exc_value: BaseException | None, 

242 exc_tb: types.TracebackType | None, 

243 ) -> Literal[False]: 

244 if self.action_required[-1]: 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

245 self.base_logger.removeHandler(self.handler) 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

246 self.action_required.pop() 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

247 return False 89 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcbfb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

248 

249 

250class StandardWarningsLoggingContextManager(StandardLoggingContextManager): (empty)

251 """A reentrant context manager setting up standard warnings logging. 

252 

253 Ensures that warnings are being diverted to the logging system, and 

254 that the given handler (defaulting to the CLI logging handler) is 

255 added to the warnings logger. If the handler had to be added, then 

256 it will be removed upon exiting the context. 

257 

258 Reentrant, but not thread safe, because it temporarily modifies 

259 global state. 

260 

261 """ 

262 

263 def __init__( (empty)

264 self, 

265 handler: logging.Handler, 

266 ) -> None: 

267 super().__init__(handler=handler, root_logger="py.warnings") 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

268 self.stack: MutableSequence[ 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

269 tuple[ 

270 Callable[ 

271 [ 

272 type[BaseException] | None, 

273 BaseException | None, 

274 types.TracebackType | None, 

275 ], 

276 None, 

277 ], 

278 Callable[ 

279 [ 

280 str | Warning, 

281 type[Warning], 

282 str, 

283 int, 

284 TextIO | None, 

285 str | None, 

286 ], 

287 None, 

288 ], 

289 ] 

290 ] = collections.deque() 

291 

292 def __enter__(self) -> Self: (empty)

293 def showwarning( # noqa: PLR0913,PLR0917 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

294 message: str | Warning, 

295 category: type[Warning], 

296 filename: str, 

297 lineno: int, 

298 file: TextIO | None = None, 

299 line: str | None = None, 

300 ) -> None: 

301 if file is not None: # pragma: no cover [external-api] 2 ctx1i=

302 self.stack[0][1]( 

303 message, category, filename, lineno, file, line 

304 ) 

305 else: 

306 logging.getLogger("py.warnings").warning( 2 ctx1i=

307 str( 

308 warnings.formatwarning( 

309 message, category, filename, lineno, line 

310 ) 

311 ) 

312 ) 

313 

314 ctx = warnings.catch_warnings() 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

315 exit_func = ctx.__exit__ 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

316 ctx.__enter__() 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

317 self.stack.append((exit_func, warnings.showwarning)) 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

318 warnings.showwarning = showwarning 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

319 return super().__enter__() 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

320 

321 def __exit__( (empty)

322 self, 

323 exc_type: type[BaseException] | None, 

324 exc_value: BaseException | None, 

325 exc_tb: types.TracebackType | None, 

326 ) -> Literal[False]: 

327 ret = super().__exit__(exc_type, exc_value, exc_tb) 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

328 val = self.stack.pop()[0](exc_type, exc_value, exc_tb) 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

329 assert not val 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

330 return ret 88 ctx2i D E x y F n a c m f g e _ ` 5 j 3 w h p G U { | } ~ abbbcb= $ dbk V l W eb7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2

331 

332 

333P = ParamSpec("P") (empty)

334R = TypeVar("R") (empty)

335 

336 

337def adjust_logging_level( (empty)

338 ctx: click.Context, 

339 /, 

340 param: click.Parameter | None = None, 

341 value: int | None = None, 

342) -> None: 

343 """Change the logs that are emitted to standard error. 

344 

345 This modifies the [`StandardCLILogging`][] settings such that log 

346 records at the respective level are emitted, based on the `param` 

347 and the `value`. 

348 

349 """ 

350 # Note: If multiple options use this callback, then we will be 

351 # called multiple times. Ensure the runs are idempotent. 

352 if param is None or value is None or ctx.resilient_parsing: 88 ctx2b i D E x y F n a c f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 q t ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobpb

353 return 87 ctx2b i D x y F n a c f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 q t ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobpb

354 StandardCLILogging.cli_handler.setLevel(value) 1 ctx1E

355 logging.getLogger(StandardCLILogging.package_name).setLevel(value) 1 ctx1E

356 

357 

358# Option parsing and grouping 

359# =========================== 

360 

361 

362class OptionGroupOption(click.Option): (empty)

363 """A [`click.Option`][] with an associated group name and group epilog. 

364 

365 Used by [`CommandWithHelpGroups`][] to print help sections. Each 

366 subclass contains its own group name and epilog. 

367 

368 Attributes: 

369 option_group_name: 

370 The name of the option group. Used as a heading on the help 

371 text for options in this section. 

372 epilog: 

373 An epilog to print after listing the options in this 

374 section. 

375 

376 """ 

377 

378 option_group_name: object = "" (empty)

379 """""" (empty)

380 epilog: object = "" (empty)

381 """""" (empty)

382 

383 def __init__(self, *args: Any, **kwargs: Any) -> None: # noqa: ANN401 (empty)

384 if self.__class__ == __class__: # type: ignore[name-defined] 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

385 raise NotImplementedError 

386 # Though click 8.1 mostly defers help text processing until the 

387 # `BaseCommand.format_*` methods are called, the Option 

388 # constructor still preprocesses the help text, and asserts that 

389 # the help text is a string. Work around this by removing the 

390 # help text from the constructor arguments and re-adding it, 

391 # unprocessed, after constructor finishes. 

392 unset = object() 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

393 help = kwargs.pop("help", unset) # noqa: A001 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

394 super().__init__(*args, **kwargs) 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

395 if help is not unset: # pragma: no branch 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

396 self.help = help 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

397 

398 

399class StandardOption(OptionGroupOption): (empty)

400 pass (empty)

401 

402 

403# Portions of this class are based directly on code from click 8.1. 

404# (This does not in general include docstrings, unless otherwise noted.) 

405# They are subject to the 3-clause BSD license in the following 

406# paragraphs. Modifications to their code are marked with respective 

407# comments; they too are released under the same license below. The 

408# original code did not contain any "noqa" or "pragma" comments. 

409# 

410# Copyright 2024 Pallets 

411# 

412# Redistribution and use in source and binary forms, with or 

413# without modification, are permitted provided that the 

414# following conditions are met: 

415# 

416# 1. Redistributions of source code must retain the above 

417# copyright notice, this list of conditions and the 

418# following disclaimer. 

419# 

420# 2. Redistributions in binary form must reproduce the above 

421# copyright notice, this list of conditions and the 

422# following disclaimer in the documentation and/or other 

423# materials provided with the distribution. 

424# 

425# 3. Neither the name of the copyright holder nor the names 

426# of its contributors may be used to endorse or promote 

427# products derived from this software without specific 

428# prior written permission. 

429# 

430# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 

431# CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, 

432# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 

433# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 

434# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 

435# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

436# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 

437# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 

438# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 

439# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

440# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 

441# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 

442# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

443class CommandWithHelpGroups(click.Command): (empty)

444 """A [`click.Command`][] with support for some help text customizations. 

445 

446 Supports help/option groups, group epilogs, and help text objects 

447 (objects that stringify to help texts). The latter is primarily 

448 used to implement translations. 

449 

450 Inspired by [a comment on `pallets/click#373`][CLICK_ISSUE] for 

451 help/option group support, and further modified to include group 

452 epilogs and help text objects. 

453 

454 [CLICK_ISSUE]: https://github.com/pallets/click/issues/373#issuecomment-515293746 

455 

456 """ 

457 

458 @staticmethod (empty)

459 def _text(text: object, /) -> str: (empty)

460 if isinstance(text, (list, tuple)): 4 ctx1ac^d

461 return "\n\n".join(str(x) for x in text) 4 ctx1ac^d

462 return str(text) 3 ctx1acd

463 

464 # This method is based on click 8.1; see the comment above the class 

465 # declaration for license details. 

466 def collect_usage_pieces(self, ctx: click.Context) -> list[str]: (empty)

467 """Return the pieces for the usage string. 

468 

469 Args: 

470 ctx: 

471 The click context. 

472 

473 """ 

474 rv = [str(self.options_metavar)] if self.options_metavar else [] 13 ctx2a c w p d t u ! # v 4 s gb

475 for param in self.get_params(ctx): 13 ctx2a c w p d t u ! # v 4 s gb

476 rv.extend(str(x) for x in param.get_usage_pieces(ctx)) 13 ctx2a c w p d t u ! # v 4 s gb

477 return rv 13 ctx2a c w p d t u ! # v 4 s gb

478 

479 # This method is based on click 8.1; see the comment above the class 

480 # declaration for license details. 

481 def get_help_option( (empty)

482 self, 

483 ctx: click.Context, 

484 ) -> click.Option | None: 

485 """Return a standard help option object. 

486 

487 Args: 

488 ctx: 

489 The click context. 

490 

491 """ 

492 help_options = self.get_help_option_names(ctx) 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

493 

494 if ( 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

495 not help_options or not self.add_help_option 

496 ): # pragma: no cover [external-api] 

497 return None 

498 

499 def show_help( 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

500 ctx: click.Context, 

501 param: click.Parameter, # noqa: ARG001 

502 value: str, 

503 ) -> None: 

504 if value and not ctx.resilient_parsing: 91 ctx2b i D E x y F n a c f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

505 click.echo(ctx.get_help(), color=ctx.color) 3 ctx1acd

506 ctx.exit() 3 ctx1acd

507 

508 # Modified from click 8.1: We use StandardOption and a non-str 

509 # object as the help string. 

510 return StandardOption( 92 ctx2b i D E x y F n a c m f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

511 help_options, 

512 is_flag=True, 

513 is_eager=True, 

514 expose_value=False, 

515 callback=show_help, 

516 help=_msg.TranslatedString(_msg.Label.HELP_OPTION_HELP_TEXT), 

517 ) 

518 

519 # This method is based on click 8.1; see the comment above the class 

520 # declaration for license details. 

521 def get_short_help_str( (empty)

522 self, 

523 limit: int = 45, 

524 ) -> str: 

525 """Return the short help string for a command. 

526 

527 If only a long help string is given, shorten it. 

528 

529 Args: 

530 limit: 

531 The maximum width of the short help string. 

532 

533 """ 

534 # Modification against click 8.1: Call `_text()` on `self.help` 

535 # to allow help texts to be general objects, not just strings. 

536 # Used to implement translatable strings, as objects that 

537 # stringify to the translation. 

538 if self.short_help: # pragma: no cover [external-api] 3 ctx1ac^

539 text = inspect.cleandoc(self._text(self.short_help)) 

540 elif self.help: 3 ctx1ac^

541 text = click.utils.make_default_short_help( 3 ctx1ac^

542 self._text(self.help), limit 

543 ) 

544 else: # pragma: no cover [external-api] 

545 text = "" 

546 if self.deprecated: # pragma: no cover [external-api] 3 ctx1ac^

547 # Modification against click 8.1: The translated string is 

548 # looked up in the derivepassphrase message domain, not the 

549 # gettext default domain. 

550 text = str( 

551 _msg.TranslatedString(_msg.Label.DEPRECATED_COMMAND_LABEL) 

552 ).format(text=text) 

553 return text.strip() 3 ctx1ac^

554 

555 # This method is based on click 8.1; see the comment above the class 

556 # declaration for license details. 

557 def format_help_text( (empty)

558 self, 

559 ctx: click.Context, 

560 formatter: click.HelpFormatter, 

561 ) -> None: 

562 """Format the help text prologue, if any. 

563 

564 Args: 

565 ctx: 

566 The click context. 

567 formatter: 

568 The formatter for the `--help` listing. 

569 

570 """ 

571 del ctx 3 ctx1acd

572 # Modification against click 8.1: Call `_text()` on `self.help` 

573 # to allow help texts to be general objects, not just strings. 

574 # Used to implement translatable strings, as objects that 

575 # stringify to the translation. 

576 text = ( 3 ctx1acd

577 inspect.cleandoc(self._text(self.help).partition("\f")[0]) 

578 if self.help is not None 

579 else "" 

580 ) 

581 if self.deprecated: # pragma: no cover [external-api] 3 ctx1acd

582 # Modification against click 8.1: The translated string is 

583 # looked up in the derivepassphrase message domain, not the 

584 # gettext default domain. 

585 text = str( 

586 _msg.TranslatedString(_msg.Label.DEPRECATED_COMMAND_LABEL) 

587 ).format(text=text) 

588 if text: # pragma: no branch 3 ctx1acd

589 formatter.write_paragraph() 3 ctx1acd

590 with formatter.indentation(): 3 ctx1acd

591 formatter.write_text(text) 3 ctx1acd

592 

593 # This method is based on click 8.1; see the comment above the class 

594 # declaration for license details. Consider the whole section 

595 # marked as modified; the code modifications are too numerous to 

596 # mark individually. 

597 def format_options( (empty)

598 self, 

599 ctx: click.Context, 

600 formatter: click.HelpFormatter, 

601 ) -> None: 

602 r"""Format options on the help listing, grouped into sections. 

603 

604 This is a callback for [`click.Command.get_help`][] that 

605 implements the `--help` listing, by calling appropriate methods 

606 of the `formatter`. We list all options (like the base 

607 implementation), but grouped into sections according to the 

608 concrete [`click.Option`][] subclass being used. If the option 

609 is an instance of some subclass of [`OptionGroupOption`][], then 

610 the section heading and the epilog are taken from the 

611 [`option_group_name`] [OptionGroupOption.option_group_name] and 

612 [`epilog`] [OptionGroupOption.epilog] attributes; otherwise, the 

613 section heading is "Options" (or "Other options" if there are 

614 other option groups) and the epilog is empty. 

615 

616 We unconditionally call [`format_commands`][], and rely on it to 

617 act as a no-op if we aren't actually a [`click.MultiCommand`][]. 

618 

619 Args: 

620 ctx: 

621 The click context. 

622 formatter: 

623 The formatter for the `--help` listing. 

624 

625 """ 

626 default_group_name = "" 3 ctx1acd

627 help_records: dict[str, list[tuple[str, str]]] = {} 3 ctx1acd

628 epilogs: dict[str, str] = {} 3 ctx1acd

629 params = self.params[:] 3 ctx1acd

630 if ( # pragma: no branch 3 ctx1acd

631 (help_opt := self.get_help_option(ctx)) is not None 

632 and help_opt not in params 

633 ): 

634 params.append(help_opt) 3 ctx1acd

635 for param in params: 3 ctx1acd

636 rec = param.get_help_record(ctx) 3 ctx1acd

637 if rec is not None: 3 ctx1acd

638 rec = (rec[0], self._text(rec[1])) 3 ctx1acd

639 if isinstance(param, OptionGroupOption): 3 ctx1acd

640 group_name = self._text(param.option_group_name) 3 ctx1acd

641 epilogs.setdefault(group_name, self._text(param.epilog)) 3 ctx1acd

642 else: # pragma: no cover [external-api] 

643 group_name = default_group_name 

644 help_records.setdefault(group_name, []).append(rec) 3 ctx1acd

645 if default_group_name in help_records: # pragma: no branch 3 ctx1acd

646 default_group = help_records.pop(default_group_name) 3 ctx1acd

647 default_group_label = ( 3 ctx1acd

648 _msg.Label.OTHER_OPTIONS_LABEL 

649 if len(default_group) > 1 

650 else _msg.Label.OPTIONS_LABEL 

651 ) 

652 default_group_name = self._text( 3 ctx1acd

653 _msg.TranslatedString(default_group_label) 

654 ) 

655 help_records[default_group_name] = default_group 3 ctx1acd

656 for group_name, records in help_records.items(): 3 ctx1acd

657 with formatter.section(group_name): 3 ctx1acd

658 formatter.write_dl(records) 3 ctx1acd

659 epilog = inspect.cleandoc(epilogs.get(group_name, "")) 3 ctx1acd

660 if epilog: 3 ctx1acd

661 formatter.write_paragraph() 3 ctx1acd

662 with formatter.indentation(): 3 ctx1acd

663 formatter.write_text(epilog) 3 ctx1acd

664 self.format_commands(ctx, formatter) 3 ctx1acd

665 

666 # This method is based on click 8.1; see the comment above the class 

667 # declaration for license details. Consider the whole section 

668 # marked as modified; the code modifications are too numerous to 

669 # mark individually. 

670 def format_commands( (empty)

671 self, 

672 ctx: click.Context, 

673 formatter: click.HelpFormatter, 

674 ) -> None: 

675 """Format the subcommands, if any. 

676 

677 If called on a command object that isn't derived from 

678 [`click.Group`][], then do nothing. 

679 

680 Args: 

681 ctx: 

682 The click context. 

683 formatter: 

684 The formatter for the `--help` listing. 

685 

686 """ 

687 if not isinstance(self, click.Group): 3 ctx1acd

688 return 3 ctx1acd

689 commands: list[tuple[str, click.Command]] = [] 2 ctx1ac

690 for subcommand in self.list_commands(ctx): 2 ctx1ac

691 cmd = self.get_command(ctx, subcommand) 2 ctx1ac

692 if cmd is None or cmd.hidden: # pragma: no cover [external-api] 2 ctx1ac

693 continue 

694 commands.append((subcommand, cmd)) 2 ctx1ac

695 if commands: # pragma: no branch 2 ctx1ac

696 longest_command = max((cmd[0] for cmd in commands), key=len) 2 ctx1ac

697 limit = formatter.width - 6 - len(longest_command) 2 ctx1ac

698 rows: list[tuple[str, str]] = [] 2 ctx1ac

699 for subcommand, cmd in commands: 2 ctx1ac

700 help_str = self._text(cmd.get_short_help_str(limit) or "") 2 ctx1ac

701 rows.append((subcommand, help_str)) 2 ctx1ac

702 if rows: # pragma: no branch 2 ctx1ac

703 commands_label = self._text( 2 ctx1ac

704 _msg.TranslatedString(_msg.Label.COMMANDS_LABEL) 

705 ) 

706 with formatter.section(commands_label): 2 ctx1ac

707 formatter.write_dl(rows) 2 ctx1ac

708 

709 # This method is based on click 8.1; see the comment above the class 

710 # declaration for license details. 

711 def format_epilog( (empty)

712 self, 

713 ctx: click.Context, 

714 formatter: click.HelpFormatter, 

715 ) -> None: 

716 """Format the epilog, if any. 

717 

718 Args: 

719 ctx: 

720 The click context. 

721 formatter: 

722 The formatter for the `--help` listing. 

723 

724 """ 

725 del ctx 3 ctx1acd

726 if self.epilog: # pragma: no branch 3 ctx1acd

727 # Modification against click 8.1: Call `str()` on 

728 # `self.epilog` to allow help texts to be general objects, 

729 # not just strings. Used to implement translatable strings, 

730 # as objects that stringify to the translation. 

731 epilog = inspect.cleandoc(self._text(self.epilog)) 3 ctx1acd

732 formatter.write_paragraph() 3 ctx1acd

733 with formatter.indentation(): 3 ctx1acd

734 formatter.write_text(epilog) 3 ctx1acd

735 

736 

737# Portions of this class are based directly on code from click 8.1. 

738# (This does not in general include docstrings, unless otherwise noted.) 

739# They are subject to the 3-clause BSD license in the following 

740# paragraphs. Modifications to their code are marked with respective 

741# comments; they too are released under the same license below. The 

742# original code did not contain any "noqa" or "pragma" comments. 

743# 

744# Copyright 2024 Pallets 

745# 

746# Redistribution and use in source and binary forms, with or 

747# without modification, are permitted provided that the 

748# following conditions are met: 

749# 

750# 1. Redistributions of source code must retain the above 

751# copyright notice, this list of conditions and the 

752# following disclaimer. 

753# 

754# 2. Redistributions in binary form must reproduce the above 

755# copyright notice, this list of conditions and the 

756# following disclaimer in the documentation and/or other 

757# materials provided with the distribution. 

758# 

759# 3. Neither the name of the copyright holder nor the names 

760# of its contributors may be used to endorse or promote 

761# products derived from this software without specific 

762# prior written permission. 

763# 

764# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 

765# CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, 

766# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 

767# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 

768# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 

769# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

770# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 

771# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 

772# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 

773# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

774# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 

775# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 

776# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

777# 

778# TODO(the-13th-letter): Remove this class and license block in v1.0. 

779# https://the13thletter.info/derivepassphrase/latest/upgrade-notes/#v1.0-implied-subcommands 

780class DefaultToVaultGroup(CommandWithHelpGroups, click.Group): (empty)

781 """A helper class to implement the default-to-"vault"-subcommand behavior. 

782 

783 Modifies internal [`click.MultiCommand`][] methods, and thus is both 

784 an implementation detail and a kludge. 

785 

786 """ 

787 

788 def resolve_command( (empty)

789 self, ctx: click.Context, args: list[str] 

790 ) -> tuple[str | None, click.Command | None, list[str]]: 

791 """Resolve a command, defaulting to "vault" instead of erroring out.""" # noqa: DOC201 

792 cmd_name = click.utils.make_str(args[0]) 16 ctx1nacfge?@5j3^w]h6

793 

794 # Get the command 

795 cmd = self.get_command(ctx, cmd_name) 16 ctx1nacfge?@5j3^w]h6

796 

797 # If we can't find the command but there is a normalization 

798 # function available, we try with that one. 

799 if ( # pragma: no cover [external-api] 16 ctx1nacfge?@5j3^w]h6

800 cmd is None and ctx.token_normalize_func is not None 

801 ): 

802 cmd_name = ctx.token_normalize_func(cmd_name) 

803 cmd = self.get_command(ctx, cmd_name) 

804 

805 # If we don't find the command we want to show an error message 

806 # to the user that it was not provided. However, there is 

807 # something else we should do: if the first argument looks like 

808 # an option we want to kick off parsing again for arguments to 

809 # resolve things like --help which now should go to the main 

810 # place. 

811 if cmd is None and not ctx.resilient_parsing: 16 ctx1nacfge?@5j3^w]h6

812 #### 

813 # BEGIN modifications for derivepassphrase 

814 # 

815 # Instead of using 

816 # 

817 # if click.parsers.split_opt(cmd_name)[0] 

818 # 

819 # which splits the option prefix (typically `-` or `--`) from 

820 # the option name, but triggers deprecation warnings in click 

821 # 8.2.0 and later, we check directly for a `-` prefix. 

822 # 

823 # END modifications for derivepassphrase 

824 #### 

825 if cmd_name.startswith("-"): 2 ctx1]h

826 self.parse_args(ctx, ctx.args) 1 ctx1h

827 #### 

828 # BEGIN modifications for derivepassphrase 

829 # 

830 # Instead of calling ctx.fail here, default to "vault", and 

831 # issue a deprecation warning. 

832 deprecation = logging.getLogger(f"{PROG_NAME}.deprecation") 2 ctx1]h

833 deprecation.warning( 2 ctx1]h

834 _msg.TranslatedString( 

835 _msg.WarnMsgTemplate.V10_SUBCOMMAND_REQUIRED 

836 ) 

837 ) 

838 cmd_name = "vault" 2 ctx1]h

839 cmd = self.get_command(ctx, cmd_name) 2 ctx1]h

840 assert cmd is not None, 'Mandatory subcommand "vault" missing!' 2 ctx1]h

841 args = [cmd_name, *args] 2 ctx1]h

842 # 

843 # END modifications for derivepassphrase 

844 #### 

845 return cmd_name if cmd else None, cmd, args[1:] 16 ctx1nacfge?@5j3^w]h6

846 

847 

848# TODO(the-13th-letter): Base this class on CommandWithHelpGroups and 

849# click.Group in v1.0. 

850# https://the13thletter.info/derivepassphrase/latest/upgrade-notes/#v1.0-implied-subcommands 

851class TopLevelCLIEntryPoint(DefaultToVaultGroup): (empty)

852 """A minor variation of DefaultToVaultGroup for the top-level command. 

853 

854 When called as a function, this sets up the environment properly 

855 before invoking the actual callbacks. Currently, this means setting 

856 up the logging subsystem and the delegation of Python warnings to 

857 the logging subsystem. 

858 

859 The environment setup can be bypassed by calling the `.main` method 

860 directly. 

861 

862 """ 

863 

864 def __call__( # pragma: no cover [external-api] (empty)

865 self, 

866 *args: Any, # noqa: ANN401 (empty)

867 **kwargs: Any, # noqa: ANN401 (empty)

868 ) -> Any: # noqa: ANN401 (empty)

869 """""" # noqa: D419 

870 # Coverage testing is done with the `click.testing` module, 

871 # which does not use the `__call__` shortcut. So it is normal 

872 # that this function is never called, and thus should be 

873 # excluded from coverage. 

874 with ( 

875 StandardCLILogging.ensure_standard_logging(), 

876 StandardCLILogging.ensure_standard_warnings_logging(), 

877 ): 

878 return self.main(*args, **kwargs) 

879 

880 

881# Actual option groups and callbacks used by derivepassphrase 

882# =========================================================== 

883 

884 

885def color_forcing_callback( (empty)

886 ctx: click.Context, 

887 param: click.Parameter, 

888 value: Any, # noqa: ANN401 

889) -> None: 

890 """Disable automatic color (and text highlighting). 

891 

892 Ideally, we would default to color and text styling if outputting to 

893 a TTY, or monochrome/unstyled otherwise. We would also support the 

894 `NO_COLOR` and `FORCE_COLOR` environment variables to override this 

895 auto-detection, and perhaps the `TTY_COMPATIBLE` variable too. 

896 

897 Alas, this is not sensible to support at the moment, because the 

898 conventions are still in flux. And settling on a specific 

899 interpretation of the conventions would likely prove very difficult 

900 to change later on in a backward-compatible way. We thus opt for 

901 a conservative approach and use device-indepedendent text output 

902 without any color or text styling whatsoever. 

903 

904 """ 

905 del param, value 91 ctx2b i D E x y F n a c f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

906 ctx.color = False 91 ctx2b i D E x y F n a c f g e ? @ 5 j 3 ^ w ] h p G U $ [ k V l W 7 8 d q t u ! # v % ' ( H ) * X + , z I J K 6 - L M N Y O P Q R o r S 4 s A B . Z 0 9 T 1 C / : ; 2 hbibjbkblbmbnbobgbpb

907 

908 

909def validate_occurrence_constraint( (empty)

910 ctx: click.Context, 

911 param: click.Parameter,