o
    XôjãW  ã                   @   sL  d Z ddlmZ zddlmZ W n ey   ddlZY nw ze e¡Z	W n ej
y1   dZ	Y nw zeeee	 d¡d  d¡dd… ƒƒZW n eyR   dZY nw d	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ƒZefdd„Zdd„ Zz&zddlZW n ey›   ddlZY nw dd„ Zdd„ Zee_eeƒe_W n	 ey¶   Y nw zcddlZddl m!Z!m"Z" dd„ Z#dd „ Z$d!d"„ Z%d#D ]Z&e'ee&dƒZ(e(du rßqÒej)d$e#e(d%� ej)d&e#e(d%� qÒe" *ee$¡ e" +ee$¡ e! *ee%¡ e! +ee%¡ d'd(„ Z,d)d*„ Z-e,e_,ee-ƒe_-W dS  e�y%   Y dS w )+aé   Munch is a subclass of dict with attribute-style access.

    >>> b = Munch()
    >>> b.hello = 'world'
    >>> b.hello
    'world'
    >>> b['hello'] += "!"
    >>> b.hello
    'world!'
    >>> b.foo = Munch(lol=True)
    >>> b.foo.lol
    True
    >>> b.foo is b['foo']
    True

    It is safe to import * from this module:

        __all__ = ('Munch', 'munchify','unmunchify')

    un/munchify provide dictionary conversion; Munches can also be
    converted via Munch.to/fromDict().
é    )ÚMappingNz0.0.0ú+Ú.é   )r   r   r   )ÚMunchÚmunchifyÚDefaultMunchÚDefaultFactoryMunchÚRecursiveMunchÚ
unmunchifyc                   @   s˜   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Ze	dd„ ƒZ
dd„ Zdd„ Zdd„ Zdd„ ZeZedd„ ƒZdd„ Zdd„ Zd!dd„Zd!dd „ZdS )"r   a1   A dictionary that provides attribute-style access.

        >>> b = Munch()
        >>> b.hello = 'world'
        >>> b.hello
        'world'
        >>> b['hello'] += "!"
        >>> b.hello
        'world!'
        >>> b.foo = Munch(lol=True)
        >>> b.foo.lol
        True
        >>> b.foo is b['foo']
        True

        A Munch is a subclass of dict; it supports all the methods a dict does...

        >>> sorted(b.keys())
        ['foo', 'hello']

        Including update()...

        >>> b.update({ 'ponies': 'are pretty!' }, hello=42)
        >>> print (repr(b))
        Munch({'ponies': 'are pretty!', 'foo': Munch({'lol': True}), 'hello': 42})

        As well as iteration...

        >>> sorted([ (k,b[k]) for k in b ])
        [('foo', Munch({'lol': True})), ('hello', 42), ('ponies', 'are pretty!')]

        And "splats".

        >>> "The {knights} who say {ni}!".format(**Munch(knights='lolcats', ni='can haz'))
        'The lolcats who say can haz!'

        See unmunchify/Munch.toDict, munchify/Munch.fromDict for notes about conversion.
    c                 O   s   | j |i |¤Ž d S ©N)Úupdate©ÚselfÚargsÚkwargs© r   ú_/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/munch/__init__.pyÚ__init__W   ó   zMunch.__init__c                 C   sD   zt  | |¡W S  ty!   z| | W  Y S  ty    t|ƒ‚w w )a2   Gets key if it exists, otherwise throws AttributeError.

            nb. __getattr__ is only called if key is not found in normal places.

            >>> b = Munch(bar='baz', lol={})
            >>> b.foo
            Traceback (most recent call last):
                ...
            AttributeError: foo

            >>> b.bar
            'baz'
            >>> getattr(b, 'bar')
            'baz'
            >>> b['bar']
            'baz'

            >>> b.lol is b['lol']
            True
            >>> b.lol is getattr(b, 'lol')
            True
        )ÚobjectÚ__getattribute__ÚAttributeErrorÚKeyError©r   Úkr   r   r   Ú__getattr__[   s   ÿýzMunch.__getattr__c              	   C   sR   zt  | |¡ W n ty   z|| |< W Y dS    t|ƒ‚w t  | ||¡ dS )a   Sets attribute k if it exists, otherwise sets key k. A KeyError
            raised by set-item (only likely if you subclass Munch) will
            propagate as an AttributeError instead.

            >>> b = Munch(foo='bar', this_is='useful when subclassing')
            >>> hasattr(b.values, '__call__')
            True
            >>> b.values = 'uh oh'
            >>> b.values
            'uh oh'
            >>> b['values']
            Traceback (most recent call last):
                ...
            KeyError: 'values'
        N)r   r   r   Ú__setattr__©r   r   Úvr   r   r   r   {   s   üzMunch.__setattr__c                 C   sV   zt  | |¡ W n ty"   z| |= W Y dS  ty!   t|ƒ‚w w t  | |¡ dS )a‡   Deletes attribute k if it exists, otherwise deletes key k. A KeyError
            raised by deleting the key--such as when the key is missing--will
            propagate as an AttributeError instead.

            >>> b = Munch(lol=42)
            >>> del b.lol
            >>> b.lol
            Traceback (most recent call last):
                ...
            AttributeError: lol
        N)r   r   r   r   Ú__delattr__r   r   r   r   r    –   s   ÿýzMunch.__delattr__c                 C   s   t | ƒS )a3   Recursively converts a munch back into a dictionary.

            >>> b = Munch(foo=Munch(lol=True), hello=42, ponies='are pretty!')
            >>> sorted(b.toDict().items())
            [('foo', {'lol': True}), ('hello', 42), ('ponies', 'are pretty!')]

            See unmunchify for more info.
        )r   ©r   r   r   r   ÚtoDict­   s   	zMunch.toDictc                 C   s   |   ¡ S r   )r"   r!   r   r   r   Ú__dict__¸   s   zMunch.__dict__c                 C   s   | j j› dt | ¡› d�S )aà   Invertible* string-form of a Munch.

            >>> b = Munch(foo=Munch(lol=True), hello=42, ponies='are pretty!')
            >>> print (repr(b))
            Munch({'ponies': 'are pretty!', 'foo': Munch({'lol': True}), 'hello': 42})
            >>> eval(repr(b))
            Munch({'ponies': 'are pretty!', 'foo': Munch({'lol': True}), 'hello': 42})

            >>> with_spaces = Munch({1: 2, 'a b': 9, 'c': Munch({'simple': 5})})
            >>> print (repr(with_spaces))
            Munch({'a b': 9, 1: 2, 'c': Munch({'simple': 5})})
            >>> eval(repr(with_spaces))
            Munch({'a b': 9, 1: 2, 'c': Munch({'simple': 5})})

            (*) Invertible so long as collection contents are each repr-invertible.
        ú(ú))Ú	__class__Ú__name__ÚdictÚ__repr__r!   r   r   r   r)   ¼   s   zMunch.__repr__c                 C   s   t |  ¡ ƒS r   )ÚlistÚkeysr!   r   r   r   Ú__dir__Ï   s   zMunch.__dir__c                 C   s   dd„ |   ¡ D ƒS )ú} Implement a serializable interface used for pickling.

        See https://docs.python.org/3.6/library/pickle.html.
        c                 S   ó   i | ]\}}||“qS r   r   ©Ú.0r   r   r   r   r   Ú
<dictcomp>×   ó    z&Munch.__getstate__.<locals>.<dictcomp>)Úitemsr!   r   r   r   Ú__getstate__Ò   s   zMunch.__getstate__c                 C   s   |   ¡  |  |¡ dS ©r-   N)Úclearr   )r   Ústater   r   r   Ú__setstate__Ù   s   zMunch.__setstate__c                 C   s
   t || ƒS )zë Recursively transforms a dictionary into a Munch via copy.

            >>> b = Munch.fromDict({'urmom': {'sez': {'what': 'what'}}})
            >>> b.urmom.sez.what
            'what'

            See munchify for more info.
        ©r   ©ÚclsÚdr   r   r   ÚfromDictã   s   

zMunch.fromDictc                 C   ó   t | ƒ | ¡S r   ©Útyper=   r!   r   r   r   Úcopyï   ó   z
Munch.copyc                 O   s(   t |i |¤Ž ¡ D ]\}}|| |< q	dS )zw
        Override built-in method to call custom __setitem__ method that may
        be defined in subclasses.
        N)r(   r3   )r   r   r   r   r   r   r   r   r   ò   s   
ÿzMunch.updateNc                 C   s   || vr|S | | S )zN
        D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
        r   ©r   r   r<   r   r   r   Úgetú   s   z	Munch.getc                 C   s   || vr|| |< | | S )zR
        D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
        r   rC   r   r   r   Ú
setdefault  s   zMunch.setdefaultr   )r'   Ú
__module__Ú__qualname__Ú__doc__r   r   r   r    r"   Úpropertyr#   r)   r,   r4   r8   Ú__members__Úclassmethodr=   rA   r   rD   rE   r   r   r   r   r   0   s(    & 


r   c                       s   e Zd Z‡ fdd„Z‡  ZS )Ú	AutoMunchc                    s4   t |tƒrt |ttfƒst|tƒ}tƒ  ||¡ dS )z† Works the same as Munch.__setattr__ but if you supply
            a dictionary as value it will convert it to another Munch.
        N)Ú
isinstancer   rL   r   r   Úsuperr   r   ©r&   r   r   r     s   
zAutoMunch.__setattr__)r'   rF   rG   r   Ú__classcell__r   r   rO   r   rL     s    rL   c                       sr   e Zd ZdZ‡ fdd„Z‡ fdd„Z‡ fdd„Z‡ fdd	„Zd
d„ Zdd„ Z	e
ddd„ƒZdd„ Zdd„ Z‡  ZS )r   zG
    A Munch that returns a user-specified value for missing keys.
    c                    s:   |r|d }|dd… }nd}t ƒ j|i |¤Ž || _dS )z» Construct a new DefaultMunch. Like collections.defaultdict, the
            first argument is the default value; subsequent arguments are the
            same as those for dict.
        r   é   N)rN   r   Ú__default__)r   r   r   ÚdefaultrO   r   r   r     s   
zDefaultMunch.__init__c                    ó(   zt ƒ  |¡W S  ty   | j Y S w ©z< Gets key if it exists, otherwise returns the default value.)rN   r   r   rR   r   rO   r   r   r   (  ó
   
ÿzDefaultMunch.__getattr__c                    ó,   |dkrt  | ||¡ d S tƒ  ||¡ d S )NrR   ©r   r   rN   r   rO   r   r   r   /  ó   zDefaultMunch.__setattr__c                    rT   rU   )rN   Ú__getitem__r   rR   r   rO   r   r   rZ   5  rV   zDefaultMunch.__getitem__c                 C   s   | j dd„ |  ¡ D ƒfS )r-   c                 S   r.   r   r   r/   r   r   r   r1   A  r2   z-DefaultMunch.__getstate__.<locals>.<dictcomp>)rR   r3   r!   r   r   r   r4   <  s   zDefaultMunch.__getstate__c                 C   s$   |   ¡  |\}}|  |¡ || _dS r5   )r6   r   rR   )r   r7   rS   Ú
state_dictr   r   r   r8   C  s   

zDefaultMunch.__setstate__Nc                    ó   t |‡ ‡fdd„d�S )Nc                    ó
   ˆ ˆ| ƒS r   r   ©Zd_©r;   rS   r   r   Ú<lambda>P  ó   
 z'DefaultMunch.fromDict.<locals>.<lambda>©Úfactoryr9   )r;   r<   rS   r   r_   r   r=   M  ó   zDefaultMunch.fromDictc                 C   ó   t | ƒj| | jd�S )N)rS   )r@   r=   rR   r!   r   r   r   rA   R  r   zDefaultMunch.copyc                 C   s$   t | ƒj› d| j›dt | ¡› d�S ©Nr$   z, r%   )r@   r'   Z__undefined__r(   r)   r!   r   r   r   r)   U  s   $zDefaultMunch.__repr__r   )r'   rF   rG   rH   r   r   r   rZ   r4   r8   rK   r=   rA   r)   rP   r   r   rO   r   r     s    
r   c                       sP   e Zd ZdZ‡ fdd„Zedd„ ƒZdd„ Zdd	„ Z‡ fd
d„Z	dd„ Z
‡  ZS )r	   aD   A Munch that calls a user-specified function to generate values for
        missing keys like collections.defaultdict.

        >>> b = DefaultFactoryMunch(list, {'hello': 'world!'})
        >>> b.hello
        'world!'
        >>> b.foo
        []
        >>> b.bar.append('hello')
        >>> b.bar
        ['hello']
    c                    s   t ƒ j|i |¤Ž || _d S r   )rN   r   Údefault_factory)r   rg   r   r   rO   r   r   r   g  s   
zDefaultFactoryMunch.__init__c                    r\   )Nc                    r]   r   r   r^   ©r;   rg   r   r   r`   n  ra   z.DefaultFactoryMunch.fromDict.<locals>.<lambda>rb   r9   )r;   r<   rg   r   rh   r   r=   k  rd   zDefaultFactoryMunch.fromDictc                 C   re   )N©rg   )r@   r=   rg   r!   r   r   r   rA   p  r   zDefaultFactoryMunch.copyc                 C   s*   | j j}t| ƒj› d|› dt | ¡› d�S rf   )rg   r'   r@   r(   r)   )r   rc   r   r   r   r)   s  s   "zDefaultFactoryMunch.__repr__c                    rW   )Nrg   rX   r   rO   r   r   r   w  rY   zDefaultFactoryMunch.__setattr__c                 C   s   |   ¡ | |< | | S r   ri   r   r   r   r   Ú__missing__}  s   zDefaultFactoryMunch.__missing__)r'   rF   rG   rH   r   rK   r=   rA   r)   r   rj   rP   r   r   rO   r   r	   Y  s    
r	   c                       s4   e Zd ZdZ‡ fdd„Zedd„ ƒZdd„ Z‡  ZS )r
   a  A Munch that calls an instance of itself to generate values for
        missing keys.

        >>> b = RecursiveMunch({'hello': 'world!'})
        >>> b.hello
        'world!'
        >>> b.foo
        RecursiveMunch(RecursiveMunch, {})
        >>> b.bar.okay = 'hello'
        >>> b.bar
        RecursiveMunch(RecursiveMunch, {'okay': 'hello'})
        >>> b
        RecursiveMunch(RecursiveMunch, {'hello': 'world!', 'foo': RecursiveMunch(RecursiveMunch, {}),
        'bar': RecursiveMunch(RecursiveMunch, {'okay': 'hello'})})
    c                    s   t ƒ jtg|¢R i |¤Ž d S r   )rN   r   r
   r   rO   r   r   r   “  s   zRecursiveMunch.__init__c                 C   s   t || d�S )Nrb   r9   r:   r   r   r   r=   –  s   zRecursiveMunch.fromDictc                 C   r>   r   r?   r!   r   r   r   rA   ›  rB   zRecursiveMunch.copy)	r'   rF   rG   rH   r   rK   r=   rA   rP   r   r   rO   r   r
   ‚  s    
r
   c                    sF   t ƒ ‰‡‡fdd„‰‡‡fdd„‰‡ ‡fdd„‰‡‡fdd„‰ˆ| ƒS )	am   Recursively transforms a dictionary into a Munch via copy.

        >>> b = munchify({'urmom': {'sez': {'what': 'what'}}})
        >>> b.urmom.sez.what
        'what'

        munchify can handle intermediary dicts, lists and tuples (as well as
        their subclasses), but ymmv on custom datatypes.

        >>> b = munchify({ 'lol': ('cats', {'hah':'i win again'}),
        ...         'hello': [{'french':'salut', 'german':'hallo'}] })
        >>> b.hello[0].french
        'salut'
        >>> b.lol[1].hah
        'i win again'

        nb. As dicts are not hashable, they cannot be nested in sets/frozensets.
    c                    s   ˆ| ƒ\}}|r
|S ˆ || ƒS r   r   )ÚobjÚpartialZalready_seen)Úpost_munchifyÚpre_munchify_cyclesr   r   Úmunchify_cycles¼  s   
z!munchify.<locals>.munchify_cyclesc                    sB   z	ˆt | ƒ dfW S  ty   Y nw ˆ | ƒ ˆt | ƒ< }|dfS )NTF©Úidr   ©rk   rl   )Úpre_munchifyÚseenr   r   rn   Â  s   ÿz%munchify.<locals>.pre_munchify_cyclesc                    sZ   t | tƒr	ˆ i ƒS t | tƒrt| ƒƒ S t | tƒr+t| dt| ƒƒ}|‡fdd„| D ƒƒS | S )NÚ_makec                 3   s   � | ]	}ˆ |ƒd  V  qdS )r   Nr   ©r0   Úitem)rn   r   r   Ú	<genexpr>Ö  s   € z1munchify.<locals>.pre_munchify.<locals>.<genexpr>)rM   r   r*   r@   ÚtupleÚgetattr©rk   Ztype_factory)rc   rn   r   r   rs   Í  s   



zmunchify.<locals>.pre_munchifyc                    s~   t ˆ tƒr|  ‡‡ fdd„ˆ  ¡ D ƒ¡ | S t ˆ tƒr)|  ‡fdd„ˆ D ƒ¡ | S t ˆ tƒr=t| ˆ ƒD ]	\}}ˆ||ƒ q3| S )Nc                 3   s    � | ]}|ˆ ˆ| ƒfV  qd S r   r   ©r0   r   )ro   rk   r   r   rx   Þ  ó   € z2munchify.<locals>.post_munchify.<locals>.<genexpr>c                 3   ó   � | ]}ˆ |ƒV  qd S r   r   rv   )ro   r   r   rx   à  ó   € ©rM   r   r   r+   r*   Úextendry   Úzip)rl   rk   Zitem_partialrw   )ro   rm   ©rk   r   rm   Ú  ó   

ú
üzmunchify.<locals>.post_munchify©r(   )Úxrc   r   )rc   ro   rm   rs   rn   rt   r   r   ¦  s   r   c                    s8   t ƒ ‰‡ ‡‡fdd„‰‡fdd„‰‡ ‡fdd„‰ ˆ| ƒS )a   Recursively converts a Munch into a dictionary.

        >>> b = Munch(foo=Munch(lol=True), hello=42, ponies='are pretty!')
        >>> sorted(unmunchify(b).items())
        [('foo', {'lol': True}), ('hello', 42), ('ponies', 'are pretty!')]

        unmunchify will handle intermediary dicts, lists and tuples (as well as
        their subclasses), but ymmv on custom datatypes.

        >>> b = Munch(foo=['bar', Munch(lol=True)], hello=42,
        ...         ponies=('are pretty!', Munch(lies='are trouble!')))
        >>> sorted(unmunchify(b).items()) #doctest: +NORMALIZE_WHITESPACE
        [('foo', ['bar', {'lol': True}]), ('hello', 42), ('ponies', ('are pretty!', {'lies': 'are trouble!'}))]

        nb. As dicts are not hashable, they cannot be nested in sets/frozensets.
    c                    s@   zˆt | ƒ W S  ty   Y nw ˆ| ƒ ˆt | ƒ< }ˆ || ƒS r   rp   rr   )Úpost_unmunchifyÚpre_unmunchifyrt   r   r   Úunmunchify_cyclesÿ  s   ÿ
z%unmunchify.<locals>.unmunchify_cyclesc                    sX   t | tƒrtƒ S t | tƒrt| ƒƒ S t | tƒr*t| dt| ƒƒ}|‡ fdd„| D ƒƒS | S )Nru   c                 3   r~   r   r   rv   ©r‰   r   r   rx     r   z5unmunchify.<locals>.pre_unmunchify.<locals>.<genexpr>)rM   r   r(   r*   r@   ry   rz   r{   rŠ   r   r   rˆ     s   



z"unmunchify.<locals>.pre_unmunchifyc                    s~   t ˆ tƒr|  ‡ ‡fdd„ˆ  ¡ D ƒ¡ | S t ˆ tƒr)|  ‡fdd„ˆ D ƒ¡ | S t ˆ tƒr=t| ˆ ƒD ]	\}}ˆ||ƒ q3| S )Nc                 3   s    � | ]}|ˆˆ | ƒfV  qd S r   r   r|   )rk   r‰   r   r   rx     r}   z6unmunchify.<locals>.post_unmunchify.<locals>.<genexpr>c                 3   r~   r   r   )r0   r   rŠ   r   r   rx     r   r€   )rl   rk   Zvalue_partialÚvalue)r‡   r‰   rƒ   r   r‡     r„   z#unmunchify.<locals>.post_unmunchifyr…   )r†   r   )r‡   rˆ   rt   r‰   r   r   ê  s
   r   c                 K   s   t j| fi |¤ŽS )zé Serializes this Munch to JSON. Accepts the same keyword options as `json.dumps()`.

            >>> b = Munch(foo=Munch(lol=True), hello=42, ponies='are pretty!')
            >>> json.dumps(b) == b.toJSON()
            True
        )ÚjsonÚdumps)r   Úoptionsr   r   r   ÚtoJSON0  s   r�   c                    s"   ‡ ‡‡fdd„}t t |¡|d�S )z> Deserializes JSON to Munch or any of its subclasses.
        c                    ó   ˆˆ | f i ˆ¤ŽS r   r   ©r<   ©r   r;   r   r   r   r`   <  ó    zfromJSON.<locals>.<lambda>rb   )r   rŒ   Úloads)r;   Ústreamr   r   rc   r   r’   r   ÚfromJSON9  s   r–   )ÚRepresenterÚSafeRepresenterc                 c   s&   � t ƒ }|V  |  |¡}| |¡ dS )a-   PyYAML support for Munches using the tag `!munch` and `!munch.Munch`.

            >>> import yaml
            >>> yaml.load('''
            ... Flow style: !munch.Munch { Clark: Evans, Brian: Ingerson, Oren: Ben-Kiki }
            ... Block style: !munch
            ...   Clark : Evans
            ...   Brian : Ingerson
            ...   Oren  : Ben-Kiki
            ... ''') #doctest: +NORMALIZE_WHITESPACE
            {'Flow style': Munch(Brian='Ingerson', Clark='Evans', Oren='Ben-Kiki'),
             'Block style': Munch(Brian='Ingerson', Clark='Evans', Oren='Ben-Kiki')}

            This module registers itself automatically to cover both Munch and any
            subclasses. Should you want to customize the representation of a subclass,
            simply register it with PyYAML yourself.
        N)r   Úconstruct_mappingr   )ÚloaderÚnodeÚdatar‹   r   r   r   Ú	from_yamlK  s
   €
r�   c                 C   s
   |   |¡S )a<   Converts Munch to a normal mapping node, making it appear as a
            dict in the YAML output.

            >>> b = Munch(foo=['bar', Munch(lol=True)], hello=42)
            >>> import yaml
            >>> yaml.safe_dump(b, default_flow_style=True)
            '{foo: [bar, {lol: true}], hello: 42}\n'
        )Úrepresent_dict©Údumperrœ   r   r   r   Úto_yaml_safeb  s   
	r¡   c                 C   s   |   d|¡S )a   Converts Munch to a representation node.

            >>> b = Munch(foo=['bar', Munch(lol=True)], hello=42)
            >>> import yaml
            >>> yaml.dump(b, default_flow_style=True)
            '!munch.Munch {foo: [bar, !munch.Munch {lol: true}], hello: 42}\n'
        ú!munch.Munch)Úrepresent_mappingrŸ   r   r   r   Úto_yamlm  s   r¤   )Ú
BaseLoaderÚ
FullLoaderÚ
SafeLoaderÚLoaderÚUnsafeLoaderZDangerLoaderz!munch©r¨   r¢   c                 K   sB   t ddd�}| |¡ d|vrtj| fi |¤ŽS tj| fi |¤ŽS )aæ   Serializes this Munch to YAML, using `yaml.safe_dump()` if
            no `Dumper` is provided. See the PyYAML documentation for more info.

            >>> b = Munch(foo=['bar', Munch(lol=True)], hello=42)
            >>> import yaml
            >>> yaml.safe_dump(b, default_flow_style=True)
            '{foo: [bar, {lol: true}], hello: 42}\n'
            >>> b.toYAML(default_flow_style=True)
            '{foo: [bar, {lol: true}], hello: 42}\n'
            >>> yaml.dump(b, default_flow_style=True)
            '!munch.Munch {foo: [bar, !munch.Munch {lol: true}], hello: 42}\n'
            >>> b.toYAML(Dumper=yaml.Dumper, default_flow_style=True)
            '!munch.Munch {foo: [bar, !munch.Munch {lol: true}], hello: 42}\n'

        é   F)ÚindentÚdefault_flow_styleÚDumper)r(   r   ÚyamlÚ	safe_dumpÚdump)r   rŽ   Úoptsr   r   r   ÚtoYAML†  s
   
r³   c                    s4   ‡ ‡‡fdd„}ˆ  dtj¡}ttj||d�|d�S )Nc                    r�   r   r   r‘   r’   r   r   r`   ž  r“   zfromYAML.<locals>.<lambda>r¨   rª   rb   )Úpopr¯   r¦   r   Úload)r;   r•   r   r   rc   Úloader_classr   r’   r   ÚfromYAML�  s   r·   ).rH   Úcollections.abcr   Úimportlib.metadataÚmetadataZimportlib_metadataÚImportErrorÚversionr'   Ú__version__ÚPackageNotFoundErrorry   ÚmapÚintÚsplitÚVERSIONÚ
ValueErrorÚ__all__r(   r   rL   r   r	   r
   r   r   rŒ   Z
simplejsonr�   r–   rK   r¯   Zyaml.representerr—   r˜   r�   r¡   r¤   Zloader_namerz   Z	LoaderClsÚadd_constructorÚadd_representerÚadd_multi_representerr³   r·   r   r   r   r   Ú<module>   s|    þþ*ÿ \
D)$D@ÿ	ÿ
ÿ