Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/black/__init__.py: 18%

1import io 

2import json 

3import platform 

4import re 

5import sys 

6import tokenize 

7import traceback 

8from collections.abc import ( 

9 Collection, 

10 Generator, 

11 MutableMapping, 

12 Sequence, 

13) 

14from contextlib import nullcontext 

15from dataclasses import replace 

16from datetime import datetime, timezone 

17from enum import Enum 

18from json.decoder import JSONDecodeError 

19from pathlib import Path 

20from re import Pattern 

21from typing import Any 

22 

23import click 

24from click.core import ParameterSource 

25from mypy_extensions import mypyc_attr 

26from pathspec import GitIgnoreSpec 

27from pathspec.patterns.gitignore import GitIgnorePatternError 

28 

29from _black_version import version as __version__ 

30from black.cache import Cache 

31from black.comments import normalize_fmt_off 

32from black.const import ( 

33 DEFAULT_EXCLUDES, 

34 DEFAULT_INCLUDES, 

35 DEFAULT_LINE_LENGTH, 

36 STDIN_PLACEHOLDER, 

37) 

38from black.files import ( 

39 best_effort_relative_path, 

40 find_project_root, 

41 find_pyproject_toml, 

42 find_user_pyproject_toml, 

43 gen_python_files, 

44 get_gitignore, 

45 parse_pyproject_toml, 

46 path_is_excluded, 

47 resolves_outside_root_or_cannot_stat, 

48 wrap_stream_for_windows, 

49) 

50from black.handle_ipynb_magics import ( 

51 PYTHON_CELL_MAGICS, 

52 jupyter_dependencies_are_installed, 

53 mask_cell, 

54 put_trailing_semicolon_back, 

55 remove_trailing_semicolon, 

56 unmask_cell, 

57 validate_cell, 

58) 

59from black.linegen import LN, LineGenerator, transform_line 

60from black.lines import EmptyLineTracker, LinesBlock 

61from black.mode import FUTURE_FLAG_TO_FEATURE, VERSION_TO_FEATURES, Feature 

62from black.mode import Mode as Mode # re-exported 

63from black.mode import Preview, TargetVersion, supports_feature 

64from black.nodes import STARS, is_number_token, is_simple_decorator_expression, syms 

65from black.output import color_diff, diff, dump_to_file, err, ipynb_diff, out 

66from black.parsing import ( # noqa F401 

67 ASTSafetyError, 

68 InvalidInput, 

69 SourceASTParseError, 

70 lib2to3_parse, 

71 parse_ast, 

72 stringify_ast, 

73) 

74from black.ranges import ( 

75 adjusted_lines, 

76 convert_unchanged_lines, 

77 parse_line_ranges, 

78 sanitized_lines, 

79) 

80from black.report import Changed, NothingChanged, Report 

81from blib2to3.pgen2 import token 

82from blib2to3.pytree import Leaf, Node 

83 

84COMPILED = Path(__file__).suffix in (".pyd", ".so") 

85 

86# types 

87FileContent = str 

88Encoding = str 

89NewLine = str 

90 

91 

92class WriteBack(Enum): 

93 NO = 0 

94 YES = 1 

95 DIFF = 2 

96 CHECK = 3 

97 COLOR_DIFF = 4 

98 

99 @classmethod 

100 def from_configuration( 

101 cls, *, check: bool, diff: bool, color: bool = False 

102 ) -> "WriteBack": 

103 if check and not diff: 

104 return cls.CHECK 

105 

106 if diff and color: 

107 return cls.COLOR_DIFF 

108 

109 return cls.DIFF if diff else cls.YES 

110 

111 

112# Legacy name, left for integrations. 

113FileMode = Mode 

114 

115 

116def read_pyproject_toml( 

117 ctx: click.Context, param: click.Parameter | None, value: str | None 

118) -> str | None: 

119 """Inject Black configuration from "pyproject.toml" into defaults in `ctx`. 

120 

121 Returns the path to a successfully found and read configuration file, None 

122 otherwise. 

123 """ 

124 if not value: 

125 value = find_pyproject_toml( 

126 ctx.params.get("src", ()), ctx.params.get("stdin_filename", None) 

127 ) 

128 if value is None: 

129 return None 

130 

131 try: 

132 config = parse_pyproject_toml(value) 

133 except (OSError, ValueError) as e: 

134 raise click.FileError( 

135 filename=value, hint=f"Error reading configuration file: {e}" 

136 ) from None 

137 

138 if not config: 

139 return None 

140 else: 

141 spellcheck_pyproject_toml_keys(ctx, list(config), value) 

142 # Sanitize the values to be Click friendly. For more information please see: 

143 # https://github.com/psf/black/issues/1458 

144 # https://github.com/pallets/click/issues/1567 

145 config = { 

146 k: str(v) if not isinstance(v, (list, dict)) else v 

147 for k, v in config.items() 

148 } 

149 

150 target_version = config.get("target_version") 

151 if target_version is not None and not isinstance(target_version, list): 

152 raise click.BadOptionUsage( 

153 "target-version", "Config key target-version must be a list" 

154 ) 

155 

156 exclude = config.get("exclude") 

157 if exclude is not None and not isinstance(exclude, str): 

158 raise click.BadOptionUsage("exclude", "Config key exclude must be a string") 

159 

160 extend_exclude = config.get("extend_exclude") 

161 if extend_exclude is not None and not isinstance(extend_exclude, str): 

162 raise click.BadOptionUsage( 

163 "extend-exclude", "Config key extend-exclude must be a string" 

164 ) 

165 

166 line_ranges = config.get("line_ranges") 

167 if line_ranges is not None: 

168 raise click.BadOptionUsage( 

169 "line-ranges", "Cannot use line-ranges in the pyproject.toml file." 

170 ) 

171 

172 default_map: dict[str, Any] = {} 

173 if ctx.default_map: 

174 default_map.update(ctx.default_map) 

175 default_map.update(config) 

176 

177 ctx.default_map = default_map 

178 return value 

179 

180 

181def spellcheck_pyproject_toml_keys( 

182 ctx: click.Context, config_keys: list[str], config_file_path: str 

183) -> None: 

184 invalid_keys: list[str] = [] 

185 available_config_options = {param.name for param in ctx.command.params} 

186 invalid_keys = [key for key in config_keys if key not in available_config_options] 

187 if invalid_keys: 

188 keys_str = ", ".join(map(repr, invalid_keys)) 

189 out( 

190 f"Invalid config keys detected: {keys_str} (in {config_file_path})", 

191 fg="red", 

192 ) 

193 

194 

195def target_version_option_callback( 

196 c: click.Context, p: click.Option | click.Parameter, v: tuple[str, ...] 

197) -> list[TargetVersion]: 

198 """Compute the target versions from a --target-version flag. 

199 

200 This is its own function because mypy couldn't infer the type correctly 

201 when it was a lambda, causing mypyc trouble. 

202 """ 

203 return [TargetVersion[val.upper()] for val in v] 

204 

205 

206def _target_versions_exceed_runtime( 

207 target_versions: set[TargetVersion], 

208) -> bool: 

209 if not target_versions: 

210 return False 

211 max_target_minor = max(tv.value for tv in target_versions) 

212 return max_target_minor > sys.version_info[1] 

213 

214 

215def _version_mismatch_message(target_versions: set[TargetVersion]) -> str: 

216 max_target = max(target_versions, key=lambda tv: tv.value) 

217 runtime = f"{sys.version_info[0]}.{sys.version_info[1]}" 

218 return ( 

219 f"Python {runtime} cannot parse code formatted for" 

220 f" {max_target.pretty()}. To fix this: run Black with" 

221 f" {max_target.pretty()}, set --target-version to" 

222 f" py3{sys.version_info[1]}, or use --fast to skip the safety" 

223 " check." 

224 ) 

225 

226 

227def enable_unstable_feature_callback( 

228 c: click.Context, p: click.Option | click.Parameter, v: tuple[str, ...] 

229) -> list[Preview]: 

230 """Compute the features from an --enable-unstable-feature flag.""" 

231 return [Preview[val] for val in v] 

232 

233 

234def re_compile_maybe_verbose(regex: str) -> Pattern[str]: 

235 """Compile a regular expression string in `regex`. 

236 

237 If it contains newlines, use verbose mode. 

238 """ 

239 if "\n" in regex: 

240 regex = "(?x)" + regex 

241 compiled: Pattern[str] = re.compile(regex) 

242 return compiled 

243 

244 

245def validate_regex( 

246 ctx: click.Context, 

247 param: click.Parameter, 

248 value: str | None, 

249) -> Pattern[str] | None: 

250 try: 

251 return re_compile_maybe_verbose(value) if value is not None else None 

252 except re.error as e: 

253 raise click.BadParameter(f"Not a valid regular expression: {e}") from None 

254 

255 

256@click.command( 

257 context_settings={"help_option_names": ["-h", "--help"]}, 

258 # While Click does set this field automatically using the docstring, mypyc 

259 # (annoyingly) strips 'em so we need to set it here too. 

260 help="The uncompromising code formatter.", 

261) 

262@click.option("-c", "--code", type=str, help="Format the code passed in as a string.") 

263@click.option( 

264 "-l", 

265 "--line-length", 

266 type=int, 

267 default=DEFAULT_LINE_LENGTH, 

268 help="How many characters per line to allow.", 

269 show_default=True, 

270) 

271@click.option( 

272 "-t", 

273 "--target-version", 

274 type=click.Choice([v.name.lower() for v in TargetVersion]), 

275 callback=target_version_option_callback, 

276 multiple=True, 

277 help=( 

278 "Python versions that should be supported by Black's output. You should" 

279 " include all versions that your code supports. By default, Black will infer" 

280 " target versions from the project metadata in pyproject.toml. If this does" 

281 " not yield conclusive results, Black will use per-file auto-detection." 

282 ), 

283) 

284@click.option( 

285 "--pyi", 

286 is_flag=True, 

287 help=( 

288 "Format all input files like typing stubs regardless of file extension. This" 

289 " is useful when piping source on standard input." 

290 ), 

291) 

292@click.option( 

293 "--ipynb", 

294 is_flag=True, 

295 help=( 

296 "Format all input files like Jupyter Notebooks regardless of file extension." 

297 " This is useful when piping source on standard input." 

298 ), 

299) 

300@click.option( 

301 "--python-cell-magics", 

302 multiple=True, 

303 help=( 

304 "When processing Jupyter Notebooks, add the given magic to the list" 

305 f" of known python-magics ({', '.join(sorted(PYTHON_CELL_MAGICS))})." 

306 " Useful for formatting cells with custom python magics." 

307 ), 

308 default=[], 

309) 

310@click.option( 

311 "-x", 

312 "--skip-source-first-line", 

313 is_flag=True, 

314 help="Skip the first line of the source code.", 

315) 

316@click.option( 

317 "-S", 

318 "--skip-string-normalization", 

319 is_flag=True, 

320 help="Don't normalize string quotes or prefixes.", 

321) 

322@click.option( 

323 "-C", 

324 "--skip-magic-trailing-comma", 

325 is_flag=True, 

326 help="Don't use trailing commas as a reason to split lines.", 

327) 

328@click.option( 

329 "--preview", 

330 is_flag=True, 

331 help=( 

332 "Enable potentially disruptive style changes that may be added to Black's main" 

333 " functionality in the next major release." 

334 ), 

335) 

336@click.option( 

337 "--unstable", 

338 is_flag=True, 

339 help=( 

340 "Enable potentially disruptive style changes that have known bugs or are not" 

341 " currently expected to make it into the stable style Black's next major" 

342 " release. Implies --preview." 

343 ), 

344) 

345@click.option( 

346 "--enable-unstable-feature", 

347 type=click.Choice([v.name for v in Preview]), 

348 callback=enable_unstable_feature_callback, 

349 multiple=True, 

350 help=( 

351 "Enable specific features included in the `--unstable` style. Requires" 

352 " `--preview`. No compatibility guarantees are provided on the behavior" 

353 " or existence of any unstable features." 

354 ), 

355) 

356@click.option( 

357 "--check", 

358 is_flag=True, 

359 help=( 

360 "Don't write the files back, just return the status. Return code 0 means" 

361 " nothing would change. Return code 1 means some files would be reformatted." 

362 " Return code 123 means there was an internal error." 

363 ), 

364) 

365@click.option( 

366 "--diff", 

367 is_flag=True, 

368 help=( 

369 "Don't write the files back, just output a diff to indicate what changes" 

370 " Black would've made. They are printed to stdout so capturing them is simple." 

371 ), 

372) 

373@click.option( 

374 "--color/--no-color", 

375 is_flag=True, 

376 help="Show (or do not show) colored diff. Only applies when --diff is given.", 

377) 

378@click.option( 

379 "--line-ranges", 

380 multiple=True, 

381 metavar="START-END", 

382 help=( 

383 "When specified, Black will try its best to only format these lines. This" 

384 " option can be specified multiple times, and a union of the lines will be" 

385 " formatted. Each range must be specified as two integers connected by a `-`:" 

386 " `<START>-<END>`. The `<START>` and `<END>` integer indices are 1-based and" 

387 " inclusive on both ends." 

388 ), 

389 default=(), 

390) 

391@click.option( 

392 "--fast/--safe", 

393 is_flag=True, 

394 help=( 

395 "By default, Black performs an AST safety check after formatting your code." 

396 " The --fast flag turns off this check and the --safe flag explicitly enables" 

397 " it. [default: --safe]" 

398 ), 

399) 

400@click.option( 

401 "--required-version", 

402 type=str, 

403 help=( 

404 "Require a specific version of Black to be running. This is useful for" 

405 " ensuring that all contributors to your project are using the same" 

406 " version, because different versions of Black may format code a little" 

407 " differently. This option can be set in a configuration file for consistent" 

408 " results across environments." 

409 ), 

410) 

411@click.option( 

412 "--exclude", 

413 type=str, 

414 callback=validate_regex, 

415 help=( 

416 "A regular expression that matches files and directories that should be" 

417 " excluded on recursive searches. An empty value means no paths are excluded." 

418 " Use forward slashes for directories on all platforms (Windows, too)." 

419 " By default, Black also ignores all paths listed in .gitignore. Changing this" 

420 f" value will override all default exclusions. [default: {DEFAULT_EXCLUDES}]" 

421 ), 

422 show_default=False, 

423) 

424@click.option( 

425 "--extend-exclude", 

426 type=str, 

427 callback=validate_regex, 

428 help=( 

429 "Like --exclude, but adds additional files and directories on top of the" 

430 " default values instead of overriding them." 

431 ), 

432) 

433@click.option( 

434 "--force-exclude", 

435 type=str, 

436 callback=validate_regex, 

437 help=( 

438 "Like --exclude, but files and directories matching this regex will be excluded" 

439 " even when they are passed explicitly as arguments. This is useful when" 

440 " invoking Black programmatically on changed files, such as in a pre-commit" 

441 " hook or editor plugin." 

442 ), 

443) 

444@click.option( 

445 "--stdin-filename", 

446 type=str, 

447 is_eager=True, 

448 help=( 

449 "The name of the file when passing it through stdin. Useful to make sure Black" 

450 " will respect the --force-exclude option on some editors that rely on using" 

451 " stdin." 

452 ), 

453) 

454@click.option( 

455 "--include", 

456 type=str, 

457 default=DEFAULT_INCLUDES, 

458 callback=validate_regex, 

459 help=( 

460 "A regular expression that matches files and directories that should be" 

461 " included on recursive searches. An empty value means all files are included" 

462 " regardless of the name. Use forward slashes for directories on all platforms" 

463 " (Windows, too). Overrides all exclusions, including from .gitignore and" 

464 " command line options." 

465 ), 

466 show_default=True, 

467) 

468@click.option( 

469 "-W", 

470 "--workers", 

471 type=click.IntRange(min=1), 

472 default=None, 

473 help=( 

474 "When Black formats multiple files, it may use a process pool to speed up" 

475 " formatting. This option controls the number of parallel workers. This can" 

476 " also be specified via the BLACK_NUM_WORKERS environment variable. Defaults" 

477 " to the number of CPUs in the system." 

478 ), 

479) 

480@click.option( 

481 "-q", 

482 "--quiet", 

483 is_flag=True, 

484 help=( 

485 "Stop emitting all non-critical output. Error messages will still be emitted" 

486 " (which can silenced by 2>/dev/null)." 

487 ), 

488) 

489@click.option( 

490 "-v", 

491 "--verbose", 

492 is_flag=True, 

493 help=( 

494 "Emit messages about files that were not changed or were ignored due to" 

495 " exclusion patterns. If Black is using a configuration file, a message" 

496 " detailing which one it is using will be emitted." 

497 ), 

498) 

499@click.version_option( 

500 version=__version__, 

501 message=( 

502 f"%(prog)s, %(version)s (compiled: {'yes' if COMPILED else 'no'})\n" 

503 f"Python ({platform.python_implementation()}) {platform.python_version()}" 

504 ), 

505) 

506@click.argument( 

507 "src", 

508 nargs=-1, 

509 type=click.Path( 

510 exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True 

511 ), 

512 is_eager=True, 

513 metavar="SRC ...", 

514) 

515@click.option( 

516 "--config", 

517 type=click.Path( 

518 exists=True, 

519 file_okay=True, 

520 dir_okay=False, 

521 readable=True, 

522 allow_dash=False, 

523 path_type=str, 

524 ), 

525 is_eager=True, 

526 callback=read_pyproject_toml, 

527 help="Read configuration options from a configuration file.", 

528) 

529@click.option( 

530 "--no-cache", 

531 is_flag=True, 

532 help=( 

533 "Skip reading and writing the cache, forcing Black to reformat all" 

534 " included files." 

535 ), 

536) 

537@click.pass_context 

538def main( 

539 ctx: click.Context, 

540 code: str | None, 

541 line_length: int, 

542 target_version: list[TargetVersion], 

543 check: bool, 

544 diff: bool, 

545 line_ranges: Sequence[str], 

546 color: bool, 

547 fast: bool, 

548 pyi: bool, 

549 ipynb: bool, 

550 python_cell_magics: Sequence[str], 

551 skip_source_first_line: bool, 

552 skip_string_normalization: bool, 

553 skip_magic_trailing_comma: bool, 

554 preview: bool, 

555 unstable: bool, 

556 enable_unstable_feature: list[Preview], 

557 quiet: bool, 

558 verbose: bool, 

559 required_version: str | None, 

560 include: Pattern[str], 

561 exclude: Pattern[str] | None, 

562 extend_exclude: Pattern[str] | None, 

563 force_exclude: Pattern[str] | None, 

564 stdin_filename: str | None, 

565 workers: int | None, 

566 src: tuple[str, ...], 

567 config: str | None, 

568 no_cache: bool, 

569) -> None: 

570 """The uncompromising code formatter.""" 

571 ctx.ensure_object(dict) 

572 

573 assert sys.version_info >= (3, 10), "Black requires Python 3.10+" 

574 if sys.version_info[:3] == (3, 12, 5): 

575 out( 

576 "Python 3.12.5 has a memory safety issue that can cause Black's " 

577 "AST safety checks to fail. " 

578 "Please upgrade to Python 3.12.6 or downgrade to Python 3.12.4" 

579 ) 

580 ctx.exit(1) 

581 

582 if src and code is not None: 

583 out( 

584 main.get_usage(ctx) 

585 + "\n\n'SRC' and 'code' cannot be passed simultaneously." 

586 ) 

587 ctx.exit(1) 

588 if not src and code is None: 

589 out(main.get_usage(ctx) + "\n\nOne of 'SRC' or 'code' is required.") 

590 ctx.exit(1) 

591 

592 # It doesn't do anything if --unstable is also passed, so just allow it. 

593 if enable_unstable_feature and not (preview or unstable): 

594 out( 

595 main.get_usage(ctx) 

596 + "\n\n'--enable-unstable-feature' requires '--preview'." 

597 ) 

598 ctx.exit(1) 

599 

600 root, method = ( 

601 find_project_root(src, stdin_filename) if code is None else (None, None) 

602 ) 

603 ctx.obj["root"] = root 

604 

605 if verbose: 

606 if root: 

607 out( 

608 f"Identified `{root}` as project root containing a {method}.", 

609 fg="blue", 

610 ) 

611 

612 if config: 

613 config_source = ctx.get_parameter_source("config") 

614 user_level_config = str(find_user_pyproject_toml()) 

615 if config == user_level_config: 

616 out( 

617 "Using configuration from user-level config at " 

618 f"'{user_level_config}'.", 

619 fg="blue", 

620 ) 

621 elif config_source in ( 

622 ParameterSource.DEFAULT, 

623 ParameterSource.DEFAULT_MAP, 

624 ): 

625 out("Using configuration from project root.", fg="blue") 

626 else: 

627 out(f"Using configuration in '{config}'.", fg="blue") 

628 if ctx.default_map: 

629 for param, value in ctx.default_map.items(): 

630 out(f"{param}: {value}") 

631 

632 error_msg = "Oh no! 💥 💔 💥" 

633 if ( 

634 required_version 

635 and required_version != __version__ 

636 and required_version != __version__.split(".")[0] 

637 ): 

638 err( 

639 f"{error_msg} The required version `{required_version}` does not match" 

640 f" the running version `{__version__}`!" 

641 ) 

642 ctx.exit(1) 

643 if ipynb and pyi: 

644 err("Cannot pass both `pyi` and `ipynb` flags!") 

645 ctx.exit(1) 

646 

647 write_back = WriteBack.from_configuration(check=check, diff=diff, color=color) 

648 if target_version: 

649 versions = set(target_version) 

650 else: 

651 # We'll autodetect later. 

652 versions = set() 

653 mode = Mode( 

654 target_versions=versions, 

655 line_length=line_length, 

656 is_pyi=pyi, 

657 is_ipynb=ipynb, 

658 skip_source_first_line=skip_source_first_line, 

659 string_normalization=not skip_string_normalization, 

660 magic_trailing_comma=not skip_magic_trailing_comma, 

661 preview=preview, 

662 unstable=unstable, 

663 python_cell_magics=set(python_cell_magics), 

664 enabled_features=set(enable_unstable_feature), 

665 ) 

666 

667 if not fast and _target_versions_exceed_runtime(versions): 

668 err( 

669 f"Warning: {_version_mismatch_message(versions)} Black's safety" 

670 " check verifies equivalence by parsing the AST, which fails" 

671 " when the running Python is older than the target version.", 

672 fg="yellow", 

673 ) 

674 

675 lines: list[tuple[int, int]] = [] 

676 if line_ranges: 

677 if ipynb: 

678 err("Cannot use --line-ranges with ipynb files.") 

679 ctx.exit(1) 

680 

681 try: 

682 lines = parse_line_ranges(line_ranges) 

683 except ValueError as e: 

684 err(str(e)) 

685 ctx.exit(1) 

686 

687 if code is not None: 

688 # Run in quiet mode by default with -c; the extra output isn't useful. 

689 # You can still pass -v to get verbose output. 

690 quiet = True 

691 

692 report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose) 

693 

694 if code is not None: 

695 reformat_code( 

696 content=code, 

697 fast=fast, 

698 write_back=write_back, 

699 mode=mode, 

700 report=report, 

701 lines=lines, 

702 ) 

703 else: 

704 assert root is not None # root is only None if code is not None 

705 try: 

706 sources = get_sources( 

707 root=root, 

708 src=src, 

709 quiet=quiet, 

710 verbose=verbose, 

711 include=include, 

712 exclude=exclude, 

713 extend_exclude=extend_exclude, 

714 force_exclude=force_exclude, 

715 report=report, 

716 stdin_filename=stdin_filename, 

717 ) 

718 except GitIgnorePatternError: 

719 ctx.exit(1) 

720 

721 if not sources: 

722 if verbose or not quiet: 

723 out("No Python files are present to be formatted. Nothing to do 😴") 

724 if "-" in src: 

725 sys.stdout.write(sys.stdin.read()) 

726 ctx.exit(0) 

727 

728 if len(sources) == 1: 

729 reformat_one( 

730 src=sources.pop(), 

731 fast=fast, 

732 write_back=write_back, 

733 mode=mode, 

734 report=report, 

735 lines=lines, 

736 no_cache=no_cache, 

737 ) 

738 else: 

739 from black.concurrency import reformat_many 

740 

741 if lines: 

742 err("Cannot use --line-ranges to format multiple files.") 

743 ctx.exit(1) 

744 reformat_many( 

745 sources=sources, 

746 fast=fast, 

747 write_back=write_back, 

748 mode=mode, 

749 report=report, 

750 workers=workers, 

751 no_cache=no_cache, 

752 ) 

753 

754 if verbose or not quiet: 

755 if code is None and (verbose or report.change_count or report.failure_count): 

756 out() 

757 out(error_msg if report.return_code else "All done! ✨ 🍰 ✨") 

758 if code is None: 

759 click.echo(str(report), err=True) 

760 ctx.exit(report.return_code) 

761 

762 

763def get_sources( 

764 *, 

765 root: Path, 

766 src: tuple[str, ...], 

767 quiet: bool, 

768 verbose: bool, 

769 include: Pattern[str], 

770 exclude: Pattern[str] | None, 

771 extend_exclude: Pattern[str] | None, 

772 force_exclude: Pattern[str] | None, 

773 report: "Report", 

774 stdin_filename: str | None, 

775) -> set[Path]: 

776 """Compute the set of files to be formatted.""" 

777 sources: set[Path] = set() 

778 

779 assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}" 

780 using_default_exclude = exclude is None 

781 exclude = re_compile_maybe_verbose(DEFAULT_EXCLUDES) if exclude is None else exclude 

782 gitignore: dict[Path, GitIgnoreSpec] | None = None 

783 root_gitignore = get_gitignore(root) 

784 

785 for s in src: 

786 if s == "-" and stdin_filename: 

787 path = Path(stdin_filename) 

788 if path_is_excluded(stdin_filename, force_exclude): 

789 report.path_ignored( 

790 path, 

791 "--stdin-filename matches the --force-exclude regular expression", 

792 ) 

793 continue 

794 is_stdin = True 

795 else: 

796 path = Path(s) 

797 is_stdin = False 

798 

799 # Compare the logic here to the logic in `gen_python_files`. 

800 if is_stdin or path.is_file(): 

801 if resolves_outside_root_or_cannot_stat(path, root, report): 

802 if verbose: 

803 out(f'Skipping invalid source: "{path}"', fg="red") 

804 continue 

805 

806 root_relative_path = best_effort_relative_path(path, root).as_posix() 

807 root_relative_path = "/" + root_relative_path 

808 

809 # Hard-exclude any files that matches the `--force-exclude` regex. 

810 if path_is_excluded(root_relative_path, force_exclude): 

811 report.path_ignored( 

812 path, "matches the --force-exclude regular expression" 

813 ) 

814 continue 

815 

816 if is_stdin: 

817 path = Path(f"{STDIN_PLACEHOLDER}{path}") 

818 

819 if path.suffix == ".ipynb" and not jupyter_dependencies_are_installed( 

820 warn=verbose or not quiet 

821 ): 

822 continue 

823 

824 if verbose: 

825 out(f'Found input source: "{path}"', fg="blue") 

826 sources.add(path) 

827 elif path.is_dir(): 

828 path = root / (path.resolve().relative_to(root)) 

829 if verbose: 

830 out(f'Found input source directory: "{path}"', fg="blue") 

831 

832 if using_default_exclude: 

833 gitignore = { 

834 root: root_gitignore, 

835 path: get_gitignore(path), 

836 } 

837 sources.update( 

838 gen_python_files( 

839 path.iterdir(), 

840 root, 

841 include, 

842 exclude, 

843 extend_exclude, 

844 force_exclude, 

845 report, 

846 gitignore, 

847 verbose=verbose, 

848 quiet=quiet, 

849 ) 

850 ) 

851 elif s == "-": 

852 if verbose: 

853 out("Found input source stdin", fg="blue") 

854 sources.add(path) 

855 else: 

856 err(f"invalid path: {s}") 

857 

858 return sources 

859 

860 

861def reformat_code( 

862 content: str, 

863 fast: bool, 

864 write_back: WriteBack, 

865 mode: Mode, 

866 report: Report, 

867 *, 

868 lines: Collection[tuple[int, int]] = (), 

869) -> None: 

870 """ 

871 Reformat and print out `content` without spawning child processes. 

872 Similar to `reformat_one`, but for string content. 

873 

874 `fast`, `write_back`, and `mode` options are passed to 

875 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. 

876 """ 

877 path = Path("<string>") 

878 try: 

879 changed = Changed.NO 

880 if format_stdin_to_stdout( 

881 content=content, fast=fast, write_back=write_back, mode=mode, lines=lines 

882 ): 

883 changed = Changed.YES 

884 report.done(path, changed) 

885 except Exception as exc: 

886 if report.verbose: 

887 traceback.print_exc() 

888 report.failed(path, str(exc)) 

889 

890 

891# diff-shades depends on being to monkeypatch this function to operate. I know it's 

892# not ideal, but this shouldn't cause any issues ... hopefully. ~ichard26 

893@mypyc_attr(patchable=True) 

894def reformat_one( 

895 src: Path, 

896 fast: bool, 

897 write_back: WriteBack, 

898 mode: Mode, 

899 report: "Report", 

900 *, 

901 lines: Collection[tuple[int, int]] = (), 

902 no_cache: bool = False, 

903) -> None: 

904 """Reformat a single file under `src` without spawning child processes. 

905 

906 `fast`, `write_back`, and `mode` options are passed to 

907 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. 

908 """ 

909 try: