403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.156
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/python3/dist-packages/pystache/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/lib/python3/dist-packages/pystache/__pycache__/renderer.cpython-310.pyc
o

r|a�@�@s�dZddlmZddlmZmZmZddlmZm	Z	ddl
mZddlm
Z
ddlmZmZddlmZdd	lmZGd
d�de�ZdS)
z=
This module provides a Renderer class to render templates.

�)�defaults)�TemplateNotFoundError�MissingTags�	is_string)�ContextStack�KeyNotFoundError)�Loader)�ParsedTemplate)�context_get�RenderEngine)�
SpecLoader)�TemplateSpecc@s�eZdZdZ								d-dd�Zedd��Zdd�Zd	d
�Zdd�Z	d
d�Z
d.dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�ZdS)/�Renderera�
    A class for rendering mustache templates.

    This class supports several rendering options which are described in
    the constructor's docstring.  Other behavior can be customized by
    subclassing this class.

    For example, one can pass a string-string dictionary to the constructor
    to bypass loading partials from the file system:

    >>> partials = {'partial': 'Hello, {{thing}}!'}
    >>> renderer = Renderer(partials=partials)
    >>> # We apply print to make the test work in Python 3 after 2to3.
    >>> print(renderer.render('{{>partial}}', {'thing': 'world'}))
    Hello, world!

    To customize string coercion (e.g. to render False values as ''), one can
    subclass this class.  For example:

        class MyRenderer(Renderer):
            def str_coerce(self, val):
                if not val:
                    return ''
                else:
                    return str(val)

    Nc		Cs�|durtj}|durtj}|durtj}|durtj}|dur#tj}|dur*tj}|dur1tj}t|t	�r9|g}d|_
||_||_||_
||_||_||_||_||_dS)a�
        Construct an instance.

        Arguments:

          file_encoding: the name of the encoding to use by default when
            reading template files.  All templates are converted to unicode
            prior to parsing.  Defaults to the package default.

          string_encoding: the name of the encoding to use when converting
            to unicode any byte strings (type str in Python 2) encountered
            during the rendering process.  This name will be passed as the
            encoding argument to the built-in function unicode().
            Defaults to the package default.

          decode_errors: the string to pass as the errors argument to the
            built-in function unicode() when converting byte strings to
            unicode.  Defaults to the package default.

          search_dirs: the list of directories in which to search when
            loading a template by name or file name.  If given a string,
            the method interprets the string as a single directory.
            Defaults to the package default.

          file_extension: the template file extension.  Pass False for no
            extension (i.e. to use extensionless template files).
            Defaults to the package default.

          partials: an object (e.g. a dictionary) for custom partial loading
            during the rendering process.
                The object should have a get() method that accepts a string
            and returns the corresponding template as a string, preferably
            as a unicode string.  If there is no template with that name,
            the get() method should either return None (as dict.get() does)
            or raise an exception.
                If this argument is None, the rendering process will use
            the normal procedure of locating and reading templates from
            the file system -- using relevant instance attributes like
            search_dirs, file_encoding, etc.

          escape: the function used to escape variable tag values when
            rendering a template.  The function should accept a unicode
            string (or subclass of unicode) and return an escaped string
            that is again unicode (or a subclass of unicode).
                This function need not handle strings of type `str` because
            this class will only pass it unicode strings.  The constructor
            assigns this function to the constructed instance's escape()
            method.
                To disable escaping entirely, one can pass `lambda u: u`
            as the escape function, for example.  One may also wish to
            consider using markupsafe's escape function: markupsafe.escape().
            This argument defaults to the package default.

          missing_tags: a string specifying how to handle missing tags.
            If 'strict', an error is raised on a missing tag.  If 'ignore',
            the value of the tag is the empty string.  Defaults to the
            package default.

        N)r�
DECODE_ERRORS�
TAG_ESCAPE�
FILE_ENCODING�TEMPLATE_EXTENSION�MISSING_TAGS�SEARCH_DIRS�STRING_ENCODING�
isinstance�str�_context�
decode_errors�escape�
file_encoding�file_extension�missing_tags�partials�search_dirs�string_encoding)	�selfrr rrrrrr�r"�3/usr/lib/python3/dist-packages/pystache/renderer.py�__init__1s2F

zRenderer.__init__cCs|jS)zG
        Return the current rendering context [experimental].

        )r�r!r"r"r#�context�szRenderer.contextcCst|�S)aK
        Coerce a non-string value to a string.

        This method is called whenever a non-string is encountered during the
        rendering process when a string is needed (e.g. if a context value
        for string interpolation is not a string).  To customize string
        coercion, you can override this method.

        )r�r!�valr"r"r#�
str_coerce�s
zRenderer.str_coercecCst|t�r|S|�|�S)zT
        Convert a basestring to unicode, preserving any unicode subclass.

        )rr�r!�sr"r"r#�_to_unicode_soft�s

zRenderer._to_unicode_softcCst|�|��S)zU
        Convert a basestring to a string with type unicode (not subclass).

        )rr,r*r"r"r#�_to_unicode_hard�szRenderer._to_unicode_hardcCst|�|�|���S)z�
        Convert a basestring to unicode (preserving any unicode subclass), and escape it.

        Returns a unicode string (not subclass).

        )rrr,r*r"r"r#�_escape_to_unicode�szRenderer._escape_to_unicodecCs|dur|j}t|||j�S)a
        Convert a byte string to unicode, using string_encoding and decode_errors.

        Arguments:

          b: a byte string.

          encoding: the name of an encoding.  Defaults to the string_encoding
            attribute for this instance.

        Raises:

          TypeError: Because this method calls Python's built-in unicode()
            function, this method raises the following exception if the
            given string is already unicode:

              TypeError: decoding Unicode is not supported

        N)r rr)r!�b�encodingr"r"r#r�szRenderer.strcCst|j|j|j|jd�S)zE
        Create a Loader instance using current attributes.

        )r�	extension�
to_unicoder)rrrrrr%r"r"r#�_make_loader�s�zRenderer._make_loadercs|����fdd�}|S)zC
        Return a function that loads a template by name.

        cs
��|�S�N)�	load_name)�
template_name��loaderr"r#�
load_template�s
z3Renderer._make_load_template.<locals>.load_template)r3)r!r9r"r7r#�_make_load_template�szRenderer._make_load_templatecs*�jdur	���S�j���fdd�}|S)zB
        Return a function that loads a partial by name.

        Ncs4��|�}|durtdt|�t��f����|�S)Nz!Name %s not found in partials: %s)�getr�repr�typer-)�name�template�rr!r"r#�load_partial
s
�
z1Renderer._make_load_partial.<locals>.load_partial)rr:)r!rAr"r@r#�_make_load_partials

zRenderer._make_load_partialcCs2|j}|tjkr
dS|tjkrdStdt|���)z@
        Return whether missing_tags is set to strict.

        TFz$Unsupported 'missing_tags' value: %s)rr�strict�ignore�	Exceptionr<r'r"r"r#�_is_missing_tags_stricts

z Renderer._is_missing_tags_strictcs$|���|��r
�S�fdd�}|S)zZ
        Return the resolve_partial function to pass to RenderEngine.__init__().

        cs z�|�WStyYdSw�N�)r)r>�rAr"r#�resolve_partial6s

�z7Renderer._make_resolve_partial.<locals>.resolve_partial)rBrF)r!rJr"rIr#�_make_resolve_partial+s
zRenderer._make_resolve_partialcCs|��rtSdd�}|S)zZ
        Return the resolve_context function to pass to RenderEngine.__init__().

        cSs"zt||�WStyYdSwrG)r
r)�stackr>r"r"r#�resolve_contextGs
�z7Renderer._make_resolve_context.<locals>.resolve_context)rFr
)r!rMr"r"r#�_make_resolve_context>szRenderer._make_resolve_contextcCs,|��}|��}t|j|j|||jd�}|S)z@
        Return a RenderEngine instance for rendering.

        )�literalrrMrJ�to_str)rNrKrr-r.r))r!rMrJ�enginer"r"r#�_make_render_engineOs�zRenderer._make_render_enginecCs|��}||�S)z@
        Load a template by name from the file system.

        )r:)r!r6r9r"r"r#r9aszRenderer.load_templatecOsV|��}t|t�rt|�}|�|�}n|�|�}|gt|�}|j|g|�Ri|��S)zH
        Render the template associated with the given object.

        )r3rr
r�load�load_object�list�_render_string)r!�objr&�kwargsr8r?r"r"r#�_render_objectis

zRenderer._render_objectcO�*|��}|�|�}|j|g|�Ri|��S)z�
        Render the template with the given name using the given context.

        See the render() docstring for more information.

        )r3r5rV)r!r6r&rXr8r?r"r"r#�render_names
zRenderer.render_namecOrZ)z�
        Render the template at the given path using the given context.

        Read the render() docstring for more information.

        )r3�readrV)r!�
template_pathr&rXr8r?r"r"r#�render_path�s
zRenderer.render_pathcs.|�����fdd�}|j|g|�Ri|��S)zL
        Render the given template string using the given context.

        cs|��|�Sr4��render�rQrL�r?r"r#�<lambda>��z)Renderer._render_string.<locals>.<lambda>)r-�
_render_final�r!r?r&rX�render_funcr"rbr#rV�s
zRenderer._render_stringcOs(tj|i|��}||_|��}|||�S)z�
        Arguments:

          render_func: a function that accepts a RenderEngine and ContextStack
            instance and returns a template rendering as a unicode string.

        )r�createrrR)r!rgr&rXrLrQr"r"r#re�s
zRenderer._render_finalcsft��r|j�g|�Ri|��St�t�r'�fdd�}|j|g|�Ri|��S|j�g|�Ri|��S)a�
        Render the given template string, view template, or parsed template.

        Returns a unicode string.

        Prior to rendering, this method will convert a template that is a
        byte string (type str in Python 2) to unicode using the string_encoding
        and decode_errors attributes.  See the constructor docstring for
        more information.

        Arguments:

          template: a template string that is unicode or a byte string,
            a ParsedTemplate instance, or another object instance.  In the
            final case, the function first looks for the template associated
            to the object by calling this class's get_associated_template()
            method.  The rendering process also uses the passed object as
            the first element of the context stack when rendering.

          *context: zero or more dictionaries, ContextStack instances, or objects
            with which to populate the initial context stack.  None
            arguments are skipped.  Items in the *context list are added to
            the context stack in order so that later items in the argument
            list take precedence over earlier items.

          **kwargs: additional key-value data to add to the context stack.
            As these arguments appear after all items in the *context list,
            in the case of key conflicts these values take precedence over
            all items in the *context list.

        cs��||�Sr4r_rarbr"r#rc�rdz!Renderer.render.<locals>.<lambda>)rrVrr	rerYrfr"rbr#r`�s 
zRenderer.render)NNNNNNNNr4)�__name__�
__module__�__qualname__�__doc__r$�propertyr&r)r,r-r.rr3r:rBrFrKrNrRr9rYr[r^rVrer`r"r"r"r#rs@
�m
	
	rN)rl�pystacher�pystache.commonrrr�pystache.contextrr�pystache.loaderr�pystache.parsedr	�pystache.renderenginer
r�pystache.specloaderr�pystache.template_specr
�objectrr"r"r"r#�<module>s

Youez - 2016 - github.com/yon3zu
LinuXploit