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 lib2to3_parse, 

70 parse_ast, 

71 stringify_ast, 

72) 

73from black.ranges import ( 

74 adjusted_lines, 

75 convert_unchanged_lines, 

76 parse_line_ranges, 

77 sanitized_lines, 

78) 

79from black.report import Changed, NothingChanged, Report 

80from blib2to3.pgen2 import token 

81from blib2to3.pytree import Leaf, Node 

82 

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

84 

85# types 

86FileContent = str 

87Encoding = str 

88NewLine = str 

89 

90 

91class WriteBack(Enum): 

92 NO = 0 

93 YES = 1 

94 DIFF = 2 

95 CHECK = 3 

96 COLOR_DIFF = 4 

97 

98 @classmethod 

99 def from_configuration( 

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

101 ) -> "WriteBack": 

102 if check and not diff: 

103 return cls.CHECK 

104 

105 if diff and color: 

106 return cls.COLOR_DIFF 

107 

108 return cls.DIFF if diff else cls.YES 

109 

110 

111# Legacy name, left for integrations. 

112FileMode = Mode 

113 

114 

115def read_pyproject_toml( 

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

117) -> str | None: 

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

119 

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

121 otherwise. 

122 """ 

123 if not value: 

124 value = find_pyproject_toml( 

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

126 ) 

127 if value is None: 

128 return None 

129 

130 try: 

131 config = parse_pyproject_toml(value) 

132 except (OSError, ValueError) as e: 

133 raise click.FileError( 

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

135 ) from None 

136 

137 if not config: 

138 return None 

139 else: 

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

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

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

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

144 config = { 

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

146 for k, v in config.items() 

147 } 

148 

149 target_version = config.get("target_version") 

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

151 raise click.BadOptionUsage( 

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

153 ) 

154 

155 exclude = config.get("exclude") 

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

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

158 

159 extend_exclude = config.get("extend_exclude") 

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

161 raise click.BadOptionUsage( 

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

163 ) 

164 

165 line_ranges = config.get("line_ranges") 

166 if line_ranges is not None: 

167 raise click.BadOptionUsage( 

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

169 ) 

170 

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

172 if ctx.default_map: 

173 default_map.update(ctx.default_map) 

174 default_map.update(config) 

175 

176 ctx.default_map = default_map 

177 return value 

178 

179 

180def spellcheck_pyproject_toml_keys( 

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

182) -> None: 

183 invalid_keys: list[str] = [] 

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

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

186 if invalid_keys: 

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

188 out( 

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

190 fg="red", 

191 ) 

192 

193 

194def target_version_option_callback( 

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

196) -> list[TargetVersion]: 

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

198 

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

200 when it was a lambda, causing mypyc trouble. 

201 """ 

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

203 

204 

205def enable_unstable_feature_callback( 

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

207) -> list[Preview]: 

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

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

210 

211 

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

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

214 

215 If it contains newlines, use verbose mode. 

216 """ 

217 if "\n" in regex: 

218 regex = "(?x)" + regex 

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

220 return compiled 

221 

222 

223def validate_regex( 

224 ctx: click.Context, 

225 param: click.Parameter, 

226 value: str | None, 

227) -> Pattern[str] | None: 

228 try: 

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

230 except re.error as e: 

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

232 

233 

234@click.command( 

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

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

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

238 help="The uncompromising code formatter.", 

239) 

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

241@click.option( 

242 "-l", 

243 "--line-length", 

244 type=int, 

245 default=DEFAULT_LINE_LENGTH, 

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

247 show_default=True, 

248) 

249@click.option( 

250 "-t", 

251 "--target-version", 

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

253 callback=target_version_option_callback, 

254 multiple=True, 

255 help=( 

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

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

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

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

260 ), 

261) 

262@click.option( 

263 "--pyi", 

264 is_flag=True, 

265 help=( 

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

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

268 ), 

269) 

270@click.option( 

271 "--ipynb", 

272 is_flag=True, 

273 help=( 

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

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

276 ), 

277) 

278@click.option( 

279 "--python-cell-magics", 

280 multiple=True, 

281 help=( 

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

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

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

285 ), 

286 default=[], 

287) 

288@click.option( 

289 "-x", 

290 "--skip-source-first-line", 

291 is_flag=True, 

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

293) 

294@click.option( 

295 "-S", 

296 "--skip-string-normalization", 

297 is_flag=True, 

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

299) 

300@click.option( 

301 "-C", 

302 "--skip-magic-trailing-comma", 

303 is_flag=True, 

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

305) 

306@click.option( 

307 "--preview", 

308 is_flag=True, 

309 help=( 

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

311 " functionality in the next major release." 

312 ), 

313) 

314@click.option( 

315 "--unstable", 

316 is_flag=True, 

317 help=( 

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

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

320 " release. Implies --preview." 

321 ), 

322) 

323@click.option( 

324 "--enable-unstable-feature", 

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

326 callback=enable_unstable_feature_callback, 

327 multiple=True, 

328 help=( 

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

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

331 " or existence of any unstable features." 

332 ), 

333) 

334@click.option( 

335 "--check", 

336 is_flag=True, 

337 help=( 

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

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

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

341 ), 

342) 

343@click.option( 

344 "--diff", 

345 is_flag=True, 

346 help=( 

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

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

349 ), 

350) 

351@click.option( 

352 "--color/--no-color", 

353 is_flag=True, 

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

355) 

356@click.option( 

357 "--line-ranges", 

358 multiple=True, 

359 metavar="START-END", 

360 help=( 

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

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

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

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

365 " inclusive on both ends." 

366 ), 

367 default=(), 

368) 

369@click.option( 

370 "--fast/--safe", 

371 is_flag=True, 

372 help=( 

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

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

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

376 ), 

377) 

378@click.option( 

379 "--required-version", 

380 type=str, 

381 help=( 

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

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

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

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

386 " results across environments." 

387 ), 

388) 

389@click.option( 

390 "--exclude", 

391 type=str, 

392 callback=validate_regex, 

393 help=( 

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

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

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

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

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

399 ), 

400 show_default=False, 

401) 

402@click.option( 

403 "--extend-exclude", 

404 type=str, 

405 callback=validate_regex, 

406 help=( 

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

408 " default values instead of overriding them." 

409 ), 

410) 

411@click.option( 

412 "--force-exclude", 

413 type=str, 

414 callback=validate_regex, 

415 help=( 

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

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

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

419 " hook or editor plugin." 

420 ), 

421) 

422@click.option( 

423 "--stdin-filename", 

424 type=str, 

425 is_eager=True, 

426 help=( 

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

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

429 " stdin." 

430 ), 

431) 

432@click.option( 

433 "--include", 

434 type=str, 

435 default=DEFAULT_INCLUDES, 

436 callback=validate_regex, 

437 help=( 

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

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

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

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

442 " command line options." 

443 ), 

444 show_default=True, 

445) 

446@click.option( 

447 "-W", 

448 "--workers", 

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

450 default=None, 

451 help=( 

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

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

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

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

456 ), 

457) 

458@click.option( 

459 "-q", 

460 "--quiet", 

461 is_flag=True, 

462 help=( 

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

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

465 ), 

466) 

467@click.option( 

468 "-v", 

469 "--verbose", 

470 is_flag=True, 

471 help=( 

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

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

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

475 ), 

476) 

477@click.version_option( 

478 version=__version__, 

479 message=( 

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

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

482 ), 

483) 

484@click.argument( 

485 "src", 

486 nargs=-1, 

487 type=click.Path( 

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

489 ), 

490 is_eager=True, 

491 metavar="SRC ...", 

492) 

493@click.option( 

494 "--config", 

495 type=click.Path( 

496 exists=True, 

497 file_okay=True, 

498 dir_okay=False, 

499 readable=True, 

500 allow_dash=False, 

501 path_type=str, 

502 ), 

503 is_eager=True, 

504 callback=read_pyproject_toml, 

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

506) 

507@click.option( 

508 "--no-cache", 

509 is_flag=True, 

510 help=( 

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

512 " included files." 

513 ), 

514) 

515@click.pass_context 

516def main( 

517 ctx: click.Context, 

518 code: str | None, 

519 line_length: int, 

520 target_version: list[TargetVersion], 

521 check: bool, 

522 diff: bool, 

523 line_ranges: Sequence[str], 

524 color: bool, 

525 fast: bool, 

526 pyi: bool, 

527 ipynb: bool, 

528 python_cell_magics: Sequence[str], 

529 skip_source_first_line: bool, 

530 skip_string_normalization: bool, 

531 skip_magic_trailing_comma: bool, 

532 preview: bool, 

533 unstable: bool, 

534 enable_unstable_feature: list[Preview], 

535 quiet: bool, 

536 verbose: bool, 

537 required_version: str | None, 

538 include: Pattern[str], 

539 exclude: Pattern[str] | None, 

540 extend_exclude: Pattern[str] | None, 

541 force_exclude: Pattern[str] | None, 

542 stdin_filename: str | None, 

543 workers: int | None, 

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

545 config: str | None, 

546 no_cache: bool, 

547) -> None: 

548 """The uncompromising code formatter.""" 

549 ctx.ensure_object(dict) 

550 

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

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

553 out( 

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

555 "AST safety checks to fail. " 

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

557 ) 

558 ctx.exit(1) 

559 

560 if src and code is not None: 

561 out( 

562 main.get_usage(ctx) 

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

564 ) 

565 ctx.exit(1) 

566 if not src and code is None: 

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

568 ctx.exit(1) 

569 

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

571 if enable_unstable_feature and not (preview or unstable): 

572 out( 

573 main.get_usage(ctx) 

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

575 ) 

576 ctx.exit(1) 

577 

578 root, method = ( 

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

580 ) 

581 ctx.obj["root"] = root 

582 

583 if verbose: 

584 if root: 

585 out( 

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

587 fg="blue", 

588 ) 

589 

590 if config: 

591 config_source = ctx.get_parameter_source("config") 

592 user_level_config = str(find_user_pyproject_toml()) 

593 if config == user_level_config: 

594 out( 

595 "Using configuration from user-level config at " 

596 f"'{user_level_config}'.", 

597 fg="blue", 

598 ) 

599 elif config_source in ( 

600 ParameterSource.DEFAULT, 

601 ParameterSource.DEFAULT_MAP, 

602 ): 

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

604 else: 

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

606 if ctx.default_map: 

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

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

609 

610 error_msg = "Oh no! 💥 💔 💥" 

611 if ( 

612 required_version 

613 and required_version != __version__ 

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

615 ): 

616 err( 

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

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

619 ) 

620 ctx.exit(1) 

621 if ipynb and pyi: 

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

623 ctx.exit(1) 

624 

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

626 if target_version: 

627 versions = set(target_version) 

628 else: 

629 # We'll autodetect later. 

630 versions = set() 

631 mode = Mode( 

632 target_versions=versions, 

633 line_length=line_length, 

634 is_pyi=pyi, 

635 is_ipynb=ipynb, 

636 skip_source_first_line=skip_source_first_line, 

637 string_normalization=not skip_string_normalization, 

638 magic_trailing_comma=not skip_magic_trailing_comma, 

639 preview=preview, 

640 unstable=unstable, 

641 python_cell_magics=set(python_cell_magics), 

642 enabled_features=set(enable_unstable_feature), 

643 ) 

644 

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

646 if line_ranges: 

647 if ipynb: 

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

649 ctx.exit(1) 

650 

651 try: 

652 lines = parse_line_ranges(line_ranges) 

653 except ValueError as e: 

654 err(str(e)) 

655 ctx.exit(1) 

656 

657 if code is not None: 

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

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

660 quiet = True 

661 

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

663 

664 if code is not None: 

665 reformat_code( 

666 content=code, 

667 fast=fast, 

668 write_back=write_back, 

669 mode=mode, 

670 report=report, 

671 lines=lines, 

672 ) 

673 else: 

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

675 try: 

676 sources = get_sources( 

677 root=root, 

678 src=src, 

679 quiet=quiet, 

680 verbose=verbose, 

681 include=include, 

682 exclude=exclude, 

683 extend_exclude=extend_exclude, 

684 force_exclude=force_exclude, 

685 report=report, 

686 stdin_filename=stdin_filename, 

687 ) 

688 except GitIgnorePatternError: 

689 ctx.exit(1) 

690 

691 if not sources: 

692 if verbose or not quiet: 

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

694 if "-" in src: 

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

696 ctx.exit(0) 

697 

698 if len(sources) == 1: 

699 reformat_one( 

700 src=sources.pop(), 

701 fast=fast, 

702 write_back=write_back, 

703 mode=mode, 

704 report=report, 

705 lines=lines, 

706 no_cache=no_cache, 

707 ) 

708 else: 

709 from black.concurrency import reformat_many 

710 

711 if lines: 

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

713 ctx.exit(1) 

714 reformat_many( 

715 sources=sources, 

716 fast=fast, 

717 write_back=write_back, 

718 mode=mode, 

719 report=report, 

720 workers=workers, 

721 no_cache=no_cache, 

722 ) 

723 

724 if verbose or not quiet: 

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

726 out() 

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

728 if code is None: 

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

730 ctx.exit(report.return_code) 

731 

732 

733def get_sources( 

734 *, 

735 root: Path, 

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

737 quiet: bool, 

738 verbose: bool, 

739 include: Pattern[str], 

740 exclude: Pattern[str] | None, 

741 extend_exclude: Pattern[str] | None, 

742 force_exclude: Pattern[str] | None, 

743 report: "Report", 

744 stdin_filename: str | None, 

745) -> set[Path]: 

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

747 sources: set[Path] = set() 

748 

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

750 using_default_exclude = exclude is None 

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

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

753 root_gitignore = get_gitignore(root) 

754 

755 for s in src: 

756 if s == "-" and stdin_filename: 

757 path = Path(stdin_filename) 

758 if path_is_excluded(stdin_filename, force_exclude): 

759 report.path_ignored( 

760 path, 

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

762 ) 

763 continue 

764 is_stdin = True 

765 else: 

766 path = Path(s) 

767 is_stdin = False 

768 

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

770 if is_stdin or path.is_file(): 

771 if resolves_outside_root_or_cannot_stat(path, root, report): 

772 if verbose: 

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

774 continue 

775 

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

777 root_relative_path = "/" + root_relative_path 

778 

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

780 if path_is_excluded(root_relative_path, force_exclude): 

781 report.path_ignored( 

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

783 ) 

784 continue 

785 

786 if is_stdin: 

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

788 

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

790 warn=verbose or not quiet 

791 ): 

792 continue 

793 

794 if verbose: 

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

796 sources.add(path) 

797 elif path.is_dir(): 

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

799 if verbose: 

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

801 

802 if using_default_exclude: 

803 gitignore = { 

804 root: root_gitignore, 

805 path: get_gitignore(path), 

806 } 

807 sources.update( 

808 gen_python_files( 

809 path.iterdir(), 

810 root, 

811 include, 

812 exclude, 

813 extend_exclude, 

814 force_exclude, 

815 report, 

816 gitignore, 

817 verbose=verbose, 

818 quiet=quiet, 

819 ) 

820 ) 

821 elif s == "-": 

822 if verbose: 

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

824 sources.add(path) 

825 else: 

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

827 

828 return sources 

829 

830 

831def reformat_code( 

832 content: str, 

833 fast: bool, 

834 write_back: WriteBack, 

835 mode: Mode, 

836 report: Report, 

837 *, 

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

839) -> None: 

840 """ 

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

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

843 

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

845 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. 

846 """ 

847 path = Path("<string>") 

848 try: 

849 changed = Changed.NO 

850 if format_stdin_to_stdout( 

851 content=content, fast=fast, write_back=write_back, mode=mode, lines=lines 

852 ): 

853 changed = Changed.YES 

854 report.done(path, changed) 

855 except Exception as exc: 

856 if report.verbose: 

857 traceback.print_exc() 

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

859 

860 

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

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

863@mypyc_attr(patchable=True) 

864def reformat_one( 

865 src: Path, 

866 fast: bool, 

867 write_back: WriteBack, 

868 mode: Mode, 

869 report: "Report", 

870 *, 

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

872 no_cache: bool = False, 

873) -> None: 

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

875 

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

877 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. 

878 """ 

879 try: 

880 changed = Changed.NO 

881 

882 if str(src) == "-": 

883 is_stdin = True 

884 elif str(src).startswith(STDIN_PLACEHOLDER): 

885 is_stdin = True 

886 # Use the original name again in case we want to print something 

887 # to the user 

888 src = Path(str(src)[len(STDIN_PLACEHOLDER) :]) 

889 else: 

890 is_stdin = False 

891 

892 if is_stdin: 

893 if src.suffix == ".pyi": 

894 mode = replace(mode, is_pyi=True) 

895 elif src.suffix == ".ipynb": 

896 mode = replace(mode, is_ipynb=True) 

897 if format_stdin_to_stdout( 

898 fast=fast, write_back=write_back, mode=mode, lines=lines 

899 ): 

900 changed = Changed.YES 

901 else: 

902 cache = None if no_cache else Cache.read(mode) 

903 if cache is not None and write_back not in (