
    Xh,              	          U d dl Z d dlZd dlmZ d dlmZ d dlmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZ d dlZd dlZd dlZ ej.                  d      Zej2                  ed<   ej7                   ej8                                ej;                  ej<                          e       Z  ed      Z!d9ded	e
e   d
e
e   defdZ"dedee#ef   dedefdZ$ edd      Z% G d d      Z& G d de&      Z'	 d dl(Z(dZ)ejV                  dk\  rd dl,m-Z. d dl/m0Z1 nd dl.Z.d dl1Z1 ejd                  d      Z3de#deee4e4f   e	e4   f   fdZ5dZ6e6dz   Z7de#d ee#   de8fd!Z9de#de8fd"Z:de#de8fd#Z;d$ee!   de	e!   fd%Z< G d& d'e&      Z=d( Z>	 d dl?Z?dZ@ G d) d*      ZA G d+ d,eB      ZCded-edefd.ZDd/ed0edefd1ZEd2 ZFd
ede
e'   defd3ZGd4e4d5e4de	ee4e4f      fd6ZH G d7 d8ee!         ZIy# e*$ r dZ)Y w xY w# e*$ r dZ@Y pw xY w):    N)product)deque)CallableIteratorListOptionalTupleTypeTypeVarUnionDictAnySequenceIterableAbstractSetlarkloggerTseqkeyvaluereturnc                     i }| D ]/  }| ||      n|}| ||      n|}	 ||   j                  |       1 |S # t        $ r	 |g||<   Y Ew xY wN)appendKeyError)r   r   r   ditemkvs          >/var/www/html/myenv/lib/python3.12/site-packages/lark/utils.pyclassifyr"      sl    A /CI!-E$KD	aDKKN	 H  	3AaD	s   9A
Adata	namespacememoc           
      D   t        | t              rYd| v r|| d      }|j                  | |      S d| v r|| d      S | j                         D ci c]  \  }}|t	        |||       c}}S t        | t
              r| D cg c]  }t	        |||       c}S | S c c}}w c c}w )N__type__@)
isinstancedictdeserializeitems_deserializelist)r#   r$   r%   class_r   r   s         r!   r-   r-   #   s    $tJ/0F%%dD11D[S	?"KO::<XZS%L	488XX	D$	BFGUIt4GGK YGs   B>B_T	Serialize)boundc            	       t    e Zd ZdZdedefdZddeeef   fdZ	e
dee   deeef   d	eeef   defd
       Zy)r1   al  Safe-ish serialization interface that doesn't rely on Pickle

    Attributes:
        __serialize_fields__ (List[str]): Fields (aka attributes) to serialize.
        __serialize_namespace__ (list): List of classes that deserialization is allowed to instantiate.
                                        Should include all field types that aren't builtin types.
    types_to_memoizer   c                 Z    t        |      }| j                  |      |j                         fS r   )SerializeMemoizer	serialize)selfr4   r%   s      r!   memo_serializezSerialize.memo_serialize;   s(     !12~~d#T^^%555    Nc           
      <   |r.|j                  |       rd|j                  j                  |       iS t        | d      }|D ci c]  }|t	        t        | |      |       }}t        |       j                  |d<   t        | d      r| j	                  ||       |S c c}w )Nr(   __serialize_fields__r'   
_serialize)in_typesmemoizedgetgetattrr=   type__name__hasattr)r8   r%   fieldsfress        r!   r7   zSerialize.serialize?   s    DMM$'**401156>DEq*WT1-t44EEt*--J4&OOC&
	 Fs   Bclsr#   r%   c           
      j   t        | dg       }|D ci c]  }|j                  | }}t        | d      }d|v r||d      S | j                  |       }|D ]  }	 t        ||t	        ||   ||               t        |d      r|j	                          |S c c}w # t
        $ r}t        d| |      d }~ww xY w)N__serialize_namespace__r<   r(   zCannot find key for classr-   )rA   rC   __new__setattrr-   r   rD   )	rH   r#   r%   r$   crE   instrF   es	            r!   r+   zSerialize.deserializeJ   s    C!:B?	+45aQZZ\5	545$;S	?"{{3 	DADad1gy$!GH	D 4(# 6  D:CCCDs   BB	B2 B--B2r   )rC   
__module____qualname____doc__r   r   r9   r   strr7   classmethodr
   r0   intr+    r:   r!   r1   r1   2   ss    6t 6 6	S#X 	 b c3h tCH~ RT  r:   c                       e Zd ZdZdZdeddfdZdedefdZ	de
eef   fd	Zed
e
eef   de
eef   de
eef   de
eef   fd       Zy)r6   z<A version of serialize that memoizes objects to reduce space)r?   r4   r   Nc                 B    t        |      | _        t               | _        y r   )tupler4   
Enumeratorr?   )r8   r4   s     r!   __init__zSerializeMemoizer.__init__f   s     %&6 7"r:   r   c                 .    t        || j                        S r   )r)   r4   )r8   r   s     r!   r>   zSerializeMemoizer.in_typesj   s    %!6!677r:   c                 J    t        | j                  j                         d       S r   )r=   r?   reversedr8   s    r!   r7   zSerializeMemoizer.serializem   s    $--002D99r:   r#   r$   r%   c                     t        |||      S r   )r-   )rH   r#   r$   r%   s       r!   r+   zSerializeMemoizer.deserializep   s    D)T22r:   )rC   rP   rQ   rR   r<   r   r[   r1   boolr>   r   rU   r   r7   rT   rS   r+   rV   r:   r!   r6   r6   a   s    B&% %$ %8i 8D 8:4S> : 3tCH~ 3$sCx. 3PTUXZ]U]P^ 3cghkmphpcq 3 3r:   r6   TF)      z\\p{[A-Za-z_]+}exprc                 ,   t         rt        j                  t        d|       }n(t        j                  t        |       rt        d|       | }	 t        j                  |      j                         D cg c]  }t        |       c}S c c}w # t        j                  $ ru t         st        |       t        j                  |      }t        t        dt        j                         }|j#                  d      dt        |      fcY S dt        |      fcY S w xY w)NAzD`regex` module must be installed in order to use Unicode categories.MAXWIDTH    r   )
_has_regexresubcateg_patternsearchImportError	sre_parseparsegetwidthrU   sre_constantserror
ValueErrorregexcompilerA   	MAXREPEATmatch)rd   regexp_finalxrM   rg   s        r!   get_regexp_widthr|      s     vvmS$799]D)dfjkk( ) = F F HI1AIII (T"" l+A y*m6M6MNHwwr{"#h-''#h-''(s+   %B 1BB B A6DDD)LuLlLtLmLoMnMcPc)NdNls
categoriesc                     t        |       dk7  rt        fd| D              S | dk(  xs t        j                  |       v S )Nri   c              3   6   K   | ]  }t        |        y wr   )_test_unicode_category).0charr   s     r!   	<genexpr>z)_test_unicode_category.<locals>.<genexpr>   s     J)$
;Js   _)lenallunicodedatacategory)r   r   s    `r!   r   r      s>    
1v{JJJJ8<{++A.*<<r:   c                 "    t        | t              S )z
    Checks if all characters in `s` are alphanumeric characters (Unicode standard, so diacritics, indian vowels, non-latin
    numbers, etc. all pass). Synonymous with a Python `ID_CONTINUE` identifier. See PEP 3131 for details.
    )r   _ID_CONTINUEr   s    r!   is_id_continuer      s    
 "!\22r:   c                 "    t        | t              S )z
    Checks if all characters in `s` are alphabetic characters (Unicode standard, so diacritics, indian vowels, non-latin
    numbers, etc. all pass). Synonymous with a Python `ID_START` identifier. See PEP 3131 for details.
    )r   	_ID_STARTr   s    r!   is_id_startr      s    
 "!Y//r:   lc                 >    t        t        j                  |             S )zGiven a list (l) will removing duplicates from the list,
       preserving the original order of the list. Assumes that
       the list entries are hashable.)r.   r*   fromkeys)r   s    r!   
dedup_listr      s     a !!r:   c                   <    e Zd ZddZdefdZd Zdeeef   fdZ	y)rZ   r   Nc                     i | _         y r   )enumsr_   s    r!   r[   zEnumerator.__init__   s	    %'
r:   c                     || j                   vr"t        | j                         | j                   |<   | j                   |   S r   )r   r   r8   r   s     r!   r@   zEnumerator.get   s3    tzz!"4::DJJtzz$r:   c                 ,    t        | j                        S r   )r   r   r_   s    r!   __len__zEnumerator.__len__   s    4::r:   c                     | j                   j                         D ci c]  \  }}||
 }}}t        |      t        | j                         k(  sJ |S c c}}w r   )r   r,   r   )r8   r   r    rs       r!   r^   zEnumerator.reversed   sN    "jj..01daQT111vTZZ((( 2s   A)r   N)
rC   rP   rQ   r[   rU   r@   r   r   r   r^   rV   r:   r!   rZ   rZ      s,    ( 3  
$sCx. r:   rZ   c                 `    | sg gS t        d | D              sJ |        t        t        |        S )a  
    Accepts a list of alternatives, and enumerates all their possible concatenations.

    Examples:
        >>> combine_alternatives([range(2), [4,5]])
        [[0, 4], [0, 5], [1, 4], [1, 5]]

        >>> combine_alternatives(["abc", "xy", '$'])
        [['a', 'x', '$'], ['a', 'y', '$'], ['b', 'x', '$'], ['b', 'y', '$'], ['c', 'x', '$'], ['c', 'y', '$']]

        >>> combine_alternatives([])
        [[]]
    c              3       K   | ]  }|  y wr   rV   )r   r   s     r!   r   z'combine_alternatives.<locals>.<genexpr>   s      Qq s   )r   r.   r   )listss    r!   combine_alternativesr      s6     t %  '%'   r:   c                   V    e Zd Z eej
                  j                        Zedd       Zy)FSc                 b    t         rd|v rt        j                  | f|dd|S t        | |fi |S )NwT)mode	overwrite)_has_atomicwritesatomicwritesatomic_writeopen)namer   kwargss      r!   r   zFS.open   s;    ,,TWWPVWWd-f--r:   N)r   )rC   rP   rQ   staticmethodospathexistsr   rV   r:   r!   r   r      s&    "''..)F. .r:   r   c                       e Zd Zd Zy)fzsetc                 F    ddj                  t        t        |             z  S )Nz{%s}, )joinmapreprr_   s    r!   __repr__zfzset.__repr__   s    		#dD/222r:   N)rC   rP   rQ   r   rV   r:   r!   r   r      s    3r:   r   predc                 j    g }| D cg c]  } ||      s|j                  |      s|  }}||fS c c}w r   )r   )r   r   false_elemselem
true_elemss        r!   classify_boolr      s>    K#&Q4$t*8J8J48P$QJQ{"" Rs   00initialexpandc              #      K   t        t        |             }t        |      }|rL|j                         }|  ||      D ])  }||vs|j	                  |       |j                  |       + |rKy y wr   )r   r.   setpopleftaddr   )r   r   open_qvisitednode	next_nodes         r!   bfsr     si     4=!F&kG
~~
 	)I'I&i(	) s   AA1&A1/A1c              #   ~   K   t        t        |             }|r#|j                         }| | ||      z  }|r"yyw)zVbfs, but doesn't keep track of visited (aka seen), because there can be no repetitionsN)r   r.   r   )r   r   r   r   s       r!   bfs_all_uniquer     s;     4=!F
~~
&, s   8==c           	      d   t        | t              r| j                  |      S t        | t              r| D cg c]  }t	        ||       c}S t        | t
              rt        |       S t        | t              r.| j                         D ci c]  \  }}|t	        ||       c}}S | S c c}w c c}}w r   )r)   r1   r7   r.   r=   	frozensetr*   r,   )r   r%   r   r   s       r!   r=   r=     s    %#t$$	E4	 3894
4&99	E9	%E{	E4	 <AKKMJysDJtT**JJL : Ks   B'
B,n
max_factorc                     | dk\  sJ |dkD  sJ | |k  r| dfgS t        |dd      D ]-  }t        | |      \  }}||z   |k  st        ||      ||fgz   c S  J d| z         )a  
    Splits n up into smaller factors and summands <= max_factor.
    Returns a list of [(a, b), ...]
    so that the following code returns n:

    n = 1
    for a, b in values:
        n = n * a + b

    Currently, we also keep a + b <= max_factor, but that might change
    r      ri   zFailed to factorize %s)rangedivmodsmall_factors)r   r   ar   bs        r!   r   r   '  s     6M6>>JAx:q"% ;a|1q5J J/Aq6(::; /*Q..5r:   c                   v    e Zd ZdZddee   fdZdedefdZ	defdZ
dee   fdZdefd	Zd
 ZdefdZd Zy)
OrderedSetzkA minimal OrderedSet implementation, using a dictionary.

    (relies on the dictionary being ordered)
    r,   c                 8    t         j                  |      | _        y r   )r*   r   r   )r8   r,   s     r!   r[   zOrderedSet.__init__D  s    u%r:   r   r   c                     || j                   v S r   r   r   s     r!   __contains__zOrderedSet.__contains__G  s    tvv~r:   c                 "    d | j                   |<   y r   r   r   s     r!   r   zOrderedSet.addJ  s    tr:   c                 ,    t        | j                        S r   )iterr   r_   s    r!   __iter__zOrderedSet.__iter__M      DFF|r:   c                     | j                   |= y r   r   r   s     r!   removezOrderedSet.removeP  s    FF4Lr:   c                 ,    t        | j                        S r   )ra   r   r_   s    r!   __bool__zOrderedSet.__bool__S  r   r:   c                 ,    t        | j                        S r   )r   r   r_   s    r!   r   zOrderedSet.__len__V  s    466{r:   c                 r    t        |       j                   ddj                  t        t        |              dS )N(r   ))rB   rC   r   r   r   r_   s    r!   r   zOrderedSet.__repr__Y  s0    t*%%&a		#d4.(A'B!DDr:   N)rV   )rC   rP   rQ   rR   r   r   r[   r   ra   r   r   r   r   r   r   rU   r   r   rV   r:   r!   r   r   ?  si    &hqk &   (1+ 1  Er:   r   )NN)Jr   r   	itertoolsr   collectionsr   typingr   r   r   r   r	   r
   r   r   r   r   r   r   r   sysrk   logging	getLoggerr   Logger__annotations__
addHandlerStreamHandlersetLevelCRITICALobjectNO_VALUEr   r"   rS   r-   r0   r1   r6   rv   rj   ro   version_info
re._parser_parserrp   re._constants
_constantsrs   rw   rm   rU   r|   r   r   ra   r   r   r   r   rZ   r   r   r   r   r   r   r   r   r   r=   r   r   rV   r:   r!   <module>r	     s    	   ~ ~ ~ ~  ***62 2   '''') *    ! 8CL	( 	(!3 	8HCU 	ae 	
s 
tCH~ 
T 
c 
 T%, ,^3	 3(J w")

-.(3 (5sCx$s))C#D (@ >	=(=c =x} = =
3c 3d 303 04 0"(1+ "$q' " &!&. .3I 3
#x #x #C #	) 	)8 	) 	)
c 
*;!< 
 
/S /c /d5c?.C /0EQ EO  Jf  s$   /G! G. !G+*G+.G87G8