
    X-Ph'                    $   U d Z ddlmZ ddlmZ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mZmZmZmZmZmZmZ ddlmZ ddlmZ ddlm Z m!Z!  e"d          Z#d	e$d
<    e"ddddge	dddddR           Z%d	e$d<    G d d          Z&dS )zySemantic analysis of call-based Enum definitions.

This is conceptually part of mypy.semanal (semantic analyzer pass 2).
    )annotations)Finalcast)	ARG_NAMEDARG_POSEXCLUDED_ENUM_ATTRIBUTESMDEFAssignmentStmtCallExprContextDictExprEnumCallExpr
ExpressionListExpr
MemberExprNameExprRefExprStrExprSymbolTableNode	TupleExprTypeInfoVaris_StrExpr_list)Options)SemanticAnalyzerInterface)LiteralTypeget_proper_type)z	enum.Enumzenum.IntEnumz	enum.Flagzenum.IntFlagzenum.StrEnumr   
ENUM_BASESnamevalue_name__value_
__module____annotations____doc__	__slots____dict__ENUM_SPECIAL_PROPSc                  F    e Zd Zd(dZd)dZd*dZd+dZd,dZd-d#Zd.d&Z	d'S )/EnumCallAnalyzeroptionsr   apir   returnNonec                "    || _         || _        d S N)r+   r,   )selfr+   r,   s      Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/semanal_enum.py__init__zEnumCallAnalyzer.__init__;   s        sr
   is_func_scopeboolc                   t          |j                  dk    s't          |j        d         t          t          f          sdS |j        d         }|j        }|                     |j        ||          }|dS t          |t                    r|                     d|           dS | j	        
                    |||           dS )zCheck if s defines an Enum; if yes, store the definition in symbol table.

        Return True if this looks like an Enum definition (but maybe with errors),
        otherwise return False.
           r   FNz'Enum type as attribute is not supportedT)lenlvalues
isinstancer   r   r   check_enum_callrvaluefailr,   
add_symbol)r1   r5   r6   lvaluer   	enum_calls         r2   process_enum_callz"EnumCallAnalyzer.process_enum_call?   s     qy>>Qj1*?U&V&V51{((4GG	5fj)) 	II?HHH5D)Q///tr4   noder   var_namestrTypeInfo | Nonec                R   t          |t                    sdS |}|j        }t          |t                    sdS |j        }|t
          vrdS |                     ||                    d          d                   \  }}}	}
|
s<|}|r|dt          |j	                  z   z  }| 
                    |g ||j	                  }n||k    r"d| d| d| d}|                     ||           t          t          |j        d	                   j        }||k    s|r|dt          |j	                  z   z  }| 
                    ||||j	                  }||k    s|r| j                            ||           t%          |||	          |_        |j                            |           |j	        |_	        |S )
zCheck if a call defines an Enum.

        Example:

          A = enum.Enum('A', 'foo bar')

        is equivalent to:

          class A(enum.Enum):
              foo = 1
              bar = 2
        N.@zString argument 1 "z" to z$(...) does not match variable name ""r   )r<   r   calleer   fullnamer   parse_enum_call_argssplitrF   linebuild_enum_call_typeinfor?   r   r   argsr    r,   add_symbol_skip_localr   analyzedset_line)r1   rD   rE   r6   callrM   rN   new_class_nameitemsvaluesokr   infomsgs                 r2   r=   z EnumCallAnalyzer.check_enum_callS   s    $)) 	4&'** 	4?:%%4,0,E,E(..%%b)-
 -
)vr  	SD -c$)nn,,00r8TYOODD))zNzzzzowzzz		#t$$$1..4Dx=c$)nn,,00uh	RRD8}H**4666$T5&99t$$$I	r4   r   rY   	list[str]rN   rQ   intr   c                h   | j                             |          }|J | j                             |||          }|                                |_        d|_        |D ]T}t          |          }||_        d|_        d|_	        |j
         d| |_        t          t          |          |j        |<   U|S )NTrI   )r,   named_type_or_nonebasic_new_typeinfocalculate_metaclass_typemetaclass_typeis_enumr   r\   is_propertyhas_explicit_valuerN   	_fullnamer   r	   names)	r1   r   rY   rN   rQ   baser\   itemvars	            r2   rR   z)EnumCallAnalyzer.build_enum_call_typeinfo   s     x**844x**4t<<";;== 	: 	:Dd))CCH"CO &*C"#}55t55CM.tS99DJtr4   rW   r   
class_name4tuple[str, list[str], list[Expression | None], bool]c                	   |j         }t          d |j        D                       s|                     d| d|          S t	          |          dk     r|                     d| d|          S t	          |          dk    r|                     d| d|          S g d}|j        D ] }||vr|                     d	| d
|           !d\  }}t          |j        |          D ]\  }}|dk    r|}|dk    r|}||d         }||d         }t          |t                    s|                     | d|          S |j	        }	g }
g }t          |t                    rI|j	        }|
                    dd                                          D ]}|
                    |           nt          |t          t          f          r|j        }t!          |          rd |D             }
nt          d |D                       ru|D ]p}t          |t          t          f          sJ |j        \  }}t          |t                    sJ |
                    |j	                   |                    |           qn-|                     d|z  |          S t          |t"                    rn|j        D ]d\  }}t          |t                    s|                     | d|          c S |
                    |j	                   |                    |           ent          |d         t$                    r\t          |d         j        t(                    r;t+          |d         j        j                  }|wt          |t.                    rbt          |j	        t0                    rH|j	        }|
                    dd                                          D ]}|
                    |           n|d         j        j        rxt          |d         j        j        t0                    rS|d         j        j        }|
                    dd                                          D ]}|
                    |           n2|                     d|z  |          S |                     d|z  |          S |
s|                     | d|          S |sdgt	          |
          z  }t	          |
          t	          |          k    sJ |	|
|dfS )zhParse arguments of an Enum call.

        Return a tuple of fields, values, was there an error.
        c              3  6   K   | ]}|t           t          fv V  d S r0   )r   r   ).0arg_kinds     r2   	<genexpr>z8EnumCallAnalyzer.parse_enum_call_args.<locals>.<genexpr>   s,      SS833SSSSSSr4   zUnexpected arguments to z()   zToo few arguments for    zToo many arguments for )Nr    ri   modulequalnametypestartzUnexpected keyword argument "rL   )NNr    ri   Nr   r9   z1() expects a string literal as the first argument, c                    g | ]	}|j         
S  )r    rq   seq_items     r2   
<listcomp>z9EnumCallAnalyzer.parse_enum_call_args.<locals>.<listcomp>   s    BBBHBBBr4   c              3     K   | ]X}t          |t          t          f          o7t          |j                  d k    ot          |j        d         t
                    V  YdS )rt   r   N)r<   r   r   r:   rY   r   r~   s     r2   rs   z8EnumCallAnalyzer.parse_enum_call_args.<locals>.<genexpr>   sw          8i%:;; ;''1,;x~a0'::     r4   z>%s() with tuple or list expects strings or (name, value) pairsz-() with dict literal requires string literalszfSecond argument of %s() must be string, tuple, list or dict literal for mypy to determine Enum membersz() needs at least one itemT)rS   all	arg_kindsfail_enum_call_argr:   	arg_nameszipr<   r   r    replacerP   appendr   r   rY   r   r   r   rD   r   r   rx   r   rF   is_finalfinal_value)r1   rW   rm   rS   
valid_namearg_namer    ri   argrX   rY   rZ   fieldsfield	seq_itemsr   r   keyproper_types                      r2   rO   z%EnumCallAnalyzer.parse_enum_call_args   s    ySSDNSSSSS 	\**+Tj+T+T+TVZ[[[t99q==**+RJ+R+R+RTXYYYt99q==**+SZ+S+S+SUYZZZTTT
 	[ 	[Hz))''(S(S(S(SUYZZZ!u 66 	 	MHc7""7""=GE=GE%)) 	**PPPRV   *,eW%% ;	[FS117799 $ $U####$	8455 7	Iy)) BB	BBB   !*	      !* ) )H%hH0EFFFFF"*.KD%%dG44444LL,,,MM%(((() ..TWaa   x(( "	#k % %
U!#w// 22%TTTVZ     SY'''e$$$$% Q)) 	jas.K.K 	)$q',*;<<K'{K88 ({0#66 ( %*#^^C55;;== ( (ELL''''(a& 	:d1gl6NPS+T+T 	a1#^^C55;;== ( (ELL''''( ..| !   **x  
  	\**j+T+T+TVZ[[[ 	)Vc%jj(F5zzS[[((((ufd22r4   messagecontextr   c                :    |                      ||           dg g dfS )N F)r?   )r1   r   r   s      r2   r   z#EnumCallAnalyzer.fail_enum_call_arg  s'     			'7###2r5  r4   r]   ctxc                <    | j                             ||           d S r0   )r,   r?   )r1   r]   r   s      r2   r?   zEnumCallAnalyzer.fail  s    c3r4   N)r+   r   r,   r   r-   r.   )r5   r
   r6   r7   r-   r7   )rD   r   rE   rF   r6   r7   r-   rG   )
r   rF   rY   r^   rN   rF   rQ   r_   r-   r   )rW   r   rm   rF   r-   rn   )r   rF   r   r   r-   rn   )r]   rF   r   r   r-   r.   )
__name__r#   __qualname__r3   rC   r=   rR   rO   r   r?   r}   r4   r2   r*   r*   :   s              (2 2 2 2h   ,e3 e3 e3 e3N! ! ! !           r4   r*   N)'r%   
__future__r   typingr   r   
mypy.nodesr   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   mypy.optionsr   mypy.semanal_sharedr   
mypy.typesr   r   	frozensetr   r$   r(   r*   r}   r4   r2   <module>r      s:    
 # " " " " "                                                   , !           9 9 9 9 9 9 3 3 3 3 3 3 3 3 IN 
     &I	
 
" 	 	 	 	 	       "S  S  S  S  S  S  S  S  S  S r4   