File manager - Edit - /usr/local/CyberCP/lib/python3.10/site-packages/tornado/__pycache__/template.cpython-310.pyc
Back
o �h�� � @ sb d Z ddlZddlmZ ddlZddlZddlZddlZddl Z ddl mZ ddlm Z ddlmZmZmZ ddlmZmZmZmZmZmZmZmZ ddlZejrYddlmZmZ d ZG d d� d�Ze� Z de!d e!de!fdd�Z"G dd� de#�Z$G dd� de#�Z%G dd� de%�Z&G dd� de%�Z'G dd� de#�Z(G dd� de(�Z)G dd� de(�Z*G dd � d e(�Z+G d!d"� d"e(�Z,G d#d$� d$e(�Z-G d%d&� d&e(�Z.G d'd(� d(e(�Z/G d)d*� d*e(�Z0G d+d,� d,e(�Z1G d-d.� d.e(�Z2G d/d0� d0e2�Z3G d1d2� d2e(�Z4G d3d4� d4e5�Z6G d5d6� d6e#�Z7G d7d8� d8e#�Z8d9e!de!fd:d;�Z9 dBd<e8d=e$d>ee! d?ee! de*f d@dA�Z:dS )Ca� A simple template system that compiles templates to Python code. Basic usage looks like:: t = template.Template("<html>{{ myvalue }}</html>") print(t.generate(myvalue="XXX")) `Loader` is a class that loads templates from a root directory and caches the compiled templates:: loader = template.Loader("/home/btaylor") print(loader.load("test.html").generate(myvalue="XXX")) We compile all templates to raw Python. Error-reporting is currently... uh, interesting. Syntax for the templates:: ### base.html <html> <head> <title>{% block title %}Default title{% end %}</title> </head> <body> <ul> {% for student in students %} {% block student %} <li>{{ escape(student.name) }}</li> {% end %} {% end %} </ul> </body> </html> ### bold.html {% extends "base.html" %} {% block title %}A bolder title{% end %} {% block student %} <li><span style="bold">{{ escape(student.name) }}</span></li> {% end %} Unlike most other template systems, we do not put any restrictions on the expressions you can include in your statements. ``if`` and ``for`` blocks get translated exactly into Python, so you can do complex expressions like:: {% for student in [p for p in people if p.student and p.age > 23] %} <li>{{ escape(student.name) }}</li> {% end %} Translating directly to Python means you can apply functions to expressions easily, like the ``escape()`` function in the examples above. You can pass functions in to your template just like any other variable (In a `.RequestHandler`, override `.RequestHandler.get_template_namespace`):: ### Python code def add(x, y): return x + y template.execute(add=add) ### The template {{ add(1, 2) }} We provide the functions `escape() <.xhtml_escape>`, `.url_escape()`, `.json_encode()`, and `.squeeze()` to all templates by default. Typical applications do not create `Template` or `Loader` instances by hand, but instead use the `~.RequestHandler.render` and `~.RequestHandler.render_string` methods of `tornado.web.RequestHandler`, which load templates automatically based on the ``template_path`` `.Application` setting. Variable names beginning with ``_tt_`` are reserved by the template system and should not be used by application code. Syntax Reference ---------------- Template expressions are surrounded by double curly braces: ``{{ ... }}``. The contents may be any python expression, which will be escaped according to the current autoescape setting and inserted into the output. Other template directives use ``{% %}``. To comment out a section so that it is omitted from the output, surround it with ``{# ... #}``. To include a literal ``{{``, ``{%``, or ``{#`` in the output, escape them as ``{{!``, ``{%!``, and ``{#!``, respectively. ``{% apply *function* %}...{% end %}`` Applies a function to the output of all template code between ``apply`` and ``end``:: {% apply linkify %}{{name}} said: {{message}}{% end %} Note that as an implementation detail apply blocks are implemented as nested functions and thus may interact strangely with variables set via ``{% set %}``, or the use of ``{% break %}`` or ``{% continue %}`` within loops. ``{% autoescape *function* %}`` Sets the autoescape mode for the current file. This does not affect other files, even those referenced by ``{% include %}``. Note that autoescaping can also be configured globally, at the `.Application` or `Loader`.:: {% autoescape xhtml_escape %} {% autoescape None %} ``{% block *name* %}...{% end %}`` Indicates a named, replaceable block for use with ``{% extends %}``. Blocks in the parent template will be replaced with the contents of the same-named block in a child template.:: <!-- base.html --> <title>{% block title %}Default title{% end %}</title> <!-- mypage.html --> {% extends "base.html" %} {% block title %}My page title{% end %} ``{% comment ... %}`` A comment which will be removed from the template output. Note that there is no ``{% end %}`` tag; the comment goes from the word ``comment`` to the closing ``%}`` tag. ``{% extends *filename* %}`` Inherit from another template. Templates that use ``extends`` should contain one or more ``block`` tags to replace content from the parent template. Anything in the child template not contained in a ``block`` tag will be ignored. For an example, see the ``{% block %}`` tag. ``{% for *var* in *expr* %}...{% end %}`` Same as the python ``for`` statement. ``{% break %}`` and ``{% continue %}`` may be used inside the loop. ``{% from *x* import *y* %}`` Same as the python ``import`` statement. ``{% if *condition* %}...{% elif *condition* %}...{% else %}...{% end %}`` Conditional statement - outputs the first section whose condition is true. (The ``elif`` and ``else`` sections are optional) ``{% import *module* %}`` Same as the python ``import`` statement. ``{% include *filename* %}`` Includes another template file. The included file can see all the local variables as if it were copied directly to the point of the ``include`` directive (the ``{% autoescape %}`` directive is an exception). Alternately, ``{% module Template(filename, **kwargs) %}`` may be used to include another template with an isolated namespace. ``{% module *expr* %}`` Renders a `~tornado.web.UIModule`. The output of the ``UIModule`` is not escaped:: {% module Template("foo.html", arg=42) %} ``UIModules`` are a feature of the `tornado.web.RequestHandler` class (and specifically its ``render`` method) and will not work when the template system is used on its own in other contexts. ``{% raw *expr* %}`` Outputs the result of the given expression without autoescaping. ``{% set *x* = *y* %}`` Sets a local variable. ``{% try %}...{% except %}...{% else %}...{% finally %}...{% end %}`` Same as the python ``try`` statement. ``{% while *condition* %}... {% end %}`` Same as the python ``while`` statement. ``{% break %}`` and ``{% continue %}`` may be used inside the loop. ``{% whitespace *mode* %}`` Sets the whitespace mode for the remainder of the current file (or until the next ``{% whitespace %}`` directive). See `filter_whitespace` for available options. New in Tornado 4.3. � N)�StringIO)�escape)�app_log)� ObjectDict�exec_in�unicode_type)�Any�Union�Callable�List�Dict�Iterable�Optional�TextIO)�Tuple�ContextManager�xhtml_escapec @ s e Zd ZdS )�_UnsetMarkerN)�__name__� __module__�__qualname__� r r �C/usr/local/CyberCP/lib/python3.10/site-packages/tornado/template.pyr � s r �mode�text�returnc C sV | dkr|S | dkrt �dd|�}t �dd|�}|S | dkr%t �dd|�S td | ��) a� Transform whitespace in ``text`` according to ``mode``. Available modes are: * ``all``: Return all whitespace unmodified. * ``single``: Collapse consecutive whitespace with a single whitespace character, preserving newlines. * ``oneline``: Collapse all runs of whitespace into a single space character, removing all newlines in the process. .. versionadded:: 4.3 �all�singlez([\t ]+)� z (\s*\n\s*)� �onelinez(\s+)zinvalid whitespace mode %s)�re�sub� Exception)r r r r r �filter_whitespace� s r$ c @ s� e Zd ZdZddeedfdeeef deded dee e f d eeee f d ee ddfdd �Zdedefdd�Z ded defdd�Zded ded fdd�ZdS )�Templatez�A compiled template. We compile into Python from the given template_string. You can generate the template from variables with generate(). z<string>N�template_string�name�loader� BaseLoader�compress_whitespace� autoescape� whitespacer c C sH t �|�| _|tur|durtd��|rdnd}|du r4|r%|jr%|j}n|�d�s/|�d�r2d}nd}|dus:J �t|d� t|t �sH|| _ n |rO|j | _ nt| _ |rW|jni | _t |t �|�|�}t| t|| ��| _| �|�| _|| _ztt �| j�d| j�d d � ddd �| _W dS ty� t| j��� }t�d| j|� � w )a� Construct a Template. :arg str template_string: the contents of the template file. :arg str name: the filename from which the template was loaded (used for error message). :arg tornado.template.BaseLoader loader: the `~tornado.template.BaseLoader` responsible for this template, used to resolve ``{% include %}`` and ``{% extend %}`` directives. :arg bool compress_whitespace: Deprecated since Tornado 4.3. Equivalent to ``whitespace="single"`` if true and ``whitespace="all"`` if false. :arg str autoescape: The name of a function in the template namespace, or ``None`` to disable escaping by default. :arg str whitespace: A string specifying treatment of whitespace; see `filter_whitespace` for options. .. versionchanged:: 4.3 Added ``whitespace`` parameter; deprecated ``compress_whitespace``. Nz2cannot set both whitespace and compress_whitespacer r z.htmlz.js� z%s.generated.py�.�_�execT)�dont_inheritz%s code: %s)r � native_strr'