
    XhC                        U d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZ d dl mZm	Z	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 er$ddlmZ  G d d	e
      Zeeef   Zej<                  Zd
 Z G d d ej@                  dd            Z!d.dZ"d.dZ#d Z$d Z%d Z&d/dZ'e jP                  jS                         D  ch c]Q  \  } } e*|e+      s e,|e jZ                  e j\                  e j^                  e j`                  e jb                  f      r|S c}} Z2d/dZ3e jP                  jS                         D  ch c]#  \  } } e*|e+      r e,|e jh                        r| % c}} Z5e jP                  jS                         D  ch c]#  \  } } e*|e+      r e,|e j                        r| % c}} h dz  Z6d Z7d Z8d Z9d Z:d Z;e jx                  fZ=eedf   e>d<   	 d dl?m@Z@ e=e@fz  Z=d ZBd ZCd  ZDd! ZEd" ZF eG       ZHd# ZId/d$ZJd% ZK G d& d'      ZLd( ZMd) ZNd* ZO ed+      d,        ZPd- ZQyc c}} w c c}} w c c}} w # eA$ r Y _w xY w)0    N)ABCMeta)ModuleexprAST)	lru_cache)CallableDictIterableIteratorListOptionalTupleUnioncastAnyTYPE_CHECKINGType   )NodeNGc                       e Zd ZdZdZdZy)EnhancedASTNr   )__name__
__module____qualname__first_token
last_tokenlineno     B/var/www/html/myenv/lib/python3.12/site-packages/asttokens/util.pyr   r   ,   s    KJFr   r   c                 b    t         j                  |    dt        |      j                  d      S )zRReturns a human-friendly representation of a token with the given type and string.:u)tokentok_namereprlstrip)tok_typestrings     r    
token_reprr*   7   s'     NN8,d6l.A.A#.F	GGr   c                       e Zd ZdZd Zy)Tokena  
  TokenInfo is an 8-tuple containing the same 5 fields as the tokens produced by the tokenize
  module, and 3 additional ones useful for this module:

  - [0] .type     Token type (see token.py)
  - [1] .string   Token (a string)
  - [2] .start    Starting (row, column) indices of the token (a 2-tuple of ints)
  - [3] .end      Ending (row, column) indices of the token (a 2-tuple of ints)
  - [4] .line     Original line (string)
  - [5] .index    Index of the token in the list of tokens that it belongs to.
  - [6] .startpos Starting character offset into the input text.
  - [7] .endpos   Ending character offset into the input text.
  c                 B    t        | j                  | j                        S N)r*   typer)   selfs    r    __str__zToken.__str__L   s    dii--r   N)r   r   r   __doc__r2   r   r   r    r,   r,   >   s    .r   r,   z0type string start end line index startpos endposc                 N    | j                   |k(  xr |du xs | j                  |k(  S )zVReturns true if token is of the given type and, if a string is given, has that string.N)r/   r)   r$   r(   tok_strs      r    match_tokenr7   Q   s*     
x		PW_%O8OPr   c                     t        | ||      sGt        dt        ||      dt        |       d| j                  d   d| j                  d   dz         y)z
  Verifies that the given token is of the expected type. If tok_str is given, the token string
  is verified too. If the token doesn't match, raises an informative ValueError.
  zExpected token z, got z	 on line r   z col r   N)r7   
ValueErrorr*   strstartr5   s      r    expect_tokenr<   W   sQ     
UHg	.
7#SZkk!nekk!nq(* + + 
/r   c                 d    | t         j                  t         j                  t         j                  fv S )zS
  These are considered non-coding tokens, as they don't affect the syntax tree.
  )r$   NLCOMMENTENCODING)
token_types    r    is_non_coding_tokenrB   c   s"    
 
%--@	@@r   c                     t        j                  t        t        g t        f   t        j                  |       j                              S )z;
  Generates standard library tokens for the given code.
  )tokenizegenerate_tokensr   r   r:   ioStringIOreadline)texts    r    rE   rE   k   s4     
	!	!$xC'8"++d:K:T:T"U	VVr   c                 2    t        | d      rt        S t        S )z
  Returns a function which yields all direct children of a AST node,
  skipping children that are singleton nodes.
  The function depends on whether ``node`` is from ``ast`` or from the ``astroid`` module.
  get_children)hasattriter_children_astroiditer_children_astnodes    r    iter_children_funcrQ   v   s     #*$"?	VEVVr   c                 @    |st        |       rg S | j                         S r.   )is_joined_strrK   )rP   include_joined_strs     r    rM   rM      s     	d 3I				r   c              #   $  K   |st        |       ry t        | t        j                        r3t	        | j
                  | j                        D ]  \  }}|| |  y t        j                  |       D ]  }|j                  t        vs|  y wr.   )
rS   
isinstanceastr	   zipkeysvaluesiter_child_nodes	__class__
SINGLETONS)rP   rT   keyvaluechilds        r    rN   rN      s     	d 3
chh DIIt{{3 e		k ##D) e j(ks   BB	B>   ConstDelAttrDelName
AssignAttr
AssignNamec                 :    | j                   j                  t        v S )z+Returns whether node is an expression node.)r\   r   expr_class_namesrO   s    r    is_exprrh           
	 	 $4	44r   c                 :    | j                   j                  t        v S )z)Returns whether node is a statement node.)r\   r   stmt_class_namesrO   s    r    is_stmtrl      ri   r   c                 4    | j                   j                  dk(  S )z&Returns whether node is a module node.r   r\   r   rO   s    r    	is_modulero      s     
	 	 H	,,r   c                 4    | j                   j                  dk(  S )zFReturns whether node is a JoinedStr node, used to represent f-strings.	JoinedStrrn   rO   s    r    rS   rS      s    
 
	 	 K	//r   c                 4    | j                   j                  dk(  S )zSReturns whether node is an `Expr` node, which is a statement that is an expression.Exprrn   rO   s    r    is_expr_stmtrt      s     
	 	 F	**r   .CONSTANT_CLASSES)ra   c                 "    t        | t              S )z(Returns whether node is a Constant node.)rV   ru   rO   s    r    is_constantrw      s     
D*	++r   c                 @    t        |       xr | j                  t        u S )z)Returns whether node is an Ellipsis node.)rw   r_   EllipsisrO   s    r    is_ellipsisrz      s     
T		5tzzX55r   c                 4    | j                   j                  dk(  S )z2Returns whether node is a starred expression node.Starredrn   rO   s    r    
is_starredr}      s     
	 	 I	--r   c           	          | j                   j                  dv xsV | j                   j                  dk(  xr; t        t        t        t        t        j                  |       j                              S )z?Returns whether node represents a slice, e.g. `1:2` in `x[1:2]`)SliceExtSlicer   )	r\   r   anymapis_slicer   rW   r   eltsrO   s    r    r   r      sX     nn!66 
..
!
!W
, =#hSYY 5 : :;<	r   c                     | j                   j                  dk(  xrP t        | t        j                         xr3 | j
                  | j                  cxu xr | j                  cxu xr d u S c S )Nr   )r\   r   rV   rW   r   loweruppersteprO   s    r    is_empty_astroid_slicer      s^     nn( 8sww'
'8
**


7dii
74
7 8r   c                    |sd }t        |       }t               }d}| dt        fg}|r|j                         \  }}}	|	t        u ri||vsJ |j	                  |        |||      \  }
}|j                  |||f       t        |      } ||      D ]  }|j                  |||
t        f        n |||t        t        t           |	            }|r|S )a5  
  Scans the tree under the node depth-first using an explicit stack. It avoids implicit recursion
  via the function call stack to avoid hitting 'maximum recursion depth exceeded' error.

  It calls ``previsit()`` and ``postvisit()`` as follows:

  * ``previsit(node, par_value)`` - should return ``(par_value, value)``
        ``par_value`` is as returned from ``previsit()`` of the parent.

  * ``postvisit(node, par_value, value)`` - should return ``value``
        ``par_value`` is as returned from ``previsit()`` of the parent, and ``value`` is as
        returned from ``previsit()`` of this node itself. The return ``value`` is ignored except
        the one for the root node, which is returned from the overall ``visit_tree()`` call.

  For the initial node, ``par_value`` is None. ``postvisit`` may be None.
  c                      y r.   r   )rP   pvaluer_   s      r    <lambda>zvisit_tree.<locals>.<lambda>  s    r   N)rQ   set	_PREVISITpopaddappendleninsertr   r   r,   )rP   previsit	postvisititer_childrendoneretstackcurrent	par_valuer_   r   
post_valueinsns                 r    
visit_treer      s    $ 
0I$T*-	$#$	"
#% %		GY	D   
hhw#GY7fjllGY
34 JcW% 2!S1fi012 gy$x*FGc 	 
*r   c              #      K   t        |       }t               }| g}|rZ|j                         }||vsJ |j                  |       | t	        |      } |||      D ]  }|j                  ||        |rYyyw)a1  
  Recursively yield all descendant nodes in the tree starting at ``node`` (including ``node``
  itself), using depth-first pre-order traversal (yieling parents before their children).

  This is similar to ``ast.walk()``, but with a different order, and it works for both ``ast`` and
  ``astroid`` trees. Also, as ``iter_children()``, it skips singleton nodes generated by ``ast``.

  By default, ``JoinedStr`` (f-string) nodes and their contents are skipped
  because they previously couldn't be handled. Set ``include_joined_str`` to True to include them.
  N)rQ   r   r   r   r   r   )rP   rT   r   r   r   r   r   cs           r    walkr   '  s      %T*-	$&%iikG$HHW
M e*C7$67 ll3 	s   A3A86A8c                     d}g }t        |      D ]-  \  }}}|j                  | ||        |j                  |       |}/ |j                  | |d        dj                  |      S )ah  
  Replaces multiple slices of text with new values. This is a convenience method for making code
  modifications of ranges e.g. as identified by ``ASTTokens.get_text_range(node)``. Replacements is
  an iterable of ``(start, end, new_text)`` tuples.

  For example, ``replace("this is a test", [(0, 4, "X"), (8, 9, "THE")])`` produces
  ``"X is THE test"``.
  r   N )sortedr   join)rI   replacementsppartsr;   endnew_texts          r    replacer   D  sn     !
% &| 4 uc8	LLa	LLA ,,tABx	r   c                       e Zd ZdZd Zd Zy)NodeMethodsz[
  Helper to get `visit_{node_type}` methods given a node's class and cache the results.
  c                     i | _         y r.   )_cacher0   s    r    __init__zNodeMethods.__init__\  s	    DKr   c                     | j                   j                  |      }|sCd|j                  j                         z   }t	        |||j
                        }|| j                   |<   |S )z
    Using the lowercase name of the class as node_type, returns `obj.visit_{node_type}`,
    or `obj.visit_default` if the type-specific method is not found.
    visit_)r   getr   r   getattrvisit_default)r1   objclsmethodnames        r    r   zNodeMethods.get`  sW     [[__S!F**,,dsD#"3"34fdkk#Mr   N)r   r   r   r3   r   r   r   r   r    r   r   X  s    r   r   c              #   P  K   g }| D ]  }|j                   t        j                  t        j                  t        j                  fv r0|r|d   j
                  |j                  k(  r|j                  |       nt        |      D ]  }|  g }|  t        |      D ]  }|  yw)a  
    Fixes tokens yielded by `tokenize.generate_tokens` to handle more non-ASCII characters in identifiers.
    Workaround for https://github.com/python/cpython/issues/68382.
    Should only be used when tokenizing a string that is known to be valid syntax,
    because it assumes that error tokens are not actually errors.
    Combines groups of consecutive NAME, NUMBER, and/or ERRORTOKEN tokens into a single NAME token.
    N)	r/   rD   NAME
ERRORTOKENNUMBERr   r;   r   combine_tokens)original_tokensgrouptokcombined_tokens       r    patched_generate_tokensr   n  s      E 
((x}}h&9&98??K
KE"IMMSYY6S,U3 	N
		 )/ s   B$B&c                 L   t        d | D              r&t        | D ch c]  }|j                   c}      dk7  r| S t        j                  t        j
                  dj                  d | D              | d   j                  | d   j                  | d   j                        gS c c}w )Nc              3   V   K   | ]!  }|j                   t        j                  k(   # y wr.   )r/   rD   r   ).0r   s     r    	<genexpr>z!combine_tokens.<locals>.<genexpr>  s     @3sxx8...@s   ')r   r   c              3   4   K   | ]  }|j                     y wr.   )r)   )r   ts     r    r   z!combine_tokens.<locals>.<genexpr>  s     /Aqxx/s   r   r   )r/   r)   r;   r   line)	r   r   r   rD   	TokenInfor   r   r;   r   )r   r   s     r    r   r     s    @%@@C]bHcVYHcDdhiDil]]ww///Ahnn"IMM1X]]  Ids   B!c                      t        |       |       D cg c]&  }t        |      st        |      j                  dv r|( }}|rt	        |d         S | S c c}w )zq
  If the given AST node contains multiple statements, return the last one.
  Otherwise, just return the node.
  )excepthandlerExceptHandler
match_case	MatchCase	TryExcept
TryFinallyr   )rQ   rl   r/   r   	last_stmt)rP   r`   child_stmtss      r    r   r     si     0)$/5
u~e-- 2  

+ 
 [_%%	+
s   +A)maxsizec                  ~   dt        j                        } t        j                  |       D cg c]  }t        |t         j                        s|! }}|D cg c]  }|j
                  |j                  f }}t        t        |            t        |      k(  }t        fd|D              }|xr |S c c}w c c}w )a  
  The positions attached to nodes inside f-string FormattedValues have some bugs
  that were fixed in Python 3.9.7 in https://github.com/python/cpython/pull/27729.
  This checks for those bugs more concretely without relying on the Python version.
  Specifically this checks:
   - Values with a format spec or conversion
   - Repeated (i.e. identical-looking) expressions
   - f-strings implicitly concatenated over multiple lines.
   - Multiline, triple-quoted f-strings.
  z(
    f"a {b}{b} c {d!r} e {f:g} h {i:{j}} k {l:{m:n}}"
    f"a {b}{b} c {d!r} e {f:g} h {i:{j}} k {l:{m:n}}"
    f"{x + y + z} {x} {y} {z} {z} {z!a} {z:z}"
    f'''
    {s} {t}
    {u} {v}
    '''
  )c              3   d   K   | ]'  }t        j                  |      |j                  k(   ) y wr.   )rW   get_source_segmentid)r   rP   sources     r    r   z)fstring_positions_work.<locals>.<genexpr>  s/        64(DGG3 s   -0)
rW   parser   rV   Namer   
col_offsetr   r   all)treerP   
name_nodesname_positionspositions_are_uniquecorrect_source_segmentsr   s         @r    fstring_positions_workr     s    & 
6	$!$$N:dCHH3MN*N?IJtT[[$//2J.JS01S5HH     
	9"99 OJs   B5B5B:c                    t         j                  dk\  ryt        | d      D ]  }t        |t        j
                        s|j                  D ]  }t        |dd       t        |t        j                        s+t               s't        |j                        D ]  }t        |dd        |j                  sit        |j                  dd         y)zy
  Add a special attribute `_broken_positions` to nodes inside f-strings
  if the lineno/col_offset cannot be trusted.
  )      NT)rT   _broken_positions)sysversion_infor   rV   rW   rq   rZ   setattrFormattedValuer   r_   format_spec)r   	joinedstrpartr`   s       r    annotate_fstring_nodesr     s     	  6 ?ii/   ?d'.	D#,,	-%'DJJ' 6eE.56 
$""$7
>??r   r.   )F)RrW   collectionsrF   r   r$   rD   abcr   r   r   r   	functoolsr   typingr   r	   r
   r   r   r   r   r   r   r   r   r   astroid_compatr   r   AstNoder   r*   
namedtupler,   r7   r<   rB   rE   rQ   rM   __dict__itemsrV   r/   
issubclassexpr_contextboolopoperatorunaryopcmpopr]   rN   stmtrk   rg   rh   rl   ro   rS   rt   Constantru   __annotations__astroidra   ImportErrorrw   rz   r}   r   r   objectr   r   r   r   r   r   r   r   r   r   )r   r   s   00r    <module>r	     s     	 
    ! !     $C  +v%&'  )H."K""7,^_ .&Q	+AWW  LL..0 cDAqJq$4GS--szz3<<VYV_V_`a  c
, #&,,"4"4"6 H$!Q!!T*z!SXX/F  H #&<<#5#5#7 H41a!!T*z!SXX/F  HOP 5
5
-
0+ '*ll_ %c	" 4uh
,6. H	(V:( ,2. 4: :>?K
c4HHP  s+   H1AH1>(H7(H=I I
I