Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/astroid/nodes/as

1# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html

2# For details: https://github.com/pylint-dev/astroid/blob/main/LICENSE

3# Copyright (c) https://github.com/pylint-dev/astroid/blob/main/CONTRIBUTORS.txt

5"""This module renders Astroid nodes as string"""

7from __future__ import annotations

9import warnings

10from collections.abc import Iterator

11from typing import TYPE_CHECKING

13from astroid import nodes

15if TYPE_CHECKING:

16 from astroid import objects

18# pylint: disable=unused-argument

20DOC_NEWLINE = "\0"

23# Visitor pattern require argument all the time and is not better with staticmethod

24# noinspection PyUnusedLocal,PyMethodMayBeStatic

25class AsStringVisitor:

26 """Visitor to render an Astroid node as a valid python code string"""

28 def __init__(self, indent: str = " "):

29 self.indent: str = indent

31 def __call__(self, node: nodes.NodeNG) -> str:

32 """Makes this visitor behave as a simple function"""

33 return node.accept(self).replace(DOC_NEWLINE, "\n")

35 def _docs_dedent(self, doc_node: nodes.Const | None) -> str:

36 """Stop newlines in docs being indented by self._stmt_list"""

37 if not doc_node:

38 return ""

40 return '\n{}"""{}"""'.format(

41 self.indent, doc_node.value.replace("\n", DOC_NEWLINE)

42 )

44 def _stmt_list(self, stmts: list, indent: bool = True) -> str:

45 """return a list of nodes to string"""

46 stmts_str: str = "\n".join(

47 nstr for nstr in [n.accept(self) for n in stmts] if nstr

48 )

49 if not indent:

50 return stmts_str

52 return self.indent + stmts_str.replace("\n", "\n" + self.indent)

54 def _precedence_parens(

55 self, node: nodes.NodeNG, child: nodes.NodeNG, is_left: bool = True

56 ) -> str:

57 """Wrap child in parens only if required to keep same semantics"""

58 if self._should_wrap(node, child, is_left):

59 return f"({child.accept(self)})"

61 return child.accept(self)

63 def _should_wrap(

64 self, node: nodes.NodeNG, child: nodes.NodeNG, is_left: bool

65 ) -> bool:

66 """Wrap child if:

67 - it has lower precedence

68 - same precedence with position opposite to associativity direction

69 """

70 node_precedence = node.op_precedence()

71 child_precedence = child.op_precedence()

73 if node_precedence > child_precedence:

74 # 3 * (4 + 5)

75 return True

77 if (

78 node_precedence == child_precedence

79 and is_left != node.op_left_associative()

80 ):

81 # 3 - (4 - 5)

82 # (2**3)**4

83 return True

85 return False

87 # visit_<node> methods ###########################################

89 def visit_await(self, node: nodes.Await) -> str:

90 return f"await {node.value.accept(self)}"

92 def visit_asyncwith(self, node: nodes.AsyncWith) -> str:

93 return f"async {self.visit_with(node)}"

95 def visit_asyncfor(self, node: nodes.AsyncFor) -> str:

96 return f"async {self.visit_for(node)}"

98 def visit_arguments(self, node: nodes.Arguments) -> str:

99 """return an nodes.Arguments node as string"""

100 return node.format_args()

101

102 def visit_assignattr(self, node: nodes.AssignAttr) -> str:

103 """return an nodes.AssignAttr node as string"""

104 return self.visit_attribute(node)

105

106 def visit_assert(self, node: nodes.Assert) -> str:

107 """return an nodes.Assert node as string"""

108 if node.fail:

109 return f"assert {node.test.accept(self)}, {node.fail.accept(self)}"

110 return f"assert {node.test.accept(self)}"

111

112 def visit_assignname(self, node: nodes.AssignName) -> str:

113 """return an nodes.AssignName node as string"""

114 return node.name

115

116 def visit_assign(self, node: nodes.Assign) -> str:

117 """return an nodes.Assign node as string"""

118 lhs = " = ".join(n.accept(self) for n in node.targets)

119 return f"{lhs} = {node.value.accept(self)}"

120

121 def visit_augassign(self, node: nodes.AugAssign) -> str:

122 """return an nodes.AugAssign node as string"""

123 return f"{node.target.accept(self)} {node.op} {node.value.accept(self)}"

124

125 def visit_annassign(self, node: nodes.AnnAssign) -> str:

126 """Return an nodes.AnnAssign node as string"""

127

128 target = node.target.accept(self)

129 annotation = node.annotation.accept(self)

130 if node.value is None:

131 return f"{target}: {annotation}"

132 return f"{target}: {annotation} = {node.value.accept(self)}"

133

134 def visit_binop(self, node: nodes.BinOp) -> str:

135 """return an nodes.BinOp node as string"""

136 left = self._precedence_parens(node, node.left)

137 right = self._precedence_parens(node, node.right, is_left=False)

138 if node.op == "**":

139 return f"{left}{node.op}{right}"

140

141 return f"{left} {node.op} {right}"

142

143 def visit_boolop(self, node: nodes.BoolOp) -> str:

144 """return an nodes.BoolOp node as string"""

145 values = [f"{self._precedence_parens(node, n)}" for n in node.values]

146 return (f" {node.op} ").join(values)

147

148 def visit_break(self, node: nodes.Break) -> str:

149 """return an nodes.Break node as string"""

150 return "break"

151

152 def visit_call(self, node: nodes.Call) -> str:

153 """return an nodes.Call node as string"""

154 expr_str = self._precedence_parens(node, node.func)

155 args = [arg.accept(self) for arg in node.args]

156 if node.keywords:

157 keywords = [kwarg.accept(self) for kwarg in node.keywords]

158 else:

159 keywords = []

160

161 args.extend(keywords)

162 return f"{expr_str}({', '.join(args)})"

163

164 def _handle_type_params(

165 self, type_params: list[nodes.TypeVar | nodes.ParamSpec | nodes.TypeVarTuple]

166 ) -> str:

167 return (

168 f"[{', '.join(tp.accept(self) for tp in type_params)}]"

169 if type_params

170 else ""

171 )

172

173 def visit_classdef(self, node: nodes.ClassDef) -> str:

174 """return an nodes.ClassDef node as string"""

175 decorate = node.decorators.accept(self) if node.decorators else ""

176 type_params = self._handle_type_params(node.type_params)

177 args = [n.accept(self) for n in node.bases]

178 if node._metaclass and not node.has_metaclass_hack():

179 args.append("metaclass=" + node._metaclass.accept(self))

180 args += [n.accept(self) for n in node.keywords]

181 args_str = f"({', '.join(args)})" if args else ""

182 docs = self._docs_dedent(node.doc_node)

183 body = self._stmt_list(node.body)

184 return (

185 f"\n\n{decorate}class {node.name}{type_params}{args_str}:{docs}\n{body}\n"

186 )

187

188 def visit_compare(self, node: nodes.Compare) -> str:

189 """return an nodes.Compare node as string"""

190 rhs_str = " ".join(

191 f"{op} {self._precedence_parens(node, expr, is_left=False)}"

192 for op, expr in node.ops

193 )

194 return f"{self._precedence_parens(node, node.left)} {rhs_str}"

195

196 def visit_comprehension(self, node: nodes.Comprehension) -> str:

197 """return an nodes.Comprehension node as string"""

198 ifs = "".join(f" if {n.accept(self)}" for n in node.ifs)

199 generated = f"for {node.target.accept(self)} in {node.iter.accept(self)}{ifs}"

200 return f"{'async ' if node.is_async else ''}{generated}"

201

202 def visit_const(self, node: nodes.Const) -> str:

203 """return an nodes.Const node as string"""

204 if node.value is Ellipsis:

205 return "..."

206 return repr(node.value)

207

208 def visit_continue(self, node: nodes.Continue) -> str:

209 """return an nodes.Continue node as string"""

210 return "continue"

211

212 def visit_delete(self, node: nodes.Delete) -> str:

213 """return an nodes.Delete node as string"""

214 return f"del {', '.join(child.accept(self) for child in node.targets)}"

215

216 def visit_delattr(self, node: nodes.DelAttr) -> str:

217 """return an nodes.DelAttr node as string"""

218 return self.visit_attribute(node)

219

220 def visit_delname(self, node: nodes.DelName) -> str:

221 """return an nodes.DelName node as string"""

222 return node.name

223

224 def visit_decorators(self, node: nodes.Decorators) -> str:

225 """return an nodes.Decorators node as string"""

226 joined = "\n@".join(item.accept(self) for item in node.nodes)

227 return f"@{joined}\n"

228

229 def visit_dict(self, node: nodes.Dict) -> str:

230 """return an nodes.Dict node as string"""

231 return f"{{{', '.join(self._visit_dict(node))}}}"

232

233 def _visit_dict(self, node: nodes.Dict) -> Iterator[str]:

234 for key, value in node.items:

235 key = key.accept(self)

236 value = value.accept(self)

237 if key == "**":

238 # It can only be a DictUnpack node.

239 yield key + value

240 else:

241 yield f"{key}: {value}"

242

243 def visit_dictunpack(self, node: nodes.DictUnpack) -> str:

244 return "**"

245

246 def visit_dictcomp(self, node: nodes.DictComp) -> str:

247 """return an nodes.DictComp node as string"""

248 return "{{{}: {} {}}}".format(

249 node.key.accept(self),

250 node.value.accept(self),

251 " ".join(n.accept(self) for n in node.generators),

252 )

253

254 def visit_expr(self, node: nodes.Expr) -> str:

255 """return an nodes.Expr node as string"""

256 return node.value.accept(self)

257

258 def visit_emptynode(self, node: nodes.EmptyNode) -> str:

259 """dummy method for visiting an EmptyNode"""

260 return ""

261

262 def visit_excepthandler(self, node: nodes.ExceptHandler) -> str:

263 n = "except"

264 if isinstance(getattr(node, "parent", None), nodes.TryStar):

265 n = "except*"

266 if node.type:

267 if node.name:

268 excs = f"{n} {node.type.accept(self)} as {node.name.accept(self)}"

269 else:

270 excs = f"{n} {node.type.accept(self)}"

271 else:

272 excs = f"{n}"

273 return f"{excs}:\n{self._stmt_list(node.body)}"

274

275 def visit_empty(self, node: nodes.EmptyNode) -> str:

276 """return an EmptyNode as string"""

277 return ""

278

279 def visit_for(self, node: nodes.For) -> str:

280 """return an nodes.For node as string"""

281 fors = f"for {node.target.accept(self)} in {node.iter.accept(self)}:\n{self._stmt_list(node.body)}"

282 if node.orelse:

283 fors = f"{fors}\nelse:\n{self._stmt_list(node.orelse)}"

284 return fors

285

286 def visit_importfrom(self, node: nodes.ImportFrom) -> str:

287 """return an nodes.ImportFrom node as string"""

288 return "from {} import {}".format(

289 "." * (node.level or 0) + node.modname, _import_string(node.names)

290 )

291

292 def visit_joinedstr(self, node: nodes.JoinedStr) -> str:

293 string = "".join(

294 # Use repr on the string literal parts

295 # to get proper escapes, e.g. \n, \\, \"

296 # But strip the quotes off the ends

297 # (they will always be one character: ' or ")

298 (

299 repr(value.value)[1:-1]

300 # Literal braces must be doubled to escape them

301 .replace("{", "{{").replace("}", "}}")

302 # Each value in values is either a string literal (Const)

303 # or a FormattedValue

304 if type(value).__name__ == "Const"

305 else value.accept(self)

306 )

307 for value in node.values

308 )

309

310 # Try to find surrounding quotes that don't appear at all in the string.

311 # Because the formatted values inside {} can't contain backslash (\)

312 # using a triple quote is sometimes necessary

313 for quote in ("'", '"', '"""', "'''"):

314 if quote not in string:

315 break

316

317 return "f" + quote + string + quote

318

319 def visit_formattedvalue(self, node: nodes.FormattedValue) -> str:

320 result = node.value.accept(self)

321 if node.conversion and node.conversion >= 0:

322 # e.g. if node.conversion == 114: result += "!r"

323 result += "!" + chr(node.conversion)

324 if node.format_spec:

325 # The format spec is itself a JoinedString, i.e. an f-string

326 # We strip the f and quotes of the ends

327 result += ":" + node.format_spec.accept(self)[2:-1]

328 return f"{{{result}}}"

329

330 def handle_functiondef(self, node: nodes.FunctionDef, keyword: str) -> str:

331 """return a (possibly async) function definition node as string"""

332 decorate = node.decorators.accept(self) if node.decorators else ""

333 type_params = self._handle_type_params(node.type_params)

334 docs = self._docs_dedent(node.doc_node)

335 trailer = ":"

336 if node.returns:

337 return_annotation = " -> " + node.returns.as_string()

338 trailer = return_annotation + ":"

339 def_format = "\n%s%s %s%s(%s)%s%s\n%s"

340 return def_format % (

341 decorate,

342 keyword,

343 node.name,

344 type_params,

345 node.args.accept(self),

346 trailer,

347 docs,

348 self._stmt_list(node.body),

349 )

350

351 def visit_functiondef(self, node: nodes.FunctionDef) -> str:

352 """return an nodes.FunctionDef node as string"""

353 return self.handle_functiondef(node, "def")

354

355 def visit_asyncfunctiondef(self, node: nodes.AsyncFunctionDef) -> str:

356 """return an nodes.AsyncFunction node as string"""

357 return self.handle_functiondef(node, "async def")

358

359 def visit_generatorexp(self, node: nodes.GeneratorExp) -> str:

360 """return an nodes.GeneratorExp node as string"""

361 return "({} {})".format(

362 node.elt.accept(self), " ".join(n.accept(self) for n in node.generators)

363 )

364

365 def visit_attribute(

366 self, node: nodes.Attribute | nodes.AssignAttr | nodes.DelAttr

367 ) -> str:

368 """return an nodes.Attribute node as string"""

369 try:

370 left = self._precedence_parens(node, node.expr)

371 except RecursionError:

372 warnings.warn(

373 "Recursion limit exhausted; defaulting to adding parentheses.",

374 UserWarning,

375 stacklevel=2,

376 )

377 left = f"({node.expr.accept(self)})"

378 if left.isdigit():

379 left = f"({left})"

380 return f"{left}.{node.attrname}"

381

382 def visit_global(self, node: nodes.Global) -> str:

383 """return an nodes.Global node as string"""

384 return f"global {', '.join(node.names)}"

385

386 def visit_if(self, node: nodes.If) -> str:

387 """return an nodes.If node as string"""

388 ifs = [f"if {node.test.accept(self)}:\n{self._stmt_list(node.body)}"]

389 if node.has_elif_block():

390 ifs.append(f"el{self._stmt_list(node.orelse, indent=False)}")

391 elif node.orelse:

392 ifs.append(f"else:\n{self._stmt_list(node.orelse)}")

393 return "\n".join(ifs)

394

395 def visit_ifexp(self, node: nodes.IfExp) -> str:

396 """return an nodes.IfExp node as string"""

397 body = self._precedence_parens(node, node.body, is_left=True)

398 test = self._precedence_parens(node, node.test, is_left=True)

399 orelse = self._precedence_parens(node, node.orelse, is_left=False)

400 return f"{body} if {test} else {orelse}"

401

402 def visit_import(self, node: nodes.Import) -> str:

403 """return an nodes.Import node as string"""

404 return f"import {_import_string(node.names)}"

405

406 def visit_keyword(self, node: nodes.Keyword) -> str:

407 """return an nodes.Keyword node as string"""

408 if node.arg is None:

409 return f"**{node.value.accept(self)}"

410 return f"{node.arg}={node.value.accept(self)}"

411

412 def visit_lambda(self, node: nodes.Lambda) -> str:

413 """return an nodes.Lambda node as string"""

414 args = node.args.accept(self)

415 body = node.body.accept(self)

416 if args:

417 return f"lambda {args}: {body}"

418

419 return f"lambda: {body}"

420

421 def visit_list(self, node: nodes.List) -> str:

422 """return an nodes.List node as string"""

423 return f"[{', '.join(child.accept(self) for child in node.elts)}]"

424

425 def visit_listcomp(self, node: nodes.ListComp) -> str:

426 """return an nodes.ListComp node as string"""

427 return "[{} {}]".format(

428 node.elt.accept(self), " ".join(n.accept(self) for n in node.generators)

429 )

430

431 def visit_module(self, node: nodes.Module) -> str:

432 """return an nodes.Module node as string"""

433 docs = f'"""{node.doc_node.value}"""\n\n' if node.doc_node else ""

434 return docs + "\n".join(n.accept(self) for n in node.body) + "\n\n"

435

436 def visit_name(self, node: nodes.Name) -> str:

437 """return an nodes.Name node as string"""

438 return node.name

439

440 def visit_namedexpr(self, node: nodes.NamedExpr) -> str:

441 """Return an assignment expression node as string, always parenthesized."""

442 target = node.target.accept(self)

443 value = node.value.accept(self)

444 if isinstance(node.parent, nodes.Compare):

445 return f"{target} := {value}"

446 return f"({target} := {value})"

447

448 def visit_nonlocal(self, node: nodes.Nonlocal) -> str:

449 """return an nodes.Nonlocal node as string"""

450 return f"nonlocal {', '.join(node.names)}"

451

452 def visit_paramspec(self, node: nodes.ParamSpec) -> str:

453 """return an nodes.ParamSpec node as string"""

454 default_value_str = (

455 f" = {node.default_value.accept(self)}" if node.default_value else ""

456 )

457 return f"**{node.name.accept(self)}{default_value_str}"

458

459 def visit_pass(self, node: nodes.Pass) -> str:

460 """return an nodes.Pass node as string"""

461 return "pass"

462

463 def visit_partialfunction(self, node: objects.PartialFunction) -> str:

464 """Return an objects.PartialFunction as string."""

465 return self.visit_functiondef(node)

466

467 def visit_raise(self, node: nodes.Raise) -> str:

468 """return an nodes.Raise node as string"""

469 if node.exc:

470 if node.cause:

471 return f"raise {node.exc.accept(self)} from {node.cause.accept(self)}"

472 return f"raise {node.exc.accept(self)}"

473 return "raise"

474

475 def visit_return(self, node: nodes.Return) -> str:

476 """return an nodes.Return node as string"""

477 if node.is_tuple_return() and len(node.value.elts) > 1:

478 elts = [child.accept(self) for child in node.value.elts]

479 return f"return {', '.join(elts)}"

480

481 if node.value:

482 return f"return {node.value.accept(self)}"

483

484 return "return"

485

486 def visit_set(self, node: nodes.Set) -> str:

487 """return an nodes.Set node as string"""

488 return f"{{{', '.join(child.accept(self) for child in node.elts)}}}"

489

490 def visit_setcomp(self, node: nodes.SetComp) -> str:

491 """return an nodes.SetComp node as string"""

492 return "{{{} {}}}".format(

493 node.elt.accept(self), " ".join(n.accept(self) for n in node.generators)

494 )

495

496 def visit_slice(self, node: nodes.Slice) -> str:

497 """return an nodes.Slice node as string"""

498 lower = node.lower.accept(self) if node.lower else ""

499 upper = node.upper.accept(self) if node.upper else ""

500 step = node.step.accept(self) if node.step else ""

501 if step:

502 return f"{lower}:{upper}:{step}"

503 return f"{lower}:{upper}"

504

505 def visit_subscript(self, node: nodes.Subscript) -> str:

506 """return an nodes.Subscript node as string"""

507 idx = node.slice

508 if idx.__class__.__name__.lower() == "index":

509 idx = idx.value

510 idxstr = idx.accept(self)

511 if idx.__class__.__name__.lower() == "tuple" and idx.elts:

512 # Remove parenthesis in tuple and extended slice.

513 # a[(::1, 1:)] is not valid syntax.

514 idxstr = idxstr[1:-1]

515 return f"{self._precedence_parens(node, node.value)}[{idxstr}]"

516

517 def visit_try(self, node: nodes.Try) -> str:

518 """return an nodes.Try node as string"""

519 trys = [f"try:\n{self._stmt_list(node.body)}"]

520 for handler in node.handlers:

521 trys.append(handler.accept(self))

522 if node.orelse:

523 trys.append(f"else:\n{self._stmt_list(node.orelse)}")

524 if node.finalbody:

525 trys.append(f"finally:\n{self._stmt_list(node.finalbody)}")

526 return "\n".join(trys)

527

528 def visit_trystar(self, node: nodes.TryStar) -> str:

529 """return an nodes.TryStar node as string"""

530 trys = [f"try:\n{self._stmt_list(node.body)}"]

531 for handler in node.handlers:

532 trys.append(handler.accept(self))

533 if node.orelse:

534 trys.append(f"else:\n{self._stmt_list(node.orelse)}")

535 if node.finalbody:

536 trys.append(f"finally:\n{self._stmt_list(node.finalbody)}")

537 return "\n".join(trys)

538

539 def visit_tuple(self, node: nodes.Tuple) -> str:

540 """return an nodes.Tuple node as string"""

541 if len(node.elts) == 1:

542 return f"({node.elts[0].accept(self)}, )"

543 return f"({', '.join(child.accept(self) for child in node.elts)})"

544

545 def visit_typealias(self, node: nodes.TypeAlias) -> str:

546 """return an nodes.TypeAlias node as string"""

547 type_params = self._handle_type_params(node.type_params)

548 return f"type {node.name.accept(self)}{type_params} = {node.value.accept(self)}"

549

550 def visit_typevar(self, node: nodes.TypeVar) -> str:

551 """return an nodes.TypeVar node as string"""

552 bound_str = f": {node.bound.accept(self)}" if node.bound else ""

553 default_value_str = (

554 f" = {node.default_value.accept(self)}" if node.default_value else ""

555 )

556 return f"{node.name.accept(self)}{bound_str}{default_value_str}"

557

558 def visit_typevartuple(self, node: nodes.TypeVarTuple) -> str:

559 """return an nodes.TypeVarTuple node as string"""

560 default_value_str = (

561 f" = {node.default_value.accept(self)}" if node.default_value else ""

562 )

563 return f"*{node.name.accept(self)}{default_value_str}"

564

565 def visit_unaryop(self, node: nodes.UnaryOp) -> str:

566 """return an nodes.UnaryOp node as string"""

567 if node.op == "not":

568 operator = "not "

569 else:

570 operator = node.op

571 return f"{operator}{self._precedence_parens(node, node.operand)}"

572

573 def visit_while(self, node: nodes.While) -> str:

574 """return an nodes.While node as string"""

575 whiles = f"while {node.test.accept(self)}:\n{self._stmt_list(node.body)}"

576 if node.orelse:

577 whiles = f"{whiles}\nelse:\n{self._stmt_list(node.orelse)}"

578 return whiles

579

580 def visit_with(self, node: nodes.With) -> str: # 'with' without 'as' is possible

581 """return an nodes.With node as string"""

582 items = ", ".join(

583 f"{expr.accept(self)}" + ((v and f" as {v.accept(self)}") or "")

584 for expr, v in node.items

585 )

586 return f"with {items}:\n{self._stmt_list(node.body)}"

587

588 def visit_yield(self, node: nodes.Yield) -> str:

589 """yield an ast.Yield node as string"""

590 yi_val = (" " + node.value.accept(self)) if node.value else ""

591 expr = "yield" + yi_val

592 if node.parent.is_statement:

593 return expr

594

595 return f"({expr})"

596

597 def visit_yieldfrom(self, node: nodes.YieldFrom) -> str:

598 """Return an nodes.YieldFrom node as string."""

599 yi_val = (" " + node.value.accept(self)) if node.value else ""

600 expr = "yield from" + yi_val

601 if node.parent.is_statement:

602 return expr

603

604 return f"({expr})"

605

606 def visit_starred(self, node: nodes.Starred) -> str:

607 """return Starred node as string"""

608 return "*" + node.value.accept(self)

609

610 def visit_match(self, node: nodes.Match) -> str:

611 """Return an nodes.Match node as string."""

612 return f"match {node.subject.accept(self)}:\n{self._stmt_list(node.cases)}"

613

614 def visit_matchcase(self, node: nodes.MatchCase) -> str:

615 """Return an nodes.MatchCase node as string."""

616 guard_str = f" if {node.guard.accept(self)}" if node.guard else ""

617 return (

618 f"case {node.pattern.accept(self)}{guard_str}:\n"

619 f"{self._stmt_list(node.body)}"

620 )

621

622 def visit_matchvalue(self, node: nodes.MatchValue) -> str:

623 """Return an nodes.MatchValue node as string."""

624 return node.value.accept(self)

625

626 @staticmethod

627 def visit_matchsingleton(node: nodes.MatchSingleton) -> str:

628 """Return an nodes.MatchSingleton node as string."""

629 return str(node.value)

630

631 def visit_matchsequence(self, node: nodes.MatchSequence) -> str:

632 """Return an nodes.MatchSequence node as string."""

633 if node.patterns is None:

634 return "[]"

635 return f"[{', '.join(p.accept(self) for p in node.patterns)}]"

636

637 def visit_matchmapping(self, node: nodes.MatchMapping) -> str:

638 """Return an nodes..MatchMapping node as string."""

639 mapping_strings: list[str] = []

640 if node.keys and node.patterns:

641 mapping_strings.extend(

642 f"{key.accept(self)}: {p.accept(self)}"

643 for key, p in zip(node.keys, node.patterns)

644 )

645 if node.rest:

646 mapping_strings.append(f"**{node.rest.accept(self)}")

647 return f"{'{'}{', '.join(mapping_strings)}{'}'}"

648

649 def visit_matchclass(self, node: nodes.MatchClass) -> str:

650 """Return an nodes..MatchClass node as string."""

651 if node.cls is None:

652 raise AssertionError(f"{node} does not have a 'cls' node")

653 class_strings: list[str] = []

654 if node.patterns:

655 class_strings.extend(p.accept(self) for p in node.patterns)

656 if node.kwd_attrs and node.kwd_patterns:

657 for attr, pattern in zip(node.kwd_attrs, node.kwd_patterns):

658 class_strings.append(f"{attr}={pattern.accept(self)}")

659 return f"{node.cls.accept(self)}({', '.join(class_strings)})"

660

661 def visit_matchstar(self, node: nodes.MatchStar) -> str:

662 """Return an nodes..MatchStar node as string."""

663 return f"*{node.name.accept(self) if node.name else '_'}"

664

665 def visit_matchas(self, node: nodes.MatchAs) -> str:

666 """Return an nodes..MatchAs node as string."""

667 if isinstance(

668 node.parent, (nodes.MatchSequence, nodes.MatchMapping, nodes.MatchClass)

669 ):

670 return node.name.accept(self) if node.name else "_"

671 return (

672 f"{node.pattern.accept(self) if node.pattern else '_'}"

673 f"{f' as {node.name.accept(self)}' if node.name else ''}"

674 )

675

676 def visit_matchor(self, node: nodes.MatchOr) -> str:

677 """Return an nodes.MatchOr node as string."""

678 if node.patterns is None:

679 raise AssertionError(f"{node} does not have pattern nodes")

680 return " | ".join(p.accept(self) for p in node.patterns)

681

682 def visit_templatestr(self, node: nodes.TemplateStr) -> str:

683 """Return an nodes.TemplateStr node as string."""

684 string = ""

685 for value in node.values:

686 match value:

687 case nodes.Interpolation():

688 string += "{" + value.accept(self) + "}"

689 case _:

690 string += value.accept(self)[1:-1]

691 for quote in ("'", '"', '"""', "'''"):

692 if quote not in string:

693 break

694 return "t" + quote + string + quote

695

696 def visit_interpolation(self, node: nodes.Interpolation) -> str:

697 """Return an nodes.Interpolation node as string."""

698 result = f"{node.str}"

699 if node.conversion and node.conversion >= 0:

700 # e.g. if node.conversion == 114: result += "!r"

701 result += "!" + chr(node.conversion)

702 if node.format_spec:

703 # The format spec is itself a JoinedString, i.e. an f-string

704 # We strip the f and quotes of the ends

705 result += ":" + node.format_spec.accept(self)[2:-1]

706 return result

707

708 # These aren't for real AST nodes, but for inference objects.

709

710 def visit_frozenset(self, node: objects.FrozenSet) -> str:

711 return node.parent.accept(self)

712

713 def visit_super(self, node: objects.Super) -> str:

714 return node.parent.accept(self)

715

716 def visit_uninferable(self, node) -> str:

717 return str(node)

718

719 def visit_property(self, node: objects.Property) -> str:

720 return node.function.accept(self)

721

722 def visit_evaluatedobject(self, node: nodes.EvaluatedObject) -> str:

723 return node.original.accept(self)

724

725 def visit_unknown(self, node: nodes.Unknown) -> str:

726 return str(node)

727

728

729def _import_string(names: list[tuple[str, str | None]]) -> str:

730 """return a list of (name, asname) formatted as a string"""

731 _names = []

732 for name, asname in names:

733 if asname is not None:

734 _names.append(f"{name} as {asname}")

735 else:

736 _names.append(name)

737 return ", ".join(_names)

738

739

740# This sets the default indent to 4 spaces.

741to_code = AsStringVisitor(" ")

Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/astroid/nodes/as_string.py: 40%

412 statements