Lines Matching refs:self
36 self,
121 """The `self` in templates."""
123 def __init__(self, context: "Context") -> None:
124 self.__context = context
126 def __getitem__(self, name: str) -> t.Any:
127 blocks = self.__context.blocks[name]
128 return BlockReference(name, self.__context, blocks, 0)
130 def __repr__(self) -> str:
131 return f"<{type(self).__name__} {self.__context.name!r}>"
136 def f_all(self: "Context") -> t.Any:
137 return dict_method(self.get_all())
164 self,
171 self.parent = parent
172 self.vars: t.Dict[str, t.Any] = {}
173 self.environment: "Environment" = environment
174 self.eval_ctx = EvalContext(self.environment, name)
175 self.exported_vars: t.Set[str] = set()
176 self.name = name
177 self.globals_keys = set() if globals is None else set(globals)
182 self.blocks = {k: [v] for k, v in blocks.items()}
185 self, name: str, current: t.Callable[["Context"], t.Iterator[str]]
189 blocks = self.blocks[name]
193 return self.environment.undefined(
196 return BlockReference(name, self, blocks, index)
198 def get(self, key: str, default: t.Any = None) -> t.Any:
206 return self[key]
210 def resolve(self, key: str) -> t.Union[t.Any, "Undefined"]:
220 rv = self.resolve_or_missing(key)
223 return self.environment.undefined(name=key)
227 def resolve_or_missing(self, key: str) -> t.Any:
237 if key in self.vars:
238 return self.vars[key]
240 if key in self.parent:
241 return self.parent[key]
245 def get_exported(self) -> t.Dict[str, t.Any]:
247 return {k: self.vars[k] for k in self.exported_vars}
249 def get_all(self) -> t.Dict[str, t.Any]:
254 if not self.vars:
255 return self.parent
256 if not self.parent:
257 return self.vars
258 return dict(self.parent, **self.vars)
305 def derived(self, locals: t.Optional[t.Dict[str, t.Any]] = None) -> "Context":
311 self.environment, self.name, {}, self.get_all(), True, None, locals
313 context.eval_ctx = self.eval_ctx
314 context.blocks.update((k, list(v)) for k, v in self.blocks.items())
321 def __contains__(self, name: str) -> bool:
322 return name in self.vars or name in self.parent
324 def __getitem__(self, key: str) -> t.Any:
328 item = self.resolve_or_missing(key)
335 def __repr__(self) -> str:
336 return f"<{type(self).__name__} {self.get_all()!r} of {self.name!r}>"
343 self,
349 self.name = name
350 self._context = context
351 self._stack = stack
352 self._depth = depth
355 def super(self) -> t.Union["BlockReference", "Undefined"]:
357 if self._depth + 1 >= len(self._stack):
358 return self._context.environment.undefined(
359 f"there is no parent block called {self.name!r}.", name="super"
361 return BlockReference(self.name, self._context, self._stack, self._depth + 1)
364 async def _async_call(self) -> str:
366 [x async for x in self._stack[self._depth](self._context)] # type: ignore
369 if self._context.eval_ctx.autoescape:
375 def __call__(self) -> str:
376 if self._context.environment.is_async:
377 return self._async_call() # type: ignore
379 rv = concat(self._stack[self._depth](self._context))
381 if self._context.eval_ctx.autoescape:
402 self,
416 self._iterable = iterable
417 self._iterator = self._to_iterator(iterable)
418 self._undefined = undefined
419 self._recurse = recurse
421 self.depth0 = depth0
428 def length(self) -> int:
434 if self._length is not None:
435 return self._length
438 self._length = len(self._iterable) # type: ignore
440 iterable = list(self._iterator)
441 self._iterator = self._to_iterator(iterable)
442 self._length = len(iterable) + self.index + (self._after is not missing)
444 return self._length
446 def __len__(self) -> int:
447 return self.length
450 def depth(self) -> int:
452 return self.depth0 + 1
455 def index(self) -> int:
457 return self.index0 + 1
460 def revindex0(self) -> int:
465 return self.length - self.index
468 def revindex(self) -> int:
473 return self.length - self.index0
476 def first(self) -> bool:
478 return self.index0 == 0
480 def _peek_next(self) -> t.Any:
486 if self._after is not missing:
487 return self._after
489 self._after = next(self._iterator, missing)
490 return self._after
493 def last(self) -> bool:
500 return self._peek_next() is missing
503 def previtem(self) -> t.Union[t.Any, "Undefined"]:
507 if self.first:
508 return self._undefined("there is no previous item")
510 return self._before
513 def nextitem(self) -> t.Union[t.Any, "Undefined"]:
521 rv = self._peek_next()
524 return self._undefined("there is no next item")
528 def cycle(self, *args: V) -> V:
537 return args[self.index0 % len(args)]
539 def changed(self, *value: t.Any) -> bool:
545 if self._last_changed_value != value:
546 self._last_changed_value = value
551 def __iter__(self) -> "LoopContext":
552 return self
554 def __next__(self) -> t.Tuple[t.Any, "LoopContext"]:
555 if self._after is not missing:
556 rv = self._after
557 self._after = missing
559 rv = next(self._iterator)
561 self.index0 += 1
562 self._before = self._current
563 self._current = rv
564 return rv, self
567 def __call__(self, iterable: t.Iterable[V]) -> str:
573 if self._recurse is None:
578 return self._recurse(iterable, self._recurse, depth=self.depth)
580 def __repr__(self) -> str:
581 return f"<{type(self).__name__} {self.index}/{self.length}>"
594 async def length(self) -> int: # type: ignore
595 if self._length is not None:
596 return self._length
599 self._length = len(self._iterable) # type: ignore
601 iterable = [x async for x in self._iterator]
602 self._iterator = self._to_iterator(iterable)
603 self._length = len(iterable) + self.index + (self._after is not missing)
605 return self._length
608 async def revindex0(self) -> int: # type: ignore
609 return await self.length - self.index
612 async def revindex(self) -> int: # type: ignore
613 return await self.length - self.index0
615 async def _peek_next(self) -> t.Any:
616 if self._after is not missing:
617 return self._after
620 self._after = await self._iterator.__anext__()
622 self._after = missing
624 return self._after
627 async def last(self) -> bool: # type: ignore
628 return await self._peek_next() is missing
631 async def nextitem(self) -> t.Union[t.Any, "Undefined"]:
632 rv = await self._peek_next()
635 return self._undefined("there is no next item")
639 def __aiter__(self) -> "AsyncLoopContext":
640 return self
642 async def __anext__(self) -> t.Tuple[t.Any, "AsyncLoopContext"]:
643 if self._after is not missing:
644 rv = self._after
645 self._after = missing
647 rv = await self._iterator.__anext__()
649 self.index0 += 1
650 self._before = self._current
651 self._current = rv
652 return rv, self
659 self,
669 self._environment = environment
670 self._func = func
671 self._argument_count = len(arguments)
672 self.name = name
673 self.arguments = arguments
674 self.catch_kwargs = catch_kwargs
675 self.catch_varargs = catch_varargs
676 self.caller = caller
677 self.explicit_caller = "caller" in arguments
685 self._default_autoescape = default_autoescape
689 def __call__(self, *args: t.Any, **kwargs: t.Any) -> str:
710 autoescape = self._default_autoescape
713 arguments = list(args[: self._argument_count])
723 if off != self._argument_count:
724 for name in self.arguments[len(arguments) :]:
733 found_caller = self.explicit_caller
738 if self.caller and not found_caller:
741 caller = self._environment.undefined("No caller defined", name="caller")
744 if self.catch_kwargs:
749 f"macro {self.name!r} was invoked with two values for the special"
753 f"macro {self.name!r} takes no keyword argument {next(iter(kwargs))!r}"
755 if self.catch_varargs:
756 arguments.append(args[self._argument_count :])
757 elif len(args) > self._argument_count:
759 f"macro {self.name!r} takes not more than"
760 f" {len(self.arguments)} argument(s)"
763 return self._invoke(arguments, autoescape)
765 async def _async_invoke(self, arguments: t.List[t.Any], autoescape: bool) -> str:
766 rv = await self._func(*arguments) # type: ignore
773 def _invoke(self, arguments: t.List[t.Any], autoescape: bool) -> str:
774 if self._environment.is_async:
775 return self._async_invoke(arguments, autoescape) # type: ignore
777 rv = self._func(*arguments)
784 def __repr__(self) -> str:
785 name = "anonymous" if self.name is None else repr(self.name)
786 return f"<{type(self).__name__} {name}>"
812 self,
818 self._undefined_hint = hint
819 self._undefined_obj = obj
820 self._undefined_name = name
821 self._undefined_exception = exc
824 def _undefined_message(self) -> str:
828 if self._undefined_hint:
829 return self._undefined_hint
831 if self._undefined_obj is missing:
832 return f"{self._undefined_name!r} is undefined"
834 if not isinstance(self._undefined_name, str):
836 f"{object_type_repr(self._undefined_obj)} has no"
837 f" element {self._undefined_name!r}"
841 f"{object_type_repr(self._undefined_obj)!r} has no"
842 f" attribute {self._undefined_name!r}"
847 self, *args: t.Any, **kwargs: t.Any
852 raise self._undefined_exception(self._undefined_message)
855 def __getattr__(self, name: str) -> t.Any:
859 return self._fail_with_undefined_error()
872 def __eq__(self, other: t.Any) -> bool:
873 return type(self) is type(other)
875 def __ne__(self, other: t.Any) -> bool:
876 return not self.__eq__(other)
878 def __hash__(self) -> int:
879 return id(type(self))
881 def __str__(self) -> str:
884 def __len__(self) -> int:
887 def __iter__(self) -> t.Iterator[t.Any]:
890 async def __aiter__(self) -> t.AsyncIterator[t.Any]:
894 def __bool__(self) -> bool:
897 def __repr__(self) -> str:
936 self, *args: t.Any, **kwargs: t.Any
940 except self._undefined_exception as e:
944 def __str__(self) -> str:
945 _log_message(self)
948 def __iter__(self) -> t.Iterator[t.Any]:
949 _log_message(self)
952 def __bool__(self) -> bool:
953 _log_message(self)
977 def __html__(self) -> str:
978 return str(self)
980 def __getattr__(self, _: str) -> "ChainableUndefined":
981 return self
1002 def __str__(self) -> str:
1003 if self._undefined_hint:
1004 message = f"undefined value printed: {self._undefined_hint}"
1006 elif self._undefined_obj is missing:
1007 message = self._undefined_name # type: ignore
1011 f"no such element: {object_type_repr(self._undefined_obj)}"
1012 f"[{self._undefined_name!r}]"