Your IP : 216.73.216.52


Current Path : /snap/certbot/current/lib64/python3.12/site-packages/pyparsing/__pycache__/
Upload File :
Current File : //snap/certbot/current/lib64/python3.12/site-packages/pyparsing/__pycache__/util.cpython-312.pyc

�

tI�i}>���ddlZddlZddlmZmZddlZddlZddlZddlm	Z	m
Z
mZmZm
Z
mZddlZddlmZmZed�Zede	��ZGd	�d
�Zed��d
ededefd��Zed��d
ededefd��Zed��d
ededefd��ZGd�d�ZGd�d�ZGd�d�ZGd�de�Zdedefd�Z Gd�d�Z!ee"fe#fd�Z$d edefd!�Z%	d9de
eeefd#e&defd$�Z'd%ede(fd&�Z)dedefd'�Z*	d:d"dd(�d)eed*ed+e&d,edef
d-�Z+d.ed/edefd0�Z,ejZd1�fdedefd2�Z.	d;d3d4�d5eeefd6ed7edefd8�Z/y)<�N)�	lru_cache�wraps)�Callable�Union�Iterable�TypeVar�cast�Any�)�PyparsingDeprecationWarning�PyparsingDiagnosticWarning�\�C)�boundc�r�eZdZUdZgZeeed<gZeeed<dZ	e
d��Ze
d��Ze
d��Z
y)	�__config_flagsz=Internal class for defining compatibility and debugging flags�
_all_names�_fixed_names�
configurationc�H�||jvr^tj|j�d|�d|j�dtt
||��j��d�td��y||jvrt|||�ytd|j�d|����)N�.� z is z and cannot be overridden���
stacklevelzno such )r�warnings�warn�__name__�
_type_desc�str�getattr�upperr
r�setattr�
ValueError)�cls�dname�values   �~/build/snapcraft-certbot-53a6961353a63169611ae8a78f6bfa4f/parts/certbot/install/lib/python3.12/site-packages/pyparsing/util.py�_setz__config_flags._sets����C�$�$�$��M�M��<�<�.��%���#�.�.�)9��c�'�#�u�BU�>V�>\�>\�>^�=_�+�-�*��	
�
��C�N�N�"��C���&��x����'7�q��	�B�C�C�c�&�|j|d�S)NT�r)�r%�names  r(�<lambda>z__config_flags.<lambda>'s��3�8�8�D�$�+?�r*c�&�|j|d�S)NFr,r-s  r(r/z__config_flags.<lambda>(s��C�H�H�T�5�,A�r*N)r�
__module__�__qualname__�__doc__r�listr �__annotations__rr�classmethodr)�enable�disable�r*r(rrsR��G��J��S�	�� �L�$�s�)� � �J��D��D��?�
@�F��A�B�Gr*r�)�maxsize�loc�strg�returnc�z�|}d|cxkrt|�krnn
||dz
dk(rdS||jdd|�z
S)a�
    Returns current column within a string, counting newlines as line separators.
    The first column is number 1.

    Note: the default parsing behavior is to expand tabs in the input string
    before starting the parsing process.  See
    :meth:`ParserElement.parse_string` for more
    information on parsing strings containing ``<TAB>`` s, and suggested
    methods to maintain a consistent view of the parsed string, the parse
    location, and line and column positions within the parsed string.
    rr�
)�len�rfind)r<r=�ss   r(�colrD+sG��	
�A��C� �#�a�&� �Q�s�Q�w�Z�4�%7�1�X�S�1�7�7�4�QR�TW�CX�=X�Xr*c�.�|jdd|�dzS)a�Returns current line number within a string, counting newlines as line separators.
    The first line is number 1.

    Note - the default parsing behavior is to expand tabs in the input string
    before starting the parsing process.  See :meth:`ParserElement.parse_string`
    for more information on parsing strings containing ``<TAB>`` s, and
    suggested methods to maintain a consistent view of the parsed string, the
    parse location, and line and column positions within the parsed string.
    r@rr)�count)r<r=s  r(�linenorG<s���:�:�d�A�s�#�a�'�'r*c�v�|jdd|�}|jd|�}|dk\r||dz|S||dzdS)zh
    Returns the line of text containing loc within a string, counting newlines as line separators.
    r@rrN)rB�find)r<r=�last_cr�next_crs    r(�linerLJsM��
�j�j��q�#�&�G��i�i��c�"�G�*1�Q�,�4��!��g�&�O�D��1���<O�Or*c��eZdZd�Zy)�_UnboundedCachec�����i��j�t�x|_���fd�}�fd�}�fd�}d|_t	j
||�|_t	j
||�|_t	j
||�|_y)Nc����|��S�Nr9��_�key�	cache_get�not_in_caches  ��r(�getz%_UnboundedCache.__init__.<locals>.getZ�����S�,�/�/r*c���|�|<yrQr9)rSrTr'�caches   �r(�set_z&_UnboundedCache.__init__.<locals>.set_]s����E�#�Jr*c�&���j�yrQ��clear�rSrZs �r(r^z'_UnboundedCache.__init__.<locals>.clear`�����K�K�Mr*)rW�objectrV�size�types�
MethodType�setr^)�selfrWr[r^rZrUrVs    @@@r(�__init__z_UnboundedCache.__init__Ust������I�I�	�+1�8�3���L�	0�	�	���	��#�#�C��.����#�#�D�$�/����%�%�e�T�2��
r*N�rr1r2rgr9r*r(rNrNTs��3r*rNc��eZdZd�Zy)�
_FifoCachec�8������i��|_t�x|_��j��j���fd�}���fd�}�fd�}tj||�|_tj||�|_tj||�|_y)Nc����|��SrQr9rRs  ��r(rWz _FifoCache.__init__.<locals>.getqrXr*c���|�|<t���kDr*�tt����t���kDr�)yyrQ)rA�next�iter)rSrTr'rZ�	cache_poprbs   ���r(r[z!_FifoCache.__init__.<locals>.set_ts7����E�#�J��e�*�t�#��$�t�E�{�+�,��e�*�t�#r*c�&���j�yrQr]r_s �r(r^z"_FifoCache.__init__.<locals>.clearzr`r*)	rbrarVrW�poprcrdrer^)	rfrbrWr[r^rZrUrprVs	 `   @@@@r(rgz_FifoCache.__init__js}�������	�+1�8�3���L��I�I�	��I�I�	�	0�	-�	��#�#�C��.����#�#�D�$�/����%�%�e�T�2��
r*Nrhr9r*r(rjrjis��3r*rjc�.�eZdZdZd�Zd�Zd�Zd�Zd�Zy)�LRUMemoz�
    A memoizing mapping that retains `capacity` deleted items

    The memo tracks retained items by their access order; once `capacity` items
    are retained, the least recently used item is discarded.
    c�.�||_i|_i|_yrQ)�	_capacity�_active�_memory)rf�capacitys  r(rgzLRUMemo.__init__�s��!��������r*c��	|j|S#t$r:|jj|�|j|<|j|cYSwxYwrQ)rw�KeyErrorrxrr�rfrTs  r(�__getitem__zLRUMemo.__getitem__�sQ��	%��<�<��$�$���	%� $��� 0� 0�� 5�D�L�L����<�<��$�$�	%�s��AA�Ac�Z�|jj|d�||j|<yrQ)rxrrrw)rfrTr's   r(�__setitem__zLRUMemo.__setitem__�s$��������d�#�!����S�r*c��	|jj|�}t|j�d|jdz}|D]}|jj|��||j|<y#t
$rYywxYw�Nr)rwrrr4rxrvr{)rfrTr'�oldest_keys�
key_to_deletes     r(�__delitem__zLRUMemo.__delitem__�s���	&��L�L�$�$�S�)�E��t�|�|�,�-D����!�1C�/D�E�K�!,�
0�
���� � ��/�
0� %�D�L�L����
�	��	�s�A5�5	B�Bc�l�|jj�|jj�yrQ)rwr^rx�rfs r(r^z
LRUMemo.clear�s"�������������r*N)	rr1r2r3rgr}rr�r^r9r*r(rtrt�s ����
%�"�	&�r*rtc��eZdZdZd�Zy)�
UnboundedMemoz<
    A memoizing mapping that retains all deleted items
    c��yrQr9r|s  r(r�zUnboundedMemo.__delitem__�s��r*N)rr1r2r3r�r9r*r(r�r��s���
r*r�rCc��dD]}|j|t|z�}�|jdd�}|jdd�}t|�S)Nz\^-[]r@z\n�	z\t)�replace�_bslashr )rC�cs  r(�_escape_regex_range_charsr��sN��
�&��
�I�I�a��1��%��&�	�	�	�$���A�	�	�	�$���A��q�6�Mr*c�(�eZdZdZdd�Zdedefd�Zy)�_GroupConsecutivea�
    Used as a callable `key` for itertools.groupby to group
    characters that are consecutive:

    .. testcode::

       from itertools import groupby
       from pyparsing.util import _GroupConsecutive

       grouped = groupby("abcdejkmpqrs", key=_GroupConsecutive())
       for index, group in grouped:
           print(tuple([index, list(group)]))

    prints:

    .. testoutput::

       (0, ['a', 'b', 'c', 'd', 'e'])
       (1, ['j', 'k'])
       (2, ['m'])
       (3, ['p', 'q', 'r', 's'])
    r>Nc�R�d|_tj�|_d|_y)Nr���)�prev�	itertoolsrF�counterr'r�s r(rgz_GroupConsecutive.__init__�s����	� ���(�����
r*�charc��t|�}||jc|_}||z
dkDrt|j�|_|jSr�)�ordr�rnr�r')rfr��c_intr�s    r(�__call__z_GroupConsecutive.__call__�sB���D�	��������	�4��4�<�!���d�l�l�+�D�J��z�z�r*)r>N)rr1r2r3rgr �intr�r9r*r(r�r��s���.�
�S��S�r*r�c�L�t||�ry	t|�y#|$rYywxYw)NFT)�
isinstancero)�obj�	_str_type�_iter_exceptions   r(�_is_iterabler��s4���#�y�!����S�	�������s��#�#r�c��|dvrd|��S|S)Nz\^-][�\r9)r�s r(�_escape_re_range_charr��s���H�}�a��s�8�+�!�+r*T�	re_escapec�~�|rt}nd�}g}tt|��}t|�dkDr�t	j
|t
���D]�\}}t|�x}}tjt�5|�^}}ddd�||k(r|j||���W|tt|�dz�k(r"|j||��||������|j||��d||������n|D�	cgc]
}	||	���}}	dj|�S#1swY��xYwcc}	w)a(
    Take a string or list of single-character strings, and return
    a string of the consecutive characters in that string collapsed
    into groups, as might be used in a regular expression '[a-z]'
    character set::

        'a' -> 'a' -> '[a]'
        'bc' -> 'bc' -> '[bc]'
        'defgh' -> 'd-h' -> '[d-h]'
        'fdgeh' -> 'd-h' -> '[d-h]'
        'jklnpqrtu' -> 'j-lnp-rtu' -> '[j-lnp-rtu]'

    Duplicates get collapsed out::

        'aaa' -> 'a' -> '[a]'
        'bcbccb' -> 'bc' -> '[bc]'
        'defghhgf' -> 'd-h' -> '[d-h]'
        'jklnpqrjjjtu' -> 'j-lnp-rtu' -> '[j-lnp-rtu]'

    Spaces are preserved::

        'ab c' -> ' a-c' -> '[ a-c]'

    Characters that are significant when defining regex ranges
    get escaped::

        'acde[]-' -> r'\-\[\]ac-e' -> r'[\-\[\]ac-e]'
    c��|SrQr9)�sss r(r/z,_collapse_string_to_ranges.<locals>.<lambda>s��"�r*��rTNr�-�)r��sortedrerAr��groupbyr�rn�
contextlib�suppressr$�append�chrr��join)
rCr��escape_re_range_char�ret�s_charsrS�chars�first�lastr�s
          r(�_collapse_string_to_rangesr��sB��P�4��,��
�C� ��A���G�
�7�|�a��"�)�)�'�7H�7J�K�	�H�A�u� ��;�&�E�D��$�$�Z�0�
!� ���D�
!���}��
�
�/��6�7���S��Z�!�^�,�,��
�
�2�5�9�:�;O�PT�;U�:V�W�X�
�
�
�+�E�2�3�1�5I�$�5O�4P�Q��)	�<18�8�1�#�A�&�8��8�
�7�7�3�<��7
!�
!��29s�<D.�D:�.D7	�llc���g}|D]`}t|t�r|j|��%t|t�r|j	t|���P|j|��b|SrQ)r�r r�r�extend�_flatten)r�r��is   r(r�r�JsY��
�C�
�	���a����J�J�q�M�
��8�
$��J�J�x��{�#��J�J�q�M�	��Jr*c���|dk(ry|j�r#t|�dk(rtt|d��S|j	d�rtt|ddd��S|S)N�0�r�)�u�xr�)�isdigitrAr�r��
startswith�rCs r(�!_convert_escaped_numerics_to_charr�YsW���C�x���y�y�{�s�1�v��{��3�q�!�9�~��	
���j�	!��3�q���u�b�>�"�"��Hr*��non_capturing_groups�_level�	word_list�	max_levelr�r�c
��dttfd�}|dk(r|std��d|vrtd��|sytij|��}|dk(rpt	d�|D��rBd	jt
|D�cgc]}tj|���c}td
���Sddjd
�|D���d�Sg}d}|rdnd}|t
|��D�]�\}	}
|j|�d	}tj|	�}	d}d|
vrd}|
jd�t|
�dkD�rtd�|
D��r0|j|	�ddjd�|
D���d|�����||kr7tt
|
�|||dz��}|j|	�d|�|�d|�����td�|
D��r1|j|	�ddjd�|
D���d|�����|
jtd
��|j|	�d|�d	jd�|
D���d|�����b|
r^tj|
d�}
t|
�dkDr|r|j|	�d|�|
�d|������|j|	�|
�|������|j|	����dj|�Scc}w)z�
    Create a regular expression string from a list of words, collapsing by common
    prefixes and optional suffixes.

    Calls itself recursively to build nested sublists for each group of suffixes
    that have a shared prefix.
    �namelistc
3��K�t|�dkDrHtj|d���D],\}}|t|D�cgc]}|dd��	c}td��f���.y|dd|dddgf��ycc}w�w)Nrc��|ddSr�r9r�s r(r/zOmake_compressed_re.<locals>.get_suffixes_from_common_prefixes.<locals>.<lambda>ts��a�PR�QR�e�r*r�T�rT�reverser)rAr�r�r�)r��prefix�suffixesrCs    r(�!get_suffixes_from_common_prefixesz=make_compressed_re.<locals>.get_suffixes_from_common_prefixesrs������x�=�1��$-�$5�$5�h�O�$T�
W� ����f�X�%>��a���e�%>�C�QU�V�V�V�
W��1�+�a�.�8�A�;�q�r�?�"3�3�3��&?�s�7A2�A-�-A2rz&no words given to make_compressed_re()r�z%word list cannot contain empty stringrc3�8K�|]}t|�dkD���y�w�rN�rA��.0�wds  r(�	<genexpr>z%make_compressed_re.<locals>.<genexpr>�s����/�r�s�2�w��{�/����|Tr��[c3�2K�|]}t|����y�wrQ�r�r�s  r(r�z%make_compressed_re.<locals>.<genexpr>�s����Q��8��<�Q����]z?:�?c3�8K�|]}t|�dk(���y�wr�r��r�rCs  r(r�z%make_compressed_re.<locals>.<genexpr>�s����1�1�3�q�6�Q�;�1�r�c3�2K�|]}t|����y�wrQr�r�s  r(r�z%make_compressed_re.<locals>.<genexpr>�s����(X�!�)B�1�)E�(X�r�r��(�)c3�8K�|]}t|�dk(���y�wr�r�r�s  r(r�z%make_compressed_re.<locals>.<genexpr>�s����9�1�3�q�6�Q�;�9�r�c3�2K�|]}t|����y�wrQr�r�s  r(r�z%make_compressed_re.<locals>.<genexpr>�s����0`�RS�1J�1�1M�0`�r�c3�FK�|]}tj|����y�wrQ)�re�escaper�s  r(r�z%make_compressed_re.<locals>.<genexpr>�s����:Z�A�2�9�9�Q�<�:Z�s�!)r4r r$�fromkeys�anyr�r�r�r�rAr��remove�all�make_compressed_re�sort)r�r�r�r�r�r�r��sep�ncgroup�initialr��trailing�	suffix_re�suffixs              r(r�r�cs���4�D��I�4���{���E�F�F�
��?��D�E�E����R�[�[��+�,�I��A�~��/�Y�/�/��8�8��	�:�"��	�	�"�
�:��T�R��
��r�w�w�Q�y�Q�Q�R�RS�T�T�
�C�
�C�*�d��G�>�v�i�?P�Q�+$�����
�
�3�����)�)�G�$����
��>��H��O�O�B���x�=�1���1��1�1��
�
��i�q����(X�x�(X�!X� Y�YZ�[c�Zd�e���I�%� 2��x�(�!�-A�%��z�	!�I��J�J�'��!�G�9�Y�K�q��
�K�L��9��9�9��
�
�&�i�q����0`�W_�0`�)`�(a�ab�ck�bl�m��!�
�
�#�t�
�<��
�
�&�i�q��	�#�(�(�:Z�QY�:Z�2Z�1[�[\�]e�\f�g������8�A�;�/���v�;��?�x��J�J�'��!�G�9�V�H�A�h�Z�H�I��J�J�'��6�(�8�*�=�>��
�
�7�#�W+$�X�7�7�3�<���k;s�;K�compat_name�fnc�B���t�d���dgttj��j�ddk(rt����fd��}nt����fd��}d�j�d�|_�|_�j|_t�tj�r�j|_n?t�t�r(t�d�r�jj|_nd|_�j |_t#t$|�S)	N�__func__rfrc�r��tj��d�j��td���|g|��i|��S�Nz deprecated - use r�r�rrrr)rf�args�kwargsr�rs   ��r(�_innerz replaced_by_pep8.<locals>._inner�s?����M�M��/�!3�B�K�K�?�C�+��
�
�d�,�T�,�V�,�,r*c�j��tj��d�j��td���|i|��Srr)rrr�rs  ��r(rz replaced_by_pep8.<locals>._inner�s:����M�M��/�!3�B�K�K�?�C�+��
�
�t�&�v�&�&r*z6
        .. deprecated:: 3.0.0
           Use :class:`z` instead
        rg)r!r4�inspect�	signature�
parametersrrr3r5r�rc�FunctionType�__kwdefaults__�type�hasattrrgr2r	r)r�rrs`` r(�replaced_by_pep8r�s���
��Z��	$�B�	�x�4��)�)�"�-�8�8�9�"�1�=�=�	�r��	-�
�	-�
�r��	'�
�	'�����}�%	��F�N�"�F�O��/�/�F���"�e�(�(�)� "� 1� 1���	�B��	�'�"�j�"9� "��� :� :��� $����/�/�F����6�?�r*z([a-z])([A-Z])c�F�|jd|�}|j�S)Nz\1_\2)�sub�lower)rC�_re_sub_patterns  r(�
_to_pep8_namer�s �����H�a�(�A��7�7�9�r*r�)�new_namer�arg_namerc��||vr5|xst|�}tj|�d|��td��||S|||<||S)Nz argument is deprecated, use r)�categoryr)rrrr)rr�
default_valuers    r(�deprecate_argumentr�s`���6���6�}�X�6���
�
��l�7��|�D�0��	
��(���)��x���(��r*)T)r�rQ)0r�r��	functoolsrrr
r�rc�typingrrrrr	r
rrr
r�r�rrr�r rDrGrLrNrjrt�dictr�r�r��bytes�	Exceptionr�r��boolr�r4r�r�r�r�compilerrr9r*r(�<module>r$si���	�&����@�@��M�

�b�'���C�x� ��C�C�4�3��
Y�S�
Y��
Y��
Y��
Y� �3��
(��
(�3�
(�3�
(��
(��3��P�c�P��P��P��P�3�3�*3�3�2%�%�P
�D�
������"�"�J"%�e��i�
�,�S�,�S�,�
59�U��S�(�3�-�
� �U�-1�U��U�p���d��
��
��
��\�"&��\���}�\��\��	\�

�\�	�
\�~*�#�*�1�*��*�Z+5�"�*�*�5F�*G��S��C��:>��RT����c��N��&)��LO���r*