Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/django/template/defaulttags.py: 22%

1"""Default tags used by the template system, available to all templates.""" 

2import re 

3import sys 

4import warnings 

5from collections import namedtuple 

6from datetime import datetime 

7from itertools import cycle as itertools_cycle 

8from itertools import groupby 

9 

10from django.conf import settings 

11from django.utils import timezone 

12from django.utils.html import conditional_escape, escape, format_html 

13from django.utils.lorem_ipsum import paragraphs, words 

14from django.utils.safestring import mark_safe 

15 

16from .base import ( 

17 BLOCK_TAG_END, 

18 BLOCK_TAG_START, 

19 COMMENT_TAG_END, 

20 COMMENT_TAG_START, 

21 FILTER_SEPARATOR, 

22 SINGLE_BRACE_END, 

23 SINGLE_BRACE_START, 

24 VARIABLE_ATTRIBUTE_SEPARATOR, 

25 VARIABLE_TAG_END, 

26 VARIABLE_TAG_START, 

27 Node, 

28 NodeList, 

29 TemplateSyntaxError, 

30 VariableDoesNotExist, 

31 kwarg_re, 

32 render_value_in_context, 

33 token_kwargs, 

34) 

35from .context import Context 

36from .defaultfilters import date 

37from .library import Library 

38from .smartif import IfParser, Literal 

39 

40register = Library() 

41 

42 

43class AutoEscapeControlNode(Node): 

44 """Implement the actions of the autoescape tag.""" 

45 

46 def __init__(self, setting, nodelist): 

47 self.setting, self.nodelist = setting, nodelist 

48 

49 def render(self, context): 

50 old_setting = context.autoescape 

51 context.autoescape = self.setting 

52 output = self.nodelist.render(context) 

53 context.autoescape = old_setting 

54 if self.setting: 

55 return mark_safe(output) 

56 else: 

57 return output 

58 

59 

60class CommentNode(Node): 

61 child_nodelists = () 

62 

63 def render(self, context): 

64 return "" 

65 

66 

67class CsrfTokenNode(Node): 

68 child_nodelists = () 

69 

70 def render(self, context): 

71 csrf_token = context.get("csrf_token") 

72 if csrf_token: 

73 if csrf_token == "NOTPROVIDED": 

74 return format_html("") 

75 else: 

76 return format_html( 

77 '<input type="hidden" name="csrfmiddlewaretoken" value="{}">', 

78 csrf_token, 

79 ) 

80 else: 

81 # It's very probable that the token is missing because of 

82 # misconfiguration, so we raise a warning 

83 if settings.DEBUG: 

84 warnings.warn( 

85 "A {% csrf_token %} was used in a template, but the context " 

86 "did not provide the value. This is usually caused by not " 

87 "using RequestContext." 

88 ) 

89 return "" 

90 

91 

92class CycleNode(Node): 

93 def __init__(self, cyclevars, variable_name=None, silent=False): 

94 self.cyclevars = cyclevars 

95 self.variable_name = variable_name 

96 self.silent = silent 

97 

98 def render(self, context): 

99 if self not in context.render_context: 

100 # First time the node is rendered in template 

101 context.render_context[self] = itertools_cycle(self.cyclevars) 

102 cycle_iter = context.render_context[self] 

103 value = next(cycle_iter).resolve(context) 

104 if self.variable_name: 

105 context.set_upward(self.variable_name, value) 

106 if self.silent: 

107 return "" 

108 return render_value_in_context(value, context) 

109 

110 def reset(self, context): 

111 """ 

112 Reset the cycle iteration back to the beginning. 

113 """ 

114 context.render_context[self] = itertools_cycle(self.cyclevars) 

115 

116 

117class DebugNode(Node): 

118 def render(self, context): 

119 if not settings.DEBUG: 

120 return "" 

121 

122 from pprint import pformat 

123 

124 output = [escape(pformat(val)) for val in context] 

125 output.append("\n\n") 

126 output.append(escape(pformat(sys.modules))) 

127 return "".join(output) 

128 

129 

130class FilterNode(Node): 

131 def __init__(self, filter_expr, nodelist): 

132 self.filter_expr, self.nodelist = filter_expr, nodelist 

133 

134 def render(self, context): 

135 output = self.nodelist.render(context) 

136 # Apply filters. 

137 with context.push(var=output): 

138 return self.filter_expr.resolve(context) 

139 

140 

141class FirstOfNode(Node): 

142 def __init__(self, variables, asvar=None): 

143 self.vars = variables 

144 self.asvar = asvar 

145 

146 def render(self, context): 

147 first = "" 

148 for var in self.vars: 

149 value = var.resolve(context, ignore_failures=True) 

150 if value: 

151 first = render_value_in_context(value, context) 

152 break 

153 if self.asvar: 

154 context[self.asvar] = first 

155 return "" 

156 return first 

157 

158 

159class ForNode(Node): 

160 child_nodelists = ("nodelist_loop", "nodelist_empty") 

161 

162 def __init__( 

163 self, loopvars, sequence, is_reversed, nodelist_loop, nodelist_empty=None 

164 ): 

165 self.loopvars, self.sequence = loopvars, sequence 

166 self.is_reversed = is_reversed 

167 self.nodelist_loop = nodelist_loop 

168 if nodelist_empty is None: 

169 self.nodelist_empty = NodeList() 

170 else: 

171 self.nodelist_empty = nodelist_empty 

172 

173 def __repr__(self): 

174 reversed_text = " reversed" if self.is_reversed else "" 

175 return "<%s: for %s in %s, tail_len: %d%s>" % ( 

176 self.__class__.__name__, 

177 ", ".join(self.loopvars), 

178 self.sequence, 

179 len(self.nodelist_loop), 

180 reversed_text, 

181 ) 

182 

183 def render(self, context): 

184 if "forloop" in context: 

185 parentloop = context["forloop"] 

186 else: 

187 parentloop = {} 

188 with context.push(): 

189 values = self.sequence.resolve(context, ignore_failures=True) 

190 if values is None: 

191 values = [] 

192 if not hasattr(values, "__len__"): 

193 values = list(values) 

194 len_values = len(values) 

195 if len_values < 1: 

196 return self.nodelist_empty.render(context) 

197 nodelist = [] 

198 if self.is_reversed: 

199 values = reversed(values) 

200 num_loopvars = len(self.loopvars) 

201 unpack = num_loopvars > 1 

202 # Create a forloop value in the context. We'll update counters on each 

203 # iteration just below. 

204 loop_dict = context["forloop"] = {"parentloop": parentloop} 

205 for i, item in enumerate(values): 

206 # Shortcuts for current loop iteration number. 

207 loop_dict["counter0"] = i 

208 loop_dict["counter"] = i + 1 

209 # Reverse counter iteration numbers. 

210 loop_dict["revcounter"] = len_values - i 

211 loop_dict["revcounter0"] = len_values - i - 1 

212 # Boolean values designating first and last times through loop. 

213 loop_dict["first"] = i == 0 

214 loop_dict["last"] = i == len_values - 1 

215 

216 pop_context = False 

217 if unpack: 

218 # If there are multiple loop variables, unpack the item into 

219 # them. 

220 try: 

221 len_item = len(item) 

222 except TypeError: # not an iterable 

223 len_item = 1 

224 # Check loop variable count before unpacking 

225 if num_loopvars != len_item: 

226 raise ValueError( 

227 "Need {} values to unpack in for loop; got {}. ".format( 

228 num_loopvars, len_item 

229 ), 

230 ) 

231 unpacked_vars = dict(zip(self.loopvars, item)) 

232 pop_context = True 

233 context.update(unpacked_vars) 

234 else: 

235 context[self.loopvars[0]] = item 

236 

237 for node in self.nodelist_loop: 

238 nodelist.append(node.render_annotated(context)) 

239 

240 if pop_context: 

241 # Pop the loop variables pushed on to the context to avoid 

242 # the context ending up in an inconsistent state when other 

243 # tags (e.g., include and with) push data to context. 

244 context.pop() 

245 return mark_safe("".join(nodelist)) 

246 

247 

248class IfChangedNode(Node): 

249 child_nodelists = ("nodelist_true", "nodelist_false") 

250 

251 def __init__(self, nodelist_true, nodelist_false, *varlist): 

252 self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false 

253 self._varlist = varlist 

254 

255 def render(self, context): 

256 # Init state storage 

257 state_frame = self._get_context_stack_frame(context) 

258 state_frame.setdefault(self) 

259 

260 nodelist_true_output = None 

261 if self._varlist: 

262 # Consider multiple parameters. This behaves like an OR evaluation 

263 # of the multiple variables. 

264 compare_to = [ 

265 var.resolve(context, ignore_failures=True) for var in self._varlist 

266 ] 

267 else: 

268 # The "{% ifchanged %}" syntax (without any variables) compares 

269 # the rendered output. 

270 compare_to = nodelist_true_output = self.nodelist_true.render(context) 

271 

272 if compare_to != state_frame[self]: 

273 state_frame[self] = compare_to 

274 # render true block if not already rendered 

275 return nodelist_true_output or self.nodelist_true.render(context) 

276 elif self.nodelist_false: 

277 return self.nodelist_false.render(context) 

278 return "" 

279 

280 def _get_context_stack_frame(self, context): 

281 # The Context object behaves like a stack where each template tag can 

282 # create a new scope. Find the place where to store the state to detect 

283 # changes. 

284 if "forloop" in context: 

285 # Ifchanged is bound to the local for loop. 

286 # When there is a loop-in-loop, the state is bound to the inner loop, 

287 # so it resets when the outer loop continues. 

288 return context["forloop"] 

289 else: 

290 # Using ifchanged outside loops. Effectively this is a no-op 

291 # because the state is associated with 'self'. 

292 return context.render_context 

293 

294 

295class IfNode(Node): 

296 def __init__(self, conditions_nodelists): 

297 self.conditions_nodelists = conditions_nodelists 

298 

299 def __repr__(self): 

300 return "<%s>" % self.__class__.__name__ 

301 

302 def __iter__(self): 

303 for _, nodelist in self.conditions_nodelists: 

304 yield from nodelist 

305 

306 @property 

307 def nodelist(self): 

308 return NodeList(self) 

309 

310 def render(self, context): 

311 for condition, nodelist in self.conditions_nodelists: 

312 

313 if condition is not None: # if / elif clause 

314 try: 

315 match = condition.eval(context) 

316 except VariableDoesNotExist: 

317 match = None 

318 else: # else clause 

319 match = True 

320 

321 if match: 

322 return nodelist.render(context) 

323 

324 return "" 

325 

326 

327class LoremNode(Node): 

328 def __init__(self, count, method, common): 

329 self.count, self.method, self.common = count, method, common 

330 

331 def render(self, context): 

332 try: 

333 count = int(self.count.resolve(context)) 

334 except (ValueError, TypeError): 

335 count = 1 

336 if self.method == "w": 

337 return words(count, common=self.common) 

338 else: 

339 paras = paragraphs(count, common=self.common) 

340 if self.method == "p": 

341 paras = ["<p>%s</p>" % p for p in paras] 

342 return "\n\n".join(paras) 

343 

344 

345GroupedResult = namedtuple("GroupedResult", ["grouper", "list"]) 

346 

347 

348class RegroupNode(Node): 

349 def __init__(self, target, expression, var_name): 

350 self.target, self.expression = target, expression 

351 self.var_name = var_name 

352 

353 def resolve_expression(self, obj, context): 

354 # This method is called for each object in self.target. See regroup() 

355 # for the reason why we temporarily put the object in the context. 

356 context[self.var_name] = obj 

357 return self.expression.resolve(context, ignore_failures=True) 

358 

359 def render(self, context): 

360 obj_list = self.target.resolve(context, ignore_failures=True) 

361 if obj_list is None: 

362 # target variable wasn't found in context; fail silently. 

363 context[self.var_name] = [] 

364 return "" 

365 # List of dictionaries in the format: 

366 # {'grouper': 'key', 'list': [list of contents]}. 

367 context[self.var_name] = [ 

368 GroupedResult(grouper=key, list=list(val)) 

369 for key, val in groupby( 

370 obj_list, lambda obj: self.resolve_expression(obj, context) 

371 ) 

372 ] 

373 return "" 

374 

375 

376class LoadNode(Node): 

377 child_nodelists = () 

378 

379 def render(self, context): 

380 return "" 

381 

382 

383class NowNode(Node): 

384 def __init__(self, format_string, asvar=None): 

385 self.format_string = format_string 

386 self.asvar = asvar 

387 

388 def render(self, context): 

389 tzinfo = timezone.get_current_timezone() if settings.USE_TZ else None 

390 formatted = date(datetime.now(tz=tzinfo), self.format_string) 

391 

392 if self.asvar: 

393 context[self.asvar] = formatted 

394 return "" 

395 else: 

396 return formatted 

397 

398 

399class ResetCycleNode(Node): 

400 def __init__(self, node): 

401 self.node = node 

402 

403 def render(self, context): 

404 self.node.reset(context) 

405 return "" 

406 

407 

408class SpacelessNode(Node): 

409 def __init__(self, nodelist): 

410 self.nodelist = nodelist 

411 

412 def render(self, context): 

413 from django.utils.html import strip_spaces_between_tags 

414 

415 return strip_spaces_between_tags(self.nodelist.render(context).strip()) 

416 

417 

418class TemplateTagNode(Node): 

419 mapping = { 

420 "openblock": BLOCK_TAG_START, 

421 "closeblock": BLOCK_TAG_END, 

422 "openvariable": VARIABLE_TAG_START, 

423 "closevariable": VARIABLE_TAG_END, 

424 "openbrace": SINGLE_BRACE_START, 

425 "closebrace": SINGLE_BRACE_END, 

426 "opencomment": COMMENT_TAG_START, 

427 "closecomment": COMMENT_TAG_END, 

428 } 

429 

430 def __init__(self, tagtype): 

431 self.tagtype = tagtype 

432 

433 def render(self, context): 

434 return self.mapping.get(self.tagtype, "") 

435 

436 

437class URLNode(Node): 

438 child_nodelists = () 

439 

440 def __init__(self, view_name, args, kwargs, asvar): 

441 self.view_name = view_name 

442 self.args = args 

443 self.kwargs = kwargs 

444 self.asvar = asvar 

445 

446 def __repr__(self): 

447 return "<%s view_name='%s' args=%s kwargs=%s as=%s>" % ( 

448 self.__class__.__qualname__, 

449 self.view_name, 

450 repr(self.args), 

451 repr(self.kwargs), 

452 repr(self.asvar), 

453 ) 

454 

455 def render(self, context): 

456 from django.urls import NoReverseMatch, reverse 

457 

458 args = [arg.resolve(context) for arg in self.args] 

459 kwargs = {k: v.resolve(context) for k, v in self.kwargs.items()} 

460 view_name = self.view_name.resolve(context) 

461 try: 

462 current_app = context.request.current_app 

463 except AttributeError: 

464 try: 

465 current_app = context.request.resolver_match.namespace 

466 except AttributeError: 

467 current_app = None 

468 # Try to look up the URL. If it fails, raise NoReverseMatch unless the 

469 # {% url ... as var %} construct is used, in which case return nothing. 

470 url = "" 

471 try: 

472 url = reverse(view_name, args=args, kwargs=kwargs, current_app=current_app) 

473 except NoReverseMatch: 

474 if self.asvar is None: 

475 raise 

476 

477 if self.asvar: 

478 context[self.asvar] = url 

479 return "" 

480 else: 

481 if context.autoescape: 

482 url = conditional_escape(url) 

483 return url 

484 

485 

486class VerbatimNode(Node): 

487 def __init__(self, content): 

488 self.content = content 

489 

490 def render(self, context): 

491 return self.content 

492 

493 

494class WidthRatioNode(Node): 

495 def __init__(self, val_expr, max_expr, max_width, asvar=None): 

496 self.val_expr = val_expr 

497 self.max_expr = max_expr 

498 self.max_width = max_width 

499 self.asvar = asvar 

500 

501 def render(self, context): 

502 try: 

503 value = self.val_expr.resolve(context) 

504 max_value = self.max_expr.resolve(context) 

505 max_width = int(self.max_width.resolve(context)) 

506 except VariableDoesNotExist: 

507 return "" 

508 except (ValueError, TypeError): 

509 raise TemplateSyntaxError("widthratio final argument must be a number") 

510 try: 

511 value = float(value) 

512 max_value = float(max_value) 

513 ratio = (value / max_value) * max_width 

514 result = str(round(ratio)) 

515 except ZeroDivisionError: 

516 result = "0" 

517 except (ValueError, TypeError, OverflowError): 

518 result = "" 

519 

520 if self.asvar: 

521 context[self.asvar] = result 

522 return "" 

523 else: 

524 return result 

525 

526 

527class WithNode(Node): 

528 def __init__(self, var, name, nodelist, extra_context=None): 

529 self.nodelist = nodelist 

530 # var and name are legacy attributes, being left in case they are used 

531 # by third-party subclasses of this Node. 

532 self.extra_context = extra_context or {} 

533 if name: 

534 self.extra_context[name] = var 

535 

536 def __repr__(self): 

537 return "<%s>" % self.__class__.__name__ 

538 

539 def render(self, context): 

540 values = {key: val.resolve(context) for key, val in self.extra_context.items()} 

541 with context.push(**values): 

542 return self.nodelist.render(context) 

543 

544 

545@register.tag 

546def autoescape(parser, token): 

547 """ 

548 Force autoescape behavior for this block. 

549 """ 

550 # token.split_contents() isn't useful here because this tag doesn't accept 

551 # variable as arguments. 

552 args = token.contents.split() 

553 if len(args) != 2: 

554 raise TemplateSyntaxError("'autoescape' tag requires exactly one argument.") 

555 arg = args[1] 

556 if arg not in ("on", "off"): 

557 raise TemplateSyntaxError("'autoescape' argument should be 'on' or 'off'") 

558 nodelist = parser.parse(("endautoescape",)) 

559 parser.delete_first_token() 

560 return AutoEscapeControlNode((arg == "on"), nodelist) 

561 

562 

563@register.tag 

564def comment(parser, token): 

565 """ 

566 Ignore everything between ``{% comment %}`` and ``{% endcomment %}``. 

567 """ 

568 parser.skip_past("endcomment") 

569 return CommentNode() 

570 

571 

572@register.tag 

573def cycle(parser, token): 

574 """ 

575 Cycle among the given strings each time this tag is encountered. 

576 

577 Within a loop, cycles among the given strings each time through 

578 the loop:: 

579 

580 {% for o in some_list %} 

581 <tr class="{% cycle 'row1' 'row2' %}"> 

582 ... 

583 </tr> 

584 {% endfor %} 

585 

586 Outside of a loop, give the values a unique name the first time you call 

587 it, then use that name each successive time through:: 

588 

589 <tr class="{% cycle 'row1' 'row2' 'row3' as rowcolors %}">...</tr> 

590 <tr class="{% cycle rowcolors %}">...</tr> 

591 <tr class="{% cycle rowcolors %}">...</tr> 

592 

593 You can use any number of values, separated by spaces. Commas can also 

594 be used to separate values; if a comma is used, the cycle values are 

595 interpreted as literal strings. 

596 

597 The optional flag "silent" can be used to prevent the cycle declaration 

598 from returning any value:: 

599 

600 {% for o in some_list %} 

601 {% cycle 'row1' 'row2' as rowcolors silent %} 

602 <tr class="{{ rowcolors }}">{% include "subtemplate.html " %}</tr> 

603 {% endfor %} 

604 """ 

605 # Note: This returns the exact same node on each {% cycle name %} call; 

606 # that is, the node object returned from {% cycle a b c as name %} and the 

607 # one returned from {% cycle name %} are the exact same object. This 

608 # shouldn't cause problems (heh), but if it does, now you know. 

609 # 

610 # Ugly hack warning: This stuffs the named template dict into parser so 

611 # that names are only unique within each template (as opposed to using 

612 # a global variable, which would make cycle names have to be unique across 

613 # *all* templates. 

614 # 

615 # It keeps the last node in the parser to be able to reset it with 

616 # {% resetcycle %}. 

617 

618 args = token.split_contents() 

619 

620 if len(args) < 2: 

621 raise TemplateSyntaxError("'cycle' tag requires at least two arguments") 

622 

623 if len(args) == 2: 

624 # {% cycle foo %} case. 

625 name = args[1] 

626 if not hasattr(parser, "_named_cycle_nodes"): 

627 raise TemplateSyntaxError( 

628 "No named cycles in template. '%s' is not defined" % name 

629 ) 

630 if name not in parser._named_cycle_nodes: 

631 raise TemplateSyntaxError("Named cycle '%s' does not exist" % name) 

632 return parser._named_cycle_nodes[name] 

633 

634 as_form = False 

635 

636 if len(args) > 4: 

637 # {% cycle ... as foo [silent] %} case. 

638 if args[-3] == "as": 

639 if args[-1] != "silent": 

640 raise TemplateSyntaxError( 

641 "Only 'silent' flag is allowed after cycle's name, not '%s'." 

642 % args[-1] 

643 ) 

644 as_form = True 

645 silent = True 

646 args = args[:-1] 

647 elif args[-2] == "as": 

648 as_form = True 

649 silent = False 

650 

651 if as_form: 

652 name = args[-1] 

653 values = [parser.compile_filter(arg) for arg in args[1:-2]] 

654 node = CycleNode(values, name, silent=silent) 

655 if not hasattr(parser, "_named_cycle_nodes"): 

656 parser._named_cycle_nodes = {} 

657 parser._named_cycle_nodes[name] = node 

658 else: 

659 values = [parser.compile_filter(arg) for arg in args[1:]] 

660 node = CycleNode(values) 

661 parser._last_cycle_node = node 

662 return node 

663 

664 

665@register.tag 

666def csrf_token(parser, token): 

667 return CsrfTokenNode() 

668 

669 

670@register.tag 

671def debug(parser, token): 

672 """ 

673 Output a whole load of debugging information, including the current 

674 context and imported modules. 

675 

676 Sample usage:: 

677 

678 <pre> 

679 {% debug %} 

680 </pre> 

681 """ 

682 return DebugNode() 

683 

684 

685@register.tag("filter") 

686def do_filter(parser, token): 

687 """ 

688 Filter the contents of the block through variable filters. 

689 

690 Filters can also be piped through each other, and they can have 

691 arguments -- just like in variable syntax. 

692 

693 Sample usage:: 

694 

695 {% filter force_escape|lower %} 

696 This text will be HTML-escaped, and will appear in lowercase. 

697 {% endfilter %} 

698 

699 Note that the ``escape`` and ``safe`` filters are not acceptable arguments. 

700 Instead, use the ``autoescape`` tag to manage autoescaping for blocks of 

701 template code. 

702 """ 

703 # token.split_contents() isn't useful here because this tag doesn't accept 

704 # variable as arguments. 

705 _, rest = token.contents.split(None, 1) 

706 filter_expr = parser.compile_filter("var|%s" % (rest)) 

707 for func, unused in filter_expr.filters: 

708 filter_name = getattr(func, "_filter_name", None) 

709 if filter_name in ("escape", "safe"): 

710 raise TemplateSyntaxError( 

711 '"filter %s" is not permitted. Use the "autoescape" tag instead.' 

712 % filter_name 

713 ) 

714 nodelist = parser.parse(("endfilter",)) 

715 parser.delete_first_token() 

716 return FilterNode(filter_expr, nodelist) 

717 

718 

719@register.tag 

720def firstof(parser, token): 

721 """ 

722 Output the first variable passed that is not False. 

723 

724 Output nothing if all the passed variables are False. 

725 

726 Sample usage:: 

727 

728 {% firstof var1 var2 var3 as myvar %} 

729 

730 This is equivalent to:: 

731 

732 {% if var1 %} 

733 {{ var1 }} 

734 {% elif var2 %} 

735 {{ var2 }} 

736 {% elif var3 %} 

737 {{ var3 }} 

738 {% endif %} 

739 

740 but much cleaner! 

741 

742 You can also use a literal string as a fallback value in case all 

743 passed variables are False:: 

744 

745 {% firstof var1 var2 var3 "fallback value" %} 

746 

747 If you want to disable auto-escaping of variables you can use:: 

748 

749 {% autoescape off %} 

750 {% firstof var1 var2 var3 "<strong>fallback value</strong>" %} 

751 {% autoescape %} 

752 

753 Or if only some variables should be escaped, you can use:: 

754 

755 {% firstof var1 var2|safe var3 "<strong>fallback value</strong>"|safe %} 

756 """ 

757 bits = token.split_contents()[1:] 

758 asvar = None 

759 if not bits: 

760 raise TemplateSyntaxError("'firstof' statement requires at least one argument") 

761 

762 if len(bits) >= 2 and bits[-2] == "as": 

763 asvar = bits[-1] 

764 bits = bits[:-2] 

765 return FirstOfNode([parser.compile_filter(bit) for bit in bits], asvar) 

766 

767 

768@register.tag("for") 

769def do_for(parser, token): 

770 """ 

771 Loop over each item in an array. 

772 

773 For example, to display a list of athletes given ``athlete_list``:: 

774 

775 <ul> 

776 {% for athlete in athlete_list %} 

777 <li>{{ athlete.name }}</li> 

778 {% endfor %} 

779 </ul> 

780 

781 You can loop over a list in reverse by using 

782 ``{% for obj in list reversed %}``. 

783 

784 You can also unpack multiple values from a two-dimensional array:: 

785 

786 {% for key,value in dict.items %} 

787 {{ key }}: {{ value }} 

788 {% endfor %} 

789 

790 The ``for`` tag can take an optional ``{% empty %}`` clause that will 

791 be displayed if the given array is empty or could not be found:: 

792 

793 <ul> 

794 {% for athlete in athlete_list %} 

795 <li>{{ athlete.name }}</li> 

796 {% empty %} 

797 <li>Sorry, no athletes in this list.</li> 

798 {% endfor %} 

799 <ul> 

800 

801 The above is equivalent to -- but shorter, cleaner, and possibly faster 

802 than -- the following:: 

803 

804 <ul> 

805 {% if athlete_list %} 

806 {% for athlete in athlete_list %} 

807 <li>{{ athlete.name }}</li> 

808 {% endfor %} 

809 {% else %} 

810 <li>Sorry, no athletes in this list.</li> 

811 {% endif %} 

812 </ul> 

813 

814 The for loop sets a number of variables available within the loop: 

815 

816 ========================== ================================================ 

817 Variable Description 

818 ========================== ================================================ 

819 ``forloop.counter`` The current iteration of the loop (1-indexed) 

820 ``forloop.counter0`` The current iteration of the loop (0-indexed) 

821 ``forloop.revcounter`` The number of iterations from the end of the 

822 loop (1-indexed) 

823 ``forloop.revcounter0`` The number of iterations from the end of the 

824 loop (0-indexed) 

825 ``forloop.first`` True if this is the first time through the loop 

826 ``forloop.last`` True if this is the last time through the loop 

827 ``forloop.parentloop`` For nested loops, this is the loop "above" the 

828 current one 

829 ========================== ================================================ 

830 """ 

831 bits = token.split_contents() 

832 if len(bits) < 4: 

833 raise TemplateSyntaxError( 

834 "'for' statements should have at least four words: %s" % token.contents 

835 ) 

836 

837 is_reversed = bits[-1] == "reversed" 

838 in_index = -3 if is_reversed else -2 

839 if bits[in_index] != "in": 

840 raise TemplateSyntaxError( 

841 "'for' statements should use the format" 

842 " 'for x in y': %s" % token.contents 

843 ) 

844 

845 invalid_chars = frozenset((" ", '"', "'", FILTER_SEPARATOR)) 

846 loopvars = re.split(r" *, *", " ".join(bits[1:in_index])) 

847 for var in loopvars: 

848 if not var or not invalid_chars.isdisjoint(var): 

849 raise TemplateSyntaxError( 

850 "'for' tag received an invalid argument: %s" % token.contents 

851 ) 

852 

853 sequence = parser.compile_filter(bits[in_index + 1]) 

854 nodelist_loop = parser.parse( 

855 ( 

856 "empty", 

857 "endfor", 

858 ) 

859 ) 

860 token = parser.next_token() 

861 if token.contents == "empty": 

862 nodelist_empty = parser.parse(("endfor",)) 

863 parser.delete_first_token() 

864 else: 

865 nodelist_empty = None 

866 return ForNode(loopvars, sequence, is_reversed, nodelist_loop, nodelist_empty) 

867 

868 

869class TemplateLiteral(Literal): 

870 def __init__(self, value, text): 

871 self.value = value 

872 self.text = text # for better error messages 

873 

874 def display(self): 

875 return self.text 

876 

877 def eval(self, context): 

878 return self.value.resolve(context, ignore_failures=True) 

879 

880 

881class TemplateIfParser(IfParser): 

882 error_class = TemplateSyntaxError 

883 

884 def __init__(self, parser, *args, **kwargs): 

885 self.template_parser = parser 

886 super().__init__(*args, **kwargs) 

887 

888 def create_var(self, value): 

889 return TemplateLiteral(self.template_parser.compile_filter(value), value)