Lines Matching refs:self
264 def __init__(self,
299 self.block_start_string = block_start_string
300 self.block_end_string = block_end_string
301 self.variable_start_string = variable_start_string
302 self.variable_end_string = variable_end_string
303 self.comment_start_string = comment_start_string
304 self.comment_end_string = comment_end_string
305 self.line_statement_prefix = line_statement_prefix
306 self.line_comment_prefix = line_comment_prefix
307 self.trim_blocks = trim_blocks
308 self.lstrip_blocks = lstrip_blocks
309 self.newline_sequence = newline_sequence
310 self.keep_trailing_newline = keep_trailing_newline
313 self.undefined = undefined
314 self.optimized = optimized
315 self.finalize = finalize
316 self.autoescape = autoescape
319 self.filters = DEFAULT_FILTERS.copy()
320 self.tests = DEFAULT_TESTS.copy()
321 self.globals = DEFAULT_NAMESPACE.copy()
324 self.loader = loader
325 self.cache = create_cache(cache_size)
326 self.bytecode_cache = bytecode_cache
327 self.auto_reload = auto_reload
330 self.policies = DEFAULT_POLICIES.copy()
333 self.extensions = load_extensions(self, extensions)
335 self.enable_async = enable_async
336 self.is_async = self.enable_async and have_async_gen
338 _environment_sanity_check(self)
340 def add_extension(self, extension):
345 self.extensions.update(load_extensions(self, [extension]))
347 def extend(self, **attributes):
353 if not hasattr(self, key):
354 setattr(self, key, value)
356 def overlay(self, block_start_string=missing, block_end_string=missing,
377 del args['self'], args['cache_size'], args['extensions']
379 rv = object.__new__(self.__class__)
380 rv.__dict__.update(self.__dict__)
382 rv.linked_to = self
391 rv.cache = copy_cache(self.cache)
394 for key, value in iteritems(self.extensions):
403 def iter_extensions(self):
405 return iter(sorted(self.extensions.values(),
408 def getitem(self, obj, argument):
423 return self.undefined(obj=obj, name=argument)
425 def getattr(self, obj, attribute):
436 return self.undefined(obj=obj, name=attribute)
438 def call_filter(self, name, value, args=None, kwargs=None,
449 func = self.filters.get(name)
463 eval_ctx = EvalContext(self)
466 args.insert(0, self)
469 def call_test(self, name, value, args=None, kwargs=None):
474 func = self.tests.get(name)
480 def parse(self, source, name=None, filename=None):
490 return self._parse(source, name, filename)
493 self.handle_exception(exc_info, source_hint=source)
495 def _parse(self, source, name, filename):
497 return Parser(self, source, name, encode_filename(filename)).parse()
499 def lex(self, source, name=None, filename=None):
511 return self.lexer.tokeniter(source, name, filename)
514 self.handle_exception(exc_info, source_hint=source)
516 def preprocess(self, source, name=None, filename=None):
522 self.iter_extensions(), text_type(source))
524 def _tokenize(self, source, name, filename=None, state=None):
528 source = self.preprocess(source, name, filename)
529 stream = self.lexer.tokenize(source, name, filename, state)
530 for ext in self.iter_extensions():
536 def _generate(self, source, name, filename, defer_init=False):
542 return generate(source, self, name, filename, defer_init=defer_init,
543 optimized=self.optimized)
545 def _compile(self, source, filename):
554 def compile(self, source, name=None, filename=None, raw=False,
579 source = self._parse(source, name, filename)
580 source = self._generate(source, name, filename,
588 return self._compile(source, filename)
591 self.handle_exception(exc_info, source_hint=source_hint)
593 def compile_expression(self, source, undefined_to_none=True):
621 parser = Parser(self, source, state='variable')
629 expr.set_environment(self)
633 self.handle_exception(exc_info, source_hint=source)
635 template = self.from_string(nodes.Template(body, lineno=1))
638 def compile_templates(self, target, extensions=None, filter_func=None,
706 for name in self.list_templates(extensions, filter_func):
707 source, filename, _ = self.loader.get_source(self, name)
709 code = self.compile(source, name, filename, True, True)
719 c = self._compile(code, encode_filename(filename))
733 def list_templates(self, extensions=None, filter_func=None):
749 x = self.loader.list_templates()
760 def handle_exception(self, exc_info=None, rendered=False, source_hint=None):
775 if rendered and self.exception_formatter is not None:
776 return self.exception_formatter(traceback)
777 if self.exception_handler is not None:
778 self.exception_handler(traceback)
782 def join_path(self, template, parent):
795 def _load_template(self, name, globals):
796 if self.loader is None:
798 cache_key = (weakref.ref(self.loader), name)
799 if self.cache is not None:
800 template = self.cache.get(cache_key)
801 if template is not None and (not self.auto_reload or
804 template = self.loader.load(self, name, globals)
805 if self.cache is not None:
806 self.cache[cache_key] = template
810 def get_template(self, name, parent=None, globals=None):
829 name = self.join_path(name, parent)
830 return self._load_template(name, self.make_globals(globals))
833 def select_template(self, names, parent=None, globals=None):
847 globals = self.make_globals(globals)
852 name = self.join_path(name, parent)
854 return self._load_template(name, globals)
860 def get_or_select_template(self, template_name_or_list,
869 return self.get_template(template_name_or_list, parent, globals)
872 return self.select_template(template_name_or_list, parent, globals)
874 def from_string(self, source, globals=None, template_class=None):
878 globals = self.make_globals(globals)
879 cls = template_class or self.template_class
880 return cls.from_code(self, self.compile(source), globals, None)
882 def make_globals(self, d):
885 return self.globals
886 return dict(self.globals, **d)
993 def render(self, *args, **kwargs):
1005 return concat(self.root_render_func(self.new_context(vars)))
1008 return self.environment.handle_exception(exc_info, True)
1010 def render_async(self, *args, **kwargs):
1023 def stream(self, *args, **kwargs):
1027 return TemplateStream(self.generate(*args, **kwargs))
1029 def generate(self, *args, **kwargs):
1039 for event in self.root_render_func(self.new_context(vars)):
1045 yield self.environment.handle_exception(exc_info, True)
1047 def generate_async(self, *args, **kwargs):
1055 def new_context(self, vars=None, shared=False, locals=None):
1063 return new_context(self.environment, self.name, self.blocks,
1064 vars, shared, self.globals, locals)
1066 def make_module(self, vars=None, shared=False, locals=None):
1073 return TemplateModule(self, self.new_context(vars, shared, locals))
1075 def make_module_async(self, vars=None, shared=False, locals=None):
1086 def _get_default_module(self):
1087 if self._module is not None:
1088 return self._module
1089 self._module = rv = self.make_module()
1093 def module(self):
1106 return self._get_default_module()
1108 def get_corresponding_lineno(self, lineno):
1112 for template_line, code_line in reversed(self.debug_info):
1118 def is_up_to_date(self):
1120 if self._uptodate is None:
1122 return self._uptodate()
1125 def debug_info(self):
1128 self._debug_info.split('&')]
1130 def __repr__(self):
1131 if self.name is None:
1132 name = 'memory:%x' % id(self)
1134 name = repr(self.name)
1135 return '<%s %s>' % (self.__class__.__name__, name)
1145 def __init__(self, template, context, body_stream=None):
1153 self._body_stream = body_stream
1154 self.__dict__.update(context.get_exported())
1155 self.__name__ = template.name
1157 def __html__(self):
1158 return Markup(concat(self._body_stream))
1160 def __str__(self):
1161 return concat(self._body_stream)
1163 def __repr__(self):
1164 if self.__name__ is None:
1165 name = 'memory:%x' % id(self)
1167 name = repr(self.__name__)
1168 return '<%s %s>' % (self.__class__.__name__, name)
1177 def __init__(self, template, undefined_to_none):
1178 self._template = template
1179 self._undefined_to_none = undefined_to_none
1181 def __call__(self, *args, **kwargs):
1182 context = self._template.new_context(dict(*args, **kwargs))
1183 consume(self._template.root_render_func(context))
1185 if self._undefined_to_none and isinstance(rv, Undefined):
1202 def __init__(self, gen):
1203 self._gen = gen
1204 self.disable_buffering()
1206 def dump(self, fp, encoding=None, errors='strict'):
1223 iterable = (x.encode(encoding, errors) for x in self)
1225 iterable = self
1235 def disable_buffering(self):
1237 self._next = partial(next, self._gen)
1238 self.buffered = False
1240 def _buffered_generator(self, size):
1248 c = next(self._gen)
1259 def enable_buffering(self, size=5):
1264 self.buffered = True
1265 self._next = partial(next, self._buffered_generator(size))
1267 def __iter__(self):
1268 return self
1270 def __next__(self):
1271 return self._next()