o
    
vi}>                     @   sJ  d dl Z d dlZd dlmZmZ d dlZd dlZd dlZd dlm	Z	m
Z
mZmZmZmZ d dlZddlmZmZ edZede	dZG d	d
 d
ZedddededefddZedddededefddZedddededefddZG dd dZG dd dZG dd dZG dd deZdedefdd Z G d!d" d"Z!ee"fe#fd#d$Z$d%edefd&d'Z%	(dGde
eee f d)e&defd*d+Z'd,ede(fd-d.Z)dedefd/d0Z*	1dHd(dd2d3ee d4ed5e&d6edef
d7d8Z+d9ed:edefd;d<Z,e-d=fdedefd>d?Z.	dId@dAdBeeef dCedDedefdEdFZ/dS )J    N)	lru_cachewraps)CallableUnionIterableTypeVarcastAny   )PyparsingDeprecationWarningPyparsingDiagnosticWarning\   C)boundc                   @   sZ   e Zd ZU dZg Zee ed< g Zee ed< dZ	e
dd Ze
dd Ze
d	d Zd
S )__config_flagsz=Internal class for defining compatibility and debugging flags
_all_names_fixed_namesconfigurationc                 C   sx   || j v r$tj| j d| d| j dtt| |  dtdd d S || j	v r1t
| || d S td| j d|)N. z is z and cannot be overridden   
stacklevelzno such )r   warningswarn__name__
_type_descstrgetattrupperr   r   setattr
ValueError)clsdnamevalue r%   M/home/air/biblejyuku/back/venv/lib/python3.10/site-packages/pyparsing/util.py_set   s   
,
z__config_flags._setc                 C      |  |dS )NTr'   r"   namer%   r%   r&   <lambda>'       z__config_flags.<lambda>c                 C   r(   )NFr)   r*   r%   r%   r&   r,   (   r-   N)r   
__module____qualname____doc__r   listr   __annotations__r   r   classmethodr'   enabledisabler%   r%   r%   r&   r      s   
 
r      )maxsizelocstrgreturnc                 C   sF   |}d|   k rt |k rn n
|| d  dkrdS | |dd|  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.
    r   r
   
)lenrfind)r8   r9   sr%   r%   r&   col+   s   Br?   c                 C   s   | dd| d S )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;   r   r
   )count)r8   r9   r%   r%   r&   lineno<   s   rA   c                 C   sB   | dd| }|d| }|dkr||d | S ||d d S )zh
    Returns the line of text containing loc within a string, counting newlines as line separators.
    r;   r   r
   N)r=   find)r8   r9   last_crnext_crr%   r%   r&   lineJ   s   (rE   c                   @      e Zd Zdd ZdS )_UnboundedCachec                    sp   i   j t  | _fdd} fdd} fdd}d | _t|| | _ t|| | _t|| | _d S )Nc                    
    |S Nr%   _key	cache_getnot_in_cacher%   r&   getZ      
z%_UnboundedCache.__init__.<locals>.getc                    s   | |< d S rI   r%   rK   rL   r$   cacher%   r&   set_]      z&_UnboundedCache.__init__.<locals>.set_c                           d S rI   clearrK   rS   r%   r&   rY   `   rV   z'_UnboundedCache.__init__.<locals>.clear)rP   objectrO   sizetypes
MethodTypesetrY   )selfrP   rU   rY   r%   )rT   rN   rO   r&   __init__U   s   z_UnboundedCache.__init__Nr   r.   r/   ra   r%   r%   r%   r&   rG   T       rG   c                   @   rF   )
_FifoCachec                    sz   i  | _ t  | _ j jfdd} fdd} fdd}t|| | _t|| | _t|| | _d S )Nc                    rH   rI   r%   rJ   rM   r%   r&   rP   q   rQ   z _FifoCache.__init__.<locals>.getc                    s8   | |< t  krtt  t  ks
d S d S rI   )r<   nextiterrR   )rT   	cache_popr\   r%   r&   rU   t   s   z!_FifoCache.__init__.<locals>.set_c                    rW   rI   rX   rZ   rS   r%   r&   rY   z   rV   z"_FifoCache.__init__.<locals>.clear)	r\   r[   rO   rP   popr]   r^   r_   rY   )r`   r\   rP   rU   rY   r%   )rT   rN   rg   rO   r\   r&   ra   j   s   z_FifoCache.__init__Nrb   r%   r%   r%   r&   rd   i   rc   rd   c                   @   s8   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d ZdS )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                 C   s   || _ i | _i | _d S rI   )	_capacity_active_memory)r`   capacityr%   r%   r&   ra      s   
zLRUMemo.__init__c                 C   s<   z| j | W S  ty   | j|| j|< | j|  Y S w rI   )rk   KeyErrorrl   rh   r`   rL   r%   r%   r&   __getitem__   s   zLRUMemo.__getitem__c                 C   s   | j |d  || j|< d S rI   )rl   rh   rk   )r`   rL   r$   r%   r%   r&   __setitem__   s   zLRUMemo.__setitem__c                 C   sd   z| j |}W n
 ty   Y d S w t| jd | jd   }|D ]}| j| q"|| j|< d S Nr
   )rk   rh   rn   r1   rl   rj   )r`   rL   r$   oldest_keyskey_to_deleter%   r%   r&   __delitem__   s   zLRUMemo.__delitem__c                 C   s   | j   | j  d S rI   )rk   rY   rl   r`   r%   r%   r&   rY      s   
zLRUMemo.clearN)	r   r.   r/   r0   ra   rp   rq   ru   rY   r%   r%   r%   r&   ri      s    ri   c                   @   s   e Zd ZdZdd ZdS )UnboundedMemoz<
    A memoizing mapping that retains all deleted items
    c                 C   s   d S rI   r%   ro   r%   r%   r&   ru      s   zUnboundedMemo.__delitem__N)r   r.   r/   r0   ru   r%   r%   r%   r&   rw      s    rw   r>   c                 C   s:   dD ]
}|  |t| } q|  dd} |  dd} t| S )Nz\^-[]r;   z\n	z\t)replace_bslashr   )r>   cr%   r%   r&   _escape_regex_range_chars   s
   r|   c                   @   s,   e Zd ZdZd	ddZdedefddZdS )
_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                 C   s   d| _ t | _d| _d S )Nr   )prev	itertoolsr@   counterr$   rv   r%   r%   r&   ra      s   

z_GroupConsecutive.__init__charc                 C   s4   t |}|| j| _}|| dkrt| j| _| jS rr   )ordr   re   r   r$   )r`   r   c_intr   r%   r%   r&   __call__   s
   z_GroupConsecutive.__call__)r:   N)r   r.   r/   r0   ra   r   intr   r%   r%   r%   r&   r}      s    
r}   c                 C   s2   t | |rdS zt|  W dS  |y   Y dS w )NFT)
isinstancerf   )obj	_str_type_iter_exceptionr%   r%   r&   _is_iterable   s   

r   r{   c                 C   s   | dv r	d|  S | S )Nz\^-][\r%   )r{   r%   r%   r&   _escape_re_range_char   s   r   T	re_escapec              	      s
  |rt  ndd  g }tt| }t|dkrwtj|t dD ]V\}}t| }}t	t
 |^ }}W d   n1 s>w   Y  ||krO| | q|tt|d krg| |  |  q| | d |  qn	 fdd	|D }d
|S )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                 S   s   | S rI   r%   )ssr%   r%   r&   r,     s    z,_collapse_string_to_ranges.<locals>.<lambda>   rL   Nr
   -c                    s   g | ]} |qS r%   r%   ).0r{   escape_re_range_charr%   r&   
<listcomp>E  s    z._collapse_string_to_ranges.<locals>.<listcomp> )r   sortedr_   r<   r   groupbyr}   re   
contextlibsuppressr!   appendchrr   join)r>   r   rets_charsrK   charsfirstlastr%   r   r&   _collapse_string_to_ranges   s*   (
r   llc                 C   sL   g }| D ]}t |tr|| qt |tr|t| q|| q|S rI   )r   r   r   r   extend_flatten)r   r   ir%   r%   r&   r   J  s   

r   c                 C   sR   | dkrdS |   rt| dkrtt| dS | dr'tt| dd  dS | S )N0 r      )uxr
      )isdigitr<   r   r   
startswithr>   r%   r%   r&   !_convert_escaped_numerics_to_charY  s   
r   r   non_capturing_groups_level	word_list	max_levelr   r   c             
   C   sz  dt t fdd}|dkr| stdd| v rtdn| s dS t i | } |dkrQtd	d
 | D rCdtdd | D tddS dddd
 | D  dS g }d}|rYdnd}|t| D ]\}}	|| d}t	
|}d}
d|	v r~d}
|	d t|	dkrtdd
 |	D r|| dddd
 |	D  d|
  qa||k rtt|	|||d d}|| d| | d|
  qatdd
 |	D r|| dddd
 |	D  d|
  qa|	jtdd || d| ddd
 |	D  d|
  qa|	r2t	
|	d }t|dkr&|
r&|| d| | d|
  qa|| | |
  qa|| qad|S )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                 s   sp    t | dkr&tj| dd dD ]\}}|tdd |D t ddfV  qd S | d	 d	 | d	 dd  gfV  d S )
Nr
   c                 S   s   | d d S rr   r%   r   r%   r%   r&   r,   t  r-   zOmake_compressed_re.<locals>.get_suffixes_from_common_prefixes.<locals>.<lambda>r   c                 S   s   g | ]}|d d qS r
   Nr%   r   r>   r%   r%   r&   r   u  s    zQmake_compressed_re.<locals>.get_suffixes_from_common_prefixes.<locals>.<listcomp>TrL   reverser   )r<   r   r   r   )r   prefixsuffixesr%   r%   r&   !get_suffixes_from_common_prefixesr  s    $z=make_compressed_re.<locals>.get_suffixes_from_common_prefixesr
   z&no words given to make_compressed_re()r   z%word list cannot contain empty stringr   c                 s   s    | ]	}t |d kV  qdS r   r<   r   wdr%   r%   r&   	<genexpr>      z%make_compressed_re.<locals>.<genexpr>|c                 S   s   g | ]}t |qS r%   reescaper   r%   r%   r&   r     s    z&make_compressed_re.<locals>.<listcomp>Tr   [c                 s       | ]}t |V  qd S rI   r|   r   r%   r%   r&   r         ]z?:?c                 s       | ]	}t |d kV  qdS r   r   r   r%   r%   r&   r     r   c                 s   r   rI   r   r   r%   r%   r&   r     r   r   ()c                 s   r   r   r   r   r%   r%   r&   r     r   c                 s   r   rI   r   r   r%   r%   r&   r     r   c                 s   s    | ]}t |V  qd S rI   r   r   r%   r%   r&   r     s    )r1   r   r!   fromkeysanyr   r   r<   r   r   r   removeallmake_compressed_resort)r   r   r   r   r   r   sepncgroupinitialr   trailing	suffix_resuffixr%   r%   r&   r   c  sn   


" "& 
r   compat_namefnc                    s   t ddgttjd d kr!t fdd}nt fdd}dj d|_ |_j|_t	t
jrFj|_nt	trVtd	rVjj|_nd |_j|_tt|S )
N__func__r`   r
   c                    s2   t j djtdd | g|R i |S Nz deprecated - use r   r   r   r   r   r   )r`   argskwargsr   r   r%   r&   _inner  s   z replaced_by_pep8.<locals>._innerc                     s*   t j djtdd | i |S r   r   )r   r   r   r%   r&   r     s   z6
        .. deprecated:: 3.0.0
           Use :class:`z` instead
        ra   )r   r1   inspect	signature
parametersr   r   r0   r2   r   r]   FunctionType__kwdefaults__typehasattrra   r/   r   r   )r   r   r   r%   r   r&   replaced_by_pep8  s$   



r   z([a-z])([A-Z])c                 C   s   | d| } |  S )Nz\1_\2)sublower)r>   _re_sub_patternr%   r%   r&   _to_pep8_name  s   r   r   )new_namer   arg_namer   c                C   sF   || v r|p	t |}tj|d|tdd | | S || |< | | S )Nz argument is deprecated, use r   )categoryr   )r   r   r   r   )r   r   default_valuer   r%   r%   r&   deprecate_argument  s   r   )T)r   rI   )0r   r   	functoolsr   r   r   r   r]   typingr   r   r   r   r   r	   r   r   r   r   rz   r   r   r   r   r?   rA   rE   rG   rd   ri   dictrw   r|   r}   bytes	Exceptionr   r   boolr   r1   r   r   r   r   compiler   r   r%   r%   r%   r&   <module>   s    	(		%
X
_-
