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

1import io 

2import json 

3import platform 

4import re 

5import sys 

6import tokenize 

7import traceback 

8from collections.abc import ( 

9 Collection, 

10 Generator, 

11 Iterator, 

12 MutableMapping, 

13 Sequence, 

14 Sized, 

15) 

16from contextlib import contextmanager 

17from dataclasses import replace 

18from datetime import datetime, timezone 

19from enum import Enum 

20from json.decoder import JSONDecodeError 

21from pathlib import Path 

22from re import Pattern 

23from typing import Any, Optional, Union 

24 

25import click 

26from click.core import ParameterSource 

27from mypy_extensions import mypyc_attr 

28from pathspec import PathSpec 

29from pathspec.patterns.gitwildmatch import GitWildMatchPatternError 

30 

31from _black_version import version as __version__ 

32from black.cache import Cache 

33from black.comments import normalize_fmt_off 

34from black.const import ( 

35 DEFAULT_EXCLUDES, 

36 DEFAULT_INCLUDES, 

37 DEFAULT_LINE_LENGTH, 

38 STDIN_PLACEHOLDER, 

39) 

40from black.files import ( 

41 best_effort_relative_path, 

42 find_project_root, 

43 find_pyproject_toml, 

44 find_user_pyproject_toml, 

45 gen_python_files, 

46 get_gitignore, 

47 parse_pyproject_toml, 

48 path_is_excluded, 

49 resolves_outside_root_or_cannot_stat, 

50 wrap_stream_for_windows, 

51) 

52from black.handle_ipynb_magics import ( 

53 PYTHON_CELL_MAGICS, 

54 jupyter_dependencies_are_installed, 

55 mask_cell, 

56 put_trailing_semicolon_back, 

57 remove_trailing_semicolon, 

58 unmask_cell, 

59 validate_cell, 

60) 

61from black.linegen import LN, LineGenerator, transform_line 

62from black.lines import EmptyLineTracker, LinesBlock 

63from black.mode import FUTURE_FLAG_TO_FEATURE, VERSION_TO_FEATURES, Feature 

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

65from black.mode import Preview, TargetVersion, supports_feature 

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

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

68from black.parsing import ( # noqa F401 

69 ASTSafetyError, 

70 InvalidInput, 

71 lib2to3_parse, 

72 parse_ast, 

73 stringify_ast, 

74) 

75from black.ranges import ( 

76 adjusted_lines, 

77 convert_unchanged_lines, 

78 parse_line_ranges, 

79 sanitized_lines, 

80) 

81from black.report import Changed, NothingChanged, Report 

82from blib2to3.pgen2 import token 

83from blib2to3.pytree import Leaf, Node 

84 

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

86 

87# types 

88FileContent = str 

89Encoding = str 

90NewLine = str 

91 

92 

93class WriteBack(Enum): 

94 NO = 0 

95 YES = 1 

96 DIFF = 2 

97 CHECK = 3 

98 COLOR_DIFF = 4 

99 

100 @classmethod 

101 def from_configuration( 

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

103 ) -> "WriteBack": 

104 if check and not diff: 

105 return cls.CHECK 

106 

107 if diff and color: 

108 return cls.COLOR_DIFF 

109 

110 return cls.DIFF if diff else cls.YES 

111 

112 

113# Legacy name, left for integrations. 

114FileMode = Mode 

115 

116 

117def read_pyproject_toml( 

118 ctx: click.Context, param: click.Parameter, value: Optional[str] 

119) -> Optional[str]: 

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

121 

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

123 otherwise. 

124 """ 

125 if not value: 

126 value = find_pyproject_toml( 

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

128 ) 

129 if value is None: 

130 return None 

131 

132 try: 

133 config = parse_pyproject_toml(value) 

134 except (OSError, ValueError) as e: 

135 raise click.FileError( 

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

137 ) from None 

138 

139 if not config: 

140 return None 

141 else: 

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

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

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

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

146 config = { 

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

148 for k, v in config.items() 

149 } 

150 

151 target_version = config.get("target_version") 

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

153 raise click.BadOptionUsage( 

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

155 ) 

156 

157 exclude = config.get("exclude") 

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

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

160 

161 extend_exclude = config.get("extend_exclude") 

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

163 raise click.BadOptionUsage( 

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

165 ) 

166 

167 line_ranges = config.get("line_ranges") 

168 if line_ranges is not None: 

169 raise click.BadOptionUsage( 

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

171 ) 

172 

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

174 if ctx.default_map: 

175 default_map.update(ctx.default_map) 

176 default_map.update(config) 

177 

178 ctx.default_map = default_map 

179 return value 

180 

181 

182def spellcheck_pyproject_toml_keys( 

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

184) -> None: 

185 invalid_keys: list[str] = [] 

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

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

188 if invalid_keys: 

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

190 out( 

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

192 fg="red", 

193 ) 

194 

195 

196def target_version_option_callback( 

197 c: click.Context, p: Union[click.Option, click.Parameter], v: tuple[str, ...] 

198) -> list[TargetVersion]: 

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

200 

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

202 when it was a lambda, causing mypyc trouble. 

203 """ 

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

205 

206 

207def enable_unstable_feature_callback( 

208 c: click.Context, p: Union[click.Option, click.Parameter], v: tuple[str, ...] 

209) -> list[Preview]: 

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

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

212 

213 

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

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

216 

217 If it contains newlines, use verbose mode. 

218 """ 

219 if "\n" in regex: 

220 regex = "(?x)" + regex 

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

222 return compiled 

223 

224 

225def validate_regex( 

226 ctx: click.Context, 

227 param: click.Parameter, 

228 value: Optional[str], 

229) -> Optional[Pattern[str]]: 

230 try: 

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

232 except re.error as e: 

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

234 

235 

236@click.command( 

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

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

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

240 help="The uncompromising code formatter.", 

241) 

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

243@click.option( 

244 "-l", 

245 "--line-length", 

246 type=int, 

247 default=DEFAULT_LINE_LENGTH, 

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

249 show_default=True, 

250) 

251@click.option( 

252 "-t", 

253 "--target-version", 

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

255 callback=target_version_option_callback, 

256 multiple=True, 

257 help=( 

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

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

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

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

262 ), 

263) 

264@click.option( 

265 "--pyi", 

266 is_flag=True, 

267 help=( 

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

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

270 ), 

271) 

272@click.option( 

273 "--ipynb", 

274 is_flag=True, 

275 help=( 

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

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

278 ), 

279) 

280@click.option( 

281 "--python-cell-magics", 

282 multiple=True, 

283 help=( 

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

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

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

287 ), 

288 default=[], 

289) 

290@click.option( 

291 "-x", 

292 "--skip-source-first-line", 

293 is_flag=True, 

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

295) 

296@click.option( 

297 "-S", 

298 "--skip-string-normalization", 

299 is_flag=True, 

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

301) 

302@click.option( 

303 "-C", 

304 "--skip-magic-trailing-comma", 

305 is_flag=True, 

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

307) 

308@click.option( 

309 "--preview", 

310 is_flag=True, 

311 help=( 

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

313 " functionality in the next major release." 

314 ), 

315) 

316@click.option( 

317 "--unstable", 

318 is_flag=True, 

319 help=( 

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

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

322 " release. Implies --preview." 

323 ), 

324) 

325@click.option( 

326 "--enable-unstable-feature", 

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

328 callback=enable_unstable_feature_callback, 

329 multiple=True, 

330 help=( 

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

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

333 " or existence of any unstable features." 

334 ), 

335) 

336@click.option( 

337 "--check", 

338 is_flag=True, 

339 help=( 

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

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

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

343 ), 

344) 

345@click.option( 

346 "--diff", 

347 is_flag=True, 

348 help=( 

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

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

351 ), 

352) 

353@click.option( 

354 "--color/--no-color", 

355 is_flag=True, 

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

357) 

358@click.option( 

359 "--line-ranges", 

360 multiple=True, 

361 metavar="START-END", 

362 help=( 

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

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

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

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

367 " inclusive on both ends." 

368 ), 

369 default=(), 

370) 

371@click.option( 

372 "--fast/--safe", 

373 is_flag=True, 

374 help=( 

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

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

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

378 ), 

379) 

380@click.option( 

381 "--required-version", 

382 type=str, 

383 help=( 

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

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

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

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

388 " results across environments." 

389 ), 

390) 

391@click.option( 

392 "--exclude", 

393 type=str, 

394 callback=validate_regex, 

395 help=( 

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

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

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

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

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

401 ), 

402 show_default=False, 

403) 

404@click.option( 

405 "--extend-exclude", 

406 type=str, 

407 callback=validate_regex, 

408 help=( 

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

410 " default values instead of overriding them." 

411 ), 

412) 

413@click.option( 

414 "--force-exclude", 

415 type=str, 

416 callback=validate_regex, 

417 help=( 

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

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

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

421 " hook or editor plugin." 

422 ), 

423) 

424@click.option( 

425 "--stdin-filename", 

426 type=str, 

427 is_eager=True, 

428 help=( 

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

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

431 " stdin." 

432 ), 

433) 

434@click.option( 

435 "--include", 

436 type=str, 

437 default=DEFAULT_INCLUDES, 

438 callback=validate_regex, 

439 help=( 

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

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

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

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

444 " command line options." 

445 ), 

446 show_default=True, 

447) 

448@click.option( 

449 "-W", 

450 "--workers", 

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

452 default=None, 

453 help=( 

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

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

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

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

458 ), 

459) 

460@click.option( 

461 "-q", 

462 "--quiet", 

463 is_flag=True, 

464 help=( 

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

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

467 ), 

468) 

469@click.option( 

470 "-v", 

471 "--verbose", 

472 is_flag=True, 

473 help=( 

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

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

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

477 ), 

478) 

479@click.version_option( 

480 version=__version__, 

481 message=( 

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

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

484 ), 

485) 

486@click.argument( 

487 "src", 

488 nargs=-1, 

489 type=click.Path( 

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

491 ), 

492 is_eager=True, 

493 metavar="SRC ...", 

494) 

495@click.option( 

496 "--config", 

497 type=click.Path( 

498 exists=True, 

499 file_okay=True, 

500 dir_okay=False, 

501 readable=True, 

502 allow_dash=False, 

503 path_type=str, 

504 ), 

505 is_eager=True, 

506 callback=read_pyproject_toml, 

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

508) 

509@click.pass_context 

510def main( # noqa: C901 

511 ctx: click.Context, 

512 code: Optional[str], 

513 line_length: int, 

514 target_version: list[TargetVersion], 

515 check: bool, 

516 diff: bool, 

517 line_ranges: Sequence[str], 

518 color: bool, 

519 fast: bool, 

520 pyi: bool, 

521 ipynb: bool, 

522 python_cell_magics: Sequence[str], 

523 skip_source_first_line: bool, 

524 skip_string_normalization: bool, 

525 skip_magic_trailing_comma: bool, 

526 preview: bool, 

527 unstable: bool, 

528 enable_unstable_feature: list[Preview], 

529 quiet: bool, 

530 verbose: bool, 

531 required_version: Optional[str], 

532 include: Pattern[str], 

533 exclude: Optional[Pattern[str]], 

534 extend_exclude: Optional[Pattern[str]], 

535 force_exclude: Optional[Pattern[str]], 

536 stdin_filename: Optional[str], 

537 workers: Optional[int], 

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

539 config: Optional[str], 

540) -> None: 

541 """The uncompromising code formatter.""" 

542 ctx.ensure_object(dict) 

543 

544 assert sys.version_info >= (3, 9), "Black requires Python 3.9+" 

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

546 out( 

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

548 "AST safety checks to fail. " 

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

550 ) 

551 ctx.exit(1) 

552 

553 if src and code is not None: 

554 out( 

555 main.get_usage(ctx) 

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

557 ) 

558 ctx.exit(1) 

559 if not src and code is None: 

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

561 ctx.exit(1) 

562 

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

564 if enable_unstable_feature and not (preview or unstable): 

565 out( 

566 main.get_usage(ctx) 

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

568 ) 

569 ctx.exit(1) 

570 

571 root, method = ( 

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

573 ) 

574 ctx.obj["root"] = root 

575 

576 if verbose: 

577 if root: 

578 out( 

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

580 fg="blue", 

581 ) 

582 

583 if config: 

584 config_source = ctx.get_parameter_source("config") 

585 user_level_config = str(find_user_pyproject_toml()) 

586 if config == user_level_config: 

587 out( 

588 "Using configuration from user-level config at " 

589 f"'{user_level_config}'.", 

590 fg="blue", 

591 ) 

592 elif config_source in ( 

593 ParameterSource.DEFAULT, 

594 ParameterSource.DEFAULT_MAP, 

595 ): 

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

597 else: 

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

599 if ctx.default_map: 

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

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

602 

603 error_msg = "Oh no! 💥 💔 💥" 

604 if ( 

605 required_version 

606 and required_version != __version__ 

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

608 ): 

609 err( 

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

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

612 ) 

613 ctx.exit(1) 

614 if ipynb and pyi: 

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

616 ctx.exit(1) 

617 

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

619 if target_version: 

620 versions = set(target_version) 

621 else: 

622 # We'll autodetect later. 

623 versions = set() 

624 mode = Mode( 

625 target_versions=versions, 

626 line_length=line_length, 

627 is_pyi=pyi, 

628 is_ipynb=ipynb, 

629 skip_source_first_line=skip_source_first_line, 

630 string_normalization=not skip_string_normalization, 

631 magic_trailing_comma=not skip_magic_trailing_comma, 

632 preview=preview, 

633 unstable=unstable, 

634 python_cell_magics=set(python_cell_magics), 

635 enabled_features=set(enable_unstable_feature), 

636 ) 

637 

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

639 if line_ranges: 

640 if ipynb: 

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

642 ctx.exit(1) 

643 

644 try: 

645 lines = parse_line_ranges(line_ranges) 

646 except ValueError as e: 

647 err(str(e)) 

648 ctx.exit(1) 

649 

650 if code is not None: 

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

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

653 quiet = True 

654 

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

656 

657 if code is not None: 

658 reformat_code( 

659 content=code, 

660 fast=fast, 

661 write_back=write_back, 

662 mode=mode, 

663 report=report, 

664 lines=lines, 

665 ) 

666 else: 

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

668 try: 

669 sources = get_sources( 

670 root=root, 

671 src=src, 

672 quiet=quiet, 

673 verbose=verbose, 

674 include=include, 

675 exclude=exclude, 

676 extend_exclude=extend_exclude, 

677 force_exclude=force_exclude, 

678 report=report, 

679 stdin_filename=stdin_filename, 

680 ) 

681 except GitWildMatchPatternError: 

682 ctx.exit(1) 

683 

684 path_empty( 

685 sources, 

686 "No Python files are present to be formatted. Nothing to do 😴", 

687 quiet, 

688 verbose, 

689 ctx, 

690 ) 

691 

692 if len(sources) == 1: 

693 reformat_one( 

694 src=sources.pop(), 

695 fast=fast, 

696 write_back=write_back, 

697 mode=mode, 

698 report=report, 

699 lines=lines, 

700 ) 

701 else: 

702 from black.concurrency import reformat_many 

703 

704 if lines: 

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

706 ctx.exit(1) 

707 reformat_many( 

708 sources=sources, 

709 fast=fast, 

710 write_back=write_back, 

711 mode=mode, 

712 report=report, 

713 workers=workers, 

714 ) 

715 

716 if verbose or not quiet: 

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

718 out() 

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

720 if code is None: 

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

722 ctx.exit(report.return_code) 

723 

724 

725def get_sources( 

726 *, 

727 root: Path, 

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

729 quiet: bool, 

730 verbose: bool, 

731 include: Pattern[str], 

732 exclude: Optional[Pattern[str]], 

733 extend_exclude: Optional[Pattern[str]], 

734 force_exclude: Optional[Pattern[str]], 

735 report: "Report", 

736 stdin_filename: Optional[str], 

737) -> set[Path]: 

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

739 sources: set[Path] = set() 

740 

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

742 using_default_exclude = exclude is None 

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

744 gitignore: Optional[dict[Path, PathSpec]] = None 

745 root_gitignore = get_gitignore(root) 

746 

747 for s in src: 

748 if s == "-" and stdin_filename: 

749 path = Path(stdin_filename) 

750 if path_is_excluded(stdin_filename, force_exclude): 

751 report.path_ignored( 

752 path, 

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

754 ) 

755 continue 

756 is_stdin = True 

757 else: 

758 path = Path(s) 

759 is_stdin = False 

760 

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

762 if is_stdin or path.is_file(): 

763 if resolves_outside_root_or_cannot_stat(path, root, report): 

764 if verbose: 

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

766 continue 

767 

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

769 root_relative_path = "/" + root_relative_path 

770 

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

772 if path_is_excluded(root_relative_path, force_exclude): 

773 report.path_ignored( 

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

775 ) 

776 continue 

777 

778 if is_stdin: 

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

780 

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

782 warn=verbose or not quiet 

783 ): 

784 continue 

785 

786 if verbose: 

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

788 sources.add(path) 

789 elif path.is_dir(): 

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

791 if verbose: 

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

793 

794 if using_default_exclude: 

795 gitignore = { 

796 root: root_gitignore, 

797 path: get_gitignore(path), 

798 } 

799 sources.update( 

800 gen_python_files( 

801 path.iterdir(), 

802 root, 

803 include, 

804 exclude, 

805 extend_exclude, 

806 force_exclude, 

807 report, 

808 gitignore, 

809 verbose=verbose, 

810 quiet=quiet, 

811 ) 

812 ) 

813 elif s == "-": 

814 if verbose: 

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

816 sources.add(path) 

817 else: 

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

819 

820 return sources 

821 

822 

823def path_empty( 

824 src: Sized, msg: str, quiet: bool, verbose: bool, ctx: click.Context 

825) -> None: 

826 """ 

827 Exit if there is no `src` provided for formatting 

828 """ 

829 if not src: 

830 if verbose or not quiet: 

831 out(msg) 

832 ctx.exit(0) 

833 

834 

835def reformat_code( 

836 content: str, 

837 fast: bool, 

838 write_back: WriteBack, 

839 mode: Mode, 

840 report: Report, 

841 *, 

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

843) -> None: 

844 """ 

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

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

847 

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

849 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. 

850 """ 

851 path = Path("<string>") 

852 try: 

853 changed = Changed.NO 

854 if format_stdin_to_stdout( 

855 content=content, fast=fast, write_back=write_back, mode=mode, lines=lines 

856 ): 

857 changed = Changed.YES 

858 report.done(path, changed) 

859 except Exception as exc: 

860 if report.verbose: 

861 traceback.print_exc() 

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

863 

864 

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

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

867@mypyc_attr(patchable=True) 

868def reformat_one( 

869 src: Path, 

870 fast: bool, 

871 write_back: WriteBack, 

872 mode: Mode, 

873 report: "Report", 

874 *, 

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

876) -> None: 

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

878 

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

880 :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. 

881 """ 

882 try: 

883 changed = Changed.NO 

884 

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

886 is_stdin = True 

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

888 is_stdin = True 

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

890 # to the user 

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

892 else: 

893 is_stdin = False 

894 

895 if is_stdin: 

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

897 mode = replace(mode, is_pyi=True) 

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

899 mode = replace(mode, is_ipynb=True) 

900 if format_stdin_to_stdout( 

901 fast=fast, write_back=write_back, mode=mode, lines=lines 

902 ): 

903 changed = Changed.YES