HEX

File: //opt/saltstack/salt/lib/python3.10/site-packages/salt/utils/__pycache__/jinja.cpython-310.pyc
o

;j���@s�dZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlmZddl
mZmZmZddlmZddlmZddlmZmZmZddlZddlmZmZmZdd	lmZdd
lm Z ddl!m"Z"ddl#Z$ddl%Z$ddl&Z$ddl'Z$ddl(Z$ddl)Z$ddl*Z$ddl+m,Z,dd
l-m.Z.m/Z/m0Z0ddl1m2Z2zddl3m4Z4Wne5y�ddlm4Z4Ynwe�6e7�Z8ddgZ9e	�:d�Z;e2ej<�Z=Gdd�de�Z>dd�Z?Gdd�de�Z@e/d�dd��ZAe0d�d^dd��ZBe0d�d d!��ZCe.d"�d#d$��ZDe.d%�d&d'��ZEe.d(�d)d(��ZFe.d*�d_d,d*��ZGe.d-�d.d-��ZHe.�d/d0��ZIe.d1�d^d2d1��ZJe.d3�d^d4d3��ZKe.d5�d^d6d5��ZLe.d7�d8d9��ZMe.�d:d;��ZNe.d<�d=d>��ZOe.d?�d@dA��ZPe.dB�dCdD��ZQe.dE�dFdE��ZRe.dG�dHdG��ZSe.dI�dJdI��ZTe.dK�dLdK��ZUe.dM�dNdM��ZVzejWZWWn
eX�y�ejYZWYnweWdOdP��ZZdQdR�Z[dSdT�Z\dUdV�Z]dWdX�Z^dYdZ�Z_e.d[�e^d`d\d[���Z`Gd]d�de"�ZadS)azK
Jinja loading utils to enable a more powerful backend for jinja templates
�N)�OrderedDict)�Hashable�Mapping�Sequence��wraps)�minidom)�Element�
SubElement�tostring)�
BaseLoader�TemplateNotFound�nodes)�TemplateModule)�TemplateRuntimeError)�	Extension��
TemplateError)�jinja_filter�jinja_global�
jinja_test)�Version)�Markup�SaltCacheLoader�SerializerExtensionz$91633EBF-1C86-5E33-935A-28061F4B480Ec@sZeZdZdZ				ddd�Zdd	�Zd
d�Zdd
�Zdd�Zdd�Z	dd�Z
dd�ZdS)rz�
    A special jinja Template Loader for salt.
    Requested templates are always fetched from the server
    to guarantee that the file is up to date.
    Templates are cached like regular salt states
    and only loaded once per loader instance.
    �base�utf-8FNcCs�||_||_||_||_|jr"||jdvrg|_n|d||_ntj�|dd|�g|_t�	d|j�g|_
||_|du|_dS)NZpillar_rootsZcachedir�fileszJinja search path: %s)
�opts�saltenv�encoding�pillar_rend�
searchpath�os�path�join�log�debug�cached�_file_client�_close_file_client)�selfrrr r!r)�r,�D/opt/saltstack/salt/lib/python3.10/site-packages/salt/utils/jinja.py�__init__<szSaltCacheLoader.__init__cCsL|jdust|jd�r|jjd|jdkr#tj�|j|j�|_d|_|jS)zC
        Return a file client. Instantiates on first call.
        NrZ
file_rootsT)r)�hasattrr�saltZ
fileclientZget_file_clientr!r*�r+r,r,r-�file_clientTs

��zSaltCacheLoader.file_clientcCs(tjj�|�}|��}|�|dd|j�S)z3
        Cache a file from the salt master
        �T)r0�utils�url�creater2Zget_filer)r+�templateZsaltpathZfclr,r,r-�
cache_filefszSaltCacheLoader.cache_filecCs4||jvr|�|�}|dur|j�|�dSdSdS)z(
        Cache a file only once
        FN)r(r8�append)r+r7�retr,r,r-�check_cachens

�zSaltCacheLoader.check_cachec
	s�|}|�dd�ddvrd}nd}|ra|rd|jvr$t�d|�t|��|jd}tj�d�||f��}|�dd�dd	krHt�d
|�t|��|j�	di��	d�d
kratj�
|�ratj�||�}|�|�|r�|r�tj�
|��dd�}|}|r�|j�	d|�}|}||dkr�dn||�dd�d�}|j�|�||jvs�tj�|�r�|jD]I}	tj�|	|��z7tjj��d��%}
|
���|j�}tj������fdd�}|�|fWd�WS1s�wYWq�ty�Yq�wt|��)a{
        Salt-specific loader to find imported jinja files.

        Jinja imports will be interpreted as originating from the top
        of each of the directories in the searchpath when the template
        name does not begin with './' or '../'.  When a template name
        begins with './' or '../' then the import will be relative to
        the importing file.

        �/�r)�..�.TF�tpldirz<Relative path "%s" cannot be resolved without an environmentr>zCDiscarded template path "%s": attempts to ascend outside of salt://rr2�local�\r3r?)�tplfiler@Ztpldot�rbcs(z	tj����kWStyYdSw�NF)r#r$�getmtime�OSErrorr,��filepath�mtimer,r-�uptodate�s
�z,SaltCacheLoader.get_source.<locals>.uptodateN)�split�globalsr&�warningr
r#r$�normpathr%�get�isabs�relpathr;�dirname�replace�updater(�existsr"r0r4rZfopen�read�decoder rFrG)
r+�environmentr7Z	_templateZis_relative�	base_pathr@rCZtpldataZspathZifile�contentsrKr,rHr-�
get_sourcewsj�
���
�

�
*��zSaltCacheLoader.get_sourcecCsL|jdurdS|jdurdS|j}d|_z|��WdSty%YdSwrE)r*r)�destroy�AttributeError)r+r2r,r,r-r]�s

�zSaltCacheLoader.destroycCs|��|S�N)r2r1r,r,r-�	__enter__�szSaltCacheLoader.__enter__cGs|��dSr_)r])r+�argsr,r,r-�__exit__�szSaltCacheLoader.__exit__)rrFN)�__name__�
__module__�__qualname__�__doc__r.r2r8r;r\r]r`rbr,r,r,r-r3s
�	QcsNt�t�r#t�fdd�dD��r#tjjj�ddd��d��d��d�St��S)	a�
    Return a YAML-safe repr for a string value.

    Python's ``repr()`` of a string containing a newline produces ``'foo\nbar'``
    where ``\n`` is the two-character backslash-n escape sequence. When such a
    repr is embedded into a YAML state file via Jinja interpolation (e.g.
    ``{{ some_dict }}``), the YAML parser sees the literal ``\n`` and not an
    actual newline, breaking multi-line scalars loaded via ``import_yaml``.

    For strings containing characters that would be escaped by ``repr()`` in a
    way YAML wouldn't round-trip (newlines, tabs, etc.), emit a YAML
    double-quoted scalar instead. Otherwise fall back to ``repr()`` for
    backward compatibility.

    See https://github.com/saltstack/salt/issues/30690
    c3s�|]}|�vVqdSr_r,)�.0�c��valuer,r-�	<genexpr>�s�z"_yaml_safe_repr.<locals>.<genexpr>z

	�"T)Z
default_style�default_flow_style�
z...)	�
isinstance�str�anyr0r4�yaml�	safe_dump�rstrip�reprrir,rir-�_yaml_safe_repr�s �rvc@s eZdZdZdd�Zdd�ZdS)�
PrintableDicta@
    Ensures that dict str() and repr() are YAML friendly.

    .. code-block:: python

        mapping = OrderedDict([('a', 'b'), ('c', None)])
        print mapping
        # OrderedDict([('a', 'b'), ('c', None)])

        decorated = PrintableDict(mapping)
        print decorated
        # {'a': 'b', 'c': None}
    cCs`g}|��D] \}}t|t�r|�|�dt|����q|�|�d|���qdd�|�dS�Nz: �{z, �}��itemsrorpr9rvr%�r+�output�keyrjr,r,r-�__str__s
zPrintableDict.__str__cCs`g}|��D] \}}t|t�r|�|�dt|����q|�|�d|���qdd�|�dSrxr{r}r,r,r-�__repr__s
zPrintableDict.__repr__N)rcrdrerfr�r�r,r,r,r-rw�srw�raisecCst|��r_r)�msgr,r,r-�jinja_raise&sr��matchFcCs>d}|r	|tjO}|r|tjO}t�||�}|�|�rdSdS)z6Returns true if a sequence of chars matches a pattern.rTF)�re�I�M�compiler�)�txt�rgx�
ignorecase�	multiline�flag�compiled_rgxr,r,r-�
test_match,s

r�ZequaltocCs||kS)z%Returns true if two values are equal.r,)rj�otherr,r,r-�test_equalto8sr��skipcCsdS)z�
    Suppress data output

    .. code-block:: yaml

        {% my_string = "foo" %}

        {{ my_string|skip }}

    will be rendered as empty string,

    r3r,��datar,r,r-�skip_filter?sr�ZsequencecCst|ttttf�s|gS|S)a�
    Ensure sequenced data.

    **sequence**

        ensure that parsed data is a sequence

    .. code-block:: jinja

        {% set my_string = "foo" %}
        {% set my_list = ["bar", ] %}
        {% set my_dict = {"baz": "qux"} %}

        {{ my_string|sequence|first }}
        {{ my_list|sequence|first }}
        {{ my_dict|sequence|first }}


    will be rendered as:

    .. code-block:: yaml

        foo
        bar
        baz
    )ro�list�tuple�set�dictr�r,r,r-�ensure_sequence_filterPsr��to_boolcCsb|durdSt|t�r
|St|ttff�r|��dvSt|t�r$|dkSt|t�s/t|�dkSdS)z�
    Returns the logical value.

    .. code-block:: jinja

        {{ 'yes' | to_bool }}

    will be rendered as:

    .. code-block:: text

        True
    NF)Zyes�1�truer)ro�boolrp�lower�intr�len��valr,r,r-r�qs


�indent�cs�|durtjdtdd�|}d|�d}t|t�r!t���t|�}||7}|r1|��|���}n|��}|�d�}|rL|||��fdd	�|D��7}|rR�|}|S)
z�
    A ported version of the "indent" filter containing a fix for indenting Markup
    objects. If the minion has Jinja version 2.11 or newer, the "indent" filter
    from upstream will be used, and this one will be ignored.
    NzRThe 'indentfirst' argument is renamed to 'first' and will be removed in Jinja 3.0.�)�
stacklevel� rnrc3s �|]}|r
�|n|VqdSr_r,)rg�line�Z	indentionr,r-rk�s�
�zindent.<locals>.<genexpr>)�warnings�warn�DeprecationWarningrorr%�
splitlines�pop)�s�width�firstZblankZindentfirst�newline�rv�linesr,r�r-r��s0�

��quotecC�
t�|�S)z�
    Wraps a text around quotes.

    .. code-block:: jinja

        {% set my_text = 'my_text' %}
        {{ my_text | quote }}

    will be rendered as:

    .. code-block:: text

        'my_text'
    )�shlexr�)r�r,r,r-r��s
cCr�r_)r��escaperir,r,r-�regex_escape�s
r��regex_searchcC�>d}|r	|tjO}|r|tjO}t�|||�}|sdS|��S)z�
    Searches for a pattern in the text.

    .. code-block:: jinja

        {% set my_text = 'abcd' %}
        {{ my_text | regex_search('^(.*)BC(.*)$', ignorecase=True) }}

    will be rendered as:

    .. code-block:: text

        ('a', 'd')
    rN)r�r�r��search�groups�r�r�r�r�r��objr,r,r-r���

�regex_matchcCr�)z�
    Searches for a pattern in the text.

    .. code-block:: jinja

        {% set my_text = 'abcd' %}
        {{ my_text | regex_match('^(.*)BC(.*)$', ignorecase=True) }}

    will be rendered as:

    .. code-block:: text

        ('a', 'd')
    rN)r�r�r�r�r�r�r,r,r-r��r��
regex_replacecCs8d}|r	|tjO}|r|tjO}t�||�}|�||�S)a 
    Searches for a pattern and replaces with a sequence of characters.

    .. code-block:: jinja

        {% set my_text = 'lets replace spaces' %}
        {{ my_text | regex_replace('\s+', '__') }}

    will be rendered as:

    .. code-block:: text

        lets__replace__spaces
    r)r�r�r�r��sub)r�r�r�r�r�r�r�r,r,r-r�s

�uuidcCstt�ttjj�|���S)z�
    Returns a UUID corresponding to the value passed as argument.

    .. code-block:: jinja

        {{ 'example' | uuid }}

    will be rendered as:

    .. code-block:: text

        f4efeff8-c219-578a-bad7-3dc280612ec8
    )rpr�Zuuid5�GLOBAL_UUIDr0r4�stringutilsZto_strr�r,r,r-�uuid_sr�cCs>d}t|t�r
t|�}|Sg}|D]}||vr|�|�q|S)z�
    Removes duplicates from a list.

    .. code-block:: jinja

        {% set my_list = ['a', 'b', 'c', 'a', 'b'] -%}
        {{ my_list | unique }}

    will be rendered as:

    .. code-block:: text

        ['a', 'b', 'c']
    N)rorr�r9)�valuesr:rjr,r,r-�unique3s
�
�r��mincC�t|�S)z�
    Returns the min value.

    .. code-block:: jinja

        {% set my_list = [1,2,3,4] -%}
        {{ my_list | min }}

    will be rendered as:

    .. code-block:: text

        1
    )r��r�r,r,r-�lst_minN�r��maxcCr�)z�
    Returns the max value.

    .. code-block:: jinja

        {% my_list = [1,2,3,4] -%}
        {{ set my_list | max }}

    will be rendered as:

    .. code-block:: text

        4
    )r�r�r,r,r-�lst_maxar�r�ZavgcCs&t|t�stt|�t|��St|�S)z�
    Returns the average value of a list.

    .. code-block:: jinja

        {% my_list = [1,2,3,4] -%}
        {{ set my_list | avg }}

    will be rendered as:

    .. code-block:: yaml

        2.5
    )ror�float�sumr�)�lstr,r,r-�lst_avgts
r��unioncCs0t|t�rt|t�rt|�t|�BSt||�S)z�
    Returns the union of two lists.

    .. code-block:: jinja

        {% my_list = [1,2,3,4] -%}
        {{ set my_list | union([2, 4, 6]) }}

    will be rendered as:

    .. code-block:: text

        [1, 2, 3, 4, 6]
    �rorr�r��Zlst1�lst2r,r,r-r��s�	intersectcs:t|t�rt�t�rt|�t��@St�fdd�|D��S)z�
    Returns the intersection of two lists.

    .. code-block:: jinja

        {% my_list = [1,2,3,4] -%}
        {{ set my_list | intersect([2, 4, 6]) }}

    will be rendered as:

    .. code-block:: text

        [2, 4]
    csg|]}|�vr|�qSr,r,�rgZele�r�r,r-�
<listcomp>��zintersect.<locals>.<listcomp>r�r�r,r�r-r����
differencecs:t|t�rt�t�rt|�t��St�fdd�|D��S)z�
    Returns the difference of two lists.

    .. code-block:: jinja

        {% my_list = [1,2,3,4] -%}
        {{ set my_list | difference([2, 4, 6]) }}

    will be rendered as:

    .. code-block:: text

        [1, 3, 6]
    csg|]}|�vr|�qSr,r,r�r�r,r-r��r�zdifference.<locals>.<listcomp>r�r�r,r�r-r��r��symmetric_differencecsBt�t�rt�t�rt��t��ASt��fdd�t���D��S)z�
    Returns the symmetric difference of two lists.

    .. code-block:: jinja

        {% my_list = [1,2,3,4] -%}
        {{ set my_list | symmetric_difference([2, 4, 6]) }}

    will be rendered as:

    .. code-block:: text

        [1, 3]
    csg|]}|t���vr|�qSr,)r�r�r�r,r-r��sz(symmetric_difference.<locals>.<listcomp>)rorr�r�r�r�r,r�r-r��s
��method_callcOst||dd��|i|��S)Nc_sdSr_r,)ra�kwargsr,r,r-�<lambda>�szmethod_call.<locals>.<lambda>)�getattr)r�Zf_nameZf_argsZf_kwargsr,r,r-r��scCstjj�dd�|��D��S)NcSsi|]\}}||�qSr,r,�rgrrjr,r,r-�
<dictcomp>�sz%show_full_context.<locals>.<dictcomp>)r0r4r�Zsimple_types_filterr|)�ctxr,r,r-�show_full_context�s�r�cCs�t|�|vrgS|�t|��g}t|tj�r|�|�|St|t�r>|��D]\}}|�t	||��|�t	||��q'|St|t
�rUt|t�sU|D]
}|�t	||��qJ|Sr_)�id�addro�jinja2�StrictUndefinedr9rr|�extend�__get_strict_undefinedrrp)rjZids�	undefinedr�itemr,r,r-r��s 
	
��r�cCstt|t���Sr_)r�r�r�rir,r,r-�_get_strict_undefined�r�cCst�d�dd�|D���S)Nrncss�|]}|jVqdSr_)Z_undefined_message)rg�ur,r,r-rk	s�z)_join_strict_undefined.<locals>.<genexpr>)r�r�r%)r�r,r,r-�_join_strict_undefinedsr�c�t���fdd��}|S)Ncs*t|�}|r
t|�S�|g|�Ri|��Sr_�r�r�)rjrar�r���functionr,r-�__handle_strict_undefined
sz;_handle_strict_undefined.<locals>.__handle_strict_undefinedr)r�r�r,r�r-�_handle_strict_undefined�r�cr�)Ncs,t|�}|r
t|�S�||g|�Ri|��Sr_r�)r+rjrar�r�r�r,r-� __handle_method_strict_undefinedszI_handle_method_strict_undefined.<locals>.__handle_method_strict_undefinedr)r�r�r,r�r-�_handle_method_strict_undefinedr�r��tojsoncKsR|�dd�|dur||d<tjjj|fi|���dd��dd��d	d
��dd�S)
z�
    Implementation of tojson filter (only present in Jinja 2.9 and later).
    Unlike the Jinja built-in filter, this allows arbitrary options to be
    passed in to the underlying JSON library.
    �ensure_asciiTNr��<z\u003c�>z\u003e�&z\u0026�'z\u0027)�
setdefaultr0r4�json�dumpsrT)r�r��optionsr,r,r-r"s�cs�eZdZdZhd�Z�fdd�Zdd�Zed,d	d
��Zed-dd��Z	ed
d��Z
edd��Zedd��Zedd��Z
edd��Zhd�Zhd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zed.d*d+��Z�ZS)/ra�
    Yaml and Json manipulation.

    **Format filters**

    Allows jsonifying or yamlifying any data structure. For example, this dataset:

    .. code-block:: python

        data = {
            'foo': True,
            'bar': 42,
            'baz': [1, 2, 3],
            'qux': 2.0
        }

    .. code-block:: jinja

        yaml = {{ data|yaml }}
        json = {{ data|json }}
        python = {{ data|python }}
        xml  = {{ {'root_node': data}|xml }}

    will be rendered as::

        yaml = {bar: 42, baz: [1, 2, 3], foo: true, qux: 2.0}
        json = {"baz": [1, 2, 3], "foo": true, "bar": 42, "qux": 2.0}
        python = {'bar': 42, 'baz': [1, 2, 3], 'foo': True, 'qux': 2.0}
        xml = """<<?xml version="1.0" ?>
                 <root_node bar="42" foo="True" qux="2.0">
                  <baz>1</baz>
                  <baz>2</baz>
                  <baz>3</baz>
                 </root_node>"""

    The yaml filter takes an optional flow_style parameter to control the
    default-flow-style parameter of the YAML dumper.

    .. code-block:: jinja

        {{ data|yaml(False) }}

    will be rendered as:

    .. code-block:: yaml

        bar: 42
        baz:
          - 1
          - 2
          - 3
        foo: true
        qux: 2.0

    **Load filters**

    Strings and variables can be deserialized with **load_yaml** and
    **load_json** tags and filters. It allows one to manipulate data directly
    in templates, easily:

    .. code-block:: jinja

        {%- set yaml_src = "{foo: it works}"|load_yaml %}
        {%- set json_src = '{"bar": "for real"}'|load_json %}
        Dude, {{ yaml_src.foo }} {{ json_src.bar }}!

    will be rendered as::

        Dude, it works for real!

    **Load tags**

    Salt implements ``load_yaml`` and ``load_json`` tags. They work like
    the `import tag`_, except that the document is also deserialized.

    Syntaxes are ``{% load_yaml as [VARIABLE] %}[YOUR DATA]{% endload %}``
    and ``{% load_json as [VARIABLE] %}[YOUR DATA]{% endload %}``

    For example:

    .. code-block:: jinja

        {% load_yaml as yaml_src %}
            foo: it works
        {% endload %}
        {% load_json as json_src %}
            {
                "bar": "for real"
            }
        {% endload %}
        Dude, {{ yaml_src.foo }} {{ json_src.bar }}!

    will be rendered as::

        Dude, it works for real!

    **Import tags**

    External files can be imported and made available as a Jinja variable.

    .. code-block:: jinja

        {% import_yaml "myfile.yml" as myfile %}
        {% import_json "defaults.json" as defaults %}
        {% import_text "completeworksofshakespeare.txt" as poems %}

    **Catalog**

    ``import_*`` and ``load_*`` tags will automatically expose their
    target variable to import. This feature makes catalog of data to
    handle.

    for example:

    .. code-block:: jinja

        # doc1.sls
        {% load_yaml as var1 %}
            foo: it works
        {% endload %}
        {% load_yaml as var2 %}
            bar: for real
        {% endload %}

    .. code-block:: jinja

        # doc2.sls
        {% from "doc1.sls" import var1, var2 as local2 %}
        {{ var1.foo }} {{ local2.bar }}

    ** Escape Filters **

    .. versionadded:: 2017.7.0

    Allows escaping of strings so they can be interpreted literally by another
    function.

    For example:

    .. code-block:: jinja

        regex_escape = {{ 'https://example.com?foo=bar%20baz' | regex_escape }}

    will be rendered as::

        regex_escape = https\:\/\/example\.com\?foo\=bar\%20baz

    ** Set Theory Filters **

    .. versionadded:: 2017.7.0

    Performs set math using Jinja filters.

    For example:

    .. code-block:: jinja

        unique = {{ ['foo', 'foo', 'bar'] | unique }}

    will be rendered as::

        unique = ['foo', 'bar']

    ** Salt State Parameter Format Filters **

    .. versionadded:: 3005

    Renders a formatted multi-line YAML string from a Python dictionary. Each
    key/value pair in the dictionary will be added as a single-key dictionary
    to a list that will then be sent to the YAML formatter.

    For example:

    .. code-block:: jinja

        {% set thing_params = {
            "name": "thing",
            "changes": True,
            "warnings": "OMG! Stuff is happening!"
           }
        %}

        thing:
          test.configurable_test_state:
            {{ thing_params | dict_to_sls_yaml_params | indent }}

    will be rendered as::

    .. code-block:: yaml

        thing:
          test.configurable_test_state:
            - name: thing
            - changes: true
            - warnings: OMG! Stuff is happening!

    .. _`import tag`: https://jinja.palletsprojects.com/en/2.11.x/templates/#import
    >�import_text�import_yaml�	load_yaml�profile�	load_json�	load_text�import_jsoncs�t��|�|jj�|j|j|j|j|j	|j
|j|jt
tj�t
tj�t
tj�t
tj�t
tj�t
t�t
tj�d��|jjdurF|j|j_dS|jj�t���fdd��}||j_dS)N)rrrZxml�pythonrrr�dict_to_sls_yaml_params�combinations�combinations_with_replacement�compress�permutations�product�zip�zip_longestcs�|�|��Sr_��	finalizer�r+r�rr,r-�wrapper%sz-SerializerExtension.__init__.<locals>.wrapper)�superr.rY�filtersrU�format_yaml�format_json�
format_xml�
format_pythonrrrrr��	itertoolsrrrrrrr�finalizerr)r+rYr��	__class__rr-r.s6���zSerializerExtension.__init__cs�fdd���|�S)zA
        Ensure that printed mappings are YAML friendly.
        csTt|ttf�rt�fdd�|��D��St|tttf�r(|��fdd�|D��S|S)Ncsg|]
\}}|�|�f�qSr,r,r���explorer,r-r�3szBSerializerExtension.finalizer.<locals>.explore.<locals>.<listcomp>csg|]}�|��qSr,r,)rgrjr(r,r-r�6s)	ror�rrwr|r�r�r�r'r�r(r,r-r)0s�z.SerializerExtension.finalizer.<locals>.explorer,rr,r(r-r+s	zSerializerExtension.finalizerTNcCsHtjjj|||d���}zt|�WSty#ttjj�|��YSw)N)�	sort_keysr�)	r0r4rr�stripr�UnicodeDecodeErrorr��
to_unicode)r+rjr*r�Zjson_txtr,r,r-r!;s��
�zSerializerExtension.format_jsoncCsdtjjj||d���}|�d�r|dt|�d�}zt|�WSty1ttjj	�
|��YSw)N)rmz
...r�)r0r4rrrsr+�endswithr�rr,r�r-)r+rj�
flow_styleZyaml_txtr,r,r-r Es��

�zSerializerExtension.format_yamlcs:dd��d��fdd�	�tt�t��|����jdd��S)	a9Render a formatted multi-line XML string from a complex Python
        data structure. Supports tag attributes and nested dicts/lists.

        :param value: Complex data structure representing XML contents
        :returns: Formatted XML string rendered with newlines and indentation
        :rtype: str
        cSsNt|ttf�rt|dt�r|}|Sg}|St|t�r#t|���}|Std��)Nrz1Value is not a dict or list. Cannot render as XML)ror�r�rpr�r|r)rjZxmlvalr,r,r-�normalize_iter[s	�
���z6SerializerExtension.format_xml.<locals>.normalize_iterNcs�d}|D]Y\}}t|t�r|D]
}�||ff|�qn|dur%t||�}nt|�}t|ttttf�r8t|�|_qt|t	�rGdd�|�
�D�|_dd��|�D�D]\}}�||ff|�qPq|S)NcSs(i|]\}}t|ttf�s|t|��qSr,)ror�r�rp)rg�attrr�r,r,r-r�ws��zHSerializerExtension.format_xml.<locals>.recurse_tree.<locals>.<dictcomp>cSs"g|]
}t|dttf�r|�qS)r=)ror�r�)rgr�r,r,r-r�|s��zHSerializerExtension.format_xml.<locals>.recurse_tree.<locals>.<listcomp>)ror�r
r	rpr�r�r��textr�r|Zattrib)Zxmliter�elementr��tag�attrsr1r��r0�recurse_treer,r-r7is,
�

���z4SerializerExtension.format_xml.<locals>.recurse_treer�)r�r_)rrZparseStringrZtoprettyxml�r+rjr,r6r-r"Qs
���zSerializerExtension.format_xmlcCstt�|����Sr_)r�pprintZpformatr+r8r,r,r-r#�sz!SerializerExtension.format_pythoncCs�t|t�r	t|�}z
tjj�tjj�|��WStjjj	y`}z;d}z|j
jd}|j
j}|j
}WntyD|t|�7}Yt|��w||�d�7}|tjjj||dd�7}t|��d}~wtymtd|����w)Nz Encountered error loading yaml: r=rnz    <======================)�markerzUnable to load yaml from )rorrpr0r4r�rXrrZ	safe_loadZ	YAMLErrorZproblem_markr��buffer�problemr^r�Zget_contextr)r+rj�excr�r��bufr<r,r,r-r�s.

�
���zSerializerExtension.load_yamlc
CsFt|t�r	t|�}ztjj�|�WSttt	fy"t
d|����w)NzUnable to load json from )rorrpr0r4r�loads�
ValueError�	TypeErrorr^rr8r,r,r-r�s
�zSerializerExtension.load_jsoncCst|t�r	t|�}|Sr_)rorrpr8r,r,r-r�s
zSerializerExtension.load_text>rrr>r
rrcCs�|jjj|jvr
|�|�S|jjj|jvr$|�||jjj�dd�d�S|jjjdkr0|�|�S|�	d|jjj|jjj
�dS)N�_r=r
zUnknown format )�stream�currentrj�
_load_parsers�
parse_load�_import_parsers�parse_importrL�
parse_profile�fail�lineno�r+�parserr,r,r-�parse�s
�
�zSerializerExtension.parsecCsBt|j�j}|j�d�|��}|jdgdd�}|�||d||�S)N�name:aszname:endprofileT�Zdrop_needlez
profile block)�nextrCrK�expectZparse_expression�parse_statements�_parse_profile_block)r+rMrK�label�bodyr,r,r-rI�s
z!SerializerExtension.parse_profilecCsd|��j��S)NZ_salt_profile_)�free_identifier�namerLr,r,r-�_create_profile_id�r�z&SerializerExtension._create_profile_idcCs||t��fSr_)�time)r+rU�sourcer,r,r-�_profile_start�sz"SerializerExtension._profile_startcCst�d||t��|�dS)Nz'Time (in seconds) to render %s '%s': %s)r&r
rZ)r+rUr[Z
previous_timer,r,r-�_profile_end�s
�z SerializerExtension._profile_endcCs~|�|�}t�t�|d��|�|jdt�|t�|�g��|�d��|���|�g|t�|jdt�|d�d���|�g}|S)N�storer\)Zdyn_argsr]�load)	rYr�Assign�Name�
set_linenoZcall_method�ListZConstZExprStmt)r+rMrUr[rVrKZ
profile_idr:r,r,r-rT�s2
�����
�����z(SerializerExtension._parse_profile_blockc
Cs�|jjj}t|j�j}||jjvr|�d|��|�|j�d�|�	�}d|�
�j}|jddd�}t
�|gg|��|�t
�|t
�t
�t
�|d��|�ggdd��|�|ggdd��|���|�gS)NzUnable to parse rOrB)zname:endloadTrPr_)rCrDrjrQrKrYrrJrRZparse_assign_targetrWrXrSrZMacrorbr`�FilterZCallra)r+rMZfilter_namerK�targetZ
macro_nameZ
macro_bodyr,r,r-rF�s<
��
��zSerializerExtension.parse_loadcCs||��}|j}|j}|t�t�|d��|�t�t�|d��|�d|��ggdd��|���|�g}|�||j	d|��||�S)Nr^r_Zload_�import_)
rHrerKrr`rarbrdrTr7)r+rM�	converterZimport_nodererKrVr,r,r-rHs*��
��z SerializerExtension.parse_importFcCs|jdd�|��D�|d�S)a/
        .. versionadded:: 3005

        Render a formatted multi-line YAML string from a Python dictionary. Each
        key/value pair in the dictionary will be added as a single-key dictionary
        to a list that will then be sent to the YAML formatter.

        :param value: Python dictionary representing Salt state parameters

        :param flow_style: Setting flow_style to False will enforce indentation
                           mode

        :returns: Formatted SLS YAML string rendered with newlines and
                  indentation
        cSsg|]\}}||i�qSr,r,)rgrr�r,r,r-r�Br�z?SerializerExtension.dict_to_sls_yaml_params.<locals>.<listcomp>)r/)r r|)r+rjr/r,r,r-r0s�z+SerializerExtension.dict_to_sls_yaml_params)TN)T)F)rcrdrerf�tagsr.rr�r!r r"r#rrrrErGrNrIrYr\r]rTrFrHr�
__classcell__r,r,r&r-r6s@H
#	
8



 )FF)r�FFNr_)brfr$�loggingZos.pathr#r9r�r�rZr�r��collectionsr�collections.abcrrr�	functoolsrZxml.domrZxml.etree.ElementTreer	r
rr�rr
rZjinja2.environmentrZjinja2.exceptionsrZ
jinja2.extrZsalt.fileclientr0Zsalt.utils.dataZsalt.utils.filesZsalt.utils.jsonZsalt.utils.stringutilsZsalt.utils.urlZsalt.utils.yamlZsalt.exceptionsrZsalt.utils.decorators.jinjarrrZsalt.utils.versionsrZ
markupsafer�ImportError�	getLoggerrcr&�__all__ZUUIDr��__version__Z
JINJA_VERSIONrrvrwr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�Zpass_contextr^Zcontextfunctionr�r�r�r�r�r�rrr,r,r,r-�<module>s��


,)



 
)













�