o
    FDiy                     @   s  U d Z ddlZddlmZ ddlmZmZmZmZm	Z	m
Z
 ejdkr)ddlmZ nddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ ddlmZmZmZmZ e e ej!Z"ee#d< e	dZ$e
eef Z%e&Z'e&Z(ej)ej*ej+hZ,ee#d< e"j-e"j.e"j/e"j0e"j1e"j2e"j3e"j4e"j5e"j6h
Z7ee#d< dZ8ee#d< dej9e8< ddhZ:ee#d< ej;ej<ej=ej>ej?ej@hZAee#d< ejBejCejDejEejFejGejHejIejJejKejLejMejNejOhZPee#d< ejIejOhZQee#d< eQejJhB ZRee#d< e"jSe"jTe"jUe"jVe"jWhZXee#d< e"jYe"jZe"j[e"j\e"j]e"j^e"j_hZ`ee#d< e"jae"jbe"jce"jde"jee"jfe"jge"jhe"jie"jje"jke"jle"jUe"jme"jne"johZpee#d< e"jqe"jrhZsee#d< h dZtee#d < e"jue"j]e"jvhZwee#d!< ejxejyejzej{ej|ej}iZ~ee#d"< ee~ Zee#d#< ee~ Zee#d$< eeB Zee#d%< eeje8ejejejhB Zee#d&< d'Zed(d)G d*d+ d+ee$ Zd,ed-ed.ed/efd0d1Zdd3e&d4ed5ed/efd6d7Zd8ee% d/ee fd9d:Zd8ee% d;eee(  d/efd<d=Zd8ee% d/ee( fd>d?Zd@edAe%d/ee% fdBdCZdDe%dEe%d/dfdFdGZd,ed/e%fdHdIZd8e%d/ee fdJdKZd8e%d/efdLdMZd8ed/efdNdOZd8e%d/efdPdQZd8e%d/efdRdSZd8e%d/efdTdUZd8e%d/efdVdWZd8e%d/efdXdYZd8e%d/efdZd[Zejxejyffd\ed]ed^ee d_ee&e&f d/ef
d`daZd8e%d/efdbdcZdd8e%deed/efdfdgZd8e%d/efdhdiZd8e%d/efdjdkZd,edlee( d/efdmdnZd8ed/efdodpZd8ed/efdqdrZd8e%d/efdsdtZd8ed/efdudvZd8ed/efdwdxZd8ed/efdydzZd8e%d/efd{d|Zd8e%d/efd}d~Zd,ed/efddZd,ed/efddZd,ed/efddZd,ed/efddZd,ed/efddZd,ed/efddZd,ed/efddZd,ed/efddZded/efddZd(ddede%ded/dfddZd8e%d/ee% fddZd,ed/dfddZded/ee fddZded/ee fddZded/ee fddZded/ee fddZd,ed/ed fddZd,ed/efddZd8e%d/ee fddZd8e%d/ee fddZd,ed/e%fddZd8e%de&d/efddZdS )z>
blib2to3 Node/Leaf transformation-related utility functions.
    N)Iterator)FinalGenericLiteralOptionalTypeVarUnion)   
   )	TypeGuard)
mypyc_attr)	CACHE_DIR)Mode)get_string_prefixhas_triple_quotes)pygram)token)NLLeafNode	type_reprsymsT
WHITESPACE	STATEMENT   STANDALONE_COMMENTandorLOGIC_OPERATORSCOMPARATORSMATH_OPERATORSSTARSVARARGS_SPECIALSVARARGS_PARENTSUNPACKING_PARENTSTEST_DESCENDANTSTYPED_NAMES>   %=&=*=+=-=/=@=^=|=**=//=<<=>>=:=ASSIGNMENTSIMPLICIT_TUPLEBRACKETOPENING_BRACKETSCLOSING_BRACKETSBRACKETSALWAYS_NO_SPACE7   T)allow_interpreted_subclassesc                   @   s<   e Zd ZdZdedee fddZdedee fddZdS )	VisitorzBBasic lib2to3 visitor that yields things of type `T` on `visit()`.nodereturnc                 c   sd    |j dk rtj|j  }ntt|j }t| d| d}|r(||E dH  dS | |E dH  dS )az  Main method to visit `node` and its children.

        It tries to find a `visit_*()` method for the given `node.type`, like
        `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
        If no dedicated `visit_*()` method is found, chooses `visit_default()`
        instead.

        Then yields objects of type `T` from the selected visitor.
           visit_N)typer   tok_namestrr   getattrvisit_default)selfrA   namevisitf rM   D/var/www/Datamplify/venv/lib/python3.10/site-packages/black/nodes.pyvisit   s   

zVisitor.visitc                 c   s0    t |tr|jD ]}| |E dH  q	dS dS )zCDefault `visit_*()` implementation. Recurses to children of `node`.N)
isinstancer   childrenrO   )rJ   rA   childrM   rM   rN   rI      s   

zVisitor.visit_defaultN)	__name__
__module____qualname____doc__LNr   r   rO   rI   rM   rM   rM   rN   r@      s    r@   leafcomplex_subscriptmoderB   c                C   s  d}d}d}| j }| j}| j}|tv r|S |tjkr|S |dus'J d| |tjkr9|j tjtj	tj
hvr9|S |tjkrF|j tjkrF|S | j}	|	st|}
|
rV|
j tv rX|S |tjkrq|
j tjkre|S |
j tjkro|so|S |S |
j tjkr|
jr|
jj tjtjtjtjhv r|S |
jj tjkr|
jS ny|
j tjkrt|
tjkrt|
jtj	tjfv r|S |
j tv rt|
ttB dr|S nO|
j tjkr|
jr|
jj tjtj
hv r|r|S |S n5|
jr|
jj tj kr|
j t!v r|S |
j tj"kr|jr|jj tj#kr|S n|	j tv r|S |	j tj$kr|S |j tjtjhv r&|	r"|	j tjkr$|S |S |j tjkr;|	r9|	j tjkr9|S |S |j tjkrl|	sG|S |tjkrW|	j t%vrU|S |S |	j tjkra|	jS |	j tjkrj|S |S |j t%v r|	st|}
|
r|
j tjkr|S |S |j tj&kr|tj'ks|tj(kr|S |	s|tj)ks|tj*kr|S |S |	j tjkr|S |S |j tjkr|tjkr|S |	st|}
|
r|
j tj'kr|S |S |	j tjhtB v r|S |S |j tj#kr|S |j tj+kr|	r|S t|}
|
r|
j tj"ks|
j tj)kr|S |S |j tj,kr7|tj'kr)|S |	r5|	j tj'kr5|S |S |j tjtj
hv rp|	sZ|jdusNJ d|jj tj	krX|S |S |tj-ksg|	j tj-kri|S |sn|S |S |j tj.kr|	r|tj)kr|S |S |j tj/kr|	r|	j tj0kr|S |S |j tj tjhv r|	st|}
|
r|
j tv r|S |
j}|dusJ |
j tjkr|j tjtj
hv r|S |
j tjkr|j tjkr|S |S |tj1tj2tj3hv r|S |S |j tj4kr)|tj)kr|	r|	j tj)kr|S |S |tj1kr'|dkr|S |	r'|	j tj)kr'|S |S |j tj
kr2|S |j tj5krA|tjkrA|S |S )	zReturn whitespace prefix if needed for the given `leaf`.

    `complex_subscript` signals whether the given leaf is part of a subscription
    which has non-trivial arguments, like arithmetic expressions or function calls.
      z  Nz/INTERNAL ERROR: hand-made leaf without parent: )withinzsubscripts are always parentedimport)6rE   parentvaluer=   r   COMMENTCOLONr   	subscriptsubscriptlistsliceopLBRACEfstring_replacement_fieldprev_siblingpreceding_leafr:   COMMAEQUALarglistargument
parametersvarargslisttypedargslistprefixSTARparent_type	star_expr
tname_starr#   	is_varargr$   r%   factorr!   AT	decoratorBANGr'   trailerLPARRPARDOTLSQBdotted_nameclassdef
COLONEQUALatomdictsetmaker
DOUBLESTARNAMENUMBERSTRINGimport_fromexcept_clause)rX   rY   rZ   NOSPACEDOUBLESPACEtpvprevprevpprevp_parentrM   rM   rN   
whitespace   st  



    	 wpgdZW"KD50+
	r   
nl_count	form_feed
empty_linec                 C   s    |r|| d  d | S ||  S )z$Generate a normalized prefix string.   rM   )r   r   r   rM   rM   rN   make_simple_prefix  s   r   rA   c                 C   sR   | r'| j }|r"t|tr|S z	t| d W S  ty!   Y dS w | j} | sdS )z3Return the first leaf that precedes `node`, if any.N)rh   rP   r   listleaves
IndexErrorr_   )rA   resrM   rM   rN   ri     s   
ri   tokensc                 C   sJ   |sdS |d du r| du S | sdS | j |d krdS t| j|dd S )a;  Return if the `node` and its previous siblings match types against the provided
    list of tokens; the provided `node`has its type matched against the last element in
    the list.  `None` can be used as the first element to declare that the start of the
    list is anchored at the start of its parent's children.Tr   NF)rE   prev_siblings_arerh   )rA   r   rM   rM   rN   r     s   r   c                 C   s   | du s	| j du rdS | j jS )z|
    Returns:
        @node.parent.type, if @node is not None and has a parent.
            OR
        None, otherwise.
    N)r_   rE   rA   rM   rM   rN   rs     s   rs   ancestor
descendantc                 C   s*   |}|r|j | kr|j }|r|j | ks	|S )z:Return the child of `ancestor` that contains `descendant`.)r_   )r   r   rA   rM   rM   rN   child_towards  s
   r   	old_child	new_childc                 C   s2   | j }|sdS |  }|dur||| dS dS )z
    Side Effects:
        * If @old_child.parent is set, replace @old_child with @new_child in
        @old_child's underlying Node structure.
            OR
        * Otherwise, this function does nothing.
    N)r_   removeinsert_child)r   r   r_   	child_idxrM   rM   rN   replace_child  s   r   c                 C   sr   | j }| }|r7|j}|du r	 |S |jd j |kr	 |S |jtjkr%	 |S |jdur3|jjtv r3	 |S |}|s|S )zReturn `leaf` or one of its ancestors that is the topmost container of it.

    By "container" we mean a node where `leaf` is the very first child.
    Nr   )rq   r_   rQ   rE   r   
file_inputrh   r<   )rX   same_prefix	containerr_   rM   rM   rN   container_of  s&   	r   c                 C   s&   t | tr| S | jrt| jd S dS )z(Returns the first leaf of the node tree.r   N)rP   r   rQ   first_leaf_ofr   rM   rM   rN   r     s
   
r   c                 C   s   | j tjtjtjtjhv S )z?Whether node is an arithmetic or a binary arithmetic expression)rE   r   
arith_expr
shift_exprxor_exprand_exprr   rM   rM   rN   is_arith_like  s   r   c                 C   s   t | tr| jtjkrdS t| j}t|drdS | j	r7| j	jt
jkr7| j	js7| j	j	r7| j	j	jt
jkr7dS t| j	d tjtjt
jgrFdS t| j	t
jtjt
jgrTdS dS )NFbBfFT)rP   r   rE   r   r   r   r`   setintersectionr_   r   simple_stmtrh   r   r   NEWLINEINDENTrn   rb   )rA   rq   rM   rM   rN   is_docstring$  s,   

r   c                 C   s>   | j tjkot| jdko| jd j tjko| jd j tjkS )z+Return True if `node` holds an empty tuple.   r   r   )rE   r   r   lenrQ   r   r|   r}   r   rM   rM   rN   is_empty_tupleD  s   r   c                 C   sv   | j tjkr&t| }|du s|j tjkrdS t|jdko%|jd j tjkS | j t	v o:t| jdko:| jd j tjkS )zMReturn True if `node` holds a tuple with one element, with or without parens.NFr   r   )
rE   r   r   unwrap_singleton_parenthesistestlist_gexpr   rQ   r   rj   r8   rA   gexprM   rM   rN   is_one_tupleN  s    
r   c                 C   s4   | j tjkrdS t| }|du s|j tjkrdS dS )z$Return True if `node` holds a tuple.FNT)rE   r   r   r   r   r   rM   rM   rN   is_tuple^  s   r   c                 C   D   | j tjkrdS t| }|du s|j tjkrdS tdd |jD S )zDReturn True if `node` holds a tuple that contains a walrus operator.FNc                 s       | ]	}|j tjkV  qd S N)rE   r   namedexpr_test.0rR   rM   rM   rN   	<genexpr>q      z-is_tuple_containing_walrus.<locals>.<genexpr>rE   r   r   r   r   anyrQ   r   rM   rM   rN   is_tuple_containing_walrusi     r   c                 C   r   )zBReturn True if `node` holds a tuple that contains a star operator.FNc                 s   r   r   )rE   r   rt   r   rM   rM   rN   r   |  r   z+is_tuple_containing_star.<locals>.<genexpr>r   r   rM   rM   rN   is_tuple_containing_start  r   r   c                 C   r   )z(Return True if `node` holds a generator.FNc                 s   r   r   )rE   r   old_comp_forr   rM   rM   rN   r     r   zis_generator.<locals>.<genexpr>r   r   rM   rM   rN   is_generator  r   r   openingclosingr   bracketsc           	      C   s   | j |j f|kr
dS |jd }t|D ]
\}}|| u r nqtdd}|d7 }||d D ]2}||u r9 |dk S |j}||kr`|j tjkr`|d7 }|jr`|jj tjtj	hv r`|d7 } |dk S q.|dk S )zIReturn True if content between `opening` and `closing` is a one-sequence.Fr   z#Opening paren not found in `leaves`r   Nr   )
rE   bracket_depth	enumerateLookupErrorr   rj   r_   r   rl   rp   )	r   r   r   r   depth_opening_indexrX   commasr   rM   rM   rN   is_one_sequence_between  s4   
 r   c                 C   s   t | }|duo|jtjkS )z7Return True iff `node` is of the shape ( test := test )N)r   rE   r   r   )rA   innerrM   rM   rN   is_walrus_assignment  s   r   Flastc                 C   s   | j tjkoTt| jdko| jd j tjko| jd j tjkpT|o9t| jdko9| jd j tjko9| jd j tj	kpT|oTt| jdkoT| jd j tjkoT| jd j tj	kS )z?Return True iff `node` is a trailer valid in a simple decoratorr   r   r   r	   )
rE   r   r{   r   rQ   r   r~   r   r|   r}   )rA   r   rM   rM   rN   is_simple_decorator_trailer  s(   r   c                 C   sp   | j tjkrdS | j tjkr6| jr6| jd j tjko5ttt| jdd o5t	| jdk p5t| jd ddS dS )a\  Return True iff `node` could be a 'dotted name' decorator

    This function takes the node of the 'namedexpr_test' of the new decorator
    grammar and test if it would be valid under the old decorator grammar.

    The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
    The new grammar is : decorator: @ namedexpr_test NEWLINE
    Tr   r   r   r   )r   F)
rE   r   r   r   powerrQ   allmapr   r   r   rM   rM   rN   is_simple_decorator_expression  s   	r   c                 C   sx   | j tjkrdS t| r| jdkrdS | j tjkrdS t| jdkr$dS | j\}}}|j tj	kr:|j tj
kr:t|S dS )zAReturn True if `node` holds a `yield` or `yield from` expression.TyieldFr	   )rE   r   
yield_expris_name_tokenr`   r   r   rQ   r   r|   r}   is_yield)rA   lparexprrparrM   rM   rN   r     s   r   r]   c                 C   s@   | j tvs| js
dS | j}|j tjkr|jsdS |j}|j |v S )aF  Return True if `leaf` is a star or double star in a vararg or kwarg.

    If `within` includes VARARGS_PARENTS, this applies to function signatures.
    If `within` includes UNPACKING_PARENTS, it applies to right hand-side
    extended iterable unpacking (PEP 3132) and additional unpacking
    generalizations (PEP 448).
    F)rE   r#   r_   r   rt   )rX   r]   r   rM   rM   rN   rv     s   
rv   c                 C      | j tjkS )z&Return True if the node is an f-string)rE   r   fstringr   rM   rM   rN   
is_fstring  s   r   c                 C   s:   t | t| jd }ttj|| jd}|  pd|_|S )z/Converts an fstring node back to a string node.N)rq   r   )rG   r   rq   r   r   r   
get_linenolineno)rA   string_without_prefixstring_leafrM   rM   rN   fstring_to_string  s   r   c                 C   sD   t | trt| rt| }n
t | tr| }ndS t|jo!d|jv S )zKReturn True if `leaf` is a multiline string that actually spans many lines.Fr   )rP   r   r   r   r   r   r`   )rA   rX   rM   rM   rN   is_multiline_string   s   

r   c                 C   s8   | j tjtjhv sJ | jd usJ | jj tjtjhv S r   )rE   r   suiter   r_   funcdefr   r   rM   rM   rN   is_parent_function_or_class,  s   r   c                 C   s   | j tjtjtjhv S r   )rE   r   r   r   async_funcdefr   rM   rM   rN   is_function_or_class3     r   c                 C   s   | j durt| sdS | j rdS t| jdks4| jd jtjks4| jd jtj	ks4| jd jtj
kr6dS | jd j r@dS t| jd S )z2Return True if `node` is a suite with a stub body.NF   r   r   r	   r   )r_   r   rq   stripr   rQ   rE   r   r   r   DEDENTis_stub_bodyr   rM   rM   rN   is_stub_suite7  s   
r  c                 C   sp   t | tr| jtjkrdS t| jdkrdS | jd }|j  o7|jtj	ko7t|jdko7t
dd |jD S )zCReturn True if `node` is a simple statement containing an ellipsis.Fr   r   r	   c                 s   s     | ]}|t tjd kV  qdS ).N)r   r   r~   )r   rX   rM   rM   rN   r   [  s    zis_stub_body.<locals>.<genexpr>)rP   r   rE   r   r   r   rQ   rq   r   r   r   )rA   rR   rM   rM   rN   r  N  s   

r  c                 C   sp   t | ts| jtjkrdS | jd | jd }}t |to7|jtjko7|jdko7t |to7|jtj	ko7|jdkS )zGiven a `LN`, determines whether it's an atom `node` with invisible
    parens. Useful in dedupe-ing and normalizing parens.
    Fr   r   r[   )
rP   r   rE   r   r   rQ   r   r|   r`   r}   )rA   firstr   rM   rM   rN   is_atom_with_invisible_parens_  s   


r  c                 C   s   t | pt| S r   )is_empty_lparis_empty_rparrX   rM   rM   rN   is_empty_parq  s   r	  c                 C      | j tjko
| jdkS Nr[   )rE   r   r|   r`   r  rM   rM   rN   r  u  r   r  c                 C   r
  r  )rE   r   r}   r`   r  rM   rM   rN   r  y  r   r  c                 C   sP   | j }| j}| j}t|tjko&|dkr|r|jtjkp&|dko&|o&|jtjkS )z9Return True if the given leaf starts an import statement.r^   from)	r_   rE   r`   boolr   r   r   import_namer   )rX   r   r   r   rM   rM   rN   	is_import}  s   
r  c                 C   sR   t | jtjko| jdko| jo| jjtjkp(t | jtjko'| j	o'| j	jtjkS )zDReturn True if the given leaf starts a with or async with statement.with)
r  rE   r   r   r`   r_   r   	with_stmtASYNCnext_siblingr  rM   rM   rN   is_with_or_async_with_stmt  s   r  c                 C   s*   t | jtjko| jo| jjtjtjhv S )zReturn True if the given leaf starts an async def/for/with statement.

    Note that `async def` can be either an `async_stmt` or `async_funcdef`,
    the latter is used when it has decorators.
    )r  rE   r   r  r_   r   
async_stmtr   r  rM   rM   rN   is_async_stmt_or_funcdef  s   r  c                 C   s$   | j }| j}|tjthv o|dS )aB  Return True if the given leaf is a type comment. This function should only
    be used for general type comments (excluding ignore annotations, which should
    use `is_type_ignore_comment`). Note that general type comments are no longer
    used in modern version of Python, this function may be deprecated in the future.z# type:)rE   r`   r   ra   r   
startswithrX   r   r   rM   rM   rN   is_type_comment  s   r  c                 C   s"   | j }| j}|tjthv ot|S )zGReturn True if the given leaf is a type comment with ignore annotation.)rE   r`   r   ra   r   is_type_ignore_comment_stringr  rM   rM   rN   is_type_ignore_comment  s   r  r`   c                 C   s
   |  dS )zSReturn True if the given string match with type comment with
    ignore annotation.z# type: ignore)r  )r`   rM   rM   rN   r    s   
r  )visibler_   rR   r  c                C   sh   t tj|rdnd}t tj|rdnd}|j}d|_| pd}ttj|||g}||_| 	|| dS )zWrap `child` in parentheses.

    This replaces `child` with an atom holding the parentheses and the old
    child.  That requires moving the prefix.

    If `visible` is False, the leaves will be valueless (and thus invisible).
    (r[   )r   N)
r   r   r|   r}   rq   r   r   r   r   r   )r_   rR   r  r   r   rq   indexr   rM   rM   rN   wrap_in_parentheses  s   r   c                 C   s>   t | jdkr	dS | j\}}}|jtjkr|jtjksdS |S )zqReturns `wrapped` if `node` is of the shape ( wrapped ).

    Parenthesis can be optional. Returns None otherwiser	   N)r   rQ   rE   r   r|   r}   )rA   r   wrappedr   rM   rM   rN   r     s   r   c                 C   s0   | j tjkrd| _dS | j tjkrd| _dS dS )zMake sure parentheses are visible.

    They could be invisible as part of some statements (see
    :func:`normalize_invisible_parens` and :func:`visit_import_from`).
    r  r  N)rE   r   r|   r`   r}   r  rM   rM   rN   ensure_visible  s
   

r"  nlc                 C   r   r   )rE   r   r   r#  rM   rM   rN   r        r   c                 C   r   r   )rE   r   r|   r$  rM   rM   rN   is_lpar_token  r%  r&  c                 C   r   r   )rE   r   r}   r$  rM   rM   rN   is_rpar_token  r%  r'  c                 C   r   r   )rE   r   r   r$  rM   rM   rN   is_number_token  r%  r(  )rB   paramNc                 C   sP   | j }|dur&|jr|jjtjkrdS |j r|j jtjkrdS |j }|dusdS )z<Returns the type of annotation this leaf is part of, if any.NrB   r)  )r_   rh   rE   r   RARROWr   tname)rX   r   rM   rM   rN   get_annotation_type  s   r,  c                 C   s   | j dusJ t| duS )z7Returns whether this leaf is part of a type annotation.N)r_   r,  r  rM   rM   rN   is_part_of_annotation  s   r-  c                 C   &   t | tr| S | jsdS t| jd S )z,Returns the first leaf of the ancestor node.Nr   )rP   r   rQ   
first_leafr   rM   rM   rN   r/    
   
r/  c                 C   r.  )z+Returns the last leaf of the ancestor node.Nr   )rP   r   rQ   	last_leafr   rM   rM   rN   r1    r0  r1  c                 C   sJ   | }|j r#|j jr#||j jd u r#|j }|j r#|j jr#||j jd u s|S )zGReturns the furthest ancestor that has this leaf node as the last leaf.r   )r_   rQ   )rX   rA   rM   rM   rN    furthest_ancestor_with_last_leaf  s
   r2  rE   c                 C   sX   | j }|d ur|j|krdS |j }|d us| j}|d ur*|j|kr#dS |j}|d usdS )NTF)rh   rE   r  )rA   rE   siblingrM   rM   rN   has_sibling_with_type'  s   

r4  )r   )F)rV   syscollections.abcr   typingr   r   r   r   r   r   version_infor   typing_extensionsmypy_extensionsr   black.cacher   
black.moder   black.stringsr   r   blib2to3r   blib2to3.pgen2r   blib2to3.pytreer   r   r   r   
initializepython_symbolsr   __annotations__r   rW   intLeafIDNodeTyper   r   r   r   if_stmt
while_stmtfor_stmttry_stmtr   r  r   r   
match_stmt
case_blockr   r   rF   r   LESSGREATEREQEQUALNOTEQUAL	LESSEQUALGREATEREQUALr    VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSrr   SLASHDOUBLESLASHPERCENTrx   TILDEr   r!   r"   r#   rl   rm   r{   rp   ro   r$   r   r   	listmakerr   testlist_star_exprsubject_exprpatternr%   testlambdefor_testand_testnot_test
comparisonrt   r   r   r   r   r   termr   r   r&   r+  ru   r'   r7   testlistexprlistr8   r|   r}   r   RSQBrf   RBRACEr9   r   keysr:   valuesr;   r<   rj   FSTRING_MIDDLEFSTRING_ENDrz   r=   r*  r@   r  rG   r   r   ri   r   r   rs   r   r   r   r   r   r   r   r   r   r   r   r   tupler   r   r   r   r   rv   r   r   r   r   r   r  r  r  r	  r  r  r  r  r  r  r  r  r   r   r"  r   r&  r'  r(  r,  r-  r/  r1  r2  r4  rM   rM   rM   rN   <module>   s^    


	
" q"

 



%
 

