Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/libcst/matchers/__init_

1# Copyright (c) Meta Platforms, Inc. and affiliates.

3# This source code is licensed under the MIT license found in the

4# LICENSE file in the root directory of this source tree.

7# This file was generated by libcst.codegen.gen_matcher_classes

8from dataclasses import dataclass

9from typing import Literal, Optional, Sequence, Union

11import libcst as cst

12from libcst.matchers._decorators import call_if_inside, call_if_not_inside, leave, visit

14from libcst.matchers._matcher_base import (

15 AbstractBaseMatcherNodeMeta,

16 AllOf,

17 AtLeastN,

18 AtMostN,

19 BaseMatcherNode,

20 DoesNotMatch,

21 DoNotCare,

22 DoNotCareSentinel,

23 extract,

24 extractall,

25 findall,

26 matches,

27 MatchIfTrue,

28 MatchMetadata,

29 MatchMetadataIfTrue,

30 MatchRegex,

31 OneOf,

32 replace,

33 SaveMatchedNode,

34 TypeOf,

35 ZeroOrMore,

36 ZeroOrOne,

37)

38from libcst.matchers._visitors import (

39 MatchDecoratorMismatch,

40 MatcherDecoratableTransformer,

41 MatcherDecoratableVisitor,

42)

45class _NodeABC(metaclass=AbstractBaseMatcherNodeMeta):

46 __slots__ = ()

49class BaseAssignTargetExpression(_NodeABC):

50 pass

53class BaseAugOp(_NodeABC):

54 pass

57class BaseBinaryOp(_NodeABC):

58 pass

61class BaseBooleanOp(_NodeABC):

62 pass

65class BaseComp(_NodeABC):

66 pass

69class BaseCompOp(_NodeABC):

70 pass

73class BaseCompoundStatement(_NodeABC):

74 pass

77class BaseDelTargetExpression(_NodeABC):

78 pass

81class BaseDict(_NodeABC):

82 pass

85class BaseDictElement(_NodeABC):

86 pass

89class BaseElement(_NodeABC):

90 pass

93class BaseExpression(_NodeABC):

94 pass

97class BaseFormattedStringContent(_NodeABC):

98 pass

100

101class BaseList(_NodeABC):

102 pass

103

104

105class BaseMetadataProvider(_NodeABC):

106 pass

107

108

109class BaseNumber(_NodeABC):

110 pass

111

112

113class BaseParenthesizableWhitespace(_NodeABC):

114 pass

115

116

117class BaseSet(_NodeABC):

118 pass

119

120

121class BaseSimpleComp(_NodeABC):

122 pass

123

124

125class BaseSlice(_NodeABC):

126 pass

127

128

129class BaseSmallStatement(_NodeABC):

130 pass

131

132

133class BaseStatement(_NodeABC):

134 pass

135

136

137class BaseString(_NodeABC):

138 pass

139

140

141class BaseSuite(_NodeABC):

142 pass

143

144

145class BaseTemplatedStringContent(_NodeABC):

146 pass

147

148

149class BaseUnaryOp(_NodeABC):

150 pass

151

152

153MetadataMatchType = Union[MatchMetadata, MatchMetadataIfTrue]

154

155

156BaseParenthesizableWhitespaceMatchType = Union[

157 "BaseParenthesizableWhitespace",

158 MetadataMatchType,

159 MatchIfTrue[cst.BaseParenthesizableWhitespace],

160]

161

162

163@dataclass(frozen=True, eq=False, unsafe_hash=False)

164class Add(BaseBinaryOp, BaseMatcherNode):

165 whitespace_before: Union[

166 BaseParenthesizableWhitespaceMatchType,

167 DoNotCareSentinel,

168 OneOf[BaseParenthesizableWhitespaceMatchType],

169 AllOf[BaseParenthesizableWhitespaceMatchType],

170 ] = DoNotCare()

171 whitespace_after: Union[

172 BaseParenthesizableWhitespaceMatchType,

173 DoNotCareSentinel,

174 OneOf[BaseParenthesizableWhitespaceMatchType],

175 AllOf[BaseParenthesizableWhitespaceMatchType],

176 ] = DoNotCare()

177 metadata: Union[

178 MetadataMatchType,

179 DoNotCareSentinel,

180 OneOf[MetadataMatchType],

181 AllOf[MetadataMatchType],

182 ] = DoNotCare()

183

184

185@dataclass(frozen=True, eq=False, unsafe_hash=False)

186class AddAssign(BaseAugOp, BaseMatcherNode):

187 whitespace_before: Union[

188 BaseParenthesizableWhitespaceMatchType,

189 DoNotCareSentinel,

190 OneOf[BaseParenthesizableWhitespaceMatchType],

191 AllOf[BaseParenthesizableWhitespaceMatchType],

192 ] = DoNotCare()

193 whitespace_after: Union[

194 BaseParenthesizableWhitespaceMatchType,

195 DoNotCareSentinel,

196 OneOf[BaseParenthesizableWhitespaceMatchType],

197 AllOf[BaseParenthesizableWhitespaceMatchType],

198 ] = DoNotCare()

199 metadata: Union[

200 MetadataMatchType,

201 DoNotCareSentinel,

202 OneOf[MetadataMatchType],

203 AllOf[MetadataMatchType],

204 ] = DoNotCare()

205

206

207@dataclass(frozen=True, eq=False, unsafe_hash=False)

208class And(BaseBooleanOp, BaseMatcherNode):

209 whitespace_before: Union[

210 BaseParenthesizableWhitespaceMatchType,

211 DoNotCareSentinel,

212 OneOf[BaseParenthesizableWhitespaceMatchType],

213 AllOf[BaseParenthesizableWhitespaceMatchType],

214 ] = DoNotCare()

215 whitespace_after: Union[

216 BaseParenthesizableWhitespaceMatchType,

217 DoNotCareSentinel,

218 OneOf[BaseParenthesizableWhitespaceMatchType],

219 AllOf[BaseParenthesizableWhitespaceMatchType],

220 ] = DoNotCare()

221 metadata: Union[

222 MetadataMatchType,

223 DoNotCareSentinel,

224 OneOf[MetadataMatchType],

225 AllOf[MetadataMatchType],

226 ] = DoNotCare()

227

228

229BaseAssignTargetExpressionMatchType = Union[

230 "BaseAssignTargetExpression",

231 MetadataMatchType,

232 MatchIfTrue[cst.BaseAssignTargetExpression],

233]

234AnnotationMatchType = Union[

235 "Annotation", MetadataMatchType, MatchIfTrue[cst.Annotation]

236]

237AssignEqualMatchType = Union[

238 "AssignEqual", MetadataMatchType, MatchIfTrue[cst.AssignEqual]

239]

240SemicolonMatchType = Union["Semicolon", MetadataMatchType, MatchIfTrue[cst.Semicolon]]

241

242

243@dataclass(frozen=True, eq=False, unsafe_hash=False)

244class AnnAssign(BaseSmallStatement, BaseMatcherNode):

245 target: Union[

246 BaseAssignTargetExpressionMatchType,

247 DoNotCareSentinel,

248 OneOf[BaseAssignTargetExpressionMatchType],

249 AllOf[BaseAssignTargetExpressionMatchType],

250 ] = DoNotCare()

251 annotation: Union[

252 AnnotationMatchType,

253 DoNotCareSentinel,

254 OneOf[AnnotationMatchType],

255 AllOf[AnnotationMatchType],

256 ] = DoNotCare()

257 value: Union[

258 Optional["BaseExpression"],

259 MetadataMatchType,

260 MatchIfTrue[Optional[cst.BaseExpression]],

261 DoNotCareSentinel,

262 OneOf[

263 Union[

264 Optional["BaseExpression"],

265 MetadataMatchType,

266 MatchIfTrue[Optional[cst.BaseExpression]],

267 ]

268 ],

269 AllOf[

270 Union[

271 Optional["BaseExpression"],

272 MetadataMatchType,

273 MatchIfTrue[Optional[cst.BaseExpression]],

274 ]

275 ],

276 ] = DoNotCare()

277 equal: Union[

278 AssignEqualMatchType,

279 DoNotCareSentinel,

280 OneOf[AssignEqualMatchType],

281 AllOf[AssignEqualMatchType],

282 ] = DoNotCare()

283 semicolon: Union[

284 SemicolonMatchType,

285 DoNotCareSentinel,

286 OneOf[SemicolonMatchType],

287 AllOf[SemicolonMatchType],

288 ] = DoNotCare()

289 metadata: Union[

290 MetadataMatchType,

291 DoNotCareSentinel,

292 OneOf[MetadataMatchType],

293 AllOf[MetadataMatchType],

294 ] = DoNotCare()

295

296

297BaseExpressionMatchType = Union[

298 "BaseExpression", MetadataMatchType, MatchIfTrue[cst.BaseExpression]

299]

300

301

302@dataclass(frozen=True, eq=False, unsafe_hash=False)

303class Annotation(BaseMatcherNode):

304 annotation: Union[

305 BaseExpressionMatchType,

306 DoNotCareSentinel,

307 OneOf[BaseExpressionMatchType],

308 AllOf[BaseExpressionMatchType],

309 ] = DoNotCare()

310 whitespace_before_indicator: Union[

311 BaseParenthesizableWhitespaceMatchType,

312 DoNotCareSentinel,

313 OneOf[BaseParenthesizableWhitespaceMatchType],

314 AllOf[BaseParenthesizableWhitespaceMatchType],

315 ] = DoNotCare()

316 whitespace_after_indicator: Union[

317 BaseParenthesizableWhitespaceMatchType,

318 DoNotCareSentinel,

319 OneOf[BaseParenthesizableWhitespaceMatchType],

320 AllOf[BaseParenthesizableWhitespaceMatchType],

321 ] = DoNotCare()

322 metadata: Union[

323 MetadataMatchType,

324 DoNotCareSentinel,

325 OneOf[MetadataMatchType],

326 AllOf[MetadataMatchType],

327 ] = DoNotCare()

328

329

330CommaMatchType = Union["Comma", MetadataMatchType, MatchIfTrue[cst.Comma]]

331

332

333@dataclass(frozen=True, eq=False, unsafe_hash=False)

334class Arg(BaseMatcherNode):

335 value: Union[

336 BaseExpressionMatchType,

337 DoNotCareSentinel,

338 OneOf[BaseExpressionMatchType],

339 AllOf[BaseExpressionMatchType],

340 ] = DoNotCare()

341 keyword: Union[

342 Optional["Name"],

343 MetadataMatchType,

344 MatchIfTrue[Optional[cst.Name]],

345 DoNotCareSentinel,

346 OneOf[

347 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

348 ],

349 AllOf[

350 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

351 ],

352 ] = DoNotCare()

353 equal: Union[

354 AssignEqualMatchType,

355 DoNotCareSentinel,

356 OneOf[AssignEqualMatchType],

357 AllOf[AssignEqualMatchType],

358 ] = DoNotCare()

359 comma: Union[

360 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

361 ] = DoNotCare()

362 star: Union[

363 Literal["", "*", "**"],

364 MetadataMatchType,

365 MatchIfTrue[Literal["", "*", "**"]],

366 DoNotCareSentinel,

367 OneOf[

368 Union[

369 Literal["", "*", "**"],

370 MetadataMatchType,

371 MatchIfTrue[Literal["", "*", "**"]],

372 ]

373 ],

374 AllOf[

375 Union[

376 Literal["", "*", "**"],

377 MetadataMatchType,

378 MatchIfTrue[Literal["", "*", "**"]],

379 ]

380 ],

381 ] = DoNotCare()

382 whitespace_after_star: Union[

383 BaseParenthesizableWhitespaceMatchType,

384 DoNotCareSentinel,

385 OneOf[BaseParenthesizableWhitespaceMatchType],

386 AllOf[BaseParenthesizableWhitespaceMatchType],

387 ] = DoNotCare()

388 whitespace_after_arg: Union[

389 BaseParenthesizableWhitespaceMatchType,

390 DoNotCareSentinel,

391 OneOf[BaseParenthesizableWhitespaceMatchType],

392 AllOf[BaseParenthesizableWhitespaceMatchType],

393 ] = DoNotCare()

394 metadata: Union[

395 MetadataMatchType,

396 DoNotCareSentinel,

397 OneOf[MetadataMatchType],

398 AllOf[MetadataMatchType],

399 ] = DoNotCare()

400

401

402NameOrTupleOrListMatchType = Union[

403 "Name",

404 "Tuple",

405 "List",

406 MetadataMatchType,

407 MatchIfTrue[Union[cst.Name, cst.Tuple, cst.List]],

408]

409

410

411@dataclass(frozen=True, eq=False, unsafe_hash=False)

412class AsName(BaseMatcherNode):

413 name: Union[

414 NameOrTupleOrListMatchType,

415 DoNotCareSentinel,

416 OneOf[NameOrTupleOrListMatchType],

417 AllOf[NameOrTupleOrListMatchType],

418 ] = DoNotCare()

419 whitespace_before_as: Union[

420 BaseParenthesizableWhitespaceMatchType,

421 DoNotCareSentinel,

422 OneOf[BaseParenthesizableWhitespaceMatchType],

423 AllOf[BaseParenthesizableWhitespaceMatchType],

424 ] = DoNotCare()

425 whitespace_after_as: Union[

426 BaseParenthesizableWhitespaceMatchType,

427 DoNotCareSentinel,

428 OneOf[BaseParenthesizableWhitespaceMatchType],

429 AllOf[BaseParenthesizableWhitespaceMatchType],

430 ] = DoNotCare()

431 metadata: Union[

432 MetadataMatchType,

433 DoNotCareSentinel,

434 OneOf[MetadataMatchType],

435 AllOf[MetadataMatchType],

436 ] = DoNotCare()

437

438

439SimpleWhitespaceMatchType = Union[

440 "SimpleWhitespace", MetadataMatchType, MatchIfTrue[cst.SimpleWhitespace]

441]

442

443

444@dataclass(frozen=True, eq=False, unsafe_hash=False)

445class Assert(BaseSmallStatement, BaseMatcherNode):

446 test: Union[

447 BaseExpressionMatchType,

448 DoNotCareSentinel,

449 OneOf[BaseExpressionMatchType],

450 AllOf[BaseExpressionMatchType],

451 ] = DoNotCare()

452 msg: Union[

453 Optional["BaseExpression"],

454 MetadataMatchType,

455 MatchIfTrue[Optional[cst.BaseExpression]],

456 DoNotCareSentinel,

457 OneOf[

458 Union[

459 Optional["BaseExpression"],

460 MetadataMatchType,

461 MatchIfTrue[Optional[cst.BaseExpression]],

462 ]

463 ],

464 AllOf[

465 Union[

466 Optional["BaseExpression"],

467 MetadataMatchType,

468 MatchIfTrue[Optional[cst.BaseExpression]],

469 ]

470 ],

471 ] = DoNotCare()

472 comma: Union[

473 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

474 ] = DoNotCare()

475 whitespace_after_assert: Union[

476 SimpleWhitespaceMatchType,

477 DoNotCareSentinel,

478 OneOf[SimpleWhitespaceMatchType],

479 AllOf[SimpleWhitespaceMatchType],

480 ] = DoNotCare()

481 semicolon: Union[

482 SemicolonMatchType,

483 DoNotCareSentinel,

484 OneOf[SemicolonMatchType],

485 AllOf[SemicolonMatchType],

486 ] = DoNotCare()

487 metadata: Union[

488 MetadataMatchType,

489 DoNotCareSentinel,

490 OneOf[MetadataMatchType],

491 AllOf[MetadataMatchType],

492 ] = DoNotCare()

493

494

495AssignTargetMatchType = Union[

496 "AssignTarget", MetadataMatchType, MatchIfTrue[cst.AssignTarget]

497]

498

499

500@dataclass(frozen=True, eq=False, unsafe_hash=False)

501class Assign(BaseSmallStatement, BaseMatcherNode):

502 targets: Union[

503 Sequence[

504 Union[

505 AssignTargetMatchType,

506 DoNotCareSentinel,

507 OneOf[AssignTargetMatchType],

508 AllOf[AssignTargetMatchType],

509 AtLeastN[

510 Union[

511 AssignTargetMatchType,

512 DoNotCareSentinel,

513 OneOf[AssignTargetMatchType],

514 AllOf[AssignTargetMatchType],

515 ]

516 ],

517 AtMostN[

518 Union[

519 AssignTargetMatchType,

520 DoNotCareSentinel,

521 OneOf[AssignTargetMatchType],

522 AllOf[AssignTargetMatchType],

523 ]

524 ],

525 ]

526 ],

527 DoNotCareSentinel,

528 MatchIfTrue[Sequence[cst.AssignTarget]],

529 OneOf[

530 Union[

531 Sequence[

532 Union[

533 AssignTargetMatchType,

534 OneOf[AssignTargetMatchType],

535 AllOf[AssignTargetMatchType],

536 AtLeastN[

537 Union[

538 AssignTargetMatchType,

539 OneOf[AssignTargetMatchType],

540 AllOf[AssignTargetMatchType],

541 ]

542 ],

543 AtMostN[

544 Union[

545 AssignTargetMatchType,

546 OneOf[AssignTargetMatchType],

547 AllOf[AssignTargetMatchType],

548 ]

549 ],

550 ]

551 ],

552 MatchIfTrue[Sequence[cst.AssignTarget]],

553 ]

554 ],

555 AllOf[

556 Union[

557 Sequence[

558 Union[

559 AssignTargetMatchType,

560 OneOf[AssignTargetMatchType],

561 AllOf[AssignTargetMatchType],

562 AtLeastN[

563 Union[

564 AssignTargetMatchType,

565 OneOf[AssignTargetMatchType],

566 AllOf[AssignTargetMatchType],

567 ]

568 ],

569 AtMostN[

570 Union[

571 AssignTargetMatchType,

572 OneOf[AssignTargetMatchType],

573 AllOf[AssignTargetMatchType],

574 ]

575 ],

576 ]

577 ],

578 MatchIfTrue[Sequence[cst.AssignTarget]],

579 ]

580 ],

581 ] = DoNotCare()

582 value: Union[

583 BaseExpressionMatchType,

584 DoNotCareSentinel,

585 OneOf[BaseExpressionMatchType],

586 AllOf[BaseExpressionMatchType],

587 ] = DoNotCare()

588 semicolon: Union[

589 SemicolonMatchType,

590 DoNotCareSentinel,

591 OneOf[SemicolonMatchType],

592 AllOf[SemicolonMatchType],

593 ] = DoNotCare()

594 metadata: Union[

595 MetadataMatchType,

596 DoNotCareSentinel,

597 OneOf[MetadataMatchType],

598 AllOf[MetadataMatchType],

599 ] = DoNotCare()

600

601

602@dataclass(frozen=True, eq=False, unsafe_hash=False)

603class AssignEqual(BaseMatcherNode):

604 whitespace_before: Union[

605 BaseParenthesizableWhitespaceMatchType,

606 DoNotCareSentinel,

607 OneOf[BaseParenthesizableWhitespaceMatchType],

608 AllOf[BaseParenthesizableWhitespaceMatchType],

609 ] = DoNotCare()

610 whitespace_after: Union[

611 BaseParenthesizableWhitespaceMatchType,

612 DoNotCareSentinel,

613 OneOf[BaseParenthesizableWhitespaceMatchType],

614 AllOf[BaseParenthesizableWhitespaceMatchType],

615 ] = DoNotCare()

616 metadata: Union[

617 MetadataMatchType,

618 DoNotCareSentinel,

619 OneOf[MetadataMatchType],

620 AllOf[MetadataMatchType],

621 ] = DoNotCare()

622

623

624@dataclass(frozen=True, eq=False, unsafe_hash=False)

625class AssignTarget(BaseMatcherNode):

626 target: Union[

627 BaseAssignTargetExpressionMatchType,

628 DoNotCareSentinel,

629 OneOf[BaseAssignTargetExpressionMatchType],

630 AllOf[BaseAssignTargetExpressionMatchType],

631 ] = DoNotCare()

632 whitespace_before_equal: Union[

633 SimpleWhitespaceMatchType,

634 DoNotCareSentinel,

635 OneOf[SimpleWhitespaceMatchType],

636 AllOf[SimpleWhitespaceMatchType],

637 ] = DoNotCare()

638 whitespace_after_equal: Union[

639 SimpleWhitespaceMatchType,

640 DoNotCareSentinel,

641 OneOf[SimpleWhitespaceMatchType],

642 AllOf[SimpleWhitespaceMatchType],

643 ] = DoNotCare()

644 metadata: Union[

645 MetadataMatchType,

646 DoNotCareSentinel,

647 OneOf[MetadataMatchType],

648 AllOf[MetadataMatchType],

649 ] = DoNotCare()

650

651

652@dataclass(frozen=True, eq=False, unsafe_hash=False)

653class Asynchronous(BaseMatcherNode):

654 whitespace_after: Union[

655 SimpleWhitespaceMatchType,

656 DoNotCareSentinel,

657 OneOf[SimpleWhitespaceMatchType],

658 AllOf[SimpleWhitespaceMatchType],

659 ] = DoNotCare()

660 metadata: Union[

661 MetadataMatchType,

662 DoNotCareSentinel,

663 OneOf[MetadataMatchType],

664 AllOf[MetadataMatchType],

665 ] = DoNotCare()

666

667

668NameMatchType = Union["Name", MetadataMatchType, MatchIfTrue[cst.Name]]

669DotMatchType = Union["Dot", MetadataMatchType, MatchIfTrue[cst.Dot]]

670LeftParenMatchType = Union["LeftParen", MetadataMatchType, MatchIfTrue[cst.LeftParen]]

671RightParenMatchType = Union[

672 "RightParen", MetadataMatchType, MatchIfTrue[cst.RightParen]

673]

674

675

676@dataclass(frozen=True, eq=False, unsafe_hash=False)

677class Attribute(

678 BaseAssignTargetExpression, BaseDelTargetExpression, BaseExpression, BaseMatcherNode

679):

680 value: Union[

681 BaseExpressionMatchType,

682 DoNotCareSentinel,

683 OneOf[BaseExpressionMatchType],

684 AllOf[BaseExpressionMatchType],

685 ] = DoNotCare()

686 attr: Union[

687 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

688 ] = DoNotCare()

689 dot: Union[

690 DotMatchType, DoNotCareSentinel, OneOf[DotMatchType], AllOf[DotMatchType]

691 ] = DoNotCare()

692 lpar: Union[

693 Sequence[

694 Union[

695 LeftParenMatchType,

696 DoNotCareSentinel,

697 OneOf[LeftParenMatchType],

698 AllOf[LeftParenMatchType],

699 AtLeastN[

700 Union[

701 LeftParenMatchType,

702 DoNotCareSentinel,

703 OneOf[LeftParenMatchType],

704 AllOf[LeftParenMatchType],

705 ]

706 ],

707 AtMostN[

708 Union[

709 LeftParenMatchType,

710 DoNotCareSentinel,

711 OneOf[LeftParenMatchType],

712 AllOf[LeftParenMatchType],

713 ]

714 ],

715 ]

716 ],

717 DoNotCareSentinel,

718 MatchIfTrue[Sequence[cst.LeftParen]],

719 OneOf[

720 Union[

721 Sequence[

722 Union[

723 LeftParenMatchType,

724 OneOf[LeftParenMatchType],

725 AllOf[LeftParenMatchType],

726 AtLeastN[

727 Union[

728 LeftParenMatchType,

729 OneOf[LeftParenMatchType],

730 AllOf[LeftParenMatchType],

731 ]

732 ],

733 AtMostN[

734 Union[

735 LeftParenMatchType,

736 OneOf[LeftParenMatchType],

737 AllOf[LeftParenMatchType],

738 ]

739 ],

740 ]

741 ],

742 MatchIfTrue[Sequence[cst.LeftParen]],

743 ]

744 ],

745 AllOf[

746 Union[

747 Sequence[

748 Union[

749 LeftParenMatchType,

750 OneOf[LeftParenMatchType],

751 AllOf[LeftParenMatchType],

752 AtLeastN[

753 Union[

754 LeftParenMatchType,

755 OneOf[LeftParenMatchType],

756 AllOf[LeftParenMatchType],

757 ]

758 ],

759 AtMostN[

760 Union[

761 LeftParenMatchType,

762 OneOf[LeftParenMatchType],

763 AllOf[LeftParenMatchType],

764 ]

765 ],

766 ]

767 ],

768 MatchIfTrue[Sequence[cst.LeftParen]],

769 ]

770 ],

771 ] = DoNotCare()

772 rpar: Union[

773 Sequence[

774 Union[

775 RightParenMatchType,

776 DoNotCareSentinel,

777 OneOf[RightParenMatchType],

778 AllOf[RightParenMatchType],

779 AtLeastN[

780 Union[

781 RightParenMatchType,

782 DoNotCareSentinel,

783 OneOf[RightParenMatchType],

784 AllOf[RightParenMatchType],

785 ]

786 ],

787 AtMostN[

788 Union[

789 RightParenMatchType,

790 DoNotCareSentinel,

791 OneOf[RightParenMatchType],

792 AllOf[RightParenMatchType],

793 ]

794 ],

795 ]

796 ],

797 DoNotCareSentinel,

798 MatchIfTrue[Sequence[cst.RightParen]],

799 OneOf[

800 Union[

801 Sequence[

802 Union[

803 RightParenMatchType,

804 OneOf[RightParenMatchType],

805 AllOf[RightParenMatchType],

806 AtLeastN[

807 Union[

808 RightParenMatchType,

809 OneOf[RightParenMatchType],

810 AllOf[RightParenMatchType],

811 ]

812 ],

813 AtMostN[

814 Union[

815 RightParenMatchType,

816 OneOf[RightParenMatchType],

817 AllOf[RightParenMatchType],

818 ]

819 ],

820 ]

821 ],

822 MatchIfTrue[Sequence[cst.RightParen]],

823 ]

824 ],

825 AllOf[

826 Union[

827 Sequence[

828 Union[

829 RightParenMatchType,

830 OneOf[RightParenMatchType],

831 AllOf[RightParenMatchType],

832 AtLeastN[

833 Union[

834 RightParenMatchType,

835 OneOf[RightParenMatchType],

836 AllOf[RightParenMatchType],

837 ]

838 ],

839 AtMostN[

840 Union[

841 RightParenMatchType,

842 OneOf[RightParenMatchType],

843 AllOf[RightParenMatchType],

844 ]

845 ],

846 ]

847 ],

848 MatchIfTrue[Sequence[cst.RightParen]],

849 ]

850 ],

851 ] = DoNotCare()

852 metadata: Union[

853 MetadataMatchType,

854 DoNotCareSentinel,

855 OneOf[MetadataMatchType],

856 AllOf[MetadataMatchType],

857 ] = DoNotCare()

858

859

860BaseAugOpMatchType = Union["BaseAugOp", MetadataMatchType, MatchIfTrue[cst.BaseAugOp]]

861

862

863@dataclass(frozen=True, eq=False, unsafe_hash=False)

864class AugAssign(BaseSmallStatement, BaseMatcherNode):

865 target: Union[

866 BaseAssignTargetExpressionMatchType,

867 DoNotCareSentinel,

868 OneOf[BaseAssignTargetExpressionMatchType],

869 AllOf[BaseAssignTargetExpressionMatchType],

870 ] = DoNotCare()

871 operator: Union[

872 BaseAugOpMatchType,

873 DoNotCareSentinel,

874 OneOf[BaseAugOpMatchType],

875 AllOf[BaseAugOpMatchType],

876 ] = DoNotCare()

877 value: Union[

878 BaseExpressionMatchType,

879 DoNotCareSentinel,

880 OneOf[BaseExpressionMatchType],

881 AllOf[BaseExpressionMatchType],

882 ] = DoNotCare()

883 semicolon: Union[

884 SemicolonMatchType,

885 DoNotCareSentinel,

886 OneOf[SemicolonMatchType],

887 AllOf[SemicolonMatchType],

888 ] = DoNotCare()

889 metadata: Union[

890 MetadataMatchType,

891 DoNotCareSentinel,

892 OneOf[MetadataMatchType],

893 AllOf[MetadataMatchType],

894 ] = DoNotCare()

895

896

897@dataclass(frozen=True, eq=False, unsafe_hash=False)

898class Await(BaseExpression, BaseMatcherNode):

899 expression: Union[

900 BaseExpressionMatchType,

901 DoNotCareSentinel,

902 OneOf[BaseExpressionMatchType],

903 AllOf[BaseExpressionMatchType],

904 ] = DoNotCare()

905 lpar: Union[

906 Sequence[

907 Union[

908 LeftParenMatchType,

909 DoNotCareSentinel,

910 OneOf[LeftParenMatchType],

911 AllOf[LeftParenMatchType],

912 AtLeastN[

913 Union[

914 LeftParenMatchType,

915 DoNotCareSentinel,

916 OneOf[LeftParenMatchType],

917 AllOf[LeftParenMatchType],

918 ]

919 ],

920 AtMostN[

921 Union[

922 LeftParenMatchType,

923 DoNotCareSentinel,

924 OneOf[LeftParenMatchType],

925 AllOf[LeftParenMatchType],

926 ]

927 ],

928 ]

929 ],

930 DoNotCareSentinel,

931 MatchIfTrue[Sequence[cst.LeftParen]],

932 OneOf[

933 Union[

934 Sequence[

935 Union[

936 LeftParenMatchType,

937 OneOf[LeftParenMatchType],

938 AllOf[LeftParenMatchType],

939 AtLeastN[

940 Union[

941 LeftParenMatchType,

942 OneOf[LeftParenMatchType],

943 AllOf[LeftParenMatchType],

944 ]

945 ],

946 AtMostN[

947 Union[

948 LeftParenMatchType,

949 OneOf[LeftParenMatchType],

950 AllOf[LeftParenMatchType],

951 ]

952 ],

953 ]

954 ],

955 MatchIfTrue[Sequence[cst.LeftParen]],

956 ]

957 ],

958 AllOf[

959 Union[

960 Sequence[

961 Union[

962 LeftParenMatchType,

963 OneOf[LeftParenMatchType],

964 AllOf[LeftParenMatchType],

965 AtLeastN[

966 Union[

967 LeftParenMatchType,

968 OneOf[LeftParenMatchType],

969 AllOf[LeftParenMatchType],

970 ]

971 ],

972 AtMostN[

973 Union[

974 LeftParenMatchType,

975 OneOf[LeftParenMatchType],

976 AllOf[LeftParenMatchType],

977 ]

978 ],

979 ]

980 ],

981 MatchIfTrue[Sequence[cst.LeftParen]],

982 ]

983 ],

984 ] = DoNotCare()

985 rpar: Union[

986 Sequence[

987 Union[

988 RightParenMatchType,

989 DoNotCareSentinel,

990 OneOf[RightParenMatchType],

991 AllOf[RightParenMatchType],

992 AtLeastN[

993 Union[

994 RightParenMatchType,

995 DoNotCareSentinel,

996 OneOf[RightParenMatchType],

997 AllOf[RightParenMatchType],

998 ]

999 ],

1000 AtMostN[

1001 Union[

1002 RightParenMatchType,

1003 DoNotCareSentinel,

1004 OneOf[RightParenMatchType],

1005 AllOf[RightParenMatchType],

1006 ]

1007 ],

1008 ]

1009 ],

1010 DoNotCareSentinel,

1011 MatchIfTrue[Sequence[cst.RightParen]],

1012 OneOf[

1013 Union[

1014 Sequence[

1015 Union[

1016 RightParenMatchType,

1017 OneOf[RightParenMatchType],

1018 AllOf[RightParenMatchType],

1019 AtLeastN[

1020 Union[

1021 RightParenMatchType,

1022 OneOf[RightParenMatchType],

1023 AllOf[RightParenMatchType],

1024 ]

1025 ],

1026 AtMostN[

1027 Union[

1028 RightParenMatchType,

1029 OneOf[RightParenMatchType],

1030 AllOf[RightParenMatchType],

1031 ]

1032 ],

1033 ]

1034 ],

1035 MatchIfTrue[Sequence[cst.RightParen]],

1036 ]

1037 ],

1038 AllOf[

1039 Union[

1040 Sequence[

1041 Union[

1042 RightParenMatchType,

1043 OneOf[RightParenMatchType],

1044 AllOf[RightParenMatchType],

1045 AtLeastN[

1046 Union[

1047 RightParenMatchType,

1048 OneOf[RightParenMatchType],

1049 AllOf[RightParenMatchType],

1050 ]

1051 ],

1052 AtMostN[

1053 Union[

1054 RightParenMatchType,

1055 OneOf[RightParenMatchType],

1056 AllOf[RightParenMatchType],

1057 ]

1058 ],

1059 ]

1060 ],

1061 MatchIfTrue[Sequence[cst.RightParen]],

1062 ]

1063 ],

1064 ] = DoNotCare()

1065 whitespace_after_await: Union[

1066 BaseParenthesizableWhitespaceMatchType,

1067 DoNotCareSentinel,

1068 OneOf[BaseParenthesizableWhitespaceMatchType],

1069 AllOf[BaseParenthesizableWhitespaceMatchType],

1070 ] = DoNotCare()

1071 metadata: Union[

1072 MetadataMatchType,

1073 DoNotCareSentinel,

1074 OneOf[MetadataMatchType],

1075 AllOf[MetadataMatchType],

1076 ] = DoNotCare()

1077

1078

1079BaseBinaryOpMatchType = Union[

1080 "BaseBinaryOp", MetadataMatchType, MatchIfTrue[cst.BaseBinaryOp]

1081]

1082

1083

1084@dataclass(frozen=True, eq=False, unsafe_hash=False)

1085class BinaryOperation(BaseExpression, BaseMatcherNode):

1086 left: Union[

1087 BaseExpressionMatchType,

1088 DoNotCareSentinel,

1089 OneOf[BaseExpressionMatchType],

1090 AllOf[BaseExpressionMatchType],

1091 ] = DoNotCare()

1092 operator: Union[

1093 BaseBinaryOpMatchType,

1094 DoNotCareSentinel,

1095 OneOf[BaseBinaryOpMatchType],

1096 AllOf[BaseBinaryOpMatchType],

1097 ] = DoNotCare()

1098 right: Union[

1099 BaseExpressionMatchType,

1100 DoNotCareSentinel,

1101 OneOf[BaseExpressionMatchType],

1102 AllOf[BaseExpressionMatchType],

1103 ] = DoNotCare()

1104 lpar: Union[

1105 Sequence[

1106 Union[

1107 LeftParenMatchType,

1108 DoNotCareSentinel,

1109 OneOf[LeftParenMatchType],

1110 AllOf[LeftParenMatchType],

1111 AtLeastN[

1112 Union[

1113 LeftParenMatchType,

1114 DoNotCareSentinel,

1115 OneOf[LeftParenMatchType],

1116 AllOf[LeftParenMatchType],

1117 ]

1118 ],

1119 AtMostN[

1120 Union[

1121 LeftParenMatchType,

1122 DoNotCareSentinel,

1123 OneOf[LeftParenMatchType],

1124 AllOf[LeftParenMatchType],

1125 ]

1126 ],

1127 ]

1128 ],

1129 DoNotCareSentinel,

1130 MatchIfTrue[Sequence[cst.LeftParen]],

1131 OneOf[

1132 Union[

1133 Sequence[

1134 Union[

1135 LeftParenMatchType,

1136 OneOf[LeftParenMatchType],

1137 AllOf[LeftParenMatchType],

1138 AtLeastN[

1139 Union[

1140 LeftParenMatchType,

1141 OneOf[LeftParenMatchType],

1142 AllOf[LeftParenMatchType],

1143 ]

1144 ],

1145 AtMostN[

1146 Union[

1147 LeftParenMatchType,

1148 OneOf[LeftParenMatchType],

1149 AllOf[LeftParenMatchType],

1150 ]

1151 ],

1152 ]

1153 ],

1154 MatchIfTrue[Sequence[cst.LeftParen]],

1155 ]

1156 ],

1157 AllOf[

1158 Union[

1159 Sequence[

1160 Union[

1161 LeftParenMatchType,

1162 OneOf[LeftParenMatchType],

1163 AllOf[LeftParenMatchType],

1164 AtLeastN[

1165 Union[

1166 LeftParenMatchType,

1167 OneOf[LeftParenMatchType],

1168 AllOf[LeftParenMatchType],

1169 ]

1170 ],

1171 AtMostN[

1172 Union[

1173 LeftParenMatchType,

1174 OneOf[LeftParenMatchType],

1175 AllOf[LeftParenMatchType],

1176 ]

1177 ],

1178 ]

1179 ],

1180 MatchIfTrue[Sequence[cst.LeftParen]],

1181 ]

1182 ],

1183 ] = DoNotCare()

1184 rpar: Union[

1185 Sequence[

1186 Union[

1187 RightParenMatchType,

1188 DoNotCareSentinel,

1189 OneOf[RightParenMatchType],

1190 AllOf[RightParenMatchType],

1191 AtLeastN[

1192 Union[

1193 RightParenMatchType,

1194 DoNotCareSentinel,

1195 OneOf[RightParenMatchType],

1196 AllOf[RightParenMatchType],

1197 ]

1198 ],

1199 AtMostN[

1200 Union[

1201 RightParenMatchType,

1202 DoNotCareSentinel,

1203 OneOf[RightParenMatchType],

1204 AllOf[RightParenMatchType],

1205 ]

1206 ],

1207 ]

1208 ],

1209 DoNotCareSentinel,

1210 MatchIfTrue[Sequence[cst.RightParen]],

1211 OneOf[

1212 Union[

1213 Sequence[

1214 Union[

1215 RightParenMatchType,

1216 OneOf[RightParenMatchType],

1217 AllOf[RightParenMatchType],

1218 AtLeastN[

1219 Union[

1220 RightParenMatchType,

1221 OneOf[RightParenMatchType],

1222 AllOf[RightParenMatchType],

1223 ]

1224 ],

1225 AtMostN[

1226 Union[

1227 RightParenMatchType,

1228 OneOf[RightParenMatchType],

1229 AllOf[RightParenMatchType],

1230 ]

1231 ],

1232 ]

1233 ],

1234 MatchIfTrue[Sequence[cst.RightParen]],

1235 ]

1236 ],

1237 AllOf[

1238 Union[

1239 Sequence[

1240 Union[

1241 RightParenMatchType,

1242 OneOf[RightParenMatchType],

1243 AllOf[RightParenMatchType],

1244 AtLeastN[

1245 Union[

1246 RightParenMatchType,

1247 OneOf[RightParenMatchType],

1248 AllOf[RightParenMatchType],

1249 ]

1250 ],

1251 AtMostN[

1252 Union[

1253 RightParenMatchType,

1254 OneOf[RightParenMatchType],

1255 AllOf[RightParenMatchType],

1256 ]

1257 ],

1258 ]

1259 ],

1260 MatchIfTrue[Sequence[cst.RightParen]],

1261 ]

1262 ],

1263 ] = DoNotCare()

1264 metadata: Union[

1265 MetadataMatchType,

1266 DoNotCareSentinel,

1267 OneOf[MetadataMatchType],

1268 AllOf[MetadataMatchType],

1269 ] = DoNotCare()

1270

1271

1272@dataclass(frozen=True, eq=False, unsafe_hash=False)

1273class BitAnd(BaseBinaryOp, BaseMatcherNode):

1274 whitespace_before: Union[

1275 BaseParenthesizableWhitespaceMatchType,

1276 DoNotCareSentinel,

1277 OneOf[BaseParenthesizableWhitespaceMatchType],

1278 AllOf[BaseParenthesizableWhitespaceMatchType],

1279 ] = DoNotCare()

1280 whitespace_after: Union[

1281 BaseParenthesizableWhitespaceMatchType,

1282 DoNotCareSentinel,

1283 OneOf[BaseParenthesizableWhitespaceMatchType],

1284 AllOf[BaseParenthesizableWhitespaceMatchType],

1285 ] = DoNotCare()

1286 metadata: Union[

1287 MetadataMatchType,

1288 DoNotCareSentinel,

1289 OneOf[MetadataMatchType],

1290 AllOf[MetadataMatchType],

1291 ] = DoNotCare()

1292

1293

1294@dataclass(frozen=True, eq=False, unsafe_hash=False)

1295class BitAndAssign(BaseAugOp, BaseMatcherNode):

1296 whitespace_before: Union[

1297 BaseParenthesizableWhitespaceMatchType,

1298 DoNotCareSentinel,

1299 OneOf[BaseParenthesizableWhitespaceMatchType],

1300 AllOf[BaseParenthesizableWhitespaceMatchType],

1301 ] = DoNotCare()

1302 whitespace_after: Union[

1303 BaseParenthesizableWhitespaceMatchType,

1304 DoNotCareSentinel,

1305 OneOf[BaseParenthesizableWhitespaceMatchType],

1306 AllOf[BaseParenthesizableWhitespaceMatchType],

1307 ] = DoNotCare()

1308 metadata: Union[

1309 MetadataMatchType,

1310 DoNotCareSentinel,

1311 OneOf[MetadataMatchType],

1312 AllOf[MetadataMatchType],

1313 ] = DoNotCare()

1314

1315

1316@dataclass(frozen=True, eq=False, unsafe_hash=False)

1317class BitInvert(BaseUnaryOp, BaseMatcherNode):

1318 whitespace_after: Union[

1319 BaseParenthesizableWhitespaceMatchType,

1320 DoNotCareSentinel,

1321 OneOf[BaseParenthesizableWhitespaceMatchType],

1322 AllOf[BaseParenthesizableWhitespaceMatchType],

1323 ] = DoNotCare()

1324 metadata: Union[

1325 MetadataMatchType,

1326 DoNotCareSentinel,

1327 OneOf[MetadataMatchType],

1328 AllOf[MetadataMatchType],

1329 ] = DoNotCare()

1330

1331

1332@dataclass(frozen=True, eq=False, unsafe_hash=False)

1333class BitOr(BaseBinaryOp, BaseMatcherNode):

1334 whitespace_before: Union[

1335 BaseParenthesizableWhitespaceMatchType,

1336 DoNotCareSentinel,

1337 OneOf[BaseParenthesizableWhitespaceMatchType],

1338 AllOf[BaseParenthesizableWhitespaceMatchType],

1339 ] = DoNotCare()

1340 whitespace_after: Union[

1341 BaseParenthesizableWhitespaceMatchType,

1342 DoNotCareSentinel,

1343 OneOf[BaseParenthesizableWhitespaceMatchType],

1344 AllOf[BaseParenthesizableWhitespaceMatchType],

1345 ] = DoNotCare()

1346 metadata: Union[

1347 MetadataMatchType,

1348 DoNotCareSentinel,

1349 OneOf[MetadataMatchType],

1350 AllOf[MetadataMatchType],

1351 ] = DoNotCare()

1352

1353

1354@dataclass(frozen=True, eq=False, unsafe_hash=False)

1355class BitOrAssign(BaseAugOp, BaseMatcherNode):

1356 whitespace_before: Union[

1357 BaseParenthesizableWhitespaceMatchType,

1358 DoNotCareSentinel,

1359 OneOf[BaseParenthesizableWhitespaceMatchType],

1360 AllOf[BaseParenthesizableWhitespaceMatchType],

1361 ] = DoNotCare()

1362 whitespace_after: Union[

1363 BaseParenthesizableWhitespaceMatchType,

1364 DoNotCareSentinel,

1365 OneOf[BaseParenthesizableWhitespaceMatchType],

1366 AllOf[BaseParenthesizableWhitespaceMatchType],

1367 ] = DoNotCare()

1368 metadata: Union[

1369 MetadataMatchType,

1370 DoNotCareSentinel,

1371 OneOf[MetadataMatchType],

1372 AllOf[MetadataMatchType],

1373 ] = DoNotCare()

1374

1375

1376@dataclass(frozen=True, eq=False, unsafe_hash=False)

1377class BitXor(BaseBinaryOp, BaseMatcherNode):

1378 whitespace_before: Union[

1379 BaseParenthesizableWhitespaceMatchType,

1380 DoNotCareSentinel,

1381 OneOf[BaseParenthesizableWhitespaceMatchType],

1382 AllOf[BaseParenthesizableWhitespaceMatchType],

1383 ] = DoNotCare()

1384 whitespace_after: Union[

1385 BaseParenthesizableWhitespaceMatchType,

1386 DoNotCareSentinel,

1387 OneOf[BaseParenthesizableWhitespaceMatchType],

1388 AllOf[BaseParenthesizableWhitespaceMatchType],

1389 ] = DoNotCare()

1390 metadata: Union[

1391 MetadataMatchType,

1392 DoNotCareSentinel,

1393 OneOf[MetadataMatchType],

1394 AllOf[MetadataMatchType],

1395 ] = DoNotCare()

1396

1397

1398@dataclass(frozen=True, eq=False, unsafe_hash=False)

1399class BitXorAssign(BaseAugOp, BaseMatcherNode):

1400 whitespace_before: Union[

1401 BaseParenthesizableWhitespaceMatchType,

1402 DoNotCareSentinel,

1403 OneOf[BaseParenthesizableWhitespaceMatchType],

1404 AllOf[BaseParenthesizableWhitespaceMatchType],

1405 ] = DoNotCare()

1406 whitespace_after: Union[

1407 BaseParenthesizableWhitespaceMatchType,

1408 DoNotCareSentinel,

1409 OneOf[BaseParenthesizableWhitespaceMatchType],

1410 AllOf[BaseParenthesizableWhitespaceMatchType],

1411 ] = DoNotCare()

1412 metadata: Union[

1413 MetadataMatchType,

1414 DoNotCareSentinel,

1415 OneOf[MetadataMatchType],

1416 AllOf[MetadataMatchType],

1417 ] = DoNotCare()

1418

1419

1420BaseBooleanOpMatchType = Union[

1421 "BaseBooleanOp", MetadataMatchType, MatchIfTrue[cst.BaseBooleanOp]

1422]

1423

1424

1425@dataclass(frozen=True, eq=False, unsafe_hash=False)

1426class BooleanOperation(BaseExpression, BaseMatcherNode):

1427 left: Union[

1428 BaseExpressionMatchType,

1429 DoNotCareSentinel,

1430 OneOf[BaseExpressionMatchType],

1431 AllOf[BaseExpressionMatchType],

1432 ] = DoNotCare()

1433 operator: Union[

1434 BaseBooleanOpMatchType,

1435 DoNotCareSentinel,

1436 OneOf[BaseBooleanOpMatchType],

1437 AllOf[BaseBooleanOpMatchType],

1438 ] = DoNotCare()

1439 right: Union[

1440 BaseExpressionMatchType,

1441 DoNotCareSentinel,

1442 OneOf[BaseExpressionMatchType],

1443 AllOf[BaseExpressionMatchType],

1444 ] = DoNotCare()

1445 lpar: Union[

1446 Sequence[

1447 Union[

1448 LeftParenMatchType,

1449 DoNotCareSentinel,

1450 OneOf[LeftParenMatchType],

1451 AllOf[LeftParenMatchType],

1452 AtLeastN[

1453 Union[

1454 LeftParenMatchType,

1455 DoNotCareSentinel,

1456 OneOf[LeftParenMatchType],

1457 AllOf[LeftParenMatchType],

1458 ]

1459 ],

1460 AtMostN[

1461 Union[

1462 LeftParenMatchType,

1463 DoNotCareSentinel,

1464 OneOf[LeftParenMatchType],

1465 AllOf[LeftParenMatchType],

1466 ]

1467 ],

1468 ]

1469 ],

1470 DoNotCareSentinel,

1471 MatchIfTrue[Sequence[cst.LeftParen]],

1472 OneOf[

1473 Union[

1474 Sequence[

1475 Union[

1476 LeftParenMatchType,

1477 OneOf[LeftParenMatchType],

1478 AllOf[LeftParenMatchType],

1479 AtLeastN[

1480 Union[

1481 LeftParenMatchType,

1482 OneOf[LeftParenMatchType],

1483 AllOf[LeftParenMatchType],

1484 ]

1485 ],

1486 AtMostN[

1487 Union[

1488 LeftParenMatchType,

1489 OneOf[LeftParenMatchType],

1490 AllOf[LeftParenMatchType],

1491 ]

1492 ],

1493 ]

1494 ],

1495 MatchIfTrue[Sequence[cst.LeftParen]],

1496 ]

1497 ],

1498 AllOf[

1499 Union[

1500 Sequence[

1501 Union[

1502 LeftParenMatchType,

1503 OneOf[LeftParenMatchType],

1504 AllOf[LeftParenMatchType],

1505 AtLeastN[

1506 Union[

1507 LeftParenMatchType,

1508 OneOf[LeftParenMatchType],

1509 AllOf[LeftParenMatchType],

1510 ]

1511 ],

1512 AtMostN[

1513 Union[

1514 LeftParenMatchType,

1515 OneOf[LeftParenMatchType],

1516 AllOf[LeftParenMatchType],

1517 ]

1518 ],

1519 ]

1520 ],

1521 MatchIfTrue[Sequence[cst.LeftParen]],

1522 ]

1523 ],

1524 ] = DoNotCare()

1525 rpar: Union[

1526 Sequence[

1527 Union[

1528 RightParenMatchType,

1529 DoNotCareSentinel,

1530 OneOf[RightParenMatchType],

1531 AllOf[RightParenMatchType],

1532 AtLeastN[

1533 Union[

1534 RightParenMatchType,

1535 DoNotCareSentinel,

1536 OneOf[RightParenMatchType],

1537 AllOf[RightParenMatchType],

1538 ]

1539 ],

1540 AtMostN[

1541 Union[

1542 RightParenMatchType,

1543 DoNotCareSentinel,

1544 OneOf[RightParenMatchType],

1545 AllOf[RightParenMatchType],

1546 ]

1547 ],

1548 ]

1549 ],

1550 DoNotCareSentinel,

1551 MatchIfTrue[Sequence[cst.RightParen]],

1552 OneOf[

1553 Union[

1554 Sequence[

1555 Union[

1556 RightParenMatchType,

1557 OneOf[RightParenMatchType],

1558 AllOf[RightParenMatchType],

1559 AtLeastN[

1560 Union[

1561 RightParenMatchType,

1562 OneOf[RightParenMatchType],

1563 AllOf[RightParenMatchType],

1564 ]

1565 ],

1566 AtMostN[

1567 Union[

1568 RightParenMatchType,

1569 OneOf[RightParenMatchType],

1570 AllOf[RightParenMatchType],

1571 ]

1572 ],

1573 ]

1574 ],

1575 MatchIfTrue[Sequence[cst.RightParen]],

1576 ]

1577 ],

1578 AllOf[

1579 Union[

1580 Sequence[

1581 Union[

1582 RightParenMatchType,

1583 OneOf[RightParenMatchType],

1584 AllOf[RightParenMatchType],

1585 AtLeastN[

1586 Union[

1587 RightParenMatchType,

1588 OneOf[RightParenMatchType],

1589 AllOf[RightParenMatchType],

1590 ]

1591 ],

1592 AtMostN[

1593 Union[

1594 RightParenMatchType,

1595 OneOf[RightParenMatchType],

1596 AllOf[RightParenMatchType],

1597 ]

1598 ],

1599 ]

1600 ],

1601 MatchIfTrue[Sequence[cst.RightParen]],

1602 ]

1603 ],

1604 ] = DoNotCare()

1605 metadata: Union[

1606 MetadataMatchType,

1607 DoNotCareSentinel,

1608 OneOf[MetadataMatchType],

1609 AllOf[MetadataMatchType],

1610 ] = DoNotCare()

1611

1612

1613@dataclass(frozen=True, eq=False, unsafe_hash=False)

1614class Break(BaseSmallStatement, BaseMatcherNode):

1615 semicolon: Union[

1616 SemicolonMatchType,

1617 DoNotCareSentinel,

1618 OneOf[SemicolonMatchType],

1619 AllOf[SemicolonMatchType],

1620 ] = DoNotCare()

1621 metadata: Union[

1622 MetadataMatchType,

1623 DoNotCareSentinel,

1624 OneOf[MetadataMatchType],

1625 AllOf[MetadataMatchType],

1626 ] = DoNotCare()

1627

1628

1629ArgMatchType = Union["Arg", MetadataMatchType, MatchIfTrue[cst.Arg]]

1630

1631

1632@dataclass(frozen=True, eq=False, unsafe_hash=False)

1633class Call(BaseExpression, BaseMatcherNode):

1634 func: Union[

1635 BaseExpressionMatchType,

1636 DoNotCareSentinel,

1637 OneOf[BaseExpressionMatchType],

1638 AllOf[BaseExpressionMatchType],

1639 ] = DoNotCare()

1640 args: Union[

1641 Sequence[

1642 Union[

1643 ArgMatchType,

1644 DoNotCareSentinel,

1645 OneOf[ArgMatchType],

1646 AllOf[ArgMatchType],

1647 AtLeastN[

1648 Union[

1649 ArgMatchType,

1650 DoNotCareSentinel,

1651 OneOf[ArgMatchType],

1652 AllOf[ArgMatchType],

1653 ]

1654 ],

1655 AtMostN[

1656 Union[

1657 ArgMatchType,

1658 DoNotCareSentinel,

1659 OneOf[ArgMatchType],

1660 AllOf[ArgMatchType],

1661 ]

1662 ],

1663 ]

1664 ],

1665 DoNotCareSentinel,

1666 MatchIfTrue[Sequence[cst.Arg]],

1667 OneOf[

1668 Union[

1669 Sequence[

1670 Union[

1671 ArgMatchType,

1672 OneOf[ArgMatchType],

1673 AllOf[ArgMatchType],

1674 AtLeastN[

1675 Union[

1676 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1677 ]

1678 ],

1679 AtMostN[

1680 Union[

1681 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1682 ]

1683 ],

1684 ]

1685 ],

1686 MatchIfTrue[Sequence[cst.Arg]],

1687 ]

1688 ],

1689 AllOf[

1690 Union[

1691 Sequence[

1692 Union[

1693 ArgMatchType,

1694 OneOf[ArgMatchType],

1695 AllOf[ArgMatchType],

1696 AtLeastN[

1697 Union[

1698 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1699 ]

1700 ],

1701 AtMostN[

1702 Union[

1703 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1704 ]

1705 ],

1706 ]

1707 ],

1708 MatchIfTrue[Sequence[cst.Arg]],

1709 ]

1710 ],

1711 ] = DoNotCare()

1712 lpar: Union[

1713 Sequence[

1714 Union[

1715 LeftParenMatchType,

1716 DoNotCareSentinel,

1717 OneOf[LeftParenMatchType],

1718 AllOf[LeftParenMatchType],

1719 AtLeastN[

1720 Union[

1721 LeftParenMatchType,

1722 DoNotCareSentinel,

1723 OneOf[LeftParenMatchType],

1724 AllOf[LeftParenMatchType],

1725 ]

1726 ],

1727 AtMostN[

1728 Union[

1729 LeftParenMatchType,

1730 DoNotCareSentinel,

1731 OneOf[LeftParenMatchType],

1732 AllOf[LeftParenMatchType],

1733 ]

1734 ],

1735 ]

1736 ],

1737 DoNotCareSentinel,

1738 MatchIfTrue[Sequence[cst.LeftParen]],

1739 OneOf[

1740 Union[

1741 Sequence[

1742 Union[

1743 LeftParenMatchType,

1744 OneOf[LeftParenMatchType],

1745 AllOf[LeftParenMatchType],

1746 AtLeastN[

1747 Union[

1748 LeftParenMatchType,

1749 OneOf[LeftParenMatchType],

1750 AllOf[LeftParenMatchType],

1751 ]

1752 ],

1753 AtMostN[

1754 Union[

1755 LeftParenMatchType,

1756 OneOf[LeftParenMatchType],

1757 AllOf[LeftParenMatchType],

1758 ]

1759 ],

1760 ]

1761 ],

1762 MatchIfTrue[Sequence[cst.LeftParen]],

1763 ]

1764 ],

1765 AllOf[

1766 Union[

1767 Sequence[

1768 Union[

1769 LeftParenMatchType,

1770 OneOf[LeftParenMatchType],

1771 AllOf[LeftParenMatchType],

1772 AtLeastN[

1773 Union[

1774 LeftParenMatchType,

1775 OneOf[LeftParenMatchType],

1776 AllOf[LeftParenMatchType],

1777 ]

1778 ],

1779 AtMostN[

1780 Union[

1781 LeftParenMatchType,

1782 OneOf[LeftParenMatchType],

1783 AllOf[LeftParenMatchType],

1784 ]

1785 ],

1786 ]

1787 ],

1788 MatchIfTrue[Sequence[cst.LeftParen]],

1789 ]

1790 ],

1791 ] = DoNotCare()

1792 rpar: Union[

1793 Sequence[

1794 Union[

1795 RightParenMatchType,

1796 DoNotCareSentinel,

1797 OneOf[RightParenMatchType],

1798 AllOf[RightParenMatchType],

1799 AtLeastN[

1800 Union[

1801 RightParenMatchType,

1802 DoNotCareSentinel,

1803 OneOf[RightParenMatchType],

1804 AllOf[RightParenMatchType],

1805 ]

1806 ],

1807 AtMostN[

1808 Union[

1809 RightParenMatchType,

1810 DoNotCareSentinel,

1811 OneOf[RightParenMatchType],

1812 AllOf[RightParenMatchType],

1813 ]

1814 ],

1815 ]

1816 ],

1817 DoNotCareSentinel,

1818 MatchIfTrue[Sequence[cst.RightParen]],

1819 OneOf[

1820 Union[

1821 Sequence[

1822 Union[

1823 RightParenMatchType,

1824 OneOf[RightParenMatchType],

1825 AllOf[RightParenMatchType],

1826 AtLeastN[

1827 Union[

1828 RightParenMatchType,

1829 OneOf[RightParenMatchType],

1830 AllOf[RightParenMatchType],

1831 ]

1832 ],

1833 AtMostN[

1834 Union[

1835 RightParenMatchType,

1836 OneOf[RightParenMatchType],

1837 AllOf[RightParenMatchType],

1838 ]

1839 ],

1840 ]

1841 ],

1842 MatchIfTrue[Sequence[cst.RightParen]],

1843 ]

1844 ],

1845 AllOf[

1846 Union[

1847 Sequence[

1848 Union[

1849 RightParenMatchType,

1850 OneOf[RightParenMatchType],

1851 AllOf[RightParenMatchType],

1852 AtLeastN[

1853 Union[

1854 RightParenMatchType,

1855 OneOf[RightParenMatchType],

1856 AllOf[RightParenMatchType],

1857 ]

1858 ],

1859 AtMostN[

1860 Union[

1861 RightParenMatchType,

1862 OneOf[RightParenMatchType],

1863 AllOf[RightParenMatchType],

1864 ]

1865 ],

1866 ]

1867 ],

1868 MatchIfTrue[Sequence[cst.RightParen]],

1869 ]

1870 ],

1871 ] = DoNotCare()

1872 whitespace_after_func: Union[

1873 BaseParenthesizableWhitespaceMatchType,

1874 DoNotCareSentinel,

1875 OneOf[BaseParenthesizableWhitespaceMatchType],

1876 AllOf[BaseParenthesizableWhitespaceMatchType],

1877 ] = DoNotCare()

1878 whitespace_before_args: Union[

1879 BaseParenthesizableWhitespaceMatchType,

1880 DoNotCareSentinel,

1881 OneOf[BaseParenthesizableWhitespaceMatchType],

1882 AllOf[BaseParenthesizableWhitespaceMatchType],

1883 ] = DoNotCare()

1884 metadata: Union[

1885 MetadataMatchType,

1886 DoNotCareSentinel,

1887 OneOf[MetadataMatchType],

1888 AllOf[MetadataMatchType],

1889 ] = DoNotCare()

1890

1891

1892BaseSuiteMatchType = Union["BaseSuite", MetadataMatchType, MatchIfTrue[cst.BaseSuite]]

1893DecoratorMatchType = Union["Decorator", MetadataMatchType, MatchIfTrue[cst.Decorator]]

1894EmptyLineMatchType = Union["EmptyLine", MetadataMatchType, MatchIfTrue[cst.EmptyLine]]

1895

1896

1897@dataclass(frozen=True, eq=False, unsafe_hash=False)

1898class ClassDef(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

1899 name: Union[

1900 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

1901 ] = DoNotCare()

1902 body: Union[

1903 BaseSuiteMatchType,

1904 DoNotCareSentinel,

1905 OneOf[BaseSuiteMatchType],

1906 AllOf[BaseSuiteMatchType],

1907 ] = DoNotCare()

1908 bases: Union[

1909 Sequence[

1910 Union[

1911 ArgMatchType,

1912 DoNotCareSentinel,

1913 OneOf[ArgMatchType],

1914 AllOf[ArgMatchType],

1915 AtLeastN[

1916 Union[

1917 ArgMatchType,

1918 DoNotCareSentinel,

1919 OneOf[ArgMatchType],

1920 AllOf[ArgMatchType],

1921 ]

1922 ],

1923 AtMostN[

1924 Union[

1925 ArgMatchType,

1926 DoNotCareSentinel,

1927 OneOf[ArgMatchType],

1928 AllOf[ArgMatchType],

1929 ]

1930 ],

1931 ]

1932 ],

1933 DoNotCareSentinel,

1934 MatchIfTrue[Sequence[cst.Arg]],

1935 OneOf[

1936 Union[

1937 Sequence[

1938 Union[

1939 ArgMatchType,

1940 OneOf[ArgMatchType],

1941 AllOf[ArgMatchType],

1942 AtLeastN[

1943 Union[

1944 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1945 ]

1946 ],

1947 AtMostN[

1948 Union[

1949 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1950 ]

1951 ],

1952 ]

1953 ],

1954 MatchIfTrue[Sequence[cst.Arg]],

1955 ]

1956 ],

1957 AllOf[

1958 Union[

1959 Sequence[

1960 Union[

1961 ArgMatchType,

1962 OneOf[ArgMatchType],

1963 AllOf[ArgMatchType],

1964 AtLeastN[

1965 Union[

1966 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1967 ]

1968 ],

1969 AtMostN[

1970 Union[

1971 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

1972 ]

1973 ],

1974 ]

1975 ],

1976 MatchIfTrue[Sequence[cst.Arg]],

1977 ]

1978 ],

1979 ] = DoNotCare()

1980 keywords: Union[

1981 Sequence[

1982 Union[

1983 ArgMatchType,

1984 DoNotCareSentinel,

1985 OneOf[ArgMatchType],

1986 AllOf[ArgMatchType],

1987 AtLeastN[

1988 Union[

1989 ArgMatchType,

1990 DoNotCareSentinel,

1991 OneOf[ArgMatchType],

1992 AllOf[ArgMatchType],

1993 ]

1994 ],

1995 AtMostN[

1996 Union[

1997 ArgMatchType,

1998 DoNotCareSentinel,

1999 OneOf[ArgMatchType],

2000 AllOf[ArgMatchType],

2001 ]

2002 ],

2003 ]

2004 ],

2005 DoNotCareSentinel,

2006 MatchIfTrue[Sequence[cst.Arg]],

2007 OneOf[

2008 Union[

2009 Sequence[

2010 Union[

2011 ArgMatchType,

2012 OneOf[ArgMatchType],

2013 AllOf[ArgMatchType],

2014 AtLeastN[

2015 Union[

2016 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

2017 ]

2018 ],

2019 AtMostN[

2020 Union[

2021 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

2022 ]

2023 ],

2024 ]

2025 ],

2026 MatchIfTrue[Sequence[cst.Arg]],

2027 ]

2028 ],

2029 AllOf[

2030 Union[

2031 Sequence[

2032 Union[

2033 ArgMatchType,

2034 OneOf[ArgMatchType],

2035 AllOf[ArgMatchType],

2036 AtLeastN[

2037 Union[

2038 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

2039 ]

2040 ],

2041 AtMostN[

2042 Union[

2043 ArgMatchType, OneOf[ArgMatchType], AllOf[ArgMatchType]

2044 ]

2045 ],

2046 ]

2047 ],

2048 MatchIfTrue[Sequence[cst.Arg]],

2049 ]

2050 ],

2051 ] = DoNotCare()

2052 decorators: Union[

2053 Sequence[

2054 Union[

2055 DecoratorMatchType,

2056 DoNotCareSentinel,

2057 OneOf[DecoratorMatchType],

2058 AllOf[DecoratorMatchType],

2059 AtLeastN[

2060 Union[

2061 DecoratorMatchType,

2062 DoNotCareSentinel,

2063 OneOf[DecoratorMatchType],

2064 AllOf[DecoratorMatchType],

2065 ]

2066 ],

2067 AtMostN[

2068 Union[

2069 DecoratorMatchType,

2070 DoNotCareSentinel,

2071 OneOf[DecoratorMatchType],

2072 AllOf[DecoratorMatchType],

2073 ]

2074 ],

2075 ]

2076 ],

2077 DoNotCareSentinel,

2078 MatchIfTrue[Sequence[cst.Decorator]],

2079 OneOf[

2080 Union[

2081 Sequence[

2082 Union[

2083 DecoratorMatchType,

2084 OneOf[DecoratorMatchType],

2085 AllOf[DecoratorMatchType],

2086 AtLeastN[

2087 Union[

2088 DecoratorMatchType,

2089 OneOf[DecoratorMatchType],

2090 AllOf[DecoratorMatchType],

2091 ]

2092 ],

2093 AtMostN[

2094 Union[

2095 DecoratorMatchType,

2096 OneOf[DecoratorMatchType],

2097 AllOf[DecoratorMatchType],

2098 ]

2099 ],

2100 ]

2101 ],

2102 MatchIfTrue[Sequence[cst.Decorator]],

2103 ]

2104 ],

2105 AllOf[

2106 Union[

2107 Sequence[

2108 Union[

2109 DecoratorMatchType,

2110 OneOf[DecoratorMatchType],

2111 AllOf[DecoratorMatchType],

2112 AtLeastN[

2113 Union[

2114 DecoratorMatchType,

2115 OneOf[DecoratorMatchType],

2116 AllOf[DecoratorMatchType],

2117 ]

2118 ],

2119 AtMostN[

2120 Union[

2121 DecoratorMatchType,

2122 OneOf[DecoratorMatchType],

2123 AllOf[DecoratorMatchType],

2124 ]

2125 ],

2126 ]

2127 ],

2128 MatchIfTrue[Sequence[cst.Decorator]],

2129 ]

2130 ],

2131 ] = DoNotCare()

2132 lpar: Union[

2133 LeftParenMatchType,

2134 DoNotCareSentinel,

2135 OneOf[LeftParenMatchType],

2136 AllOf[LeftParenMatchType],

2137 ] = DoNotCare()

2138 rpar: Union[

2139 RightParenMatchType,

2140 DoNotCareSentinel,

2141 OneOf[RightParenMatchType],

2142 AllOf[RightParenMatchType],

2143 ] = DoNotCare()

2144 leading_lines: Union[

2145 Sequence[

2146 Union[

2147 EmptyLineMatchType,

2148 DoNotCareSentinel,

2149 OneOf[EmptyLineMatchType],

2150 AllOf[EmptyLineMatchType],

2151 AtLeastN[

2152 Union[

2153 EmptyLineMatchType,

2154 DoNotCareSentinel,

2155 OneOf[EmptyLineMatchType],

2156 AllOf[EmptyLineMatchType],

2157 ]

2158 ],

2159 AtMostN[

2160 Union[

2161 EmptyLineMatchType,

2162 DoNotCareSentinel,

2163 OneOf[EmptyLineMatchType],

2164 AllOf[EmptyLineMatchType],

2165 ]

2166 ],

2167 ]

2168 ],

2169 DoNotCareSentinel,

2170 MatchIfTrue[Sequence[cst.EmptyLine]],

2171 OneOf[

2172 Union[

2173 Sequence[

2174 Union[

2175 EmptyLineMatchType,

2176 OneOf[EmptyLineMatchType],

2177 AllOf[EmptyLineMatchType],

2178 AtLeastN[

2179 Union[

2180 EmptyLineMatchType,

2181 OneOf[EmptyLineMatchType],

2182 AllOf[EmptyLineMatchType],

2183 ]

2184 ],

2185 AtMostN[

2186 Union[

2187 EmptyLineMatchType,

2188 OneOf[EmptyLineMatchType],

2189 AllOf[EmptyLineMatchType],

2190 ]

2191 ],

2192 ]

2193 ],

2194 MatchIfTrue[Sequence[cst.EmptyLine]],

2195 ]

2196 ],

2197 AllOf[

2198 Union[

2199 Sequence[

2200 Union[

2201 EmptyLineMatchType,

2202 OneOf[EmptyLineMatchType],

2203 AllOf[EmptyLineMatchType],

2204 AtLeastN[

2205 Union[

2206 EmptyLineMatchType,

2207 OneOf[EmptyLineMatchType],

2208 AllOf[EmptyLineMatchType],

2209 ]

2210 ],

2211 AtMostN[

2212 Union[

2213 EmptyLineMatchType,

2214 OneOf[EmptyLineMatchType],

2215 AllOf[EmptyLineMatchType],

2216 ]

2217 ],

2218 ]

2219 ],

2220 MatchIfTrue[Sequence[cst.EmptyLine]],

2221 ]

2222 ],

2223 ] = DoNotCare()

2224 lines_after_decorators: Union[

2225 Sequence[

2226 Union[

2227 EmptyLineMatchType,

2228 DoNotCareSentinel,

2229 OneOf[EmptyLineMatchType],

2230 AllOf[EmptyLineMatchType],

2231 AtLeastN[

2232 Union[

2233 EmptyLineMatchType,

2234 DoNotCareSentinel,

2235 OneOf[EmptyLineMatchType],

2236 AllOf[EmptyLineMatchType],

2237 ]

2238 ],

2239 AtMostN[

2240 Union[

2241 EmptyLineMatchType,

2242 DoNotCareSentinel,

2243 OneOf[EmptyLineMatchType],

2244 AllOf[EmptyLineMatchType],

2245 ]

2246 ],

2247 ]

2248 ],

2249 DoNotCareSentinel,

2250 MatchIfTrue[Sequence[cst.EmptyLine]],

2251 OneOf[

2252 Union[

2253 Sequence[

2254 Union[

2255 EmptyLineMatchType,

2256 OneOf[EmptyLineMatchType],

2257 AllOf[EmptyLineMatchType],

2258 AtLeastN[

2259 Union[

2260 EmptyLineMatchType,

2261 OneOf[EmptyLineMatchType],

2262 AllOf[EmptyLineMatchType],

2263 ]

2264 ],

2265 AtMostN[

2266 Union[

2267 EmptyLineMatchType,

2268 OneOf[EmptyLineMatchType],

2269 AllOf[EmptyLineMatchType],

2270 ]

2271 ],

2272 ]

2273 ],

2274 MatchIfTrue[Sequence[cst.EmptyLine]],

2275 ]

2276 ],

2277 AllOf[

2278 Union[

2279 Sequence[

2280 Union[

2281 EmptyLineMatchType,

2282 OneOf[EmptyLineMatchType],

2283 AllOf[EmptyLineMatchType],

2284 AtLeastN[

2285 Union[

2286 EmptyLineMatchType,

2287 OneOf[EmptyLineMatchType],

2288 AllOf[EmptyLineMatchType],

2289 ]

2290 ],

2291 AtMostN[

2292 Union[

2293 EmptyLineMatchType,

2294 OneOf[EmptyLineMatchType],

2295 AllOf[EmptyLineMatchType],

2296 ]

2297 ],

2298 ]

2299 ],

2300 MatchIfTrue[Sequence[cst.EmptyLine]],

2301 ]

2302 ],

2303 ] = DoNotCare()

2304 whitespace_after_class: Union[

2305 SimpleWhitespaceMatchType,

2306 DoNotCareSentinel,

2307 OneOf[SimpleWhitespaceMatchType],

2308 AllOf[SimpleWhitespaceMatchType],

2309 ] = DoNotCare()

2310 whitespace_after_name: Union[

2311 SimpleWhitespaceMatchType,

2312 DoNotCareSentinel,

2313 OneOf[SimpleWhitespaceMatchType],

2314 AllOf[SimpleWhitespaceMatchType],

2315 ] = DoNotCare()

2316 whitespace_before_colon: Union[

2317 SimpleWhitespaceMatchType,

2318 DoNotCareSentinel,

2319 OneOf[SimpleWhitespaceMatchType],

2320 AllOf[SimpleWhitespaceMatchType],

2321 ] = DoNotCare()

2322 type_parameters: Union[

2323 Optional["TypeParameters"],

2324 MetadataMatchType,

2325 MatchIfTrue[Optional[cst.TypeParameters]],

2326 DoNotCareSentinel,

2327 OneOf[

2328 Union[

2329 Optional["TypeParameters"],

2330 MetadataMatchType,

2331 MatchIfTrue[Optional[cst.TypeParameters]],

2332 ]

2333 ],

2334 AllOf[

2335 Union[

2336 Optional["TypeParameters"],

2337 MetadataMatchType,

2338 MatchIfTrue[Optional[cst.TypeParameters]],

2339 ]

2340 ],

2341 ] = DoNotCare()

2342 whitespace_after_type_parameters: Union[

2343 SimpleWhitespaceMatchType,

2344 DoNotCareSentinel,

2345 OneOf[SimpleWhitespaceMatchType],

2346 AllOf[SimpleWhitespaceMatchType],

2347 ] = DoNotCare()

2348 metadata: Union[

2349 MetadataMatchType,

2350 DoNotCareSentinel,

2351 OneOf[MetadataMatchType],

2352 AllOf[MetadataMatchType],

2353 ] = DoNotCare()

2354

2355

2356@dataclass(frozen=True, eq=False, unsafe_hash=False)

2357class Colon(BaseMatcherNode):

2358 whitespace_before: Union[

2359 BaseParenthesizableWhitespaceMatchType,

2360 DoNotCareSentinel,

2361 OneOf[BaseParenthesizableWhitespaceMatchType],

2362 AllOf[BaseParenthesizableWhitespaceMatchType],

2363 ] = DoNotCare()

2364 whitespace_after: Union[

2365 BaseParenthesizableWhitespaceMatchType,

2366 DoNotCareSentinel,

2367 OneOf[BaseParenthesizableWhitespaceMatchType],

2368 AllOf[BaseParenthesizableWhitespaceMatchType],

2369 ] = DoNotCare()

2370 metadata: Union[

2371 MetadataMatchType,

2372 DoNotCareSentinel,

2373 OneOf[MetadataMatchType],

2374 AllOf[MetadataMatchType],

2375 ] = DoNotCare()

2376

2377

2378@dataclass(frozen=True, eq=False, unsafe_hash=False)

2379class Comma(BaseMatcherNode):

2380 whitespace_before: Union[

2381 BaseParenthesizableWhitespaceMatchType,

2382 DoNotCareSentinel,

2383 OneOf[BaseParenthesizableWhitespaceMatchType],

2384 AllOf[BaseParenthesizableWhitespaceMatchType],

2385 ] = DoNotCare()

2386 whitespace_after: Union[

2387 BaseParenthesizableWhitespaceMatchType,

2388 DoNotCareSentinel,

2389 OneOf[BaseParenthesizableWhitespaceMatchType],

2390 AllOf[BaseParenthesizableWhitespaceMatchType],

2391 ] = DoNotCare()

2392 metadata: Union[

2393 MetadataMatchType,

2394 DoNotCareSentinel,

2395 OneOf[MetadataMatchType],

2396 AllOf[MetadataMatchType],

2397 ] = DoNotCare()

2398

2399

2400strMatchType = Union[str, MetadataMatchType, MatchIfTrue[str]]

2401

2402

2403@dataclass(frozen=True, eq=False, unsafe_hash=False)

2404class Comment(BaseMatcherNode):

2405 value: Union[

2406 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

2407 ] = DoNotCare()

2408 metadata: Union[

2409 MetadataMatchType,

2410 DoNotCareSentinel,

2411 OneOf[MetadataMatchType],

2412 AllOf[MetadataMatchType],

2413 ] = DoNotCare()

2414

2415

2416CompIfMatchType = Union["CompIf", MetadataMatchType, MatchIfTrue[cst.CompIf]]

2417

2418

2419@dataclass(frozen=True, eq=False, unsafe_hash=False)

2420class CompFor(BaseMatcherNode):

2421 target: Union[

2422 BaseAssignTargetExpressionMatchType,

2423 DoNotCareSentinel,

2424 OneOf[BaseAssignTargetExpressionMatchType],

2425 AllOf[BaseAssignTargetExpressionMatchType],

2426 ] = DoNotCare()

2427 iter: Union[

2428 BaseExpressionMatchType,

2429 DoNotCareSentinel,

2430 OneOf[BaseExpressionMatchType],

2431 AllOf[BaseExpressionMatchType],

2432 ] = DoNotCare()

2433 ifs: Union[

2434 Sequence[

2435 Union[

2436 CompIfMatchType,

2437 DoNotCareSentinel,

2438 OneOf[CompIfMatchType],

2439 AllOf[CompIfMatchType],

2440 AtLeastN[

2441 Union[

2442 CompIfMatchType,

2443 DoNotCareSentinel,

2444 OneOf[CompIfMatchType],

2445 AllOf[CompIfMatchType],

2446 ]

2447 ],

2448 AtMostN[

2449 Union[

2450 CompIfMatchType,

2451 DoNotCareSentinel,

2452 OneOf[CompIfMatchType],

2453 AllOf[CompIfMatchType],

2454 ]

2455 ],

2456 ]

2457 ],

2458 DoNotCareSentinel,

2459 MatchIfTrue[Sequence[cst.CompIf]],

2460 OneOf[

2461 Union[

2462 Sequence[

2463 Union[

2464 CompIfMatchType,

2465 OneOf[CompIfMatchType],

2466 AllOf[CompIfMatchType],

2467 AtLeastN[

2468 Union[

2469 CompIfMatchType,

2470 OneOf[CompIfMatchType],

2471 AllOf[CompIfMatchType],

2472 ]

2473 ],

2474 AtMostN[

2475 Union[

2476 CompIfMatchType,

2477 OneOf[CompIfMatchType],

2478 AllOf[CompIfMatchType],

2479 ]

2480 ],

2481 ]

2482 ],

2483 MatchIfTrue[Sequence[cst.CompIf]],

2484 ]

2485 ],

2486 AllOf[

2487 Union[

2488 Sequence[

2489 Union[

2490 CompIfMatchType,

2491 OneOf[CompIfMatchType],

2492 AllOf[CompIfMatchType],

2493 AtLeastN[

2494 Union[

2495 CompIfMatchType,

2496 OneOf[CompIfMatchType],

2497 AllOf[CompIfMatchType],

2498 ]

2499 ],

2500 AtMostN[

2501 Union[

2502 CompIfMatchType,

2503 OneOf[CompIfMatchType],

2504 AllOf[CompIfMatchType],

2505 ]

2506 ],

2507 ]

2508 ],

2509 MatchIfTrue[Sequence[cst.CompIf]],

2510 ]

2511 ],

2512 ] = DoNotCare()

2513 inner_for_in: Union[

2514 Optional["CompFor"],

2515 MetadataMatchType,

2516 MatchIfTrue[Optional[cst.CompFor]],

2517 DoNotCareSentinel,

2518 OneOf[

2519 Union[

2520 Optional["CompFor"],

2521 MetadataMatchType,

2522 MatchIfTrue[Optional[cst.CompFor]],

2523 ]

2524 ],

2525 AllOf[

2526 Union[

2527 Optional["CompFor"],

2528 MetadataMatchType,

2529 MatchIfTrue[Optional[cst.CompFor]],

2530 ]

2531 ],

2532 ] = DoNotCare()

2533 asynchronous: Union[

2534 Optional["Asynchronous"],

2535 MetadataMatchType,

2536 MatchIfTrue[Optional[cst.Asynchronous]],

2537 DoNotCareSentinel,

2538 OneOf[

2539 Union[

2540 Optional["Asynchronous"],

2541 MetadataMatchType,

2542 MatchIfTrue[Optional[cst.Asynchronous]],

2543 ]

2544 ],

2545 AllOf[

2546 Union[

2547 Optional["Asynchronous"],

2548 MetadataMatchType,

2549 MatchIfTrue[Optional[cst.Asynchronous]],

2550 ]

2551 ],

2552 ] = DoNotCare()

2553 whitespace_before: Union[

2554 BaseParenthesizableWhitespaceMatchType,

2555 DoNotCareSentinel,

2556 OneOf[BaseParenthesizableWhitespaceMatchType],

2557 AllOf[BaseParenthesizableWhitespaceMatchType],

2558 ] = DoNotCare()

2559 whitespace_after_for: Union[

2560 BaseParenthesizableWhitespaceMatchType,

2561 DoNotCareSentinel,

2562 OneOf[BaseParenthesizableWhitespaceMatchType],

2563 AllOf[BaseParenthesizableWhitespaceMatchType],

2564 ] = DoNotCare()

2565 whitespace_before_in: Union[

2566 BaseParenthesizableWhitespaceMatchType,

2567 DoNotCareSentinel,

2568 OneOf[BaseParenthesizableWhitespaceMatchType],

2569 AllOf[BaseParenthesizableWhitespaceMatchType],

2570 ] = DoNotCare()

2571 whitespace_after_in: Union[

2572 BaseParenthesizableWhitespaceMatchType,

2573 DoNotCareSentinel,

2574 OneOf[BaseParenthesizableWhitespaceMatchType],

2575 AllOf[BaseParenthesizableWhitespaceMatchType],

2576 ] = DoNotCare()

2577 metadata: Union[

2578 MetadataMatchType,

2579 DoNotCareSentinel,

2580 OneOf[MetadataMatchType],

2581 AllOf[MetadataMatchType],

2582 ] = DoNotCare()

2583

2584

2585@dataclass(frozen=True, eq=False, unsafe_hash=False)

2586class CompIf(BaseMatcherNode):

2587 test: Union[

2588 BaseExpressionMatchType,

2589 DoNotCareSentinel,

2590 OneOf[BaseExpressionMatchType],

2591 AllOf[BaseExpressionMatchType],

2592 ] = DoNotCare()

2593 whitespace_before: Union[

2594 BaseParenthesizableWhitespaceMatchType,

2595 DoNotCareSentinel,

2596 OneOf[BaseParenthesizableWhitespaceMatchType],

2597 AllOf[BaseParenthesizableWhitespaceMatchType],

2598 ] = DoNotCare()

2599 whitespace_before_test: Union[

2600 BaseParenthesizableWhitespaceMatchType,

2601 DoNotCareSentinel,

2602 OneOf[BaseParenthesizableWhitespaceMatchType],

2603 AllOf[BaseParenthesizableWhitespaceMatchType],

2604 ] = DoNotCare()

2605 metadata: Union[

2606 MetadataMatchType,

2607 DoNotCareSentinel,

2608 OneOf[MetadataMatchType],

2609 AllOf[MetadataMatchType],

2610 ] = DoNotCare()

2611

2612

2613ComparisonTargetMatchType = Union[

2614 "ComparisonTarget", MetadataMatchType, MatchIfTrue[cst.ComparisonTarget]

2615]

2616

2617

2618@dataclass(frozen=True, eq=False, unsafe_hash=False)

2619class Comparison(BaseExpression, BaseMatcherNode):

2620 left: Union[

2621 BaseExpressionMatchType,

2622 DoNotCareSentinel,

2623 OneOf[BaseExpressionMatchType],

2624 AllOf[BaseExpressionMatchType],

2625 ] = DoNotCare()

2626 comparisons: Union[

2627 Sequence[

2628 Union[

2629 ComparisonTargetMatchType,

2630 DoNotCareSentinel,

2631 OneOf[ComparisonTargetMatchType],

2632 AllOf[ComparisonTargetMatchType],

2633 AtLeastN[

2634 Union[

2635 ComparisonTargetMatchType,

2636 DoNotCareSentinel,

2637 OneOf[ComparisonTargetMatchType],

2638 AllOf[ComparisonTargetMatchType],

2639 ]

2640 ],

2641 AtMostN[

2642 Union[

2643 ComparisonTargetMatchType,

2644 DoNotCareSentinel,

2645 OneOf[ComparisonTargetMatchType],

2646 AllOf[ComparisonTargetMatchType],

2647 ]

2648 ],

2649 ]

2650 ],

2651 DoNotCareSentinel,

2652 MatchIfTrue[Sequence[cst.ComparisonTarget]],

2653 OneOf[

2654 Union[

2655 Sequence[

2656 Union[

2657 ComparisonTargetMatchType,

2658 OneOf[ComparisonTargetMatchType],

2659 AllOf[ComparisonTargetMatchType],

2660 AtLeastN[

2661 Union[

2662 ComparisonTargetMatchType,

2663 OneOf[ComparisonTargetMatchType],

2664 AllOf[ComparisonTargetMatchType],

2665 ]

2666 ],

2667 AtMostN[

2668 Union[

2669 ComparisonTargetMatchType,

2670 OneOf[ComparisonTargetMatchType],

2671 AllOf[ComparisonTargetMatchType],

2672 ]

2673 ],

2674 ]

2675 ],

2676 MatchIfTrue[Sequence[cst.ComparisonTarget]],

2677 ]

2678 ],

2679 AllOf[

2680 Union[

2681 Sequence[

2682 Union[

2683 ComparisonTargetMatchType,

2684 OneOf[ComparisonTargetMatchType],

2685 AllOf[ComparisonTargetMatchType],

2686 AtLeastN[

2687 Union[

2688 ComparisonTargetMatchType,

2689 OneOf[ComparisonTargetMatchType],

2690 AllOf[ComparisonTargetMatchType],

2691 ]

2692 ],

2693 AtMostN[

2694 Union[

2695 ComparisonTargetMatchType,

2696 OneOf[ComparisonTargetMatchType],

2697 AllOf[ComparisonTargetMatchType],

2698 ]

2699 ],

2700 ]

2701 ],

2702 MatchIfTrue[Sequence[cst.ComparisonTarget]],

2703 ]

2704 ],

2705 ] = DoNotCare()

2706 lpar: Union[

2707 Sequence[

2708 Union[

2709 LeftParenMatchType,

2710 DoNotCareSentinel,

2711 OneOf[LeftParenMatchType],

2712 AllOf[LeftParenMatchType],

2713 AtLeastN[

2714 Union[

2715 LeftParenMatchType,

2716 DoNotCareSentinel,

2717 OneOf[LeftParenMatchType],

2718 AllOf[LeftParenMatchType],

2719 ]

2720 ],

2721 AtMostN[

2722 Union[

2723 LeftParenMatchType,

2724 DoNotCareSentinel,

2725 OneOf[LeftParenMatchType],

2726 AllOf[LeftParenMatchType],

2727 ]

2728 ],

2729 ]

2730 ],

2731 DoNotCareSentinel,

2732 MatchIfTrue[Sequence[cst.LeftParen]],

2733 OneOf[

2734 Union[

2735 Sequence[

2736 Union[

2737 LeftParenMatchType,

2738 OneOf[LeftParenMatchType],

2739 AllOf[LeftParenMatchType],

2740 AtLeastN[

2741 Union[

2742 LeftParenMatchType,

2743 OneOf[LeftParenMatchType],

2744 AllOf[LeftParenMatchType],

2745 ]

2746 ],

2747 AtMostN[

2748 Union[

2749 LeftParenMatchType,

2750 OneOf[LeftParenMatchType],

2751 AllOf[LeftParenMatchType],

2752 ]

2753 ],

2754 ]

2755 ],

2756 MatchIfTrue[Sequence[cst.LeftParen]],

2757 ]

2758 ],

2759 AllOf[

2760 Union[

2761 Sequence[

2762 Union[

2763 LeftParenMatchType,

2764 OneOf[LeftParenMatchType],

2765 AllOf[LeftParenMatchType],

2766 AtLeastN[

2767 Union[

2768 LeftParenMatchType,

2769 OneOf[LeftParenMatchType],

2770 AllOf[LeftParenMatchType],

2771 ]

2772 ],

2773 AtMostN[

2774 Union[

2775 LeftParenMatchType,

2776 OneOf[LeftParenMatchType],

2777 AllOf[LeftParenMatchType],

2778 ]

2779 ],

2780 ]

2781 ],

2782 MatchIfTrue[Sequence[cst.LeftParen]],

2783 ]

2784 ],

2785 ] = DoNotCare()

2786 rpar: Union[

2787 Sequence[

2788 Union[

2789 RightParenMatchType,

2790 DoNotCareSentinel,

2791 OneOf[RightParenMatchType],

2792 AllOf[RightParenMatchType],

2793 AtLeastN[

2794 Union[

2795 RightParenMatchType,

2796 DoNotCareSentinel,

2797 OneOf[RightParenMatchType],

2798 AllOf[RightParenMatchType],

2799 ]

2800 ],

2801 AtMostN[

2802 Union[

2803 RightParenMatchType,

2804 DoNotCareSentinel,

2805 OneOf[RightParenMatchType],

2806 AllOf[RightParenMatchType],

2807 ]

2808 ],

2809 ]

2810 ],

2811 DoNotCareSentinel,

2812 MatchIfTrue[Sequence[cst.RightParen]],

2813 OneOf[

2814 Union[

2815 Sequence[

2816 Union[

2817 RightParenMatchType,

2818 OneOf[RightParenMatchType],

2819 AllOf[RightParenMatchType],

2820 AtLeastN[

2821 Union[

2822 RightParenMatchType,

2823 OneOf[RightParenMatchType],

2824 AllOf[RightParenMatchType],

2825 ]

2826 ],

2827 AtMostN[

2828 Union[

2829 RightParenMatchType,

2830 OneOf[RightParenMatchType],

2831 AllOf[RightParenMatchType],

2832 ]

2833 ],

2834 ]

2835 ],

2836 MatchIfTrue[Sequence[cst.RightParen]],

2837 ]

2838 ],

2839 AllOf[

2840 Union[

2841 Sequence[

2842 Union[

2843 RightParenMatchType,

2844 OneOf[RightParenMatchType],

2845 AllOf[RightParenMatchType],

2846 AtLeastN[

2847 Union[

2848 RightParenMatchType,

2849 OneOf[RightParenMatchType],

2850 AllOf[RightParenMatchType],

2851 ]

2852 ],

2853 AtMostN[

2854 Union[

2855 RightParenMatchType,

2856 OneOf[RightParenMatchType],

2857 AllOf[RightParenMatchType],

2858 ]

2859 ],

2860 ]

2861 ],

2862 MatchIfTrue[Sequence[cst.RightParen]],

2863 ]

2864 ],

2865 ] = DoNotCare()

2866 metadata: Union[

2867 MetadataMatchType,

2868 DoNotCareSentinel,

2869 OneOf[MetadataMatchType],

2870 AllOf[MetadataMatchType],

2871 ] = DoNotCare()

2872

2873

2874BaseCompOpMatchType = Union[

2875 "BaseCompOp", MetadataMatchType, MatchIfTrue[cst.BaseCompOp]

2876]

2877

2878

2879@dataclass(frozen=True, eq=False, unsafe_hash=False)

2880class ComparisonTarget(BaseMatcherNode):

2881 operator: Union[

2882 BaseCompOpMatchType,

2883 DoNotCareSentinel,

2884 OneOf[BaseCompOpMatchType],

2885 AllOf[BaseCompOpMatchType],

2886 ] = DoNotCare()

2887 comparator: Union[

2888 BaseExpressionMatchType,

2889 DoNotCareSentinel,

2890 OneOf[BaseExpressionMatchType],

2891 AllOf[BaseExpressionMatchType],

2892 ] = DoNotCare()

2893 metadata: Union[

2894 MetadataMatchType,

2895 DoNotCareSentinel,

2896 OneOf[MetadataMatchType],

2897 AllOf[MetadataMatchType],

2898 ] = DoNotCare()

2899

2900

2901SimpleStringOrFormattedStringMatchType = Union[

2902 "SimpleString",

2903 "FormattedString",

2904 MetadataMatchType,

2905 MatchIfTrue[Union[cst.SimpleString, cst.FormattedString]],

2906]

2907SimpleStringOrFormattedStringOrConcatenatedStringMatchType = Union[

2908 "SimpleString",

2909 "FormattedString",

2910 "ConcatenatedString",

2911 MetadataMatchType,

2912 MatchIfTrue[Union[cst.SimpleString, cst.FormattedString, cst.ConcatenatedString]],

2913]

2914

2915

2916@dataclass(frozen=True, eq=False, unsafe_hash=False)

2917class ConcatenatedString(BaseExpression, BaseString, BaseMatcherNode):

2918 left: Union[

2919 SimpleStringOrFormattedStringMatchType,

2920 DoNotCareSentinel,

2921 OneOf[SimpleStringOrFormattedStringMatchType],

2922 AllOf[SimpleStringOrFormattedStringMatchType],

2923 ] = DoNotCare()

2924 right: Union[

2925 SimpleStringOrFormattedStringOrConcatenatedStringMatchType,

2926 DoNotCareSentinel,

2927 OneOf[SimpleStringOrFormattedStringOrConcatenatedStringMatchType],

2928 AllOf[SimpleStringOrFormattedStringOrConcatenatedStringMatchType],

2929 ] = DoNotCare()

2930 lpar: Union[

2931 Sequence[

2932 Union[

2933 LeftParenMatchType,

2934 DoNotCareSentinel,

2935 OneOf[LeftParenMatchType],

2936 AllOf[LeftParenMatchType],

2937 AtLeastN[

2938 Union[

2939 LeftParenMatchType,

2940 DoNotCareSentinel,

2941 OneOf[LeftParenMatchType],

2942 AllOf[LeftParenMatchType],

2943 ]

2944 ],

2945 AtMostN[

2946 Union[

2947 LeftParenMatchType,

2948 DoNotCareSentinel,

2949 OneOf[LeftParenMatchType],

2950 AllOf[LeftParenMatchType],

2951 ]

2952 ],

2953 ]

2954 ],

2955 DoNotCareSentinel,

2956 MatchIfTrue[Sequence[cst.LeftParen]],

2957 OneOf[

2958 Union[

2959 Sequence[

2960 Union[

2961 LeftParenMatchType,

2962 OneOf[LeftParenMatchType],

2963 AllOf[LeftParenMatchType],

2964 AtLeastN[

2965 Union[

2966 LeftParenMatchType,

2967 OneOf[LeftParenMatchType],

2968 AllOf[LeftParenMatchType],

2969 ]

2970 ],

2971 AtMostN[

2972 Union[

2973 LeftParenMatchType,

2974 OneOf[LeftParenMatchType],

2975 AllOf[LeftParenMatchType],

2976 ]

2977 ],

2978 ]

2979 ],

2980 MatchIfTrue[Sequence[cst.LeftParen]],

2981 ]

2982 ],

2983 AllOf[

2984 Union[

2985 Sequence[

2986 Union[

2987 LeftParenMatchType,

2988 OneOf[LeftParenMatchType],

2989 AllOf[LeftParenMatchType],

2990 AtLeastN[

2991 Union[

2992 LeftParenMatchType,

2993 OneOf[LeftParenMatchType],

2994 AllOf[LeftParenMatchType],

2995 ]

2996 ],

2997 AtMostN[

2998 Union[

2999 LeftParenMatchType,

3000 OneOf[LeftParenMatchType],

3001 AllOf[LeftParenMatchType],

3002 ]

3003 ],

3004 ]

3005 ],

3006 MatchIfTrue[Sequence[cst.LeftParen]],

3007 ]

3008 ],

3009 ] = DoNotCare()

3010 rpar: Union[

3011 Sequence[

3012 Union[

3013 RightParenMatchType,

3014 DoNotCareSentinel,

3015 OneOf[RightParenMatchType],

3016 AllOf[RightParenMatchType],

3017 AtLeastN[

3018 Union[

3019 RightParenMatchType,

3020 DoNotCareSentinel,

3021 OneOf[RightParenMatchType],

3022 AllOf[RightParenMatchType],

3023 ]

3024 ],

3025 AtMostN[

3026 Union[

3027 RightParenMatchType,

3028 DoNotCareSentinel,

3029 OneOf[RightParenMatchType],

3030 AllOf[RightParenMatchType],

3031 ]

3032 ],

3033 ]

3034 ],

3035 DoNotCareSentinel,

3036 MatchIfTrue[Sequence[cst.RightParen]],

3037 OneOf[

3038 Union[

3039 Sequence[

3040 Union[

3041 RightParenMatchType,

3042 OneOf[RightParenMatchType],

3043 AllOf[RightParenMatchType],

3044 AtLeastN[

3045 Union[

3046 RightParenMatchType,

3047 OneOf[RightParenMatchType],

3048 AllOf[RightParenMatchType],

3049 ]

3050 ],

3051 AtMostN[

3052 Union[

3053 RightParenMatchType,

3054 OneOf[RightParenMatchType],

3055 AllOf[RightParenMatchType],

3056 ]

3057 ],

3058 ]

3059 ],

3060 MatchIfTrue[Sequence[cst.RightParen]],

3061 ]

3062 ],

3063 AllOf[

3064 Union[

3065 Sequence[

3066 Union[

3067 RightParenMatchType,

3068 OneOf[RightParenMatchType],

3069 AllOf[RightParenMatchType],

3070 AtLeastN[

3071 Union[

3072 RightParenMatchType,

3073 OneOf[RightParenMatchType],

3074 AllOf[RightParenMatchType],

3075 ]

3076 ],

3077 AtMostN[

3078 Union[

3079 RightParenMatchType,

3080 OneOf[RightParenMatchType],

3081 AllOf[RightParenMatchType],

3082 ]

3083 ],

3084 ]

3085 ],

3086 MatchIfTrue[Sequence[cst.RightParen]],

3087 ]

3088 ],

3089 ] = DoNotCare()

3090 whitespace_between: Union[

3091 BaseParenthesizableWhitespaceMatchType,

3092 DoNotCareSentinel,

3093 OneOf[BaseParenthesizableWhitespaceMatchType],

3094 AllOf[BaseParenthesizableWhitespaceMatchType],

3095 ] = DoNotCare()

3096 metadata: Union[

3097 MetadataMatchType,

3098 DoNotCareSentinel,

3099 OneOf[MetadataMatchType],

3100 AllOf[MetadataMatchType],

3101 ] = DoNotCare()

3102

3103

3104@dataclass(frozen=True, eq=False, unsafe_hash=False)

3105class Continue(BaseSmallStatement, BaseMatcherNode):

3106 semicolon: Union[

3107 SemicolonMatchType,

3108 DoNotCareSentinel,

3109 OneOf[SemicolonMatchType],

3110 AllOf[SemicolonMatchType],

3111 ] = DoNotCare()

3112 metadata: Union[

3113 MetadataMatchType,

3114 DoNotCareSentinel,

3115 OneOf[MetadataMatchType],

3116 AllOf[MetadataMatchType],

3117 ] = DoNotCare()

3118

3119

3120TrailingWhitespaceMatchType = Union[

3121 "TrailingWhitespace", MetadataMatchType, MatchIfTrue[cst.TrailingWhitespace]

3122]

3123

3124

3125@dataclass(frozen=True, eq=False, unsafe_hash=False)

3126class Decorator(BaseMatcherNode):

3127 decorator: Union[

3128 BaseExpressionMatchType,

3129 DoNotCareSentinel,

3130 OneOf[BaseExpressionMatchType],

3131 AllOf[BaseExpressionMatchType],

3132 ] = DoNotCare()

3133 leading_lines: Union[

3134 Sequence[

3135 Union[

3136 EmptyLineMatchType,

3137 DoNotCareSentinel,

3138 OneOf[EmptyLineMatchType],

3139 AllOf[EmptyLineMatchType],

3140 AtLeastN[

3141 Union[

3142 EmptyLineMatchType,

3143 DoNotCareSentinel,

3144 OneOf[EmptyLineMatchType],

3145 AllOf[EmptyLineMatchType],

3146 ]

3147 ],

3148 AtMostN[

3149 Union[

3150 EmptyLineMatchType,

3151 DoNotCareSentinel,

3152 OneOf[EmptyLineMatchType],

3153 AllOf[EmptyLineMatchType],

3154 ]

3155 ],

3156 ]

3157 ],

3158 DoNotCareSentinel,

3159 MatchIfTrue[Sequence[cst.EmptyLine]],

3160 OneOf[

3161 Union[

3162 Sequence[

3163 Union[

3164 EmptyLineMatchType,

3165 OneOf[EmptyLineMatchType],

3166 AllOf[EmptyLineMatchType],

3167 AtLeastN[

3168 Union[

3169 EmptyLineMatchType,

3170 OneOf[EmptyLineMatchType],

3171 AllOf[EmptyLineMatchType],

3172 ]

3173 ],

3174 AtMostN[

3175 Union[

3176 EmptyLineMatchType,

3177 OneOf[EmptyLineMatchType],

3178 AllOf[EmptyLineMatchType],

3179 ]

3180 ],

3181 ]

3182 ],

3183 MatchIfTrue[Sequence[cst.EmptyLine]],

3184 ]

3185 ],

3186 AllOf[

3187 Union[

3188 Sequence[

3189 Union[

3190 EmptyLineMatchType,

3191 OneOf[EmptyLineMatchType],

3192 AllOf[EmptyLineMatchType],

3193 AtLeastN[

3194 Union[

3195 EmptyLineMatchType,

3196 OneOf[EmptyLineMatchType],

3197 AllOf[EmptyLineMatchType],

3198 ]

3199 ],

3200 AtMostN[

3201 Union[

3202 EmptyLineMatchType,

3203 OneOf[EmptyLineMatchType],

3204 AllOf[EmptyLineMatchType],

3205 ]

3206 ],

3207 ]

3208 ],

3209 MatchIfTrue[Sequence[cst.EmptyLine]],

3210 ]

3211 ],

3212 ] = DoNotCare()

3213 whitespace_after_at: Union[

3214 SimpleWhitespaceMatchType,

3215 DoNotCareSentinel,

3216 OneOf[SimpleWhitespaceMatchType],

3217 AllOf[SimpleWhitespaceMatchType],

3218 ] = DoNotCare()

3219 trailing_whitespace: Union[

3220 TrailingWhitespaceMatchType,

3221 DoNotCareSentinel,

3222 OneOf[TrailingWhitespaceMatchType],

3223 AllOf[TrailingWhitespaceMatchType],

3224 ] = DoNotCare()

3225 metadata: Union[

3226 MetadataMatchType,

3227 DoNotCareSentinel,

3228 OneOf[MetadataMatchType],

3229 AllOf[MetadataMatchType],

3230 ] = DoNotCare()

3231

3232

3233BaseDelTargetExpressionMatchType = Union[

3234 "BaseDelTargetExpression",

3235 MetadataMatchType,

3236 MatchIfTrue[cst.BaseDelTargetExpression],

3237]

3238

3239

3240@dataclass(frozen=True, eq=False, unsafe_hash=False)

3241class Del(BaseSmallStatement, BaseMatcherNode):

3242 target: Union[

3243 BaseDelTargetExpressionMatchType,

3244 DoNotCareSentinel,

3245 OneOf[BaseDelTargetExpressionMatchType],

3246 AllOf[BaseDelTargetExpressionMatchType],

3247 ] = DoNotCare()

3248 whitespace_after_del: Union[

3249 SimpleWhitespaceMatchType,

3250 DoNotCareSentinel,

3251 OneOf[SimpleWhitespaceMatchType],

3252 AllOf[SimpleWhitespaceMatchType],

3253 ] = DoNotCare()

3254 semicolon: Union[

3255 SemicolonMatchType,

3256 DoNotCareSentinel,

3257 OneOf[SemicolonMatchType],

3258 AllOf[SemicolonMatchType],

3259 ] = DoNotCare()

3260 metadata: Union[

3261 MetadataMatchType,

3262 DoNotCareSentinel,

3263 OneOf[MetadataMatchType],

3264 AllOf[MetadataMatchType],

3265 ] = DoNotCare()

3266

3267

3268BaseDictElementMatchType = Union[

3269 "BaseDictElement", MetadataMatchType, MatchIfTrue[cst.BaseDictElement]

3270]

3271LeftCurlyBraceMatchType = Union[

3272 "LeftCurlyBrace", MetadataMatchType, MatchIfTrue[cst.LeftCurlyBrace]

3273]

3274RightCurlyBraceMatchType = Union[

3275 "RightCurlyBrace", MetadataMatchType, MatchIfTrue[cst.RightCurlyBrace]

3276]

3277

3278

3279@dataclass(frozen=True, eq=False, unsafe_hash=False)

3280class Dict(BaseDict, BaseExpression, BaseMatcherNode):

3281 elements: Union[

3282 Sequence[

3283 Union[

3284 BaseDictElementMatchType,

3285 DoNotCareSentinel,

3286 OneOf[BaseDictElementMatchType],

3287 AllOf[BaseDictElementMatchType],

3288 AtLeastN[

3289 Union[

3290 BaseDictElementMatchType,

3291 DoNotCareSentinel,

3292 OneOf[BaseDictElementMatchType],

3293 AllOf[BaseDictElementMatchType],

3294 ]

3295 ],

3296 AtMostN[

3297 Union[

3298 BaseDictElementMatchType,

3299 DoNotCareSentinel,

3300 OneOf[BaseDictElementMatchType],

3301 AllOf[BaseDictElementMatchType],

3302 ]

3303 ],

3304 ]

3305 ],

3306 DoNotCareSentinel,

3307 MatchIfTrue[Sequence[cst.BaseDictElement]],

3308 OneOf[

3309 Union[

3310 Sequence[

3311 Union[

3312 BaseDictElementMatchType,

3313 OneOf[BaseDictElementMatchType],

3314 AllOf[BaseDictElementMatchType],

3315 AtLeastN[

3316 Union[

3317 BaseDictElementMatchType,

3318 OneOf[BaseDictElementMatchType],

3319 AllOf[BaseDictElementMatchType],

3320 ]

3321 ],

3322 AtMostN[

3323 Union[

3324 BaseDictElementMatchType,

3325 OneOf[BaseDictElementMatchType],

3326 AllOf[BaseDictElementMatchType],

3327 ]

3328 ],

3329 ]

3330 ],

3331 MatchIfTrue[Sequence[cst.BaseDictElement]],

3332 ]

3333 ],

3334 AllOf[

3335 Union[

3336 Sequence[

3337 Union[

3338 BaseDictElementMatchType,

3339 OneOf[BaseDictElementMatchType],

3340 AllOf[BaseDictElementMatchType],

3341 AtLeastN[

3342 Union[

3343 BaseDictElementMatchType,

3344 OneOf[BaseDictElementMatchType],

3345 AllOf[BaseDictElementMatchType],

3346 ]

3347 ],

3348 AtMostN[

3349 Union[

3350 BaseDictElementMatchType,

3351 OneOf[BaseDictElementMatchType],

3352 AllOf[BaseDictElementMatchType],

3353 ]

3354 ],

3355 ]

3356 ],

3357 MatchIfTrue[Sequence[cst.BaseDictElement]],

3358 ]

3359 ],

3360 ] = DoNotCare()

3361 lbrace: Union[

3362 LeftCurlyBraceMatchType,

3363 DoNotCareSentinel,

3364 OneOf[LeftCurlyBraceMatchType],

3365 AllOf[LeftCurlyBraceMatchType],

3366 ] = DoNotCare()

3367 rbrace: Union[

3368 RightCurlyBraceMatchType,

3369 DoNotCareSentinel,

3370 OneOf[RightCurlyBraceMatchType],

3371 AllOf[RightCurlyBraceMatchType],

3372 ] = DoNotCare()

3373 lpar: Union[

3374 Sequence[

3375 Union[

3376 LeftParenMatchType,

3377 DoNotCareSentinel,

3378 OneOf[LeftParenMatchType],

3379 AllOf[LeftParenMatchType],

3380 AtLeastN[

3381 Union[

3382 LeftParenMatchType,

3383 DoNotCareSentinel,

3384 OneOf[LeftParenMatchType],

3385 AllOf[LeftParenMatchType],

3386 ]

3387 ],

3388 AtMostN[

3389 Union[

3390 LeftParenMatchType,

3391 DoNotCareSentinel,

3392 OneOf[LeftParenMatchType],

3393 AllOf[LeftParenMatchType],

3394 ]

3395 ],

3396 ]

3397 ],

3398 DoNotCareSentinel,

3399 MatchIfTrue[Sequence[cst.LeftParen]],

3400 OneOf[

3401 Union[

3402 Sequence[

3403 Union[

3404 LeftParenMatchType,

3405 OneOf[LeftParenMatchType],

3406 AllOf[LeftParenMatchType],

3407 AtLeastN[

3408 Union[

3409 LeftParenMatchType,

3410 OneOf[LeftParenMatchType],

3411 AllOf[LeftParenMatchType],

3412 ]

3413 ],

3414 AtMostN[

3415 Union[

3416 LeftParenMatchType,

3417 OneOf[LeftParenMatchType],

3418 AllOf[LeftParenMatchType],

3419 ]

3420 ],

3421 ]

3422 ],

3423 MatchIfTrue[Sequence[cst.LeftParen]],

3424 ]

3425 ],

3426 AllOf[

3427 Union[

3428 Sequence[

3429 Union[

3430 LeftParenMatchType,

3431 OneOf[LeftParenMatchType],

3432 AllOf[LeftParenMatchType],

3433 AtLeastN[

3434 Union[

3435 LeftParenMatchType,

3436 OneOf[LeftParenMatchType],

3437 AllOf[LeftParenMatchType],

3438 ]

3439 ],

3440 AtMostN[

3441 Union[

3442 LeftParenMatchType,

3443 OneOf[LeftParenMatchType],

3444 AllOf[LeftParenMatchType],

3445 ]

3446 ],

3447 ]

3448 ],

3449 MatchIfTrue[Sequence[cst.LeftParen]],

3450 ]

3451 ],

3452 ] = DoNotCare()

3453 rpar: Union[

3454 Sequence[

3455 Union[

3456 RightParenMatchType,

3457 DoNotCareSentinel,

3458 OneOf[RightParenMatchType],

3459 AllOf[RightParenMatchType],

3460 AtLeastN[

3461 Union[

3462 RightParenMatchType,

3463 DoNotCareSentinel,

3464 OneOf[RightParenMatchType],

3465 AllOf[RightParenMatchType],

3466 ]

3467 ],

3468 AtMostN[

3469 Union[

3470 RightParenMatchType,

3471 DoNotCareSentinel,

3472 OneOf[RightParenMatchType],

3473 AllOf[RightParenMatchType],

3474 ]

3475 ],

3476 ]

3477 ],

3478 DoNotCareSentinel,

3479 MatchIfTrue[Sequence[cst.RightParen]],

3480 OneOf[

3481 Union[

3482 Sequence[

3483 Union[

3484 RightParenMatchType,

3485 OneOf[RightParenMatchType],

3486 AllOf[RightParenMatchType],

3487 AtLeastN[

3488 Union[

3489 RightParenMatchType,

3490 OneOf[RightParenMatchType],

3491 AllOf[RightParenMatchType],

3492 ]

3493 ],

3494 AtMostN[

3495 Union[

3496 RightParenMatchType,

3497 OneOf[RightParenMatchType],

3498 AllOf[RightParenMatchType],

3499 ]

3500 ],

3501 ]

3502 ],

3503 MatchIfTrue[Sequence[cst.RightParen]],

3504 ]

3505 ],

3506 AllOf[

3507 Union[

3508 Sequence[

3509 Union[

3510 RightParenMatchType,

3511 OneOf[RightParenMatchType],

3512 AllOf[RightParenMatchType],

3513 AtLeastN[

3514 Union[

3515 RightParenMatchType,

3516 OneOf[RightParenMatchType],

3517 AllOf[RightParenMatchType],

3518 ]

3519 ],

3520 AtMostN[

3521 Union[

3522 RightParenMatchType,

3523 OneOf[RightParenMatchType],

3524 AllOf[RightParenMatchType],

3525 ]

3526 ],

3527 ]

3528 ],

3529 MatchIfTrue[Sequence[cst.RightParen]],

3530 ]

3531 ],

3532 ] = DoNotCare()

3533 metadata: Union[

3534 MetadataMatchType,

3535 DoNotCareSentinel,

3536 OneOf[MetadataMatchType],

3537 AllOf[MetadataMatchType],

3538 ] = DoNotCare()

3539

3540

3541CompForMatchType = Union["CompFor", MetadataMatchType, MatchIfTrue[cst.CompFor]]

3542

3543

3544@dataclass(frozen=True, eq=False, unsafe_hash=False)

3545class DictComp(BaseComp, BaseDict, BaseExpression, BaseMatcherNode):

3546 key: Union[

3547 BaseExpressionMatchType,

3548 DoNotCareSentinel,

3549 OneOf[BaseExpressionMatchType],

3550 AllOf[BaseExpressionMatchType],

3551 ] = DoNotCare()

3552 value: Union[

3553 BaseExpressionMatchType,

3554 DoNotCareSentinel,

3555 OneOf[BaseExpressionMatchType],

3556 AllOf[BaseExpressionMatchType],

3557 ] = DoNotCare()

3558 for_in: Union[

3559 CompForMatchType,

3560 DoNotCareSentinel,

3561 OneOf[CompForMatchType],

3562 AllOf[CompForMatchType],

3563 ] = DoNotCare()

3564 lbrace: Union[

3565 LeftCurlyBraceMatchType,

3566 DoNotCareSentinel,

3567 OneOf[LeftCurlyBraceMatchType],

3568 AllOf[LeftCurlyBraceMatchType],

3569 ] = DoNotCare()

3570 rbrace: Union[

3571 RightCurlyBraceMatchType,

3572 DoNotCareSentinel,

3573 OneOf[RightCurlyBraceMatchType],

3574 AllOf[RightCurlyBraceMatchType],

3575 ] = DoNotCare()

3576 lpar: Union[

3577 Sequence[

3578 Union[

3579 LeftParenMatchType,

3580 DoNotCareSentinel,

3581 OneOf[LeftParenMatchType],

3582 AllOf[LeftParenMatchType],

3583 AtLeastN[

3584 Union[

3585 LeftParenMatchType,

3586 DoNotCareSentinel,

3587 OneOf[LeftParenMatchType],

3588 AllOf[LeftParenMatchType],

3589 ]

3590 ],

3591 AtMostN[

3592 Union[

3593 LeftParenMatchType,

3594 DoNotCareSentinel,

3595 OneOf[LeftParenMatchType],

3596 AllOf[LeftParenMatchType],

3597 ]

3598 ],

3599 ]

3600 ],

3601 DoNotCareSentinel,

3602 MatchIfTrue[Sequence[cst.LeftParen]],

3603 OneOf[

3604 Union[

3605 Sequence[

3606 Union[

3607 LeftParenMatchType,

3608 OneOf[LeftParenMatchType],

3609 AllOf[LeftParenMatchType],

3610 AtLeastN[

3611 Union[

3612 LeftParenMatchType,

3613 OneOf[LeftParenMatchType],

3614 AllOf[LeftParenMatchType],

3615 ]

3616 ],

3617 AtMostN[

3618 Union[

3619 LeftParenMatchType,

3620 OneOf[LeftParenMatchType],

3621 AllOf[LeftParenMatchType],

3622 ]

3623 ],

3624 ]

3625 ],

3626 MatchIfTrue[Sequence[cst.LeftParen]],

3627 ]

3628 ],

3629 AllOf[

3630 Union[

3631 Sequence[

3632 Union[

3633 LeftParenMatchType,

3634 OneOf[LeftParenMatchType],

3635 AllOf[LeftParenMatchType],

3636 AtLeastN[

3637 Union[

3638 LeftParenMatchType,

3639 OneOf[LeftParenMatchType],

3640 AllOf[LeftParenMatchType],

3641 ]

3642 ],

3643 AtMostN[

3644 Union[

3645 LeftParenMatchType,

3646 OneOf[LeftParenMatchType],

3647 AllOf[LeftParenMatchType],

3648 ]

3649 ],

3650 ]

3651 ],

3652 MatchIfTrue[Sequence[cst.LeftParen]],

3653 ]

3654 ],

3655 ] = DoNotCare()

3656 rpar: Union[

3657 Sequence[

3658 Union[

3659 RightParenMatchType,

3660 DoNotCareSentinel,

3661 OneOf[RightParenMatchType],

3662 AllOf[RightParenMatchType],

3663 AtLeastN[

3664 Union[

3665 RightParenMatchType,

3666 DoNotCareSentinel,

3667 OneOf[RightParenMatchType],

3668 AllOf[RightParenMatchType],

3669 ]

3670 ],

3671 AtMostN[

3672 Union[

3673 RightParenMatchType,

3674 DoNotCareSentinel,

3675 OneOf[RightParenMatchType],

3676 AllOf[RightParenMatchType],

3677 ]

3678 ],

3679 ]

3680 ],

3681 DoNotCareSentinel,

3682 MatchIfTrue[Sequence[cst.RightParen]],

3683 OneOf[

3684 Union[

3685 Sequence[

3686 Union[

3687 RightParenMatchType,

3688 OneOf[RightParenMatchType],

3689 AllOf[RightParenMatchType],

3690 AtLeastN[

3691 Union[

3692 RightParenMatchType,

3693 OneOf[RightParenMatchType],

3694 AllOf[RightParenMatchType],

3695 ]

3696 ],

3697 AtMostN[

3698 Union[

3699 RightParenMatchType,

3700 OneOf[RightParenMatchType],

3701 AllOf[RightParenMatchType],

3702 ]

3703 ],

3704 ]

3705 ],

3706 MatchIfTrue[Sequence[cst.RightParen]],

3707 ]

3708 ],

3709 AllOf[

3710 Union[

3711 Sequence[

3712 Union[

3713 RightParenMatchType,

3714 OneOf[RightParenMatchType],

3715 AllOf[RightParenMatchType],

3716 AtLeastN[

3717 Union[

3718 RightParenMatchType,

3719 OneOf[RightParenMatchType],

3720 AllOf[RightParenMatchType],

3721 ]

3722 ],

3723 AtMostN[

3724 Union[

3725 RightParenMatchType,

3726 OneOf[RightParenMatchType],

3727 AllOf[RightParenMatchType],

3728 ]

3729 ],

3730 ]

3731 ],

3732 MatchIfTrue[Sequence[cst.RightParen]],

3733 ]

3734 ],

3735 ] = DoNotCare()

3736 whitespace_before_colon: Union[

3737 BaseParenthesizableWhitespaceMatchType,

3738 DoNotCareSentinel,

3739 OneOf[BaseParenthesizableWhitespaceMatchType],

3740 AllOf[BaseParenthesizableWhitespaceMatchType],

3741 ] = DoNotCare()

3742 whitespace_after_colon: Union[

3743 BaseParenthesizableWhitespaceMatchType,

3744 DoNotCareSentinel,

3745 OneOf[BaseParenthesizableWhitespaceMatchType],

3746 AllOf[BaseParenthesizableWhitespaceMatchType],

3747 ] = DoNotCare()

3748 metadata: Union[

3749 MetadataMatchType,

3750 DoNotCareSentinel,

3751 OneOf[MetadataMatchType],

3752 AllOf[MetadataMatchType],

3753 ] = DoNotCare()

3754

3755

3756@dataclass(frozen=True, eq=False, unsafe_hash=False)

3757class DictElement(BaseDictElement, BaseMatcherNode):

3758 key: Union[

3759 BaseExpressionMatchType,

3760 DoNotCareSentinel,

3761 OneOf[BaseExpressionMatchType],

3762 AllOf[BaseExpressionMatchType],

3763 ] = DoNotCare()

3764 value: Union[

3765 BaseExpressionMatchType,

3766 DoNotCareSentinel,

3767 OneOf[BaseExpressionMatchType],

3768 AllOf[BaseExpressionMatchType],

3769 ] = DoNotCare()

3770 comma: Union[

3771 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

3772 ] = DoNotCare()

3773 whitespace_before_colon: Union[

3774 BaseParenthesizableWhitespaceMatchType,

3775 DoNotCareSentinel,

3776 OneOf[BaseParenthesizableWhitespaceMatchType],

3777 AllOf[BaseParenthesizableWhitespaceMatchType],

3778 ] = DoNotCare()

3779 whitespace_after_colon: Union[

3780 BaseParenthesizableWhitespaceMatchType,

3781 DoNotCareSentinel,

3782 OneOf[BaseParenthesizableWhitespaceMatchType],

3783 AllOf[BaseParenthesizableWhitespaceMatchType],

3784 ] = DoNotCare()

3785 metadata: Union[

3786 MetadataMatchType,

3787 DoNotCareSentinel,

3788 OneOf[MetadataMatchType],

3789 AllOf[MetadataMatchType],

3790 ] = DoNotCare()

3791

3792

3793@dataclass(frozen=True, eq=False, unsafe_hash=False)

3794class Divide(BaseBinaryOp, BaseMatcherNode):

3795 whitespace_before: Union[

3796 BaseParenthesizableWhitespaceMatchType,

3797 DoNotCareSentinel,

3798 OneOf[BaseParenthesizableWhitespaceMatchType],

3799 AllOf[BaseParenthesizableWhitespaceMatchType],

3800 ] = DoNotCare()

3801 whitespace_after: Union[

3802 BaseParenthesizableWhitespaceMatchType,

3803 DoNotCareSentinel,

3804 OneOf[BaseParenthesizableWhitespaceMatchType],

3805 AllOf[BaseParenthesizableWhitespaceMatchType],

3806 ] = DoNotCare()

3807 metadata: Union[

3808 MetadataMatchType,

3809 DoNotCareSentinel,

3810 OneOf[MetadataMatchType],

3811 AllOf[MetadataMatchType],

3812 ] = DoNotCare()

3813

3814

3815@dataclass(frozen=True, eq=False, unsafe_hash=False)

3816class DivideAssign(BaseAugOp, BaseMatcherNode):

3817 whitespace_before: Union[

3818 BaseParenthesizableWhitespaceMatchType,

3819 DoNotCareSentinel,

3820 OneOf[BaseParenthesizableWhitespaceMatchType],

3821 AllOf[BaseParenthesizableWhitespaceMatchType],

3822 ] = DoNotCare()

3823 whitespace_after: Union[

3824 BaseParenthesizableWhitespaceMatchType,

3825 DoNotCareSentinel,

3826 OneOf[BaseParenthesizableWhitespaceMatchType],

3827 AllOf[BaseParenthesizableWhitespaceMatchType],

3828 ] = DoNotCare()

3829 metadata: Union[

3830 MetadataMatchType,

3831 DoNotCareSentinel,

3832 OneOf[MetadataMatchType],

3833 AllOf[MetadataMatchType],

3834 ] = DoNotCare()

3835

3836

3837@dataclass(frozen=True, eq=False, unsafe_hash=False)

3838class Dot(BaseMatcherNode):

3839 whitespace_before: Union[

3840 BaseParenthesizableWhitespaceMatchType,

3841 DoNotCareSentinel,

3842 OneOf[BaseParenthesizableWhitespaceMatchType],

3843 AllOf[BaseParenthesizableWhitespaceMatchType],

3844 ] = DoNotCare()

3845 whitespace_after: Union[

3846 BaseParenthesizableWhitespaceMatchType,

3847 DoNotCareSentinel,

3848 OneOf[BaseParenthesizableWhitespaceMatchType],

3849 AllOf[BaseParenthesizableWhitespaceMatchType],

3850 ] = DoNotCare()

3851 metadata: Union[

3852 MetadataMatchType,

3853 DoNotCareSentinel,

3854 OneOf[MetadataMatchType],

3855 AllOf[MetadataMatchType],

3856 ] = DoNotCare()

3857

3858

3859@dataclass(frozen=True, eq=False, unsafe_hash=False)

3860class Element(BaseElement, BaseMatcherNode):

3861 value: Union[

3862 BaseExpressionMatchType,

3863 DoNotCareSentinel,

3864 OneOf[BaseExpressionMatchType],

3865 AllOf[BaseExpressionMatchType],

3866 ] = DoNotCare()

3867 comma: Union[

3868 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

3869 ] = DoNotCare()

3870 metadata: Union[

3871 MetadataMatchType,

3872 DoNotCareSentinel,

3873 OneOf[MetadataMatchType],

3874 AllOf[MetadataMatchType],

3875 ] = DoNotCare()

3876

3877

3878@dataclass(frozen=True, eq=False, unsafe_hash=False)

3879class Ellipsis(BaseExpression, BaseMatcherNode):

3880 lpar: Union[

3881 Sequence[

3882 Union[

3883 LeftParenMatchType,

3884 DoNotCareSentinel,

3885 OneOf[LeftParenMatchType],

3886 AllOf[LeftParenMatchType],

3887 AtLeastN[

3888 Union[

3889 LeftParenMatchType,

3890 DoNotCareSentinel,

3891 OneOf[LeftParenMatchType],

3892 AllOf[LeftParenMatchType],

3893 ]

3894 ],

3895 AtMostN[

3896 Union[

3897 LeftParenMatchType,

3898 DoNotCareSentinel,

3899 OneOf[LeftParenMatchType],

3900 AllOf[LeftParenMatchType],

3901 ]

3902 ],

3903 ]

3904 ],

3905 DoNotCareSentinel,

3906 MatchIfTrue[Sequence[cst.LeftParen]],

3907 OneOf[

3908 Union[

3909 Sequence[

3910 Union[

3911 LeftParenMatchType,

3912 OneOf[LeftParenMatchType],

3913 AllOf[LeftParenMatchType],

3914 AtLeastN[

3915 Union[

3916 LeftParenMatchType,

3917 OneOf[LeftParenMatchType],

3918 AllOf[LeftParenMatchType],

3919 ]

3920 ],

3921 AtMostN[

3922 Union[

3923 LeftParenMatchType,

3924 OneOf[LeftParenMatchType],

3925 AllOf[LeftParenMatchType],

3926 ]

3927 ],

3928 ]

3929 ],

3930 MatchIfTrue[Sequence[cst.LeftParen]],

3931 ]

3932 ],

3933 AllOf[

3934 Union[

3935 Sequence[

3936 Union[

3937 LeftParenMatchType,

3938 OneOf[LeftParenMatchType],

3939 AllOf[LeftParenMatchType],

3940 AtLeastN[

3941 Union[

3942 LeftParenMatchType,

3943 OneOf[LeftParenMatchType],

3944 AllOf[LeftParenMatchType],

3945 ]

3946 ],

3947 AtMostN[

3948 Union[

3949 LeftParenMatchType,

3950 OneOf[LeftParenMatchType],

3951 AllOf[LeftParenMatchType],

3952 ]

3953 ],

3954 ]

3955 ],

3956 MatchIfTrue[Sequence[cst.LeftParen]],

3957 ]

3958 ],

3959 ] = DoNotCare()

3960 rpar: Union[

3961 Sequence[

3962 Union[

3963 RightParenMatchType,

3964 DoNotCareSentinel,

3965 OneOf[RightParenMatchType],

3966 AllOf[RightParenMatchType],

3967 AtLeastN[

3968 Union[

3969 RightParenMatchType,

3970 DoNotCareSentinel,

3971 OneOf[RightParenMatchType],

3972 AllOf[RightParenMatchType],

3973 ]

3974 ],

3975 AtMostN[

3976 Union[

3977 RightParenMatchType,

3978 DoNotCareSentinel,

3979 OneOf[RightParenMatchType],

3980 AllOf[RightParenMatchType],

3981 ]

3982 ],

3983 ]

3984 ],

3985 DoNotCareSentinel,

3986 MatchIfTrue[Sequence[cst.RightParen]],

3987 OneOf[

3988 Union[

3989 Sequence[

3990 Union[

3991 RightParenMatchType,

3992 OneOf[RightParenMatchType],

3993 AllOf[RightParenMatchType],

3994 AtLeastN[

3995 Union[

3996 RightParenMatchType,

3997 OneOf[RightParenMatchType],

3998 AllOf[RightParenMatchType],

3999 ]

4000 ],

4001 AtMostN[

4002 Union[

4003 RightParenMatchType,

4004 OneOf[RightParenMatchType],

4005 AllOf[RightParenMatchType],

4006 ]

4007 ],

4008 ]

4009 ],

4010 MatchIfTrue[Sequence[cst.RightParen]],

4011 ]

4012 ],

4013 AllOf[

4014 Union[

4015 Sequence[

4016 Union[

4017 RightParenMatchType,

4018 OneOf[RightParenMatchType],

4019 AllOf[RightParenMatchType],

4020 AtLeastN[

4021 Union[

4022 RightParenMatchType,

4023 OneOf[RightParenMatchType],

4024 AllOf[RightParenMatchType],

4025 ]

4026 ],

4027 AtMostN[

4028 Union[

4029 RightParenMatchType,

4030 OneOf[RightParenMatchType],

4031 AllOf[RightParenMatchType],

4032 ]

4033 ],

4034 ]

4035 ],

4036 MatchIfTrue[Sequence[cst.RightParen]],

4037 ]

4038 ],

4039 ] = DoNotCare()

4040 metadata: Union[

4041 MetadataMatchType,

4042 DoNotCareSentinel,

4043 OneOf[MetadataMatchType],

4044 AllOf[MetadataMatchType],

4045 ] = DoNotCare()

4046

4047

4048@dataclass(frozen=True, eq=False, unsafe_hash=False)

4049class Else(BaseMatcherNode):

4050 body: Union[

4051 BaseSuiteMatchType,

4052 DoNotCareSentinel,

4053 OneOf[BaseSuiteMatchType],

4054 AllOf[BaseSuiteMatchType],

4055 ] = DoNotCare()

4056 leading_lines: Union[

4057 Sequence[

4058 Union[

4059 EmptyLineMatchType,

4060 DoNotCareSentinel,

4061 OneOf[EmptyLineMatchType],

4062 AllOf[EmptyLineMatchType],

4063 AtLeastN[

4064 Union[

4065 EmptyLineMatchType,

4066 DoNotCareSentinel,

4067 OneOf[EmptyLineMatchType],

4068 AllOf[EmptyLineMatchType],

4069 ]

4070 ],

4071 AtMostN[

4072 Union[

4073 EmptyLineMatchType,

4074 DoNotCareSentinel,

4075 OneOf[EmptyLineMatchType],

4076 AllOf[EmptyLineMatchType],

4077 ]

4078 ],

4079 ]

4080 ],

4081 DoNotCareSentinel,

4082 MatchIfTrue[Sequence[cst.EmptyLine]],

4083 OneOf[

4084 Union[

4085 Sequence[

4086 Union[

4087 EmptyLineMatchType,

4088 OneOf[EmptyLineMatchType],

4089 AllOf[EmptyLineMatchType],

4090 AtLeastN[

4091 Union[

4092 EmptyLineMatchType,

4093 OneOf[EmptyLineMatchType],

4094 AllOf[EmptyLineMatchType],

4095 ]

4096 ],

4097 AtMostN[

4098 Union[

4099 EmptyLineMatchType,

4100 OneOf[EmptyLineMatchType],

4101 AllOf[EmptyLineMatchType],

4102 ]

4103 ],

4104 ]

4105 ],

4106 MatchIfTrue[Sequence[cst.EmptyLine]],

4107 ]

4108 ],

4109 AllOf[

4110 Union[

4111 Sequence[

4112 Union[

4113 EmptyLineMatchType,

4114 OneOf[EmptyLineMatchType],

4115 AllOf[EmptyLineMatchType],

4116 AtLeastN[

4117 Union[

4118 EmptyLineMatchType,

4119 OneOf[EmptyLineMatchType],

4120 AllOf[EmptyLineMatchType],

4121 ]

4122 ],

4123 AtMostN[

4124 Union[

4125 EmptyLineMatchType,

4126 OneOf[EmptyLineMatchType],

4127 AllOf[EmptyLineMatchType],

4128 ]

4129 ],

4130 ]

4131 ],

4132 MatchIfTrue[Sequence[cst.EmptyLine]],

4133 ]

4134 ],

4135 ] = DoNotCare()

4136 whitespace_before_colon: Union[

4137 SimpleWhitespaceMatchType,

4138 DoNotCareSentinel,

4139 OneOf[SimpleWhitespaceMatchType],

4140 AllOf[SimpleWhitespaceMatchType],

4141 ] = DoNotCare()

4142 metadata: Union[

4143 MetadataMatchType,

4144 DoNotCareSentinel,

4145 OneOf[MetadataMatchType],

4146 AllOf[MetadataMatchType],

4147 ] = DoNotCare()

4148

4149

4150boolMatchType = Union[bool, MetadataMatchType, MatchIfTrue[bool]]

4151NewlineMatchType = Union["Newline", MetadataMatchType, MatchIfTrue[cst.Newline]]

4152

4153

4154@dataclass(frozen=True, eq=False, unsafe_hash=False)

4155class EmptyLine(BaseMatcherNode):

4156 indent: Union[

4157 boolMatchType, DoNotCareSentinel, OneOf[boolMatchType], AllOf[boolMatchType]

4158 ] = DoNotCare()

4159 whitespace: Union[

4160 SimpleWhitespaceMatchType,

4161 DoNotCareSentinel,

4162 OneOf[SimpleWhitespaceMatchType],

4163 AllOf[SimpleWhitespaceMatchType],

4164 ] = DoNotCare()

4165 comment: Union[

4166 Optional["Comment"],

4167 MetadataMatchType,

4168 MatchIfTrue[Optional[cst.Comment]],

4169 DoNotCareSentinel,

4170 OneOf[

4171 Union[

4172 Optional["Comment"],

4173 MetadataMatchType,

4174 MatchIfTrue[Optional[cst.Comment]],

4175 ]

4176 ],

4177 AllOf[

4178 Union[

4179 Optional["Comment"],

4180 MetadataMatchType,

4181 MatchIfTrue[Optional[cst.Comment]],

4182 ]

4183 ],

4184 ] = DoNotCare()

4185 newline: Union[

4186 NewlineMatchType,

4187 DoNotCareSentinel,

4188 OneOf[NewlineMatchType],

4189 AllOf[NewlineMatchType],

4190 ] = DoNotCare()

4191 metadata: Union[

4192 MetadataMatchType,

4193 DoNotCareSentinel,

4194 OneOf[MetadataMatchType],

4195 AllOf[MetadataMatchType],

4196 ] = DoNotCare()

4197

4198

4199@dataclass(frozen=True, eq=False, unsafe_hash=False)

4200class Equal(BaseCompOp, BaseMatcherNode):

4201 whitespace_before: Union[

4202 BaseParenthesizableWhitespaceMatchType,

4203 DoNotCareSentinel,

4204 OneOf[BaseParenthesizableWhitespaceMatchType],

4205 AllOf[BaseParenthesizableWhitespaceMatchType],

4206 ] = DoNotCare()

4207 whitespace_after: Union[

4208 BaseParenthesizableWhitespaceMatchType,

4209 DoNotCareSentinel,

4210 OneOf[BaseParenthesizableWhitespaceMatchType],

4211 AllOf[BaseParenthesizableWhitespaceMatchType],

4212 ] = DoNotCare()

4213 metadata: Union[

4214 MetadataMatchType,

4215 DoNotCareSentinel,

4216 OneOf[MetadataMatchType],

4217 AllOf[MetadataMatchType],

4218 ] = DoNotCare()

4219

4220

4221@dataclass(frozen=True, eq=False, unsafe_hash=False)

4222class ExceptHandler(BaseMatcherNode):

4223 body: Union[

4224 BaseSuiteMatchType,

4225 DoNotCareSentinel,

4226 OneOf[BaseSuiteMatchType],

4227 AllOf[BaseSuiteMatchType],

4228 ] = DoNotCare()

4229 type: Union[

4230 Optional["BaseExpression"],

4231 MetadataMatchType,

4232 MatchIfTrue[Optional[cst.BaseExpression]],

4233 DoNotCareSentinel,

4234 OneOf[

4235 Union[

4236 Optional["BaseExpression"],

4237 MetadataMatchType,

4238 MatchIfTrue[Optional[cst.BaseExpression]],

4239 ]

4240 ],

4241 AllOf[

4242 Union[

4243 Optional["BaseExpression"],

4244 MetadataMatchType,

4245 MatchIfTrue[Optional[cst.BaseExpression]],

4246 ]

4247 ],

4248 ] = DoNotCare()

4249 name: Union[

4250 Optional["AsName"],

4251 MetadataMatchType,

4252 MatchIfTrue[Optional[cst.AsName]],

4253 DoNotCareSentinel,

4254 OneOf[

4255 Union[

4256 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

4257 ]

4258 ],

4259 AllOf[

4260 Union[

4261 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

4262 ]

4263 ],

4264 ] = DoNotCare()

4265 leading_lines: Union[

4266 Sequence[

4267 Union[

4268 EmptyLineMatchType,

4269 DoNotCareSentinel,

4270 OneOf[EmptyLineMatchType],

4271 AllOf[EmptyLineMatchType],

4272 AtLeastN[

4273 Union[

4274 EmptyLineMatchType,

4275 DoNotCareSentinel,

4276 OneOf[EmptyLineMatchType],

4277 AllOf[EmptyLineMatchType],

4278 ]

4279 ],

4280 AtMostN[

4281 Union[

4282 EmptyLineMatchType,

4283 DoNotCareSentinel,

4284 OneOf[EmptyLineMatchType],

4285 AllOf[EmptyLineMatchType],

4286 ]

4287 ],

4288 ]

4289 ],

4290 DoNotCareSentinel,

4291 MatchIfTrue[Sequence[cst.EmptyLine]],

4292 OneOf[

4293 Union[

4294 Sequence[

4295 Union[

4296 EmptyLineMatchType,

4297 OneOf[EmptyLineMatchType],

4298 AllOf[EmptyLineMatchType],

4299 AtLeastN[

4300 Union[

4301 EmptyLineMatchType,

4302 OneOf[EmptyLineMatchType],

4303 AllOf[EmptyLineMatchType],

4304 ]

4305 ],

4306 AtMostN[

4307 Union[

4308 EmptyLineMatchType,

4309 OneOf[EmptyLineMatchType],

4310 AllOf[EmptyLineMatchType],

4311 ]

4312 ],

4313 ]

4314 ],

4315 MatchIfTrue[Sequence[cst.EmptyLine]],

4316 ]

4317 ],

4318 AllOf[

4319 Union[

4320 Sequence[

4321 Union[

4322 EmptyLineMatchType,

4323 OneOf[EmptyLineMatchType],

4324 AllOf[EmptyLineMatchType],

4325 AtLeastN[

4326 Union[

4327 EmptyLineMatchType,

4328 OneOf[EmptyLineMatchType],

4329 AllOf[EmptyLineMatchType],

4330 ]

4331 ],

4332 AtMostN[

4333 Union[

4334 EmptyLineMatchType,

4335 OneOf[EmptyLineMatchType],

4336 AllOf[EmptyLineMatchType],

4337 ]

4338 ],

4339 ]

4340 ],

4341 MatchIfTrue[Sequence[cst.EmptyLine]],

4342 ]

4343 ],

4344 ] = DoNotCare()

4345 whitespace_after_except: Union[

4346 SimpleWhitespaceMatchType,

4347 DoNotCareSentinel,

4348 OneOf[SimpleWhitespaceMatchType],

4349 AllOf[SimpleWhitespaceMatchType],

4350 ] = DoNotCare()

4351 whitespace_before_colon: Union[

4352 SimpleWhitespaceMatchType,

4353 DoNotCareSentinel,

4354 OneOf[SimpleWhitespaceMatchType],

4355 AllOf[SimpleWhitespaceMatchType],

4356 ] = DoNotCare()

4357 metadata: Union[

4358 MetadataMatchType,

4359 DoNotCareSentinel,

4360 OneOf[MetadataMatchType],

4361 AllOf[MetadataMatchType],

4362 ] = DoNotCare()

4363

4364

4365@dataclass(frozen=True, eq=False, unsafe_hash=False)

4366class ExceptStarHandler(BaseMatcherNode):

4367 body: Union[

4368 BaseSuiteMatchType,

4369 DoNotCareSentinel,

4370 OneOf[BaseSuiteMatchType],

4371 AllOf[BaseSuiteMatchType],

4372 ] = DoNotCare()

4373 type: Union[

4374 BaseExpressionMatchType,

4375 DoNotCareSentinel,

4376 OneOf[BaseExpressionMatchType],

4377 AllOf[BaseExpressionMatchType],

4378 ] = DoNotCare()

4379 name: Union[

4380 Optional["AsName"],

4381 MetadataMatchType,

4382 MatchIfTrue[Optional[cst.AsName]],

4383 DoNotCareSentinel,

4384 OneOf[

4385 Union[

4386 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

4387 ]

4388 ],

4389 AllOf[

4390 Union[

4391 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

4392 ]

4393 ],

4394 ] = DoNotCare()

4395 leading_lines: Union[

4396 Sequence[

4397 Union[

4398 EmptyLineMatchType,

4399 DoNotCareSentinel,

4400 OneOf[EmptyLineMatchType],

4401 AllOf[EmptyLineMatchType],

4402 AtLeastN[

4403 Union[

4404 EmptyLineMatchType,

4405 DoNotCareSentinel,

4406 OneOf[EmptyLineMatchType],

4407 AllOf[EmptyLineMatchType],

4408 ]

4409 ],

4410 AtMostN[

4411 Union[

4412 EmptyLineMatchType,

4413 DoNotCareSentinel,

4414 OneOf[EmptyLineMatchType],

4415 AllOf[EmptyLineMatchType],

4416 ]

4417 ],

4418 ]

4419 ],

4420 DoNotCareSentinel,

4421 MatchIfTrue[Sequence[cst.EmptyLine]],

4422 OneOf[

4423 Union[

4424 Sequence[

4425 Union[

4426 EmptyLineMatchType,

4427 OneOf[EmptyLineMatchType],

4428 AllOf[EmptyLineMatchType],

4429 AtLeastN[

4430 Union[

4431 EmptyLineMatchType,

4432 OneOf[EmptyLineMatchType],

4433 AllOf[EmptyLineMatchType],

4434 ]

4435 ],

4436 AtMostN[

4437 Union[

4438 EmptyLineMatchType,

4439 OneOf[EmptyLineMatchType],

4440 AllOf[EmptyLineMatchType],

4441 ]

4442 ],

4443 ]

4444 ],

4445 MatchIfTrue[Sequence[cst.EmptyLine]],

4446 ]

4447 ],

4448 AllOf[

4449 Union[

4450 Sequence[

4451 Union[

4452 EmptyLineMatchType,

4453 OneOf[EmptyLineMatchType],

4454 AllOf[EmptyLineMatchType],

4455 AtLeastN[

4456 Union[

4457 EmptyLineMatchType,

4458 OneOf[EmptyLineMatchType],

4459 AllOf[EmptyLineMatchType],

4460 ]

4461 ],

4462 AtMostN[

4463 Union[

4464 EmptyLineMatchType,

4465 OneOf[EmptyLineMatchType],

4466 AllOf[EmptyLineMatchType],

4467 ]

4468 ],

4469 ]

4470 ],

4471 MatchIfTrue[Sequence[cst.EmptyLine]],

4472 ]

4473 ],

4474 ] = DoNotCare()

4475 whitespace_after_except: Union[

4476 SimpleWhitespaceMatchType,

4477 DoNotCareSentinel,

4478 OneOf[SimpleWhitespaceMatchType],

4479 AllOf[SimpleWhitespaceMatchType],

4480 ] = DoNotCare()

4481 whitespace_after_star: Union[

4482 SimpleWhitespaceMatchType,

4483 DoNotCareSentinel,

4484 OneOf[SimpleWhitespaceMatchType],

4485 AllOf[SimpleWhitespaceMatchType],

4486 ] = DoNotCare()

4487 whitespace_before_colon: Union[

4488 SimpleWhitespaceMatchType,

4489 DoNotCareSentinel,

4490 OneOf[SimpleWhitespaceMatchType],

4491 AllOf[SimpleWhitespaceMatchType],

4492 ] = DoNotCare()

4493 metadata: Union[

4494 MetadataMatchType,

4495 DoNotCareSentinel,

4496 OneOf[MetadataMatchType],

4497 AllOf[MetadataMatchType],

4498 ] = DoNotCare()

4499

4500

4501@dataclass(frozen=True, eq=False, unsafe_hash=False)

4502class Expr(BaseSmallStatement, BaseMatcherNode):

4503 value: Union[

4504 BaseExpressionMatchType,

4505 DoNotCareSentinel,

4506 OneOf[BaseExpressionMatchType],

4507 AllOf[BaseExpressionMatchType],

4508 ] = DoNotCare()

4509 semicolon: Union[

4510 SemicolonMatchType,

4511 DoNotCareSentinel,

4512 OneOf[SemicolonMatchType],

4513 AllOf[SemicolonMatchType],

4514 ] = DoNotCare()

4515 metadata: Union[

4516 MetadataMatchType,

4517 DoNotCareSentinel,

4518 OneOf[MetadataMatchType],

4519 AllOf[MetadataMatchType],

4520 ] = DoNotCare()

4521

4522

4523@dataclass(frozen=True, eq=False, unsafe_hash=False)

4524class Finally(BaseMatcherNode):

4525 body: Union[

4526 BaseSuiteMatchType,

4527 DoNotCareSentinel,

4528 OneOf[BaseSuiteMatchType],

4529 AllOf[BaseSuiteMatchType],

4530 ] = DoNotCare()

4531 leading_lines: Union[

4532 Sequence[

4533 Union[

4534 EmptyLineMatchType,

4535 DoNotCareSentinel,

4536 OneOf[EmptyLineMatchType],

4537 AllOf[EmptyLineMatchType],

4538 AtLeastN[

4539 Union[

4540 EmptyLineMatchType,

4541 DoNotCareSentinel,

4542 OneOf[EmptyLineMatchType],

4543 AllOf[EmptyLineMatchType],

4544 ]

4545 ],

4546 AtMostN[

4547 Union[

4548 EmptyLineMatchType,

4549 DoNotCareSentinel,

4550 OneOf[EmptyLineMatchType],

4551 AllOf[EmptyLineMatchType],

4552 ]

4553 ],

4554 ]

4555 ],

4556 DoNotCareSentinel,

4557 MatchIfTrue[Sequence[cst.EmptyLine]],

4558 OneOf[

4559 Union[

4560 Sequence[

4561 Union[

4562 EmptyLineMatchType,

4563 OneOf[EmptyLineMatchType],

4564 AllOf[EmptyLineMatchType],

4565 AtLeastN[

4566 Union[

4567 EmptyLineMatchType,

4568 OneOf[EmptyLineMatchType],

4569 AllOf[EmptyLineMatchType],

4570 ]

4571 ],

4572 AtMostN[

4573 Union[

4574 EmptyLineMatchType,

4575 OneOf[EmptyLineMatchType],

4576 AllOf[EmptyLineMatchType],

4577 ]

4578 ],

4579 ]

4580 ],

4581 MatchIfTrue[Sequence[cst.EmptyLine]],

4582 ]

4583 ],

4584 AllOf[

4585 Union[

4586 Sequence[

4587 Union[

4588 EmptyLineMatchType,

4589 OneOf[EmptyLineMatchType],

4590 AllOf[EmptyLineMatchType],

4591 AtLeastN[

4592 Union[

4593 EmptyLineMatchType,

4594 OneOf[EmptyLineMatchType],

4595 AllOf[EmptyLineMatchType],

4596 ]

4597 ],

4598 AtMostN[

4599 Union[

4600 EmptyLineMatchType,

4601 OneOf[EmptyLineMatchType],

4602 AllOf[EmptyLineMatchType],

4603 ]

4604 ],

4605 ]

4606 ],

4607 MatchIfTrue[Sequence[cst.EmptyLine]],

4608 ]

4609 ],

4610 ] = DoNotCare()

4611 whitespace_before_colon: Union[

4612 SimpleWhitespaceMatchType,

4613 DoNotCareSentinel,

4614 OneOf[SimpleWhitespaceMatchType],

4615 AllOf[SimpleWhitespaceMatchType],

4616 ] = DoNotCare()

4617 metadata: Union[

4618 MetadataMatchType,

4619 DoNotCareSentinel,

4620 OneOf[MetadataMatchType],

4621 AllOf[MetadataMatchType],

4622 ] = DoNotCare()

4623

4624

4625@dataclass(frozen=True, eq=False, unsafe_hash=False)

4626class Float(BaseExpression, BaseNumber, BaseMatcherNode):

4627 value: Union[

4628 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

4629 ] = DoNotCare()

4630 lpar: Union[

4631 Sequence[

4632 Union[

4633 LeftParenMatchType,

4634 DoNotCareSentinel,

4635 OneOf[LeftParenMatchType],

4636 AllOf[LeftParenMatchType],

4637 AtLeastN[

4638 Union[

4639 LeftParenMatchType,

4640 DoNotCareSentinel,

4641 OneOf[LeftParenMatchType],

4642 AllOf[LeftParenMatchType],

4643 ]

4644 ],

4645 AtMostN[

4646 Union[

4647 LeftParenMatchType,

4648 DoNotCareSentinel,

4649 OneOf[LeftParenMatchType],

4650 AllOf[LeftParenMatchType],

4651 ]

4652 ],

4653 ]

4654 ],

4655 DoNotCareSentinel,

4656 MatchIfTrue[Sequence[cst.LeftParen]],

4657 OneOf[

4658 Union[

4659 Sequence[

4660 Union[

4661 LeftParenMatchType,

4662 OneOf[LeftParenMatchType],

4663 AllOf[LeftParenMatchType],

4664 AtLeastN[

4665 Union[

4666 LeftParenMatchType,

4667 OneOf[LeftParenMatchType],

4668 AllOf[LeftParenMatchType],

4669 ]

4670 ],

4671 AtMostN[

4672 Union[

4673 LeftParenMatchType,

4674 OneOf[LeftParenMatchType],

4675 AllOf[LeftParenMatchType],

4676 ]

4677 ],

4678 ]

4679 ],

4680 MatchIfTrue[Sequence[cst.LeftParen]],

4681 ]

4682 ],

4683 AllOf[

4684 Union[

4685 Sequence[

4686 Union[

4687 LeftParenMatchType,

4688 OneOf[LeftParenMatchType],

4689 AllOf[LeftParenMatchType],

4690 AtLeastN[

4691 Union[

4692 LeftParenMatchType,

4693 OneOf[LeftParenMatchType],

4694 AllOf[LeftParenMatchType],

4695 ]

4696 ],

4697 AtMostN[

4698 Union[

4699 LeftParenMatchType,

4700 OneOf[LeftParenMatchType],

4701 AllOf[LeftParenMatchType],

4702 ]

4703 ],

4704 ]

4705 ],

4706 MatchIfTrue[Sequence[cst.LeftParen]],

4707 ]

4708 ],

4709 ] = DoNotCare()

4710 rpar: Union[

4711 Sequence[

4712 Union[

4713 RightParenMatchType,

4714 DoNotCareSentinel,

4715 OneOf[RightParenMatchType],

4716 AllOf[RightParenMatchType],

4717 AtLeastN[

4718 Union[

4719 RightParenMatchType,

4720 DoNotCareSentinel,

4721 OneOf[RightParenMatchType],

4722 AllOf[RightParenMatchType],

4723 ]

4724 ],

4725 AtMostN[

4726 Union[

4727 RightParenMatchType,

4728 DoNotCareSentinel,

4729 OneOf[RightParenMatchType],

4730 AllOf[RightParenMatchType],

4731 ]

4732 ],

4733 ]

4734 ],

4735 DoNotCareSentinel,

4736 MatchIfTrue[Sequence[cst.RightParen]],

4737 OneOf[

4738 Union[

4739 Sequence[

4740 Union[

4741 RightParenMatchType,

4742 OneOf[RightParenMatchType],

4743 AllOf[RightParenMatchType],

4744 AtLeastN[

4745 Union[

4746 RightParenMatchType,

4747 OneOf[RightParenMatchType],

4748 AllOf[RightParenMatchType],

4749 ]

4750 ],

4751 AtMostN[

4752 Union[

4753 RightParenMatchType,

4754 OneOf[RightParenMatchType],

4755 AllOf[RightParenMatchType],

4756 ]

4757 ],

4758 ]

4759 ],

4760 MatchIfTrue[Sequence[cst.RightParen]],

4761 ]

4762 ],

4763 AllOf[

4764 Union[

4765 Sequence[

4766 Union[

4767 RightParenMatchType,

4768 OneOf[RightParenMatchType],

4769 AllOf[RightParenMatchType],

4770 AtLeastN[

4771 Union[

4772 RightParenMatchType,

4773 OneOf[RightParenMatchType],

4774 AllOf[RightParenMatchType],

4775 ]

4776 ],

4777 AtMostN[

4778 Union[

4779 RightParenMatchType,

4780 OneOf[RightParenMatchType],

4781 AllOf[RightParenMatchType],

4782 ]

4783 ],

4784 ]

4785 ],

4786 MatchIfTrue[Sequence[cst.RightParen]],

4787 ]

4788 ],

4789 ] = DoNotCare()

4790 metadata: Union[

4791 MetadataMatchType,

4792 DoNotCareSentinel,

4793 OneOf[MetadataMatchType],

4794 AllOf[MetadataMatchType],

4795 ] = DoNotCare()

4796

4797

4798@dataclass(frozen=True, eq=False, unsafe_hash=False)

4799class FloorDivide(BaseBinaryOp, BaseMatcherNode):

4800 whitespace_before: Union[

4801 BaseParenthesizableWhitespaceMatchType,

4802 DoNotCareSentinel,

4803 OneOf[BaseParenthesizableWhitespaceMatchType],

4804 AllOf[BaseParenthesizableWhitespaceMatchType],

4805 ] = DoNotCare()

4806 whitespace_after: Union[

4807 BaseParenthesizableWhitespaceMatchType,

4808 DoNotCareSentinel,

4809 OneOf[BaseParenthesizableWhitespaceMatchType],

4810 AllOf[BaseParenthesizableWhitespaceMatchType],

4811 ] = DoNotCare()

4812 metadata: Union[

4813 MetadataMatchType,

4814 DoNotCareSentinel,

4815 OneOf[MetadataMatchType],

4816 AllOf[MetadataMatchType],

4817 ] = DoNotCare()

4818

4819

4820@dataclass(frozen=True, eq=False, unsafe_hash=False)

4821class FloorDivideAssign(BaseAugOp, BaseMatcherNode):

4822 whitespace_before: Union[

4823 BaseParenthesizableWhitespaceMatchType,

4824 DoNotCareSentinel,

4825 OneOf[BaseParenthesizableWhitespaceMatchType],

4826 AllOf[BaseParenthesizableWhitespaceMatchType],

4827 ] = DoNotCare()

4828 whitespace_after: Union[

4829 BaseParenthesizableWhitespaceMatchType,

4830 DoNotCareSentinel,

4831 OneOf[BaseParenthesizableWhitespaceMatchType],

4832 AllOf[BaseParenthesizableWhitespaceMatchType],

4833 ] = DoNotCare()

4834 metadata: Union[

4835 MetadataMatchType,

4836 DoNotCareSentinel,

4837 OneOf[MetadataMatchType],

4838 AllOf[MetadataMatchType],

4839 ] = DoNotCare()

4840

4841

4842@dataclass(frozen=True, eq=False, unsafe_hash=False)

4843class For(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

4844 target: Union[

4845 BaseAssignTargetExpressionMatchType,

4846 DoNotCareSentinel,

4847 OneOf[BaseAssignTargetExpressionMatchType],

4848 AllOf[BaseAssignTargetExpressionMatchType],

4849 ] = DoNotCare()

4850 iter: Union[

4851 BaseExpressionMatchType,

4852 DoNotCareSentinel,

4853 OneOf[BaseExpressionMatchType],

4854 AllOf[BaseExpressionMatchType],

4855 ] = DoNotCare()

4856 body: Union[

4857 BaseSuiteMatchType,

4858 DoNotCareSentinel,

4859 OneOf[BaseSuiteMatchType],

4860 AllOf[BaseSuiteMatchType],

4861 ] = DoNotCare()

4862 orelse: Union[

4863 Optional["Else"],

4864 MetadataMatchType,

4865 MatchIfTrue[Optional[cst.Else]],

4866 DoNotCareSentinel,

4867 OneOf[

4868 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

4869 ],

4870 AllOf[

4871 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

4872 ],

4873 ] = DoNotCare()

4874 asynchronous: Union[

4875 Optional["Asynchronous"],

4876 MetadataMatchType,

4877 MatchIfTrue[Optional[cst.Asynchronous]],

4878 DoNotCareSentinel,

4879 OneOf[

4880 Union[

4881 Optional["Asynchronous"],

4882 MetadataMatchType,

4883 MatchIfTrue[Optional[cst.Asynchronous]],

4884 ]

4885 ],

4886 AllOf[

4887 Union[

4888 Optional["Asynchronous"],

4889 MetadataMatchType,

4890 MatchIfTrue[Optional[cst.Asynchronous]],

4891 ]

4892 ],

4893 ] = DoNotCare()

4894 leading_lines: Union[

4895 Sequence[

4896 Union[

4897 EmptyLineMatchType,

4898 DoNotCareSentinel,

4899 OneOf[EmptyLineMatchType],

4900 AllOf[EmptyLineMatchType],

4901 AtLeastN[

4902 Union[

4903 EmptyLineMatchType,

4904 DoNotCareSentinel,

4905 OneOf[EmptyLineMatchType],

4906 AllOf[EmptyLineMatchType],

4907 ]

4908 ],

4909 AtMostN[

4910 Union[

4911 EmptyLineMatchType,

4912 DoNotCareSentinel,

4913 OneOf[EmptyLineMatchType],

4914 AllOf[EmptyLineMatchType],

4915 ]

4916 ],

4917 ]

4918 ],

4919 DoNotCareSentinel,

4920 MatchIfTrue[Sequence[cst.EmptyLine]],

4921 OneOf[

4922 Union[

4923 Sequence[

4924 Union[

4925 EmptyLineMatchType,

4926 OneOf[EmptyLineMatchType],

4927 AllOf[EmptyLineMatchType],

4928 AtLeastN[

4929 Union[

4930 EmptyLineMatchType,

4931 OneOf[EmptyLineMatchType],

4932 AllOf[EmptyLineMatchType],

4933 ]

4934 ],

4935 AtMostN[

4936 Union[

4937 EmptyLineMatchType,

4938 OneOf[EmptyLineMatchType],

4939 AllOf[EmptyLineMatchType],

4940 ]

4941 ],

4942 ]

4943 ],

4944 MatchIfTrue[Sequence[cst.EmptyLine]],

4945 ]

4946 ],

4947 AllOf[

4948 Union[

4949 Sequence[

4950 Union[

4951 EmptyLineMatchType,

4952 OneOf[EmptyLineMatchType],

4953 AllOf[EmptyLineMatchType],

4954 AtLeastN[

4955 Union[

4956 EmptyLineMatchType,

4957 OneOf[EmptyLineMatchType],

4958 AllOf[EmptyLineMatchType],

4959 ]

4960 ],

4961 AtMostN[

4962 Union[

4963 EmptyLineMatchType,

4964 OneOf[EmptyLineMatchType],

4965 AllOf[EmptyLineMatchType],

4966 ]

4967 ],

4968 ]

4969 ],

4970 MatchIfTrue[Sequence[cst.EmptyLine]],

4971 ]

4972 ],

4973 ] = DoNotCare()

4974 whitespace_after_for: Union[

4975 SimpleWhitespaceMatchType,

4976 DoNotCareSentinel,

4977 OneOf[SimpleWhitespaceMatchType],

4978 AllOf[SimpleWhitespaceMatchType],

4979 ] = DoNotCare()

4980 whitespace_before_in: Union[

4981 SimpleWhitespaceMatchType,

4982 DoNotCareSentinel,

4983 OneOf[SimpleWhitespaceMatchType],

4984 AllOf[SimpleWhitespaceMatchType],

4985 ] = DoNotCare()

4986 whitespace_after_in: Union[

4987 SimpleWhitespaceMatchType,

4988 DoNotCareSentinel,

4989 OneOf[SimpleWhitespaceMatchType],

4990 AllOf[SimpleWhitespaceMatchType],

4991 ] = DoNotCare()

4992 whitespace_before_colon: Union[

4993 SimpleWhitespaceMatchType,

4994 DoNotCareSentinel,

4995 OneOf[SimpleWhitespaceMatchType],

4996 AllOf[SimpleWhitespaceMatchType],

4997 ] = DoNotCare()

4998 metadata: Union[

4999 MetadataMatchType,

5000 DoNotCareSentinel,

5001 OneOf[MetadataMatchType],

5002 AllOf[MetadataMatchType],

5003 ] = DoNotCare()

5004

5005

5006BaseFormattedStringContentMatchType = Union[

5007 "BaseFormattedStringContent",

5008 MetadataMatchType,

5009 MatchIfTrue[cst.BaseFormattedStringContent],

5010]

5011

5012

5013@dataclass(frozen=True, eq=False, unsafe_hash=False)

5014class FormattedString(BaseExpression, BaseString, BaseMatcherNode):

5015 parts: Union[

5016 Sequence[

5017 Union[

5018 BaseFormattedStringContentMatchType,

5019 DoNotCareSentinel,

5020 OneOf[BaseFormattedStringContentMatchType],

5021 AllOf[BaseFormattedStringContentMatchType],

5022 AtLeastN[

5023 Union[

5024 BaseFormattedStringContentMatchType,

5025 DoNotCareSentinel,

5026 OneOf[BaseFormattedStringContentMatchType],

5027 AllOf[BaseFormattedStringContentMatchType],

5028 ]

5029 ],

5030 AtMostN[

5031 Union[

5032 BaseFormattedStringContentMatchType,

5033 DoNotCareSentinel,

5034 OneOf[BaseFormattedStringContentMatchType],

5035 AllOf[BaseFormattedStringContentMatchType],

5036 ]

5037 ],

5038 ]

5039 ],

5040 DoNotCareSentinel,

5041 MatchIfTrue[Sequence[cst.BaseFormattedStringContent]],

5042 OneOf[

5043 Union[

5044 Sequence[

5045 Union[

5046 BaseFormattedStringContentMatchType,

5047 OneOf[BaseFormattedStringContentMatchType],

5048 AllOf[BaseFormattedStringContentMatchType],

5049 AtLeastN[

5050 Union[

5051 BaseFormattedStringContentMatchType,

5052 OneOf[BaseFormattedStringContentMatchType],

5053 AllOf[BaseFormattedStringContentMatchType],

5054 ]

5055 ],

5056 AtMostN[

5057 Union[

5058 BaseFormattedStringContentMatchType,

5059 OneOf[BaseFormattedStringContentMatchType],

5060 AllOf[BaseFormattedStringContentMatchType],

5061 ]

5062 ],

5063 ]

5064 ],

5065 MatchIfTrue[Sequence[cst.BaseFormattedStringContent]],

5066 ]

5067 ],

5068 AllOf[

5069 Union[

5070 Sequence[

5071 Union[

5072 BaseFormattedStringContentMatchType,

5073 OneOf[BaseFormattedStringContentMatchType],

5074 AllOf[BaseFormattedStringContentMatchType],

5075 AtLeastN[

5076 Union[

5077 BaseFormattedStringContentMatchType,

5078 OneOf[BaseFormattedStringContentMatchType],

5079 AllOf[BaseFormattedStringContentMatchType],

5080 ]

5081 ],

5082 AtMostN[

5083 Union[

5084 BaseFormattedStringContentMatchType,

5085 OneOf[BaseFormattedStringContentMatchType],

5086 AllOf[BaseFormattedStringContentMatchType],

5087 ]

5088 ],

5089 ]

5090 ],

5091 MatchIfTrue[Sequence[cst.BaseFormattedStringContent]],

5092 ]

5093 ],

5094 ] = DoNotCare()

5095 start: Union[

5096 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

5097 ] = DoNotCare()

5098 end: Union[

5099 Literal['"', "'", '"""', "'''"],

5100 MetadataMatchType,

5101 MatchIfTrue[Literal['"', "'", '"""', "'''"]],

5102 DoNotCareSentinel,

5103 OneOf[

5104 Union[

5105 Literal['"', "'", '"""', "'''"],

5106 MetadataMatchType,

5107 MatchIfTrue[Literal['"', "'", '"""', "'''"]],

5108 ]

5109 ],

5110 AllOf[

5111 Union[

5112 Literal['"', "'", '"""', "'''"],

5113 MetadataMatchType,

5114 MatchIfTrue[Literal['"', "'", '"""', "'''"]],

5115 ]

5116 ],

5117 ] = DoNotCare()

5118 lpar: Union[

5119 Sequence[

5120 Union[

5121 LeftParenMatchType,

5122 DoNotCareSentinel,

5123 OneOf[LeftParenMatchType],

5124 AllOf[LeftParenMatchType],

5125 AtLeastN[

5126 Union[

5127 LeftParenMatchType,

5128 DoNotCareSentinel,

5129 OneOf[LeftParenMatchType],

5130 AllOf[LeftParenMatchType],

5131 ]

5132 ],

5133 AtMostN[

5134 Union[

5135 LeftParenMatchType,

5136 DoNotCareSentinel,

5137 OneOf[LeftParenMatchType],

5138 AllOf[LeftParenMatchType],

5139 ]

5140 ],

5141 ]

5142 ],

5143 DoNotCareSentinel,

5144 MatchIfTrue[Sequence[cst.LeftParen]],

5145 OneOf[

5146 Union[

5147 Sequence[

5148 Union[

5149 LeftParenMatchType,

5150 OneOf[LeftParenMatchType],

5151 AllOf[LeftParenMatchType],

5152 AtLeastN[

5153 Union[

5154 LeftParenMatchType,

5155 OneOf[LeftParenMatchType],

5156 AllOf[LeftParenMatchType],

5157 ]

5158 ],

5159 AtMostN[

5160 Union[

5161 LeftParenMatchType,

5162 OneOf[LeftParenMatchType],

5163 AllOf[LeftParenMatchType],

5164 ]

5165 ],

5166 ]

5167 ],

5168 MatchIfTrue[Sequence[cst.LeftParen]],

5169 ]

5170 ],

5171 AllOf[

5172 Union[

5173 Sequence[

5174 Union[

5175 LeftParenMatchType,

5176 OneOf[LeftParenMatchType],

5177 AllOf[LeftParenMatchType],

5178 AtLeastN[

5179 Union[

5180 LeftParenMatchType,

5181 OneOf[LeftParenMatchType],

5182 AllOf[LeftParenMatchType],

5183 ]

5184 ],

5185 AtMostN[

5186 Union[

5187 LeftParenMatchType,

5188 OneOf[LeftParenMatchType],

5189 AllOf[LeftParenMatchType],

5190 ]

5191 ],

5192 ]

5193 ],

5194 MatchIfTrue[Sequence[cst.LeftParen]],

5195 ]

5196 ],

5197 ] = DoNotCare()

5198 rpar: Union[

5199 Sequence[

5200 Union[

5201 RightParenMatchType,

5202 DoNotCareSentinel,

5203 OneOf[RightParenMatchType],

5204 AllOf[RightParenMatchType],

5205 AtLeastN[

5206 Union[

5207 RightParenMatchType,

5208 DoNotCareSentinel,

5209 OneOf[RightParenMatchType],

5210 AllOf[RightParenMatchType],

5211 ]

5212 ],

5213 AtMostN[

5214 Union[

5215 RightParenMatchType,

5216 DoNotCareSentinel,

5217 OneOf[RightParenMatchType],

5218 AllOf[RightParenMatchType],

5219 ]

5220 ],

5221 ]

5222 ],

5223 DoNotCareSentinel,

5224 MatchIfTrue[Sequence[cst.RightParen]],

5225 OneOf[

5226 Union[

5227 Sequence[

5228 Union[

5229 RightParenMatchType,

5230 OneOf[RightParenMatchType],

5231 AllOf[RightParenMatchType],

5232 AtLeastN[

5233 Union[

5234 RightParenMatchType,

5235 OneOf[RightParenMatchType],

5236 AllOf[RightParenMatchType],

5237 ]

5238 ],

5239 AtMostN[

5240 Union[

5241 RightParenMatchType,

5242 OneOf[RightParenMatchType],

5243 AllOf[RightParenMatchType],

5244 ]

5245 ],

5246 ]

5247 ],

5248 MatchIfTrue[Sequence[cst.RightParen]],

5249 ]

5250 ],

5251 AllOf[

5252 Union[

5253 Sequence[

5254 Union[

5255 RightParenMatchType,

5256 OneOf[RightParenMatchType],

5257 AllOf[RightParenMatchType],

5258 AtLeastN[

5259 Union[

5260 RightParenMatchType,

5261 OneOf[RightParenMatchType],

5262 AllOf[RightParenMatchType],

5263 ]

5264 ],

5265 AtMostN[

5266 Union[

5267 RightParenMatchType,

5268 OneOf[RightParenMatchType],

5269 AllOf[RightParenMatchType],

5270 ]

5271 ],

5272 ]

5273 ],

5274 MatchIfTrue[Sequence[cst.RightParen]],

5275 ]

5276 ],

5277 ] = DoNotCare()

5278 metadata: Union[

5279 MetadataMatchType,

5280 DoNotCareSentinel,

5281 OneOf[MetadataMatchType],

5282 AllOf[MetadataMatchType],

5283 ] = DoNotCare()

5284

5285

5286@dataclass(frozen=True, eq=False, unsafe_hash=False)

5287class FormattedStringExpression(BaseFormattedStringContent, BaseMatcherNode):

5288 expression: Union[

5289 BaseExpressionMatchType,

5290 DoNotCareSentinel,

5291 OneOf[BaseExpressionMatchType],

5292 AllOf[BaseExpressionMatchType],

5293 ] = DoNotCare()

5294 conversion: Union[

5295 Optional[str],

5296 MetadataMatchType,

5297 MatchIfTrue[Optional[str]],

5298 DoNotCareSentinel,

5299 OneOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

5300 AllOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

5301 ] = DoNotCare()

5302 format_spec: Union[

5303 Optional[Sequence["BaseFormattedStringContent"]],

5304 MetadataMatchType,

5305 MatchIfTrue[Optional[Sequence[cst.BaseFormattedStringContent]]],

5306 DoNotCareSentinel,

5307 OneOf[

5308 Union[

5309 Optional[Sequence["BaseFormattedStringContent"]],

5310 MetadataMatchType,

5311 MatchIfTrue[Optional[Sequence[cst.BaseFormattedStringContent]]],

5312 ]

5313 ],

5314 AllOf[

5315 Union[

5316 Optional[Sequence["BaseFormattedStringContent"]],

5317 MetadataMatchType,

5318 MatchIfTrue[Optional[Sequence[cst.BaseFormattedStringContent]]],

5319 ]

5320 ],

5321 ] = DoNotCare()

5322 whitespace_before_expression: Union[

5323 BaseParenthesizableWhitespaceMatchType,

5324 DoNotCareSentinel,

5325 OneOf[BaseParenthesizableWhitespaceMatchType],

5326 AllOf[BaseParenthesizableWhitespaceMatchType],

5327 ] = DoNotCare()

5328 whitespace_after_expression: Union[

5329 BaseParenthesizableWhitespaceMatchType,

5330 DoNotCareSentinel,

5331 OneOf[BaseParenthesizableWhitespaceMatchType],

5332 AllOf[BaseParenthesizableWhitespaceMatchType],

5333 ] = DoNotCare()

5334 equal: Union[

5335 Optional["AssignEqual"],

5336 MetadataMatchType,

5337 MatchIfTrue[Optional[cst.AssignEqual]],

5338 DoNotCareSentinel,

5339 OneOf[

5340 Union[

5341 Optional["AssignEqual"],

5342 MetadataMatchType,

5343 MatchIfTrue[Optional[cst.AssignEqual]],

5344 ]

5345 ],

5346 AllOf[

5347 Union[

5348 Optional["AssignEqual"],

5349 MetadataMatchType,

5350 MatchIfTrue[Optional[cst.AssignEqual]],

5351 ]

5352 ],

5353 ] = DoNotCare()

5354 metadata: Union[

5355 MetadataMatchType,

5356 DoNotCareSentinel,

5357 OneOf[MetadataMatchType],

5358 AllOf[MetadataMatchType],

5359 ] = DoNotCare()

5360

5361

5362@dataclass(frozen=True, eq=False, unsafe_hash=False)

5363class FormattedStringText(BaseFormattedStringContent, BaseMatcherNode):

5364 value: Union[

5365 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

5366 ] = DoNotCare()

5367 metadata: Union[

5368 MetadataMatchType,

5369 DoNotCareSentinel,

5370 OneOf[MetadataMatchType],

5371 AllOf[MetadataMatchType],

5372 ] = DoNotCare()

5373

5374

5375@dataclass(frozen=True, eq=False, unsafe_hash=False)

5376class From(BaseMatcherNode):

5377 item: Union[

5378 BaseExpressionMatchType,

5379 DoNotCareSentinel,

5380 OneOf[BaseExpressionMatchType],

5381 AllOf[BaseExpressionMatchType],

5382 ] = DoNotCare()

5383 whitespace_before_from: Union[

5384 BaseParenthesizableWhitespaceMatchType,

5385 DoNotCareSentinel,

5386 OneOf[BaseParenthesizableWhitespaceMatchType],

5387 AllOf[BaseParenthesizableWhitespaceMatchType],

5388 ] = DoNotCare()

5389 whitespace_after_from: Union[

5390 BaseParenthesizableWhitespaceMatchType,

5391 DoNotCareSentinel,

5392 OneOf[BaseParenthesizableWhitespaceMatchType],

5393 AllOf[BaseParenthesizableWhitespaceMatchType],

5394 ] = DoNotCare()

5395 metadata: Union[

5396 MetadataMatchType,

5397 DoNotCareSentinel,

5398 OneOf[MetadataMatchType],

5399 AllOf[MetadataMatchType],

5400 ] = DoNotCare()

5401

5402

5403ParametersMatchType = Union[

5404 "Parameters", MetadataMatchType, MatchIfTrue[cst.Parameters]

5405]

5406

5407

5408@dataclass(frozen=True, eq=False, unsafe_hash=False)

5409class FunctionDef(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

5410 name: Union[

5411 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

5412 ] = DoNotCare()

5413 params: Union[

5414 ParametersMatchType,

5415 DoNotCareSentinel,

5416 OneOf[ParametersMatchType],

5417 AllOf[ParametersMatchType],

5418 ] = DoNotCare()

5419 body: Union[

5420 BaseSuiteMatchType,

5421 DoNotCareSentinel,

5422 OneOf[BaseSuiteMatchType],

5423 AllOf[BaseSuiteMatchType],

5424 ] = DoNotCare()

5425 decorators: Union[

5426 Sequence[

5427 Union[

5428 DecoratorMatchType,

5429 DoNotCareSentinel,

5430 OneOf[DecoratorMatchType],

5431 AllOf[DecoratorMatchType],

5432 AtLeastN[

5433 Union[

5434 DecoratorMatchType,

5435 DoNotCareSentinel,

5436 OneOf[DecoratorMatchType],

5437 AllOf[DecoratorMatchType],

5438 ]

5439 ],

5440 AtMostN[

5441 Union[

5442 DecoratorMatchType,

5443 DoNotCareSentinel,

5444 OneOf[DecoratorMatchType],

5445 AllOf[DecoratorMatchType],

5446 ]

5447 ],

5448 ]

5449 ],

5450 DoNotCareSentinel,

5451 MatchIfTrue[Sequence[cst.Decorator]],

5452 OneOf[

5453 Union[

5454 Sequence[

5455 Union[

5456 DecoratorMatchType,

5457 OneOf[DecoratorMatchType],

5458 AllOf[DecoratorMatchType],

5459 AtLeastN[

5460 Union[

5461 DecoratorMatchType,

5462 OneOf[DecoratorMatchType],

5463 AllOf[DecoratorMatchType],

5464 ]

5465 ],

5466 AtMostN[

5467 Union[

5468 DecoratorMatchType,

5469 OneOf[DecoratorMatchType],

5470 AllOf[DecoratorMatchType],

5471 ]

5472 ],

5473 ]

5474 ],

5475 MatchIfTrue[Sequence[cst.Decorator]],

5476 ]

5477 ],

5478 AllOf[

5479 Union[

5480 Sequence[

5481 Union[

5482 DecoratorMatchType,

5483 OneOf[DecoratorMatchType],

5484 AllOf[DecoratorMatchType],

5485 AtLeastN[

5486 Union[

5487 DecoratorMatchType,

5488 OneOf[DecoratorMatchType],

5489 AllOf[DecoratorMatchType],

5490 ]

5491 ],

5492 AtMostN[

5493 Union[

5494 DecoratorMatchType,

5495 OneOf[DecoratorMatchType],

5496 AllOf[DecoratorMatchType],

5497 ]

5498 ],

5499 ]

5500 ],

5501 MatchIfTrue[Sequence[cst.Decorator]],

5502 ]

5503 ],

5504 ] = DoNotCare()

5505 returns: Union[

5506 Optional["Annotation"],

5507 MetadataMatchType,

5508 MatchIfTrue[Optional[cst.Annotation]],

5509 DoNotCareSentinel,

5510 OneOf[

5511 Union[

5512 Optional["Annotation"],

5513 MetadataMatchType,

5514 MatchIfTrue[Optional[cst.Annotation]],

5515 ]

5516 ],

5517 AllOf[

5518 Union[

5519 Optional["Annotation"],

5520 MetadataMatchType,

5521 MatchIfTrue[Optional[cst.Annotation]],

5522 ]

5523 ],

5524 ] = DoNotCare()

5525 asynchronous: Union[

5526 Optional["Asynchronous"],

5527 MetadataMatchType,

5528 MatchIfTrue[Optional[cst.Asynchronous]],

5529 DoNotCareSentinel,

5530 OneOf[

5531 Union[

5532 Optional["Asynchronous"],

5533 MetadataMatchType,

5534 MatchIfTrue[Optional[cst.Asynchronous]],

5535 ]

5536 ],

5537 AllOf[

5538 Union[

5539 Optional["Asynchronous"],

5540 MetadataMatchType,

5541 MatchIfTrue[Optional[cst.Asynchronous]],

5542 ]

5543 ],

5544 ] = DoNotCare()

5545 leading_lines: Union[

5546 Sequence[

5547 Union[

5548 EmptyLineMatchType,

5549 DoNotCareSentinel,

5550 OneOf[EmptyLineMatchType],

5551 AllOf[EmptyLineMatchType],

5552 AtLeastN[

5553 Union[

5554 EmptyLineMatchType,

5555 DoNotCareSentinel,

5556 OneOf[EmptyLineMatchType],

5557 AllOf[EmptyLineMatchType],

5558 ]

5559 ],

5560 AtMostN[

5561 Union[

5562 EmptyLineMatchType,

5563 DoNotCareSentinel,

5564 OneOf[EmptyLineMatchType],

5565 AllOf[EmptyLineMatchType],

5566 ]

5567 ],

5568 ]

5569 ],

5570 DoNotCareSentinel,

5571 MatchIfTrue[Sequence[cst.EmptyLine]],

5572 OneOf[

5573 Union[

5574 Sequence[

5575 Union[

5576 EmptyLineMatchType,

5577 OneOf[EmptyLineMatchType],

5578 AllOf[EmptyLineMatchType],

5579 AtLeastN[

5580 Union[

5581 EmptyLineMatchType,

5582 OneOf[EmptyLineMatchType],

5583 AllOf[EmptyLineMatchType],

5584 ]

5585 ],

5586 AtMostN[

5587 Union[

5588 EmptyLineMatchType,

5589 OneOf[EmptyLineMatchType],

5590 AllOf[EmptyLineMatchType],

5591 ]

5592 ],

5593 ]

5594 ],

5595 MatchIfTrue[Sequence[cst.EmptyLine]],

5596 ]

5597 ],

5598 AllOf[

5599 Union[

5600 Sequence[

5601 Union[

5602 EmptyLineMatchType,

5603 OneOf[EmptyLineMatchType],

5604 AllOf[EmptyLineMatchType],

5605 AtLeastN[

5606 Union[

5607 EmptyLineMatchType,

5608 OneOf[EmptyLineMatchType],

5609 AllOf[EmptyLineMatchType],

5610 ]

5611 ],

5612 AtMostN[

5613 Union[

5614 EmptyLineMatchType,

5615 OneOf[EmptyLineMatchType],

5616 AllOf[EmptyLineMatchType],

5617 ]

5618 ],

5619 ]

5620 ],

5621 MatchIfTrue[Sequence[cst.EmptyLine]],

5622 ]

5623 ],

5624 ] = DoNotCare()

5625 lines_after_decorators: Union[

5626 Sequence[

5627 Union[

5628 EmptyLineMatchType,

5629 DoNotCareSentinel,

5630 OneOf[EmptyLineMatchType],

5631 AllOf[EmptyLineMatchType],

5632 AtLeastN[

5633 Union[

5634 EmptyLineMatchType,

5635 DoNotCareSentinel,

5636 OneOf[EmptyLineMatchType],

5637 AllOf[EmptyLineMatchType],

5638 ]

5639 ],

5640 AtMostN[

5641 Union[

5642 EmptyLineMatchType,

5643 DoNotCareSentinel,

5644 OneOf[EmptyLineMatchType],

5645 AllOf[EmptyLineMatchType],

5646 ]

5647 ],

5648 ]

5649 ],

5650 DoNotCareSentinel,

5651 MatchIfTrue[Sequence[cst.EmptyLine]],

5652 OneOf[

5653 Union[

5654 Sequence[

5655 Union[

5656 EmptyLineMatchType,

5657 OneOf[EmptyLineMatchType],

5658 AllOf[EmptyLineMatchType],

5659 AtLeastN[

5660 Union[

5661 EmptyLineMatchType,

5662 OneOf[EmptyLineMatchType],

5663 AllOf[EmptyLineMatchType],

5664 ]

5665 ],

5666 AtMostN[

5667 Union[

5668 EmptyLineMatchType,

5669 OneOf[EmptyLineMatchType],

5670 AllOf[EmptyLineMatchType],

5671 ]

5672 ],

5673 ]

5674 ],

5675 MatchIfTrue[Sequence[cst.EmptyLine]],

5676 ]

5677 ],

5678 AllOf[

5679 Union[

5680 Sequence[

5681 Union[

5682 EmptyLineMatchType,

5683 OneOf[EmptyLineMatchType],

5684 AllOf[EmptyLineMatchType],

5685 AtLeastN[

5686 Union[

5687 EmptyLineMatchType,

5688 OneOf[EmptyLineMatchType],

5689 AllOf[EmptyLineMatchType],

5690 ]

5691 ],

5692 AtMostN[

5693 Union[

5694 EmptyLineMatchType,

5695 OneOf[EmptyLineMatchType],

5696 AllOf[EmptyLineMatchType],

5697 ]

5698 ],

5699 ]

5700 ],

5701 MatchIfTrue[Sequence[cst.EmptyLine]],

5702 ]

5703 ],

5704 ] = DoNotCare()

5705 whitespace_after_def: Union[

5706 SimpleWhitespaceMatchType,

5707 DoNotCareSentinel,

5708 OneOf[SimpleWhitespaceMatchType],

5709 AllOf[SimpleWhitespaceMatchType],

5710 ] = DoNotCare()

5711 whitespace_after_name: Union[

5712 SimpleWhitespaceMatchType,

5713 DoNotCareSentinel,

5714 OneOf[SimpleWhitespaceMatchType],

5715 AllOf[SimpleWhitespaceMatchType],

5716 ] = DoNotCare()

5717 whitespace_before_params: Union[

5718 BaseParenthesizableWhitespaceMatchType,

5719 DoNotCareSentinel,

5720 OneOf[BaseParenthesizableWhitespaceMatchType],

5721 AllOf[BaseParenthesizableWhitespaceMatchType],

5722 ] = DoNotCare()

5723 whitespace_before_colon: Union[

5724 SimpleWhitespaceMatchType,

5725 DoNotCareSentinel,

5726 OneOf[SimpleWhitespaceMatchType],

5727 AllOf[SimpleWhitespaceMatchType],

5728 ] = DoNotCare()

5729 type_parameters: Union[

5730 Optional["TypeParameters"],

5731 MetadataMatchType,

5732 MatchIfTrue[Optional[cst.TypeParameters]],

5733 DoNotCareSentinel,

5734 OneOf[

5735 Union[

5736 Optional["TypeParameters"],

5737 MetadataMatchType,

5738 MatchIfTrue[Optional[cst.TypeParameters]],

5739 ]

5740 ],

5741 AllOf[

5742 Union[

5743 Optional["TypeParameters"],

5744 MetadataMatchType,

5745 MatchIfTrue[Optional[cst.TypeParameters]],

5746 ]

5747 ],

5748 ] = DoNotCare()

5749 whitespace_after_type_parameters: Union[

5750 SimpleWhitespaceMatchType,

5751 DoNotCareSentinel,

5752 OneOf[SimpleWhitespaceMatchType],

5753 AllOf[SimpleWhitespaceMatchType],

5754 ] = DoNotCare()

5755 metadata: Union[

5756 MetadataMatchType,

5757 DoNotCareSentinel,

5758 OneOf[MetadataMatchType],

5759 AllOf[MetadataMatchType],

5760 ] = DoNotCare()

5761

5762

5763@dataclass(frozen=True, eq=False, unsafe_hash=False)

5764class GeneratorExp(BaseComp, BaseExpression, BaseSimpleComp, BaseMatcherNode):

5765 elt: Union[

5766 BaseExpressionMatchType,

5767 DoNotCareSentinel,

5768 OneOf[BaseExpressionMatchType],

5769 AllOf[BaseExpressionMatchType],

5770 ] = DoNotCare()

5771 for_in: Union[

5772 CompForMatchType,

5773 DoNotCareSentinel,

5774 OneOf[CompForMatchType],

5775 AllOf[CompForMatchType],

5776 ] = DoNotCare()

5777 lpar: Union[

5778 Sequence[

5779 Union[

5780 LeftParenMatchType,

5781 DoNotCareSentinel,

5782 OneOf[LeftParenMatchType],

5783 AllOf[LeftParenMatchType],

5784 AtLeastN[

5785 Union[

5786 LeftParenMatchType,

5787 DoNotCareSentinel,

5788 OneOf[LeftParenMatchType],

5789 AllOf[LeftParenMatchType],

5790 ]

5791 ],

5792 AtMostN[

5793 Union[

5794 LeftParenMatchType,

5795 DoNotCareSentinel,

5796 OneOf[LeftParenMatchType],

5797 AllOf[LeftParenMatchType],

5798 ]

5799 ],

5800 ]

5801 ],

5802 DoNotCareSentinel,

5803 MatchIfTrue[Sequence[cst.LeftParen]],

5804 OneOf[

5805 Union[

5806 Sequence[

5807 Union[

5808 LeftParenMatchType,

5809 OneOf[LeftParenMatchType],

5810 AllOf[LeftParenMatchType],

5811 AtLeastN[

5812 Union[

5813 LeftParenMatchType,

5814 OneOf[LeftParenMatchType],

5815 AllOf[LeftParenMatchType],

5816 ]

5817 ],

5818 AtMostN[

5819 Union[

5820 LeftParenMatchType,

5821 OneOf[LeftParenMatchType],

5822 AllOf[LeftParenMatchType],

5823 ]

5824 ],

5825 ]

5826 ],

5827 MatchIfTrue[Sequence[cst.LeftParen]],

5828 ]

5829 ],

5830 AllOf[

5831 Union[

5832 Sequence[

5833 Union[

5834 LeftParenMatchType,

5835 OneOf[LeftParenMatchType],

5836 AllOf[LeftParenMatchType],

5837 AtLeastN[

5838 Union[

5839 LeftParenMatchType,

5840 OneOf[LeftParenMatchType],

5841 AllOf[LeftParenMatchType],

5842 ]

5843 ],

5844 AtMostN[

5845 Union[

5846 LeftParenMatchType,

5847 OneOf[LeftParenMatchType],

5848 AllOf[LeftParenMatchType],

5849 ]

5850 ],

5851 ]

5852 ],

5853 MatchIfTrue[Sequence[cst.LeftParen]],

5854 ]

5855 ],

5856 ] = DoNotCare()

5857 rpar: Union[

5858 Sequence[

5859 Union[

5860 RightParenMatchType,

5861 DoNotCareSentinel,

5862 OneOf[RightParenMatchType],

5863 AllOf[RightParenMatchType],

5864 AtLeastN[

5865 Union[

5866 RightParenMatchType,

5867 DoNotCareSentinel,

5868 OneOf[RightParenMatchType],

5869 AllOf[RightParenMatchType],

5870 ]

5871 ],

5872 AtMostN[

5873 Union[

5874 RightParenMatchType,

5875 DoNotCareSentinel,

5876 OneOf[RightParenMatchType],

5877 AllOf[RightParenMatchType],

5878 ]

5879 ],

5880 ]

5881 ],

5882 DoNotCareSentinel,

5883 MatchIfTrue[Sequence[cst.RightParen]],

5884 OneOf[

5885 Union[

5886 Sequence[

5887 Union[

5888 RightParenMatchType,

5889 OneOf[RightParenMatchType],

5890 AllOf[RightParenMatchType],

5891 AtLeastN[

5892 Union[

5893 RightParenMatchType,

5894 OneOf[RightParenMatchType],

5895 AllOf[RightParenMatchType],

5896 ]

5897 ],

5898 AtMostN[

5899 Union[

5900 RightParenMatchType,

5901 OneOf[RightParenMatchType],

5902 AllOf[RightParenMatchType],

5903 ]

5904 ],

5905 ]

5906 ],

5907 MatchIfTrue[Sequence[cst.RightParen]],

5908 ]

5909 ],

5910 AllOf[

5911 Union[

5912 Sequence[

5913 Union[

5914 RightParenMatchType,

5915 OneOf[RightParenMatchType],

5916 AllOf[RightParenMatchType],

5917 AtLeastN[

5918 Union[

5919 RightParenMatchType,

5920 OneOf[RightParenMatchType],

5921 AllOf[RightParenMatchType],

5922 ]

5923 ],

5924 AtMostN[

5925 Union[

5926 RightParenMatchType,

5927 OneOf[RightParenMatchType],

5928 AllOf[RightParenMatchType],

5929 ]

5930 ],

5931 ]

5932 ],

5933 MatchIfTrue[Sequence[cst.RightParen]],

5934 ]

5935 ],

5936 ] = DoNotCare()

5937 metadata: Union[

5938 MetadataMatchType,

5939 DoNotCareSentinel,

5940 OneOf[MetadataMatchType],

5941 AllOf[MetadataMatchType],

5942 ] = DoNotCare()

5943

5944

5945NameItemMatchType = Union["NameItem", MetadataMatchType, MatchIfTrue[cst.NameItem]]

5946

5947

5948@dataclass(frozen=True, eq=False, unsafe_hash=False)

5949class Global(BaseSmallStatement, BaseMatcherNode):

5950 names: Union[

5951 Sequence[

5952 Union[

5953 NameItemMatchType,

5954 DoNotCareSentinel,

5955 OneOf[NameItemMatchType],

5956 AllOf[NameItemMatchType],

5957 AtLeastN[

5958 Union[

5959 NameItemMatchType,

5960 DoNotCareSentinel,

5961 OneOf[NameItemMatchType],

5962 AllOf[NameItemMatchType],

5963 ]

5964 ],

5965 AtMostN[

5966 Union[

5967 NameItemMatchType,

5968 DoNotCareSentinel,

5969 OneOf[NameItemMatchType],

5970 AllOf[NameItemMatchType],

5971 ]

5972 ],

5973 ]

5974 ],

5975 DoNotCareSentinel,

5976 MatchIfTrue[Sequence[cst.NameItem]],

5977 OneOf[

5978 Union[

5979 Sequence[

5980 Union[

5981 NameItemMatchType,

5982 OneOf[NameItemMatchType],

5983 AllOf[NameItemMatchType],

5984 AtLeastN[

5985 Union[

5986 NameItemMatchType,

5987 OneOf[NameItemMatchType],

5988 AllOf[NameItemMatchType],

5989 ]

5990 ],

5991 AtMostN[

5992 Union[

5993 NameItemMatchType,

5994 OneOf[NameItemMatchType],

5995 AllOf[NameItemMatchType],

5996 ]

5997 ],

5998 ]

5999 ],

6000 MatchIfTrue[Sequence[cst.NameItem]],

6001 ]

6002 ],

6003 AllOf[

6004 Union[

6005 Sequence[

6006 Union[

6007 NameItemMatchType,

6008 OneOf[NameItemMatchType],

6009 AllOf[NameItemMatchType],

6010 AtLeastN[

6011 Union[

6012 NameItemMatchType,

6013 OneOf[NameItemMatchType],

6014 AllOf[NameItemMatchType],

6015 ]

6016 ],

6017 AtMostN[

6018 Union[

6019 NameItemMatchType,

6020 OneOf[NameItemMatchType],

6021 AllOf[NameItemMatchType],

6022 ]

6023 ],

6024 ]

6025 ],

6026 MatchIfTrue[Sequence[cst.NameItem]],

6027 ]

6028 ],

6029 ] = DoNotCare()

6030 whitespace_after_global: Union[

6031 SimpleWhitespaceMatchType,

6032 DoNotCareSentinel,

6033 OneOf[SimpleWhitespaceMatchType],

6034 AllOf[SimpleWhitespaceMatchType],

6035 ] = DoNotCare()

6036 semicolon: Union[

6037 SemicolonMatchType,

6038 DoNotCareSentinel,

6039 OneOf[SemicolonMatchType],

6040 AllOf[SemicolonMatchType],

6041 ] = DoNotCare()

6042 metadata: Union[

6043 MetadataMatchType,

6044 DoNotCareSentinel,

6045 OneOf[MetadataMatchType],

6046 AllOf[MetadataMatchType],

6047 ] = DoNotCare()

6048

6049

6050@dataclass(frozen=True, eq=False, unsafe_hash=False)

6051class GreaterThan(BaseCompOp, BaseMatcherNode):

6052 whitespace_before: Union[

6053 BaseParenthesizableWhitespaceMatchType,

6054 DoNotCareSentinel,

6055 OneOf[BaseParenthesizableWhitespaceMatchType],

6056 AllOf[BaseParenthesizableWhitespaceMatchType],

6057 ] = DoNotCare()

6058 whitespace_after: Union[

6059 BaseParenthesizableWhitespaceMatchType,

6060 DoNotCareSentinel,

6061 OneOf[BaseParenthesizableWhitespaceMatchType],

6062 AllOf[BaseParenthesizableWhitespaceMatchType],

6063 ] = DoNotCare()

6064 metadata: Union[

6065 MetadataMatchType,

6066 DoNotCareSentinel,

6067 OneOf[MetadataMatchType],

6068 AllOf[MetadataMatchType],

6069 ] = DoNotCare()

6070

6071

6072@dataclass(frozen=True, eq=False, unsafe_hash=False)

6073class GreaterThanEqual(BaseCompOp, BaseMatcherNode):

6074 whitespace_before: Union[

6075 BaseParenthesizableWhitespaceMatchType,

6076 DoNotCareSentinel,

6077 OneOf[BaseParenthesizableWhitespaceMatchType],

6078 AllOf[BaseParenthesizableWhitespaceMatchType],

6079 ] = DoNotCare()

6080 whitespace_after: Union[

6081 BaseParenthesizableWhitespaceMatchType,

6082 DoNotCareSentinel,

6083 OneOf[BaseParenthesizableWhitespaceMatchType],

6084 AllOf[BaseParenthesizableWhitespaceMatchType],

6085 ] = DoNotCare()

6086 metadata: Union[

6087 MetadataMatchType,

6088 DoNotCareSentinel,

6089 OneOf[MetadataMatchType],

6090 AllOf[MetadataMatchType],

6091 ] = DoNotCare()

6092

6093

6094IfOrElseOrNoneMatchType = Union[

6095 "If", "Else", None, MetadataMatchType, MatchIfTrue[Union[cst.If, cst.Else, None]]

6096]

6097

6098

6099@dataclass(frozen=True, eq=False, unsafe_hash=False)

6100class If(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

6101 test: Union[

6102 BaseExpressionMatchType,

6103 DoNotCareSentinel,

6104 OneOf[BaseExpressionMatchType],

6105 AllOf[BaseExpressionMatchType],

6106 ] = DoNotCare()

6107 body: Union[

6108 BaseSuiteMatchType,

6109 DoNotCareSentinel,

6110 OneOf[BaseSuiteMatchType],

6111 AllOf[BaseSuiteMatchType],

6112 ] = DoNotCare()

6113 orelse: Union[

6114 IfOrElseOrNoneMatchType,

6115 DoNotCareSentinel,

6116 OneOf[IfOrElseOrNoneMatchType],

6117 AllOf[IfOrElseOrNoneMatchType],

6118 ] = DoNotCare()

6119 leading_lines: Union[

6120 Sequence[

6121 Union[

6122 EmptyLineMatchType,

6123 DoNotCareSentinel,

6124 OneOf[EmptyLineMatchType],

6125 AllOf[EmptyLineMatchType],

6126 AtLeastN[

6127 Union[

6128 EmptyLineMatchType,

6129 DoNotCareSentinel,

6130 OneOf[EmptyLineMatchType],

6131 AllOf[EmptyLineMatchType],

6132 ]

6133 ],

6134 AtMostN[

6135 Union[

6136 EmptyLineMatchType,

6137 DoNotCareSentinel,

6138 OneOf[EmptyLineMatchType],

6139 AllOf[EmptyLineMatchType],

6140 ]

6141 ],

6142 ]

6143 ],

6144 DoNotCareSentinel,

6145 MatchIfTrue[Sequence[cst.EmptyLine]],

6146 OneOf[

6147 Union[

6148 Sequence[

6149 Union[

6150 EmptyLineMatchType,

6151 OneOf[EmptyLineMatchType],

6152 AllOf[EmptyLineMatchType],

6153 AtLeastN[

6154 Union[

6155 EmptyLineMatchType,

6156 OneOf[EmptyLineMatchType],

6157 AllOf[EmptyLineMatchType],

6158 ]

6159 ],

6160 AtMostN[

6161 Union[

6162 EmptyLineMatchType,

6163 OneOf[EmptyLineMatchType],

6164 AllOf[EmptyLineMatchType],

6165 ]

6166 ],

6167 ]

6168 ],

6169 MatchIfTrue[Sequence[cst.EmptyLine]],

6170 ]

6171 ],

6172 AllOf[

6173 Union[

6174 Sequence[

6175 Union[

6176 EmptyLineMatchType,

6177 OneOf[EmptyLineMatchType],

6178 AllOf[EmptyLineMatchType],

6179 AtLeastN[

6180 Union[

6181 EmptyLineMatchType,

6182 OneOf[EmptyLineMatchType],

6183 AllOf[EmptyLineMatchType],

6184 ]

6185 ],

6186 AtMostN[

6187 Union[

6188 EmptyLineMatchType,

6189 OneOf[EmptyLineMatchType],

6190 AllOf[EmptyLineMatchType],

6191 ]

6192 ],

6193 ]

6194 ],

6195 MatchIfTrue[Sequence[cst.EmptyLine]],

6196 ]

6197 ],

6198 ] = DoNotCare()

6199 whitespace_before_test: Union[

6200 SimpleWhitespaceMatchType,

6201 DoNotCareSentinel,

6202 OneOf[SimpleWhitespaceMatchType],

6203 AllOf[SimpleWhitespaceMatchType],

6204 ] = DoNotCare()

6205 whitespace_after_test: Union[

6206 SimpleWhitespaceMatchType,

6207 DoNotCareSentinel,

6208 OneOf[SimpleWhitespaceMatchType],

6209 AllOf[SimpleWhitespaceMatchType],

6210 ] = DoNotCare()

6211 metadata: Union[

6212 MetadataMatchType,

6213 DoNotCareSentinel,

6214 OneOf[MetadataMatchType],

6215 AllOf[MetadataMatchType],

6216 ] = DoNotCare()

6217

6218

6219@dataclass(frozen=True, eq=False, unsafe_hash=False)

6220class IfExp(BaseExpression, BaseMatcherNode):

6221 test: Union[

6222 BaseExpressionMatchType,

6223 DoNotCareSentinel,

6224 OneOf[BaseExpressionMatchType],

6225 AllOf[BaseExpressionMatchType],

6226 ] = DoNotCare()

6227 body: Union[

6228 BaseExpressionMatchType,

6229 DoNotCareSentinel,

6230 OneOf[BaseExpressionMatchType],

6231 AllOf[BaseExpressionMatchType],

6232 ] = DoNotCare()

6233 orelse: Union[

6234 BaseExpressionMatchType,

6235 DoNotCareSentinel,

6236 OneOf[BaseExpressionMatchType],

6237 AllOf[BaseExpressionMatchType],

6238 ] = DoNotCare()

6239 lpar: Union[

6240 Sequence[

6241 Union[

6242 LeftParenMatchType,

6243 DoNotCareSentinel,

6244 OneOf[LeftParenMatchType],

6245 AllOf[LeftParenMatchType],

6246 AtLeastN[

6247 Union[

6248 LeftParenMatchType,

6249 DoNotCareSentinel,

6250 OneOf[LeftParenMatchType],

6251 AllOf[LeftParenMatchType],

6252 ]

6253 ],

6254 AtMostN[

6255 Union[

6256 LeftParenMatchType,

6257 DoNotCareSentinel,

6258 OneOf[LeftParenMatchType],

6259 AllOf[LeftParenMatchType],

6260 ]

6261 ],

6262 ]

6263 ],

6264 DoNotCareSentinel,

6265 MatchIfTrue[Sequence[cst.LeftParen]],

6266 OneOf[

6267 Union[

6268 Sequence[

6269 Union[

6270 LeftParenMatchType,

6271 OneOf[LeftParenMatchType],

6272 AllOf[LeftParenMatchType],

6273 AtLeastN[

6274 Union[

6275 LeftParenMatchType,

6276 OneOf[LeftParenMatchType],

6277 AllOf[LeftParenMatchType],

6278 ]

6279 ],

6280 AtMostN[

6281 Union[

6282 LeftParenMatchType,

6283 OneOf[LeftParenMatchType],

6284 AllOf[LeftParenMatchType],

6285 ]

6286 ],

6287 ]

6288 ],

6289 MatchIfTrue[Sequence[cst.LeftParen]],

6290 ]

6291 ],

6292 AllOf[

6293 Union[

6294 Sequence[

6295 Union[

6296 LeftParenMatchType,

6297 OneOf[LeftParenMatchType],

6298 AllOf[LeftParenMatchType],

6299 AtLeastN[

6300 Union[

6301 LeftParenMatchType,

6302 OneOf[LeftParenMatchType],

6303 AllOf[LeftParenMatchType],

6304 ]

6305 ],

6306 AtMostN[

6307 Union[

6308 LeftParenMatchType,

6309 OneOf[LeftParenMatchType],

6310 AllOf[LeftParenMatchType],

6311 ]

6312 ],

6313 ]

6314 ],

6315 MatchIfTrue[Sequence[cst.LeftParen]],

6316 ]

6317 ],

6318 ] = DoNotCare()

6319 rpar: Union[

6320 Sequence[

6321 Union[

6322 RightParenMatchType,

6323 DoNotCareSentinel,

6324 OneOf[RightParenMatchType],

6325 AllOf[RightParenMatchType],

6326 AtLeastN[

6327 Union[

6328 RightParenMatchType,

6329 DoNotCareSentinel,

6330 OneOf[RightParenMatchType],

6331 AllOf[RightParenMatchType],

6332 ]

6333 ],

6334 AtMostN[

6335 Union[

6336 RightParenMatchType,

6337 DoNotCareSentinel,

6338 OneOf[RightParenMatchType],

6339 AllOf[RightParenMatchType],

6340 ]

6341 ],

6342 ]

6343 ],

6344 DoNotCareSentinel,

6345 MatchIfTrue[Sequence[cst.RightParen]],

6346 OneOf[

6347 Union[

6348 Sequence[

6349 Union[

6350 RightParenMatchType,

6351 OneOf[RightParenMatchType],

6352 AllOf[RightParenMatchType],

6353 AtLeastN[

6354 Union[

6355 RightParenMatchType,

6356 OneOf[RightParenMatchType],

6357 AllOf[RightParenMatchType],

6358 ]

6359 ],

6360 AtMostN[

6361 Union[

6362 RightParenMatchType,

6363 OneOf[RightParenMatchType],

6364 AllOf[RightParenMatchType],

6365 ]

6366 ],

6367 ]

6368 ],

6369 MatchIfTrue[Sequence[cst.RightParen]],

6370 ]

6371 ],

6372 AllOf[

6373 Union[

6374 Sequence[

6375 Union[

6376 RightParenMatchType,

6377 OneOf[RightParenMatchType],

6378 AllOf[RightParenMatchType],

6379 AtLeastN[

6380 Union[

6381 RightParenMatchType,

6382 OneOf[RightParenMatchType],

6383 AllOf[RightParenMatchType],

6384 ]

6385 ],

6386 AtMostN[

6387 Union[

6388 RightParenMatchType,

6389 OneOf[RightParenMatchType],

6390 AllOf[RightParenMatchType],

6391 ]

6392 ],

6393 ]

6394 ],

6395 MatchIfTrue[Sequence[cst.RightParen]],

6396 ]

6397 ],

6398 ] = DoNotCare()

6399 whitespace_before_if: Union[

6400 BaseParenthesizableWhitespaceMatchType,

6401 DoNotCareSentinel,

6402 OneOf[BaseParenthesizableWhitespaceMatchType],

6403 AllOf[BaseParenthesizableWhitespaceMatchType],

6404 ] = DoNotCare()

6405 whitespace_after_if: Union[

6406 BaseParenthesizableWhitespaceMatchType,

6407 DoNotCareSentinel,

6408 OneOf[BaseParenthesizableWhitespaceMatchType],

6409 AllOf[BaseParenthesizableWhitespaceMatchType],

6410 ] = DoNotCare()

6411 whitespace_before_else: Union[

6412 BaseParenthesizableWhitespaceMatchType,

6413 DoNotCareSentinel,

6414 OneOf[BaseParenthesizableWhitespaceMatchType],

6415 AllOf[BaseParenthesizableWhitespaceMatchType],

6416 ] = DoNotCare()

6417 whitespace_after_else: Union[

6418 BaseParenthesizableWhitespaceMatchType,

6419 DoNotCareSentinel,

6420 OneOf[BaseParenthesizableWhitespaceMatchType],

6421 AllOf[BaseParenthesizableWhitespaceMatchType],

6422 ] = DoNotCare()

6423 metadata: Union[

6424 MetadataMatchType,

6425 DoNotCareSentinel,

6426 OneOf[MetadataMatchType],

6427 AllOf[MetadataMatchType],

6428 ] = DoNotCare()

6429

6430

6431@dataclass(frozen=True, eq=False, unsafe_hash=False)

6432class Imaginary(BaseExpression, BaseNumber, BaseMatcherNode):

6433 value: Union[

6434 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

6435 ] = DoNotCare()

6436 lpar: Union[

6437 Sequence[

6438 Union[

6439 LeftParenMatchType,

6440 DoNotCareSentinel,

6441 OneOf[LeftParenMatchType],

6442 AllOf[LeftParenMatchType],

6443 AtLeastN[

6444 Union[

6445 LeftParenMatchType,

6446 DoNotCareSentinel,

6447 OneOf[LeftParenMatchType],

6448 AllOf[LeftParenMatchType],

6449 ]

6450 ],

6451 AtMostN[

6452 Union[

6453 LeftParenMatchType,

6454 DoNotCareSentinel,

6455 OneOf[LeftParenMatchType],

6456 AllOf[LeftParenMatchType],

6457 ]

6458 ],

6459 ]

6460 ],

6461 DoNotCareSentinel,

6462 MatchIfTrue[Sequence[cst.LeftParen]],

6463 OneOf[

6464 Union[

6465 Sequence[

6466 Union[

6467 LeftParenMatchType,

6468 OneOf[LeftParenMatchType],

6469 AllOf[LeftParenMatchType],

6470 AtLeastN[

6471 Union[

6472 LeftParenMatchType,

6473 OneOf[LeftParenMatchType],

6474 AllOf[LeftParenMatchType],

6475 ]

6476 ],

6477 AtMostN[

6478 Union[

6479 LeftParenMatchType,

6480 OneOf[LeftParenMatchType],

6481 AllOf[LeftParenMatchType],

6482 ]

6483 ],

6484 ]

6485 ],

6486 MatchIfTrue[Sequence[cst.LeftParen]],

6487 ]

6488 ],

6489 AllOf[

6490 Union[

6491 Sequence[

6492 Union[

6493 LeftParenMatchType,

6494 OneOf[LeftParenMatchType],

6495 AllOf[LeftParenMatchType],

6496 AtLeastN[

6497 Union[

6498 LeftParenMatchType,

6499 OneOf[LeftParenMatchType],

6500 AllOf[LeftParenMatchType],

6501 ]

6502 ],

6503 AtMostN[

6504 Union[

6505 LeftParenMatchType,

6506 OneOf[LeftParenMatchType],

6507 AllOf[LeftParenMatchType],

6508 ]

6509 ],

6510 ]

6511 ],

6512 MatchIfTrue[Sequence[cst.LeftParen]],

6513 ]

6514 ],

6515 ] = DoNotCare()

6516 rpar: Union[

6517 Sequence[

6518 Union[

6519 RightParenMatchType,

6520 DoNotCareSentinel,

6521 OneOf[RightParenMatchType],

6522 AllOf[RightParenMatchType],

6523 AtLeastN[

6524 Union[

6525 RightParenMatchType,

6526 DoNotCareSentinel,

6527 OneOf[RightParenMatchType],

6528 AllOf[RightParenMatchType],

6529 ]

6530 ],

6531 AtMostN[

6532 Union[

6533 RightParenMatchType,

6534 DoNotCareSentinel,

6535 OneOf[RightParenMatchType],

6536 AllOf[RightParenMatchType],

6537 ]

6538 ],

6539 ]

6540 ],

6541 DoNotCareSentinel,

6542 MatchIfTrue[Sequence[cst.RightParen]],

6543 OneOf[

6544 Union[

6545 Sequence[

6546 Union[

6547 RightParenMatchType,

6548 OneOf[RightParenMatchType],

6549 AllOf[RightParenMatchType],

6550 AtLeastN[

6551 Union[

6552 RightParenMatchType,

6553 OneOf[RightParenMatchType],

6554 AllOf[RightParenMatchType],

6555 ]

6556 ],

6557 AtMostN[

6558 Union[

6559 RightParenMatchType,

6560 OneOf[RightParenMatchType],

6561 AllOf[RightParenMatchType],

6562 ]

6563 ],

6564 ]

6565 ],

6566 MatchIfTrue[Sequence[cst.RightParen]],

6567 ]

6568 ],

6569 AllOf[

6570 Union[

6571 Sequence[

6572 Union[

6573 RightParenMatchType,

6574 OneOf[RightParenMatchType],

6575 AllOf[RightParenMatchType],

6576 AtLeastN[

6577 Union[

6578 RightParenMatchType,

6579 OneOf[RightParenMatchType],

6580 AllOf[RightParenMatchType],

6581 ]

6582 ],

6583 AtMostN[

6584 Union[

6585 RightParenMatchType,

6586 OneOf[RightParenMatchType],

6587 AllOf[RightParenMatchType],

6588 ]

6589 ],

6590 ]

6591 ],

6592 MatchIfTrue[Sequence[cst.RightParen]],

6593 ]

6594 ],

6595 ] = DoNotCare()

6596 metadata: Union[

6597 MetadataMatchType,

6598 DoNotCareSentinel,

6599 OneOf[MetadataMatchType],

6600 AllOf[MetadataMatchType],

6601 ] = DoNotCare()

6602

6603

6604ImportAliasMatchType = Union[

6605 "ImportAlias", MetadataMatchType, MatchIfTrue[cst.ImportAlias]

6606]

6607

6608

6609@dataclass(frozen=True, eq=False, unsafe_hash=False)

6610class Import(BaseSmallStatement, BaseMatcherNode):

6611 names: Union[

6612 Sequence[

6613 Union[

6614 ImportAliasMatchType,

6615 DoNotCareSentinel,

6616 OneOf[ImportAliasMatchType],

6617 AllOf[ImportAliasMatchType],

6618 AtLeastN[

6619 Union[

6620 ImportAliasMatchType,

6621 DoNotCareSentinel,

6622 OneOf[ImportAliasMatchType],

6623 AllOf[ImportAliasMatchType],

6624 ]

6625 ],

6626 AtMostN[

6627 Union[

6628 ImportAliasMatchType,

6629 DoNotCareSentinel,

6630 OneOf[ImportAliasMatchType],

6631 AllOf[ImportAliasMatchType],

6632 ]

6633 ],

6634 ]

6635 ],

6636 DoNotCareSentinel,

6637 MatchIfTrue[Sequence[cst.ImportAlias]],

6638 OneOf[

6639 Union[

6640 Sequence[

6641 Union[

6642 ImportAliasMatchType,

6643 OneOf[ImportAliasMatchType],

6644 AllOf[ImportAliasMatchType],

6645 AtLeastN[

6646 Union[

6647 ImportAliasMatchType,

6648 OneOf[ImportAliasMatchType],

6649 AllOf[ImportAliasMatchType],

6650 ]

6651 ],

6652 AtMostN[

6653 Union[

6654 ImportAliasMatchType,

6655 OneOf[ImportAliasMatchType],

6656 AllOf[ImportAliasMatchType],

6657 ]

6658 ],

6659 ]

6660 ],

6661 MatchIfTrue[Sequence[cst.ImportAlias]],

6662 ]

6663 ],

6664 AllOf[

6665 Union[

6666 Sequence[

6667 Union[

6668 ImportAliasMatchType,

6669 OneOf[ImportAliasMatchType],

6670 AllOf[ImportAliasMatchType],

6671 AtLeastN[

6672 Union[

6673 ImportAliasMatchType,

6674 OneOf[ImportAliasMatchType],

6675 AllOf[ImportAliasMatchType],

6676 ]

6677 ],

6678 AtMostN[

6679 Union[

6680 ImportAliasMatchType,

6681 OneOf[ImportAliasMatchType],

6682 AllOf[ImportAliasMatchType],

6683 ]

6684 ],

6685 ]

6686 ],

6687 MatchIfTrue[Sequence[cst.ImportAlias]],

6688 ]

6689 ],

6690 ] = DoNotCare()

6691 semicolon: Union[

6692 SemicolonMatchType,

6693 DoNotCareSentinel,

6694 OneOf[SemicolonMatchType],

6695 AllOf[SemicolonMatchType],

6696 ] = DoNotCare()

6697 whitespace_after_import: Union[

6698 SimpleWhitespaceMatchType,

6699 DoNotCareSentinel,

6700 OneOf[SimpleWhitespaceMatchType],

6701 AllOf[SimpleWhitespaceMatchType],

6702 ] = DoNotCare()

6703 metadata: Union[

6704 MetadataMatchType,

6705 DoNotCareSentinel,

6706 OneOf[MetadataMatchType],

6707 AllOf[MetadataMatchType],

6708 ] = DoNotCare()

6709

6710

6711AttributeOrNameMatchType = Union[

6712 "Attribute", "Name", MetadataMatchType, MatchIfTrue[Union[cst.Attribute, cst.Name]]

6713]

6714

6715

6716@dataclass(frozen=True, eq=False, unsafe_hash=False)

6717class ImportAlias(BaseMatcherNode):

6718 name: Union[

6719 AttributeOrNameMatchType,

6720 DoNotCareSentinel,

6721 OneOf[AttributeOrNameMatchType],

6722 AllOf[AttributeOrNameMatchType],

6723 ] = DoNotCare()

6724 asname: Union[

6725 Optional["AsName"],

6726 MetadataMatchType,

6727 MatchIfTrue[Optional[cst.AsName]],

6728 DoNotCareSentinel,

6729 OneOf[

6730 Union[

6731 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

6732 ]

6733 ],

6734 AllOf[

6735 Union[

6736 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

6737 ]

6738 ],

6739 ] = DoNotCare()

6740 comma: Union[

6741 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

6742 ] = DoNotCare()

6743 metadata: Union[

6744 MetadataMatchType,

6745 DoNotCareSentinel,

6746 OneOf[MetadataMatchType],

6747 AllOf[MetadataMatchType],

6748 ] = DoNotCare()

6749

6750

6751AttributeOrNameOrNoneMatchType = Union[

6752 "Attribute",

6753 "Name",

6754 None,

6755 MetadataMatchType,

6756 MatchIfTrue[Union[cst.Attribute, cst.Name, None]],

6757]

6758

6759

6760@dataclass(frozen=True, eq=False, unsafe_hash=False)

6761class ImportFrom(BaseSmallStatement, BaseMatcherNode):

6762 module: Union[

6763 AttributeOrNameOrNoneMatchType,

6764 DoNotCareSentinel,

6765 OneOf[AttributeOrNameOrNoneMatchType],

6766 AllOf[AttributeOrNameOrNoneMatchType],

6767 ] = DoNotCare()

6768 names: Union[

6769 Union[

6770 Sequence[

6771 Union[

6772 ImportAliasMatchType,

6773 DoNotCareSentinel,

6774 OneOf[ImportAliasMatchType],

6775 AllOf[ImportAliasMatchType],

6776 AtLeastN[

6777 Union[

6778 ImportAliasMatchType,

6779 DoNotCareSentinel,

6780 OneOf[ImportAliasMatchType],

6781 AllOf[ImportAliasMatchType],

6782 ]

6783 ],

6784 AtMostN[

6785 Union[

6786 ImportAliasMatchType,

6787 DoNotCareSentinel,

6788 OneOf[ImportAliasMatchType],

6789 AllOf[ImportAliasMatchType],

6790 ]

6791 ],

6792 ]

6793 ],

6794 DoNotCareSentinel,

6795 MatchIfTrue[Sequence[cst.ImportAlias]],

6796 OneOf[

6797 Union[

6798 Sequence[

6799 Union[

6800 ImportAliasMatchType,

6801 OneOf[ImportAliasMatchType],

6802 AllOf[ImportAliasMatchType],

6803 AtLeastN[

6804 Union[

6805 ImportAliasMatchType,

6806 OneOf[ImportAliasMatchType],

6807 AllOf[ImportAliasMatchType],

6808 ]

6809 ],

6810 AtMostN[

6811 Union[

6812 ImportAliasMatchType,

6813 OneOf[ImportAliasMatchType],

6814 AllOf[ImportAliasMatchType],

6815 ]

6816 ],

6817 ]

6818 ],

6819 MatchIfTrue[Sequence[cst.ImportAlias]],

6820 ]

6821 ],

6822 AllOf[

6823 Union[

6824 Sequence[

6825 Union[

6826 ImportAliasMatchType,

6827 OneOf[ImportAliasMatchType],

6828 AllOf[ImportAliasMatchType],

6829 AtLeastN[

6830 Union[

6831 ImportAliasMatchType,

6832 OneOf[ImportAliasMatchType],

6833 AllOf[ImportAliasMatchType],

6834 ]

6835 ],

6836 AtMostN[

6837 Union[

6838 ImportAliasMatchType,

6839 OneOf[ImportAliasMatchType],

6840 AllOf[ImportAliasMatchType],

6841 ]

6842 ],

6843 ]

6844 ],

6845 MatchIfTrue[Sequence[cst.ImportAlias]],

6846 ]

6847 ],

6848 ],

6849 "ImportStar",

6850 MetadataMatchType,

6851 MatchIfTrue[

6852 Union[

6853 Sequence[cst.ImportAlias],

6854 cst.ImportStar,

6855 OneOf[Union[Sequence[cst.ImportAlias], cst.ImportStar]],

6856 AllOf[Union[Sequence[cst.ImportAlias], cst.ImportStar]],

6857 ]

6858 ],

6859 DoNotCareSentinel,

6860 OneOf[

6861 Union[

6862 Union[

6863 Sequence[

6864 Union[

6865 ImportAliasMatchType,

6866 OneOf[ImportAliasMatchType],

6867 AllOf[ImportAliasMatchType],

6868 AtLeastN[

6869 Union[

6870 ImportAliasMatchType,

6871 OneOf[ImportAliasMatchType],

6872 AllOf[ImportAliasMatchType],

6873 ]

6874 ],

6875 AtMostN[

6876 Union[

6877 ImportAliasMatchType,

6878 OneOf[ImportAliasMatchType],

6879 AllOf[ImportAliasMatchType],

6880 ]

6881 ],

6882 ]

6883 ],

6884 MatchIfTrue[Sequence[cst.ImportAlias]],

6885 OneOf[

6886 Union[

6887 Sequence[

6888 Union[

6889 ImportAliasMatchType,

6890 OneOf[ImportAliasMatchType],

6891 AllOf[ImportAliasMatchType],

6892 AtLeastN[

6893 Union[

6894 ImportAliasMatchType,

6895 OneOf[ImportAliasMatchType],

6896 AllOf[ImportAliasMatchType],

6897 ]

6898 ],

6899 AtMostN[

6900 Union[

6901 ImportAliasMatchType,

6902 OneOf[ImportAliasMatchType],

6903 AllOf[ImportAliasMatchType],

6904 ]

6905 ],

6906 ]

6907 ],

6908 MatchIfTrue[Sequence[cst.ImportAlias]],

6909 ]

6910 ],

6911 AllOf[

6912 Union[

6913 Sequence[

6914 Union[

6915 ImportAliasMatchType,

6916 OneOf[ImportAliasMatchType],

6917 AllOf[ImportAliasMatchType],

6918 AtLeastN[

6919 Union[

6920 ImportAliasMatchType,

6921 OneOf[ImportAliasMatchType],

6922 AllOf[ImportAliasMatchType],

6923 ]

6924 ],

6925 AtMostN[

6926 Union[

6927 ImportAliasMatchType,

6928 OneOf[ImportAliasMatchType],

6929 AllOf[ImportAliasMatchType],

6930 ]

6931 ],

6932 ]

6933 ],

6934 MatchIfTrue[Sequence[cst.ImportAlias]],

6935 ]

6936 ],

6937 ],

6938 "ImportStar",

6939 MetadataMatchType,

6940 MatchIfTrue[

6941 Union[

6942 Sequence[cst.ImportAlias],

6943 cst.ImportStar,

6944 OneOf[Union[Sequence[cst.ImportAlias], cst.ImportStar]],

6945 AllOf[Union[Sequence[cst.ImportAlias], cst.ImportStar]],

6946 ]

6947 ],

6948 ]

6949 ],

6950 AllOf[

6951 Union[

6952 Union[

6953 Sequence[

6954 Union[

6955 ImportAliasMatchType,

6956 OneOf[ImportAliasMatchType],

6957 AllOf[ImportAliasMatchType],

6958 AtLeastN[

6959 Union[

6960 ImportAliasMatchType,

6961 OneOf[ImportAliasMatchType],

6962 AllOf[ImportAliasMatchType],

6963 ]

6964 ],

6965 AtMostN[

6966 Union[

6967 ImportAliasMatchType,

6968 OneOf[ImportAliasMatchType],

6969 AllOf[ImportAliasMatchType],

6970 ]

6971 ],

6972 ]

6973 ],

6974 MatchIfTrue[Sequence[cst.ImportAlias]],

6975 OneOf[

6976 Union[

6977 Sequence[

6978 Union[

6979 ImportAliasMatchType,

6980 OneOf[ImportAliasMatchType],

6981 AllOf[ImportAliasMatchType],

6982 AtLeastN[

6983 Union[

6984 ImportAliasMatchType,

6985 OneOf[ImportAliasMatchType],

6986 AllOf[ImportAliasMatchType],

6987 ]

6988 ],

6989 AtMostN[

6990 Union[

6991 ImportAliasMatchType,

6992 OneOf[ImportAliasMatchType],

6993 AllOf[ImportAliasMatchType],

6994 ]

6995 ],

6996 ]

6997 ],

6998 MatchIfTrue[Sequence[cst.ImportAlias]],

6999 ]

7000 ],

7001 AllOf[

7002 Union[

7003 Sequence[

7004 Union[

7005 ImportAliasMatchType,

7006 OneOf[ImportAliasMatchType],

7007 AllOf[ImportAliasMatchType],

7008 AtLeastN[

7009 Union[

7010 ImportAliasMatchType,

7011 OneOf[ImportAliasMatchType],

7012 AllOf[ImportAliasMatchType],

7013 ]

7014 ],

7015 AtMostN[

7016 Union[

7017 ImportAliasMatchType,

7018 OneOf[ImportAliasMatchType],

7019 AllOf[ImportAliasMatchType],

7020 ]

7021 ],

7022 ]

7023 ],

7024 MatchIfTrue[Sequence[cst.ImportAlias]],

7025 ]

7026 ],

7027 ],

7028 "ImportStar",

7029 MetadataMatchType,

7030 MatchIfTrue[

7031 Union[

7032 Sequence[cst.ImportAlias],

7033 cst.ImportStar,

7034 OneOf[Union[Sequence[cst.ImportAlias], cst.ImportStar]],

7035 AllOf[Union[Sequence[cst.ImportAlias], cst.ImportStar]],

7036 ]

7037 ],

7038 ]

7039 ],

7040 ] = DoNotCare()

7041 relative: Union[

7042 Sequence[

7043 Union[

7044 DotMatchType,

7045 DoNotCareSentinel,

7046 OneOf[DotMatchType],

7047 AllOf[DotMatchType],

7048 AtLeastN[

7049 Union[

7050 DotMatchType,

7051 DoNotCareSentinel,

7052 OneOf[DotMatchType],

7053 AllOf[DotMatchType],

7054 ]

7055 ],

7056 AtMostN[

7057 Union[

7058 DotMatchType,

7059 DoNotCareSentinel,

7060 OneOf[DotMatchType],

7061 AllOf[DotMatchType],

7062 ]

7063 ],

7064 ]

7065 ],

7066 DoNotCareSentinel,

7067 MatchIfTrue[Sequence[cst.Dot]],

7068 OneOf[

7069 Union[

7070 Sequence[

7071 Union[

7072 DotMatchType,

7073 OneOf[DotMatchType],

7074 AllOf[DotMatchType],

7075 AtLeastN[

7076 Union[

7077 DotMatchType, OneOf[DotMatchType], AllOf[DotMatchType]

7078 ]

7079 ],

7080 AtMostN[

7081 Union[

7082 DotMatchType, OneOf[DotMatchType], AllOf[DotMatchType]

7083 ]

7084 ],

7085 ]

7086 ],

7087 MatchIfTrue[Sequence[cst.Dot]],

7088 ]

7089 ],

7090 AllOf[

7091 Union[

7092 Sequence[

7093 Union[

7094 DotMatchType,

7095 OneOf[DotMatchType],

7096 AllOf[DotMatchType],

7097 AtLeastN[

7098 Union[

7099 DotMatchType, OneOf[DotMatchType], AllOf[DotMatchType]

7100 ]

7101 ],

7102 AtMostN[

7103 Union[

7104 DotMatchType, OneOf[DotMatchType], AllOf[DotMatchType]

7105 ]

7106 ],

7107 ]

7108 ],

7109 MatchIfTrue[Sequence[cst.Dot]],

7110 ]

7111 ],

7112 ] = DoNotCare()

7113 lpar: Union[

7114 Optional["LeftParen"],

7115 MetadataMatchType,

7116 MatchIfTrue[Optional[cst.LeftParen]],

7117 DoNotCareSentinel,

7118 OneOf[

7119 Union[

7120 Optional["LeftParen"],

7121 MetadataMatchType,

7122 MatchIfTrue[Optional[cst.LeftParen]],

7123 ]

7124 ],

7125 AllOf[

7126 Union[

7127 Optional["LeftParen"],

7128 MetadataMatchType,

7129 MatchIfTrue[Optional[cst.LeftParen]],

7130 ]

7131 ],

7132 ] = DoNotCare()

7133 rpar: Union[

7134 Optional["RightParen"],

7135 MetadataMatchType,

7136 MatchIfTrue[Optional[cst.RightParen]],

7137 DoNotCareSentinel,

7138 OneOf[

7139 Union[

7140 Optional["RightParen"],

7141 MetadataMatchType,

7142 MatchIfTrue[Optional[cst.RightParen]],

7143 ]

7144 ],

7145 AllOf[

7146 Union[

7147 Optional["RightParen"],

7148 MetadataMatchType,

7149 MatchIfTrue[Optional[cst.RightParen]],

7150 ]

7151 ],

7152 ] = DoNotCare()

7153 semicolon: Union[

7154 SemicolonMatchType,

7155 DoNotCareSentinel,

7156 OneOf[SemicolonMatchType],

7157 AllOf[SemicolonMatchType],

7158 ] = DoNotCare()

7159 whitespace_after_from: Union[

7160 SimpleWhitespaceMatchType,

7161 DoNotCareSentinel,

7162 OneOf[SimpleWhitespaceMatchType],

7163 AllOf[SimpleWhitespaceMatchType],

7164 ] = DoNotCare()

7165 whitespace_before_import: Union[

7166 SimpleWhitespaceMatchType,

7167 DoNotCareSentinel,

7168 OneOf[SimpleWhitespaceMatchType],

7169 AllOf[SimpleWhitespaceMatchType],

7170 ] = DoNotCare()

7171 whitespace_after_import: Union[

7172 SimpleWhitespaceMatchType,

7173 DoNotCareSentinel,

7174 OneOf[SimpleWhitespaceMatchType],

7175 AllOf[SimpleWhitespaceMatchType],

7176 ] = DoNotCare()

7177 metadata: Union[

7178 MetadataMatchType,

7179 DoNotCareSentinel,

7180 OneOf[MetadataMatchType],

7181 AllOf[MetadataMatchType],

7182 ] = DoNotCare()

7183

7184

7185@dataclass(frozen=True, eq=False, unsafe_hash=False)

7186class ImportStar(BaseMatcherNode):

7187 metadata: Union[

7188 MetadataMatchType,

7189 DoNotCareSentinel,

7190 OneOf[MetadataMatchType],

7191 AllOf[MetadataMatchType],

7192 ] = DoNotCare()

7193

7194

7195@dataclass(frozen=True, eq=False, unsafe_hash=False)

7196class In(BaseCompOp, BaseMatcherNode):

7197 whitespace_before: Union[

7198 BaseParenthesizableWhitespaceMatchType,

7199 DoNotCareSentinel,

7200 OneOf[BaseParenthesizableWhitespaceMatchType],

7201 AllOf[BaseParenthesizableWhitespaceMatchType],

7202 ] = DoNotCare()

7203 whitespace_after: Union[

7204 BaseParenthesizableWhitespaceMatchType,

7205 DoNotCareSentinel,

7206 OneOf[BaseParenthesizableWhitespaceMatchType],

7207 AllOf[BaseParenthesizableWhitespaceMatchType],

7208 ] = DoNotCare()

7209 metadata: Union[

7210 MetadataMatchType,

7211 DoNotCareSentinel,

7212 OneOf[MetadataMatchType],

7213 AllOf[MetadataMatchType],

7214 ] = DoNotCare()

7215

7216

7217BaseStatementMatchType = Union[

7218 "BaseStatement", MetadataMatchType, MatchIfTrue[cst.BaseStatement]

7219]

7220

7221

7222@dataclass(frozen=True, eq=False, unsafe_hash=False)

7223class IndentedBlock(BaseSuite, BaseMatcherNode):

7224 body: Union[

7225 Sequence[

7226 Union[

7227 BaseStatementMatchType,

7228 DoNotCareSentinel,

7229 OneOf[BaseStatementMatchType],

7230 AllOf[BaseStatementMatchType],

7231 AtLeastN[

7232 Union[

7233 BaseStatementMatchType,

7234 DoNotCareSentinel,

7235 OneOf[BaseStatementMatchType],

7236 AllOf[BaseStatementMatchType],

7237 ]

7238 ],

7239 AtMostN[

7240 Union[

7241 BaseStatementMatchType,

7242 DoNotCareSentinel,

7243 OneOf[BaseStatementMatchType],

7244 AllOf[BaseStatementMatchType],

7245 ]

7246 ],

7247 ]

7248 ],

7249 DoNotCareSentinel,

7250 MatchIfTrue[Sequence[cst.BaseStatement]],

7251 OneOf[

7252 Union[

7253 Sequence[

7254 Union[

7255 BaseStatementMatchType,

7256 OneOf[BaseStatementMatchType],

7257 AllOf[BaseStatementMatchType],

7258 AtLeastN[

7259 Union[

7260 BaseStatementMatchType,

7261 OneOf[BaseStatementMatchType],

7262 AllOf[BaseStatementMatchType],

7263 ]

7264 ],

7265 AtMostN[

7266 Union[

7267 BaseStatementMatchType,

7268 OneOf[BaseStatementMatchType],

7269 AllOf[BaseStatementMatchType],

7270 ]

7271 ],

7272 ]

7273 ],

7274 MatchIfTrue[Sequence[cst.BaseStatement]],

7275 ]

7276 ],

7277 AllOf[

7278 Union[

7279 Sequence[

7280 Union[

7281 BaseStatementMatchType,

7282 OneOf[BaseStatementMatchType],

7283 AllOf[BaseStatementMatchType],

7284 AtLeastN[

7285 Union[

7286 BaseStatementMatchType,

7287 OneOf[BaseStatementMatchType],

7288 AllOf[BaseStatementMatchType],

7289 ]

7290 ],

7291 AtMostN[

7292 Union[

7293 BaseStatementMatchType,

7294 OneOf[BaseStatementMatchType],

7295 AllOf[BaseStatementMatchType],

7296 ]

7297 ],

7298 ]

7299 ],

7300 MatchIfTrue[Sequence[cst.BaseStatement]],

7301 ]

7302 ],

7303 ] = DoNotCare()

7304 header: Union[

7305 TrailingWhitespaceMatchType,

7306 DoNotCareSentinel,

7307 OneOf[TrailingWhitespaceMatchType],

7308 AllOf[TrailingWhitespaceMatchType],

7309 ] = DoNotCare()

7310 indent: Union[

7311 Optional[str],

7312 MetadataMatchType,

7313 MatchIfTrue[Optional[str]],

7314 DoNotCareSentinel,

7315 OneOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

7316 AllOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

7317 ] = DoNotCare()

7318 footer: Union[

7319 Sequence[

7320 Union[

7321 EmptyLineMatchType,

7322 DoNotCareSentinel,

7323 OneOf[EmptyLineMatchType],

7324 AllOf[EmptyLineMatchType],

7325 AtLeastN[

7326 Union[

7327 EmptyLineMatchType,

7328 DoNotCareSentinel,

7329 OneOf[EmptyLineMatchType],

7330 AllOf[EmptyLineMatchType],

7331 ]

7332 ],

7333 AtMostN[

7334 Union[

7335 EmptyLineMatchType,

7336 DoNotCareSentinel,

7337 OneOf[EmptyLineMatchType],

7338 AllOf[EmptyLineMatchType],

7339 ]

7340 ],

7341 ]

7342 ],

7343 DoNotCareSentinel,

7344 MatchIfTrue[Sequence[cst.EmptyLine]],

7345 OneOf[

7346 Union[

7347 Sequence[

7348 Union[

7349 EmptyLineMatchType,

7350 OneOf[EmptyLineMatchType],

7351 AllOf[EmptyLineMatchType],

7352 AtLeastN[

7353 Union[

7354 EmptyLineMatchType,

7355 OneOf[EmptyLineMatchType],

7356 AllOf[EmptyLineMatchType],

7357 ]

7358 ],

7359 AtMostN[

7360 Union[

7361 EmptyLineMatchType,

7362 OneOf[EmptyLineMatchType],

7363 AllOf[EmptyLineMatchType],

7364 ]

7365 ],

7366 ]

7367 ],

7368 MatchIfTrue[Sequence[cst.EmptyLine]],

7369 ]

7370 ],

7371 AllOf[

7372 Union[

7373 Sequence[

7374 Union[

7375 EmptyLineMatchType,

7376 OneOf[EmptyLineMatchType],

7377 AllOf[EmptyLineMatchType],

7378 AtLeastN[

7379 Union[

7380 EmptyLineMatchType,

7381 OneOf[EmptyLineMatchType],

7382 AllOf[EmptyLineMatchType],

7383 ]

7384 ],

7385 AtMostN[

7386 Union[

7387 EmptyLineMatchType,

7388 OneOf[EmptyLineMatchType],

7389 AllOf[EmptyLineMatchType],

7390 ]

7391 ],

7392 ]

7393 ],

7394 MatchIfTrue[Sequence[cst.EmptyLine]],

7395 ]

7396 ],

7397 ] = DoNotCare()

7398 metadata: Union[

7399 MetadataMatchType,

7400 DoNotCareSentinel,

7401 OneOf[MetadataMatchType],

7402 AllOf[MetadataMatchType],

7403 ] = DoNotCare()

7404

7405

7406@dataclass(frozen=True, eq=False, unsafe_hash=False)

7407class Index(BaseSlice, BaseMatcherNode):

7408 value: Union[

7409 BaseExpressionMatchType,

7410 DoNotCareSentinel,

7411 OneOf[BaseExpressionMatchType],

7412 AllOf[BaseExpressionMatchType],

7413 ] = DoNotCare()

7414 star: Union[

7415 Optional[Literal["*"]],

7416 MetadataMatchType,

7417 MatchIfTrue[Optional[Literal["*"]]],

7418 DoNotCareSentinel,

7419 OneOf[

7420 Union[

7421 Optional[Literal["*"]],

7422 MetadataMatchType,

7423 MatchIfTrue[Optional[Literal["*"]]],

7424 ]

7425 ],

7426 AllOf[

7427 Union[

7428 Optional[Literal["*"]],

7429 MetadataMatchType,

7430 MatchIfTrue[Optional[Literal["*"]]],

7431 ]

7432 ],

7433 ] = DoNotCare()

7434 whitespace_after_star: Union[

7435 Optional["BaseParenthesizableWhitespace"],

7436 MetadataMatchType,

7437 MatchIfTrue[Optional[cst.BaseParenthesizableWhitespace]],

7438 DoNotCareSentinel,

7439 OneOf[

7440 Union[

7441 Optional["BaseParenthesizableWhitespace"],

7442 MetadataMatchType,

7443 MatchIfTrue[Optional[cst.BaseParenthesizableWhitespace]],

7444 ]

7445 ],

7446 AllOf[

7447 Union[

7448 Optional["BaseParenthesizableWhitespace"],

7449 MetadataMatchType,

7450 MatchIfTrue[Optional[cst.BaseParenthesizableWhitespace]],

7451 ]

7452 ],

7453 ] = DoNotCare()

7454 metadata: Union[

7455 MetadataMatchType,

7456 DoNotCareSentinel,

7457 OneOf[MetadataMatchType],

7458 AllOf[MetadataMatchType],

7459 ] = DoNotCare()

7460

7461

7462@dataclass(frozen=True, eq=False, unsafe_hash=False)

7463class Integer(BaseExpression, BaseNumber, BaseMatcherNode):

7464 value: Union[

7465 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

7466 ] = DoNotCare()

7467 lpar: Union[

7468 Sequence[

7469 Union[

7470 LeftParenMatchType,

7471 DoNotCareSentinel,

7472 OneOf[LeftParenMatchType],

7473 AllOf[LeftParenMatchType],

7474 AtLeastN[

7475 Union[

7476 LeftParenMatchType,

7477 DoNotCareSentinel,

7478 OneOf[LeftParenMatchType],

7479 AllOf[LeftParenMatchType],

7480 ]

7481 ],

7482 AtMostN[

7483 Union[

7484 LeftParenMatchType,

7485 DoNotCareSentinel,

7486 OneOf[LeftParenMatchType],

7487 AllOf[LeftParenMatchType],

7488 ]

7489 ],

7490 ]

7491 ],

7492 DoNotCareSentinel,

7493 MatchIfTrue[Sequence[cst.LeftParen]],

7494 OneOf[

7495 Union[

7496 Sequence[

7497 Union[

7498 LeftParenMatchType,

7499 OneOf[LeftParenMatchType],

7500 AllOf[LeftParenMatchType],

7501 AtLeastN[

7502 Union[

7503 LeftParenMatchType,

7504 OneOf[LeftParenMatchType],

7505 AllOf[LeftParenMatchType],

7506 ]

7507 ],

7508 AtMostN[

7509 Union[

7510 LeftParenMatchType,

7511 OneOf[LeftParenMatchType],

7512 AllOf[LeftParenMatchType],

7513 ]

7514 ],

7515 ]

7516 ],

7517 MatchIfTrue[Sequence[cst.LeftParen]],

7518 ]

7519 ],

7520 AllOf[

7521 Union[

7522 Sequence[

7523 Union[

7524 LeftParenMatchType,

7525 OneOf[LeftParenMatchType],

7526 AllOf[LeftParenMatchType],

7527 AtLeastN[

7528 Union[

7529 LeftParenMatchType,

7530 OneOf[LeftParenMatchType],

7531 AllOf[LeftParenMatchType],

7532 ]

7533 ],

7534 AtMostN[

7535 Union[

7536 LeftParenMatchType,

7537 OneOf[LeftParenMatchType],

7538 AllOf[LeftParenMatchType],

7539 ]

7540 ],

7541 ]

7542 ],

7543 MatchIfTrue[Sequence[cst.LeftParen]],

7544 ]

7545 ],

7546 ] = DoNotCare()

7547 rpar: Union[

7548 Sequence[

7549 Union[

7550 RightParenMatchType,

7551 DoNotCareSentinel,

7552 OneOf[RightParenMatchType],

7553 AllOf[RightParenMatchType],

7554 AtLeastN[

7555 Union[

7556 RightParenMatchType,

7557 DoNotCareSentinel,

7558 OneOf[RightParenMatchType],

7559 AllOf[RightParenMatchType],

7560 ]

7561 ],

7562 AtMostN[

7563 Union[

7564 RightParenMatchType,

7565 DoNotCareSentinel,

7566 OneOf[RightParenMatchType],

7567 AllOf[RightParenMatchType],

7568 ]

7569 ],

7570 ]

7571 ],

7572 DoNotCareSentinel,

7573 MatchIfTrue[Sequence[cst.RightParen]],

7574 OneOf[

7575 Union[

7576 Sequence[

7577 Union[

7578 RightParenMatchType,

7579 OneOf[RightParenMatchType],

7580 AllOf[RightParenMatchType],

7581 AtLeastN[

7582 Union[

7583 RightParenMatchType,

7584 OneOf[RightParenMatchType],

7585 AllOf[RightParenMatchType],

7586 ]

7587 ],

7588 AtMostN[

7589 Union[

7590 RightParenMatchType,

7591 OneOf[RightParenMatchType],

7592 AllOf[RightParenMatchType],

7593 ]

7594 ],

7595 ]

7596 ],

7597 MatchIfTrue[Sequence[cst.RightParen]],

7598 ]

7599 ],

7600 AllOf[

7601 Union[

7602 Sequence[

7603 Union[

7604 RightParenMatchType,

7605 OneOf[RightParenMatchType],

7606 AllOf[RightParenMatchType],

7607 AtLeastN[

7608 Union[

7609 RightParenMatchType,

7610 OneOf[RightParenMatchType],

7611 AllOf[RightParenMatchType],

7612 ]

7613 ],

7614 AtMostN[

7615 Union[

7616 RightParenMatchType,

7617 OneOf[RightParenMatchType],

7618 AllOf[RightParenMatchType],

7619 ]

7620 ],

7621 ]

7622 ],

7623 MatchIfTrue[Sequence[cst.RightParen]],

7624 ]

7625 ],

7626 ] = DoNotCare()

7627 metadata: Union[

7628 MetadataMatchType,

7629 DoNotCareSentinel,

7630 OneOf[MetadataMatchType],

7631 AllOf[MetadataMatchType],

7632 ] = DoNotCare()

7633

7634

7635@dataclass(frozen=True, eq=False, unsafe_hash=False)

7636class Is(BaseCompOp, BaseMatcherNode):

7637 whitespace_before: Union[

7638 BaseParenthesizableWhitespaceMatchType,

7639 DoNotCareSentinel,

7640 OneOf[BaseParenthesizableWhitespaceMatchType],

7641 AllOf[BaseParenthesizableWhitespaceMatchType],

7642 ] = DoNotCare()

7643 whitespace_after: Union[

7644 BaseParenthesizableWhitespaceMatchType,

7645 DoNotCareSentinel,

7646 OneOf[BaseParenthesizableWhitespaceMatchType],

7647 AllOf[BaseParenthesizableWhitespaceMatchType],

7648 ] = DoNotCare()

7649 metadata: Union[

7650 MetadataMatchType,

7651 DoNotCareSentinel,

7652 OneOf[MetadataMatchType],

7653 AllOf[MetadataMatchType],

7654 ] = DoNotCare()

7655

7656

7657@dataclass(frozen=True, eq=False, unsafe_hash=False)

7658class IsNot(BaseCompOp, BaseMatcherNode):

7659 whitespace_before: Union[

7660 BaseParenthesizableWhitespaceMatchType,

7661 DoNotCareSentinel,

7662 OneOf[BaseParenthesizableWhitespaceMatchType],

7663 AllOf[BaseParenthesizableWhitespaceMatchType],

7664 ] = DoNotCare()

7665 whitespace_between: Union[

7666 BaseParenthesizableWhitespaceMatchType,

7667 DoNotCareSentinel,

7668 OneOf[BaseParenthesizableWhitespaceMatchType],

7669 AllOf[BaseParenthesizableWhitespaceMatchType],

7670 ] = DoNotCare()

7671 whitespace_after: Union[

7672 BaseParenthesizableWhitespaceMatchType,

7673 DoNotCareSentinel,

7674 OneOf[BaseParenthesizableWhitespaceMatchType],

7675 AllOf[BaseParenthesizableWhitespaceMatchType],

7676 ] = DoNotCare()

7677 metadata: Union[

7678 MetadataMatchType,

7679 DoNotCareSentinel,

7680 OneOf[MetadataMatchType],

7681 AllOf[MetadataMatchType],

7682 ] = DoNotCare()

7683

7684

7685ColonMatchType = Union["Colon", MetadataMatchType, MatchIfTrue[cst.Colon]]

7686

7687

7688@dataclass(frozen=True, eq=False, unsafe_hash=False)

7689class Lambda(BaseExpression, BaseMatcherNode):

7690 params: Union[

7691 ParametersMatchType,

7692 DoNotCareSentinel,

7693 OneOf[ParametersMatchType],

7694 AllOf[ParametersMatchType],

7695 ] = DoNotCare()

7696 body: Union[

7697 BaseExpressionMatchType,

7698 DoNotCareSentinel,

7699 OneOf[BaseExpressionMatchType],

7700 AllOf[BaseExpressionMatchType],

7701 ] = DoNotCare()

7702 colon: Union[

7703 ColonMatchType, DoNotCareSentinel, OneOf[ColonMatchType], AllOf[ColonMatchType]

7704 ] = DoNotCare()

7705 lpar: Union[

7706 Sequence[

7707 Union[

7708 LeftParenMatchType,

7709 DoNotCareSentinel,

7710 OneOf[LeftParenMatchType],

7711 AllOf[LeftParenMatchType],

7712 AtLeastN[

7713 Union[

7714 LeftParenMatchType,

7715 DoNotCareSentinel,

7716 OneOf[LeftParenMatchType],

7717 AllOf[LeftParenMatchType],

7718 ]

7719 ],

7720 AtMostN[

7721 Union[

7722 LeftParenMatchType,

7723 DoNotCareSentinel,

7724 OneOf[LeftParenMatchType],

7725 AllOf[LeftParenMatchType],

7726 ]

7727 ],

7728 ]

7729 ],

7730 DoNotCareSentinel,

7731 MatchIfTrue[Sequence[cst.LeftParen]],

7732 OneOf[

7733 Union[

7734 Sequence[

7735 Union[

7736 LeftParenMatchType,

7737 OneOf[LeftParenMatchType],

7738 AllOf[LeftParenMatchType],

7739 AtLeastN[

7740 Union[

7741 LeftParenMatchType,

7742 OneOf[LeftParenMatchType],

7743 AllOf[LeftParenMatchType],

7744 ]

7745 ],

7746 AtMostN[

7747 Union[

7748 LeftParenMatchType,

7749 OneOf[LeftParenMatchType],

7750 AllOf[LeftParenMatchType],

7751 ]

7752 ],

7753 ]

7754 ],

7755 MatchIfTrue[Sequence[cst.LeftParen]],

7756 ]

7757 ],

7758 AllOf[

7759 Union[

7760 Sequence[

7761 Union[

7762 LeftParenMatchType,

7763 OneOf[LeftParenMatchType],

7764 AllOf[LeftParenMatchType],

7765 AtLeastN[

7766 Union[

7767 LeftParenMatchType,

7768 OneOf[LeftParenMatchType],

7769 AllOf[LeftParenMatchType],

7770 ]

7771 ],

7772 AtMostN[

7773 Union[

7774 LeftParenMatchType,

7775 OneOf[LeftParenMatchType],

7776 AllOf[LeftParenMatchType],

7777 ]

7778 ],

7779 ]

7780 ],

7781 MatchIfTrue[Sequence[cst.LeftParen]],

7782 ]

7783 ],

7784 ] = DoNotCare()

7785 rpar: Union[

7786 Sequence[

7787 Union[

7788 RightParenMatchType,

7789 DoNotCareSentinel,

7790 OneOf[RightParenMatchType],

7791 AllOf[RightParenMatchType],

7792 AtLeastN[

7793 Union[

7794 RightParenMatchType,

7795 DoNotCareSentinel,

7796 OneOf[RightParenMatchType],

7797 AllOf[RightParenMatchType],

7798 ]

7799 ],

7800 AtMostN[

7801 Union[

7802 RightParenMatchType,

7803 DoNotCareSentinel,

7804 OneOf[RightParenMatchType],

7805 AllOf[RightParenMatchType],

7806 ]

7807 ],

7808 ]

7809 ],

7810 DoNotCareSentinel,

7811 MatchIfTrue[Sequence[cst.RightParen]],

7812 OneOf[

7813 Union[

7814 Sequence[

7815 Union[

7816 RightParenMatchType,

7817 OneOf[RightParenMatchType],

7818 AllOf[RightParenMatchType],

7819 AtLeastN[

7820 Union[

7821 RightParenMatchType,

7822 OneOf[RightParenMatchType],

7823 AllOf[RightParenMatchType],

7824 ]

7825 ],

7826 AtMostN[

7827 Union[

7828 RightParenMatchType,

7829 OneOf[RightParenMatchType],

7830 AllOf[RightParenMatchType],

7831 ]

7832 ],

7833 ]

7834 ],

7835 MatchIfTrue[Sequence[cst.RightParen]],

7836 ]

7837 ],

7838 AllOf[

7839 Union[

7840 Sequence[

7841 Union[

7842 RightParenMatchType,

7843 OneOf[RightParenMatchType],

7844 AllOf[RightParenMatchType],

7845 AtLeastN[

7846 Union[

7847 RightParenMatchType,

7848 OneOf[RightParenMatchType],

7849 AllOf[RightParenMatchType],

7850 ]

7851 ],

7852 AtMostN[

7853 Union[

7854 RightParenMatchType,

7855 OneOf[RightParenMatchType],

7856 AllOf[RightParenMatchType],

7857 ]

7858 ],

7859 ]

7860 ],

7861 MatchIfTrue[Sequence[cst.RightParen]],

7862 ]

7863 ],

7864 ] = DoNotCare()

7865 whitespace_after_lambda: Union[

7866 BaseParenthesizableWhitespaceMatchType,

7867 DoNotCareSentinel,

7868 OneOf[BaseParenthesizableWhitespaceMatchType],

7869 AllOf[BaseParenthesizableWhitespaceMatchType],

7870 ] = DoNotCare()

7871 metadata: Union[

7872 MetadataMatchType,

7873 DoNotCareSentinel,

7874 OneOf[MetadataMatchType],

7875 AllOf[MetadataMatchType],

7876 ] = DoNotCare()

7877

7878

7879@dataclass(frozen=True, eq=False, unsafe_hash=False)

7880class LeftCurlyBrace(BaseMatcherNode):

7881 whitespace_after: Union[

7882 BaseParenthesizableWhitespaceMatchType,

7883 DoNotCareSentinel,

7884 OneOf[BaseParenthesizableWhitespaceMatchType],

7885 AllOf[BaseParenthesizableWhitespaceMatchType],

7886 ] = DoNotCare()

7887 metadata: Union[

7888 MetadataMatchType,

7889 DoNotCareSentinel,

7890 OneOf[MetadataMatchType],

7891 AllOf[MetadataMatchType],

7892 ] = DoNotCare()

7893

7894

7895@dataclass(frozen=True, eq=False, unsafe_hash=False)

7896class LeftParen(BaseMatcherNode):

7897 whitespace_after: Union[

7898 BaseParenthesizableWhitespaceMatchType,

7899 DoNotCareSentinel,

7900 OneOf[BaseParenthesizableWhitespaceMatchType],

7901 AllOf[BaseParenthesizableWhitespaceMatchType],

7902 ] = DoNotCare()

7903 metadata: Union[

7904 MetadataMatchType,

7905 DoNotCareSentinel,

7906 OneOf[MetadataMatchType],

7907 AllOf[MetadataMatchType],

7908 ] = DoNotCare()

7909

7910

7911@dataclass(frozen=True, eq=False, unsafe_hash=False)

7912class LeftShift(BaseBinaryOp, BaseMatcherNode):

7913 whitespace_before: Union[

7914 BaseParenthesizableWhitespaceMatchType,

7915 DoNotCareSentinel,

7916 OneOf[BaseParenthesizableWhitespaceMatchType],

7917 AllOf[BaseParenthesizableWhitespaceMatchType],

7918 ] = DoNotCare()

7919 whitespace_after: Union[

7920 BaseParenthesizableWhitespaceMatchType,

7921 DoNotCareSentinel,

7922 OneOf[BaseParenthesizableWhitespaceMatchType],

7923 AllOf[BaseParenthesizableWhitespaceMatchType],

7924 ] = DoNotCare()

7925 metadata: Union[

7926 MetadataMatchType,

7927 DoNotCareSentinel,

7928 OneOf[MetadataMatchType],

7929 AllOf[MetadataMatchType],

7930 ] = DoNotCare()

7931

7932

7933@dataclass(frozen=True, eq=False, unsafe_hash=False)

7934class LeftShiftAssign(BaseAugOp, BaseMatcherNode):

7935 whitespace_before: Union[

7936 BaseParenthesizableWhitespaceMatchType,

7937 DoNotCareSentinel,

7938 OneOf[BaseParenthesizableWhitespaceMatchType],

7939 AllOf[BaseParenthesizableWhitespaceMatchType],

7940 ] = DoNotCare()

7941 whitespace_after: Union[

7942 BaseParenthesizableWhitespaceMatchType,

7943 DoNotCareSentinel,

7944 OneOf[BaseParenthesizableWhitespaceMatchType],

7945 AllOf[BaseParenthesizableWhitespaceMatchType],

7946 ] = DoNotCare()

7947 metadata: Union[

7948 MetadataMatchType,

7949 DoNotCareSentinel,

7950 OneOf[MetadataMatchType],

7951 AllOf[MetadataMatchType],

7952 ] = DoNotCare()

7953

7954

7955@dataclass(frozen=True, eq=False, unsafe_hash=False)

7956class LeftSquareBracket(BaseMatcherNode):

7957 whitespace_after: Union[

7958 BaseParenthesizableWhitespaceMatchType,

7959 DoNotCareSentinel,

7960 OneOf[BaseParenthesizableWhitespaceMatchType],

7961 AllOf[BaseParenthesizableWhitespaceMatchType],

7962 ] = DoNotCare()

7963 metadata: Union[

7964 MetadataMatchType,

7965 DoNotCareSentinel,

7966 OneOf[MetadataMatchType],

7967 AllOf[MetadataMatchType],

7968 ] = DoNotCare()

7969

7970

7971@dataclass(frozen=True, eq=False, unsafe_hash=False)

7972class LessThan(BaseCompOp, BaseMatcherNode):

7973 whitespace_before: Union[

7974 BaseParenthesizableWhitespaceMatchType,

7975 DoNotCareSentinel,

7976 OneOf[BaseParenthesizableWhitespaceMatchType],

7977 AllOf[BaseParenthesizableWhitespaceMatchType],

7978 ] = DoNotCare()

7979 whitespace_after: Union[

7980 BaseParenthesizableWhitespaceMatchType,

7981 DoNotCareSentinel,

7982 OneOf[BaseParenthesizableWhitespaceMatchType],

7983 AllOf[BaseParenthesizableWhitespaceMatchType],

7984 ] = DoNotCare()

7985 metadata: Union[

7986 MetadataMatchType,

7987 DoNotCareSentinel,

7988 OneOf[MetadataMatchType],

7989 AllOf[MetadataMatchType],

7990 ] = DoNotCare()

7991

7992

7993@dataclass(frozen=True, eq=False, unsafe_hash=False)

7994class LessThanEqual(BaseCompOp, BaseMatcherNode):

7995 whitespace_before: Union[

7996 BaseParenthesizableWhitespaceMatchType,

7997 DoNotCareSentinel,

7998 OneOf[BaseParenthesizableWhitespaceMatchType],

7999 AllOf[BaseParenthesizableWhitespaceMatchType],

8000 ] = DoNotCare()

8001 whitespace_after: Union[

8002 BaseParenthesizableWhitespaceMatchType,

8003 DoNotCareSentinel,

8004 OneOf[BaseParenthesizableWhitespaceMatchType],

8005 AllOf[BaseParenthesizableWhitespaceMatchType],

8006 ] = DoNotCare()

8007 metadata: Union[

8008 MetadataMatchType,

8009 DoNotCareSentinel,

8010 OneOf[MetadataMatchType],

8011 AllOf[MetadataMatchType],

8012 ] = DoNotCare()

8013

8014

8015BaseElementMatchType = Union[

8016 "BaseElement", MetadataMatchType, MatchIfTrue[cst.BaseElement]

8017]

8018LeftSquareBracketMatchType = Union[

8019 "LeftSquareBracket", MetadataMatchType, MatchIfTrue[cst.LeftSquareBracket]

8020]

8021RightSquareBracketMatchType = Union[

8022 "RightSquareBracket", MetadataMatchType, MatchIfTrue[cst.RightSquareBracket]

8023]

8024

8025

8026@dataclass(frozen=True, eq=False, unsafe_hash=False)

8027class List(

8028 BaseAssignTargetExpression,

8029 BaseDelTargetExpression,

8030 BaseExpression,

8031 BaseList,

8032 BaseMatcherNode,

8033):

8034 elements: Union[

8035 Sequence[

8036 Union[

8037 BaseElementMatchType,

8038 DoNotCareSentinel,

8039 OneOf[BaseElementMatchType],

8040 AllOf[BaseElementMatchType],

8041 AtLeastN[

8042 Union[

8043 BaseElementMatchType,

8044 DoNotCareSentinel,

8045 OneOf[BaseElementMatchType],

8046 AllOf[BaseElementMatchType],

8047 ]

8048 ],

8049 AtMostN[

8050 Union[

8051 BaseElementMatchType,

8052 DoNotCareSentinel,

8053 OneOf[BaseElementMatchType],

8054 AllOf[BaseElementMatchType],

8055 ]

8056 ],

8057 ]

8058 ],

8059 DoNotCareSentinel,

8060 MatchIfTrue[Sequence[cst.BaseElement]],

8061 OneOf[

8062 Union[

8063 Sequence[

8064 Union[

8065 BaseElementMatchType,

8066 OneOf[BaseElementMatchType],

8067 AllOf[BaseElementMatchType],

8068 AtLeastN[

8069 Union[

8070 BaseElementMatchType,

8071 OneOf[BaseElementMatchType],

8072 AllOf[BaseElementMatchType],

8073 ]

8074 ],

8075 AtMostN[

8076 Union[

8077 BaseElementMatchType,

8078 OneOf[BaseElementMatchType],

8079 AllOf[BaseElementMatchType],

8080 ]

8081 ],

8082 ]

8083 ],

8084 MatchIfTrue[Sequence[cst.BaseElement]],

8085 ]

8086 ],

8087 AllOf[

8088 Union[

8089 Sequence[

8090 Union[

8091 BaseElementMatchType,

8092 OneOf[BaseElementMatchType],

8093 AllOf[BaseElementMatchType],

8094 AtLeastN[

8095 Union[

8096 BaseElementMatchType,

8097 OneOf[BaseElementMatchType],

8098 AllOf[BaseElementMatchType],

8099 ]

8100 ],

8101 AtMostN[

8102 Union[

8103 BaseElementMatchType,

8104 OneOf[BaseElementMatchType],

8105 AllOf[BaseElementMatchType],

8106 ]

8107 ],

8108 ]

8109 ],

8110 MatchIfTrue[Sequence[cst.BaseElement]],

8111 ]

8112 ],

8113 ] = DoNotCare()

8114 lbracket: Union[

8115 LeftSquareBracketMatchType,

8116 DoNotCareSentinel,

8117 OneOf[LeftSquareBracketMatchType],

8118 AllOf[LeftSquareBracketMatchType],

8119 ] = DoNotCare()

8120 rbracket: Union[

8121 RightSquareBracketMatchType,

8122 DoNotCareSentinel,

8123 OneOf[RightSquareBracketMatchType],

8124 AllOf[RightSquareBracketMatchType],

8125 ] = DoNotCare()

8126 lpar: Union[

8127 Sequence[

8128 Union[

8129 LeftParenMatchType,

8130 DoNotCareSentinel,

8131 OneOf[LeftParenMatchType],

8132 AllOf[LeftParenMatchType],

8133 AtLeastN[

8134 Union[

8135 LeftParenMatchType,

8136 DoNotCareSentinel,

8137 OneOf[LeftParenMatchType],

8138 AllOf[LeftParenMatchType],

8139 ]

8140 ],

8141 AtMostN[

8142 Union[

8143 LeftParenMatchType,

8144 DoNotCareSentinel,

8145 OneOf[LeftParenMatchType],

8146 AllOf[LeftParenMatchType],

8147 ]

8148 ],

8149 ]

8150 ],

8151 DoNotCareSentinel,

8152 MatchIfTrue[Sequence[cst.LeftParen]],

8153 OneOf[

8154 Union[

8155 Sequence[

8156 Union[

8157 LeftParenMatchType,

8158 OneOf[LeftParenMatchType],

8159 AllOf[LeftParenMatchType],

8160 AtLeastN[

8161 Union[

8162 LeftParenMatchType,

8163 OneOf[LeftParenMatchType],

8164 AllOf[LeftParenMatchType],

8165 ]

8166 ],

8167 AtMostN[

8168 Union[

8169 LeftParenMatchType,

8170 OneOf[LeftParenMatchType],

8171 AllOf[LeftParenMatchType],

8172 ]

8173 ],

8174 ]

8175 ],

8176 MatchIfTrue[Sequence[cst.LeftParen]],

8177 ]

8178 ],

8179 AllOf[

8180 Union[

8181 Sequence[

8182 Union[

8183 LeftParenMatchType,

8184 OneOf[LeftParenMatchType],

8185 AllOf[LeftParenMatchType],

8186 AtLeastN[

8187 Union[

8188 LeftParenMatchType,

8189 OneOf[LeftParenMatchType],

8190 AllOf[LeftParenMatchType],

8191 ]

8192 ],

8193 AtMostN[

8194 Union[

8195 LeftParenMatchType,

8196 OneOf[LeftParenMatchType],

8197 AllOf[LeftParenMatchType],

8198 ]

8199 ],

8200 ]

8201 ],

8202 MatchIfTrue[Sequence[cst.LeftParen]],

8203 ]

8204 ],

8205 ] = DoNotCare()

8206 rpar: Union[

8207 Sequence[

8208 Union[

8209 RightParenMatchType,

8210 DoNotCareSentinel,

8211 OneOf[RightParenMatchType],

8212 AllOf[RightParenMatchType],

8213 AtLeastN[

8214 Union[

8215 RightParenMatchType,

8216 DoNotCareSentinel,

8217 OneOf[RightParenMatchType],

8218 AllOf[RightParenMatchType],

8219 ]

8220 ],

8221 AtMostN[

8222 Union[

8223 RightParenMatchType,

8224 DoNotCareSentinel,

8225 OneOf[RightParenMatchType],

8226 AllOf[RightParenMatchType],

8227 ]

8228 ],

8229 ]

8230 ],

8231 DoNotCareSentinel,

8232 MatchIfTrue[Sequence[cst.RightParen]],

8233 OneOf[

8234 Union[

8235 Sequence[

8236 Union[

8237 RightParenMatchType,

8238 OneOf[RightParenMatchType],

8239 AllOf[RightParenMatchType],

8240 AtLeastN[

8241 Union[

8242 RightParenMatchType,

8243 OneOf[RightParenMatchType],

8244 AllOf[RightParenMatchType],

8245 ]

8246 ],

8247 AtMostN[

8248 Union[

8249 RightParenMatchType,

8250 OneOf[RightParenMatchType],

8251 AllOf[RightParenMatchType],

8252 ]

8253 ],

8254 ]

8255 ],

8256 MatchIfTrue[Sequence[cst.RightParen]],

8257 ]

8258 ],

8259 AllOf[

8260 Union[

8261 Sequence[

8262 Union[

8263 RightParenMatchType,

8264 OneOf[RightParenMatchType],

8265 AllOf[RightParenMatchType],

8266 AtLeastN[

8267 Union[

8268 RightParenMatchType,

8269 OneOf[RightParenMatchType],

8270 AllOf[RightParenMatchType],

8271 ]

8272 ],

8273 AtMostN[

8274 Union[

8275 RightParenMatchType,

8276 OneOf[RightParenMatchType],

8277 AllOf[RightParenMatchType],

8278 ]

8279 ],

8280 ]

8281 ],

8282 MatchIfTrue[Sequence[cst.RightParen]],

8283 ]

8284 ],

8285 ] = DoNotCare()

8286 metadata: Union[

8287 MetadataMatchType,

8288 DoNotCareSentinel,

8289 OneOf[MetadataMatchType],

8290 AllOf[MetadataMatchType],

8291 ] = DoNotCare()

8292

8293

8294@dataclass(frozen=True, eq=False, unsafe_hash=False)

8295class ListComp(BaseComp, BaseExpression, BaseList, BaseSimpleComp, BaseMatcherNode):

8296 elt: Union[

8297 BaseExpressionMatchType,

8298 DoNotCareSentinel,

8299 OneOf[BaseExpressionMatchType],

8300 AllOf[BaseExpressionMatchType],

8301 ] = DoNotCare()

8302 for_in: Union[

8303 CompForMatchType,

8304 DoNotCareSentinel,

8305 OneOf[CompForMatchType],

8306 AllOf[CompForMatchType],

8307 ] = DoNotCare()

8308 lbracket: Union[

8309 LeftSquareBracketMatchType,

8310 DoNotCareSentinel,

8311 OneOf[LeftSquareBracketMatchType],

8312 AllOf[LeftSquareBracketMatchType],

8313 ] = DoNotCare()

8314 rbracket: Union[

8315 RightSquareBracketMatchType,

8316 DoNotCareSentinel,

8317 OneOf[RightSquareBracketMatchType],

8318 AllOf[RightSquareBracketMatchType],

8319 ] = DoNotCare()

8320 lpar: Union[

8321 Sequence[

8322 Union[

8323 LeftParenMatchType,

8324 DoNotCareSentinel,

8325 OneOf[LeftParenMatchType],

8326 AllOf[LeftParenMatchType],

8327 AtLeastN[

8328 Union[

8329 LeftParenMatchType,

8330 DoNotCareSentinel,

8331 OneOf[LeftParenMatchType],

8332 AllOf[LeftParenMatchType],

8333 ]

8334 ],

8335 AtMostN[

8336 Union[

8337 LeftParenMatchType,

8338 DoNotCareSentinel,

8339 OneOf[LeftParenMatchType],

8340 AllOf[LeftParenMatchType],

8341 ]

8342 ],

8343 ]

8344 ],

8345 DoNotCareSentinel,

8346 MatchIfTrue[Sequence[cst.LeftParen]],

8347 OneOf[

8348 Union[

8349 Sequence[

8350 Union[

8351 LeftParenMatchType,

8352 OneOf[LeftParenMatchType],

8353 AllOf[LeftParenMatchType],

8354 AtLeastN[

8355 Union[

8356 LeftParenMatchType,

8357 OneOf[LeftParenMatchType],

8358 AllOf[LeftParenMatchType],

8359 ]

8360 ],

8361 AtMostN[

8362 Union[

8363 LeftParenMatchType,

8364 OneOf[LeftParenMatchType],

8365 AllOf[LeftParenMatchType],

8366 ]

8367 ],

8368 ]

8369 ],

8370 MatchIfTrue[Sequence[cst.LeftParen]],

8371 ]

8372 ],

8373 AllOf[

8374 Union[

8375 Sequence[

8376 Union[

8377 LeftParenMatchType,

8378 OneOf[LeftParenMatchType],

8379 AllOf[LeftParenMatchType],

8380 AtLeastN[

8381 Union[

8382 LeftParenMatchType,

8383 OneOf[LeftParenMatchType],

8384 AllOf[LeftParenMatchType],

8385 ]

8386 ],

8387 AtMostN[

8388 Union[

8389 LeftParenMatchType,

8390 OneOf[LeftParenMatchType],

8391 AllOf[LeftParenMatchType],

8392 ]

8393 ],

8394 ]

8395 ],

8396 MatchIfTrue[Sequence[cst.LeftParen]],

8397 ]

8398 ],

8399 ] = DoNotCare()

8400 rpar: Union[

8401 Sequence[

8402 Union[

8403 RightParenMatchType,

8404 DoNotCareSentinel,

8405 OneOf[RightParenMatchType],

8406 AllOf[RightParenMatchType],

8407 AtLeastN[

8408 Union[

8409 RightParenMatchType,

8410 DoNotCareSentinel,

8411 OneOf[RightParenMatchType],

8412 AllOf[RightParenMatchType],

8413 ]

8414 ],

8415 AtMostN[

8416 Union[

8417 RightParenMatchType,

8418 DoNotCareSentinel,

8419 OneOf[RightParenMatchType],

8420 AllOf[RightParenMatchType],

8421 ]

8422 ],

8423 ]

8424 ],

8425 DoNotCareSentinel,

8426 MatchIfTrue[Sequence[cst.RightParen]],

8427 OneOf[

8428 Union[

8429 Sequence[

8430 Union[

8431 RightParenMatchType,

8432 OneOf[RightParenMatchType],

8433 AllOf[RightParenMatchType],

8434 AtLeastN[

8435 Union[

8436 RightParenMatchType,

8437 OneOf[RightParenMatchType],

8438 AllOf[RightParenMatchType],

8439 ]

8440 ],

8441 AtMostN[

8442 Union[

8443 RightParenMatchType,

8444 OneOf[RightParenMatchType],

8445 AllOf[RightParenMatchType],

8446 ]

8447 ],

8448 ]

8449 ],

8450 MatchIfTrue[Sequence[cst.RightParen]],

8451 ]

8452 ],

8453 AllOf[

8454 Union[

8455 Sequence[

8456 Union[

8457 RightParenMatchType,

8458 OneOf[RightParenMatchType],

8459 AllOf[RightParenMatchType],

8460 AtLeastN[

8461 Union[

8462 RightParenMatchType,

8463 OneOf[RightParenMatchType],

8464 AllOf[RightParenMatchType],

8465 ]

8466 ],

8467 AtMostN[

8468 Union[

8469 RightParenMatchType,

8470 OneOf[RightParenMatchType],

8471 AllOf[RightParenMatchType],

8472 ]

8473 ],

8474 ]

8475 ],

8476 MatchIfTrue[Sequence[cst.RightParen]],

8477 ]

8478 ],

8479 ] = DoNotCare()

8480 metadata: Union[

8481 MetadataMatchType,

8482 DoNotCareSentinel,

8483 OneOf[MetadataMatchType],

8484 AllOf[MetadataMatchType],

8485 ] = DoNotCare()

8486

8487

8488MatchCaseMatchType = Union["MatchCase", MetadataMatchType, MatchIfTrue[cst.MatchCase]]

8489

8490

8491@dataclass(frozen=True, eq=False, unsafe_hash=False)

8492class Match(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

8493 subject: Union[

8494 BaseExpressionMatchType,

8495 DoNotCareSentinel,

8496 OneOf[BaseExpressionMatchType],

8497 AllOf[BaseExpressionMatchType],

8498 ] = DoNotCare()

8499 cases: Union[

8500 Sequence[

8501 Union[

8502 MatchCaseMatchType,

8503 DoNotCareSentinel,

8504 OneOf[MatchCaseMatchType],

8505 AllOf[MatchCaseMatchType],

8506 AtLeastN[

8507 Union[

8508 MatchCaseMatchType,

8509 DoNotCareSentinel,

8510 OneOf[MatchCaseMatchType],

8511 AllOf[MatchCaseMatchType],

8512 ]

8513 ],

8514 AtMostN[

8515 Union[

8516 MatchCaseMatchType,

8517 DoNotCareSentinel,

8518 OneOf[MatchCaseMatchType],

8519 AllOf[MatchCaseMatchType],

8520 ]

8521 ],

8522 ]

8523 ],

8524 DoNotCareSentinel,

8525 MatchIfTrue[Sequence[cst.MatchCase]],

8526 OneOf[

8527 Union[

8528 Sequence[

8529 Union[

8530 MatchCaseMatchType,

8531 OneOf[MatchCaseMatchType],

8532 AllOf[MatchCaseMatchType],

8533 AtLeastN[

8534 Union[

8535 MatchCaseMatchType,

8536 OneOf[MatchCaseMatchType],

8537 AllOf[MatchCaseMatchType],

8538 ]

8539 ],

8540 AtMostN[

8541 Union[

8542 MatchCaseMatchType,

8543 OneOf[MatchCaseMatchType],

8544 AllOf[MatchCaseMatchType],

8545 ]

8546 ],

8547 ]

8548 ],

8549 MatchIfTrue[Sequence[cst.MatchCase]],

8550 ]

8551 ],

8552 AllOf[

8553 Union[

8554 Sequence[

8555 Union[

8556 MatchCaseMatchType,

8557 OneOf[MatchCaseMatchType],

8558 AllOf[MatchCaseMatchType],

8559 AtLeastN[

8560 Union[

8561 MatchCaseMatchType,

8562 OneOf[MatchCaseMatchType],

8563 AllOf[MatchCaseMatchType],

8564 ]

8565 ],

8566 AtMostN[

8567 Union[

8568 MatchCaseMatchType,

8569 OneOf[MatchCaseMatchType],

8570 AllOf[MatchCaseMatchType],

8571 ]

8572 ],

8573 ]

8574 ],

8575 MatchIfTrue[Sequence[cst.MatchCase]],

8576 ]

8577 ],

8578 ] = DoNotCare()

8579 leading_lines: Union[

8580 Sequence[

8581 Union[

8582 EmptyLineMatchType,

8583 DoNotCareSentinel,

8584 OneOf[EmptyLineMatchType],

8585 AllOf[EmptyLineMatchType],

8586 AtLeastN[

8587 Union[

8588 EmptyLineMatchType,

8589 DoNotCareSentinel,

8590 OneOf[EmptyLineMatchType],

8591 AllOf[EmptyLineMatchType],

8592 ]

8593 ],

8594 AtMostN[

8595 Union[

8596 EmptyLineMatchType,

8597 DoNotCareSentinel,

8598 OneOf[EmptyLineMatchType],

8599 AllOf[EmptyLineMatchType],

8600 ]

8601 ],

8602 ]

8603 ],

8604 DoNotCareSentinel,

8605 MatchIfTrue[Sequence[cst.EmptyLine]],

8606 OneOf[

8607 Union[

8608 Sequence[

8609 Union[

8610 EmptyLineMatchType,

8611 OneOf[EmptyLineMatchType],

8612 AllOf[EmptyLineMatchType],

8613 AtLeastN[

8614 Union[

8615 EmptyLineMatchType,

8616 OneOf[EmptyLineMatchType],

8617 AllOf[EmptyLineMatchType],

8618 ]

8619 ],

8620 AtMostN[

8621 Union[

8622 EmptyLineMatchType,

8623 OneOf[EmptyLineMatchType],

8624 AllOf[EmptyLineMatchType],

8625 ]

8626 ],

8627 ]

8628 ],

8629 MatchIfTrue[Sequence[cst.EmptyLine]],

8630 ]

8631 ],

8632 AllOf[

8633 Union[

8634 Sequence[

8635 Union[

8636 EmptyLineMatchType,

8637 OneOf[EmptyLineMatchType],

8638 AllOf[EmptyLineMatchType],

8639 AtLeastN[

8640 Union[

8641 EmptyLineMatchType,

8642 OneOf[EmptyLineMatchType],

8643 AllOf[EmptyLineMatchType],

8644 ]

8645 ],

8646 AtMostN[

8647 Union[

8648 EmptyLineMatchType,

8649 OneOf[EmptyLineMatchType],

8650 AllOf[EmptyLineMatchType],

8651 ]

8652 ],

8653 ]

8654 ],

8655 MatchIfTrue[Sequence[cst.EmptyLine]],

8656 ]

8657 ],

8658 ] = DoNotCare()

8659 whitespace_after_match: Union[

8660 SimpleWhitespaceMatchType,

8661 DoNotCareSentinel,

8662 OneOf[SimpleWhitespaceMatchType],

8663 AllOf[SimpleWhitespaceMatchType],

8664 ] = DoNotCare()

8665 whitespace_before_colon: Union[

8666 SimpleWhitespaceMatchType,

8667 DoNotCareSentinel,

8668 OneOf[SimpleWhitespaceMatchType],

8669 AllOf[SimpleWhitespaceMatchType],

8670 ] = DoNotCare()

8671 whitespace_after_colon: Union[

8672 TrailingWhitespaceMatchType,

8673 DoNotCareSentinel,

8674 OneOf[TrailingWhitespaceMatchType],

8675 AllOf[TrailingWhitespaceMatchType],

8676 ] = DoNotCare()

8677 indent: Union[

8678 Optional[str],

8679 MetadataMatchType,

8680 MatchIfTrue[Optional[str]],

8681 DoNotCareSentinel,

8682 OneOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

8683 AllOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

8684 ] = DoNotCare()

8685 footer: Union[

8686 Sequence[

8687 Union[

8688 EmptyLineMatchType,

8689 DoNotCareSentinel,

8690 OneOf[EmptyLineMatchType],

8691 AllOf[EmptyLineMatchType],

8692 AtLeastN[

8693 Union[

8694 EmptyLineMatchType,

8695 DoNotCareSentinel,

8696 OneOf[EmptyLineMatchType],

8697 AllOf[EmptyLineMatchType],

8698 ]

8699 ],

8700 AtMostN[

8701 Union[

8702 EmptyLineMatchType,

8703 DoNotCareSentinel,

8704 OneOf[EmptyLineMatchType],

8705 AllOf[EmptyLineMatchType],

8706 ]

8707 ],

8708 ]

8709 ],

8710 DoNotCareSentinel,

8711 MatchIfTrue[Sequence[cst.EmptyLine]],

8712 OneOf[

8713 Union[

8714 Sequence[

8715 Union[

8716 EmptyLineMatchType,

8717 OneOf[EmptyLineMatchType],

8718 AllOf[EmptyLineMatchType],

8719 AtLeastN[

8720 Union[

8721 EmptyLineMatchType,

8722 OneOf[EmptyLineMatchType],

8723 AllOf[EmptyLineMatchType],

8724 ]

8725 ],

8726 AtMostN[

8727 Union[

8728 EmptyLineMatchType,

8729 OneOf[EmptyLineMatchType],

8730 AllOf[EmptyLineMatchType],

8731 ]

8732 ],

8733 ]

8734 ],

8735 MatchIfTrue[Sequence[cst.EmptyLine]],

8736 ]

8737 ],

8738 AllOf[

8739 Union[

8740 Sequence[

8741 Union[

8742 EmptyLineMatchType,

8743 OneOf[EmptyLineMatchType],

8744 AllOf[EmptyLineMatchType],

8745 AtLeastN[

8746 Union[

8747 EmptyLineMatchType,

8748 OneOf[EmptyLineMatchType],

8749 AllOf[EmptyLineMatchType],

8750 ]

8751 ],

8752 AtMostN[

8753 Union[

8754 EmptyLineMatchType,

8755 OneOf[EmptyLineMatchType],

8756 AllOf[EmptyLineMatchType],

8757 ]

8758 ],

8759 ]

8760 ],

8761 MatchIfTrue[Sequence[cst.EmptyLine]],

8762 ]

8763 ],

8764 ] = DoNotCare()

8765 metadata: Union[

8766 MetadataMatchType,

8767 DoNotCareSentinel,

8768 OneOf[MetadataMatchType],

8769 AllOf[MetadataMatchType],

8770 ] = DoNotCare()

8771

8772

8773@dataclass(frozen=True, eq=False, unsafe_hash=False)

8774class MatchAs(BaseMatcherNode):

8775 pattern: Union[

8776 Optional["MatchPattern"],

8777 MetadataMatchType,

8778 MatchIfTrue[Optional[cst.MatchPattern]],

8779 DoNotCareSentinel,

8780 OneOf[

8781 Union[

8782 Optional["MatchPattern"],

8783 MetadataMatchType,

8784 MatchIfTrue[Optional[cst.MatchPattern]],

8785 ]

8786 ],

8787 AllOf[

8788 Union[

8789 Optional["MatchPattern"],

8790 MetadataMatchType,

8791 MatchIfTrue[Optional[cst.MatchPattern]],

8792 ]

8793 ],

8794 ] = DoNotCare()

8795 name: Union[

8796 Optional["Name"],

8797 MetadataMatchType,

8798 MatchIfTrue[Optional[cst.Name]],

8799 DoNotCareSentinel,

8800 OneOf[

8801 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

8802 ],

8803 AllOf[

8804 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

8805 ],

8806 ] = DoNotCare()

8807 whitespace_before_as: Union[

8808 BaseParenthesizableWhitespaceMatchType,

8809 DoNotCareSentinel,

8810 OneOf[BaseParenthesizableWhitespaceMatchType],

8811 AllOf[BaseParenthesizableWhitespaceMatchType],

8812 ] = DoNotCare()

8813 whitespace_after_as: Union[

8814 BaseParenthesizableWhitespaceMatchType,

8815 DoNotCareSentinel,

8816 OneOf[BaseParenthesizableWhitespaceMatchType],

8817 AllOf[BaseParenthesizableWhitespaceMatchType],

8818 ] = DoNotCare()

8819 lpar: Union[

8820 Sequence[

8821 Union[

8822 LeftParenMatchType,

8823 DoNotCareSentinel,

8824 OneOf[LeftParenMatchType],

8825 AllOf[LeftParenMatchType],

8826 AtLeastN[

8827 Union[

8828 LeftParenMatchType,

8829 DoNotCareSentinel,

8830 OneOf[LeftParenMatchType],

8831 AllOf[LeftParenMatchType],

8832 ]

8833 ],

8834 AtMostN[

8835 Union[

8836 LeftParenMatchType,

8837 DoNotCareSentinel,

8838 OneOf[LeftParenMatchType],

8839 AllOf[LeftParenMatchType],

8840 ]

8841 ],

8842 ]

8843 ],

8844 DoNotCareSentinel,

8845 MatchIfTrue[Sequence[cst.LeftParen]],

8846 OneOf[

8847 Union[

8848 Sequence[

8849 Union[

8850 LeftParenMatchType,

8851 OneOf[LeftParenMatchType],

8852 AllOf[LeftParenMatchType],

8853 AtLeastN[

8854 Union[

8855 LeftParenMatchType,

8856 OneOf[LeftParenMatchType],

8857 AllOf[LeftParenMatchType],

8858 ]

8859 ],

8860 AtMostN[

8861 Union[

8862 LeftParenMatchType,

8863 OneOf[LeftParenMatchType],

8864 AllOf[LeftParenMatchType],

8865 ]

8866 ],

8867 ]

8868 ],

8869 MatchIfTrue[Sequence[cst.LeftParen]],

8870 ]

8871 ],

8872 AllOf[

8873 Union[

8874 Sequence[

8875 Union[

8876 LeftParenMatchType,

8877 OneOf[LeftParenMatchType],

8878 AllOf[LeftParenMatchType],

8879 AtLeastN[

8880 Union[

8881 LeftParenMatchType,

8882 OneOf[LeftParenMatchType],

8883 AllOf[LeftParenMatchType],

8884 ]

8885 ],

8886 AtMostN[

8887 Union[

8888 LeftParenMatchType,

8889 OneOf[LeftParenMatchType],

8890 AllOf[LeftParenMatchType],

8891 ]

8892 ],

8893 ]

8894 ],

8895 MatchIfTrue[Sequence[cst.LeftParen]],

8896 ]

8897 ],

8898 ] = DoNotCare()

8899 rpar: Union[

8900 Sequence[

8901 Union[

8902 RightParenMatchType,

8903 DoNotCareSentinel,

8904 OneOf[RightParenMatchType],

8905 AllOf[RightParenMatchType],

8906 AtLeastN[

8907 Union[

8908 RightParenMatchType,

8909 DoNotCareSentinel,

8910 OneOf[RightParenMatchType],

8911 AllOf[RightParenMatchType],

8912 ]

8913 ],

8914 AtMostN[

8915 Union[

8916 RightParenMatchType,

8917 DoNotCareSentinel,

8918 OneOf[RightParenMatchType],

8919 AllOf[RightParenMatchType],

8920 ]

8921 ],

8922 ]

8923 ],

8924 DoNotCareSentinel,

8925 MatchIfTrue[Sequence[cst.RightParen]],

8926 OneOf[

8927 Union[

8928 Sequence[

8929 Union[

8930 RightParenMatchType,

8931 OneOf[RightParenMatchType],

8932 AllOf[RightParenMatchType],

8933 AtLeastN[

8934 Union[

8935 RightParenMatchType,

8936 OneOf[RightParenMatchType],

8937 AllOf[RightParenMatchType],

8938 ]

8939 ],

8940 AtMostN[

8941 Union[

8942 RightParenMatchType,

8943 OneOf[RightParenMatchType],

8944 AllOf[RightParenMatchType],

8945 ]

8946 ],

8947 ]

8948 ],

8949 MatchIfTrue[Sequence[cst.RightParen]],

8950 ]

8951 ],

8952 AllOf[

8953 Union[

8954 Sequence[

8955 Union[

8956 RightParenMatchType,

8957 OneOf[RightParenMatchType],

8958 AllOf[RightParenMatchType],

8959 AtLeastN[

8960 Union[

8961 RightParenMatchType,

8962 OneOf[RightParenMatchType],

8963 AllOf[RightParenMatchType],

8964 ]

8965 ],

8966 AtMostN[

8967 Union[

8968 RightParenMatchType,

8969 OneOf[RightParenMatchType],

8970 AllOf[RightParenMatchType],

8971 ]

8972 ],

8973 ]

8974 ],

8975 MatchIfTrue[Sequence[cst.RightParen]],

8976 ]

8977 ],

8978 ] = DoNotCare()

8979 metadata: Union[

8980 MetadataMatchType,

8981 DoNotCareSentinel,

8982 OneOf[MetadataMatchType],

8983 AllOf[MetadataMatchType],

8984 ] = DoNotCare()

8985

8986

8987MatchPatternMatchType = Union[

8988 "MatchPattern", MetadataMatchType, MatchIfTrue[cst.MatchPattern]

8989]

8990

8991

8992@dataclass(frozen=True, eq=False, unsafe_hash=False)

8993class MatchCase(BaseMatcherNode):

8994 pattern: Union[

8995 MatchPatternMatchType,

8996 DoNotCareSentinel,

8997 OneOf[MatchPatternMatchType],

8998 AllOf[MatchPatternMatchType],

8999 ] = DoNotCare()

9000 body: Union[

9001 BaseSuiteMatchType,

9002 DoNotCareSentinel,

9003 OneOf[BaseSuiteMatchType],

9004 AllOf[BaseSuiteMatchType],

9005 ] = DoNotCare()

9006 guard: Union[

9007 Optional["BaseExpression"],

9008 MetadataMatchType,

9009 MatchIfTrue[Optional[cst.BaseExpression]],

9010 DoNotCareSentinel,

9011 OneOf[

9012 Union[

9013 Optional["BaseExpression"],

9014 MetadataMatchType,

9015 MatchIfTrue[Optional[cst.BaseExpression]],

9016 ]

9017 ],

9018 AllOf[

9019 Union[

9020 Optional["BaseExpression"],

9021 MetadataMatchType,

9022 MatchIfTrue[Optional[cst.BaseExpression]],

9023 ]

9024 ],

9025 ] = DoNotCare()

9026 leading_lines: Union[

9027 Sequence[

9028 Union[

9029 EmptyLineMatchType,

9030 DoNotCareSentinel,

9031 OneOf[EmptyLineMatchType],

9032 AllOf[EmptyLineMatchType],

9033 AtLeastN[

9034 Union[

9035 EmptyLineMatchType,

9036 DoNotCareSentinel,

9037 OneOf[EmptyLineMatchType],

9038 AllOf[EmptyLineMatchType],

9039 ]

9040 ],

9041 AtMostN[

9042 Union[

9043 EmptyLineMatchType,

9044 DoNotCareSentinel,

9045 OneOf[EmptyLineMatchType],

9046 AllOf[EmptyLineMatchType],

9047 ]

9048 ],

9049 ]

9050 ],

9051 DoNotCareSentinel,

9052 MatchIfTrue[Sequence[cst.EmptyLine]],

9053 OneOf[

9054 Union[

9055 Sequence[

9056 Union[

9057 EmptyLineMatchType,

9058 OneOf[EmptyLineMatchType],

9059 AllOf[EmptyLineMatchType],

9060 AtLeastN[

9061 Union[

9062 EmptyLineMatchType,

9063 OneOf[EmptyLineMatchType],

9064 AllOf[EmptyLineMatchType],

9065 ]

9066 ],

9067 AtMostN[

9068 Union[

9069 EmptyLineMatchType,

9070 OneOf[EmptyLineMatchType],

9071 AllOf[EmptyLineMatchType],

9072 ]

9073 ],

9074 ]

9075 ],

9076 MatchIfTrue[Sequence[cst.EmptyLine]],

9077 ]

9078 ],

9079 AllOf[

9080 Union[

9081 Sequence[

9082 Union[

9083 EmptyLineMatchType,

9084 OneOf[EmptyLineMatchType],

9085 AllOf[EmptyLineMatchType],

9086 AtLeastN[

9087 Union[

9088 EmptyLineMatchType,

9089 OneOf[EmptyLineMatchType],

9090 AllOf[EmptyLineMatchType],

9091 ]

9092 ],

9093 AtMostN[

9094 Union[

9095 EmptyLineMatchType,

9096 OneOf[EmptyLineMatchType],

9097 AllOf[EmptyLineMatchType],

9098 ]

9099 ],

9100 ]

9101 ],

9102 MatchIfTrue[Sequence[cst.EmptyLine]],

9103 ]

9104 ],

9105 ] = DoNotCare()

9106 whitespace_after_case: Union[

9107 SimpleWhitespaceMatchType,

9108 DoNotCareSentinel,

9109 OneOf[SimpleWhitespaceMatchType],

9110 AllOf[SimpleWhitespaceMatchType],

9111 ] = DoNotCare()

9112 whitespace_before_if: Union[

9113 SimpleWhitespaceMatchType,

9114 DoNotCareSentinel,

9115 OneOf[SimpleWhitespaceMatchType],

9116 AllOf[SimpleWhitespaceMatchType],

9117 ] = DoNotCare()

9118 whitespace_after_if: Union[

9119 SimpleWhitespaceMatchType,

9120 DoNotCareSentinel,

9121 OneOf[SimpleWhitespaceMatchType],

9122 AllOf[SimpleWhitespaceMatchType],

9123 ] = DoNotCare()

9124 whitespace_before_colon: Union[

9125 SimpleWhitespaceMatchType,

9126 DoNotCareSentinel,

9127 OneOf[SimpleWhitespaceMatchType],

9128 AllOf[SimpleWhitespaceMatchType],

9129 ] = DoNotCare()

9130 metadata: Union[

9131 MetadataMatchType,

9132 DoNotCareSentinel,

9133 OneOf[MetadataMatchType],

9134 AllOf[MetadataMatchType],

9135 ] = DoNotCare()

9136

9137

9138MatchSequenceElementMatchType = Union[

9139 "MatchSequenceElement", MetadataMatchType, MatchIfTrue[cst.MatchSequenceElement]

9140]

9141MatchKeywordElementMatchType = Union[

9142 "MatchKeywordElement", MetadataMatchType, MatchIfTrue[cst.MatchKeywordElement]

9143]

9144

9145

9146@dataclass(frozen=True, eq=False, unsafe_hash=False)

9147class MatchClass(BaseMatcherNode):

9148 cls: Union[

9149 BaseExpressionMatchType,

9150 DoNotCareSentinel,

9151 OneOf[BaseExpressionMatchType],

9152 AllOf[BaseExpressionMatchType],

9153 ] = DoNotCare()

9154 patterns: Union[

9155 Sequence[

9156 Union[

9157 MatchSequenceElementMatchType,

9158 DoNotCareSentinel,

9159 OneOf[MatchSequenceElementMatchType],

9160 AllOf[MatchSequenceElementMatchType],

9161 AtLeastN[

9162 Union[

9163 MatchSequenceElementMatchType,

9164 DoNotCareSentinel,

9165 OneOf[MatchSequenceElementMatchType],

9166 AllOf[MatchSequenceElementMatchType],

9167 ]

9168 ],

9169 AtMostN[

9170 Union[

9171 MatchSequenceElementMatchType,

9172 DoNotCareSentinel,

9173 OneOf[MatchSequenceElementMatchType],

9174 AllOf[MatchSequenceElementMatchType],

9175 ]

9176 ],

9177 ]

9178 ],

9179 DoNotCareSentinel,

9180 MatchIfTrue[Sequence[cst.MatchSequenceElement]],

9181 OneOf[

9182 Union[

9183 Sequence[

9184 Union[

9185 MatchSequenceElementMatchType,

9186 OneOf[MatchSequenceElementMatchType],

9187 AllOf[MatchSequenceElementMatchType],

9188 AtLeastN[

9189 Union[

9190 MatchSequenceElementMatchType,

9191 OneOf[MatchSequenceElementMatchType],

9192 AllOf[MatchSequenceElementMatchType],

9193 ]

9194 ],

9195 AtMostN[

9196 Union[

9197 MatchSequenceElementMatchType,

9198 OneOf[MatchSequenceElementMatchType],

9199 AllOf[MatchSequenceElementMatchType],

9200 ]

9201 ],

9202 ]

9203 ],

9204 MatchIfTrue[Sequence[cst.MatchSequenceElement]],

9205 ]

9206 ],

9207 AllOf[

9208 Union[

9209 Sequence[

9210 Union[

9211 MatchSequenceElementMatchType,

9212 OneOf[MatchSequenceElementMatchType],

9213 AllOf[MatchSequenceElementMatchType],

9214 AtLeastN[

9215 Union[

9216 MatchSequenceElementMatchType,

9217 OneOf[MatchSequenceElementMatchType],

9218 AllOf[MatchSequenceElementMatchType],

9219 ]

9220 ],

9221 AtMostN[

9222 Union[

9223 MatchSequenceElementMatchType,

9224 OneOf[MatchSequenceElementMatchType],

9225 AllOf[MatchSequenceElementMatchType],

9226 ]

9227 ],

9228 ]

9229 ],

9230 MatchIfTrue[Sequence[cst.MatchSequenceElement]],

9231 ]

9232 ],

9233 ] = DoNotCare()

9234 kwds: Union[

9235 Sequence[

9236 Union[

9237 MatchKeywordElementMatchType,

9238 DoNotCareSentinel,

9239 OneOf[MatchKeywordElementMatchType],

9240 AllOf[MatchKeywordElementMatchType],

9241 AtLeastN[

9242 Union[

9243 MatchKeywordElementMatchType,

9244 DoNotCareSentinel,

9245 OneOf[MatchKeywordElementMatchType],

9246 AllOf[MatchKeywordElementMatchType],

9247 ]

9248 ],

9249 AtMostN[

9250 Union[

9251 MatchKeywordElementMatchType,

9252 DoNotCareSentinel,

9253 OneOf[MatchKeywordElementMatchType],

9254 AllOf[MatchKeywordElementMatchType],

9255 ]

9256 ],

9257 ]

9258 ],

9259 DoNotCareSentinel,

9260 MatchIfTrue[Sequence[cst.MatchKeywordElement]],

9261 OneOf[

9262 Union[

9263 Sequence[

9264 Union[

9265 MatchKeywordElementMatchType,

9266 OneOf[MatchKeywordElementMatchType],

9267 AllOf[MatchKeywordElementMatchType],

9268 AtLeastN[

9269 Union[

9270 MatchKeywordElementMatchType,

9271 OneOf[MatchKeywordElementMatchType],

9272 AllOf[MatchKeywordElementMatchType],

9273 ]

9274 ],

9275 AtMostN[

9276 Union[

9277 MatchKeywordElementMatchType,

9278 OneOf[MatchKeywordElementMatchType],

9279 AllOf[MatchKeywordElementMatchType],

9280 ]

9281 ],

9282 ]

9283 ],

9284 MatchIfTrue[Sequence[cst.MatchKeywordElement]],

9285 ]

9286 ],

9287 AllOf[

9288 Union[

9289 Sequence[

9290 Union[

9291 MatchKeywordElementMatchType,

9292 OneOf[MatchKeywordElementMatchType],

9293 AllOf[MatchKeywordElementMatchType],

9294 AtLeastN[

9295 Union[

9296 MatchKeywordElementMatchType,

9297 OneOf[MatchKeywordElementMatchType],

9298 AllOf[MatchKeywordElementMatchType],

9299 ]

9300 ],

9301 AtMostN[

9302 Union[

9303 MatchKeywordElementMatchType,

9304 OneOf[MatchKeywordElementMatchType],

9305 AllOf[MatchKeywordElementMatchType],

9306 ]

9307 ],

9308 ]

9309 ],

9310 MatchIfTrue[Sequence[cst.MatchKeywordElement]],

9311 ]

9312 ],

9313 ] = DoNotCare()

9314 whitespace_after_cls: Union[

9315 BaseParenthesizableWhitespaceMatchType,

9316 DoNotCareSentinel,

9317 OneOf[BaseParenthesizableWhitespaceMatchType],

9318 AllOf[BaseParenthesizableWhitespaceMatchType],

9319 ] = DoNotCare()

9320 whitespace_before_patterns: Union[

9321 BaseParenthesizableWhitespaceMatchType,

9322 DoNotCareSentinel,

9323 OneOf[BaseParenthesizableWhitespaceMatchType],

9324 AllOf[BaseParenthesizableWhitespaceMatchType],

9325 ] = DoNotCare()

9326 whitespace_after_kwds: Union[

9327 BaseParenthesizableWhitespaceMatchType,

9328 DoNotCareSentinel,

9329 OneOf[BaseParenthesizableWhitespaceMatchType],

9330 AllOf[BaseParenthesizableWhitespaceMatchType],

9331 ] = DoNotCare()

9332 lpar: Union[

9333 Sequence[

9334 Union[

9335 LeftParenMatchType,

9336 DoNotCareSentinel,

9337 OneOf[LeftParenMatchType],

9338 AllOf[LeftParenMatchType],

9339 AtLeastN[

9340 Union[

9341 LeftParenMatchType,

9342 DoNotCareSentinel,

9343 OneOf[LeftParenMatchType],

9344 AllOf[LeftParenMatchType],

9345 ]

9346 ],

9347 AtMostN[

9348 Union[

9349 LeftParenMatchType,

9350 DoNotCareSentinel,

9351 OneOf[LeftParenMatchType],

9352 AllOf[LeftParenMatchType],

9353 ]

9354 ],

9355 ]

9356 ],

9357 DoNotCareSentinel,

9358 MatchIfTrue[Sequence[cst.LeftParen]],

9359 OneOf[

9360 Union[

9361 Sequence[

9362 Union[

9363 LeftParenMatchType,

9364 OneOf[LeftParenMatchType],

9365 AllOf[LeftParenMatchType],

9366 AtLeastN[

9367 Union[

9368 LeftParenMatchType,

9369 OneOf[LeftParenMatchType],

9370 AllOf[LeftParenMatchType],

9371 ]

9372 ],

9373 AtMostN[

9374 Union[

9375 LeftParenMatchType,

9376 OneOf[LeftParenMatchType],

9377 AllOf[LeftParenMatchType],

9378 ]

9379 ],

9380 ]

9381 ],

9382 MatchIfTrue[Sequence[cst.LeftParen]],

9383 ]

9384 ],

9385 AllOf[

9386 Union[

9387 Sequence[

9388 Union[

9389 LeftParenMatchType,

9390 OneOf[LeftParenMatchType],

9391 AllOf[LeftParenMatchType],

9392 AtLeastN[

9393 Union[

9394 LeftParenMatchType,

9395 OneOf[LeftParenMatchType],

9396 AllOf[LeftParenMatchType],

9397 ]

9398 ],

9399 AtMostN[

9400 Union[

9401 LeftParenMatchType,

9402 OneOf[LeftParenMatchType],

9403 AllOf[LeftParenMatchType],

9404 ]

9405 ],

9406 ]

9407 ],

9408 MatchIfTrue[Sequence[cst.LeftParen]],

9409 ]

9410 ],

9411 ] = DoNotCare()

9412 rpar: Union[

9413 Sequence[

9414 Union[

9415 RightParenMatchType,

9416 DoNotCareSentinel,

9417 OneOf[RightParenMatchType],

9418 AllOf[RightParenMatchType],

9419 AtLeastN[

9420 Union[

9421 RightParenMatchType,

9422 DoNotCareSentinel,

9423 OneOf[RightParenMatchType],

9424 AllOf[RightParenMatchType],

9425 ]

9426 ],

9427 AtMostN[

9428 Union[

9429 RightParenMatchType,

9430 DoNotCareSentinel,

9431 OneOf[RightParenMatchType],

9432 AllOf[RightParenMatchType],

9433 ]

9434 ],

9435 ]

9436 ],

9437 DoNotCareSentinel,

9438 MatchIfTrue[Sequence[cst.RightParen]],

9439 OneOf[

9440 Union[

9441 Sequence[

9442 Union[

9443 RightParenMatchType,

9444 OneOf[RightParenMatchType],

9445 AllOf[RightParenMatchType],

9446 AtLeastN[

9447 Union[

9448 RightParenMatchType,

9449 OneOf[RightParenMatchType],

9450 AllOf[RightParenMatchType],

9451 ]

9452 ],

9453 AtMostN[

9454 Union[

9455 RightParenMatchType,

9456 OneOf[RightParenMatchType],

9457 AllOf[RightParenMatchType],

9458 ]

9459 ],

9460 ]

9461 ],

9462 MatchIfTrue[Sequence[cst.RightParen]],

9463 ]

9464 ],

9465 AllOf[

9466 Union[

9467 Sequence[

9468 Union[

9469 RightParenMatchType,

9470 OneOf[RightParenMatchType],

9471 AllOf[RightParenMatchType],

9472 AtLeastN[

9473 Union[

9474 RightParenMatchType,

9475 OneOf[RightParenMatchType],

9476 AllOf[RightParenMatchType],

9477 ]

9478 ],

9479 AtMostN[

9480 Union[

9481 RightParenMatchType,

9482 OneOf[RightParenMatchType],

9483 AllOf[RightParenMatchType],

9484 ]

9485 ],

9486 ]

9487 ],

9488 MatchIfTrue[Sequence[cst.RightParen]],

9489 ]

9490 ],

9491 ] = DoNotCare()

9492 metadata: Union[

9493 MetadataMatchType,

9494 DoNotCareSentinel,

9495 OneOf[MetadataMatchType],

9496 AllOf[MetadataMatchType],

9497 ] = DoNotCare()

9498

9499

9500@dataclass(frozen=True, eq=False, unsafe_hash=False)

9501class MatchKeywordElement(BaseMatcherNode):

9502 key: Union[

9503 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

9504 ] = DoNotCare()

9505 pattern: Union[

9506 MatchPatternMatchType,

9507 DoNotCareSentinel,

9508 OneOf[MatchPatternMatchType],

9509 AllOf[MatchPatternMatchType],

9510 ] = DoNotCare()

9511 comma: Union[

9512 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

9513 ] = DoNotCare()

9514 whitespace_before_equal: Union[

9515 BaseParenthesizableWhitespaceMatchType,

9516 DoNotCareSentinel,

9517 OneOf[BaseParenthesizableWhitespaceMatchType],

9518 AllOf[BaseParenthesizableWhitespaceMatchType],

9519 ] = DoNotCare()

9520 whitespace_after_equal: Union[

9521 BaseParenthesizableWhitespaceMatchType,

9522 DoNotCareSentinel,

9523 OneOf[BaseParenthesizableWhitespaceMatchType],

9524 AllOf[BaseParenthesizableWhitespaceMatchType],

9525 ] = DoNotCare()

9526 metadata: Union[

9527 MetadataMatchType,

9528 DoNotCareSentinel,

9529 OneOf[MetadataMatchType],

9530 AllOf[MetadataMatchType],

9531 ] = DoNotCare()

9532

9533

9534MatchSequenceElementOrMatchStarMatchType = Union[

9535 "MatchSequenceElement",

9536 "MatchStar",

9537 MetadataMatchType,

9538 MatchIfTrue[Union[cst.MatchSequenceElement, cst.MatchStar]],

9539]

9540

9541

9542@dataclass(frozen=True, eq=False, unsafe_hash=False)

9543class MatchList(BaseMatcherNode):

9544 patterns: Union[

9545 Sequence[

9546 Union[

9547 MatchSequenceElementOrMatchStarMatchType,

9548 DoNotCareSentinel,

9549 OneOf[MatchSequenceElementOrMatchStarMatchType],

9550 AllOf[MatchSequenceElementOrMatchStarMatchType],

9551 AtLeastN[

9552 Union[

9553 MatchSequenceElementOrMatchStarMatchType,

9554 DoNotCareSentinel,

9555 OneOf[MatchSequenceElementOrMatchStarMatchType],

9556 AllOf[MatchSequenceElementOrMatchStarMatchType],

9557 ]

9558 ],

9559 AtMostN[

9560 Union[

9561 MatchSequenceElementOrMatchStarMatchType,

9562 DoNotCareSentinel,

9563 OneOf[MatchSequenceElementOrMatchStarMatchType],

9564 AllOf[MatchSequenceElementOrMatchStarMatchType],

9565 ]

9566 ],

9567 ]

9568 ],

9569 DoNotCareSentinel,

9570 MatchIfTrue[

9571 Sequence[

9572 Union[

9573 cst.MatchSequenceElement,

9574 cst.MatchStar,

9575 OneOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

9576 AllOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

9577 ]

9578 ]

9579 ],

9580 OneOf[

9581 Union[

9582 Sequence[

9583 Union[

9584 MatchSequenceElementOrMatchStarMatchType,

9585 OneOf[MatchSequenceElementOrMatchStarMatchType],

9586 AllOf[MatchSequenceElementOrMatchStarMatchType],

9587 AtLeastN[

9588 Union[

9589 MatchSequenceElementOrMatchStarMatchType,

9590 OneOf[MatchSequenceElementOrMatchStarMatchType],

9591 AllOf[MatchSequenceElementOrMatchStarMatchType],

9592 ]

9593 ],

9594 AtMostN[

9595 Union[

9596 MatchSequenceElementOrMatchStarMatchType,

9597 OneOf[MatchSequenceElementOrMatchStarMatchType],

9598 AllOf[MatchSequenceElementOrMatchStarMatchType],

9599 ]

9600 ],

9601 ]

9602 ],

9603 MatchIfTrue[

9604 Sequence[

9605 Union[

9606 cst.MatchSequenceElement,

9607 cst.MatchStar,

9608 OneOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

9609 AllOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

9610 ]

9611 ]

9612 ],

9613 ]

9614 ],

9615 AllOf[

9616 Union[

9617 Sequence[

9618 Union[

9619 MatchSequenceElementOrMatchStarMatchType,

9620 OneOf[MatchSequenceElementOrMatchStarMatchType],

9621 AllOf[MatchSequenceElementOrMatchStarMatchType],

9622 AtLeastN[

9623 Union[

9624 MatchSequenceElementOrMatchStarMatchType,

9625 OneOf[MatchSequenceElementOrMatchStarMatchType],

9626 AllOf[MatchSequenceElementOrMatchStarMatchType],

9627 ]

9628 ],

9629 AtMostN[

9630 Union[

9631 MatchSequenceElementOrMatchStarMatchType,

9632 OneOf[MatchSequenceElementOrMatchStarMatchType],

9633 AllOf[MatchSequenceElementOrMatchStarMatchType],

9634 ]

9635 ],

9636 ]

9637 ],

9638 MatchIfTrue[

9639 Sequence[

9640 Union[

9641 cst.MatchSequenceElement,

9642 cst.MatchStar,

9643 OneOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

9644 AllOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

9645 ]

9646 ]

9647 ],

9648 ]

9649 ],

9650 ] = DoNotCare()

9651 lbracket: Union[

9652 Optional["LeftSquareBracket"],

9653 MetadataMatchType,

9654 MatchIfTrue[Optional[cst.LeftSquareBracket]],

9655 DoNotCareSentinel,

9656 OneOf[

9657 Union[

9658 Optional["LeftSquareBracket"],

9659 MetadataMatchType,

9660 MatchIfTrue[Optional[cst.LeftSquareBracket]],

9661 ]

9662 ],

9663 AllOf[

9664 Union[

9665 Optional["LeftSquareBracket"],

9666 MetadataMatchType,

9667 MatchIfTrue[Optional[cst.LeftSquareBracket]],

9668 ]

9669 ],

9670 ] = DoNotCare()

9671 rbracket: Union[

9672 Optional["RightSquareBracket"],

9673 MetadataMatchType,

9674 MatchIfTrue[Optional[cst.RightSquareBracket]],

9675 DoNotCareSentinel,

9676 OneOf[

9677 Union[

9678 Optional["RightSquareBracket"],

9679 MetadataMatchType,

9680 MatchIfTrue[Optional[cst.RightSquareBracket]],

9681 ]

9682 ],

9683 AllOf[

9684 Union[

9685 Optional["RightSquareBracket"],

9686 MetadataMatchType,

9687 MatchIfTrue[Optional[cst.RightSquareBracket]],

9688 ]

9689 ],

9690 ] = DoNotCare()

9691 lpar: Union[

9692 Sequence[

9693 Union[

9694 LeftParenMatchType,

9695 DoNotCareSentinel,

9696 OneOf[LeftParenMatchType],

9697 AllOf[LeftParenMatchType],

9698 AtLeastN[

9699 Union[

9700 LeftParenMatchType,

9701 DoNotCareSentinel,

9702 OneOf[LeftParenMatchType],

9703 AllOf[LeftParenMatchType],

9704 ]

9705 ],

9706 AtMostN[

9707 Union[

9708 LeftParenMatchType,

9709 DoNotCareSentinel,

9710 OneOf[LeftParenMatchType],

9711 AllOf[LeftParenMatchType],

9712 ]

9713 ],

9714 ]

9715 ],

9716 DoNotCareSentinel,

9717 MatchIfTrue[Sequence[cst.LeftParen]],

9718 OneOf[

9719 Union[

9720 Sequence[

9721 Union[

9722 LeftParenMatchType,

9723 OneOf[LeftParenMatchType],

9724 AllOf[LeftParenMatchType],

9725 AtLeastN[

9726 Union[

9727 LeftParenMatchType,

9728 OneOf[LeftParenMatchType],

9729 AllOf[LeftParenMatchType],

9730 ]

9731 ],

9732 AtMostN[

9733 Union[

9734 LeftParenMatchType,

9735 OneOf[LeftParenMatchType],

9736 AllOf[LeftParenMatchType],

9737 ]

9738 ],

9739 ]

9740 ],

9741 MatchIfTrue[Sequence[cst.LeftParen]],

9742 ]

9743 ],

9744 AllOf[

9745 Union[

9746 Sequence[

9747 Union[

9748 LeftParenMatchType,

9749 OneOf[LeftParenMatchType],

9750 AllOf[LeftParenMatchType],

9751 AtLeastN[

9752 Union[

9753 LeftParenMatchType,

9754 OneOf[LeftParenMatchType],

9755 AllOf[LeftParenMatchType],

9756 ]

9757 ],

9758 AtMostN[

9759 Union[

9760 LeftParenMatchType,

9761 OneOf[LeftParenMatchType],

9762 AllOf[LeftParenMatchType],

9763 ]

9764 ],

9765 ]

9766 ],

9767 MatchIfTrue[Sequence[cst.LeftParen]],

9768 ]

9769 ],

9770 ] = DoNotCare()

9771 rpar: Union[

9772 Sequence[

9773 Union[

9774 RightParenMatchType,

9775 DoNotCareSentinel,

9776 OneOf[RightParenMatchType],

9777 AllOf[RightParenMatchType],

9778 AtLeastN[

9779 Union[

9780 RightParenMatchType,

9781 DoNotCareSentinel,

9782 OneOf[RightParenMatchType],

9783 AllOf[RightParenMatchType],

9784 ]

9785 ],

9786 AtMostN[

9787 Union[

9788 RightParenMatchType,

9789 DoNotCareSentinel,

9790 OneOf[RightParenMatchType],

9791 AllOf[RightParenMatchType],

9792 ]

9793 ],

9794 ]

9795 ],

9796 DoNotCareSentinel,

9797 MatchIfTrue[Sequence[cst.RightParen]],

9798 OneOf[

9799 Union[

9800 Sequence[

9801 Union[

9802 RightParenMatchType,

9803 OneOf[RightParenMatchType],

9804 AllOf[RightParenMatchType],

9805 AtLeastN[

9806 Union[

9807 RightParenMatchType,

9808 OneOf[RightParenMatchType],

9809 AllOf[RightParenMatchType],

9810 ]

9811 ],

9812 AtMostN[

9813 Union[

9814 RightParenMatchType,

9815 OneOf[RightParenMatchType],

9816 AllOf[RightParenMatchType],

9817 ]

9818 ],

9819 ]

9820 ],

9821 MatchIfTrue[Sequence[cst.RightParen]],

9822 ]

9823 ],

9824 AllOf[

9825 Union[

9826 Sequence[

9827 Union[

9828 RightParenMatchType,

9829 OneOf[RightParenMatchType],

9830 AllOf[RightParenMatchType],

9831 AtLeastN[

9832 Union[

9833 RightParenMatchType,

9834 OneOf[RightParenMatchType],

9835 AllOf[RightParenMatchType],

9836 ]

9837 ],

9838 AtMostN[

9839 Union[

9840 RightParenMatchType,

9841 OneOf[RightParenMatchType],

9842 AllOf[RightParenMatchType],

9843 ]

9844 ],

9845 ]

9846 ],

9847 MatchIfTrue[Sequence[cst.RightParen]],

9848 ]

9849 ],

9850 ] = DoNotCare()

9851 metadata: Union[

9852 MetadataMatchType,

9853 DoNotCareSentinel,

9854 OneOf[MetadataMatchType],

9855 AllOf[MetadataMatchType],

9856 ] = DoNotCare()

9857

9858

9859MatchMappingElementMatchType = Union[

9860 "MatchMappingElement", MetadataMatchType, MatchIfTrue[cst.MatchMappingElement]

9861]

9862

9863

9864@dataclass(frozen=True, eq=False, unsafe_hash=False)

9865class MatchMapping(BaseMatcherNode):

9866 elements: Union[

9867 Sequence[

9868 Union[

9869 MatchMappingElementMatchType,

9870 DoNotCareSentinel,

9871 OneOf[MatchMappingElementMatchType],

9872 AllOf[MatchMappingElementMatchType],

9873 AtLeastN[

9874 Union[

9875 MatchMappingElementMatchType,

9876 DoNotCareSentinel,

9877 OneOf[MatchMappingElementMatchType],

9878 AllOf[MatchMappingElementMatchType],

9879 ]

9880 ],

9881 AtMostN[

9882 Union[

9883 MatchMappingElementMatchType,

9884 DoNotCareSentinel,

9885 OneOf[MatchMappingElementMatchType],

9886 AllOf[MatchMappingElementMatchType],

9887 ]

9888 ],

9889 ]

9890 ],

9891 DoNotCareSentinel,

9892 MatchIfTrue[Sequence[cst.MatchMappingElement]],

9893 OneOf[

9894 Union[

9895 Sequence[

9896 Union[

9897 MatchMappingElementMatchType,

9898 OneOf[MatchMappingElementMatchType],

9899 AllOf[MatchMappingElementMatchType],

9900 AtLeastN[

9901 Union[

9902 MatchMappingElementMatchType,

9903 OneOf[MatchMappingElementMatchType],

9904 AllOf[MatchMappingElementMatchType],

9905 ]

9906 ],

9907 AtMostN[

9908 Union[

9909 MatchMappingElementMatchType,

9910 OneOf[MatchMappingElementMatchType],

9911 AllOf[MatchMappingElementMatchType],

9912 ]

9913 ],

9914 ]

9915 ],

9916 MatchIfTrue[Sequence[cst.MatchMappingElement]],

9917 ]

9918 ],

9919 AllOf[

9920 Union[

9921 Sequence[

9922 Union[

9923 MatchMappingElementMatchType,

9924 OneOf[MatchMappingElementMatchType],

9925 AllOf[MatchMappingElementMatchType],

9926 AtLeastN[

9927 Union[

9928 MatchMappingElementMatchType,

9929 OneOf[MatchMappingElementMatchType],

9930 AllOf[MatchMappingElementMatchType],

9931 ]

9932 ],

9933 AtMostN[

9934 Union[

9935 MatchMappingElementMatchType,

9936 OneOf[MatchMappingElementMatchType],

9937 AllOf[MatchMappingElementMatchType],

9938 ]

9939 ],

9940 ]

9941 ],

9942 MatchIfTrue[Sequence[cst.MatchMappingElement]],

9943 ]

9944 ],

9945 ] = DoNotCare()

9946 lbrace: Union[

9947 LeftCurlyBraceMatchType,

9948 DoNotCareSentinel,

9949 OneOf[LeftCurlyBraceMatchType],

9950 AllOf[LeftCurlyBraceMatchType],

9951 ] = DoNotCare()

9952 rbrace: Union[

9953 RightCurlyBraceMatchType,

9954 DoNotCareSentinel,

9955 OneOf[RightCurlyBraceMatchType],

9956 AllOf[RightCurlyBraceMatchType],

9957 ] = DoNotCare()

9958 rest: Union[

9959 Optional["Name"],

9960 MetadataMatchType,

9961 MatchIfTrue[Optional[cst.Name]],

9962 DoNotCareSentinel,

9963 OneOf[

9964 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

9965 ],

9966 AllOf[

9967 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

9968 ],

9969 ] = DoNotCare()

9970 whitespace_before_rest: Union[

9971 SimpleWhitespaceMatchType,

9972 DoNotCareSentinel,

9973 OneOf[SimpleWhitespaceMatchType],

9974 AllOf[SimpleWhitespaceMatchType],

9975 ] = DoNotCare()

9976 trailing_comma: Union[

9977 Optional["Comma"],

9978 MetadataMatchType,

9979 MatchIfTrue[Optional[cst.Comma]],

9980 DoNotCareSentinel,

9981 OneOf[

9982 Union[

9983 Optional["Comma"], MetadataMatchType, MatchIfTrue[Optional[cst.Comma]]

9984 ]

9985 ],

9986 AllOf[

9987 Union[

9988 Optional["Comma"], MetadataMatchType, MatchIfTrue[Optional[cst.Comma]]

9989 ]

9990 ],

9991 ] = DoNotCare()

9992 lpar: Union[

9993 Sequence[

9994 Union[

9995 LeftParenMatchType,

9996 DoNotCareSentinel,

9997 OneOf[LeftParenMatchType],

9998 AllOf[LeftParenMatchType],

9999 AtLeastN[

10000 Union[

10001 LeftParenMatchType,

10002 DoNotCareSentinel,

10003 OneOf[LeftParenMatchType],

10004 AllOf[LeftParenMatchType],

10005 ]

10006 ],

10007 AtMostN[

10008 Union[

10009 LeftParenMatchType,

10010 DoNotCareSentinel,

10011 OneOf[LeftParenMatchType],

10012 AllOf[LeftParenMatchType],

10013 ]

10014 ],

10015 ]

10016 ],

10017 DoNotCareSentinel,

10018 MatchIfTrue[Sequence[cst.LeftParen]],

10019 OneOf[

10020 Union[

10021 Sequence[

10022 Union[

10023 LeftParenMatchType,

10024 OneOf[LeftParenMatchType],

10025 AllOf[LeftParenMatchType],

10026 AtLeastN[

10027 Union[

10028 LeftParenMatchType,

10029 OneOf[LeftParenMatchType],

10030 AllOf[LeftParenMatchType],

10031 ]

10032 ],

10033 AtMostN[

10034 Union[

10035 LeftParenMatchType,

10036 OneOf[LeftParenMatchType],

10037 AllOf[LeftParenMatchType],

10038 ]

10039 ],

10040 ]

10041 ],

10042 MatchIfTrue[Sequence[cst.LeftParen]],

10043 ]

10044 ],

10045 AllOf[

10046 Union[

10047 Sequence[

10048 Union[

10049 LeftParenMatchType,

10050 OneOf[LeftParenMatchType],

10051 AllOf[LeftParenMatchType],

10052 AtLeastN[

10053 Union[

10054 LeftParenMatchType,

10055 OneOf[LeftParenMatchType],

10056 AllOf[LeftParenMatchType],

10057 ]

10058 ],

10059 AtMostN[

10060 Union[

10061 LeftParenMatchType,

10062 OneOf[LeftParenMatchType],

10063 AllOf[LeftParenMatchType],

10064 ]

10065 ],

10066 ]

10067 ],

10068 MatchIfTrue[Sequence[cst.LeftParen]],

10069 ]

10070 ],

10071 ] = DoNotCare()

10072 rpar: Union[

10073 Sequence[

10074 Union[

10075 RightParenMatchType,

10076 DoNotCareSentinel,

10077 OneOf[RightParenMatchType],

10078 AllOf[RightParenMatchType],

10079 AtLeastN[

10080 Union[

10081 RightParenMatchType,

10082 DoNotCareSentinel,

10083 OneOf[RightParenMatchType],

10084 AllOf[RightParenMatchType],

10085 ]

10086 ],

10087 AtMostN[

10088 Union[

10089 RightParenMatchType,

10090 DoNotCareSentinel,

10091 OneOf[RightParenMatchType],

10092 AllOf[RightParenMatchType],

10093 ]

10094 ],

10095 ]

10096 ],

10097 DoNotCareSentinel,

10098 MatchIfTrue[Sequence[cst.RightParen]],

10099 OneOf[

10100 Union[

10101 Sequence[

10102 Union[

10103 RightParenMatchType,

10104 OneOf[RightParenMatchType],

10105 AllOf[RightParenMatchType],

10106 AtLeastN[

10107 Union[

10108 RightParenMatchType,

10109 OneOf[RightParenMatchType],

10110 AllOf[RightParenMatchType],

10111 ]

10112 ],

10113 AtMostN[

10114 Union[

10115 RightParenMatchType,

10116 OneOf[RightParenMatchType],

10117 AllOf[RightParenMatchType],

10118 ]

10119 ],

10120 ]

10121 ],

10122 MatchIfTrue[Sequence[cst.RightParen]],

10123 ]

10124 ],

10125 AllOf[

10126 Union[

10127 Sequence[

10128 Union[

10129 RightParenMatchType,

10130 OneOf[RightParenMatchType],

10131 AllOf[RightParenMatchType],

10132 AtLeastN[

10133 Union[

10134 RightParenMatchType,

10135 OneOf[RightParenMatchType],

10136 AllOf[RightParenMatchType],

10137 ]

10138 ],

10139 AtMostN[

10140 Union[

10141 RightParenMatchType,

10142 OneOf[RightParenMatchType],

10143 AllOf[RightParenMatchType],

10144 ]

10145 ],

10146 ]

10147 ],

10148 MatchIfTrue[Sequence[cst.RightParen]],

10149 ]

10150 ],

10151 ] = DoNotCare()

10152 metadata: Union[

10153 MetadataMatchType,

10154 DoNotCareSentinel,

10155 OneOf[MetadataMatchType],

10156 AllOf[MetadataMatchType],

10157 ] = DoNotCare()

10158

10159

10160@dataclass(frozen=True, eq=False, unsafe_hash=False)

10161class MatchMappingElement(BaseMatcherNode):

10162 key: Union[

10163 BaseExpressionMatchType,

10164 DoNotCareSentinel,

10165 OneOf[BaseExpressionMatchType],

10166 AllOf[BaseExpressionMatchType],

10167 ] = DoNotCare()

10168 pattern: Union[

10169 MatchPatternMatchType,

10170 DoNotCareSentinel,

10171 OneOf[MatchPatternMatchType],

10172 AllOf[MatchPatternMatchType],

10173 ] = DoNotCare()

10174 comma: Union[

10175 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

10176 ] = DoNotCare()

10177 whitespace_before_colon: Union[

10178 BaseParenthesizableWhitespaceMatchType,

10179 DoNotCareSentinel,

10180 OneOf[BaseParenthesizableWhitespaceMatchType],

10181 AllOf[BaseParenthesizableWhitespaceMatchType],

10182 ] = DoNotCare()

10183 whitespace_after_colon: Union[

10184 BaseParenthesizableWhitespaceMatchType,

10185 DoNotCareSentinel,

10186 OneOf[BaseParenthesizableWhitespaceMatchType],

10187 AllOf[BaseParenthesizableWhitespaceMatchType],

10188 ] = DoNotCare()

10189 metadata: Union[

10190 MetadataMatchType,

10191 DoNotCareSentinel,

10192 OneOf[MetadataMatchType],

10193 AllOf[MetadataMatchType],

10194 ] = DoNotCare()

10195

10196

10197MatchOrElementMatchType = Union[

10198 "MatchOrElement", MetadataMatchType, MatchIfTrue[cst.MatchOrElement]

10199]

10200

10201

10202@dataclass(frozen=True, eq=False, unsafe_hash=False)

10203class MatchOr(BaseMatcherNode):

10204 patterns: Union[

10205 Sequence[

10206 Union[

10207 MatchOrElementMatchType,

10208 DoNotCareSentinel,

10209 OneOf[MatchOrElementMatchType],

10210 AllOf[MatchOrElementMatchType],

10211 AtLeastN[

10212 Union[

10213 MatchOrElementMatchType,

10214 DoNotCareSentinel,

10215 OneOf[MatchOrElementMatchType],

10216 AllOf[MatchOrElementMatchType],

10217 ]

10218 ],

10219 AtMostN[

10220 Union[

10221 MatchOrElementMatchType,

10222 DoNotCareSentinel,

10223 OneOf[MatchOrElementMatchType],

10224 AllOf[MatchOrElementMatchType],

10225 ]

10226 ],

10227 ]

10228 ],

10229 DoNotCareSentinel,

10230 MatchIfTrue[Sequence[cst.MatchOrElement]],

10231 OneOf[

10232 Union[

10233 Sequence[

10234 Union[

10235 MatchOrElementMatchType,

10236 OneOf[MatchOrElementMatchType],

10237 AllOf[MatchOrElementMatchType],

10238 AtLeastN[

10239 Union[

10240 MatchOrElementMatchType,

10241 OneOf[MatchOrElementMatchType],

10242 AllOf[MatchOrElementMatchType],

10243 ]

10244 ],

10245 AtMostN[

10246 Union[

10247 MatchOrElementMatchType,

10248 OneOf[MatchOrElementMatchType],

10249 AllOf[MatchOrElementMatchType],

10250 ]

10251 ],

10252 ]

10253 ],

10254 MatchIfTrue[Sequence[cst.MatchOrElement]],

10255 ]

10256 ],

10257 AllOf[

10258 Union[

10259 Sequence[

10260 Union[

10261 MatchOrElementMatchType,

10262 OneOf[MatchOrElementMatchType],

10263 AllOf[MatchOrElementMatchType],

10264 AtLeastN[

10265 Union[

10266 MatchOrElementMatchType,

10267 OneOf[MatchOrElementMatchType],

10268 AllOf[MatchOrElementMatchType],

10269 ]

10270 ],

10271 AtMostN[

10272 Union[

10273 MatchOrElementMatchType,

10274 OneOf[MatchOrElementMatchType],

10275 AllOf[MatchOrElementMatchType],

10276 ]

10277 ],

10278 ]

10279 ],

10280 MatchIfTrue[Sequence[cst.MatchOrElement]],

10281 ]

10282 ],

10283 ] = DoNotCare()

10284 lpar: Union[

10285 Sequence[

10286 Union[

10287 LeftParenMatchType,

10288 DoNotCareSentinel,

10289 OneOf[LeftParenMatchType],

10290 AllOf[LeftParenMatchType],

10291 AtLeastN[

10292 Union[

10293 LeftParenMatchType,

10294 DoNotCareSentinel,

10295 OneOf[LeftParenMatchType],

10296 AllOf[LeftParenMatchType],

10297 ]

10298 ],

10299 AtMostN[

10300 Union[

10301 LeftParenMatchType,

10302 DoNotCareSentinel,

10303 OneOf[LeftParenMatchType],

10304 AllOf[LeftParenMatchType],

10305 ]

10306 ],

10307 ]

10308 ],

10309 DoNotCareSentinel,

10310 MatchIfTrue[Sequence[cst.LeftParen]],

10311 OneOf[

10312 Union[

10313 Sequence[

10314 Union[

10315 LeftParenMatchType,

10316 OneOf[LeftParenMatchType],

10317 AllOf[LeftParenMatchType],

10318 AtLeastN[

10319 Union[

10320 LeftParenMatchType,

10321 OneOf[LeftParenMatchType],

10322 AllOf[LeftParenMatchType],

10323 ]

10324 ],

10325 AtMostN[

10326 Union[

10327 LeftParenMatchType,

10328 OneOf[LeftParenMatchType],

10329 AllOf[LeftParenMatchType],

10330 ]

10331 ],

10332 ]

10333 ],

10334 MatchIfTrue[Sequence[cst.LeftParen]],

10335 ]

10336 ],

10337 AllOf[

10338 Union[

10339 Sequence[

10340 Union[

10341 LeftParenMatchType,

10342 OneOf[LeftParenMatchType],

10343 AllOf[LeftParenMatchType],

10344 AtLeastN[

10345 Union[

10346 LeftParenMatchType,

10347 OneOf[LeftParenMatchType],

10348 AllOf[LeftParenMatchType],

10349 ]

10350 ],

10351 AtMostN[

10352 Union[

10353 LeftParenMatchType,

10354 OneOf[LeftParenMatchType],

10355 AllOf[LeftParenMatchType],

10356 ]

10357 ],

10358 ]

10359 ],

10360 MatchIfTrue[Sequence[cst.LeftParen]],

10361 ]

10362 ],

10363 ] = DoNotCare()

10364 rpar: Union[

10365 Sequence[

10366 Union[

10367 RightParenMatchType,

10368 DoNotCareSentinel,

10369 OneOf[RightParenMatchType],

10370 AllOf[RightParenMatchType],

10371 AtLeastN[

10372 Union[

10373 RightParenMatchType,

10374 DoNotCareSentinel,

10375 OneOf[RightParenMatchType],

10376 AllOf[RightParenMatchType],

10377 ]

10378 ],

10379 AtMostN[

10380 Union[

10381 RightParenMatchType,

10382 DoNotCareSentinel,

10383 OneOf[RightParenMatchType],

10384 AllOf[RightParenMatchType],

10385 ]

10386 ],

10387 ]

10388 ],

10389 DoNotCareSentinel,

10390 MatchIfTrue[Sequence[cst.RightParen]],

10391 OneOf[

10392 Union[

10393 Sequence[

10394 Union[

10395 RightParenMatchType,

10396 OneOf[RightParenMatchType],

10397 AllOf[RightParenMatchType],

10398 AtLeastN[

10399 Union[

10400 RightParenMatchType,

10401 OneOf[RightParenMatchType],

10402 AllOf[RightParenMatchType],

10403 ]

10404 ],

10405 AtMostN[

10406 Union[

10407 RightParenMatchType,

10408 OneOf[RightParenMatchType],

10409 AllOf[RightParenMatchType],

10410 ]

10411 ],

10412 ]

10413 ],

10414 MatchIfTrue[Sequence[cst.RightParen]],

10415 ]

10416 ],

10417 AllOf[

10418 Union[

10419 Sequence[

10420 Union[

10421 RightParenMatchType,

10422 OneOf[RightParenMatchType],

10423 AllOf[RightParenMatchType],

10424 AtLeastN[

10425 Union[

10426 RightParenMatchType,

10427 OneOf[RightParenMatchType],

10428 AllOf[RightParenMatchType],

10429 ]

10430 ],

10431 AtMostN[

10432 Union[

10433 RightParenMatchType,

10434 OneOf[RightParenMatchType],

10435 AllOf[RightParenMatchType],

10436 ]

10437 ],

10438 ]

10439 ],

10440 MatchIfTrue[Sequence[cst.RightParen]],

10441 ]

10442 ],

10443 ] = DoNotCare()

10444 metadata: Union[

10445 MetadataMatchType,

10446 DoNotCareSentinel,

10447 OneOf[MetadataMatchType],

10448 AllOf[MetadataMatchType],

10449 ] = DoNotCare()

10450

10451

10452BitOrMatchType = Union["BitOr", MetadataMatchType, MatchIfTrue[cst.BitOr]]

10453

10454

10455@dataclass(frozen=True, eq=False, unsafe_hash=False)

10456class MatchOrElement(BaseMatcherNode):

10457 pattern: Union[

10458 MatchPatternMatchType,

10459 DoNotCareSentinel,

10460 OneOf[MatchPatternMatchType],

10461 AllOf[MatchPatternMatchType],

10462 ] = DoNotCare()

10463 separator: Union[

10464 BitOrMatchType, DoNotCareSentinel, OneOf[BitOrMatchType], AllOf[BitOrMatchType]

10465 ] = DoNotCare()

10466 metadata: Union[

10467 MetadataMatchType,

10468 DoNotCareSentinel,

10469 OneOf[MetadataMatchType],

10470 AllOf[MetadataMatchType],

10471 ] = DoNotCare()

10472

10473

10474@dataclass(frozen=True, eq=False, unsafe_hash=False)

10475class MatchPattern(BaseMatcherNode):

10476 metadata: Union[

10477 MetadataMatchType,

10478 DoNotCareSentinel,

10479 OneOf[MetadataMatchType],

10480 AllOf[MetadataMatchType],

10481 ] = DoNotCare()

10482

10483

10484@dataclass(frozen=True, eq=False, unsafe_hash=False)

10485class MatchSequence(BaseMatcherNode):

10486 metadata: Union[

10487 MetadataMatchType,

10488 DoNotCareSentinel,

10489 OneOf[MetadataMatchType],

10490 AllOf[MetadataMatchType],

10491 ] = DoNotCare()

10492

10493

10494@dataclass(frozen=True, eq=False, unsafe_hash=False)

10495class MatchSequenceElement(BaseMatcherNode):

10496 value: Union[

10497 MatchPatternMatchType,

10498 DoNotCareSentinel,

10499 OneOf[MatchPatternMatchType],

10500 AllOf[MatchPatternMatchType],

10501 ] = DoNotCare()

10502 comma: Union[

10503 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

10504 ] = DoNotCare()

10505 metadata: Union[

10506 MetadataMatchType,

10507 DoNotCareSentinel,

10508 OneOf[MetadataMatchType],

10509 AllOf[MetadataMatchType],

10510 ] = DoNotCare()

10511

10512

10513@dataclass(frozen=True, eq=False, unsafe_hash=False)

10514class MatchSingleton(BaseMatcherNode):

10515 value: Union[

10516 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

10517 ] = DoNotCare()

10518 metadata: Union[

10519 MetadataMatchType,

10520 DoNotCareSentinel,

10521 OneOf[MetadataMatchType],

10522 AllOf[MetadataMatchType],

10523 ] = DoNotCare()

10524

10525

10526@dataclass(frozen=True, eq=False, unsafe_hash=False)

10527class MatchStar(BaseMatcherNode):

10528 name: Union[

10529 Optional["Name"],

10530 MetadataMatchType,

10531 MatchIfTrue[Optional[cst.Name]],

10532 DoNotCareSentinel,

10533 OneOf[

10534 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

10535 ],

10536 AllOf[

10537 Union[Optional["Name"], MetadataMatchType, MatchIfTrue[Optional[cst.Name]]]

10538 ],

10539 ] = DoNotCare()

10540 comma: Union[

10541 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

10542 ] = DoNotCare()

10543 whitespace_before_name: Union[

10544 BaseParenthesizableWhitespaceMatchType,

10545 DoNotCareSentinel,

10546 OneOf[BaseParenthesizableWhitespaceMatchType],

10547 AllOf[BaseParenthesizableWhitespaceMatchType],

10548 ] = DoNotCare()

10549 metadata: Union[

10550 MetadataMatchType,

10551 DoNotCareSentinel,

10552 OneOf[MetadataMatchType],

10553 AllOf[MetadataMatchType],

10554 ] = DoNotCare()

10555

10556

10557@dataclass(frozen=True, eq=False, unsafe_hash=False)

10558class MatchTuple(BaseMatcherNode):

10559 patterns: Union[

10560 Sequence[

10561 Union[

10562 MatchSequenceElementOrMatchStarMatchType,

10563 DoNotCareSentinel,

10564 OneOf[MatchSequenceElementOrMatchStarMatchType],

10565 AllOf[MatchSequenceElementOrMatchStarMatchType],

10566 AtLeastN[

10567 Union[

10568 MatchSequenceElementOrMatchStarMatchType,

10569 DoNotCareSentinel,

10570 OneOf[MatchSequenceElementOrMatchStarMatchType],

10571 AllOf[MatchSequenceElementOrMatchStarMatchType],

10572 ]

10573 ],

10574 AtMostN[

10575 Union[

10576 MatchSequenceElementOrMatchStarMatchType,

10577 DoNotCareSentinel,

10578 OneOf[MatchSequenceElementOrMatchStarMatchType],

10579 AllOf[MatchSequenceElementOrMatchStarMatchType],

10580 ]

10581 ],

10582 ]

10583 ],

10584 DoNotCareSentinel,

10585 MatchIfTrue[

10586 Sequence[

10587 Union[

10588 cst.MatchSequenceElement,

10589 cst.MatchStar,

10590 OneOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

10591 AllOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

10592 ]

10593 ]

10594 ],

10595 OneOf[

10596 Union[

10597 Sequence[

10598 Union[

10599 MatchSequenceElementOrMatchStarMatchType,

10600 OneOf[MatchSequenceElementOrMatchStarMatchType],

10601 AllOf[MatchSequenceElementOrMatchStarMatchType],

10602 AtLeastN[

10603 Union[

10604 MatchSequenceElementOrMatchStarMatchType,

10605 OneOf[MatchSequenceElementOrMatchStarMatchType],

10606 AllOf[MatchSequenceElementOrMatchStarMatchType],

10607 ]

10608 ],

10609 AtMostN[

10610 Union[

10611 MatchSequenceElementOrMatchStarMatchType,

10612 OneOf[MatchSequenceElementOrMatchStarMatchType],

10613 AllOf[MatchSequenceElementOrMatchStarMatchType],

10614 ]

10615 ],

10616 ]

10617 ],

10618 MatchIfTrue[

10619 Sequence[

10620 Union[

10621 cst.MatchSequenceElement,

10622 cst.MatchStar,

10623 OneOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

10624 AllOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

10625 ]

10626 ]

10627 ],

10628 ]

10629 ],

10630 AllOf[

10631 Union[

10632 Sequence[

10633 Union[

10634 MatchSequenceElementOrMatchStarMatchType,

10635 OneOf[MatchSequenceElementOrMatchStarMatchType],

10636 AllOf[MatchSequenceElementOrMatchStarMatchType],

10637 AtLeastN[

10638 Union[

10639 MatchSequenceElementOrMatchStarMatchType,

10640 OneOf[MatchSequenceElementOrMatchStarMatchType],

10641 AllOf[MatchSequenceElementOrMatchStarMatchType],

10642 ]

10643 ],

10644 AtMostN[

10645 Union[

10646 MatchSequenceElementOrMatchStarMatchType,

10647 OneOf[MatchSequenceElementOrMatchStarMatchType],

10648 AllOf[MatchSequenceElementOrMatchStarMatchType],

10649 ]

10650 ],

10651 ]

10652 ],

10653 MatchIfTrue[

10654 Sequence[

10655 Union[

10656 cst.MatchSequenceElement,

10657 cst.MatchStar,

10658 OneOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

10659 AllOf[Union[cst.MatchSequenceElement, cst.MatchStar]],

10660 ]

10661 ]

10662 ],

10663 ]

10664 ],

10665 ] = DoNotCare()

10666 lpar: Union[

10667 Sequence[

10668 Union[

10669 LeftParenMatchType,

10670 DoNotCareSentinel,

10671 OneOf[LeftParenMatchType],

10672 AllOf[LeftParenMatchType],

10673 AtLeastN[

10674 Union[

10675 LeftParenMatchType,

10676 DoNotCareSentinel,

10677 OneOf[LeftParenMatchType],

10678 AllOf[LeftParenMatchType],

10679 ]

10680 ],

10681 AtMostN[

10682 Union[

10683 LeftParenMatchType,

10684 DoNotCareSentinel,

10685 OneOf[LeftParenMatchType],

10686 AllOf[LeftParenMatchType],

10687 ]

10688 ],

10689 ]

10690 ],

10691 DoNotCareSentinel,

10692 MatchIfTrue[Sequence[cst.LeftParen]],

10693 OneOf[

10694 Union[

10695 Sequence[

10696 Union[

10697 LeftParenMatchType,

10698 OneOf[LeftParenMatchType],

10699 AllOf[LeftParenMatchType],

10700 AtLeastN[

10701 Union[

10702 LeftParenMatchType,

10703 OneOf[LeftParenMatchType],

10704 AllOf[LeftParenMatchType],

10705 ]

10706 ],

10707 AtMostN[

10708 Union[

10709 LeftParenMatchType,

10710 OneOf[LeftParenMatchType],

10711 AllOf[LeftParenMatchType],

10712 ]

10713 ],

10714 ]

10715 ],

10716 MatchIfTrue[Sequence[cst.LeftParen]],

10717 ]

10718 ],

10719 AllOf[

10720 Union[

10721 Sequence[

10722 Union[

10723 LeftParenMatchType,

10724 OneOf[LeftParenMatchType],

10725 AllOf[LeftParenMatchType],

10726 AtLeastN[

10727 Union[

10728 LeftParenMatchType,

10729 OneOf[LeftParenMatchType],

10730 AllOf[LeftParenMatchType],

10731 ]

10732 ],

10733 AtMostN[

10734 Union[

10735 LeftParenMatchType,

10736 OneOf[LeftParenMatchType],

10737 AllOf[LeftParenMatchType],

10738 ]

10739 ],

10740 ]

10741 ],

10742 MatchIfTrue[Sequence[cst.LeftParen]],

10743 ]

10744 ],

10745 ] = DoNotCare()

10746 rpar: Union[

10747 Sequence[

10748 Union[

10749 RightParenMatchType,

10750 DoNotCareSentinel,

10751 OneOf[RightParenMatchType],

10752 AllOf[RightParenMatchType],

10753 AtLeastN[

10754 Union[

10755 RightParenMatchType,

10756 DoNotCareSentinel,

10757 OneOf[RightParenMatchType],

10758 AllOf[RightParenMatchType],

10759 ]

10760 ],

10761 AtMostN[

10762 Union[

10763 RightParenMatchType,

10764 DoNotCareSentinel,

10765 OneOf[RightParenMatchType],

10766 AllOf[RightParenMatchType],

10767 ]

10768 ],

10769 ]

10770 ],

10771 DoNotCareSentinel,

10772 MatchIfTrue[Sequence[cst.RightParen]],

10773 OneOf[

10774 Union[

10775 Sequence[

10776 Union[

10777 RightParenMatchType,

10778 OneOf[RightParenMatchType],

10779 AllOf[RightParenMatchType],

10780 AtLeastN[

10781 Union[

10782 RightParenMatchType,

10783 OneOf[RightParenMatchType],

10784 AllOf[RightParenMatchType],

10785 ]

10786 ],

10787 AtMostN[

10788 Union[

10789 RightParenMatchType,

10790 OneOf[RightParenMatchType],

10791 AllOf[RightParenMatchType],

10792 ]

10793 ],

10794 ]

10795 ],

10796 MatchIfTrue[Sequence[cst.RightParen]],

10797 ]

10798 ],

10799 AllOf[

10800 Union[

10801 Sequence[

10802 Union[

10803 RightParenMatchType,

10804 OneOf[RightParenMatchType],

10805 AllOf[RightParenMatchType],

10806 AtLeastN[

10807 Union[

10808 RightParenMatchType,

10809 OneOf[RightParenMatchType],

10810 AllOf[RightParenMatchType],

10811 ]

10812 ],

10813 AtMostN[

10814 Union[

10815 RightParenMatchType,

10816 OneOf[RightParenMatchType],

10817 AllOf[RightParenMatchType],

10818 ]

10819 ],

10820 ]

10821 ],

10822 MatchIfTrue[Sequence[cst.RightParen]],

10823 ]

10824 ],

10825 ] = DoNotCare()

10826 metadata: Union[

10827 MetadataMatchType,

10828 DoNotCareSentinel,

10829 OneOf[MetadataMatchType],

10830 AllOf[MetadataMatchType],

10831 ] = DoNotCare()

10832

10833

10834@dataclass(frozen=True, eq=False, unsafe_hash=False)

10835class MatchValue(BaseMatcherNode):

10836 value: Union[

10837 BaseExpressionMatchType,

10838 DoNotCareSentinel,

10839 OneOf[BaseExpressionMatchType],

10840 AllOf[BaseExpressionMatchType],

10841 ] = DoNotCare()

10842 metadata: Union[

10843 MetadataMatchType,

10844 DoNotCareSentinel,

10845 OneOf[MetadataMatchType],

10846 AllOf[MetadataMatchType],

10847 ] = DoNotCare()

10848

10849

10850@dataclass(frozen=True, eq=False, unsafe_hash=False)

10851class MatrixMultiply(BaseBinaryOp, BaseMatcherNode):

10852 whitespace_before: Union[

10853 BaseParenthesizableWhitespaceMatchType,

10854 DoNotCareSentinel,

10855 OneOf[BaseParenthesizableWhitespaceMatchType],

10856 AllOf[BaseParenthesizableWhitespaceMatchType],

10857 ] = DoNotCare()

10858 whitespace_after: Union[

10859 BaseParenthesizableWhitespaceMatchType,

10860 DoNotCareSentinel,

10861 OneOf[BaseParenthesizableWhitespaceMatchType],

10862 AllOf[BaseParenthesizableWhitespaceMatchType],

10863 ] = DoNotCare()

10864 metadata: Union[

10865 MetadataMatchType,

10866 DoNotCareSentinel,

10867 OneOf[MetadataMatchType],

10868 AllOf[MetadataMatchType],

10869 ] = DoNotCare()

10870

10871

10872@dataclass(frozen=True, eq=False, unsafe_hash=False)

10873class MatrixMultiplyAssign(BaseAugOp, BaseMatcherNode):

10874 whitespace_before: Union[

10875 BaseParenthesizableWhitespaceMatchType,

10876 DoNotCareSentinel,

10877 OneOf[BaseParenthesizableWhitespaceMatchType],

10878 AllOf[BaseParenthesizableWhitespaceMatchType],

10879 ] = DoNotCare()

10880 whitespace_after: Union[

10881 BaseParenthesizableWhitespaceMatchType,

10882 DoNotCareSentinel,

10883 OneOf[BaseParenthesizableWhitespaceMatchType],

10884 AllOf[BaseParenthesizableWhitespaceMatchType],

10885 ] = DoNotCare()

10886 metadata: Union[

10887 MetadataMatchType,

10888 DoNotCareSentinel,

10889 OneOf[MetadataMatchType],

10890 AllOf[MetadataMatchType],

10891 ] = DoNotCare()

10892

10893

10894@dataclass(frozen=True, eq=False, unsafe_hash=False)

10895class Minus(BaseUnaryOp, BaseMatcherNode):

10896 whitespace_after: Union[

10897 BaseParenthesizableWhitespaceMatchType,

10898 DoNotCareSentinel,

10899 OneOf[BaseParenthesizableWhitespaceMatchType],

10900 AllOf[BaseParenthesizableWhitespaceMatchType],

10901 ] = DoNotCare()

10902 metadata: Union[

10903 MetadataMatchType,

10904 DoNotCareSentinel,

10905 OneOf[MetadataMatchType],

10906 AllOf[MetadataMatchType],

10907 ] = DoNotCare()

10908

10909

10910SimpleStatementLineOrBaseCompoundStatementMatchType = Union[

10911 "SimpleStatementLine",

10912 "BaseCompoundStatement",

10913 MetadataMatchType,

10914 MatchIfTrue[Union[cst.SimpleStatementLine, cst.BaseCompoundStatement]],

10915]

10916

10917

10918@dataclass(frozen=True, eq=False, unsafe_hash=False)

10919class Module(BaseMatcherNode):

10920 body: Union[

10921 Sequence[

10922 Union[

10923 SimpleStatementLineOrBaseCompoundStatementMatchType,

10924 DoNotCareSentinel,

10925 OneOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10926 AllOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10927 AtLeastN[

10928 Union[

10929 SimpleStatementLineOrBaseCompoundStatementMatchType,

10930 DoNotCareSentinel,

10931 OneOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10932 AllOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10933 ]

10934 ],

10935 AtMostN[

10936 Union[

10937 SimpleStatementLineOrBaseCompoundStatementMatchType,

10938 DoNotCareSentinel,

10939 OneOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10940 AllOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10941 ]

10942 ],

10943 ]

10944 ],

10945 DoNotCareSentinel,

10946 MatchIfTrue[

10947 Sequence[

10948 Union[

10949 cst.SimpleStatementLine,

10950 cst.BaseCompoundStatement,

10951 OneOf[Union[cst.SimpleStatementLine, cst.BaseCompoundStatement]],

10952 AllOf[Union[cst.SimpleStatementLine, cst.BaseCompoundStatement]],

10953 ]

10954 ]

10955 ],

10956 OneOf[

10957 Union[

10958 Sequence[

10959 Union[

10960 SimpleStatementLineOrBaseCompoundStatementMatchType,

10961 OneOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10962 AllOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

10963 AtLeastN[

10964 Union[

10965 SimpleStatementLineOrBaseCompoundStatementMatchType,

10966 OneOf[

10967 SimpleStatementLineOrBaseCompoundStatementMatchType

10968 ],

10969 AllOf[

10970 SimpleStatementLineOrBaseCompoundStatementMatchType

10971 ],

10972 ]

10973 ],

10974 AtMostN[

10975 Union[

10976 SimpleStatementLineOrBaseCompoundStatementMatchType,

10977 OneOf[

10978 SimpleStatementLineOrBaseCompoundStatementMatchType

10979 ],

10980 AllOf[

10981 SimpleStatementLineOrBaseCompoundStatementMatchType

10982 ],

10983 ]

10984 ],

10985 ]

10986 ],

10987 MatchIfTrue[

10988 Sequence[

10989 Union[

10990 cst.SimpleStatementLine,

10991 cst.BaseCompoundStatement,

10992 OneOf[

10993 Union[

10994 cst.SimpleStatementLine, cst.BaseCompoundStatement

10995 ]

10996 ],

10997 AllOf[

10998 Union[

10999 cst.SimpleStatementLine, cst.BaseCompoundStatement

11000 ]

11001 ],

11002 ]

11003 ]

11004 ],

11005 ]

11006 ],

11007 AllOf[

11008 Union[

11009 Sequence[

11010 Union[

11011 SimpleStatementLineOrBaseCompoundStatementMatchType,

11012 OneOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

11013 AllOf[SimpleStatementLineOrBaseCompoundStatementMatchType],

11014 AtLeastN[

11015 Union[

11016 SimpleStatementLineOrBaseCompoundStatementMatchType,

11017 OneOf[

11018 SimpleStatementLineOrBaseCompoundStatementMatchType

11019 ],

11020 AllOf[

11021 SimpleStatementLineOrBaseCompoundStatementMatchType

11022 ],

11023 ]

11024 ],

11025 AtMostN[

11026 Union[

11027 SimpleStatementLineOrBaseCompoundStatementMatchType,

11028 OneOf[

11029 SimpleStatementLineOrBaseCompoundStatementMatchType

11030 ],

11031 AllOf[

11032 SimpleStatementLineOrBaseCompoundStatementMatchType

11033 ],

11034 ]

11035 ],

11036 ]

11037 ],

11038 MatchIfTrue[

11039 Sequence[

11040 Union[

11041 cst.SimpleStatementLine,

11042 cst.BaseCompoundStatement,

11043 OneOf[

11044 Union[

11045 cst.SimpleStatementLine, cst.BaseCompoundStatement

11046 ]

11047 ],

11048 AllOf[

11049 Union[

11050 cst.SimpleStatementLine, cst.BaseCompoundStatement

11051 ]

11052 ],

11053 ]

11054 ]

11055 ],

11056 ]

11057 ],

11058 ] = DoNotCare()

11059 header: Union[

11060 Sequence[

11061 Union[

11062 EmptyLineMatchType,

11063 DoNotCareSentinel,

11064 OneOf[EmptyLineMatchType],

11065 AllOf[EmptyLineMatchType],

11066 AtLeastN[

11067 Union[

11068 EmptyLineMatchType,

11069 DoNotCareSentinel,

11070 OneOf[EmptyLineMatchType],

11071 AllOf[EmptyLineMatchType],

11072 ]

11073 ],

11074 AtMostN[

11075 Union[

11076 EmptyLineMatchType,

11077 DoNotCareSentinel,

11078 OneOf[EmptyLineMatchType],

11079 AllOf[EmptyLineMatchType],

11080 ]

11081 ],

11082 ]

11083 ],

11084 DoNotCareSentinel,

11085 MatchIfTrue[Sequence[cst.EmptyLine]],

11086 OneOf[

11087 Union[

11088 Sequence[

11089 Union[

11090 EmptyLineMatchType,

11091 OneOf[EmptyLineMatchType],

11092 AllOf[EmptyLineMatchType],

11093 AtLeastN[

11094 Union[

11095 EmptyLineMatchType,

11096 OneOf[EmptyLineMatchType],

11097 AllOf[EmptyLineMatchType],

11098 ]

11099 ],

11100 AtMostN[

11101 Union[

11102 EmptyLineMatchType,

11103 OneOf[EmptyLineMatchType],

11104 AllOf[EmptyLineMatchType],

11105 ]

11106 ],

11107 ]

11108 ],

11109 MatchIfTrue[Sequence[cst.EmptyLine]],

11110 ]

11111 ],

11112 AllOf[

11113 Union[

11114 Sequence[

11115 Union[

11116 EmptyLineMatchType,

11117 OneOf[EmptyLineMatchType],

11118 AllOf[EmptyLineMatchType],

11119 AtLeastN[

11120 Union[

11121 EmptyLineMatchType,

11122 OneOf[EmptyLineMatchType],

11123 AllOf[EmptyLineMatchType],

11124 ]

11125 ],

11126 AtMostN[

11127 Union[

11128 EmptyLineMatchType,

11129 OneOf[EmptyLineMatchType],

11130 AllOf[EmptyLineMatchType],

11131 ]

11132 ],

11133 ]

11134 ],

11135 MatchIfTrue[Sequence[cst.EmptyLine]],

11136 ]

11137 ],

11138 ] = DoNotCare()

11139 footer: Union[

11140 Sequence[

11141 Union[

11142 EmptyLineMatchType,

11143 DoNotCareSentinel,

11144 OneOf[EmptyLineMatchType],

11145 AllOf[EmptyLineMatchType],

11146 AtLeastN[

11147 Union[

11148 EmptyLineMatchType,

11149 DoNotCareSentinel,

11150 OneOf[EmptyLineMatchType],

11151 AllOf[EmptyLineMatchType],

11152 ]

11153 ],

11154 AtMostN[

11155 Union[

11156 EmptyLineMatchType,

11157 DoNotCareSentinel,

11158 OneOf[EmptyLineMatchType],

11159 AllOf[EmptyLineMatchType],

11160 ]

11161 ],

11162 ]

11163 ],

11164 DoNotCareSentinel,

11165 MatchIfTrue[Sequence[cst.EmptyLine]],

11166 OneOf[

11167 Union[

11168 Sequence[

11169 Union[

11170 EmptyLineMatchType,

11171 OneOf[EmptyLineMatchType],

11172 AllOf[EmptyLineMatchType],

11173 AtLeastN[

11174 Union[

11175 EmptyLineMatchType,

11176 OneOf[EmptyLineMatchType],

11177 AllOf[EmptyLineMatchType],

11178 ]

11179 ],

11180 AtMostN[

11181 Union[

11182 EmptyLineMatchType,

11183 OneOf[EmptyLineMatchType],

11184 AllOf[EmptyLineMatchType],

11185 ]

11186 ],

11187 ]

11188 ],

11189 MatchIfTrue[Sequence[cst.EmptyLine]],

11190 ]

11191 ],

11192 AllOf[

11193 Union[

11194 Sequence[

11195 Union[

11196 EmptyLineMatchType,

11197 OneOf[EmptyLineMatchType],

11198 AllOf[EmptyLineMatchType],

11199 AtLeastN[

11200 Union[

11201 EmptyLineMatchType,

11202 OneOf[EmptyLineMatchType],

11203 AllOf[EmptyLineMatchType],

11204 ]

11205 ],

11206 AtMostN[

11207 Union[

11208 EmptyLineMatchType,

11209 OneOf[EmptyLineMatchType],

11210 AllOf[EmptyLineMatchType],

11211 ]

11212 ],

11213 ]

11214 ],

11215 MatchIfTrue[Sequence[cst.EmptyLine]],

11216 ]

11217 ],

11218 ] = DoNotCare()

11219 encoding: Union[

11220 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

11221 ] = DoNotCare()

11222 default_indent: Union[

11223 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

11224 ] = DoNotCare()

11225 default_newline: Union[

11226 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

11227 ] = DoNotCare()

11228 has_trailing_newline: Union[

11229 boolMatchType, DoNotCareSentinel, OneOf[boolMatchType], AllOf[boolMatchType]

11230 ] = DoNotCare()

11231 metadata: Union[

11232 MetadataMatchType,

11233 DoNotCareSentinel,

11234 OneOf[MetadataMatchType],

11235 AllOf[MetadataMatchType],

11236 ] = DoNotCare()

11237

11238

11239@dataclass(frozen=True, eq=False, unsafe_hash=False)

11240class Modulo(BaseBinaryOp, BaseMatcherNode):

11241 whitespace_before: Union[

11242 BaseParenthesizableWhitespaceMatchType,

11243 DoNotCareSentinel,

11244 OneOf[BaseParenthesizableWhitespaceMatchType],

11245 AllOf[BaseParenthesizableWhitespaceMatchType],

11246 ] = DoNotCare()

11247 whitespace_after: Union[

11248 BaseParenthesizableWhitespaceMatchType,

11249 DoNotCareSentinel,

11250 OneOf[BaseParenthesizableWhitespaceMatchType],

11251 AllOf[BaseParenthesizableWhitespaceMatchType],

11252 ] = DoNotCare()

11253 metadata: Union[

11254 MetadataMatchType,

11255 DoNotCareSentinel,

11256 OneOf[MetadataMatchType],

11257 AllOf[MetadataMatchType],

11258 ] = DoNotCare()

11259

11260

11261@dataclass(frozen=True, eq=False, unsafe_hash=False)

11262class ModuloAssign(BaseAugOp, BaseMatcherNode):

11263 whitespace_before: Union[

11264 BaseParenthesizableWhitespaceMatchType,

11265 DoNotCareSentinel,

11266 OneOf[BaseParenthesizableWhitespaceMatchType],

11267 AllOf[BaseParenthesizableWhitespaceMatchType],

11268 ] = DoNotCare()

11269 whitespace_after: Union[

11270 BaseParenthesizableWhitespaceMatchType,

11271 DoNotCareSentinel,

11272 OneOf[BaseParenthesizableWhitespaceMatchType],

11273 AllOf[BaseParenthesizableWhitespaceMatchType],

11274 ] = DoNotCare()

11275 metadata: Union[

11276 MetadataMatchType,

11277 DoNotCareSentinel,

11278 OneOf[MetadataMatchType],

11279 AllOf[MetadataMatchType],

11280 ] = DoNotCare()

11281

11282

11283@dataclass(frozen=True, eq=False, unsafe_hash=False)

11284class Multiply(BaseBinaryOp, BaseMatcherNode):

11285 whitespace_before: Union[

11286 BaseParenthesizableWhitespaceMatchType,

11287 DoNotCareSentinel,

11288 OneOf[BaseParenthesizableWhitespaceMatchType],

11289 AllOf[BaseParenthesizableWhitespaceMatchType],

11290 ] = DoNotCare()

11291 whitespace_after: Union[

11292 BaseParenthesizableWhitespaceMatchType,

11293 DoNotCareSentinel,

11294 OneOf[BaseParenthesizableWhitespaceMatchType],

11295 AllOf[BaseParenthesizableWhitespaceMatchType],

11296 ] = DoNotCare()

11297 metadata: Union[

11298 MetadataMatchType,

11299 DoNotCareSentinel,

11300 OneOf[MetadataMatchType],

11301 AllOf[MetadataMatchType],

11302 ] = DoNotCare()

11303

11304

11305@dataclass(frozen=True, eq=False, unsafe_hash=False)

11306class MultiplyAssign(BaseAugOp, BaseMatcherNode):

11307 whitespace_before: Union[

11308 BaseParenthesizableWhitespaceMatchType,

11309 DoNotCareSentinel,

11310 OneOf[BaseParenthesizableWhitespaceMatchType],

11311 AllOf[BaseParenthesizableWhitespaceMatchType],

11312 ] = DoNotCare()

11313 whitespace_after: Union[

11314 BaseParenthesizableWhitespaceMatchType,

11315 DoNotCareSentinel,

11316 OneOf[BaseParenthesizableWhitespaceMatchType],

11317 AllOf[BaseParenthesizableWhitespaceMatchType],

11318 ] = DoNotCare()

11319 metadata: Union[

11320 MetadataMatchType,

11321 DoNotCareSentinel,

11322 OneOf[MetadataMatchType],

11323 AllOf[MetadataMatchType],

11324 ] = DoNotCare()

11325

11326

11327@dataclass(frozen=True, eq=False, unsafe_hash=False)

11328class Name(

11329 BaseAssignTargetExpression, BaseDelTargetExpression, BaseExpression, BaseMatcherNode

11330):

11331 value: Union[

11332 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

11333 ] = DoNotCare()

11334 lpar: Union[

11335 Sequence[

11336 Union[

11337 LeftParenMatchType,

11338 DoNotCareSentinel,

11339 OneOf[LeftParenMatchType],

11340 AllOf[LeftParenMatchType],

11341 AtLeastN[

11342 Union[

11343 LeftParenMatchType,

11344 DoNotCareSentinel,

11345 OneOf[LeftParenMatchType],

11346 AllOf[LeftParenMatchType],

11347 ]

11348 ],

11349 AtMostN[

11350 Union[

11351 LeftParenMatchType,

11352 DoNotCareSentinel,

11353 OneOf[LeftParenMatchType],

11354 AllOf[LeftParenMatchType],

11355 ]

11356 ],

11357 ]

11358 ],

11359 DoNotCareSentinel,

11360 MatchIfTrue[Sequence[cst.LeftParen]],

11361 OneOf[

11362 Union[

11363 Sequence[

11364 Union[

11365 LeftParenMatchType,

11366 OneOf[LeftParenMatchType],

11367 AllOf[LeftParenMatchType],

11368 AtLeastN[

11369 Union[

11370 LeftParenMatchType,

11371 OneOf[LeftParenMatchType],

11372 AllOf[LeftParenMatchType],

11373 ]

11374 ],

11375 AtMostN[

11376 Union[

11377 LeftParenMatchType,

11378 OneOf[LeftParenMatchType],

11379 AllOf[LeftParenMatchType],

11380 ]

11381 ],

11382 ]

11383 ],

11384 MatchIfTrue[Sequence[cst.LeftParen]],

11385 ]

11386 ],

11387 AllOf[

11388 Union[

11389 Sequence[

11390 Union[

11391 LeftParenMatchType,

11392 OneOf[LeftParenMatchType],

11393 AllOf[LeftParenMatchType],

11394 AtLeastN[

11395 Union[

11396 LeftParenMatchType,

11397 OneOf[LeftParenMatchType],

11398 AllOf[LeftParenMatchType],

11399 ]

11400 ],

11401 AtMostN[

11402 Union[

11403 LeftParenMatchType,

11404 OneOf[LeftParenMatchType],

11405 AllOf[LeftParenMatchType],

11406 ]

11407 ],

11408 ]

11409 ],

11410 MatchIfTrue[Sequence[cst.LeftParen]],

11411 ]

11412 ],

11413 ] = DoNotCare()

11414 rpar: Union[

11415 Sequence[

11416 Union[

11417 RightParenMatchType,

11418 DoNotCareSentinel,

11419 OneOf[RightParenMatchType],

11420 AllOf[RightParenMatchType],

11421 AtLeastN[

11422 Union[

11423 RightParenMatchType,

11424 DoNotCareSentinel,

11425 OneOf[RightParenMatchType],

11426 AllOf[RightParenMatchType],

11427 ]

11428 ],

11429 AtMostN[

11430 Union[

11431 RightParenMatchType,

11432 DoNotCareSentinel,

11433 OneOf[RightParenMatchType],

11434 AllOf[RightParenMatchType],

11435 ]

11436 ],

11437 ]

11438 ],

11439 DoNotCareSentinel,

11440 MatchIfTrue[Sequence[cst.RightParen]],

11441 OneOf[

11442 Union[

11443 Sequence[

11444 Union[

11445 RightParenMatchType,

11446 OneOf[RightParenMatchType],

11447 AllOf[RightParenMatchType],

11448 AtLeastN[

11449 Union[

11450 RightParenMatchType,

11451 OneOf[RightParenMatchType],

11452 AllOf[RightParenMatchType],

11453 ]

11454 ],

11455 AtMostN[

11456 Union[

11457 RightParenMatchType,

11458 OneOf[RightParenMatchType],

11459 AllOf[RightParenMatchType],

11460 ]

11461 ],

11462 ]

11463 ],

11464 MatchIfTrue[Sequence[cst.RightParen]],

11465 ]

11466 ],

11467 AllOf[

11468 Union[

11469 Sequence[

11470 Union[

11471 RightParenMatchType,

11472 OneOf[RightParenMatchType],

11473 AllOf[RightParenMatchType],

11474 AtLeastN[

11475 Union[

11476 RightParenMatchType,

11477 OneOf[RightParenMatchType],

11478 AllOf[RightParenMatchType],

11479 ]

11480 ],

11481 AtMostN[

11482 Union[

11483 RightParenMatchType,

11484 OneOf[RightParenMatchType],

11485 AllOf[RightParenMatchType],

11486 ]

11487 ],

11488 ]

11489 ],

11490 MatchIfTrue[Sequence[cst.RightParen]],

11491 ]

11492 ],

11493 ] = DoNotCare()

11494 metadata: Union[

11495 MetadataMatchType,

11496 DoNotCareSentinel,

11497 OneOf[MetadataMatchType],

11498 AllOf[MetadataMatchType],

11499 ] = DoNotCare()

11500

11501

11502@dataclass(frozen=True, eq=False, unsafe_hash=False)

11503class NameItem(BaseMatcherNode):

11504 name: Union[

11505 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

11506 ] = DoNotCare()

11507 comma: Union[

11508 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

11509 ] = DoNotCare()

11510 metadata: Union[

11511 MetadataMatchType,

11512 DoNotCareSentinel,

11513 OneOf[MetadataMatchType],

11514 AllOf[MetadataMatchType],

11515 ] = DoNotCare()

11516

11517

11518@dataclass(frozen=True, eq=False, unsafe_hash=False)

11519class NamedExpr(BaseExpression, BaseMatcherNode):

11520 target: Union[

11521 BaseExpressionMatchType,

11522 DoNotCareSentinel,

11523 OneOf[BaseExpressionMatchType],

11524 AllOf[BaseExpressionMatchType],

11525 ] = DoNotCare()

11526 value: Union[

11527 BaseExpressionMatchType,

11528 DoNotCareSentinel,

11529 OneOf[BaseExpressionMatchType],

11530 AllOf[BaseExpressionMatchType],

11531 ] = DoNotCare()

11532 lpar: Union[

11533 Sequence[

11534 Union[

11535 LeftParenMatchType,

11536 DoNotCareSentinel,

11537 OneOf[LeftParenMatchType],

11538 AllOf[LeftParenMatchType],

11539 AtLeastN[

11540 Union[

11541 LeftParenMatchType,

11542 DoNotCareSentinel,

11543 OneOf[LeftParenMatchType],

11544 AllOf[LeftParenMatchType],

11545 ]

11546 ],

11547 AtMostN[

11548 Union[

11549 LeftParenMatchType,

11550 DoNotCareSentinel,

11551 OneOf[LeftParenMatchType],

11552 AllOf[LeftParenMatchType],

11553 ]

11554 ],

11555 ]

11556 ],

11557 DoNotCareSentinel,

11558 MatchIfTrue[Sequence[cst.LeftParen]],

11559 OneOf[

11560 Union[

11561 Sequence[

11562 Union[

11563 LeftParenMatchType,

11564 OneOf[LeftParenMatchType],

11565 AllOf[LeftParenMatchType],

11566 AtLeastN[

11567 Union[

11568 LeftParenMatchType,

11569 OneOf[LeftParenMatchType],

11570 AllOf[LeftParenMatchType],

11571 ]

11572 ],

11573 AtMostN[

11574 Union[

11575 LeftParenMatchType,

11576 OneOf[LeftParenMatchType],

11577 AllOf[LeftParenMatchType],

11578 ]

11579 ],

11580 ]

11581 ],

11582 MatchIfTrue[Sequence[cst.LeftParen]],

11583 ]

11584 ],

11585 AllOf[

11586 Union[

11587 Sequence[

11588 Union[

11589 LeftParenMatchType,

11590 OneOf[LeftParenMatchType],

11591 AllOf[LeftParenMatchType],

11592 AtLeastN[

11593 Union[

11594 LeftParenMatchType,

11595 OneOf[LeftParenMatchType],

11596 AllOf[LeftParenMatchType],

11597 ]

11598 ],

11599 AtMostN[

11600 Union[

11601 LeftParenMatchType,

11602 OneOf[LeftParenMatchType],

11603 AllOf[LeftParenMatchType],

11604 ]

11605 ],

11606 ]

11607 ],

11608 MatchIfTrue[Sequence[cst.LeftParen]],

11609 ]

11610 ],

11611 ] = DoNotCare()

11612 rpar: Union[

11613 Sequence[

11614 Union[

11615 RightParenMatchType,

11616 DoNotCareSentinel,

11617 OneOf[RightParenMatchType],

11618 AllOf[RightParenMatchType],

11619 AtLeastN[

11620 Union[

11621 RightParenMatchType,

11622 DoNotCareSentinel,

11623 OneOf[RightParenMatchType],

11624 AllOf[RightParenMatchType],

11625 ]

11626 ],

11627 AtMostN[

11628 Union[

11629 RightParenMatchType,

11630 DoNotCareSentinel,

11631 OneOf[RightParenMatchType],

11632 AllOf[RightParenMatchType],

11633 ]

11634 ],

11635 ]

11636 ],

11637 DoNotCareSentinel,

11638 MatchIfTrue[Sequence[cst.RightParen]],

11639 OneOf[

11640 Union[

11641 Sequence[

11642 Union[

11643 RightParenMatchType,

11644 OneOf[RightParenMatchType],

11645 AllOf[RightParenMatchType],

11646 AtLeastN[

11647 Union[

11648 RightParenMatchType,

11649 OneOf[RightParenMatchType],

11650 AllOf[RightParenMatchType],

11651 ]

11652 ],

11653 AtMostN[

11654 Union[

11655 RightParenMatchType,

11656 OneOf[RightParenMatchType],

11657 AllOf[RightParenMatchType],

11658 ]

11659 ],

11660 ]

11661 ],

11662 MatchIfTrue[Sequence[cst.RightParen]],

11663 ]

11664 ],

11665 AllOf[

11666 Union[

11667 Sequence[

11668 Union[

11669 RightParenMatchType,

11670 OneOf[RightParenMatchType],

11671 AllOf[RightParenMatchType],

11672 AtLeastN[

11673 Union[

11674 RightParenMatchType,

11675 OneOf[RightParenMatchType],

11676 AllOf[RightParenMatchType],

11677 ]

11678 ],

11679 AtMostN[

11680 Union[

11681 RightParenMatchType,

11682 OneOf[RightParenMatchType],

11683 AllOf[RightParenMatchType],

11684 ]

11685 ],

11686 ]

11687 ],

11688 MatchIfTrue[Sequence[cst.RightParen]],

11689 ]

11690 ],

11691 ] = DoNotCare()

11692 whitespace_before_walrus: Union[

11693 BaseParenthesizableWhitespaceMatchType,

11694 DoNotCareSentinel,

11695 OneOf[BaseParenthesizableWhitespaceMatchType],

11696 AllOf[BaseParenthesizableWhitespaceMatchType],

11697 ] = DoNotCare()

11698 whitespace_after_walrus: Union[

11699 BaseParenthesizableWhitespaceMatchType,

11700 DoNotCareSentinel,

11701 OneOf[BaseParenthesizableWhitespaceMatchType],

11702 AllOf[BaseParenthesizableWhitespaceMatchType],

11703 ] = DoNotCare()

11704 metadata: Union[

11705 MetadataMatchType,

11706 DoNotCareSentinel,

11707 OneOf[MetadataMatchType],

11708 AllOf[MetadataMatchType],

11709 ] = DoNotCare()

11710

11711

11712@dataclass(frozen=True, eq=False, unsafe_hash=False)

11713class Newline(BaseMatcherNode):

11714 value: Union[

11715 Optional[str],

11716 MetadataMatchType,

11717 MatchIfTrue[Optional[str]],

11718 DoNotCareSentinel,

11719 OneOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

11720 AllOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

11721 ] = DoNotCare()

11722 metadata: Union[

11723 MetadataMatchType,

11724 DoNotCareSentinel,

11725 OneOf[MetadataMatchType],

11726 AllOf[MetadataMatchType],

11727 ] = DoNotCare()

11728

11729

11730@dataclass(frozen=True, eq=False, unsafe_hash=False)

11731class Nonlocal(BaseSmallStatement, BaseMatcherNode):

11732 names: Union[

11733 Sequence[

11734 Union[

11735 NameItemMatchType,

11736 DoNotCareSentinel,

11737 OneOf[NameItemMatchType],

11738 AllOf[NameItemMatchType],

11739 AtLeastN[

11740 Union[

11741 NameItemMatchType,

11742 DoNotCareSentinel,

11743 OneOf[NameItemMatchType],

11744 AllOf[NameItemMatchType],

11745 ]

11746 ],

11747 AtMostN[

11748 Union[

11749 NameItemMatchType,

11750 DoNotCareSentinel,

11751 OneOf[NameItemMatchType],

11752 AllOf[NameItemMatchType],

11753 ]

11754 ],

11755 ]

11756 ],

11757 DoNotCareSentinel,

11758 MatchIfTrue[Sequence[cst.NameItem]],

11759 OneOf[

11760 Union[

11761 Sequence[

11762 Union[

11763 NameItemMatchType,

11764 OneOf[NameItemMatchType],

11765 AllOf[NameItemMatchType],

11766 AtLeastN[

11767 Union[

11768 NameItemMatchType,

11769 OneOf[NameItemMatchType],

11770 AllOf[NameItemMatchType],

11771 ]

11772 ],

11773 AtMostN[

11774 Union[

11775 NameItemMatchType,

11776 OneOf[NameItemMatchType],

11777 AllOf[NameItemMatchType],

11778 ]

11779 ],

11780 ]

11781 ],

11782 MatchIfTrue[Sequence[cst.NameItem]],

11783 ]

11784 ],

11785 AllOf[

11786 Union[

11787 Sequence[

11788 Union[

11789 NameItemMatchType,

11790 OneOf[NameItemMatchType],

11791 AllOf[NameItemMatchType],

11792 AtLeastN[

11793 Union[

11794 NameItemMatchType,

11795 OneOf[NameItemMatchType],

11796 AllOf[NameItemMatchType],

11797 ]

11798 ],

11799 AtMostN[

11800 Union[

11801 NameItemMatchType,

11802 OneOf[NameItemMatchType],

11803 AllOf[NameItemMatchType],

11804 ]

11805 ],

11806 ]

11807 ],

11808 MatchIfTrue[Sequence[cst.NameItem]],

11809 ]

11810 ],

11811 ] = DoNotCare()

11812 whitespace_after_nonlocal: Union[

11813 SimpleWhitespaceMatchType,

11814 DoNotCareSentinel,

11815 OneOf[SimpleWhitespaceMatchType],

11816 AllOf[SimpleWhitespaceMatchType],

11817 ] = DoNotCare()

11818 semicolon: Union[

11819 SemicolonMatchType,

11820 DoNotCareSentinel,

11821 OneOf[SemicolonMatchType],

11822 AllOf[SemicolonMatchType],

11823 ] = DoNotCare()

11824 metadata: Union[

11825 MetadataMatchType,

11826 DoNotCareSentinel,

11827 OneOf[MetadataMatchType],

11828 AllOf[MetadataMatchType],

11829 ] = DoNotCare()

11830

11831

11832@dataclass(frozen=True, eq=False, unsafe_hash=False)

11833class Not(BaseUnaryOp, BaseMatcherNode):

11834 whitespace_after: Union[

11835 BaseParenthesizableWhitespaceMatchType,

11836 DoNotCareSentinel,

11837 OneOf[BaseParenthesizableWhitespaceMatchType],

11838 AllOf[BaseParenthesizableWhitespaceMatchType],

11839 ] = DoNotCare()

11840 metadata: Union[

11841 MetadataMatchType,

11842 DoNotCareSentinel,

11843 OneOf[MetadataMatchType],

11844 AllOf[MetadataMatchType],

11845 ] = DoNotCare()

11846

11847

11848@dataclass(frozen=True, eq=False, unsafe_hash=False)

11849class NotEqual(BaseCompOp, BaseMatcherNode):

11850 value: Union[

11851 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

11852 ] = DoNotCare()

11853 whitespace_before: Union[

11854 BaseParenthesizableWhitespaceMatchType,

11855 DoNotCareSentinel,

11856 OneOf[BaseParenthesizableWhitespaceMatchType],

11857 AllOf[BaseParenthesizableWhitespaceMatchType],

11858 ] = DoNotCare()

11859 whitespace_after: Union[

11860 BaseParenthesizableWhitespaceMatchType,

11861 DoNotCareSentinel,

11862 OneOf[BaseParenthesizableWhitespaceMatchType],

11863 AllOf[BaseParenthesizableWhitespaceMatchType],

11864 ] = DoNotCare()

11865 metadata: Union[

11866 MetadataMatchType,

11867 DoNotCareSentinel,

11868 OneOf[MetadataMatchType],

11869 AllOf[MetadataMatchType],

11870 ] = DoNotCare()

11871

11872

11873@dataclass(frozen=True, eq=False, unsafe_hash=False)

11874class NotIn(BaseCompOp, BaseMatcherNode):

11875 whitespace_before: Union[

11876 BaseParenthesizableWhitespaceMatchType,

11877 DoNotCareSentinel,

11878 OneOf[BaseParenthesizableWhitespaceMatchType],

11879 AllOf[BaseParenthesizableWhitespaceMatchType],

11880 ] = DoNotCare()

11881 whitespace_between: Union[

11882 BaseParenthesizableWhitespaceMatchType,

11883 DoNotCareSentinel,

11884 OneOf[BaseParenthesizableWhitespaceMatchType],

11885 AllOf[BaseParenthesizableWhitespaceMatchType],

11886 ] = DoNotCare()

11887 whitespace_after: Union[

11888 BaseParenthesizableWhitespaceMatchType,

11889 DoNotCareSentinel,

11890 OneOf[BaseParenthesizableWhitespaceMatchType],

11891 AllOf[BaseParenthesizableWhitespaceMatchType],

11892 ] = DoNotCare()

11893 metadata: Union[

11894 MetadataMatchType,

11895 DoNotCareSentinel,

11896 OneOf[MetadataMatchType],

11897 AllOf[MetadataMatchType],

11898 ] = DoNotCare()

11899

11900

11901@dataclass(frozen=True, eq=False, unsafe_hash=False)

11902class Or(BaseBooleanOp, BaseMatcherNode):

11903 whitespace_before: Union[

11904 BaseParenthesizableWhitespaceMatchType,

11905 DoNotCareSentinel,

11906 OneOf[BaseParenthesizableWhitespaceMatchType],

11907 AllOf[BaseParenthesizableWhitespaceMatchType],

11908 ] = DoNotCare()

11909 whitespace_after: Union[

11910 BaseParenthesizableWhitespaceMatchType,

11911 DoNotCareSentinel,

11912 OneOf[BaseParenthesizableWhitespaceMatchType],

11913 AllOf[BaseParenthesizableWhitespaceMatchType],

11914 ] = DoNotCare()

11915 metadata: Union[

11916 MetadataMatchType,

11917 DoNotCareSentinel,

11918 OneOf[MetadataMatchType],

11919 AllOf[MetadataMatchType],

11920 ] = DoNotCare()

11921

11922

11923@dataclass(frozen=True, eq=False, unsafe_hash=False)

11924class Param(BaseMatcherNode):

11925 name: Union[

11926 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

11927 ] = DoNotCare()

11928 annotation: Union[

11929 Optional["Annotation"],

11930 MetadataMatchType,

11931 MatchIfTrue[Optional[cst.Annotation]],

11932 DoNotCareSentinel,

11933 OneOf[

11934 Union[

11935 Optional["Annotation"],

11936 MetadataMatchType,

11937 MatchIfTrue[Optional[cst.Annotation]],

11938 ]

11939 ],

11940 AllOf[

11941 Union[

11942 Optional["Annotation"],

11943 MetadataMatchType,

11944 MatchIfTrue[Optional[cst.Annotation]],

11945 ]

11946 ],

11947 ] = DoNotCare()

11948 equal: Union[

11949 AssignEqualMatchType,

11950 DoNotCareSentinel,

11951 OneOf[AssignEqualMatchType],

11952 AllOf[AssignEqualMatchType],

11953 ] = DoNotCare()

11954 default: Union[

11955 Optional["BaseExpression"],

11956 MetadataMatchType,

11957 MatchIfTrue[Optional[cst.BaseExpression]],

11958 DoNotCareSentinel,

11959 OneOf[

11960 Union[

11961 Optional["BaseExpression"],

11962 MetadataMatchType,

11963 MatchIfTrue[Optional[cst.BaseExpression]],

11964 ]

11965 ],

11966 AllOf[

11967 Union[

11968 Optional["BaseExpression"],

11969 MetadataMatchType,

11970 MatchIfTrue[Optional[cst.BaseExpression]],

11971 ]

11972 ],

11973 ] = DoNotCare()

11974 comma: Union[

11975 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

11976 ] = DoNotCare()

11977 star: Union[

11978 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

11979 ] = DoNotCare()

11980 whitespace_after_star: Union[

11981 BaseParenthesizableWhitespaceMatchType,

11982 DoNotCareSentinel,

11983 OneOf[BaseParenthesizableWhitespaceMatchType],

11984 AllOf[BaseParenthesizableWhitespaceMatchType],

11985 ] = DoNotCare()

11986 whitespace_after_param: Union[

11987 BaseParenthesizableWhitespaceMatchType,

11988 DoNotCareSentinel,

11989 OneOf[BaseParenthesizableWhitespaceMatchType],

11990 AllOf[BaseParenthesizableWhitespaceMatchType],

11991 ] = DoNotCare()

11992 metadata: Union[

11993 MetadataMatchType,

11994 DoNotCareSentinel,

11995 OneOf[MetadataMatchType],

11996 AllOf[MetadataMatchType],

11997 ] = DoNotCare()

11998

11999

12000@dataclass(frozen=True, eq=False, unsafe_hash=False)

12001class ParamSlash(BaseMatcherNode):

12002 comma: Union[

12003 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

12004 ] = DoNotCare()

12005 whitespace_after: Union[

12006 BaseParenthesizableWhitespaceMatchType,

12007 DoNotCareSentinel,

12008 OneOf[BaseParenthesizableWhitespaceMatchType],

12009 AllOf[BaseParenthesizableWhitespaceMatchType],

12010 ] = DoNotCare()

12011 metadata: Union[

12012 MetadataMatchType,

12013 DoNotCareSentinel,

12014 OneOf[MetadataMatchType],

12015 AllOf[MetadataMatchType],

12016 ] = DoNotCare()

12017

12018

12019@dataclass(frozen=True, eq=False, unsafe_hash=False)

12020class ParamSpec(BaseMatcherNode):

12021 name: Union[

12022 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

12023 ] = DoNotCare()

12024 whitespace_after_star: Union[

12025 SimpleWhitespaceMatchType,

12026 DoNotCareSentinel,

12027 OneOf[SimpleWhitespaceMatchType],

12028 AllOf[SimpleWhitespaceMatchType],

12029 ] = DoNotCare()

12030 metadata: Union[

12031 MetadataMatchType,

12032 DoNotCareSentinel,

12033 OneOf[MetadataMatchType],

12034 AllOf[MetadataMatchType],

12035 ] = DoNotCare()

12036

12037

12038@dataclass(frozen=True, eq=False, unsafe_hash=False)

12039class ParamStar(BaseMatcherNode):

12040 comma: Union[

12041 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

12042 ] = DoNotCare()

12043 metadata: Union[

12044 MetadataMatchType,

12045 DoNotCareSentinel,

12046 OneOf[MetadataMatchType],

12047 AllOf[MetadataMatchType],

12048 ] = DoNotCare()

12049

12050

12051ParamMatchType = Union["Param", MetadataMatchType, MatchIfTrue[cst.Param]]

12052ParamOrParamStarMatchType = Union[

12053 "Param",

12054 "ParamStar",

12055 MetadataMatchType,

12056 MatchIfTrue[Union[cst.Param, cst.ParamStar]],

12057]

12058ParamSlashMatchType = Union[

12059 "ParamSlash", MetadataMatchType, MatchIfTrue[cst.ParamSlash]

12060]

12061

12062

12063@dataclass(frozen=True, eq=False, unsafe_hash=False)

12064class Parameters(BaseMatcherNode):

12065 params: Union[

12066 Sequence[

12067 Union[

12068 ParamMatchType,

12069 DoNotCareSentinel,

12070 OneOf[ParamMatchType],

12071 AllOf[ParamMatchType],

12072 AtLeastN[

12073 Union[

12074 ParamMatchType,

12075 DoNotCareSentinel,

12076 OneOf[ParamMatchType],

12077 AllOf[ParamMatchType],

12078 ]

12079 ],

12080 AtMostN[

12081 Union[

12082 ParamMatchType,

12083 DoNotCareSentinel,

12084 OneOf[ParamMatchType],

12085 AllOf[ParamMatchType],

12086 ]

12087 ],

12088 ]

12089 ],

12090 DoNotCareSentinel,

12091 MatchIfTrue[Sequence[cst.Param]],

12092 OneOf[

12093 Union[

12094 Sequence[

12095 Union[

12096 ParamMatchType,

12097 OneOf[ParamMatchType],

12098 AllOf[ParamMatchType],

12099 AtLeastN[

12100 Union[

12101 ParamMatchType,

12102 OneOf[ParamMatchType],

12103 AllOf[ParamMatchType],

12104 ]

12105 ],

12106 AtMostN[

12107 Union[

12108 ParamMatchType,

12109 OneOf[ParamMatchType],

12110 AllOf[ParamMatchType],

12111 ]

12112 ],

12113 ]

12114 ],

12115 MatchIfTrue[Sequence[cst.Param]],

12116 ]

12117 ],

12118 AllOf[

12119 Union[

12120 Sequence[

12121 Union[

12122 ParamMatchType,

12123 OneOf[ParamMatchType],

12124 AllOf[ParamMatchType],

12125 AtLeastN[

12126 Union[

12127 ParamMatchType,

12128 OneOf[ParamMatchType],

12129 AllOf[ParamMatchType],

12130 ]

12131 ],

12132 AtMostN[

12133 Union[

12134 ParamMatchType,

12135 OneOf[ParamMatchType],

12136 AllOf[ParamMatchType],

12137 ]

12138 ],

12139 ]

12140 ],

12141 MatchIfTrue[Sequence[cst.Param]],

12142 ]

12143 ],

12144 ] = DoNotCare()

12145 star_arg: Union[

12146 ParamOrParamStarMatchType,

12147 DoNotCareSentinel,

12148 OneOf[ParamOrParamStarMatchType],

12149 AllOf[ParamOrParamStarMatchType],

12150 ] = DoNotCare()

12151 kwonly_params: Union[

12152 Sequence[

12153 Union[

12154 ParamMatchType,

12155 DoNotCareSentinel,

12156 OneOf[ParamMatchType],

12157 AllOf[ParamMatchType],

12158 AtLeastN[

12159 Union[

12160 ParamMatchType,

12161 DoNotCareSentinel,

12162 OneOf[ParamMatchType],

12163 AllOf[ParamMatchType],

12164 ]

12165 ],

12166 AtMostN[

12167 Union[

12168 ParamMatchType,

12169 DoNotCareSentinel,

12170 OneOf[ParamMatchType],

12171 AllOf[ParamMatchType],

12172 ]

12173 ],

12174 ]

12175 ],

12176 DoNotCareSentinel,

12177 MatchIfTrue[Sequence[cst.Param]],

12178 OneOf[

12179 Union[

12180 Sequence[

12181 Union[

12182 ParamMatchType,

12183 OneOf[ParamMatchType],

12184 AllOf[ParamMatchType],

12185 AtLeastN[

12186 Union[

12187 ParamMatchType,

12188 OneOf[ParamMatchType],

12189 AllOf[ParamMatchType],

12190 ]

12191 ],

12192 AtMostN[

12193 Union[

12194 ParamMatchType,

12195 OneOf[ParamMatchType],

12196 AllOf[ParamMatchType],

12197 ]

12198 ],

12199 ]

12200 ],

12201 MatchIfTrue[Sequence[cst.Param]],

12202 ]

12203 ],

12204 AllOf[

12205 Union[

12206 Sequence[

12207 Union[

12208 ParamMatchType,

12209 OneOf[ParamMatchType],

12210 AllOf[ParamMatchType],

12211 AtLeastN[

12212 Union[

12213 ParamMatchType,

12214 OneOf[ParamMatchType],

12215 AllOf[ParamMatchType],

12216 ]

12217 ],

12218 AtMostN[

12219 Union[

12220 ParamMatchType,

12221 OneOf[ParamMatchType],

12222 AllOf[ParamMatchType],

12223 ]

12224 ],

12225 ]

12226 ],

12227 MatchIfTrue[Sequence[cst.Param]],

12228 ]

12229 ],

12230 ] = DoNotCare()

12231 star_kwarg: Union[

12232 Optional["Param"],

12233 MetadataMatchType,

12234 MatchIfTrue[Optional[cst.Param]],

12235 DoNotCareSentinel,

12236 OneOf[

12237 Union[

12238 Optional["Param"], MetadataMatchType, MatchIfTrue[Optional[cst.Param]]

12239 ]

12240 ],

12241 AllOf[

12242 Union[

12243 Optional["Param"], MetadataMatchType, MatchIfTrue[Optional[cst.Param]]

12244 ]

12245 ],

12246 ] = DoNotCare()

12247 posonly_params: Union[

12248 Sequence[

12249 Union[

12250 ParamMatchType,

12251 DoNotCareSentinel,

12252 OneOf[ParamMatchType],

12253 AllOf[ParamMatchType],

12254 AtLeastN[

12255 Union[

12256 ParamMatchType,

12257 DoNotCareSentinel,

12258 OneOf[ParamMatchType],

12259 AllOf[ParamMatchType],

12260 ]

12261 ],

12262 AtMostN[

12263 Union[

12264 ParamMatchType,

12265 DoNotCareSentinel,

12266 OneOf[ParamMatchType],

12267 AllOf[ParamMatchType],

12268 ]

12269 ],

12270 ]

12271 ],

12272 DoNotCareSentinel,

12273 MatchIfTrue[Sequence[cst.Param]],

12274 OneOf[

12275 Union[

12276 Sequence[

12277 Union[

12278 ParamMatchType,

12279 OneOf[ParamMatchType],

12280 AllOf[ParamMatchType],

12281 AtLeastN[

12282 Union[

12283 ParamMatchType,

12284 OneOf[ParamMatchType],

12285 AllOf[ParamMatchType],

12286 ]

12287 ],

12288 AtMostN[

12289 Union[

12290 ParamMatchType,

12291 OneOf[ParamMatchType],

12292 AllOf[ParamMatchType],

12293 ]

12294 ],

12295 ]

12296 ],

12297 MatchIfTrue[Sequence[cst.Param]],

12298 ]

12299 ],

12300 AllOf[

12301 Union[

12302 Sequence[

12303 Union[

12304 ParamMatchType,

12305 OneOf[ParamMatchType],

12306 AllOf[ParamMatchType],

12307 AtLeastN[

12308 Union[

12309 ParamMatchType,

12310 OneOf[ParamMatchType],

12311 AllOf[ParamMatchType],

12312 ]

12313 ],

12314 AtMostN[

12315 Union[

12316 ParamMatchType,

12317 OneOf[ParamMatchType],

12318 AllOf[ParamMatchType],

12319 ]

12320 ],

12321 ]

12322 ],

12323 MatchIfTrue[Sequence[cst.Param]],

12324 ]

12325 ],

12326 ] = DoNotCare()

12327 posonly_ind: Union[

12328 ParamSlashMatchType,

12329 DoNotCareSentinel,

12330 OneOf[ParamSlashMatchType],

12331 AllOf[ParamSlashMatchType],

12332 ] = DoNotCare()

12333 metadata: Union[

12334 MetadataMatchType,

12335 DoNotCareSentinel,

12336 OneOf[MetadataMatchType],

12337 AllOf[MetadataMatchType],

12338 ] = DoNotCare()

12339

12340

12341@dataclass(frozen=True, eq=False, unsafe_hash=False)

12342class ParenthesizedWhitespace(BaseParenthesizableWhitespace, BaseMatcherNode):

12343 first_line: Union[

12344 TrailingWhitespaceMatchType,

12345 DoNotCareSentinel,

12346 OneOf[TrailingWhitespaceMatchType],

12347 AllOf[TrailingWhitespaceMatchType],

12348 ] = DoNotCare()

12349 empty_lines: Union[

12350 Sequence[

12351 Union[

12352 EmptyLineMatchType,

12353 DoNotCareSentinel,

12354 OneOf[EmptyLineMatchType],

12355 AllOf[EmptyLineMatchType],

12356 AtLeastN[

12357 Union[

12358 EmptyLineMatchType,

12359 DoNotCareSentinel,

12360 OneOf[EmptyLineMatchType],

12361 AllOf[EmptyLineMatchType],

12362 ]

12363 ],

12364 AtMostN[

12365 Union[

12366 EmptyLineMatchType,

12367 DoNotCareSentinel,

12368 OneOf[EmptyLineMatchType],

12369 AllOf[EmptyLineMatchType],

12370 ]

12371 ],

12372 ]

12373 ],

12374 DoNotCareSentinel,

12375 MatchIfTrue[Sequence[cst.EmptyLine]],

12376 OneOf[

12377 Union[

12378 Sequence[

12379 Union[

12380 EmptyLineMatchType,

12381 OneOf[EmptyLineMatchType],

12382 AllOf[EmptyLineMatchType],

12383 AtLeastN[

12384 Union[

12385 EmptyLineMatchType,

12386 OneOf[EmptyLineMatchType],

12387 AllOf[EmptyLineMatchType],

12388 ]

12389 ],

12390 AtMostN[

12391 Union[

12392 EmptyLineMatchType,

12393 OneOf[EmptyLineMatchType],

12394 AllOf[EmptyLineMatchType],

12395 ]

12396 ],

12397 ]

12398 ],

12399 MatchIfTrue[Sequence[cst.EmptyLine]],

12400 ]

12401 ],

12402 AllOf[

12403 Union[

12404 Sequence[

12405 Union[

12406 EmptyLineMatchType,

12407 OneOf[EmptyLineMatchType],

12408 AllOf[EmptyLineMatchType],

12409 AtLeastN[

12410 Union[

12411 EmptyLineMatchType,

12412 OneOf[EmptyLineMatchType],

12413 AllOf[EmptyLineMatchType],

12414 ]

12415 ],

12416 AtMostN[

12417 Union[

12418 EmptyLineMatchType,

12419 OneOf[EmptyLineMatchType],

12420 AllOf[EmptyLineMatchType],

12421 ]

12422 ],

12423 ]

12424 ],

12425 MatchIfTrue[Sequence[cst.EmptyLine]],

12426 ]

12427 ],

12428 ] = DoNotCare()

12429 indent: Union[

12430 boolMatchType, DoNotCareSentinel, OneOf[boolMatchType], AllOf[boolMatchType]

12431 ] = DoNotCare()

12432 last_line: Union[

12433 SimpleWhitespaceMatchType,

12434 DoNotCareSentinel,

12435 OneOf[SimpleWhitespaceMatchType],

12436 AllOf[SimpleWhitespaceMatchType],

12437 ] = DoNotCare()

12438 metadata: Union[

12439 MetadataMatchType,

12440 DoNotCareSentinel,

12441 OneOf[MetadataMatchType],

12442 AllOf[MetadataMatchType],

12443 ] = DoNotCare()

12444

12445

12446@dataclass(frozen=True, eq=False, unsafe_hash=False)

12447class Pass(BaseSmallStatement, BaseMatcherNode):

12448 semicolon: Union[

12449 SemicolonMatchType,

12450 DoNotCareSentinel,

12451 OneOf[SemicolonMatchType],

12452 AllOf[SemicolonMatchType],

12453 ] = DoNotCare()

12454 metadata: Union[

12455 MetadataMatchType,

12456 DoNotCareSentinel,

12457 OneOf[MetadataMatchType],

12458 AllOf[MetadataMatchType],

12459 ] = DoNotCare()

12460

12461

12462@dataclass(frozen=True, eq=False, unsafe_hash=False)

12463class Plus(BaseUnaryOp, BaseMatcherNode):

12464 whitespace_after: Union[

12465 BaseParenthesizableWhitespaceMatchType,

12466 DoNotCareSentinel,

12467 OneOf[BaseParenthesizableWhitespaceMatchType],

12468 AllOf[BaseParenthesizableWhitespaceMatchType],

12469 ] = DoNotCare()

12470 metadata: Union[

12471 MetadataMatchType,

12472 DoNotCareSentinel,

12473 OneOf[MetadataMatchType],

12474 AllOf[MetadataMatchType],

12475 ] = DoNotCare()

12476

12477

12478@dataclass(frozen=True, eq=False, unsafe_hash=False)

12479class Power(BaseBinaryOp, BaseMatcherNode):

12480 whitespace_before: Union[

12481 BaseParenthesizableWhitespaceMatchType,

12482 DoNotCareSentinel,

12483 OneOf[BaseParenthesizableWhitespaceMatchType],

12484 AllOf[BaseParenthesizableWhitespaceMatchType],

12485 ] = DoNotCare()

12486 whitespace_after: Union[

12487 BaseParenthesizableWhitespaceMatchType,

12488 DoNotCareSentinel,

12489 OneOf[BaseParenthesizableWhitespaceMatchType],

12490 AllOf[BaseParenthesizableWhitespaceMatchType],

12491 ] = DoNotCare()

12492 metadata: Union[

12493 MetadataMatchType,

12494 DoNotCareSentinel,

12495 OneOf[MetadataMatchType],

12496 AllOf[MetadataMatchType],

12497 ] = DoNotCare()

12498

12499

12500@dataclass(frozen=True, eq=False, unsafe_hash=False)

12501class PowerAssign(BaseAugOp, BaseMatcherNode):

12502 whitespace_before: Union[

12503 BaseParenthesizableWhitespaceMatchType,

12504 DoNotCareSentinel,

12505 OneOf[BaseParenthesizableWhitespaceMatchType],

12506 AllOf[BaseParenthesizableWhitespaceMatchType],

12507 ] = DoNotCare()

12508 whitespace_after: Union[

12509 BaseParenthesizableWhitespaceMatchType,

12510 DoNotCareSentinel,

12511 OneOf[BaseParenthesizableWhitespaceMatchType],

12512 AllOf[BaseParenthesizableWhitespaceMatchType],

12513 ] = DoNotCare()

12514 metadata: Union[

12515 MetadataMatchType,

12516 DoNotCareSentinel,

12517 OneOf[MetadataMatchType],

12518 AllOf[MetadataMatchType],

12519 ] = DoNotCare()

12520

12521

12522@dataclass(frozen=True, eq=False, unsafe_hash=False)

12523class Raise(BaseSmallStatement, BaseMatcherNode):

12524 exc: Union[

12525 Optional["BaseExpression"],

12526 MetadataMatchType,

12527 MatchIfTrue[Optional[cst.BaseExpression]],

12528 DoNotCareSentinel,

12529 OneOf[

12530 Union[

12531 Optional["BaseExpression"],

12532 MetadataMatchType,

12533 MatchIfTrue[Optional[cst.BaseExpression]],

12534 ]

12535 ],

12536 AllOf[

12537 Union[

12538 Optional["BaseExpression"],

12539 MetadataMatchType,

12540 MatchIfTrue[Optional[cst.BaseExpression]],

12541 ]

12542 ],

12543 ] = DoNotCare()

12544 cause: Union[

12545 Optional["From"],

12546 MetadataMatchType,

12547 MatchIfTrue[Optional[cst.From]],

12548 DoNotCareSentinel,

12549 OneOf[

12550 Union[Optional["From"], MetadataMatchType, MatchIfTrue[Optional[cst.From]]]

12551 ],

12552 AllOf[

12553 Union[Optional["From"], MetadataMatchType, MatchIfTrue[Optional[cst.From]]]

12554 ],

12555 ] = DoNotCare()

12556 whitespace_after_raise: Union[

12557 SimpleWhitespaceMatchType,

12558 DoNotCareSentinel,

12559 OneOf[SimpleWhitespaceMatchType],

12560 AllOf[SimpleWhitespaceMatchType],

12561 ] = DoNotCare()

12562 semicolon: Union[

12563 SemicolonMatchType,

12564 DoNotCareSentinel,

12565 OneOf[SemicolonMatchType],

12566 AllOf[SemicolonMatchType],

12567 ] = DoNotCare()

12568 metadata: Union[

12569 MetadataMatchType,

12570 DoNotCareSentinel,

12571 OneOf[MetadataMatchType],

12572 AllOf[MetadataMatchType],

12573 ] = DoNotCare()

12574

12575

12576@dataclass(frozen=True, eq=False, unsafe_hash=False)

12577class Return(BaseSmallStatement, BaseMatcherNode):

12578 value: Union[

12579 Optional["BaseExpression"],

12580 MetadataMatchType,

12581 MatchIfTrue[Optional[cst.BaseExpression]],

12582 DoNotCareSentinel,

12583 OneOf[

12584 Union[

12585 Optional["BaseExpression"],

12586 MetadataMatchType,

12587 MatchIfTrue[Optional[cst.BaseExpression]],

12588 ]

12589 ],

12590 AllOf[

12591 Union[

12592 Optional["BaseExpression"],

12593 MetadataMatchType,

12594 MatchIfTrue[Optional[cst.BaseExpression]],

12595 ]

12596 ],

12597 ] = DoNotCare()

12598 whitespace_after_return: Union[

12599 SimpleWhitespaceMatchType,

12600 DoNotCareSentinel,

12601 OneOf[SimpleWhitespaceMatchType],

12602 AllOf[SimpleWhitespaceMatchType],

12603 ] = DoNotCare()

12604 semicolon: Union[

12605 SemicolonMatchType,

12606 DoNotCareSentinel,

12607 OneOf[SemicolonMatchType],

12608 AllOf[SemicolonMatchType],

12609 ] = DoNotCare()

12610 metadata: Union[

12611 MetadataMatchType,

12612 DoNotCareSentinel,

12613 OneOf[MetadataMatchType],

12614 AllOf[MetadataMatchType],

12615 ] = DoNotCare()

12616

12617

12618@dataclass(frozen=True, eq=False, unsafe_hash=False)

12619class RightCurlyBrace(BaseMatcherNode):

12620 whitespace_before: Union[

12621 BaseParenthesizableWhitespaceMatchType,

12622 DoNotCareSentinel,

12623 OneOf[BaseParenthesizableWhitespaceMatchType],

12624 AllOf[BaseParenthesizableWhitespaceMatchType],

12625 ] = DoNotCare()

12626 metadata: Union[

12627 MetadataMatchType,

12628 DoNotCareSentinel,

12629 OneOf[MetadataMatchType],

12630 AllOf[MetadataMatchType],

12631 ] = DoNotCare()

12632

12633

12634@dataclass(frozen=True, eq=False, unsafe_hash=False)

12635class RightParen(BaseMatcherNode):

12636 whitespace_before: Union[

12637 BaseParenthesizableWhitespaceMatchType,

12638 DoNotCareSentinel,

12639 OneOf[BaseParenthesizableWhitespaceMatchType],

12640 AllOf[BaseParenthesizableWhitespaceMatchType],

12641 ] = DoNotCare()

12642 metadata: Union[

12643 MetadataMatchType,

12644 DoNotCareSentinel,

12645 OneOf[MetadataMatchType],

12646 AllOf[MetadataMatchType],

12647 ] = DoNotCare()

12648

12649

12650@dataclass(frozen=True, eq=False, unsafe_hash=False)

12651class RightShift(BaseBinaryOp, BaseMatcherNode):

12652 whitespace_before: Union[

12653 BaseParenthesizableWhitespaceMatchType,

12654 DoNotCareSentinel,

12655 OneOf[BaseParenthesizableWhitespaceMatchType],

12656 AllOf[BaseParenthesizableWhitespaceMatchType],

12657 ] = DoNotCare()

12658 whitespace_after: Union[

12659 BaseParenthesizableWhitespaceMatchType,

12660 DoNotCareSentinel,

12661 OneOf[BaseParenthesizableWhitespaceMatchType],

12662 AllOf[BaseParenthesizableWhitespaceMatchType],

12663 ] = DoNotCare()

12664 metadata: Union[

12665 MetadataMatchType,

12666 DoNotCareSentinel,

12667 OneOf[MetadataMatchType],

12668 AllOf[MetadataMatchType],

12669 ] = DoNotCare()

12670

12671

12672@dataclass(frozen=True, eq=False, unsafe_hash=False)

12673class RightShiftAssign(BaseAugOp, BaseMatcherNode):

12674 whitespace_before: Union[

12675 BaseParenthesizableWhitespaceMatchType,

12676 DoNotCareSentinel,

12677 OneOf[BaseParenthesizableWhitespaceMatchType],

12678 AllOf[BaseParenthesizableWhitespaceMatchType],

12679 ] = DoNotCare()

12680 whitespace_after: Union[

12681 BaseParenthesizableWhitespaceMatchType,

12682 DoNotCareSentinel,

12683 OneOf[BaseParenthesizableWhitespaceMatchType],

12684 AllOf[BaseParenthesizableWhitespaceMatchType],

12685 ] = DoNotCare()

12686 metadata: Union[

12687 MetadataMatchType,

12688 DoNotCareSentinel,

12689 OneOf[MetadataMatchType],

12690 AllOf[MetadataMatchType],

12691 ] = DoNotCare()

12692

12693

12694@dataclass(frozen=True, eq=False, unsafe_hash=False)

12695class RightSquareBracket(BaseMatcherNode):

12696 whitespace_before: Union[

12697 BaseParenthesizableWhitespaceMatchType,

12698 DoNotCareSentinel,

12699 OneOf[BaseParenthesizableWhitespaceMatchType],

12700 AllOf[BaseParenthesizableWhitespaceMatchType],

12701 ] = DoNotCare()

12702 metadata: Union[

12703 MetadataMatchType,

12704 DoNotCareSentinel,

12705 OneOf[MetadataMatchType],

12706 AllOf[MetadataMatchType],

12707 ] = DoNotCare()

12708

12709

12710@dataclass(frozen=True, eq=False, unsafe_hash=False)

12711class Semicolon(BaseMatcherNode):

12712 whitespace_before: Union[

12713 BaseParenthesizableWhitespaceMatchType,

12714 DoNotCareSentinel,

12715 OneOf[BaseParenthesizableWhitespaceMatchType],

12716 AllOf[BaseParenthesizableWhitespaceMatchType],

12717 ] = DoNotCare()

12718 whitespace_after: Union[

12719 BaseParenthesizableWhitespaceMatchType,

12720 DoNotCareSentinel,

12721 OneOf[BaseParenthesizableWhitespaceMatchType],

12722 AllOf[BaseParenthesizableWhitespaceMatchType],

12723 ] = DoNotCare()

12724 metadata: Union[

12725 MetadataMatchType,

12726 DoNotCareSentinel,

12727 OneOf[MetadataMatchType],

12728 AllOf[MetadataMatchType],

12729 ] = DoNotCare()

12730

12731

12732@dataclass(frozen=True, eq=False, unsafe_hash=False)

12733class Set(BaseExpression, BaseSet, BaseMatcherNode):

12734 elements: Union[

12735 Sequence[

12736 Union[

12737 BaseElementMatchType,

12738 DoNotCareSentinel,

12739 OneOf[BaseElementMatchType],

12740 AllOf[BaseElementMatchType],

12741 AtLeastN[

12742 Union[

12743 BaseElementMatchType,

12744 DoNotCareSentinel,

12745 OneOf[BaseElementMatchType],

12746 AllOf[BaseElementMatchType],

12747 ]

12748 ],

12749 AtMostN[

12750 Union[

12751 BaseElementMatchType,

12752 DoNotCareSentinel,

12753 OneOf[BaseElementMatchType],

12754 AllOf[BaseElementMatchType],

12755 ]

12756 ],

12757 ]

12758 ],

12759 DoNotCareSentinel,

12760 MatchIfTrue[Sequence[cst.BaseElement]],

12761 OneOf[

12762 Union[

12763 Sequence[

12764 Union[

12765 BaseElementMatchType,

12766 OneOf[BaseElementMatchType],

12767 AllOf[BaseElementMatchType],

12768 AtLeastN[

12769 Union[

12770 BaseElementMatchType,

12771 OneOf[BaseElementMatchType],

12772 AllOf[BaseElementMatchType],

12773 ]

12774 ],

12775 AtMostN[

12776 Union[

12777 BaseElementMatchType,

12778 OneOf[BaseElementMatchType],

12779 AllOf[BaseElementMatchType],

12780 ]

12781 ],

12782 ]

12783 ],

12784 MatchIfTrue[Sequence[cst.BaseElement]],

12785 ]

12786 ],

12787 AllOf[

12788 Union[

12789 Sequence[

12790 Union[

12791 BaseElementMatchType,

12792 OneOf[BaseElementMatchType],

12793 AllOf[BaseElementMatchType],

12794 AtLeastN[

12795 Union[

12796 BaseElementMatchType,

12797 OneOf[BaseElementMatchType],

12798 AllOf[BaseElementMatchType],

12799 ]

12800 ],

12801 AtMostN[

12802 Union[

12803 BaseElementMatchType,

12804 OneOf[BaseElementMatchType],

12805 AllOf[BaseElementMatchType],

12806 ]

12807 ],

12808 ]

12809 ],

12810 MatchIfTrue[Sequence[cst.BaseElement]],

12811 ]

12812 ],

12813 ] = DoNotCare()

12814 lbrace: Union[

12815 LeftCurlyBraceMatchType,

12816 DoNotCareSentinel,

12817 OneOf[LeftCurlyBraceMatchType],

12818 AllOf[LeftCurlyBraceMatchType],

12819 ] = DoNotCare()

12820 rbrace: Union[

12821 RightCurlyBraceMatchType,

12822 DoNotCareSentinel,

12823 OneOf[RightCurlyBraceMatchType],

12824 AllOf[RightCurlyBraceMatchType],

12825 ] = DoNotCare()

12826 lpar: Union[

12827 Sequence[

12828 Union[

12829 LeftParenMatchType,

12830 DoNotCareSentinel,

12831 OneOf[LeftParenMatchType],

12832 AllOf[LeftParenMatchType],

12833 AtLeastN[

12834 Union[

12835 LeftParenMatchType,

12836 DoNotCareSentinel,

12837 OneOf[LeftParenMatchType],

12838 AllOf[LeftParenMatchType],

12839 ]

12840 ],

12841 AtMostN[

12842 Union[

12843 LeftParenMatchType,

12844 DoNotCareSentinel,

12845 OneOf[LeftParenMatchType],

12846 AllOf[LeftParenMatchType],

12847 ]

12848 ],

12849 ]

12850 ],

12851 DoNotCareSentinel,

12852 MatchIfTrue[Sequence[cst.LeftParen]],

12853 OneOf[

12854 Union[

12855 Sequence[

12856 Union[

12857 LeftParenMatchType,

12858 OneOf[LeftParenMatchType],

12859 AllOf[LeftParenMatchType],

12860 AtLeastN[

12861 Union[

12862 LeftParenMatchType,

12863 OneOf[LeftParenMatchType],

12864 AllOf[LeftParenMatchType],

12865 ]

12866 ],

12867 AtMostN[

12868 Union[

12869 LeftParenMatchType,

12870 OneOf[LeftParenMatchType],

12871 AllOf[LeftParenMatchType],

12872 ]

12873 ],

12874 ]

12875 ],

12876 MatchIfTrue[Sequence[cst.LeftParen]],

12877 ]

12878 ],

12879 AllOf[

12880 Union[

12881 Sequence[

12882 Union[

12883 LeftParenMatchType,

12884 OneOf[LeftParenMatchType],

12885 AllOf[LeftParenMatchType],

12886 AtLeastN[

12887 Union[

12888 LeftParenMatchType,

12889 OneOf[LeftParenMatchType],

12890 AllOf[LeftParenMatchType],

12891 ]

12892 ],

12893 AtMostN[

12894 Union[

12895 LeftParenMatchType,

12896 OneOf[LeftParenMatchType],

12897 AllOf[LeftParenMatchType],

12898 ]

12899 ],

12900 ]

12901 ],

12902 MatchIfTrue[Sequence[cst.LeftParen]],

12903 ]

12904 ],

12905 ] = DoNotCare()

12906 rpar: Union[

12907 Sequence[

12908 Union[

12909 RightParenMatchType,

12910 DoNotCareSentinel,

12911 OneOf[RightParenMatchType],

12912 AllOf[RightParenMatchType],

12913 AtLeastN[

12914 Union[

12915 RightParenMatchType,

12916 DoNotCareSentinel,

12917 OneOf[RightParenMatchType],

12918 AllOf[RightParenMatchType],

12919 ]

12920 ],

12921 AtMostN[

12922 Union[

12923 RightParenMatchType,

12924 DoNotCareSentinel,

12925 OneOf[RightParenMatchType],

12926 AllOf[RightParenMatchType],

12927 ]

12928 ],

12929 ]

12930 ],

12931 DoNotCareSentinel,

12932 MatchIfTrue[Sequence[cst.RightParen]],

12933 OneOf[

12934 Union[

12935 Sequence[

12936 Union[

12937 RightParenMatchType,

12938 OneOf[RightParenMatchType],

12939 AllOf[RightParenMatchType],

12940 AtLeastN[

12941 Union[

12942 RightParenMatchType,

12943 OneOf[RightParenMatchType],

12944 AllOf[RightParenMatchType],

12945 ]

12946 ],

12947 AtMostN[

12948 Union[

12949 RightParenMatchType,

12950 OneOf[RightParenMatchType],

12951 AllOf[RightParenMatchType],

12952 ]

12953 ],

12954 ]

12955 ],

12956 MatchIfTrue[Sequence[cst.RightParen]],

12957 ]

12958 ],

12959 AllOf[

12960 Union[

12961 Sequence[

12962 Union[

12963 RightParenMatchType,

12964 OneOf[RightParenMatchType],

12965 AllOf[RightParenMatchType],

12966 AtLeastN[

12967 Union[

12968 RightParenMatchType,

12969 OneOf[RightParenMatchType],

12970 AllOf[RightParenMatchType],

12971 ]

12972 ],

12973 AtMostN[

12974 Union[

12975 RightParenMatchType,

12976 OneOf[RightParenMatchType],

12977 AllOf[RightParenMatchType],

12978 ]

12979 ],

12980 ]

12981 ],

12982 MatchIfTrue[Sequence[cst.RightParen]],

12983 ]

12984 ],

12985 ] = DoNotCare()

12986 metadata: Union[

12987 MetadataMatchType,

12988 DoNotCareSentinel,

12989 OneOf[MetadataMatchType],

12990 AllOf[MetadataMatchType],

12991 ] = DoNotCare()

12992

12993

12994@dataclass(frozen=True, eq=False, unsafe_hash=False)

12995class SetComp(BaseComp, BaseExpression, BaseSet, BaseSimpleComp, BaseMatcherNode):

12996 elt: Union[

12997 BaseExpressionMatchType,

12998 DoNotCareSentinel,

12999 OneOf[BaseExpressionMatchType],

13000 AllOf[BaseExpressionMatchType],

13001 ] = DoNotCare()

13002 for_in: Union[

13003 CompForMatchType,

13004 DoNotCareSentinel,

13005 OneOf[CompForMatchType],

13006 AllOf[CompForMatchType],

13007 ] = DoNotCare()

13008 lbrace: Union[

13009 LeftCurlyBraceMatchType,

13010 DoNotCareSentinel,

13011 OneOf[LeftCurlyBraceMatchType],

13012 AllOf[LeftCurlyBraceMatchType],

13013 ] = DoNotCare()

13014 rbrace: Union[

13015 RightCurlyBraceMatchType,

13016 DoNotCareSentinel,

13017 OneOf[RightCurlyBraceMatchType],

13018 AllOf[RightCurlyBraceMatchType],

13019 ] = DoNotCare()

13020 lpar: Union[

13021 Sequence[

13022 Union[

13023 LeftParenMatchType,

13024 DoNotCareSentinel,

13025 OneOf[LeftParenMatchType],

13026 AllOf[LeftParenMatchType],

13027 AtLeastN[

13028 Union[

13029 LeftParenMatchType,

13030 DoNotCareSentinel,

13031 OneOf[LeftParenMatchType],

13032 AllOf[LeftParenMatchType],

13033 ]

13034 ],

13035 AtMostN[

13036 Union[

13037 LeftParenMatchType,

13038 DoNotCareSentinel,

13039 OneOf[LeftParenMatchType],

13040 AllOf[LeftParenMatchType],

13041 ]

13042 ],

13043 ]

13044 ],

13045 DoNotCareSentinel,

13046 MatchIfTrue[Sequence[cst.LeftParen]],

13047 OneOf[

13048 Union[

13049 Sequence[

13050 Union[

13051 LeftParenMatchType,

13052 OneOf[LeftParenMatchType],

13053 AllOf[LeftParenMatchType],

13054 AtLeastN[

13055 Union[

13056 LeftParenMatchType,

13057 OneOf[LeftParenMatchType],

13058 AllOf[LeftParenMatchType],

13059 ]

13060 ],

13061 AtMostN[

13062 Union[

13063 LeftParenMatchType,

13064 OneOf[LeftParenMatchType],

13065 AllOf[LeftParenMatchType],

13066 ]

13067 ],

13068 ]

13069 ],

13070 MatchIfTrue[Sequence[cst.LeftParen]],

13071 ]

13072 ],

13073 AllOf[

13074 Union[

13075 Sequence[

13076 Union[

13077 LeftParenMatchType,

13078 OneOf[LeftParenMatchType],

13079 AllOf[LeftParenMatchType],

13080 AtLeastN[

13081 Union[

13082 LeftParenMatchType,

13083 OneOf[LeftParenMatchType],

13084 AllOf[LeftParenMatchType],

13085 ]

13086 ],

13087 AtMostN[

13088 Union[

13089 LeftParenMatchType,

13090 OneOf[LeftParenMatchType],

13091 AllOf[LeftParenMatchType],

13092 ]

13093 ],

13094 ]

13095 ],

13096 MatchIfTrue[Sequence[cst.LeftParen]],

13097 ]

13098 ],

13099 ] = DoNotCare()

13100 rpar: Union[

13101 Sequence[

13102 Union[

13103 RightParenMatchType,

13104 DoNotCareSentinel,

13105 OneOf[RightParenMatchType],

13106 AllOf[RightParenMatchType],

13107 AtLeastN[

13108 Union[

13109 RightParenMatchType,

13110 DoNotCareSentinel,

13111 OneOf[RightParenMatchType],

13112 AllOf[RightParenMatchType],

13113 ]

13114 ],

13115 AtMostN[

13116 Union[

13117 RightParenMatchType,

13118 DoNotCareSentinel,

13119 OneOf[RightParenMatchType],

13120 AllOf[RightParenMatchType],

13121 ]

13122 ],

13123 ]

13124 ],

13125 DoNotCareSentinel,

13126 MatchIfTrue[Sequence[cst.RightParen]],

13127 OneOf[

13128 Union[

13129 Sequence[

13130 Union[

13131 RightParenMatchType,

13132 OneOf[RightParenMatchType],

13133 AllOf[RightParenMatchType],

13134 AtLeastN[

13135 Union[

13136 RightParenMatchType,

13137 OneOf[RightParenMatchType],

13138 AllOf[RightParenMatchType],

13139 ]

13140 ],

13141 AtMostN[

13142 Union[

13143 RightParenMatchType,

13144 OneOf[RightParenMatchType],

13145 AllOf[RightParenMatchType],

13146 ]

13147 ],

13148 ]

13149 ],

13150 MatchIfTrue[Sequence[cst.RightParen]],

13151 ]

13152 ],

13153 AllOf[

13154 Union[

13155 Sequence[

13156 Union[

13157 RightParenMatchType,

13158 OneOf[RightParenMatchType],

13159 AllOf[RightParenMatchType],

13160 AtLeastN[

13161 Union[

13162 RightParenMatchType,

13163 OneOf[RightParenMatchType],

13164 AllOf[RightParenMatchType],

13165 ]

13166 ],

13167 AtMostN[

13168 Union[

13169 RightParenMatchType,

13170 OneOf[RightParenMatchType],

13171 AllOf[RightParenMatchType],

13172 ]

13173 ],

13174 ]

13175 ],

13176 MatchIfTrue[Sequence[cst.RightParen]],

13177 ]

13178 ],

13179 ] = DoNotCare()

13180 metadata: Union[

13181 MetadataMatchType,

13182 DoNotCareSentinel,

13183 OneOf[MetadataMatchType],

13184 AllOf[MetadataMatchType],

13185 ] = DoNotCare()

13186

13187

13188BaseSmallStatementMatchType = Union[

13189 "BaseSmallStatement", MetadataMatchType, MatchIfTrue[cst.BaseSmallStatement]

13190]

13191

13192

13193@dataclass(frozen=True, eq=False, unsafe_hash=False)

13194class SimpleStatementLine(BaseStatement, BaseMatcherNode):

13195 body: Union[

13196 Sequence[

13197 Union[

13198 BaseSmallStatementMatchType,

13199 DoNotCareSentinel,

13200 OneOf[BaseSmallStatementMatchType],

13201 AllOf[BaseSmallStatementMatchType],

13202 AtLeastN[

13203 Union[

13204 BaseSmallStatementMatchType,

13205 DoNotCareSentinel,

13206 OneOf[BaseSmallStatementMatchType],

13207 AllOf[BaseSmallStatementMatchType],

13208 ]

13209 ],

13210 AtMostN[

13211 Union[

13212 BaseSmallStatementMatchType,

13213 DoNotCareSentinel,

13214 OneOf[BaseSmallStatementMatchType],

13215 AllOf[BaseSmallStatementMatchType],

13216 ]

13217 ],

13218 ]

13219 ],

13220 DoNotCareSentinel,

13221 MatchIfTrue[Sequence[cst.BaseSmallStatement]],

13222 OneOf[

13223 Union[

13224 Sequence[

13225 Union[

13226 BaseSmallStatementMatchType,

13227 OneOf[BaseSmallStatementMatchType],

13228 AllOf[BaseSmallStatementMatchType],

13229 AtLeastN[

13230 Union[

13231 BaseSmallStatementMatchType,

13232 OneOf[BaseSmallStatementMatchType],

13233 AllOf[BaseSmallStatementMatchType],

13234 ]

13235 ],

13236 AtMostN[

13237 Union[

13238 BaseSmallStatementMatchType,

13239 OneOf[BaseSmallStatementMatchType],

13240 AllOf[BaseSmallStatementMatchType],

13241 ]

13242 ],

13243 ]

13244 ],

13245 MatchIfTrue[Sequence[cst.BaseSmallStatement]],

13246 ]

13247 ],

13248 AllOf[

13249 Union[

13250 Sequence[

13251 Union[

13252 BaseSmallStatementMatchType,

13253 OneOf[BaseSmallStatementMatchType],

13254 AllOf[BaseSmallStatementMatchType],

13255 AtLeastN[

13256 Union[

13257 BaseSmallStatementMatchType,

13258 OneOf[BaseSmallStatementMatchType],

13259 AllOf[BaseSmallStatementMatchType],

13260 ]

13261 ],

13262 AtMostN[

13263 Union[

13264 BaseSmallStatementMatchType,

13265 OneOf[BaseSmallStatementMatchType],

13266 AllOf[BaseSmallStatementMatchType],

13267 ]

13268 ],

13269 ]

13270 ],

13271 MatchIfTrue[Sequence[cst.BaseSmallStatement]],

13272 ]

13273 ],

13274 ] = DoNotCare()

13275 leading_lines: Union[

13276 Sequence[

13277 Union[

13278 EmptyLineMatchType,

13279 DoNotCareSentinel,

13280 OneOf[EmptyLineMatchType],

13281 AllOf[EmptyLineMatchType],

13282 AtLeastN[

13283 Union[

13284 EmptyLineMatchType,

13285 DoNotCareSentinel,

13286 OneOf[EmptyLineMatchType],

13287 AllOf[EmptyLineMatchType],

13288 ]

13289 ],

13290 AtMostN[

13291 Union[

13292 EmptyLineMatchType,

13293 DoNotCareSentinel,

13294 OneOf[EmptyLineMatchType],

13295 AllOf[EmptyLineMatchType],

13296 ]

13297 ],

13298 ]

13299 ],

13300 DoNotCareSentinel,

13301 MatchIfTrue[Sequence[cst.EmptyLine]],

13302 OneOf[

13303 Union[

13304 Sequence[

13305 Union[

13306 EmptyLineMatchType,

13307 OneOf[EmptyLineMatchType],

13308 AllOf[EmptyLineMatchType],

13309 AtLeastN[

13310 Union[

13311 EmptyLineMatchType,

13312 OneOf[EmptyLineMatchType],

13313 AllOf[EmptyLineMatchType],

13314 ]

13315 ],

13316 AtMostN[

13317 Union[

13318 EmptyLineMatchType,

13319 OneOf[EmptyLineMatchType],

13320 AllOf[EmptyLineMatchType],

13321 ]

13322 ],

13323 ]

13324 ],

13325 MatchIfTrue[Sequence[cst.EmptyLine]],

13326 ]

13327 ],

13328 AllOf[

13329 Union[

13330 Sequence[

13331 Union[

13332 EmptyLineMatchType,

13333 OneOf[EmptyLineMatchType],

13334 AllOf[EmptyLineMatchType],

13335 AtLeastN[

13336 Union[

13337 EmptyLineMatchType,

13338 OneOf[EmptyLineMatchType],

13339 AllOf[EmptyLineMatchType],

13340 ]

13341 ],

13342 AtMostN[

13343 Union[

13344 EmptyLineMatchType,

13345 OneOf[EmptyLineMatchType],

13346 AllOf[EmptyLineMatchType],

13347 ]

13348 ],

13349 ]

13350 ],

13351 MatchIfTrue[Sequence[cst.EmptyLine]],

13352 ]

13353 ],

13354 ] = DoNotCare()

13355 trailing_whitespace: Union[

13356 TrailingWhitespaceMatchType,

13357 DoNotCareSentinel,

13358 OneOf[TrailingWhitespaceMatchType],

13359 AllOf[TrailingWhitespaceMatchType],

13360 ] = DoNotCare()

13361 metadata: Union[

13362 MetadataMatchType,

13363 DoNotCareSentinel,

13364 OneOf[MetadataMatchType],

13365 AllOf[MetadataMatchType],

13366 ] = DoNotCare()

13367

13368

13369@dataclass(frozen=True, eq=False, unsafe_hash=False)

13370class SimpleStatementSuite(BaseSuite, BaseMatcherNode):

13371 body: Union[

13372 Sequence[

13373 Union[

13374 BaseSmallStatementMatchType,

13375 DoNotCareSentinel,

13376 OneOf[BaseSmallStatementMatchType],

13377 AllOf[BaseSmallStatementMatchType],

13378 AtLeastN[

13379 Union[

13380 BaseSmallStatementMatchType,

13381 DoNotCareSentinel,

13382 OneOf[BaseSmallStatementMatchType],

13383 AllOf[BaseSmallStatementMatchType],

13384 ]

13385 ],

13386 AtMostN[

13387 Union[

13388 BaseSmallStatementMatchType,

13389 DoNotCareSentinel,

13390 OneOf[BaseSmallStatementMatchType],

13391 AllOf[BaseSmallStatementMatchType],

13392 ]

13393 ],

13394 ]

13395 ],

13396 DoNotCareSentinel,

13397 MatchIfTrue[Sequence[cst.BaseSmallStatement]],

13398 OneOf[

13399 Union[

13400 Sequence[

13401 Union[

13402 BaseSmallStatementMatchType,

13403 OneOf[BaseSmallStatementMatchType],

13404 AllOf[BaseSmallStatementMatchType],

13405 AtLeastN[

13406 Union[

13407 BaseSmallStatementMatchType,

13408 OneOf[BaseSmallStatementMatchType],

13409 AllOf[BaseSmallStatementMatchType],

13410 ]

13411 ],

13412 AtMostN[

13413 Union[

13414 BaseSmallStatementMatchType,

13415 OneOf[BaseSmallStatementMatchType],

13416 AllOf[BaseSmallStatementMatchType],

13417 ]

13418 ],

13419 ]

13420 ],

13421 MatchIfTrue[Sequence[cst.BaseSmallStatement]],

13422 ]

13423 ],

13424 AllOf[

13425 Union[

13426 Sequence[

13427 Union[

13428 BaseSmallStatementMatchType,

13429 OneOf[BaseSmallStatementMatchType],

13430 AllOf[BaseSmallStatementMatchType],

13431 AtLeastN[

13432 Union[

13433 BaseSmallStatementMatchType,

13434 OneOf[BaseSmallStatementMatchType],

13435 AllOf[BaseSmallStatementMatchType],

13436 ]

13437 ],

13438 AtMostN[

13439 Union[

13440 BaseSmallStatementMatchType,

13441 OneOf[BaseSmallStatementMatchType],

13442 AllOf[BaseSmallStatementMatchType],

13443 ]

13444 ],

13445 ]

13446 ],

13447 MatchIfTrue[Sequence[cst.BaseSmallStatement]],

13448 ]

13449 ],

13450 ] = DoNotCare()

13451 leading_whitespace: Union[

13452 SimpleWhitespaceMatchType,

13453 DoNotCareSentinel,

13454 OneOf[SimpleWhitespaceMatchType],

13455 AllOf[SimpleWhitespaceMatchType],

13456 ] = DoNotCare()

13457 trailing_whitespace: Union[

13458 TrailingWhitespaceMatchType,

13459 DoNotCareSentinel,

13460 OneOf[TrailingWhitespaceMatchType],

13461 AllOf[TrailingWhitespaceMatchType],

13462 ] = DoNotCare()

13463 metadata: Union[

13464 MetadataMatchType,

13465 DoNotCareSentinel,

13466 OneOf[MetadataMatchType],

13467 AllOf[MetadataMatchType],

13468 ] = DoNotCare()

13469

13470

13471@dataclass(frozen=True, eq=False, unsafe_hash=False)

13472class SimpleString(BaseExpression, BaseString, BaseMatcherNode):

13473 value: Union[

13474 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

13475 ] = DoNotCare()

13476 lpar: Union[

13477 Sequence[

13478 Union[

13479 LeftParenMatchType,

13480 DoNotCareSentinel,

13481 OneOf[LeftParenMatchType],

13482 AllOf[LeftParenMatchType],

13483 AtLeastN[

13484 Union[

13485 LeftParenMatchType,

13486 DoNotCareSentinel,

13487 OneOf[LeftParenMatchType],

13488 AllOf[LeftParenMatchType],

13489 ]

13490 ],

13491 AtMostN[

13492 Union[

13493 LeftParenMatchType,

13494 DoNotCareSentinel,

13495 OneOf[LeftParenMatchType],

13496 AllOf[LeftParenMatchType],

13497 ]

13498 ],

13499 ]

13500 ],

13501 DoNotCareSentinel,

13502 MatchIfTrue[Sequence[cst.LeftParen]],

13503 OneOf[

13504 Union[

13505 Sequence[

13506 Union[

13507 LeftParenMatchType,

13508 OneOf[LeftParenMatchType],

13509 AllOf[LeftParenMatchType],

13510 AtLeastN[

13511 Union[

13512 LeftParenMatchType,

13513 OneOf[LeftParenMatchType],

13514 AllOf[LeftParenMatchType],

13515 ]

13516 ],

13517 AtMostN[

13518 Union[

13519 LeftParenMatchType,

13520 OneOf[LeftParenMatchType],

13521 AllOf[LeftParenMatchType],

13522 ]

13523 ],

13524 ]

13525 ],

13526 MatchIfTrue[Sequence[cst.LeftParen]],

13527 ]

13528 ],

13529 AllOf[

13530 Union[

13531 Sequence[

13532 Union[

13533 LeftParenMatchType,

13534 OneOf[LeftParenMatchType],

13535 AllOf[LeftParenMatchType],

13536 AtLeastN[

13537 Union[

13538 LeftParenMatchType,

13539 OneOf[LeftParenMatchType],

13540 AllOf[LeftParenMatchType],

13541 ]

13542 ],

13543 AtMostN[

13544 Union[

13545 LeftParenMatchType,

13546 OneOf[LeftParenMatchType],

13547 AllOf[LeftParenMatchType],

13548 ]

13549 ],

13550 ]

13551 ],

13552 MatchIfTrue[Sequence[cst.LeftParen]],

13553 ]

13554 ],

13555 ] = DoNotCare()

13556 rpar: Union[

13557 Sequence[

13558 Union[

13559 RightParenMatchType,

13560 DoNotCareSentinel,

13561 OneOf[RightParenMatchType],

13562 AllOf[RightParenMatchType],

13563 AtLeastN[

13564 Union[

13565 RightParenMatchType,

13566 DoNotCareSentinel,

13567 OneOf[RightParenMatchType],

13568 AllOf[RightParenMatchType],

13569 ]

13570 ],

13571 AtMostN[

13572 Union[

13573 RightParenMatchType,

13574 DoNotCareSentinel,

13575 OneOf[RightParenMatchType],

13576 AllOf[RightParenMatchType],

13577 ]

13578 ],

13579 ]

13580 ],

13581 DoNotCareSentinel,

13582 MatchIfTrue[Sequence[cst.RightParen]],

13583 OneOf[

13584 Union[

13585 Sequence[

13586 Union[

13587 RightParenMatchType,

13588 OneOf[RightParenMatchType],

13589 AllOf[RightParenMatchType],

13590 AtLeastN[

13591 Union[

13592 RightParenMatchType,

13593 OneOf[RightParenMatchType],

13594 AllOf[RightParenMatchType],

13595 ]

13596 ],

13597 AtMostN[

13598 Union[

13599 RightParenMatchType,

13600 OneOf[RightParenMatchType],

13601 AllOf[RightParenMatchType],

13602 ]

13603 ],

13604 ]

13605 ],

13606 MatchIfTrue[Sequence[cst.RightParen]],

13607 ]

13608 ],

13609 AllOf[

13610 Union[

13611 Sequence[

13612 Union[

13613 RightParenMatchType,

13614 OneOf[RightParenMatchType],

13615 AllOf[RightParenMatchType],

13616 AtLeastN[

13617 Union[

13618 RightParenMatchType,

13619 OneOf[RightParenMatchType],

13620 AllOf[RightParenMatchType],

13621 ]

13622 ],

13623 AtMostN[

13624 Union[

13625 RightParenMatchType,

13626 OneOf[RightParenMatchType],

13627 AllOf[RightParenMatchType],

13628 ]

13629 ],

13630 ]

13631 ],

13632 MatchIfTrue[Sequence[cst.RightParen]],

13633 ]

13634 ],

13635 ] = DoNotCare()

13636 metadata: Union[

13637 MetadataMatchType,

13638 DoNotCareSentinel,

13639 OneOf[MetadataMatchType],

13640 AllOf[MetadataMatchType],

13641 ] = DoNotCare()

13642

13643

13644@dataclass(frozen=True, eq=False, unsafe_hash=False)

13645class SimpleWhitespace(BaseParenthesizableWhitespace, BaseMatcherNode):

13646 value: Union[

13647 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

13648 ] = DoNotCare()

13649 metadata: Union[

13650 MetadataMatchType,

13651 DoNotCareSentinel,

13652 OneOf[MetadataMatchType],

13653 AllOf[MetadataMatchType],

13654 ] = DoNotCare()

13655

13656

13657@dataclass(frozen=True, eq=False, unsafe_hash=False)

13658class Slice(BaseSlice, BaseMatcherNode):

13659 lower: Union[

13660 Optional["BaseExpression"],

13661 MetadataMatchType,

13662 MatchIfTrue[Optional[cst.BaseExpression]],

13663 DoNotCareSentinel,

13664 OneOf[

13665 Union[

13666 Optional["BaseExpression"],

13667 MetadataMatchType,

13668 MatchIfTrue[Optional[cst.BaseExpression]],

13669 ]

13670 ],

13671 AllOf[

13672 Union[

13673 Optional["BaseExpression"],

13674 MetadataMatchType,

13675 MatchIfTrue[Optional[cst.BaseExpression]],

13676 ]

13677 ],

13678 ] = DoNotCare()

13679 upper: Union[

13680 Optional["BaseExpression"],

13681 MetadataMatchType,

13682 MatchIfTrue[Optional[cst.BaseExpression]],

13683 DoNotCareSentinel,

13684 OneOf[

13685 Union[

13686 Optional["BaseExpression"],

13687 MetadataMatchType,

13688 MatchIfTrue[Optional[cst.BaseExpression]],

13689 ]

13690 ],

13691 AllOf[

13692 Union[

13693 Optional["BaseExpression"],

13694 MetadataMatchType,

13695 MatchIfTrue[Optional[cst.BaseExpression]],

13696 ]

13697 ],

13698 ] = DoNotCare()

13699 step: Union[

13700 Optional["BaseExpression"],

13701 MetadataMatchType,

13702 MatchIfTrue[Optional[cst.BaseExpression]],

13703 DoNotCareSentinel,

13704 OneOf[

13705 Union[

13706 Optional["BaseExpression"],

13707 MetadataMatchType,

13708 MatchIfTrue[Optional[cst.BaseExpression]],

13709 ]

13710 ],

13711 AllOf[

13712 Union[

13713 Optional["BaseExpression"],

13714 MetadataMatchType,

13715 MatchIfTrue[Optional[cst.BaseExpression]],

13716 ]

13717 ],

13718 ] = DoNotCare()

13719 first_colon: Union[

13720 ColonMatchType, DoNotCareSentinel, OneOf[ColonMatchType], AllOf[ColonMatchType]

13721 ] = DoNotCare()

13722 second_colon: Union[

13723 ColonMatchType, DoNotCareSentinel, OneOf[ColonMatchType], AllOf[ColonMatchType]

13724 ] = DoNotCare()

13725 metadata: Union[

13726 MetadataMatchType,

13727 DoNotCareSentinel,

13728 OneOf[MetadataMatchType],

13729 AllOf[MetadataMatchType],

13730 ] = DoNotCare()

13731

13732

13733@dataclass(frozen=True, eq=False, unsafe_hash=False)

13734class StarredDictElement(BaseDictElement, BaseMatcherNode):

13735 value: Union[

13736 BaseExpressionMatchType,

13737 DoNotCareSentinel,

13738 OneOf[BaseExpressionMatchType],

13739 AllOf[BaseExpressionMatchType],

13740 ] = DoNotCare()

13741 comma: Union[

13742 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

13743 ] = DoNotCare()

13744 whitespace_before_value: Union[

13745 BaseParenthesizableWhitespaceMatchType,

13746 DoNotCareSentinel,

13747 OneOf[BaseParenthesizableWhitespaceMatchType],

13748 AllOf[BaseParenthesizableWhitespaceMatchType],

13749 ] = DoNotCare()

13750 metadata: Union[

13751 MetadataMatchType,

13752 DoNotCareSentinel,

13753 OneOf[MetadataMatchType],

13754 AllOf[MetadataMatchType],

13755 ] = DoNotCare()

13756

13757

13758@dataclass(frozen=True, eq=False, unsafe_hash=False)

13759class StarredElement(BaseElement, BaseExpression, BaseMatcherNode):

13760 value: Union[

13761 BaseExpressionMatchType,

13762 DoNotCareSentinel,

13763 OneOf[BaseExpressionMatchType],

13764 AllOf[BaseExpressionMatchType],

13765 ] = DoNotCare()

13766 comma: Union[

13767 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

13768 ] = DoNotCare()

13769 lpar: Union[

13770 Sequence[

13771 Union[

13772 LeftParenMatchType,

13773 DoNotCareSentinel,

13774 OneOf[LeftParenMatchType],

13775 AllOf[LeftParenMatchType],

13776 AtLeastN[

13777 Union[

13778 LeftParenMatchType,

13779 DoNotCareSentinel,

13780 OneOf[LeftParenMatchType],

13781 AllOf[LeftParenMatchType],

13782 ]

13783 ],

13784 AtMostN[

13785 Union[

13786 LeftParenMatchType,

13787 DoNotCareSentinel,

13788 OneOf[LeftParenMatchType],

13789 AllOf[LeftParenMatchType],

13790 ]

13791 ],

13792 ]

13793 ],

13794 DoNotCareSentinel,

13795 MatchIfTrue[Sequence[cst.LeftParen]],

13796 OneOf[

13797 Union[

13798 Sequence[

13799 Union[

13800 LeftParenMatchType,

13801 OneOf[LeftParenMatchType],

13802 AllOf[LeftParenMatchType],

13803 AtLeastN[

13804 Union[

13805 LeftParenMatchType,

13806 OneOf[LeftParenMatchType],

13807 AllOf[LeftParenMatchType],

13808 ]

13809 ],

13810 AtMostN[

13811 Union[

13812 LeftParenMatchType,

13813 OneOf[LeftParenMatchType],

13814 AllOf[LeftParenMatchType],

13815 ]

13816 ],

13817 ]

13818 ],

13819 MatchIfTrue[Sequence[cst.LeftParen]],

13820 ]

13821 ],

13822 AllOf[

13823 Union[

13824 Sequence[

13825 Union[

13826 LeftParenMatchType,

13827 OneOf[LeftParenMatchType],

13828 AllOf[LeftParenMatchType],

13829 AtLeastN[

13830 Union[

13831 LeftParenMatchType,

13832 OneOf[LeftParenMatchType],

13833 AllOf[LeftParenMatchType],

13834 ]

13835 ],

13836 AtMostN[

13837 Union[

13838 LeftParenMatchType,

13839 OneOf[LeftParenMatchType],

13840 AllOf[LeftParenMatchType],

13841 ]

13842 ],

13843 ]

13844 ],

13845 MatchIfTrue[Sequence[cst.LeftParen]],

13846 ]

13847 ],

13848 ] = DoNotCare()

13849 rpar: Union[

13850 Sequence[

13851 Union[

13852 RightParenMatchType,

13853 DoNotCareSentinel,

13854 OneOf[RightParenMatchType],

13855 AllOf[RightParenMatchType],

13856 AtLeastN[

13857 Union[

13858 RightParenMatchType,

13859 DoNotCareSentinel,

13860 OneOf[RightParenMatchType],

13861 AllOf[RightParenMatchType],

13862 ]

13863 ],

13864 AtMostN[

13865 Union[

13866 RightParenMatchType,

13867 DoNotCareSentinel,

13868 OneOf[RightParenMatchType],

13869 AllOf[RightParenMatchType],

13870 ]

13871 ],

13872 ]

13873 ],

13874 DoNotCareSentinel,

13875 MatchIfTrue[Sequence[cst.RightParen]],

13876 OneOf[

13877 Union[

13878 Sequence[

13879 Union[

13880 RightParenMatchType,

13881 OneOf[RightParenMatchType],

13882 AllOf[RightParenMatchType],

13883 AtLeastN[

13884 Union[

13885 RightParenMatchType,

13886 OneOf[RightParenMatchType],

13887 AllOf[RightParenMatchType],

13888 ]

13889 ],

13890 AtMostN[

13891 Union[

13892 RightParenMatchType,

13893 OneOf[RightParenMatchType],

13894 AllOf[RightParenMatchType],

13895 ]

13896 ],

13897 ]

13898 ],

13899 MatchIfTrue[Sequence[cst.RightParen]],

13900 ]

13901 ],

13902 AllOf[

13903 Union[

13904 Sequence[

13905 Union[

13906 RightParenMatchType,

13907 OneOf[RightParenMatchType],

13908 AllOf[RightParenMatchType],

13909 AtLeastN[

13910 Union[

13911 RightParenMatchType,

13912 OneOf[RightParenMatchType],

13913 AllOf[RightParenMatchType],

13914 ]

13915 ],

13916 AtMostN[

13917 Union[

13918 RightParenMatchType,

13919 OneOf[RightParenMatchType],

13920 AllOf[RightParenMatchType],

13921 ]

13922 ],

13923 ]

13924 ],

13925 MatchIfTrue[Sequence[cst.RightParen]],

13926 ]

13927 ],

13928 ] = DoNotCare()

13929 whitespace_before_value: Union[

13930 BaseParenthesizableWhitespaceMatchType,

13931 DoNotCareSentinel,

13932 OneOf[BaseParenthesizableWhitespaceMatchType],

13933 AllOf[BaseParenthesizableWhitespaceMatchType],

13934 ] = DoNotCare()

13935 metadata: Union[

13936 MetadataMatchType,

13937 DoNotCareSentinel,

13938 OneOf[MetadataMatchType],

13939 AllOf[MetadataMatchType],

13940 ] = DoNotCare()

13941

13942

13943SubscriptElementMatchType = Union[

13944 "SubscriptElement", MetadataMatchType, MatchIfTrue[cst.SubscriptElement]

13945]

13946

13947

13948@dataclass(frozen=True, eq=False, unsafe_hash=False)

13949class Subscript(

13950 BaseAssignTargetExpression, BaseDelTargetExpression, BaseExpression, BaseMatcherNode

13951):

13952 value: Union[

13953 BaseExpressionMatchType,

13954 DoNotCareSentinel,

13955 OneOf[BaseExpressionMatchType],

13956 AllOf[BaseExpressionMatchType],

13957 ] = DoNotCare()

13958 slice: Union[

13959 Sequence[

13960 Union[

13961 SubscriptElementMatchType,

13962 DoNotCareSentinel,

13963 OneOf[SubscriptElementMatchType],

13964 AllOf[SubscriptElementMatchType],

13965 AtLeastN[

13966 Union[

13967 SubscriptElementMatchType,

13968 DoNotCareSentinel,

13969 OneOf[SubscriptElementMatchType],

13970 AllOf[SubscriptElementMatchType],

13971 ]

13972 ],

13973 AtMostN[

13974 Union[

13975 SubscriptElementMatchType,

13976 DoNotCareSentinel,

13977 OneOf[SubscriptElementMatchType],

13978 AllOf[SubscriptElementMatchType],

13979 ]

13980 ],

13981 ]

13982 ],

13983 DoNotCareSentinel,

13984 MatchIfTrue[Sequence[cst.SubscriptElement]],

13985 OneOf[

13986 Union[

13987 Sequence[

13988 Union[

13989 SubscriptElementMatchType,

13990 OneOf[SubscriptElementMatchType],

13991 AllOf[SubscriptElementMatchType],

13992 AtLeastN[

13993 Union[

13994 SubscriptElementMatchType,

13995 OneOf[SubscriptElementMatchType],

13996 AllOf[SubscriptElementMatchType],

13997 ]

13998 ],

13999 AtMostN[

14000 Union[

14001 SubscriptElementMatchType,

14002 OneOf[SubscriptElementMatchType],

14003 AllOf[SubscriptElementMatchType],

14004 ]

14005 ],

14006 ]

14007 ],

14008 MatchIfTrue[Sequence[cst.SubscriptElement]],

14009 ]

14010 ],

14011 AllOf[

14012 Union[

14013 Sequence[

14014 Union[

14015 SubscriptElementMatchType,

14016 OneOf[SubscriptElementMatchType],

14017 AllOf[SubscriptElementMatchType],

14018 AtLeastN[

14019 Union[

14020 SubscriptElementMatchType,

14021 OneOf[SubscriptElementMatchType],

14022 AllOf[SubscriptElementMatchType],

14023 ]

14024 ],

14025 AtMostN[

14026 Union[

14027 SubscriptElementMatchType,

14028 OneOf[SubscriptElementMatchType],

14029 AllOf[SubscriptElementMatchType],

14030 ]

14031 ],

14032 ]

14033 ],

14034 MatchIfTrue[Sequence[cst.SubscriptElement]],

14035 ]

14036 ],

14037 ] = DoNotCare()

14038 lbracket: Union[

14039 LeftSquareBracketMatchType,

14040 DoNotCareSentinel,

14041 OneOf[LeftSquareBracketMatchType],

14042 AllOf[LeftSquareBracketMatchType],

14043 ] = DoNotCare()

14044 rbracket: Union[

14045 RightSquareBracketMatchType,

14046 DoNotCareSentinel,

14047 OneOf[RightSquareBracketMatchType],

14048 AllOf[RightSquareBracketMatchType],

14049 ] = DoNotCare()

14050 lpar: Union[

14051 Sequence[

14052 Union[

14053 LeftParenMatchType,

14054 DoNotCareSentinel,

14055 OneOf[LeftParenMatchType],

14056 AllOf[LeftParenMatchType],

14057 AtLeastN[

14058 Union[

14059 LeftParenMatchType,

14060 DoNotCareSentinel,

14061 OneOf[LeftParenMatchType],

14062 AllOf[LeftParenMatchType],

14063 ]

14064 ],

14065 AtMostN[

14066 Union[

14067 LeftParenMatchType,

14068 DoNotCareSentinel,

14069 OneOf[LeftParenMatchType],

14070 AllOf[LeftParenMatchType],

14071 ]

14072 ],

14073 ]

14074 ],

14075 DoNotCareSentinel,

14076 MatchIfTrue[Sequence[cst.LeftParen]],

14077 OneOf[

14078 Union[

14079 Sequence[

14080 Union[

14081 LeftParenMatchType,

14082 OneOf[LeftParenMatchType],

14083 AllOf[LeftParenMatchType],

14084 AtLeastN[

14085 Union[

14086 LeftParenMatchType,

14087 OneOf[LeftParenMatchType],

14088 AllOf[LeftParenMatchType],

14089 ]

14090 ],

14091 AtMostN[

14092 Union[

14093 LeftParenMatchType,

14094 OneOf[LeftParenMatchType],

14095 AllOf[LeftParenMatchType],

14096 ]

14097 ],

14098 ]

14099 ],

14100 MatchIfTrue[Sequence[cst.LeftParen]],

14101 ]

14102 ],

14103 AllOf[

14104 Union[

14105 Sequence[

14106 Union[

14107 LeftParenMatchType,

14108 OneOf[LeftParenMatchType],

14109 AllOf[LeftParenMatchType],

14110 AtLeastN[

14111 Union[

14112 LeftParenMatchType,

14113 OneOf[LeftParenMatchType],

14114 AllOf[LeftParenMatchType],

14115 ]

14116 ],

14117 AtMostN[

14118 Union[

14119 LeftParenMatchType,

14120 OneOf[LeftParenMatchType],

14121 AllOf[LeftParenMatchType],

14122 ]

14123 ],

14124 ]

14125 ],

14126 MatchIfTrue[Sequence[cst.LeftParen]],

14127 ]

14128 ],

14129 ] = DoNotCare()

14130 rpar: Union[

14131 Sequence[

14132 Union[

14133 RightParenMatchType,

14134 DoNotCareSentinel,

14135 OneOf[RightParenMatchType],

14136 AllOf[RightParenMatchType],

14137 AtLeastN[

14138 Union[

14139 RightParenMatchType,

14140 DoNotCareSentinel,

14141 OneOf[RightParenMatchType],

14142 AllOf[RightParenMatchType],

14143 ]

14144 ],

14145 AtMostN[

14146 Union[

14147 RightParenMatchType,

14148 DoNotCareSentinel,

14149 OneOf[RightParenMatchType],

14150 AllOf[RightParenMatchType],

14151 ]

14152 ],

14153 ]

14154 ],

14155 DoNotCareSentinel,

14156 MatchIfTrue[Sequence[cst.RightParen]],

14157 OneOf[

14158 Union[

14159 Sequence[

14160 Union[

14161 RightParenMatchType,

14162 OneOf[RightParenMatchType],

14163 AllOf[RightParenMatchType],

14164 AtLeastN[

14165 Union[

14166 RightParenMatchType,

14167 OneOf[RightParenMatchType],

14168 AllOf[RightParenMatchType],

14169 ]

14170 ],

14171 AtMostN[

14172 Union[

14173 RightParenMatchType,

14174 OneOf[RightParenMatchType],

14175 AllOf[RightParenMatchType],

14176 ]

14177 ],

14178 ]

14179 ],

14180 MatchIfTrue[Sequence[cst.RightParen]],

14181 ]

14182 ],

14183 AllOf[

14184 Union[

14185 Sequence[

14186 Union[

14187 RightParenMatchType,

14188 OneOf[RightParenMatchType],

14189 AllOf[RightParenMatchType],

14190 AtLeastN[

14191 Union[

14192 RightParenMatchType,

14193 OneOf[RightParenMatchType],

14194 AllOf[RightParenMatchType],

14195 ]

14196 ],

14197 AtMostN[

14198 Union[

14199 RightParenMatchType,

14200 OneOf[RightParenMatchType],

14201 AllOf[RightParenMatchType],

14202 ]

14203 ],

14204 ]

14205 ],

14206 MatchIfTrue[Sequence[cst.RightParen]],

14207 ]

14208 ],

14209 ] = DoNotCare()

14210 whitespace_after_value: Union[

14211 BaseParenthesizableWhitespaceMatchType,

14212 DoNotCareSentinel,

14213 OneOf[BaseParenthesizableWhitespaceMatchType],

14214 AllOf[BaseParenthesizableWhitespaceMatchType],

14215 ] = DoNotCare()

14216 metadata: Union[

14217 MetadataMatchType,

14218 DoNotCareSentinel,

14219 OneOf[MetadataMatchType],

14220 AllOf[MetadataMatchType],

14221 ] = DoNotCare()

14222

14223

14224BaseSliceMatchType = Union["BaseSlice", MetadataMatchType, MatchIfTrue[cst.BaseSlice]]

14225

14226

14227@dataclass(frozen=True, eq=False, unsafe_hash=False)

14228class SubscriptElement(BaseMatcherNode):

14229 slice: Union[

14230 BaseSliceMatchType,

14231 DoNotCareSentinel,

14232 OneOf[BaseSliceMatchType],

14233 AllOf[BaseSliceMatchType],

14234 ] = DoNotCare()

14235 comma: Union[

14236 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

14237 ] = DoNotCare()

14238 metadata: Union[

14239 MetadataMatchType,

14240 DoNotCareSentinel,

14241 OneOf[MetadataMatchType],

14242 AllOf[MetadataMatchType],

14243 ] = DoNotCare()

14244

14245

14246@dataclass(frozen=True, eq=False, unsafe_hash=False)

14247class Subtract(BaseBinaryOp, BaseMatcherNode):

14248 whitespace_before: Union[

14249 BaseParenthesizableWhitespaceMatchType,

14250 DoNotCareSentinel,

14251 OneOf[BaseParenthesizableWhitespaceMatchType],

14252 AllOf[BaseParenthesizableWhitespaceMatchType],

14253 ] = DoNotCare()

14254 whitespace_after: Union[

14255 BaseParenthesizableWhitespaceMatchType,

14256 DoNotCareSentinel,

14257 OneOf[BaseParenthesizableWhitespaceMatchType],

14258 AllOf[BaseParenthesizableWhitespaceMatchType],

14259 ] = DoNotCare()

14260 metadata: Union[

14261 MetadataMatchType,

14262 DoNotCareSentinel,

14263 OneOf[MetadataMatchType],

14264 AllOf[MetadataMatchType],

14265 ] = DoNotCare()

14266

14267

14268@dataclass(frozen=True, eq=False, unsafe_hash=False)

14269class SubtractAssign(BaseAugOp, BaseMatcherNode):

14270 whitespace_before: Union[

14271 BaseParenthesizableWhitespaceMatchType,

14272 DoNotCareSentinel,

14273 OneOf[BaseParenthesizableWhitespaceMatchType],

14274 AllOf[BaseParenthesizableWhitespaceMatchType],

14275 ] = DoNotCare()

14276 whitespace_after: Union[

14277 BaseParenthesizableWhitespaceMatchType,

14278 DoNotCareSentinel,

14279 OneOf[BaseParenthesizableWhitespaceMatchType],

14280 AllOf[BaseParenthesizableWhitespaceMatchType],

14281 ] = DoNotCare()

14282 metadata: Union[

14283 MetadataMatchType,

14284 DoNotCareSentinel,

14285 OneOf[MetadataMatchType],

14286 AllOf[MetadataMatchType],

14287 ] = DoNotCare()

14288

14289

14290BaseTemplatedStringContentMatchType = Union[

14291 "BaseTemplatedStringContent",

14292 MetadataMatchType,

14293 MatchIfTrue[cst.BaseTemplatedStringContent],

14294]

14295

14296

14297@dataclass(frozen=True, eq=False, unsafe_hash=False)

14298class TemplatedString(BaseExpression, BaseString, BaseMatcherNode):

14299 parts: Union[

14300 Sequence[

14301 Union[

14302 BaseTemplatedStringContentMatchType,

14303 DoNotCareSentinel,

14304 OneOf[BaseTemplatedStringContentMatchType],

14305 AllOf[BaseTemplatedStringContentMatchType],

14306 AtLeastN[

14307 Union[

14308 BaseTemplatedStringContentMatchType,

14309 DoNotCareSentinel,

14310 OneOf[BaseTemplatedStringContentMatchType],

14311 AllOf[BaseTemplatedStringContentMatchType],

14312 ]

14313 ],

14314 AtMostN[

14315 Union[

14316 BaseTemplatedStringContentMatchType,

14317 DoNotCareSentinel,

14318 OneOf[BaseTemplatedStringContentMatchType],

14319 AllOf[BaseTemplatedStringContentMatchType],

14320 ]

14321 ],

14322 ]

14323 ],

14324 DoNotCareSentinel,

14325 MatchIfTrue[Sequence[cst.BaseTemplatedStringContent]],

14326 OneOf[

14327 Union[

14328 Sequence[

14329 Union[

14330 BaseTemplatedStringContentMatchType,

14331 OneOf[BaseTemplatedStringContentMatchType],

14332 AllOf[BaseTemplatedStringContentMatchType],

14333 AtLeastN[

14334 Union[

14335 BaseTemplatedStringContentMatchType,

14336 OneOf[BaseTemplatedStringContentMatchType],

14337 AllOf[BaseTemplatedStringContentMatchType],

14338 ]

14339 ],

14340 AtMostN[

14341 Union[

14342 BaseTemplatedStringContentMatchType,

14343 OneOf[BaseTemplatedStringContentMatchType],

14344 AllOf[BaseTemplatedStringContentMatchType],

14345 ]

14346 ],

14347 ]

14348 ],

14349 MatchIfTrue[Sequence[cst.BaseTemplatedStringContent]],

14350 ]

14351 ],

14352 AllOf[

14353 Union[

14354 Sequence[

14355 Union[

14356 BaseTemplatedStringContentMatchType,

14357 OneOf[BaseTemplatedStringContentMatchType],

14358 AllOf[BaseTemplatedStringContentMatchType],

14359 AtLeastN[

14360 Union[

14361 BaseTemplatedStringContentMatchType,

14362 OneOf[BaseTemplatedStringContentMatchType],

14363 AllOf[BaseTemplatedStringContentMatchType],

14364 ]

14365 ],

14366 AtMostN[

14367 Union[

14368 BaseTemplatedStringContentMatchType,

14369 OneOf[BaseTemplatedStringContentMatchType],

14370 AllOf[BaseTemplatedStringContentMatchType],

14371 ]

14372 ],

14373 ]

14374 ],

14375 MatchIfTrue[Sequence[cst.BaseTemplatedStringContent]],

14376 ]

14377 ],

14378 ] = DoNotCare()

14379 start: Union[

14380 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

14381 ] = DoNotCare()

14382 end: Union[

14383 Literal['"', "'", '"""', "'''"],

14384 MetadataMatchType,

14385 MatchIfTrue[Literal['"', "'", '"""', "'''"]],

14386 DoNotCareSentinel,

14387 OneOf[

14388 Union[

14389 Literal['"', "'", '"""', "'''"],

14390 MetadataMatchType,

14391 MatchIfTrue[Literal['"', "'", '"""', "'''"]],

14392 ]

14393 ],

14394 AllOf[

14395 Union[

14396 Literal['"', "'", '"""', "'''"],

14397 MetadataMatchType,

14398 MatchIfTrue[Literal['"', "'", '"""', "'''"]],

14399 ]

14400 ],

14401 ] = DoNotCare()

14402 lpar: Union[

14403 Sequence[

14404 Union[

14405 LeftParenMatchType,

14406 DoNotCareSentinel,

14407 OneOf[LeftParenMatchType],

14408 AllOf[LeftParenMatchType],

14409 AtLeastN[

14410 Union[

14411 LeftParenMatchType,

14412 DoNotCareSentinel,

14413 OneOf[LeftParenMatchType],

14414 AllOf[LeftParenMatchType],

14415 ]

14416 ],

14417 AtMostN[

14418 Union[

14419 LeftParenMatchType,

14420 DoNotCareSentinel,

14421 OneOf[LeftParenMatchType],

14422 AllOf[LeftParenMatchType],

14423 ]

14424 ],

14425 ]

14426 ],

14427 DoNotCareSentinel,

14428 MatchIfTrue[Sequence[cst.LeftParen]],

14429 OneOf[

14430 Union[

14431 Sequence[

14432 Union[

14433 LeftParenMatchType,

14434 OneOf[LeftParenMatchType],

14435 AllOf[LeftParenMatchType],

14436 AtLeastN[

14437 Union[

14438 LeftParenMatchType,

14439 OneOf[LeftParenMatchType],

14440 AllOf[LeftParenMatchType],

14441 ]

14442 ],

14443 AtMostN[

14444 Union[

14445 LeftParenMatchType,

14446 OneOf[LeftParenMatchType],

14447 AllOf[LeftParenMatchType],

14448 ]

14449 ],

14450 ]

14451 ],

14452 MatchIfTrue[Sequence[cst.LeftParen]],

14453 ]

14454 ],

14455 AllOf[

14456 Union[

14457 Sequence[

14458 Union[

14459 LeftParenMatchType,

14460 OneOf[LeftParenMatchType],

14461 AllOf[LeftParenMatchType],

14462 AtLeastN[

14463 Union[

14464 LeftParenMatchType,

14465 OneOf[LeftParenMatchType],

14466 AllOf[LeftParenMatchType],

14467 ]

14468 ],

14469 AtMostN[

14470 Union[

14471 LeftParenMatchType,

14472 OneOf[LeftParenMatchType],

14473 AllOf[LeftParenMatchType],

14474 ]

14475 ],

14476 ]

14477 ],

14478 MatchIfTrue[Sequence[cst.LeftParen]],

14479 ]

14480 ],

14481 ] = DoNotCare()

14482 rpar: Union[

14483 Sequence[

14484 Union[

14485 RightParenMatchType,

14486 DoNotCareSentinel,

14487 OneOf[RightParenMatchType],

14488 AllOf[RightParenMatchType],

14489 AtLeastN[

14490 Union[

14491 RightParenMatchType,

14492 DoNotCareSentinel,

14493 OneOf[RightParenMatchType],

14494 AllOf[RightParenMatchType],

14495 ]

14496 ],

14497 AtMostN[

14498 Union[

14499 RightParenMatchType,

14500 DoNotCareSentinel,

14501 OneOf[RightParenMatchType],

14502 AllOf[RightParenMatchType],

14503 ]

14504 ],

14505 ]

14506 ],

14507 DoNotCareSentinel,

14508 MatchIfTrue[Sequence[cst.RightParen]],

14509 OneOf[

14510 Union[

14511 Sequence[

14512 Union[

14513 RightParenMatchType,

14514 OneOf[RightParenMatchType],

14515 AllOf[RightParenMatchType],

14516 AtLeastN[

14517 Union[

14518 RightParenMatchType,

14519 OneOf[RightParenMatchType],

14520 AllOf[RightParenMatchType],

14521 ]

14522 ],

14523 AtMostN[

14524 Union[

14525 RightParenMatchType,

14526 OneOf[RightParenMatchType],

14527 AllOf[RightParenMatchType],

14528 ]

14529 ],

14530 ]

14531 ],

14532 MatchIfTrue[Sequence[cst.RightParen]],

14533 ]

14534 ],

14535 AllOf[

14536 Union[

14537 Sequence[

14538 Union[

14539 RightParenMatchType,

14540 OneOf[RightParenMatchType],

14541 AllOf[RightParenMatchType],

14542 AtLeastN[

14543 Union[

14544 RightParenMatchType,

14545 OneOf[RightParenMatchType],

14546 AllOf[RightParenMatchType],

14547 ]

14548 ],

14549 AtMostN[

14550 Union[

14551 RightParenMatchType,

14552 OneOf[RightParenMatchType],

14553 AllOf[RightParenMatchType],

14554 ]

14555 ],

14556 ]

14557 ],

14558 MatchIfTrue[Sequence[cst.RightParen]],

14559 ]

14560 ],

14561 ] = DoNotCare()

14562 metadata: Union[

14563 MetadataMatchType,

14564 DoNotCareSentinel,

14565 OneOf[MetadataMatchType],

14566 AllOf[MetadataMatchType],

14567 ] = DoNotCare()

14568

14569

14570@dataclass(frozen=True, eq=False, unsafe_hash=False)

14571class TemplatedStringExpression(BaseTemplatedStringContent, BaseMatcherNode):

14572 expression: Union[

14573 BaseExpressionMatchType,

14574 DoNotCareSentinel,

14575 OneOf[BaseExpressionMatchType],

14576 AllOf[BaseExpressionMatchType],

14577 ] = DoNotCare()

14578 conversion: Union[

14579 Optional[str],

14580 MetadataMatchType,

14581 MatchIfTrue[Optional[str]],

14582 DoNotCareSentinel,

14583 OneOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

14584 AllOf[Union[Optional[str], MetadataMatchType, MatchIfTrue[Optional[str]]]],

14585 ] = DoNotCare()

14586 format_spec: Union[

14587 Optional[Sequence["BaseTemplatedStringContent"]],

14588 MetadataMatchType,

14589 MatchIfTrue[Optional[Sequence[cst.BaseTemplatedStringContent]]],

14590 DoNotCareSentinel,

14591 OneOf[

14592 Union[

14593 Optional[Sequence["BaseTemplatedStringContent"]],

14594 MetadataMatchType,

14595 MatchIfTrue[Optional[Sequence[cst.BaseTemplatedStringContent]]],

14596 ]

14597 ],

14598 AllOf[

14599 Union[

14600 Optional[Sequence["BaseTemplatedStringContent"]],

14601 MetadataMatchType,

14602 MatchIfTrue[Optional[Sequence[cst.BaseTemplatedStringContent]]],

14603 ]

14604 ],

14605 ] = DoNotCare()

14606 whitespace_before_expression: Union[

14607 BaseParenthesizableWhitespaceMatchType,

14608 DoNotCareSentinel,

14609 OneOf[BaseParenthesizableWhitespaceMatchType],

14610 AllOf[BaseParenthesizableWhitespaceMatchType],

14611 ] = DoNotCare()

14612 whitespace_after_expression: Union[

14613 BaseParenthesizableWhitespaceMatchType,

14614 DoNotCareSentinel,

14615 OneOf[BaseParenthesizableWhitespaceMatchType],

14616 AllOf[BaseParenthesizableWhitespaceMatchType],

14617 ] = DoNotCare()

14618 equal: Union[

14619 Optional["AssignEqual"],

14620 MetadataMatchType,

14621 MatchIfTrue[Optional[cst.AssignEqual]],

14622 DoNotCareSentinel,

14623 OneOf[

14624 Union[

14625 Optional["AssignEqual"],

14626 MetadataMatchType,

14627 MatchIfTrue[Optional[cst.AssignEqual]],

14628 ]

14629 ],

14630 AllOf[

14631 Union[

14632 Optional["AssignEqual"],

14633 MetadataMatchType,

14634 MatchIfTrue[Optional[cst.AssignEqual]],

14635 ]

14636 ],

14637 ] = DoNotCare()

14638 metadata: Union[

14639 MetadataMatchType,

14640 DoNotCareSentinel,

14641 OneOf[MetadataMatchType],

14642 AllOf[MetadataMatchType],

14643 ] = DoNotCare()

14644

14645

14646@dataclass(frozen=True, eq=False, unsafe_hash=False)

14647class TemplatedStringText(BaseTemplatedStringContent, BaseMatcherNode):

14648 value: Union[

14649 strMatchType, DoNotCareSentinel, OneOf[strMatchType], AllOf[strMatchType]

14650 ] = DoNotCare()

14651 metadata: Union[

14652 MetadataMatchType,

14653 DoNotCareSentinel,

14654 OneOf[MetadataMatchType],

14655 AllOf[MetadataMatchType],

14656 ] = DoNotCare()

14657

14658

14659@dataclass(frozen=True, eq=False, unsafe_hash=False)

14660class TrailingWhitespace(BaseMatcherNode):

14661 whitespace: Union[

14662 SimpleWhitespaceMatchType,

14663 DoNotCareSentinel,

14664 OneOf[SimpleWhitespaceMatchType],

14665 AllOf[SimpleWhitespaceMatchType],

14666 ] = DoNotCare()

14667 comment: Union[

14668 Optional["Comment"],

14669 MetadataMatchType,

14670 MatchIfTrue[Optional[cst.Comment]],

14671 DoNotCareSentinel,

14672 OneOf[

14673 Union[

14674 Optional["Comment"],

14675 MetadataMatchType,

14676 MatchIfTrue[Optional[cst.Comment]],

14677 ]

14678 ],

14679 AllOf[

14680 Union[

14681 Optional["Comment"],

14682 MetadataMatchType,

14683 MatchIfTrue[Optional[cst.Comment]],

14684 ]

14685 ],

14686 ] = DoNotCare()

14687 newline: Union[

14688 NewlineMatchType,

14689 DoNotCareSentinel,

14690 OneOf[NewlineMatchType],

14691 AllOf[NewlineMatchType],

14692 ] = DoNotCare()

14693 metadata: Union[

14694 MetadataMatchType,

14695 DoNotCareSentinel,

14696 OneOf[MetadataMatchType],

14697 AllOf[MetadataMatchType],

14698 ] = DoNotCare()

14699

14700

14701ExceptHandlerMatchType = Union[

14702 "ExceptHandler", MetadataMatchType, MatchIfTrue[cst.ExceptHandler]

14703]

14704

14705

14706@dataclass(frozen=True, eq=False, unsafe_hash=False)

14707class Try(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

14708 body: Union[

14709 BaseSuiteMatchType,

14710 DoNotCareSentinel,

14711 OneOf[BaseSuiteMatchType],

14712 AllOf[BaseSuiteMatchType],

14713 ] = DoNotCare()

14714 handlers: Union[

14715 Sequence[

14716 Union[

14717 ExceptHandlerMatchType,

14718 DoNotCareSentinel,

14719 OneOf[ExceptHandlerMatchType],

14720 AllOf[ExceptHandlerMatchType],

14721 AtLeastN[

14722 Union[

14723 ExceptHandlerMatchType,

14724 DoNotCareSentinel,

14725 OneOf[ExceptHandlerMatchType],

14726 AllOf[ExceptHandlerMatchType],

14727 ]

14728 ],

14729 AtMostN[

14730 Union[

14731 ExceptHandlerMatchType,

14732 DoNotCareSentinel,

14733 OneOf[ExceptHandlerMatchType],

14734 AllOf[ExceptHandlerMatchType],

14735 ]

14736 ],

14737 ]

14738 ],

14739 DoNotCareSentinel,

14740 MatchIfTrue[Sequence[cst.ExceptHandler]],

14741 OneOf[

14742 Union[

14743 Sequence[

14744 Union[

14745 ExceptHandlerMatchType,

14746 OneOf[ExceptHandlerMatchType],

14747 AllOf[ExceptHandlerMatchType],

14748 AtLeastN[

14749 Union[

14750 ExceptHandlerMatchType,

14751 OneOf[ExceptHandlerMatchType],

14752 AllOf[ExceptHandlerMatchType],

14753 ]

14754 ],

14755 AtMostN[

14756 Union[

14757 ExceptHandlerMatchType,

14758 OneOf[ExceptHandlerMatchType],

14759 AllOf[ExceptHandlerMatchType],

14760 ]

14761 ],

14762 ]

14763 ],

14764 MatchIfTrue[Sequence[cst.ExceptHandler]],

14765 ]

14766 ],

14767 AllOf[

14768 Union[

14769 Sequence[

14770 Union[

14771 ExceptHandlerMatchType,

14772 OneOf[ExceptHandlerMatchType],

14773 AllOf[ExceptHandlerMatchType],

14774 AtLeastN[

14775 Union[

14776 ExceptHandlerMatchType,

14777 OneOf[ExceptHandlerMatchType],

14778 AllOf[ExceptHandlerMatchType],

14779 ]

14780 ],

14781 AtMostN[

14782 Union[

14783 ExceptHandlerMatchType,

14784 OneOf[ExceptHandlerMatchType],

14785 AllOf[ExceptHandlerMatchType],

14786 ]

14787 ],

14788 ]

14789 ],

14790 MatchIfTrue[Sequence[cst.ExceptHandler]],

14791 ]

14792 ],

14793 ] = DoNotCare()

14794 orelse: Union[

14795 Optional["Else"],

14796 MetadataMatchType,

14797 MatchIfTrue[Optional[cst.Else]],

14798 DoNotCareSentinel,

14799 OneOf[

14800 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

14801 ],

14802 AllOf[

14803 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

14804 ],

14805 ] = DoNotCare()

14806 finalbody: Union[

14807 Optional["Finally"],

14808 MetadataMatchType,

14809 MatchIfTrue[Optional[cst.Finally]],

14810 DoNotCareSentinel,

14811 OneOf[

14812 Union[

14813 Optional["Finally"],

14814 MetadataMatchType,

14815 MatchIfTrue[Optional[cst.Finally]],

14816 ]

14817 ],

14818 AllOf[

14819 Union[

14820 Optional["Finally"],

14821 MetadataMatchType,

14822 MatchIfTrue[Optional[cst.Finally]],

14823 ]

14824 ],

14825 ] = DoNotCare()

14826 leading_lines: Union[

14827 Sequence[

14828 Union[

14829 EmptyLineMatchType,

14830 DoNotCareSentinel,

14831 OneOf[EmptyLineMatchType],

14832 AllOf[EmptyLineMatchType],

14833 AtLeastN[

14834 Union[

14835 EmptyLineMatchType,

14836 DoNotCareSentinel,

14837 OneOf[EmptyLineMatchType],

14838 AllOf[EmptyLineMatchType],

14839 ]

14840 ],

14841 AtMostN[

14842 Union[

14843 EmptyLineMatchType,

14844 DoNotCareSentinel,

14845 OneOf[EmptyLineMatchType],

14846 AllOf[EmptyLineMatchType],

14847 ]

14848 ],

14849 ]

14850 ],

14851 DoNotCareSentinel,

14852 MatchIfTrue[Sequence[cst.EmptyLine]],

14853 OneOf[

14854 Union[

14855 Sequence[

14856 Union[

14857 EmptyLineMatchType,

14858 OneOf[EmptyLineMatchType],

14859 AllOf[EmptyLineMatchType],

14860 AtLeastN[

14861 Union[

14862 EmptyLineMatchType,

14863 OneOf[EmptyLineMatchType],

14864 AllOf[EmptyLineMatchType],

14865 ]

14866 ],

14867 AtMostN[

14868 Union[

14869 EmptyLineMatchType,

14870 OneOf[EmptyLineMatchType],

14871 AllOf[EmptyLineMatchType],

14872 ]

14873 ],

14874 ]

14875 ],

14876 MatchIfTrue[Sequence[cst.EmptyLine]],

14877 ]

14878 ],

14879 AllOf[

14880 Union[

14881 Sequence[

14882 Union[

14883 EmptyLineMatchType,

14884 OneOf[EmptyLineMatchType],

14885 AllOf[EmptyLineMatchType],

14886 AtLeastN[

14887 Union[

14888 EmptyLineMatchType,

14889 OneOf[EmptyLineMatchType],

14890 AllOf[EmptyLineMatchType],

14891 ]

14892 ],

14893 AtMostN[

14894 Union[

14895 EmptyLineMatchType,

14896 OneOf[EmptyLineMatchType],

14897 AllOf[EmptyLineMatchType],

14898 ]

14899 ],

14900 ]

14901 ],

14902 MatchIfTrue[Sequence[cst.EmptyLine]],

14903 ]

14904 ],

14905 ] = DoNotCare()

14906 whitespace_before_colon: Union[

14907 SimpleWhitespaceMatchType,

14908 DoNotCareSentinel,

14909 OneOf[SimpleWhitespaceMatchType],

14910 AllOf[SimpleWhitespaceMatchType],

14911 ] = DoNotCare()

14912 metadata: Union[

14913 MetadataMatchType,

14914 DoNotCareSentinel,

14915 OneOf[MetadataMatchType],

14916 AllOf[MetadataMatchType],

14917 ] = DoNotCare()

14918

14919

14920ExceptStarHandlerMatchType = Union[

14921 "ExceptStarHandler", MetadataMatchType, MatchIfTrue[cst.ExceptStarHandler]

14922]

14923

14924

14925@dataclass(frozen=True, eq=False, unsafe_hash=False)

14926class TryStar(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

14927 body: Union[

14928 BaseSuiteMatchType,

14929 DoNotCareSentinel,

14930 OneOf[BaseSuiteMatchType],

14931 AllOf[BaseSuiteMatchType],

14932 ] = DoNotCare()

14933 handlers: Union[

14934 Sequence[

14935 Union[

14936 ExceptStarHandlerMatchType,

14937 DoNotCareSentinel,

14938 OneOf[ExceptStarHandlerMatchType],

14939 AllOf[ExceptStarHandlerMatchType],

14940 AtLeastN[

14941 Union[

14942 ExceptStarHandlerMatchType,

14943 DoNotCareSentinel,

14944 OneOf[ExceptStarHandlerMatchType],

14945 AllOf[ExceptStarHandlerMatchType],

14946 ]

14947 ],

14948 AtMostN[

14949 Union[

14950 ExceptStarHandlerMatchType,

14951 DoNotCareSentinel,

14952 OneOf[ExceptStarHandlerMatchType],

14953 AllOf[ExceptStarHandlerMatchType],

14954 ]

14955 ],

14956 ]

14957 ],

14958 DoNotCareSentinel,

14959 MatchIfTrue[Sequence[cst.ExceptStarHandler]],

14960 OneOf[

14961 Union[

14962 Sequence[

14963 Union[

14964 ExceptStarHandlerMatchType,

14965 OneOf[ExceptStarHandlerMatchType],

14966 AllOf[ExceptStarHandlerMatchType],

14967 AtLeastN[

14968 Union[

14969 ExceptStarHandlerMatchType,

14970 OneOf[ExceptStarHandlerMatchType],

14971 AllOf[ExceptStarHandlerMatchType],

14972 ]

14973 ],

14974 AtMostN[

14975 Union[

14976 ExceptStarHandlerMatchType,

14977 OneOf[ExceptStarHandlerMatchType],

14978 AllOf[ExceptStarHandlerMatchType],

14979 ]

14980 ],

14981 ]

14982 ],

14983 MatchIfTrue[Sequence[cst.ExceptStarHandler]],

14984 ]

14985 ],

14986 AllOf[

14987 Union[

14988 Sequence[

14989 Union[

14990 ExceptStarHandlerMatchType,

14991 OneOf[ExceptStarHandlerMatchType],

14992 AllOf[ExceptStarHandlerMatchType],

14993 AtLeastN[

14994 Union[

14995 ExceptStarHandlerMatchType,

14996 OneOf[ExceptStarHandlerMatchType],

14997 AllOf[ExceptStarHandlerMatchType],

14998 ]

14999 ],

15000 AtMostN[

15001 Union[

15002 ExceptStarHandlerMatchType,

15003 OneOf[ExceptStarHandlerMatchType],

15004 AllOf[ExceptStarHandlerMatchType],

15005 ]

15006 ],

15007 ]

15008 ],

15009 MatchIfTrue[Sequence[cst.ExceptStarHandler]],

15010 ]

15011 ],

15012 ] = DoNotCare()

15013 orelse: Union[

15014 Optional["Else"],

15015 MetadataMatchType,

15016 MatchIfTrue[Optional[cst.Else]],

15017 DoNotCareSentinel,

15018 OneOf[

15019 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

15020 ],

15021 AllOf[

15022 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

15023 ],

15024 ] = DoNotCare()

15025 finalbody: Union[

15026 Optional["Finally"],

15027 MetadataMatchType,

15028 MatchIfTrue[Optional[cst.Finally]],

15029 DoNotCareSentinel,

15030 OneOf[

15031 Union[

15032 Optional["Finally"],

15033 MetadataMatchType,

15034 MatchIfTrue[Optional[cst.Finally]],

15035 ]

15036 ],

15037 AllOf[

15038 Union[

15039 Optional["Finally"],

15040 MetadataMatchType,

15041 MatchIfTrue[Optional[cst.Finally]],

15042 ]

15043 ],

15044 ] = DoNotCare()

15045 leading_lines: Union[

15046 Sequence[

15047 Union[

15048 EmptyLineMatchType,

15049 DoNotCareSentinel,

15050 OneOf[EmptyLineMatchType],

15051 AllOf[EmptyLineMatchType],

15052 AtLeastN[

15053 Union[

15054 EmptyLineMatchType,

15055 DoNotCareSentinel,

15056 OneOf[EmptyLineMatchType],

15057 AllOf[EmptyLineMatchType],

15058 ]

15059 ],

15060 AtMostN[

15061 Union[

15062 EmptyLineMatchType,

15063 DoNotCareSentinel,

15064 OneOf[EmptyLineMatchType],

15065 AllOf[EmptyLineMatchType],

15066 ]

15067 ],

15068 ]

15069 ],

15070 DoNotCareSentinel,

15071 MatchIfTrue[Sequence[cst.EmptyLine]],

15072 OneOf[

15073 Union[

15074 Sequence[

15075 Union[

15076 EmptyLineMatchType,

15077 OneOf[EmptyLineMatchType],

15078 AllOf[EmptyLineMatchType],

15079 AtLeastN[

15080 Union[

15081 EmptyLineMatchType,

15082 OneOf[EmptyLineMatchType],

15083 AllOf[EmptyLineMatchType],

15084 ]

15085 ],

15086 AtMostN[

15087 Union[

15088 EmptyLineMatchType,

15089 OneOf[EmptyLineMatchType],

15090 AllOf[EmptyLineMatchType],

15091 ]

15092 ],

15093 ]

15094 ],

15095 MatchIfTrue[Sequence[cst.EmptyLine]],

15096 ]

15097 ],

15098 AllOf[

15099 Union[

15100 Sequence[

15101 Union[

15102 EmptyLineMatchType,

15103 OneOf[EmptyLineMatchType],

15104 AllOf[EmptyLineMatchType],

15105 AtLeastN[

15106 Union[

15107 EmptyLineMatchType,

15108 OneOf[EmptyLineMatchType],

15109 AllOf[EmptyLineMatchType],

15110 ]

15111 ],

15112 AtMostN[

15113 Union[

15114 EmptyLineMatchType,

15115 OneOf[EmptyLineMatchType],

15116 AllOf[EmptyLineMatchType],

15117 ]

15118 ],

15119 ]

15120 ],

15121 MatchIfTrue[Sequence[cst.EmptyLine]],

15122 ]

15123 ],

15124 ] = DoNotCare()

15125 whitespace_before_colon: Union[

15126 SimpleWhitespaceMatchType,

15127 DoNotCareSentinel,

15128 OneOf[SimpleWhitespaceMatchType],

15129 AllOf[SimpleWhitespaceMatchType],

15130 ] = DoNotCare()

15131 metadata: Union[

15132 MetadataMatchType,

15133 DoNotCareSentinel,

15134 OneOf[MetadataMatchType],

15135 AllOf[MetadataMatchType],

15136 ] = DoNotCare()

15137

15138

15139@dataclass(frozen=True, eq=False, unsafe_hash=False)

15140class Tuple(

15141 BaseAssignTargetExpression, BaseDelTargetExpression, BaseExpression, BaseMatcherNode

15142):

15143 elements: Union[

15144 Sequence[

15145 Union[

15146 BaseElementMatchType,

15147 DoNotCareSentinel,

15148 OneOf[BaseElementMatchType],

15149 AllOf[BaseElementMatchType],

15150 AtLeastN[

15151 Union[

15152 BaseElementMatchType,

15153 DoNotCareSentinel,

15154 OneOf[BaseElementMatchType],

15155 AllOf[BaseElementMatchType],

15156 ]

15157 ],

15158 AtMostN[

15159 Union[

15160 BaseElementMatchType,

15161 DoNotCareSentinel,

15162 OneOf[BaseElementMatchType],

15163 AllOf[BaseElementMatchType],

15164 ]

15165 ],

15166 ]

15167 ],

15168 DoNotCareSentinel,

15169 MatchIfTrue[Sequence[cst.BaseElement]],

15170 OneOf[

15171 Union[

15172 Sequence[

15173 Union[

15174 BaseElementMatchType,

15175 OneOf[BaseElementMatchType],

15176 AllOf[BaseElementMatchType],

15177 AtLeastN[

15178 Union[

15179 BaseElementMatchType,

15180 OneOf[BaseElementMatchType],

15181 AllOf[BaseElementMatchType],

15182 ]

15183 ],

15184 AtMostN[

15185 Union[

15186 BaseElementMatchType,

15187 OneOf[BaseElementMatchType],

15188 AllOf[BaseElementMatchType],

15189 ]

15190 ],

15191 ]

15192 ],

15193 MatchIfTrue[Sequence[cst.BaseElement]],

15194 ]

15195 ],

15196 AllOf[

15197 Union[

15198 Sequence[

15199 Union[

15200 BaseElementMatchType,

15201 OneOf[BaseElementMatchType],

15202 AllOf[BaseElementMatchType],

15203 AtLeastN[

15204 Union[

15205 BaseElementMatchType,

15206 OneOf[BaseElementMatchType],

15207 AllOf[BaseElementMatchType],

15208 ]

15209 ],

15210 AtMostN[

15211 Union[

15212 BaseElementMatchType,

15213 OneOf[BaseElementMatchType],

15214 AllOf[BaseElementMatchType],

15215 ]

15216 ],

15217 ]

15218 ],

15219 MatchIfTrue[Sequence[cst.BaseElement]],

15220 ]

15221 ],

15222 ] = DoNotCare()

15223 lpar: Union[

15224 Sequence[

15225 Union[

15226 LeftParenMatchType,

15227 DoNotCareSentinel,

15228 OneOf[LeftParenMatchType],

15229 AllOf[LeftParenMatchType],

15230 AtLeastN[

15231 Union[

15232 LeftParenMatchType,

15233 DoNotCareSentinel,

15234 OneOf[LeftParenMatchType],

15235 AllOf[LeftParenMatchType],

15236 ]

15237 ],

15238 AtMostN[

15239 Union[

15240 LeftParenMatchType,

15241 DoNotCareSentinel,

15242 OneOf[LeftParenMatchType],

15243 AllOf[LeftParenMatchType],

15244 ]

15245 ],

15246 ]

15247 ],

15248 DoNotCareSentinel,

15249 MatchIfTrue[Sequence[cst.LeftParen]],

15250 OneOf[

15251 Union[

15252 Sequence[

15253 Union[

15254 LeftParenMatchType,

15255 OneOf[LeftParenMatchType],

15256 AllOf[LeftParenMatchType],

15257 AtLeastN[

15258 Union[

15259 LeftParenMatchType,

15260 OneOf[LeftParenMatchType],

15261 AllOf[LeftParenMatchType],

15262 ]

15263 ],

15264 AtMostN[

15265 Union[

15266 LeftParenMatchType,

15267 OneOf[LeftParenMatchType],

15268 AllOf[LeftParenMatchType],

15269 ]

15270 ],

15271 ]

15272 ],

15273 MatchIfTrue[Sequence[cst.LeftParen]],

15274 ]

15275 ],

15276 AllOf[

15277 Union[

15278 Sequence[

15279 Union[

15280 LeftParenMatchType,

15281 OneOf[LeftParenMatchType],

15282 AllOf[LeftParenMatchType],

15283 AtLeastN[

15284 Union[

15285 LeftParenMatchType,

15286 OneOf[LeftParenMatchType],

15287 AllOf[LeftParenMatchType],

15288 ]

15289 ],

15290 AtMostN[

15291 Union[

15292 LeftParenMatchType,

15293 OneOf[LeftParenMatchType],

15294 AllOf[LeftParenMatchType],

15295 ]

15296 ],

15297 ]

15298 ],

15299 MatchIfTrue[Sequence[cst.LeftParen]],

15300 ]

15301 ],

15302 ] = DoNotCare()

15303 rpar: Union[

15304 Sequence[

15305 Union[

15306 RightParenMatchType,

15307 DoNotCareSentinel,

15308 OneOf[RightParenMatchType],

15309 AllOf[RightParenMatchType],

15310 AtLeastN[

15311 Union[

15312 RightParenMatchType,

15313 DoNotCareSentinel,

15314 OneOf[RightParenMatchType],

15315 AllOf[RightParenMatchType],

15316 ]

15317 ],

15318 AtMostN[

15319 Union[

15320 RightParenMatchType,

15321 DoNotCareSentinel,

15322 OneOf[RightParenMatchType],

15323 AllOf[RightParenMatchType],

15324 ]

15325 ],

15326 ]

15327 ],

15328 DoNotCareSentinel,

15329 MatchIfTrue[Sequence[cst.RightParen]],

15330 OneOf[

15331 Union[

15332 Sequence[

15333 Union[

15334 RightParenMatchType,

15335 OneOf[RightParenMatchType],

15336 AllOf[RightParenMatchType],

15337 AtLeastN[

15338 Union[

15339 RightParenMatchType,

15340 OneOf[RightParenMatchType],

15341 AllOf[RightParenMatchType],

15342 ]

15343 ],

15344 AtMostN[

15345 Union[

15346 RightParenMatchType,

15347 OneOf[RightParenMatchType],

15348 AllOf[RightParenMatchType],

15349 ]

15350 ],

15351 ]

15352 ],

15353 MatchIfTrue[Sequence[cst.RightParen]],

15354 ]

15355 ],

15356 AllOf[

15357 Union[

15358 Sequence[

15359 Union[

15360 RightParenMatchType,

15361 OneOf[RightParenMatchType],

15362 AllOf[RightParenMatchType],

15363 AtLeastN[

15364 Union[

15365 RightParenMatchType,

15366 OneOf[RightParenMatchType],

15367 AllOf[RightParenMatchType],

15368 ]

15369 ],

15370 AtMostN[

15371 Union[

15372 RightParenMatchType,

15373 OneOf[RightParenMatchType],

15374 AllOf[RightParenMatchType],

15375 ]

15376 ],

15377 ]

15378 ],

15379 MatchIfTrue[Sequence[cst.RightParen]],

15380 ]

15381 ],

15382 ] = DoNotCare()

15383 metadata: Union[

15384 MetadataMatchType,

15385 DoNotCareSentinel,

15386 OneOf[MetadataMatchType],

15387 AllOf[MetadataMatchType],

15388 ] = DoNotCare()

15389

15390

15391@dataclass(frozen=True, eq=False, unsafe_hash=False)

15392class TypeAlias(BaseSmallStatement, BaseMatcherNode):

15393 name: Union[

15394 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

15395 ] = DoNotCare()

15396 value: Union[

15397 BaseExpressionMatchType,

15398 DoNotCareSentinel,

15399 OneOf[BaseExpressionMatchType],

15400 AllOf[BaseExpressionMatchType],

15401 ] = DoNotCare()

15402 type_parameters: Union[

15403 Optional["TypeParameters"],

15404 MetadataMatchType,

15405 MatchIfTrue[Optional[cst.TypeParameters]],

15406 DoNotCareSentinel,

15407 OneOf[

15408 Union[

15409 Optional["TypeParameters"],

15410 MetadataMatchType,

15411 MatchIfTrue[Optional[cst.TypeParameters]],

15412 ]

15413 ],

15414 AllOf[

15415 Union[

15416 Optional["TypeParameters"],

15417 MetadataMatchType,

15418 MatchIfTrue[Optional[cst.TypeParameters]],

15419 ]

15420 ],

15421 ] = DoNotCare()

15422 whitespace_after_type: Union[

15423 SimpleWhitespaceMatchType,

15424 DoNotCareSentinel,

15425 OneOf[SimpleWhitespaceMatchType],

15426 AllOf[SimpleWhitespaceMatchType],

15427 ] = DoNotCare()

15428 whitespace_after_name: Union[

15429 SimpleWhitespaceMatchType,

15430 DoNotCareSentinel,

15431 OneOf[SimpleWhitespaceMatchType],

15432 AllOf[SimpleWhitespaceMatchType],

15433 ] = DoNotCare()

15434 whitespace_after_type_parameters: Union[

15435 SimpleWhitespaceMatchType,

15436 DoNotCareSentinel,

15437 OneOf[SimpleWhitespaceMatchType],

15438 AllOf[SimpleWhitespaceMatchType],

15439 ] = DoNotCare()

15440 whitespace_after_equals: Union[

15441 SimpleWhitespaceMatchType,

15442 DoNotCareSentinel,

15443 OneOf[SimpleWhitespaceMatchType],

15444 AllOf[SimpleWhitespaceMatchType],

15445 ] = DoNotCare()

15446 semicolon: Union[

15447 SemicolonMatchType,

15448 DoNotCareSentinel,

15449 OneOf[SemicolonMatchType],

15450 AllOf[SemicolonMatchType],

15451 ] = DoNotCare()

15452 metadata: Union[

15453 MetadataMatchType,

15454 DoNotCareSentinel,

15455 OneOf[MetadataMatchType],

15456 AllOf[MetadataMatchType],

15457 ] = DoNotCare()

15458

15459

15460TypeVarOrTypeVarTupleOrParamSpecMatchType = Union[

15461 "TypeVar",

15462 "TypeVarTuple",

15463 "ParamSpec",

15464 MetadataMatchType,

15465 MatchIfTrue[Union[cst.TypeVar, cst.TypeVarTuple, cst.ParamSpec]],

15466]

15467

15468

15469@dataclass(frozen=True, eq=False, unsafe_hash=False)

15470class TypeParam(BaseMatcherNode):

15471 param: Union[

15472 TypeVarOrTypeVarTupleOrParamSpecMatchType,

15473 DoNotCareSentinel,

15474 OneOf[TypeVarOrTypeVarTupleOrParamSpecMatchType],

15475 AllOf[TypeVarOrTypeVarTupleOrParamSpecMatchType],

15476 ] = DoNotCare()

15477 comma: Union[

15478 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

15479 ] = DoNotCare()

15480 equal: Union[

15481 AssignEqualMatchType,

15482 DoNotCareSentinel,

15483 OneOf[AssignEqualMatchType],

15484 AllOf[AssignEqualMatchType],

15485 ] = DoNotCare()

15486 star: Union[

15487 Literal["", "*"],

15488 MetadataMatchType,

15489 MatchIfTrue[Literal["", "*"]],

15490 DoNotCareSentinel,

15491 OneOf[

15492 Union[Literal["", "*"], MetadataMatchType, MatchIfTrue[Literal["", "*"]]]

15493 ],

15494 AllOf[

15495 Union[Literal["", "*"], MetadataMatchType, MatchIfTrue[Literal["", "*"]]]

15496 ],

15497 ] = DoNotCare()

15498 whitespace_after_star: Union[

15499 SimpleWhitespaceMatchType,

15500 DoNotCareSentinel,

15501 OneOf[SimpleWhitespaceMatchType],

15502 AllOf[SimpleWhitespaceMatchType],

15503 ] = DoNotCare()

15504 default: Union[

15505 Optional["BaseExpression"],

15506 MetadataMatchType,

15507 MatchIfTrue[Optional[cst.BaseExpression]],

15508 DoNotCareSentinel,

15509 OneOf[

15510 Union[

15511 Optional["BaseExpression"],

15512 MetadataMatchType,

15513 MatchIfTrue[Optional[cst.BaseExpression]],

15514 ]

15515 ],

15516 AllOf[

15517 Union[

15518 Optional["BaseExpression"],

15519 MetadataMatchType,

15520 MatchIfTrue[Optional[cst.BaseExpression]],

15521 ]

15522 ],

15523 ] = DoNotCare()

15524 metadata: Union[

15525 MetadataMatchType,

15526 DoNotCareSentinel,

15527 OneOf[MetadataMatchType],

15528 AllOf[MetadataMatchType],

15529 ] = DoNotCare()

15530

15531

15532TypeParamMatchType = Union["TypeParam", MetadataMatchType, MatchIfTrue[cst.TypeParam]]

15533

15534

15535@dataclass(frozen=True, eq=False, unsafe_hash=False)

15536class TypeParameters(BaseMatcherNode):

15537 params: Union[

15538 Sequence[

15539 Union[

15540 TypeParamMatchType,

15541 DoNotCareSentinel,

15542 OneOf[TypeParamMatchType],

15543 AllOf[TypeParamMatchType],

15544 AtLeastN[

15545 Union[

15546 TypeParamMatchType,

15547 DoNotCareSentinel,

15548 OneOf[TypeParamMatchType],

15549 AllOf[TypeParamMatchType],

15550 ]

15551 ],

15552 AtMostN[

15553 Union[

15554 TypeParamMatchType,

15555 DoNotCareSentinel,

15556 OneOf[TypeParamMatchType],

15557 AllOf[TypeParamMatchType],

15558 ]

15559 ],

15560 ]

15561 ],

15562 DoNotCareSentinel,

15563 MatchIfTrue[Sequence[cst.TypeParam]],

15564 OneOf[

15565 Union[

15566 Sequence[

15567 Union[

15568 TypeParamMatchType,

15569 OneOf[TypeParamMatchType],

15570 AllOf[TypeParamMatchType],

15571 AtLeastN[

15572 Union[

15573 TypeParamMatchType,

15574 OneOf[TypeParamMatchType],

15575 AllOf[TypeParamMatchType],

15576 ]

15577 ],

15578 AtMostN[

15579 Union[

15580 TypeParamMatchType,

15581 OneOf[TypeParamMatchType],

15582 AllOf[TypeParamMatchType],

15583 ]

15584 ],

15585 ]

15586 ],

15587 MatchIfTrue[Sequence[cst.TypeParam]],

15588 ]

15589 ],

15590 AllOf[

15591 Union[

15592 Sequence[

15593 Union[

15594 TypeParamMatchType,

15595 OneOf[TypeParamMatchType],

15596 AllOf[TypeParamMatchType],

15597 AtLeastN[

15598 Union[

15599 TypeParamMatchType,

15600 OneOf[TypeParamMatchType],

15601 AllOf[TypeParamMatchType],

15602 ]

15603 ],

15604 AtMostN[

15605 Union[

15606 TypeParamMatchType,

15607 OneOf[TypeParamMatchType],

15608 AllOf[TypeParamMatchType],

15609 ]

15610 ],

15611 ]

15612 ],

15613 MatchIfTrue[Sequence[cst.TypeParam]],

15614 ]

15615 ],

15616 ] = DoNotCare()

15617 lbracket: Union[

15618 LeftSquareBracketMatchType,

15619 DoNotCareSentinel,

15620 OneOf[LeftSquareBracketMatchType],

15621 AllOf[LeftSquareBracketMatchType],

15622 ] = DoNotCare()

15623 rbracket: Union[

15624 RightSquareBracketMatchType,

15625 DoNotCareSentinel,

15626 OneOf[RightSquareBracketMatchType],

15627 AllOf[RightSquareBracketMatchType],

15628 ] = DoNotCare()

15629 metadata: Union[

15630 MetadataMatchType,

15631 DoNotCareSentinel,

15632 OneOf[MetadataMatchType],

15633 AllOf[MetadataMatchType],

15634 ] = DoNotCare()

15635

15636

15637@dataclass(frozen=True, eq=False, unsafe_hash=False)

15638class TypeVar(BaseMatcherNode):

15639 name: Union[

15640 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

15641 ] = DoNotCare()

15642 bound: Union[

15643 Optional["BaseExpression"],

15644 MetadataMatchType,

15645 MatchIfTrue[Optional[cst.BaseExpression]],

15646 DoNotCareSentinel,

15647 OneOf[

15648 Union[

15649 Optional["BaseExpression"],

15650 MetadataMatchType,

15651 MatchIfTrue[Optional[cst.BaseExpression]],

15652 ]

15653 ],

15654 AllOf[

15655 Union[

15656 Optional["BaseExpression"],

15657 MetadataMatchType,

15658 MatchIfTrue[Optional[cst.BaseExpression]],

15659 ]

15660 ],

15661 ] = DoNotCare()

15662 colon: Union[

15663 ColonMatchType, DoNotCareSentinel, OneOf[ColonMatchType], AllOf[ColonMatchType]

15664 ] = DoNotCare()

15665 metadata: Union[

15666 MetadataMatchType,

15667 DoNotCareSentinel,

15668 OneOf[MetadataMatchType],

15669 AllOf[MetadataMatchType],

15670 ] = DoNotCare()

15671

15672

15673@dataclass(frozen=True, eq=False, unsafe_hash=False)

15674class TypeVarTuple(BaseMatcherNode):

15675 name: Union[

15676 NameMatchType, DoNotCareSentinel, OneOf[NameMatchType], AllOf[NameMatchType]

15677 ] = DoNotCare()

15678 whitespace_after_star: Union[

15679 SimpleWhitespaceMatchType,

15680 DoNotCareSentinel,

15681 OneOf[SimpleWhitespaceMatchType],

15682 AllOf[SimpleWhitespaceMatchType],

15683 ] = DoNotCare()

15684 metadata: Union[

15685 MetadataMatchType,

15686 DoNotCareSentinel,

15687 OneOf[MetadataMatchType],

15688 AllOf[MetadataMatchType],

15689 ] = DoNotCare()

15690

15691

15692BaseUnaryOpMatchType = Union[

15693 "BaseUnaryOp", MetadataMatchType, MatchIfTrue[cst.BaseUnaryOp]

15694]

15695

15696

15697@dataclass(frozen=True, eq=False, unsafe_hash=False)

15698class UnaryOperation(BaseExpression, BaseMatcherNode):

15699 operator: Union[

15700 BaseUnaryOpMatchType,

15701 DoNotCareSentinel,

15702 OneOf[BaseUnaryOpMatchType],

15703 AllOf[BaseUnaryOpMatchType],

15704 ] = DoNotCare()

15705 expression: Union[

15706 BaseExpressionMatchType,

15707 DoNotCareSentinel,

15708 OneOf[BaseExpressionMatchType],

15709 AllOf[BaseExpressionMatchType],

15710 ] = DoNotCare()

15711 lpar: Union[

15712 Sequence[

15713 Union[

15714 LeftParenMatchType,

15715 DoNotCareSentinel,

15716 OneOf[LeftParenMatchType],

15717 AllOf[LeftParenMatchType],

15718 AtLeastN[

15719 Union[

15720 LeftParenMatchType,

15721 DoNotCareSentinel,

15722 OneOf[LeftParenMatchType],

15723 AllOf[LeftParenMatchType],

15724 ]

15725 ],

15726 AtMostN[

15727 Union[

15728 LeftParenMatchType,

15729 DoNotCareSentinel,

15730 OneOf[LeftParenMatchType],

15731 AllOf[LeftParenMatchType],

15732 ]

15733 ],

15734 ]

15735 ],

15736 DoNotCareSentinel,

15737 MatchIfTrue[Sequence[cst.LeftParen]],

15738 OneOf[

15739 Union[

15740 Sequence[

15741 Union[

15742 LeftParenMatchType,

15743 OneOf[LeftParenMatchType],

15744 AllOf[LeftParenMatchType],

15745 AtLeastN[

15746 Union[

15747 LeftParenMatchType,

15748 OneOf[LeftParenMatchType],

15749 AllOf[LeftParenMatchType],

15750 ]

15751 ],

15752 AtMostN[

15753 Union[

15754 LeftParenMatchType,

15755 OneOf[LeftParenMatchType],

15756 AllOf[LeftParenMatchType],

15757 ]

15758 ],

15759 ]

15760 ],

15761 MatchIfTrue[Sequence[cst.LeftParen]],

15762 ]

15763 ],

15764 AllOf[

15765 Union[

15766 Sequence[

15767 Union[

15768 LeftParenMatchType,

15769 OneOf[LeftParenMatchType],

15770 AllOf[LeftParenMatchType],

15771 AtLeastN[

15772 Union[

15773 LeftParenMatchType,

15774 OneOf[LeftParenMatchType],

15775 AllOf[LeftParenMatchType],

15776 ]

15777 ],

15778 AtMostN[

15779 Union[

15780 LeftParenMatchType,

15781 OneOf[LeftParenMatchType],

15782 AllOf[LeftParenMatchType],

15783 ]

15784 ],

15785 ]

15786 ],

15787 MatchIfTrue[Sequence[cst.LeftParen]],

15788 ]

15789 ],

15790 ] = DoNotCare()

15791 rpar: Union[

15792 Sequence[

15793 Union[

15794 RightParenMatchType,

15795 DoNotCareSentinel,

15796 OneOf[RightParenMatchType],

15797 AllOf[RightParenMatchType],

15798 AtLeastN[

15799 Union[

15800 RightParenMatchType,

15801 DoNotCareSentinel,

15802 OneOf[RightParenMatchType],

15803 AllOf[RightParenMatchType],

15804 ]

15805 ],

15806 AtMostN[

15807 Union[

15808 RightParenMatchType,

15809 DoNotCareSentinel,

15810 OneOf[RightParenMatchType],

15811 AllOf[RightParenMatchType],

15812 ]

15813 ],

15814 ]

15815 ],

15816 DoNotCareSentinel,

15817 MatchIfTrue[Sequence[cst.RightParen]],

15818 OneOf[

15819 Union[

15820 Sequence[

15821 Union[

15822 RightParenMatchType,

15823 OneOf[RightParenMatchType],

15824 AllOf[RightParenMatchType],

15825 AtLeastN[

15826 Union[

15827 RightParenMatchType,

15828 OneOf[RightParenMatchType],

15829 AllOf[RightParenMatchType],

15830 ]

15831 ],

15832 AtMostN[

15833 Union[

15834 RightParenMatchType,

15835 OneOf[RightParenMatchType],

15836 AllOf[RightParenMatchType],

15837 ]

15838 ],

15839 ]

15840 ],

15841 MatchIfTrue[Sequence[cst.RightParen]],

15842 ]

15843 ],

15844 AllOf[

15845 Union[

15846 Sequence[

15847 Union[

15848 RightParenMatchType,

15849 OneOf[RightParenMatchType],

15850 AllOf[RightParenMatchType],

15851 AtLeastN[

15852 Union[

15853 RightParenMatchType,

15854 OneOf[RightParenMatchType],

15855 AllOf[RightParenMatchType],

15856 ]

15857 ],

15858 AtMostN[

15859 Union[

15860 RightParenMatchType,

15861 OneOf[RightParenMatchType],

15862 AllOf[RightParenMatchType],

15863 ]

15864 ],

15865 ]

15866 ],

15867 MatchIfTrue[Sequence[cst.RightParen]],

15868 ]

15869 ],

15870 ] = DoNotCare()

15871 metadata: Union[

15872 MetadataMatchType,

15873 DoNotCareSentinel,

15874 OneOf[MetadataMatchType],

15875 AllOf[MetadataMatchType],

15876 ] = DoNotCare()

15877

15878

15879@dataclass(frozen=True, eq=False, unsafe_hash=False)

15880class While(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

15881 test: Union[

15882 BaseExpressionMatchType,

15883 DoNotCareSentinel,

15884 OneOf[BaseExpressionMatchType],

15885 AllOf[BaseExpressionMatchType],

15886 ] = DoNotCare()

15887 body: Union[

15888 BaseSuiteMatchType,

15889 DoNotCareSentinel,

15890 OneOf[BaseSuiteMatchType],

15891 AllOf[BaseSuiteMatchType],

15892 ] = DoNotCare()

15893 orelse: Union[

15894 Optional["Else"],

15895 MetadataMatchType,

15896 MatchIfTrue[Optional[cst.Else]],

15897 DoNotCareSentinel,

15898 OneOf[

15899 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

15900 ],

15901 AllOf[

15902 Union[Optional["Else"], MetadataMatchType, MatchIfTrue[Optional[cst.Else]]]

15903 ],

15904 ] = DoNotCare()

15905 leading_lines: Union[

15906 Sequence[

15907 Union[

15908 EmptyLineMatchType,

15909 DoNotCareSentinel,

15910 OneOf[EmptyLineMatchType],

15911 AllOf[EmptyLineMatchType],

15912 AtLeastN[

15913 Union[

15914 EmptyLineMatchType,

15915 DoNotCareSentinel,

15916 OneOf[EmptyLineMatchType],

15917 AllOf[EmptyLineMatchType],

15918 ]

15919 ],

15920 AtMostN[

15921 Union[

15922 EmptyLineMatchType,

15923 DoNotCareSentinel,

15924 OneOf[EmptyLineMatchType],

15925 AllOf[EmptyLineMatchType],

15926 ]

15927 ],

15928 ]

15929 ],

15930 DoNotCareSentinel,

15931 MatchIfTrue[Sequence[cst.EmptyLine]],

15932 OneOf[

15933 Union[

15934 Sequence[

15935 Union[

15936 EmptyLineMatchType,

15937 OneOf[EmptyLineMatchType],

15938 AllOf[EmptyLineMatchType],

15939 AtLeastN[

15940 Union[

15941 EmptyLineMatchType,

15942 OneOf[EmptyLineMatchType],

15943 AllOf[EmptyLineMatchType],

15944 ]

15945 ],

15946 AtMostN[

15947 Union[

15948 EmptyLineMatchType,

15949 OneOf[EmptyLineMatchType],

15950 AllOf[EmptyLineMatchType],

15951 ]

15952 ],

15953 ]

15954 ],

15955 MatchIfTrue[Sequence[cst.EmptyLine]],

15956 ]

15957 ],

15958 AllOf[

15959 Union[

15960 Sequence[

15961 Union[

15962 EmptyLineMatchType,

15963 OneOf[EmptyLineMatchType],

15964 AllOf[EmptyLineMatchType],

15965 AtLeastN[

15966 Union[

15967 EmptyLineMatchType,

15968 OneOf[EmptyLineMatchType],

15969 AllOf[EmptyLineMatchType],

15970 ]

15971 ],

15972 AtMostN[

15973 Union[

15974 EmptyLineMatchType,

15975 OneOf[EmptyLineMatchType],

15976 AllOf[EmptyLineMatchType],

15977 ]

15978 ],

15979 ]

15980 ],

15981 MatchIfTrue[Sequence[cst.EmptyLine]],

15982 ]

15983 ],

15984 ] = DoNotCare()

15985 whitespace_after_while: Union[

15986 SimpleWhitespaceMatchType,

15987 DoNotCareSentinel,

15988 OneOf[SimpleWhitespaceMatchType],

15989 AllOf[SimpleWhitespaceMatchType],

15990 ] = DoNotCare()

15991 whitespace_before_colon: Union[

15992 SimpleWhitespaceMatchType,

15993 DoNotCareSentinel,

15994 OneOf[SimpleWhitespaceMatchType],

15995 AllOf[SimpleWhitespaceMatchType],

15996 ] = DoNotCare()

15997 metadata: Union[

15998 MetadataMatchType,

15999 DoNotCareSentinel,

16000 OneOf[MetadataMatchType],

16001 AllOf[MetadataMatchType],

16002 ] = DoNotCare()

16003

16004

16005WithItemMatchType = Union["WithItem", MetadataMatchType, MatchIfTrue[cst.WithItem]]

16006

16007

16008@dataclass(frozen=True, eq=False, unsafe_hash=False)

16009class With(BaseCompoundStatement, BaseStatement, BaseMatcherNode):

16010 items: Union[

16011 Sequence[

16012 Union[

16013 WithItemMatchType,

16014 DoNotCareSentinel,

16015 OneOf[WithItemMatchType],

16016 AllOf[WithItemMatchType],

16017 AtLeastN[

16018 Union[

16019 WithItemMatchType,

16020 DoNotCareSentinel,

16021 OneOf[WithItemMatchType],

16022 AllOf[WithItemMatchType],

16023 ]

16024 ],

16025 AtMostN[

16026 Union[

16027 WithItemMatchType,

16028 DoNotCareSentinel,

16029 OneOf[WithItemMatchType],

16030 AllOf[WithItemMatchType],

16031 ]

16032 ],

16033 ]

16034 ],

16035 DoNotCareSentinel,

16036 MatchIfTrue[Sequence[cst.WithItem]],

16037 OneOf[

16038 Union[

16039 Sequence[

16040 Union[

16041 WithItemMatchType,

16042 OneOf[WithItemMatchType],

16043 AllOf[WithItemMatchType],

16044 AtLeastN[

16045 Union[

16046 WithItemMatchType,

16047 OneOf[WithItemMatchType],

16048 AllOf[WithItemMatchType],

16049 ]

16050 ],

16051 AtMostN[

16052 Union[

16053 WithItemMatchType,

16054 OneOf[WithItemMatchType],

16055 AllOf[WithItemMatchType],

16056 ]

16057 ],

16058 ]

16059 ],

16060 MatchIfTrue[Sequence[cst.WithItem]],

16061 ]

16062 ],

16063 AllOf[

16064 Union[

16065 Sequence[

16066 Union[

16067 WithItemMatchType,

16068 OneOf[WithItemMatchType],

16069 AllOf[WithItemMatchType],

16070 AtLeastN[

16071 Union[

16072 WithItemMatchType,

16073 OneOf[WithItemMatchType],

16074 AllOf[WithItemMatchType],

16075 ]

16076 ],

16077 AtMostN[

16078 Union[

16079 WithItemMatchType,

16080 OneOf[WithItemMatchType],

16081 AllOf[WithItemMatchType],

16082 ]

16083 ],

16084 ]

16085 ],

16086 MatchIfTrue[Sequence[cst.WithItem]],

16087 ]

16088 ],

16089 ] = DoNotCare()

16090 body: Union[

16091 BaseSuiteMatchType,

16092 DoNotCareSentinel,

16093 OneOf[BaseSuiteMatchType],

16094 AllOf[BaseSuiteMatchType],

16095 ] = DoNotCare()

16096 asynchronous: Union[

16097 Optional["Asynchronous"],

16098 MetadataMatchType,

16099 MatchIfTrue[Optional[cst.Asynchronous]],

16100 DoNotCareSentinel,

16101 OneOf[

16102 Union[

16103 Optional["Asynchronous"],

16104 MetadataMatchType,

16105 MatchIfTrue[Optional[cst.Asynchronous]],

16106 ]

16107 ],

16108 AllOf[

16109 Union[

16110 Optional["Asynchronous"],

16111 MetadataMatchType,

16112 MatchIfTrue[Optional[cst.Asynchronous]],

16113 ]

16114 ],

16115 ] = DoNotCare()

16116 leading_lines: Union[

16117 Sequence[

16118 Union[

16119 EmptyLineMatchType,

16120 DoNotCareSentinel,

16121 OneOf[EmptyLineMatchType],

16122 AllOf[EmptyLineMatchType],

16123 AtLeastN[

16124 Union[

16125 EmptyLineMatchType,

16126 DoNotCareSentinel,

16127 OneOf[EmptyLineMatchType],

16128 AllOf[EmptyLineMatchType],

16129 ]

16130 ],

16131 AtMostN[

16132 Union[

16133 EmptyLineMatchType,

16134 DoNotCareSentinel,

16135 OneOf[EmptyLineMatchType],

16136 AllOf[EmptyLineMatchType],

16137 ]

16138 ],

16139 ]

16140 ],

16141 DoNotCareSentinel,

16142 MatchIfTrue[Sequence[cst.EmptyLine]],

16143 OneOf[

16144 Union[

16145 Sequence[

16146 Union[

16147 EmptyLineMatchType,

16148 OneOf[EmptyLineMatchType],

16149 AllOf[EmptyLineMatchType],

16150 AtLeastN[

16151 Union[

16152 EmptyLineMatchType,

16153 OneOf[EmptyLineMatchType],

16154 AllOf[EmptyLineMatchType],

16155 ]

16156 ],

16157 AtMostN[

16158 Union[

16159 EmptyLineMatchType,

16160 OneOf[EmptyLineMatchType],

16161 AllOf[EmptyLineMatchType],

16162 ]

16163 ],

16164 ]

16165 ],

16166 MatchIfTrue[Sequence[cst.EmptyLine]],

16167 ]

16168 ],

16169 AllOf[

16170 Union[

16171 Sequence[

16172 Union[

16173 EmptyLineMatchType,

16174 OneOf[EmptyLineMatchType],

16175 AllOf[EmptyLineMatchType],

16176 AtLeastN[

16177 Union[

16178 EmptyLineMatchType,

16179 OneOf[EmptyLineMatchType],

16180 AllOf[EmptyLineMatchType],

16181 ]

16182 ],

16183 AtMostN[

16184 Union[

16185 EmptyLineMatchType,

16186 OneOf[EmptyLineMatchType],

16187 AllOf[EmptyLineMatchType],

16188 ]

16189 ],

16190 ]

16191 ],

16192 MatchIfTrue[Sequence[cst.EmptyLine]],

16193 ]

16194 ],

16195 ] = DoNotCare()

16196 lpar: Union[

16197 LeftParenMatchType,

16198 DoNotCareSentinel,

16199 OneOf[LeftParenMatchType],

16200 AllOf[LeftParenMatchType],

16201 ] = DoNotCare()

16202 rpar: Union[

16203 RightParenMatchType,

16204 DoNotCareSentinel,

16205 OneOf[RightParenMatchType],

16206 AllOf[RightParenMatchType],

16207 ] = DoNotCare()

16208 whitespace_after_with: Union[

16209 SimpleWhitespaceMatchType,

16210 DoNotCareSentinel,

16211 OneOf[SimpleWhitespaceMatchType],

16212 AllOf[SimpleWhitespaceMatchType],

16213 ] = DoNotCare()

16214 whitespace_before_colon: Union[

16215 SimpleWhitespaceMatchType,

16216 DoNotCareSentinel,

16217 OneOf[SimpleWhitespaceMatchType],

16218 AllOf[SimpleWhitespaceMatchType],

16219 ] = DoNotCare()

16220 metadata: Union[

16221 MetadataMatchType,

16222 DoNotCareSentinel,

16223 OneOf[MetadataMatchType],

16224 AllOf[MetadataMatchType],

16225 ] = DoNotCare()

16226

16227

16228@dataclass(frozen=True, eq=False, unsafe_hash=False)

16229class WithItem(BaseMatcherNode):

16230 item: Union[

16231 BaseExpressionMatchType,

16232 DoNotCareSentinel,

16233 OneOf[BaseExpressionMatchType],

16234 AllOf[BaseExpressionMatchType],

16235 ] = DoNotCare()

16236 asname: Union[

16237 Optional["AsName"],

16238 MetadataMatchType,

16239 MatchIfTrue[Optional[cst.AsName]],

16240 DoNotCareSentinel,

16241 OneOf[

16242 Union[

16243 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

16244 ]

16245 ],

16246 AllOf[

16247 Union[

16248 Optional["AsName"], MetadataMatchType, MatchIfTrue[Optional[cst.AsName]]

16249 ]

16250 ],

16251 ] = DoNotCare()

16252 comma: Union[

16253 CommaMatchType, DoNotCareSentinel, OneOf[CommaMatchType], AllOf[CommaMatchType]

16254 ] = DoNotCare()

16255 metadata: Union[

16256 MetadataMatchType,

16257 DoNotCareSentinel,

16258 OneOf[MetadataMatchType],

16259 AllOf[MetadataMatchType],

16260 ] = DoNotCare()

16261

16262

16263BaseExpressionOrFromOrNoneMatchType = Union[

16264 "BaseExpression",

16265 "From",

16266 None,

16267 MetadataMatchType,

16268 MatchIfTrue[Union[cst.BaseExpression, cst.From, None]],

16269]

16270

16271

16272@dataclass(frozen=True, eq=False, unsafe_hash=False)

16273class Yield(BaseExpression, BaseMatcherNode):

16274 value: Union[

16275 BaseExpressionOrFromOrNoneMatchType,

16276 DoNotCareSentinel,

16277 OneOf[BaseExpressionOrFromOrNoneMatchType],

16278 AllOf[BaseExpressionOrFromOrNoneMatchType],

16279 ] = DoNotCare()

16280 lpar: Union[

16281 Sequence[

16282 Union[

16283 LeftParenMatchType,

16284 DoNotCareSentinel,

16285 OneOf[LeftParenMatchType],

16286 AllOf[LeftParenMatchType],

16287 AtLeastN[

16288 Union[

16289 LeftParenMatchType,

16290 DoNotCareSentinel,

16291 OneOf[LeftParenMatchType],

16292 AllOf[LeftParenMatchType],

16293 ]

16294 ],

16295 AtMostN[

16296 Union[

16297 LeftParenMatchType,

16298 DoNotCareSentinel,

16299 OneOf[LeftParenMatchType],

16300 AllOf[LeftParenMatchType],

16301 ]

16302 ],

16303 ]

16304 ],

16305 DoNotCareSentinel,

16306 MatchIfTrue[Sequence[cst.LeftParen]],

16307 OneOf[

16308 Union[

16309 Sequence[

16310 Union[

16311 LeftParenMatchType,

16312 OneOf[LeftParenMatchType],

16313 AllOf[LeftParenMatchType],

16314 AtLeastN[

16315 Union[

16316 LeftParenMatchType,

16317 OneOf[LeftParenMatchType],

16318 AllOf[LeftParenMatchType],

16319 ]

16320 ],

16321 AtMostN[

16322 Union[

16323 LeftParenMatchType,

16324 OneOf[LeftParenMatchType],

16325 AllOf[LeftParenMatchType],

16326 ]

16327 ],

16328 ]

16329 ],

16330 MatchIfTrue[Sequence[cst.LeftParen]],

16331 ]

16332 ],

16333 AllOf[

16334 Union[

16335 Sequence[

16336 Union[

16337 LeftParenMatchType,

16338 OneOf[LeftParenMatchType],

16339 AllOf[LeftParenMatchType],

16340 AtLeastN[

16341 Union[

16342 LeftParenMatchType,

16343 OneOf[LeftParenMatchType],

16344 AllOf[LeftParenMatchType],

16345 ]

16346 ],

16347 AtMostN[

16348 Union[

16349 LeftParenMatchType,

16350 OneOf[LeftParenMatchType],

16351 AllOf[LeftParenMatchType],

16352 ]

16353 ],

16354 ]

16355 ],

16356 MatchIfTrue[Sequence[cst.LeftParen]],

16357 ]

16358 ],

16359 ] = DoNotCare()

16360 rpar: Union[

16361 Sequence[

16362 Union[

16363 RightParenMatchType,

16364 DoNotCareSentinel,

16365 OneOf[RightParenMatchType],

16366 AllOf[RightParenMatchType],

16367 AtLeastN[

16368 Union[

16369 RightParenMatchType,

16370 DoNotCareSentinel,

16371 OneOf[RightParenMatchType],

16372 AllOf[RightParenMatchType],

16373 ]

16374 ],

16375 AtMostN[

16376 Union[

16377 RightParenMatchType,

16378 DoNotCareSentinel,

16379 OneOf[RightParenMatchType],

16380 AllOf[RightParenMatchType],

16381 ]

16382 ],

16383 ]

16384 ],

16385 DoNotCareSentinel,

16386 MatchIfTrue[Sequence[cst.RightParen]],

16387 OneOf[

16388 Union[

16389 Sequence[

16390 Union[

16391 RightParenMatchType,

16392 OneOf[RightParenMatchType],

16393 AllOf[RightParenMatchType],

16394 AtLeastN[

16395 Union[

16396 RightParenMatchType,

16397 OneOf[RightParenMatchType],

16398 AllOf[RightParenMatchType],

16399 ]

16400 ],

16401 AtMostN[

16402 Union[

16403 RightParenMatchType,

16404 OneOf[RightParenMatchType],

16405 AllOf[RightParenMatchType],

16406 ]

16407 ],

16408 ]

16409 ],

16410 MatchIfTrue[Sequence[cst.RightParen]],

16411 ]

16412 ],

16413 AllOf[

16414 Union[

16415 Sequence[

16416 Union[

16417 RightParenMatchType,

16418 OneOf[RightParenMatchType],

16419 AllOf[RightParenMatchType],

16420 AtLeastN[

16421 Union[

16422 RightParenMatchType,

16423 OneOf[RightParenMatchType],

16424 AllOf[RightParenMatchType],

16425 ]

16426 ],

16427 AtMostN[

16428 Union[

16429 RightParenMatchType,

16430 OneOf[RightParenMatchType],

16431 AllOf[RightParenMatchType],

16432 ]

16433 ],

16434 ]

16435 ],

16436 MatchIfTrue[Sequence[cst.RightParen]],

16437 ]

16438 ],

16439 ] = DoNotCare()

16440 whitespace_after_yield: Union[

16441 BaseParenthesizableWhitespaceMatchType,

16442 DoNotCareSentinel,

16443 OneOf[BaseParenthesizableWhitespaceMatchType],

16444 AllOf[BaseParenthesizableWhitespaceMatchType],

16445 ] = DoNotCare()

16446 metadata: Union[

16447 MetadataMatchType,

16448 DoNotCareSentinel,

16449 OneOf[MetadataMatchType],

16450 AllOf[MetadataMatchType],

16451 ] = DoNotCare()

16452

16453

16454__all__ = [

16455 "Add",

16456 "AddAssign",

16457 "AllOf",

16458 "And",

16459 "AnnAssign",

16460 "Annotation",

16461 "Arg",

16462 "AsName",

16463 "Assert",

16464 "Assign",

16465 "AssignEqual",

16466 "AssignTarget",

16467 "Asynchronous",

16468 "AtLeastN",

16469 "AtMostN",

16470 "Attribute",

16471 "AugAssign",

16472 "Await",

16473 "BaseAssignTargetExpression",

16474 "BaseAugOp",

16475 "BaseBinaryOp",

16476 "BaseBooleanOp",

16477 "BaseComp",

16478 "BaseCompOp",

16479 "BaseCompoundStatement",

16480 "BaseDelTargetExpression",

16481 "BaseDict",

16482 "BaseDictElement",

16483 "BaseElement",

16484 "BaseExpression",

16485 "BaseFormattedStringContent",

16486 "BaseList",

16487 "BaseMatcherNode",

16488 "BaseMetadataProvider",

16489 "BaseNumber",

16490 "BaseParenthesizableWhitespace",

16491 "BaseSet",

16492 "BaseSimpleComp",

16493 "BaseSlice",

16494 "BaseSmallStatement",

16495 "BaseStatement",

16496 "BaseString",

16497 "BaseSuite",

16498 "BaseTemplatedStringContent",

16499 "BaseUnaryOp",

16500 "BinaryOperation",

16501 "BitAnd",

16502 "BitAndAssign",

16503 "BitInvert",

16504 "BitOr",

16505 "BitOrAssign",

16506 "BitXor",

16507 "BitXorAssign",

16508 "BooleanOperation",

16509 "Break",

16510 "Call",

16511 "ClassDef",

16512 "Colon",

16513 "Comma",

16514 "Comment",

16515 "CompFor",

16516 "CompIf",

16517 "Comparison",

16518 "ComparisonTarget",

16519 "ConcatenatedString",

16520 "Continue",

16521 "Decorator",

16522 "Del",

16523 "Dict",

16524 "DictComp",

16525 "DictElement",

16526 "Divide",

16527 "DivideAssign",

16528 "DoNotCare",

16529 "DoNotCareSentinel",

16530 "DoesNotMatch",

16531 "Dot",

16532 "Element",

16533 "Ellipsis",

16534 "Else",

16535 "EmptyLine",

16536 "Equal",

16537 "ExceptHandler",

16538 "ExceptStarHandler",

16539 "Expr",

16540 "Finally",

16541 "Float",

16542 "FloorDivide",

16543 "FloorDivideAssign",

16544 "For",

16545 "FormattedString",

16546 "FormattedStringExpression",

16547 "FormattedStringText",

16548 "From",

16549 "FunctionDef",

16550 "GeneratorExp",

16551 "Global",

16552 "GreaterThan",

16553 "GreaterThanEqual",

16554 "If",

16555 "IfExp",

16556 "Imaginary",

16557 "Import",

16558 "ImportAlias",

16559 "ImportFrom",

16560 "ImportStar",

16561 "In",

16562 "IndentedBlock",

16563 "Index",

16564 "Integer",

16565 "Is",

16566 "IsNot",

16567 "Lambda",

16568 "LeftCurlyBrace",

16569 "LeftParen",

16570 "LeftShift",

16571 "LeftShiftAssign",

16572 "LeftSquareBracket",

16573 "LessThan",

16574 "LessThanEqual",

16575 "List",

16576 "ListComp",

16577 "Match",

16578 "MatchAs",

16579 "MatchCase",

16580 "MatchClass",

16581 "MatchDecoratorMismatch",

16582 "MatchIfTrue",

16583 "MatchKeywordElement",

16584 "MatchList",

16585 "MatchMapping",

16586 "MatchMappingElement",

16587 "MatchMetadata",

16588 "MatchMetadataIfTrue",

16589 "MatchOr",

16590 "MatchOrElement",

16591 "MatchPattern",

16592 "MatchRegex",

16593 "MatchSequence",

16594 "MatchSequenceElement",

16595 "MatchSingleton",

16596 "MatchStar",

16597 "MatchTuple",

16598 "MatchValue",

16599 "MatcherDecoratableTransformer",

16600 "MatcherDecoratableVisitor",

16601 "MatrixMultiply",

16602 "MatrixMultiplyAssign",

16603 "Minus",

16604 "Module",

16605 "Modulo",

16606 "ModuloAssign",

16607 "Multiply",

16608 "MultiplyAssign",

16609 "Name",

16610 "NameItem",

16611 "NamedExpr",

16612 "Newline",

16613 "Nonlocal",

16614 "Not",

16615 "NotEqual",

16616 "NotIn",

16617 "OneOf",

16618 "Or",

16619 "Param",

16620 "ParamSlash",

16621 "ParamSpec",

16622 "ParamStar",

16623 "Parameters",

16624 "ParenthesizedWhitespace",

16625 "Pass",

16626 "Plus",

16627 "Power",

16628 "PowerAssign",

16629 "Raise",

16630 "Return",

16631 "RightCurlyBrace",

16632 "RightParen",

16633 "RightShift",

16634 "RightShiftAssign",

16635 "RightSquareBracket",

16636 "SaveMatchedNode",

16637 "Semicolon",

16638 "Set",

16639 "SetComp",

16640 "SimpleStatementLine",

16641 "SimpleStatementSuite",

16642 "SimpleString",

16643 "SimpleWhitespace",

16644 "Slice",

16645 "StarredDictElement",

16646 "StarredElement",

16647 "Subscript",

16648 "SubscriptElement",

16649 "Subtract",

16650 "SubtractAssign",

16651 "TemplatedString",

16652 "TemplatedStringExpression",

16653 "TemplatedStringText",

16654 "TrailingWhitespace",

16655 "Try",

16656 "TryStar",

16657 "Tuple",

16658 "TypeAlias",

16659 "TypeOf",

16660 "TypeParam",

16661 "TypeParameters",

16662 "TypeVar",

16663 "TypeVarTuple",

16664 "UnaryOperation",

16665 "While",

16666 "With",

16667 "WithItem",

16668 "Yield",

16669 "ZeroOrMore",

16670 "ZeroOrOne",

16671 "call_if_inside",

16672 "call_if_not_inside",

16673 "extract",

16674 "extractall",

16675 "findall",

16676 "leave",

16677 "matches",

16678 "replace",

16679 "visit",

16680]

Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/libcst/matchers/init.py: 99%

1249 statements