Result: 0 1 2

``` ``t-else`` ~~~~~~~~~~ **Values**: nothing Only validate the **input**, the compilation if inside the ``t-if`` directive. ``t-elif`` ~~~~~~~~~~ **Values**: python expression Only validate the **input**, the compilation if inside the ``t-if`` directive. ``t-groups`` (``groups`` is an alias) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ **Values**: name of the allowed odoo user group, or preceded by ``!`` for prohibited groups The generated code uses ``has_group`` Odoo method from ``res.users`` model. ``t-foreach`` ~~~~~~~~~~~~~ **Values**: an expression returning the collection to iterate on This directive is used with ``t-as`` directive to defined the key name. The directive will be converted into a ``for`` loop. In this loop, different values are added to the dict (``values`` in the generated method) in addition to the key defined by ``t-name``, these are (``*_value``, ``*_index``, ``*_size``, ``*_first``, ``*_last``). ``t-as`` ~~~~~~~~ **Values**: key name The compilation method only validates if ``t-as`` and ``t-foreach`` are on the same node. ``t-options`` and ``t-options-*`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ **Values**: python expression It's use on the same node of another directive, it's used to configure the other directive. Used on the same ``input node`` of the directives ``t-call``, ``t-field`` or ``t-out``. Create a ``values['__qweb_options__']`` dict from the optional ``t-options`` expression and add each key-value ``t-options-key="expression value"`` to this dict. (for example: ``t-options="{'widget': 'float'}"`` is equal to ``t-options-widget="'float'"``) ``t-att``, ``t-att-*``, ``t-attf-*`` and ``t-attf-*.translate`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ **Values**: python expression (or format string expression for ``t-attf-``) Compile the attributes to create ``values['__qweb_attrs__']`` dictionary code in the compiled function. Use the ``t-att`` expression and add each key-value ``t-att-key="expression value"`` to this dict. (for example: ``t-att="{'class': f'float_{1}'}"`` is equal to ``t-att-class="f'float_{1}'"`` and is equal to ``t-attf-class="float_{{1}}") The attributes come from new namespaces, static elements (not preceded by ``t-``) and dynamic attributes ``t-att``, attributes prefixed by ``t-att-`` (python expression) or ``t-attf`` (format string expression, translated if ending by ``.translate``). ``t-call`` ~~~~~~~~~~ **Values**: format string expression for template name Serves the called template in place of the current ``t-call`` node. Here are the different steps performed by the generated python code: #. copy the ``values`` dictionary; # define values from attributes or attributeName``.f`` for formated string; #. render the content (``_compile_directive_inner_content``) of the tag in a separate method called with the previous copied values. This values can be updated via t-set. The visible content of the rendering of the sub-content is added as a magical value ``0`` (can be rendered with ``t-out="0"``); #. copy the ``compile_context`` dictionary; #. compile the directive ``t-options`` and update the ``compile_context`` are, in added to the calling template and the ``nsmap`` values; #. get the compiled function from the ``_compile`` method; #. use the compiled function to serves the called template. ``t-lang`` ~~~~~~~~~~ **Values**: python expression Used to serve the called template (``t-call``) in another language. Used together with ``t-call``. This directive will be evaluate like ``t-options-lang``. Allows you to change the language in which the called template is rendered. It's in the ``t-call`` directive that the language of the context of the ``ir.qweb`` recordset on which the ``_compile`` function is called is updated. ``t-call-assets`` ~~~~~~~~~~~~~~~~~ **Values**: format string for template name The generated code call the ``_get_asset_nodes`` method to get the list of (tagName, attrs and content). From each tuple a tag is created into the rendering. ``t-out`` ~~~~~~~~~ **Values**: python expression Output the given value or if falsy, display the content as default value. (for example: ``Default content``) The generated code add the value into the ``MarkupSafe`` rendering. If a widget is defined (``t-options-widget``), the generated code call the ``_get_widget`` method to have the formatted field value and attributes. It's the ``ir.qweb.field.*`` models that format the value. ``t-field`` ~~~~~~~~~~~ **Values**: String representing the path to the field. (for example: ``t-field="record.name"``) Output the field value or if falsy, display the content as default value. (for example: ``Default content``) Use ``t-out`` compile method but the generated code call ``_get_field`` instead of ``_get_widget``. It's the ``ir.qweb.field.*`` models that format the value. The rendering model is chosen according to the type of field. The rendering model can be modified via the ``t-options-widget``. ``t-esc`` ~~~~~~~~~ Deprecated, please use ``t-out`` ``t-raw`` ~~~~~~~~~ Deprecated, please use ``t-out`` ``t-set`` ~~~~~~~~~ **Values**: key name The generated code update the key ``values`` dictionary equal to the value defined by ``t-value`` expression, ``t-valuef`` format string expression or to the ``MarkupSafe`` rendering come from the content of the node. ``t-value``, ``t-valuef`` and ``t-valuef.translate`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ **Values**: python expression (or format string expression for ``t-attf-``) The compilation method only validates if this directive and ``t-set`` are on the same node. The format string expression can be translated if use ``.translate``. Technical directives -------------------- Directive added automatically by IrQweb in order to go through the compilation methods. ``t-tag-open`` ~~~~~~~~~~~~~~ Used to generate the opening HTML/XML tags. ``t-tag-close`` ~~~~~~~~~~~~~~ Used to generate the closing HTML/XML tags. ``t-inner-content`` ~~~~~~~~~~~~~~~~~~~ Used to add the content of the node (text, tail and children nodes). If namespaces are declared on the current element then a copy of the options is made. ``t-consumed-options`` ~~~~~~~~~~~~~~~~~~~~~~ Raise an exception if the ``t-options`` is not consumed. ``t-qweb-skip`` ~~~~~~~~~~~~~~~~~~~~~~ Ignore rendering and directives for the curent **input** node. ``t-else-valid`` ~~~~~~~~~~~~~~~~~~~~~~ Mark a node with ``t-else`` or ``t-elif`` having a valid **input** dom structure. """ from __future__ import annotations import base64 import fnmatch import glob import io import logging import math import pprint import re import textwrap import threading import time import token import tokenize import traceback import warnings import werkzeug from markupsafe import Markup, escape from collections import defaultdict from collections.abc import Sized, Mapping, Sequence, Iterator from copy import deepcopy from itertools import count, chain from lxml import etree from dateutil.relativedelta import relativedelta from os.path import join as opj from pathlib import Path from psycopg2.extensions import TransactionRollbackError from psycopg2.errors import ReadOnlySqlTransaction from typing import NamedTuple, Literal from types import FunctionType from odoo import api, models, tools from odoo.modules import Manifest from odoo.modules.registry import _REGISTRY_CACHES from odoo.tools import config, safe_eval, OrderedSet, frozendict, json from odoo.tools.constants import SUPPORTED_DEBUGGER, EXTERNAL_ASSET from odoo.tools.safe_eval import assert_valid_codeobj, _BUILTINS, to_opcodes, _EXPR_OPCODES, _BLACKLIST from odoo.tools.lru import LRU from odoo.tools.misc import str2bool, file_open, file_path from odoo.tools.image import image_data_uri, FILETYPE_BASE64_MAGICWORD from odoo.tools.profiler import ExecutionContext from odoo.tools.translate import FORMAT_REGEX from odoo.http import request from odoo.tools.profiler import QwebTracker from odoo.exceptions import UserError, MissingError from odoo.addons.base.models.assetsbundle import AssetsBundle from odoo.tools.constants import SCRIPT_EXTENSIONS, STYLE_EXTENSIONS, TEMPLATE_EXTENSIONS _logger = logging.getLogger(__name__) # QWeb token usefull for generate expression used in `_compile_expr_tokens` method token.QWEB = token.NT_OFFSET - 1 token.tok_name[token.QWEB] = 'QWEB' # security safe eval opcodes for generated expression validation, used in `_compile_expr` _SAFE_QWEB_OPCODES = _EXPR_OPCODES.union(to_opcodes([ 'MAKE_FUNCTION', 'CALL_FUNCTION', 'CALL_FUNCTION_KW', 'CALL_FUNCTION_EX', 'CALL_METHOD', 'LOAD_METHOD', 'GET_ITER', 'FOR_ITER', 'YIELD_VALUE', 'JUMP_FORWARD', 'JUMP_ABSOLUTE', 'JUMP_BACKWARD', 'JUMP_IF_FALSE_OR_POP', 'JUMP_IF_TRUE_OR_POP', 'POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE', 'LOAD_NAME', 'LOAD_ATTR', 'LOAD_FAST', 'STORE_FAST', 'UNPACK_SEQUENCE', 'STORE_SUBSCR', 'LOAD_GLOBAL', 'EXTENDED_ARG', # Following opcodes were added in 3.11 https://docs.python.org/3/whatsnew/3.11.html#new-opcodes 'RESUME', 'CALL', 'PRECALL', 'PUSH_NULL', 'KW_NAMES', 'FORMAT_VALUE', 'BUILD_STRING', 'RETURN_GENERATOR', 'SWAP', 'POP_JUMP_FORWARD_IF_FALSE', 'POP_JUMP_FORWARD_IF_TRUE', 'POP_JUMP_BACKWARD_IF_FALSE', 'POP_JUMP_BACKWARD_IF_TRUE', 'POP_JUMP_FORWARD_IF_NONE', 'POP_JUMP_FORWARD_IF_NOT_NONE', 'POP_JUMP_BACKWARD_IF_NONE', 'POP_JUMP_BACKWARD_IF_NOT_NONE', # 3.12 https://docs.python.org/3/whatsnew/3.12.html#new-opcodes 'END_FOR', 'LOAD_FAST_AND_CLEAR', 'POP_JUMP_IF_NOT_NONE', 'POP_JUMP_IF_NONE', 'RERAISE', 'CALL_INTRINSIC_1', 'STORE_SLICE', # 3.13 'CALL_KW', 'LOAD_FAST_LOAD_FAST', 'STORE_FAST_STORE_FAST', 'STORE_FAST_LOAD_FAST', 'CONVERT_VALUE', 'FORMAT_SIMPLE', 'FORMAT_WITH_SPEC', 'SET_FUNCTION_ATTRIBUTE', ])) - _BLACKLIST # eval to compile generated string python code into binary code, used in `_compile` unsafe_eval = eval VOID_ELEMENTS = frozenset([ 'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']) # Terms allowed in addition to AVAILABLE_OBJECTS when compiling python expressions ALLOWED_KEYWORD = frozenset(['False', 'None', 'True', 'and', 'as', 'elif', 'else', 'for', 'if', 'in', 'is', 'not', 'or'] + list(_BUILTINS)) RSTRIP_REGEXP = re.compile(r'\n[ \t]*$') LSTRIP_REGEXP = re.compile(r'^[ \t]*\n') FIRST_RSTRIP_REGEXP = re.compile(r'^(\n[ \t]*)+(\n[ \t])') VARNAME_REGEXP = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*$') TO_VARNAME_REGEXP = re.compile(r'[^A-Za-z0-9_]+') # Attribute name used outside the context of the QWeb. SPECIAL_DIRECTIVES = {'t-translation', 't-ignore', 't-title'} # Name of the variable to insert the content in t-call in the template. # The slot will be replaced by the `t-call` tag content of the caller. T_CALL_SLOT = '0' ETREE_TEMPLATE_REF = count() # Only allow a javascript scheme if it is followed by [ ][window.]history.back() MALICIOUS_SCHEMES = re.compile(r'javascript:(?!( ?)((window\.)?)history\.back$)', re.I).findall def _id_or_xmlid(ref): try: return int(ref) except ValueError: return ref def indent_code(code, level): """Indent the code to respect the python syntax.""" return textwrap.indent(textwrap.dedent(code).strip(), ' ' * 4 * level) def keep_query(*keep_params, **additional_params): """ Generate a query string keeping the current request querystring's parameters specified in ``keep_params`` and also adds the parameters specified in ``additional_params``. Multiple values query string params will be merged into a single one with comma seperated values. The ``keep_params`` arguments can use wildcards too, eg: keep_query('search', 'shop_*', page=4) """ if not keep_params and not additional_params: keep_params = ('*',) params = additional_params.copy() qs_keys = list(request.httprequest.args) if request else [] for keep_param in keep_params: for param in fnmatch.filter(qs_keys, keep_param): if param not in additional_params and param in qs_keys: params[param] = request.httprequest.args.getlist(param) return werkzeug.urls.url_encode(params) #################################### ### QWeb ### #################################### class QWebError(Exception): def __init__(self, qweb: QWebErrorInfo): super().__init__('Error while rendering the template') self.qweb = qweb def __str__(self): return f'{super().__str__()}:\n {self.qweb}' class QWebErrorInfo: def __init__(self, error: str, ref_name: str | int | None, ref: int | None, path: str | None, element: str | None, source: list[tuple[int | str, str, str]], surrounding: str): self.error = error self.template = ref_name self.ref = ref self.path = path self.element = element self.source = source self.surrounding = surrounding def __str__(self): info = [self.error] if self.template is not None: info.append(f'Template: {self.template}') if self.ref is not None: info.append(f'Reference: {self.ref}') if self.path is not None: info.append(f'Path: {self.path}') if self.element is not None: info.append(f'Element: {self.element}') if self.source: source = '\n '.join(str(v) for v in self.source) info.append(f'From: {source}') if self.surrounding: info.append(f'QWeb generated code:\n{self.surrounding}') return '\n '.join(info) class QwebCallParameters(NamedTuple): context: dict view_ref: str | int method: str | None values: dict | None scope: bool | Literal['root'] directive: str path_xml: tuple[str | int, str, str] | None def __repr__(self): # cleaning context and values in order to have a consistent log when debugging. context = {k: v for k, v in self.context.items() if not k.startswith('_')} qweb_root_values = self.values.get('__qweb_root_values') or {} values = self.values and { k: v for k, v in self.values.items() if k not in ('__qweb_root_values', '__qweb_attrs__') if v is not qweb_root_values.get(k) } return ( f"" ) class QwebStackFrame(NamedTuple): params: QwebCallParameters | QwebContent irQweb: IrQweb iterator: Iterator[str | QwebCallParameters | QwebContent] values: dict options: dict | None def __repr__(self): return f'' class QwebContent: """ QwebContent wraps a snippet to be used as a string value or a fragment. If the value is used with a string operation (from a qweb directive like `t-att-help="value % 1"`), the QwebContent loads the snippet. If the value is inserted in the document (`t-out="value"`), the snippet params bubble up to `_render_iterall`. """ irQweb: IrQweb html: str | None params__: QwebCallParameters # not available for the python expression inside the xml def __init__(self, irQweb: IrQweb, params: QwebCallParameters): self.irQweb = irQweb self.html = None self.params__ = params def __str__(self): if self.html is None: params = self.params__ self.html = ''.join(self.irQweb._render_iterall( params.view_ref, params.method, params.values, params.directive, )) return self.html def __repr__(self): return f'' def __len__(self): return len(str(self)) def __html__(self): return self.__str__() def __contains__(self, key): return key in Markup(self) def __getattr__(self, name): return getattr(Markup(self), name) def __getitem__(self, key): return Markup(self)[key] def __add__(self, other): return Markup(self).__add__(other) def __radd__(self, other): return Markup(self).__radd__(other) def __mod__(self, other): return Markup(self).__mod__(other) def __rmod__(self, other): return Markup(self).__rmod__(other) class QwebJSON(json.JSON): def dumps(self, *args, **kwargs): prev_default = kwargs.pop('default', lambda obj: obj) return super().dumps(*args, **kwargs, default=( lambda obj: prev_default(str(obj) if isinstance(obj, QwebContent) else obj) )) qwebJSON = QwebJSON() class IrQweb(models.AbstractModel): """ Base QWeb rendering engine * to customize ``t-field`` rendering, subclass ``ir.qweb.field`` and create new models called :samp:`ir.qweb.field.{widget}` Beware that if you need extensions or alterations which could be incompatible with other subsystems, you should create a local object inheriting from ``ir.qweb`` and customize that. """ _name = 'ir.qweb' _description = 'Qweb' @api.model def _render(self, template: int | str | etree._Element, values: dict | None = None, **options) -> Markup: """ Render the template specified by the given name. :param template: etree, xml_id, template name (see _get_template) * Call the method ``load`` is not an etree. :param dict values: template values to be used for rendering :param options: used to compile the template Options will be add into the IrQweb.env.context for the rendering. * ``lang`` (str) used language to render the template * ``inherit_branding`` (bool) add the tag node branding * ``inherit_branding_auto`` (bool) add the branding on fields * ``minimal_qcontext``(bool) To use the minimum context and options from ``_prepare_environment`` :returns: bytes marked as markup-safe (decode to :class:`markupsafe.Markup` instead of `str`) :rtype: MarkupSafe """ # profiling code current_thread = threading.current_thread() execution_context_enabled = getattr(current_thread, 'profiler_params', {}).get('execution_context_qweb') qweb_hooks = getattr(current_thread, 'qweb_hooks', ()) if execution_context_enabled or qweb_hooks: # To have the new compilation cached because the generated code will change. # Therefore 'profile' is a key to the cache. options['profile'] = True values = values.copy() if values else {} if T_CALL_SLOT in values: _logger.warning('values[0] should be unset when call the _render method and only set into the template.') values.pop(T_CALL_SLOT) irQweb = self.with_context(**options)._prepare_environment(values) irQweb = irQweb.with_context( # List of generated and/or used functions, used for optimal performance __qweb_loaded_functions={}, # List of codes generated during compilation. It is mainly used for debugging and displaying error messages. __qweb_loaded_codes={}, __qweb_loaded_options={}, # Reference to the last node being compiled. It is mainly used for debugging and displaying error messages. _qweb_error_path_xml=[None, None, None], ) safe_eval.check_values(values) root_values = values.copy() values['__qweb_root_values'] = root_values['__qweb_root_values'] = root_values iterator = irQweb._render_iterall(template, None, values) return Markup(''.join(iterator)) def _render_iterall(self, view_ref, method, values, directive='render') -> Iterator[str]: """ Iterate over the generator method. Generator elements are a str """ root_values = values['__qweb_root_values'] loaded_functions = self.env.context['__qweb_loaded_functions'] params = QwebCallParameters( context={}, view_ref=view_ref, method=method, values=None, scope=False, directive=directive, path_xml=None, ) stack = [QwebStackFrame(params, self, iter([params]), values, None)] try: while stack: if len(stack) > 50: raise RecursionError('Qweb template infinite recursion') # noqa: TRY301 frame = stack[-1] # traverse the iterator for item in frame.iterator: # To debug the rendering step by step you can log the (len(stack) * ' ', repr(item)) if isinstance(item, str): yield item continue # use QwebContent params or return already evaluated QwebContent if is_content := isinstance(item, QwebContent): if item.html is not None: yield item.html continue params = item.params__ else: # isinstance(item, QwebCallParameters) params = item # add new QwebStackFrame from QwebCallParameters values = frame.values irQweb = frame.irQweb # Use the current directive context if params.context: irQweb = irQweb.with_context(**params.context) render_template = loaded_functions.get(params.method) # Fetch the compiled function and template options if not render_template: template_functions, def_name, options = irQweb._compile(params.view_ref) loaded_functions.update(template_functions) render_template = template_functions[params.method or def_name] else: options = irQweb._compile(params.view_ref)[2] # Apply a new scope if needed if params.scope: if params.scope == 'root': values = root_values values = values.copy() # Update values with default values if params.values: values.update(params.values) iterator = iter([]) try: # Create the iterator from the template iterator = render_template(irQweb, values) finally: if is_content and self.env.context['_qweb_error_path_xml'][1]: # add a stack frame to log a complete error with the path when compile the template logParams = QwebCallParameters(*(params[0:-1] + (tuple(self.env.context['_qweb_error_path_xml']),))) stack.append(QwebStackFrame(logParams, irQweb, [], values, options)) stack.append(QwebStackFrame(params, irQweb, iterator, values, options)) break else: stack.pop() except (TransactionRollbackError, ReadOnlySqlTransaction): raise except Exception as error: qweb_error_info = self._get_error_info(error, stack, stack[-1]) if qweb_error_info.template is None and qweb_error_info.ref is None: qweb_error_info.ref = view_ref if hasattr(error, 'qweb'): if qweb_error_info.source: error.qweb.source = qweb_error_info.source + error.qweb.source if not error.qweb.ref and frame.params.view_ref: error.qweb.ref = frame.params.view_ref qweb_error_info = error.qweb elif not isinstance(error, UserError): # If is not an odoo Exception check if the current error is raise from # IrQweb (models or computed code). In this case, convert it into an QWebError. isQweb = False trace = error.__traceback__ tb_frames = [trace.tb_frame] while trace.tb_next is not None: trace = trace.tb_next tb_frames.append(trace.tb_frame) for tb_frame in tb_frames[::-1]: if tb_frame.f_globals.get('__name__') == __name__ or ( isinstance(tb_frame.f_locals.get('self'), models.AbstractModel) and tb_frame.f_locals['self']._name == self._name ): isQweb = True break if any(path in tb_frame.f_code.co_filename for path in tools.config['addons_path']): break if isQweb: raise QWebError(qweb_error_info) from error error.qweb = qweb_error_info raise def _get_error_info(self, error, stack: list[QwebStackFrame], frame: QwebStackFrame) -> QWebErrorInfo: no_id_ref = 'etree._Element' path = None html = None loaded_codes = self.env.context['__qweb_loaded_codes'] if (frame.params.view_ref in loaded_codes and not isinstance(error, RecursionError)) or len(stack) <= 1: options = frame.options or {} # The compilation may have failed before the compilation options were loaded. if 'ref' not in options: options = self.env.context['__qweb_loaded_options'].get(frame.params.view_ref) or {} ref = options.get('ref') or frame.params.view_ref # The template can have a null reference, for example for a provided etree. ref_name = options.get('ref_name') or None code = loaded_codes.get(frame.params.view_ref) or loaded_codes.get(no_id_ref) if ref == self.env.context['_qweb_error_path_xml'][0]: path = self.env.context['_qweb_error_path_xml'][1] html = self.env.context['_qweb_error_path_xml'][2] else: # get the previous caller (like t-call) to display erroneous xml node. options = stack[-2].options or {} # The compilation may have failed before the compilation options were loaded. ref = options.get('ref') ref_name = options.get('ref_name') code = loaded_codes.get(ref) or loaded_codes.get(no_id_ref) if frame.params.path_xml: path = frame.params.path_xml[1] html = frame.params.path_xml[2] source_file_ref = None if ref == no_id_ref else ref line_nb = 0 trace = traceback.format_exc() for error_line in reversed(trace.split('\n')): if f'File "<{source_file_ref}>"' in error_line or (ref is None and 'File "<' in error_line): line_function = error_line.split(', line ')[1] line_nb = int(line_function.split(',')[0]) break source = [info.params.path_xml for info in stack if info.params.path_xml] code_lines = (code or '').split('\n') found = False for code_line in reversed(code_lines[:line_nb]): if code_line.startswith('def '): break match = re.match(r'\s*# element: (.*) , (.*)', code_line) if not match: if found: break continue if found: info = (ref, match[1][1:-1], match[2][1:-1]) if info not in source: source.append(info) else: found = True path = match[1][1:-1] html = match[2][1:-1] if path: source.append((ref, path, html)) surrounding = None if self.env.context.get('dev_mode') and line_nb: if html and ' t-if=' in html and ' if ' in '\n'.join(code_lines[line_nb - 2:line_nb - 1]): line_nb -= 1 previous_lines = '\n'.join(code_lines[max(line_nb - 25, 0):line_nb - 1]) line = code_lines[line_nb - 1] next_lines = '\n'.join(code_lines[line_nb:line_nb + 5]) indent = re.search(r"^(\s*)", line).group(0) surrounding = textwrap.indent( textwrap.dedent( f"{previous_lines}\n" f"{indent}########### Line triggering the error ############\n{line}\n" f"{indent}##################################################\n{next_lines}" ), ' ' * 8 ) return QWebErrorInfo(f'{error.__class__.__name__}: {error}', ref if ref_name is None else ref_name, ref, path, html, source, surrounding) # assume cache will be invalidated by third party on write to ir.ui.view def _get_template_cache_keys(self): """ Return the list of context keys to use for caching ``_compile``. """ return ['lang', 'inherit_branding', 'inherit_branding_auto', 'edit_translations', 'profile'] def _get_template_info(self, template): return self.env['ir.ui.view']._get_cached_template_info(template) def _compile(self, template): ref = None if isinstance(template, str) and template.endswith('.xml'): module_path = Manifest.for_addon(Path(template).parts[0]).path if 'templates' not in Path(file_path(template)).relative_to(module_path).parts: raise ValueError("The templates file %s must be under a subfolder 'templates' of a module", template) else: with file_open(template, 'rb', filter_ext=('.xml',)) as file: template = etree.fromstring(file.read()) elif not isinstance(template, etree._Element): ref = self._get_template_info(template)['id'] if ref: template_functions, def_name, options = self._generate_code_cached(ref) else: template_functions, def_name, options = self._generate_code_uncached(template) render_template = template_functions[def_name] if options.get('profile') and render_template.__name__ != 'profiled_method_compile': ref = options.get('ref') ref_xml = str(val) if (val := options.get('ref_xml')) else None def wrap(function): def profiled_method_compile(self, values): qweb_tracker = QwebTracker(ref, ref_xml, self.env.cr) self = self.with_context(qweb_tracker=qweb_tracker) if qweb_tracker.execution_context_enabled: with ExecutionContext(template=ref): return function(self, values) return function(self, values) return profiled_method_compile for key, function in template_functions.items(): if isinstance(function, FunctionType): template_functions[key] = wrap(function) return (template_functions, def_name, options) @tools.conditional( 'xml' not in tools.config['dev_mode'], tools.ormcache('ref', 'tuple(self.env.context.get(k) or False for k in self._get_template_cache_keys())', cache='templates'), ) def _generate_code_cached(self, ref: int): return self._generate_code_uncached(ref) def _generate_code_uncached(self, template: int | str | etree._Element): assert isinstance(self, IrQweb) ref = self._get_template_info(template)['id'] if isinstance(template, (int, str)) else None code, options, def_name = self._generate_code(template) if code is None: Error, message, stack = options['error'] def not_found_template(self, values): if tools.config['dev_mode']: _logger.info(stack) if self.env.context.get('raise_if_not_found', True): raise Error(message) _logger.warning('Cannot load template %s: %s', template, message) return '' return {'not_found_template': not_found_template}, 'not_found_template', frozendict(options) wrap_code = '\n'.join([ "def generate_functions():", indent_code(code, 1), f" code = {code!r}", " return template_functions", ]) compiled = compile(wrap_code, f"<{ref}>", 'exec') globals_dict = self.__prepare_globals() globals_dict['__builtins__'] = globals_dict # So that unknown/unsafe builtins are never added. unsafe_eval(compiled, globals_dict) return globals_dict['generate_functions'](), def_name, frozendict(options) def _generate_code(self, template: int | str | etree._Element): """ Compile the given template into a rendering function (generator):: render_template(qweb, values) This method can be called only by :meth:`_render` method or by the compiled code of t-call from an other template. An ``options`` dictionary is created and attached to the function. It contains rendering options that are part of the cache key in addition to template references. where ``qweb`` is a QWeb instance and ``values`` are the values to render. :returns: tuple containing code, options and main method name """ if not isinstance(template, (int, str, etree._Element)): template = str(template) # The `compile_context`` dictionary includes the elements used for the # cache key to which are added the template references as well as # technical information useful for generating the function. This # dictionary is only used when compiling the template. compile_context = self.env.context.copy() try: element, document, ref = self._get_template(template) except (ValueError, UserError) as e: # return the error information if the template is not found or fail options = {k: compile_context.get(k, False) for k in self._get_template_cache_keys()} message = str(e) if hasattr(e, 'context') and e.context.get('view'): message = f"{message} (view: {e.context['view'].key})" options['error'] = (e.__class__, message, traceback.format_exc()) return (None, options, 'not_found_template') compile_context.pop('raise_if_not_found', None) ref_name = element.attrib.pop('t-name', None) if isinstance(ref, int) or (isinstance(template, str) and '<' not in template): ref_name = self._get_template_info(ref)['key'] or ref_name # reference to get xml and etree (usually the template ID) compile_context['ref'] = ref # reference name or key to get xml and etree (usually the template XML ID) compile_context['ref_name'] = ref_name # str xml of the reference template used for compilation. Useful for debugging, dev mode and profiling. compile_context['ref_xml'] = str(document) if document else None # Identifier used to call `_compile` compile_context['template'] = template # Root of the etree which will be processed during compilation. compile_context['root'] = element.getroottree() # Reference to the last node being compiled. It is mainly used for debugging and displaying error messages. compile_context['_qweb_error_path_xml'] = compile_context.get('_qweb_error_path_xml', [None, None, None]) compile_context['nsmap'] = { ns_prefix: str(ns_definition) for ns_prefix, ns_definition in compile_context.get('nsmap', {}).items() } # The options dictionary includes cache key elements and template # references. It will be attached to the generated function. This # dictionary is only there for logs, performance or test information. # The values of these `options` cannot be changed and must always be # identical in `context` and `self.env.context`. options = { key: compile_context.get(key, False) for key in self._get_template_cache_keys() + ['ref', 'ref_name'] } # generate code ref_name = compile_context['ref_name'] or '' if isinstance(template, etree._Element): def_name = TO_VARNAME_REGEXP.sub(r'_', f'template_etree_{next(ETREE_TEMPLATE_REF)}') else: def_name = TO_VARNAME_REGEXP.sub(r'_', f'template_{ref_name if "<" not in ref_name else ""}_{ref}') name_gen = count() compile_context['make_name'] = lambda prefix: f"{def_name}_{prefix}_{next(name_gen)}" if element.text: element.text = FIRST_RSTRIP_REGEXP.sub(r'\2', element.text) compile_context['template_functions'] = {} compile_context['_text_concat'] = [] self._append_text("", compile_context) # To ensure the template function is a generator and doesn't become a regular function compile_context['template_functions'][f'{def_name}_content'] = ( [f"def {def_name}_content(self, values):"] + self._compile_node(element, compile_context, 2) + self._flush_text(compile_context, 2, rstrip=True)) compile_context['template_functions'][def_name] = [indent_code(f""" def {def_name}(self, values): if 'xmlid' not in values: values['xmlid'] = {options['ref_name']!r} values['viewid'] = {options['ref']!r} self.env.context['__qweb_loaded_functions'].update(template_functions) self.env.context['__qweb_loaded_options'][{options['ref']!r}] = self.env.context['__qweb_loaded_options'][{options['ref_name']!r}] = template_options self.env.context['__qweb_loaded_codes'][{options['ref']!r}] = self.env.context['__qweb_loaded_codes'][{options['ref_name']!r}] = code yield from {def_name}_content(self, values) """, 0)] code_lines = [] code_lines.append(f'template_options = {pprint.pformat(options, indent=4)}') code_lines.append('code = None') code_lines.append('template_functions = {}') for lines in compile_context['template_functions'].values(): code_lines.extend(lines) for name in compile_context['template_functions']: code_lines.append(f'template_functions[{name!r}] = {name}') code = '\n'.join(code_lines) if options.get('profile'): options['ref_xml'] = compile_context['ref_xml'] return (code, options, def_name) # read and load input template def _get_template(self, template): """ Retrieve the given template, and return it as a tuple ``(etree, xml, ref)``, where ``element`` is an etree, ``document`` is the string document that contains ``element``, and ``ref`` if the uniq reference of the template (id, t-name or template). :param template: template identifier or etree """ assert template not in (False, None, ""), "template is required" # template is an xml etree already if isinstance(template, etree._Element): element = template document = etree.tostring(template, encoding='unicode') # #