Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/mako/codegen.py: 12%

1# mako/codegen.py 

2# Copyright 2006-2026 the Mako authors and contributors <see AUTHORS file> 

3# 

4# This module is part of Mako and is released under 

5# the MIT License: http://www.opensource.org/licenses/mit-license.php 

6 

7"""provides functionality for rendering a parsetree constructing into module 

8source code.""" 

9 

10import json 

11import re 

12import time 

13 

14from mako import ast 

15from mako import exceptions 

16from mako import filters 

17from mako import parsetree 

18from mako import util 

19from mako.pygen import PythonPrinter 

20 

21MAGIC_NUMBER = 10 

22 

23# names which are hardwired into the 

24# template and are not accessed via the 

25# context itself 

26TOPLEVEL_DECLARED = {"UNDEFINED", "STOP_RENDERING"} 

27RESERVED_NAMES = {"context", "loop"}.union(TOPLEVEL_DECLARED) 

28 

29 

30def compile( # noqa 

31 node, 

32 uri, 

33 filename=None, 

34 default_filters=None, 

35 buffer_filters=None, 

36 imports=None, 

37 future_imports=None, 

38 source_encoding=None, 

39 generate_magic_comment=True, 

40 strict_undefined=False, 

41 enable_loop=True, 

42 reserved_names=frozenset(), 

43): 

44 """Generate module source code given a parsetree node, 

45 uri, and optional source filename""" 

46 

47 buf = util.FastEncodingBuffer() 

48 

49 printer = PythonPrinter(buf) 

50 _GenerateRenderMethod( 

51 printer, 

52 _CompileContext( 

53 uri, 

54 filename, 

55 default_filters, 

56 buffer_filters, 

57 imports, 

58 future_imports, 

59 source_encoding, 

60 generate_magic_comment, 

61 strict_undefined, 

62 enable_loop, 

63 reserved_names, 

64 ), 

65 node, 

66 ) 

67 return buf.getvalue() 

68 

69 

70class _CompileContext: 

71 def __init__( 

72 self, 

73 uri, 

74 filename, 

75 default_filters, 

76 buffer_filters, 

77 imports, 

78 future_imports, 

79 source_encoding, 

80 generate_magic_comment, 

81 strict_undefined, 

82 enable_loop, 

83 reserved_names, 

84 ): 

85 self.uri = uri 

86 self.filename = filename 

87 self.default_filters = default_filters 

88 self.buffer_filters = buffer_filters 

89 self.imports = imports 

90 self.future_imports = future_imports 

91 self.source_encoding = source_encoding 

92 self.generate_magic_comment = generate_magic_comment 

93 self.strict_undefined = strict_undefined 

94 self.enable_loop = enable_loop 

95 self.reserved_names = reserved_names 

96 

97 

98class _GenerateRenderMethod: 

99 """A template visitor object which generates the 

100 full module source for a template. 

101 

102 """ 

103 

104 def __init__(self, printer, compiler, node): 

105 self.printer = printer 

106 self.compiler = compiler 

107 self.node = node 

108 self.identifier_stack = [None] 

109 self.in_def = isinstance(node, (parsetree.DefTag, parsetree.BlockTag)) 

110 

111 if self.in_def: 

112 name = "render_%s" % node.funcname 

113 args = node.get_argument_expressions() 

114 filtered = len(node.filter_args.args) > 0 

115 buffered = eval(node.attributes.get("buffered", "False")) 

116 cached = eval(node.attributes.get("cached", "False")) 

117 defs = None 

118 pagetag = None 

119 if node.is_block and not node.is_anonymous: 

120 args += ["**pageargs"] 

121 else: 

122 defs = self.write_toplevel() 

123 pagetag = self.compiler.pagetag 

124 name = "render_body" 

125 if pagetag is not None: 

126 args = pagetag.body_decl.get_argument_expressions() 

127 if not pagetag.body_decl.kwargs: 

128 args += ["**pageargs"] 

129 cached = eval(pagetag.attributes.get("cached", "False")) 

130 self.compiler.enable_loop = self.compiler.enable_loop or eval( 

131 pagetag.attributes.get("enable_loop", "False") 

132 ) 

133 else: 

134 args = ["**pageargs"] 

135 cached = False 

136 buffered = filtered = False 

137 if args is None: 

138 args = ["context"] 

139 else: 

140 args = [a for a in ["context"] + args] 

141 

142 self.write_render_callable( 

143 pagetag or node, name, args, buffered, filtered, cached 

144 ) 

145 

146 if defs is not None: 

147 for node in defs: 

148 _GenerateRenderMethod(printer, compiler, node) 

149 

150 if not self.in_def: 

151 self.write_metadata_struct() 

152 

153 def write_metadata_struct(self): 

154 self.printer.source_map[self.printer.lineno] = max( 

155 self.printer.source_map 

156 ) 

157 struct = { 

158 "filename": self.compiler.filename, 

159 "uri": self.compiler.uri, 

160 "source_encoding": self.compiler.source_encoding, 

161 "line_map": self.printer.source_map, 

162 } 

163 self.printer.writelines( 

164 '"""', 

165 "__M_BEGIN_METADATA", 

166 json.dumps(struct), 

167 "__M_END_METADATA\n" '"""', 

168 ) 

169 

170 @property 

171 def identifiers(self): 

172 return self.identifier_stack[-1] 

173 

174 def write_toplevel(self): 

175 """Traverse a template structure for module-level directives and 

176 generate the start of module-level code. 

177 

178 """ 

179 inherit = [] 

180 namespaces = {} 

181 module_code = [] 

182 

183 self.compiler.pagetag = None 

184 

185 class FindTopLevel: 

186 def visitInheritTag(s, node): 

187 inherit.append(node) 

188 

189 def visitNamespaceTag(s, node): 

190 namespaces[node.name] = node 

191 

192 def visitPageTag(s, node): 

193 self.compiler.pagetag = node 

194 

195 def visitCode(s, node): 

196 if node.ismodule: 

197 module_code.append(node) 

198 

199 f = FindTopLevel() 

200 for n in self.node.nodes: 

201 n.accept_visitor(f) 

202 

203 self.compiler.namespaces = namespaces 

204 

205 module_ident = set() 

206 for n in module_code: 

207 module_ident = module_ident.union(n.declared_identifiers()) 

208 

209 module_identifiers = _Identifiers(self.compiler) 

210 module_identifiers.declared = module_ident 

211 

212 # module-level names, python code 

213 if ( 

214 self.compiler.generate_magic_comment 

215 and self.compiler.source_encoding 

216 ): 

217 self.printer.writeline( 

218 "# -*- coding:%s -*-" % self.compiler.source_encoding 

219 ) 

220 

221 if self.compiler.future_imports: 

222 self.printer.writeline( 

223 "from __future__ import %s" 

224 % (", ".join(self.compiler.future_imports),) 

225 ) 

226 self.printer.writeline("from mako import runtime, filters, cache") 

227 self.printer.writeline("UNDEFINED = runtime.UNDEFINED") 

228 self.printer.writeline("STOP_RENDERING = runtime.STOP_RENDERING") 

229 self.printer.writeline("__M_dict_builtin = dict") 

230 self.printer.writeline("__M_locals_builtin = locals") 

231 self.printer.writeline("_magic_number = %r" % MAGIC_NUMBER) 

232 self.printer.writeline("_modified_time = %r" % time.time()) 

233 self.printer.writeline("_enable_loop = %r" % self.compiler.enable_loop) 

234 self.printer.writeline( 

235 "_template_filename = %r" % self.compiler.filename 

236 ) 

237 self.printer.writeline("_template_uri = %r" % self.compiler.uri) 

238 self.printer.writeline( 

239 "_source_encoding = %r" % self.compiler.source_encoding 

240 ) 

241 if self.compiler.imports: 

242 buf = "" 

243 for imp in self.compiler.imports: 

244 buf += imp + "\n" 

245 self.printer.writeline(imp) 

246 impcode = ast.PythonCode( 

247 buf, 

248 source="", 

249 lineno=0, 

250 pos=0, 

251 filename="template defined imports", 

252 ) 

253 else: 

254 impcode = None 

255 

256 main_identifiers = module_identifiers.branch(self.node) 

257 mit = module_identifiers.topleveldefs 

258 module_identifiers.topleveldefs = mit.union( 

259 main_identifiers.topleveldefs 

260 ) 

261 module_identifiers.declared.update(TOPLEVEL_DECLARED) 

262 if impcode: 

263 module_identifiers.declared.update(impcode.declared_identifiers) 

264 

265 self.compiler.identifiers = module_identifiers 

266 self.printer.writeline( 

267 "_exports = %r" 

268 % [n.name for n in main_identifiers.topleveldefs.values()] 

269 ) 

270 self.printer.write_blanks(2) 

271 

272 if len(module_code): 

273 self.write_module_code(module_code) 

274 

275 if len(inherit): 

276 self.write_namespaces(namespaces) 

277 self.write_inherit(inherit[-1]) 

278 elif len(namespaces): 

279 self.write_namespaces(namespaces) 

280 

281 return list(main_identifiers.topleveldefs.values()) 

282 

283 def write_render_callable( 

284 self, node, name, args, buffered, filtered, cached 

285 ): 

286 """write a top-level render callable. 

287 

288 this could be the main render() method or that of a top-level def.""" 

289 

290 if self.in_def: 

291 decorator = node.decorator 

292 if decorator: 

293 self.printer.writeline( 

294 "@runtime._decorate_toplevel(%s)" % decorator 

295 ) 

296 

297 self.printer.start_source(node.lineno) 

298 self.printer.writelines( 

299 "def %s(%s):" % (name, ",".join(args)), 

300 # push new frame, assign current frame to __M_caller 

301 "__M_caller = context.caller_stack._push_frame()", 

302 "try:", 

303 ) 

304 if buffered or filtered or cached: 

305 self.printer.writeline("context._push_buffer()") 

306 

307 self.identifier_stack.append( 

308 self.compiler.identifiers.branch(self.node) 

309 ) 

310 if (not self.in_def or self.node.is_block) and "**pageargs" in args: 

311 self.identifier_stack[-1].argument_declared.add("pageargs") 

312 

313 if not self.in_def and ( 

314 len(self.identifiers.locally_assigned) > 0 

315 or len(self.identifiers.argument_declared) > 0 

316 ): 

317 self.printer.writeline( 

318 "__M_locals = __M_dict_builtin(%s)" 

319 % ",".join( 

320 [ 

321 "%s=%s" % (x, x) 

322 for x in self.identifiers.argument_declared 

323 ] 

324 ) 

325 ) 

326 

327 self.write_variable_declares(self.identifiers, toplevel=True) 

328 

329 for n in self.node.nodes: 

330 n.accept_visitor(self) 

331 

332 self.write_def_finish(self.node, buffered, filtered, cached) 

333 self.printer.writeline(None) 

334 self.printer.write_blanks(2) 

335 if cached: 

336 self.write_cache_decorator( 

337 node, name, args, buffered, self.identifiers, toplevel=True 

338 ) 

339 

340 def write_module_code(self, module_code): 

341 """write module-level template code, i.e. that which 

342 is enclosed in <%! %> tags in the template.""" 

343 for n in module_code: 

344 self.printer.write_indented_block(n.text, starting_lineno=n.lineno) 

345 

346 def write_inherit(self, node): 

347 """write the module-level inheritance-determination callable.""" 

348 

349 self.printer.writelines( 

350 "def _mako_inherit(template, context):", 

351 "_mako_generate_namespaces(context)", 

352 "return runtime._inherit_from(context, %s, _template_uri)" 

353 % (node.parsed_attributes["file"]), 

354 None, 

355 ) 

356 

357 def write_namespaces(self, namespaces): 

358 """write the module-level namespace-generating callable.""" 

359 self.printer.writelines( 

360 "def _mako_get_namespace(context, name):", 

361 "try:", 

362 "return context.namespaces[(__name__, name)]", 

363 "except KeyError:", 

364 "_mako_generate_namespaces(context)", 

365 "return context.namespaces[(__name__, name)]", 

366 None, 

367 None, 

368 ) 

369 self.printer.writeline("def _mako_generate_namespaces(context):") 

370 

371 for node in namespaces.values(): 

372 if "import" in node.attributes: 

373 self.compiler.has_ns_imports = True 

374 self.printer.start_source(node.lineno) 

375 if len(node.nodes): 

376 self.printer.writeline("def make_namespace():") 

377 export = [] 

378 identifiers = self.compiler.identifiers.branch(node) 

379 self.in_def = True 

380 

381 class NSDefVisitor: 

382 def visitDefTag(s, node): 

383 s.visitDefOrBase(node) 

384 

385 def visitBlockTag(s, node): 

386 s.visitDefOrBase(node) 

387 

388 def visitDefOrBase(s, node): 

389 if node.is_anonymous: 

390 raise exceptions.CompileException( 

391 "Can't put anonymous blocks inside " 

392 "<%namespace>", 

393 **node.exception_kwargs, 

394 ) 

395 self.write_inline_def(node, identifiers, nested=False) 

396 export.append(node.funcname) 

397 

398 vis = NSDefVisitor() 

399 for n in node.nodes: 

400 n.accept_visitor(vis) 

401 self.printer.writeline("return [%s]" % (",".join(export))) 

402 self.printer.writeline(None) 

403 self.in_def = False 

404 callable_name = "make_namespace()" 

405 else: 

406 callable_name = "None" 

407 

408 if "file" in node.parsed_attributes: 

409 self.printer.writeline( 

410 "ns = runtime.TemplateNamespace(%r," 

411 " context._clean_inheritance_tokens()," 

412 " templateuri=%s, callables=%s, " 

413 " calling_uri=_template_uri)" 

414 % ( 

415 node.name, 

416 node.parsed_attributes.get("file", "None"), 

417 callable_name, 

418 ) 

419 ) 

420 elif "module" in node.parsed_attributes: 

421 self.printer.writeline( 

422 "ns = runtime.ModuleNamespace(%r," 

423 " context._clean_inheritance_tokens()," 

424 " callables=%s, calling_uri=_template_uri," 

425 " module=%s)" 

426 % ( 

427 node.name, 

428 callable_name, 

429 node.parsed_attributes.get("module", "None"), 

430 ) 

431 ) 

432 else: 

433 self.printer.writeline( 

434 "ns = runtime.Namespace(%r," 

435 " context._clean_inheritance_tokens()," 

436 " callables=%s, calling_uri=_template_uri)" 

437 % (node.name, callable_name) 

438 ) 

439 if eval(node.attributes.get("inheritable", "False")): 

440 self.printer.writeline("context['self'].%s = ns" % (node.name)) 

441 

442 self.printer.writeline( 

443 "context.namespaces[(__name__, %s)] = ns" % repr(node.name) 

444 ) 

445 self.printer.write_blanks(1) 

446 if not len(namespaces): 

447 self.printer.writeline("pass") 

448 self.printer.writeline(None) 

449 

450 def write_variable_declares(self, identifiers, toplevel=False, limit=None): 

451 """write variable declarations at the top of a function. 

452 

453 the variable declarations are in the form of callable 

454 definitions for defs and/or name lookup within the 

455 function's context argument. the names declared are based 

456 on the names that are referenced in the function body, 

457 which don't otherwise have any explicit assignment 

458 operation. names that are assigned within the body are 

459 assumed to be locally-scoped variables and are not 

460 separately declared. 

461 

462 for def callable definitions, if the def is a top-level 

463 callable then a 'stub' callable is generated which wraps 

464 the current Context into a closure. if the def is not 

465 top-level, it is fully rendered as a local closure. 

466 

467 """ 

468 

469 # collection of all defs available to us in this scope 

470 comp_idents = {c.funcname: c for c in identifiers.defs} 

471 to_write = set() 

472 

473 # write "context.get()" for all variables we are going to 

474 # need that arent in the namespace yet 

475 to_write = to_write.union(identifiers.undeclared) 

476 

477 # write closure functions for closures that we define 

478 # right here 

479 to_write = to_write.union( 

480 [c.funcname for c in identifiers.closuredefs.values()] 

481 ) 

482 

483 # remove identifiers that are declared in the argument 

484 # signature of the callable 

485 to_write = to_write.difference(identifiers.argument_declared) 

486 

487 # remove identifiers that we are going to assign to. 

488 # in this way we mimic Python's behavior, 

489 # i.e. assignment to a variable within a block 

490 # means that variable is now a "locally declared" var, 

491 # which cannot be referenced beforehand. 

492 to_write = to_write.difference(identifiers.locally_declared) 

493 

494 if self.compiler.enable_loop: 

495 has_loop = "loop" in to_write 

496 to_write.discard("loop") 

497 else: 

498 has_loop = False 

499 

500 # if a limiting set was sent, constraint to those items in that list 

501 # (this is used for the caching decorator) 

502 if limit is not None: 

503 to_write = to_write.intersection(limit) 

504 

505 if toplevel and getattr(self.compiler, "has_ns_imports", False): 

506 self.printer.writeline("_import_ns = {}") 

507 self.compiler.has_imports = True 

508 for ident, ns in self.compiler.namespaces.items(): 

509 if "import" in ns.attributes: 

510 self.printer.writeline( 

511 "_mako_get_namespace(context, %r)." 

512 "_populate(_import_ns, %r)" 

513 % ( 

514 ident, 

515 re.split(r"\s*,\s*", ns.attributes["import"]), 

516 ) 

517 ) 

518 

519 if has_loop: 

520 self.printer.writeline("loop = __M_loop = runtime.LoopStack()") 

521 

522 for ident in to_write: 

523 if ident in comp_idents: 

524 comp = comp_idents[ident] 

525 if comp.is_block: 

526 if not comp.is_anonymous: 

527 self.write_def_decl(comp, identifiers) 

528 else: 

529 self.write_inline_def(comp, identifiers, nested=True) 

530 else: 

531 if comp.is_root(): 

532 self.write_def_decl(comp, identifiers) 

533 else: 

534 self.write_inline_def(comp, identifiers, nested=True) 

535 

536 elif ident in self.compiler.namespaces: 

537 self.printer.writeline( 

538 "%s = _mako_get_namespace(context, %r)" % (ident, ident) 

539 ) 

540 else: 

541 if getattr(self.compiler, "has_ns_imports", False): 

542 if self.compiler.strict_undefined: 

543 self.printer.writelines( 

544 "%s = _import_ns.get(%r, UNDEFINED)" 

545 % (ident, ident), 

546 "if %s is UNDEFINED:" % ident, 

547 "try:", 

548 "%s = context[%r]" % (ident, ident), 

549 "except KeyError:", 

550 "raise NameError(\"'%s' is not defined\")" % ident, 

551 None, 

552 None, 

553 ) 

554 else: 

555 self.printer.writeline( 

556 "%s = _import_ns.get" 

557 "(%r, context.get(%r, UNDEFINED))" 

558 % (ident, ident, ident) 

559 ) 

560 else: 

561 if self.compiler.strict_undefined: 

562 self.printer.writelines( 

563 "try:", 

564 "%s = context[%r]" % (ident, ident), 

565 "except KeyError:", 

566 "raise NameError(\"'%s' is not defined\")" % ident, 

567 None, 

568 ) 

569 else: 

570 self.printer.writeline( 

571 "%s = context.get(%r, UNDEFINED)" % (ident, ident) 

572 ) 

573 

574 self.printer.writeline("__M_writer = context.writer()") 

575 

576 def write_def_decl(self, node, identifiers): 

577 """write a locally-available callable referencing a top-level def""" 

578 funcname = node.funcname 

579 namedecls = node.get_argument_expressions() 

580 nameargs = node.get_argument_expressions(as_call=True) 

581 

582 if not self.in_def and ( 

583 len(self.identifiers.locally_assigned) > 0 

584 or len(self.identifiers.argument_declared) > 0 

585 ): 

586 nameargs.insert(0, "context._locals(__M_locals)") 

587 else: 

588 nameargs.insert(0, "context") 

589 self.printer.writeline("def %s(%s):" % (funcname, ",".join(namedecls))) 

590 self.printer.writeline( 

591 "return render_%s(%s)" % (funcname, ",".join(nameargs)) 

592 ) 

593 self.printer.writeline(None) 

594 

595 def write_inline_def(self, node, identifiers, nested): 

596 """write a locally-available def callable inside an enclosing def.""" 

597 

598 namedecls = node.get_argument_expressions() 

599 

600 decorator = node.decorator 

601 if decorator: 

602 self.printer.writeline( 

603 "@runtime._decorate_inline(context, %s)" % decorator 

604 ) 

605 self.printer.writeline( 

606 "def %s(%s):" % (node.funcname, ",".join(namedecls)) 

607 ) 

608 filtered = len(node.filter_args.args) > 0 

609 buffered = eval(node.attributes.get("buffered", "False")) 

610 cached = eval(node.attributes.get("cached", "False")) 

611 self.printer.writelines( 

612 # push new frame, assign current frame to __M_caller 

613 "__M_caller = context.caller_stack._push_frame()", 

614 "try:", 

615 ) 

616 if buffered or filtered or cached: 

617 self.printer.writelines("context._push_buffer()") 

618 

619 identifiers = identifiers.branch(node, nested=nested) 

620 

621 self.write_variable_declares(identifiers) 

622 

623 self.identifier_stack.append(identifiers) 

624 for n in node.nodes: 

625 n.accept_visitor(self) 

626 self.identifier_stack.pop() 

627 

628 self.write_def_finish(node, buffered, filtered, cached) 

629 self.printer.writeline(None) 

630 if cached: 

631 self.write_cache_decorator( 

632 node, 

633 node.funcname, 

634 namedecls, 

635 False, 

636 identifiers, 

637 inline=True, 

638 toplevel=False, 

639 ) 

640 

641 def write_def_finish( 

642 self, node, buffered, filtered, cached, callstack=True 

643 ): 

644 """write the end section of a rendering function, either outermost or 

645 inline. 

646 

647 this takes into account if the rendering function was filtered, 

648 buffered, etc. and closes the corresponding try: block if any, and 

649 writes code to retrieve captured content, apply filters, send proper 

650 return value.""" 

651 

652 if not buffered and not cached and not filtered: 

653 self.printer.writeline("return ''") 

654 if callstack: 

655 self.printer.writelines( 

656 "finally:", "context.caller_stack._pop_frame()", None 

657 ) 

658 

659 if buffered or filtered or cached: 

660 if buffered or cached: 

661 # in a caching scenario, don't try to get a writer 

662 # from the context after popping; assume the caching 

663 # implemenation might be using a context with no 

664 # extra buffers 

665 self.printer.writelines( 

666 "finally:", "__M_buf = context._pop_buffer()" 

667 ) 

668 else: 

669 self.printer.writelines( 

670 "finally:", 

671 "__M_buf, __M_writer = context._pop_buffer_and_writer()", 

672 ) 

673 

674 if callstack: 

675 self.printer.writeline("context.caller_stack._pop_frame()") 

676 

677 s = "__M_buf.getvalue()" 

678 if filtered: 

679 s = self.create_filter_callable( 

680 node.filter_args.args, s, False 

681 ) 

682 self.printer.writeline(None) 

683 if buffered and not cached: 

684 s = self.create_filter_callable( 

685 self.compiler.buffer_filters, s, False 

686 ) 

687 if buffered or cached: 

688 self.printer.writeline("return %s" % s) 

689 else: 

690 self.printer.writelines("__M_writer(%s)" % s, "return ''") 

691 

692 def write_cache_decorator( 

693 self, 

694 node_or_pagetag, 

695 name, 

696 args, 

697 buffered, 

698 identifiers, 

699 inline=False, 

700 toplevel=False, 

701 ): 

702 """write a post-function decorator to replace a rendering 

703 callable with a cached version of itself.""" 

704 

705 self.printer.writeline("__M_%s = %s" % (name, name)) 

706 cachekey = node_or_pagetag.parsed_attributes.get( 

707 "cache_key", repr(name) 

708 ) 

709 

710 cache_args = {} 

711 if self.compiler.pagetag is not None: 

712 cache_args.update( 

713 (pa[6:], self.compiler.pagetag.parsed_attributes[pa]) 

714 for pa in self.compiler.pagetag.parsed_attributes 

715 if pa.startswith("cache_") and pa != "cache_key" 

716 ) 

717 cache_args.update( 

718 (pa[6:], node_or_pagetag.parsed_attributes[pa]) 

719 for pa in node_or_pagetag.parsed_attributes 

720 if pa.startswith("cache_") and pa != "cache_key" 

721 ) 

722 if "timeout" in cache_args: 

723 cache_args["timeout"] = int(eval(cache_args["timeout"])) 

724 

725 self.printer.writeline("def %s(%s):" % (name, ",".join(args))) 

726 

727 # form "arg1, arg2, arg3=arg3, arg4=arg4", etc. 

728 pass_args = [ 

729 "%s=%s" % ((a.split("=")[0],) * 2) if "=" in a else a for a in args 

730 ] 

731 

732 self.write_variable_declares( 

733 identifiers, 

734 toplevel=toplevel, 

735 limit=node_or_pagetag.undeclared_identifiers(), 

736 ) 

737 if buffered: 

738 s = ( 

739 "context.get('local')." 

740 "cache._ctx_get_or_create(" 

741 "%s, lambda:__M_%s(%s), context, %s__M_defname=%r)" 

742 % ( 

743 cachekey, 

744 name, 

745 ",".join(pass_args), 

746 "".join( 

747 ["%s=%s, " % (k, v) for k, v in cache_args.items()] 

748 ), 

749 name, 

750 ) 

751 ) 

752 # apply buffer_filters 

753 s = self.create_filter_callable( 

754 self.compiler.buffer_filters, s, False 

755 ) 

756 self.printer.writelines("return " + s, None) 

757 else: 

758 self.printer.writelines( 

759 "__M_writer(context.get('local')." 

760 "cache._ctx_get_or_create(" 

761 "%s, lambda:__M_%s(%s), context, %s__M_defname=%r))" 

762 % ( 

763 cachekey, 

764 name, 

765 ",".join(pass_args), 

766 "".join( 

767 ["%s=%s, " % (k, v) for k, v in cache_args.items()] 

768 ), 

769 name, 

770 ), 

771 "return ''", 

772 None, 

773 ) 

774 

775 def create_filter_callable(self, args, target, is_expression): 

776 """write a filter-applying expression based on the filters 

777 present in the given filter names, adjusting for the global 

778 'default' filter aliases as needed.""" 

779 

780 def locate_encode(name): 

781 if re.match(r"decode\..+", name): 

782 return "filters." + name 

783 else: 

784 return filters.DEFAULT_ESCAPES.get(name, name) 

785 

786 if "n" not in args: 

787 if is_expression: 

788 if self.compiler.pagetag: 

789 args = self.compiler.pagetag.filter_args.args + args 

790 if self.compiler.default_filters and "n" not in args: 

791 args = self.compiler.default_filters + args 

792 for e in args: 

793 # if filter given as a function, get just the identifier portion 

794 if e == "n": 

795 continue 

796 m = re.match(r"(.+?)(\(.*\))", e) 

797 if m: 

798 ident, fargs = m.group(1, 2) 

799 f = locate_encode(ident) 

800 e = f + fargs 

801 else: 

802 e = locate_encode(e) 

803 assert e is not None 

804 target = "%s(%s)" % (e, target) 

805 return target 

806 

807 def visitExpression(self, node): 

808 self.printer.start_source(node.lineno) 

809 if ( 

810 len(node.escapes) 

811 or ( 

812 self.compiler.pagetag is not None 

813 and len(self.compiler.pagetag.filter_args.args) 

814 ) 

815 or len(self.compiler.default_filters) 

816 ): 

817 s = self.create_filter_callable( 

818 node.escapes_code.args, "%s" % node.text, True 

819 ) 

820 self.printer.writeline("__M_writer(%s)" % s) 

821 else: 

822 self.printer.writeline("__M_writer(%s)" % node.text) 

823 

824 def visitControlLine(self, node): 

825 if node.isend: 

826 self.printer.writeline(None) 

827 if node.has_loop_context: 

828 self.printer.writeline("finally:") 

829 self.printer.writeline("loop = __M_loop._exit()") 

830 self.printer.writeline(None) 

831 else: 

832 self.printer.start_source(node.lineno) 

833 if self.compiler.enable_loop and node.keyword == "for": 

834 text = mangle_mako_loop(node, self.printer) 

835 else: 

836 text = node.text 

837 self.printer.writeline(text) 

838 children = node.get_children() 

839 

840 # this covers the four situations where we want to insert a pass: 

841 # 1) a ternary control line with no children, 

842 # 2) a primary control line with nothing but its own ternary 

843 # and end control lines, and 

844 # 3) any control line with no content other than comments 

845 # 4) the first control block with no content other than comments 

846 def _search_for_control_line():