o
    tBhWm                     @  s  U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	Z
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 ddlm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  ddl!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/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z? ddl@mAZA ddlBmCZC g dZDdeEd< g dZFdeEd< G dd deZGG dd deCeG ZHd2d$d%ZId3d)d*ZJd4d-d.ZKd5d0d1ZLdS )6z?Pattern checker. This file is conceptually part of TypeChecker.    )annotations)defaultdict)
NamedTuple)FinalN)message_registry)analyze_member_access)expand_type_by_instance)
join_typesliteral_hash)map_instance_to_supertype)narrow_declared_type)MessageBuilder)ARG_POS
ExpressionNameExpr	TypeAliasTypeInfoVar)		AsPatternClassPatternMappingPattern	OrPatternPatternSequencePatternSingletonPatternStarredPatternValuePattern)Plugin)
is_subtype)coerce_to_literalmake_simplified_union"try_getting_str_literals_from_type)AnyTypeInstanceLiteralTypeNoneType
ProperType	TupleTypeTypeTypedDictType	TypeOfAnyUninhabitedType	UnionTypeget_proper_type)fill_typevars)PatternVisitor)builtins.boolbuiltins.bytearraybuiltins.bytesbuiltins.dictzbuiltins.floatzbuiltins.frozensetzbuiltins.intbuiltins.listzbuiltins.setbuiltins.strzbuiltins.tupler   self_match_type_names)r6   r3   r2   non_sequence_match_type_namesc                   @  s&   e Zd ZU ded< ded< ded< dS )PatternTyper)   type	rest_typedict[Expression, Type]capturesN)__name__
__module____qualname____annotations__ rB   rB   h/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/mypy/checkpattern.pyr9   J   s   
 r9   c                   @  s$  e Zd ZU dZded< ded< ded< ded	< d
ed< ded< ded< ded< d]ddZd^ddZd_ddZd`ddZdad d!Z	dbd#d$Z
dcd&d'Zddd*d+Zded1d2Zdfd4d5Zdgd7d8Zdhd:d;Zdid?d@ZdjdAdBZdkdDdEZdldHdIZdmdKdLZdndOdPZdodTdUZdpdXdYZdqdZd[Zd\S )rPatternCheckerzPattern checker.

    This class checks if a pattern can match a type, what the type can be narrowed to, and what
    type capture patterns should be inferred as.
    mypy.checker.TypeCheckerchkr   msgr   pluginr   subjectr)   subject_type
list[Type]type_contextself_match_typesnon_sequence_match_typesreturnNonec                 C  s4   || _ || _|| _g | _| t| _| t| _d S N)	rF   rG   rH   rL   generate_types_from_namesr7   rM   r8   rN   )selfrF   rG   rH   rB   rB   rC   __init__j   s   
zPatternChecker.__init__or   r9   c                 C  s$   | j | || }| j   |S rQ   )rL   appendacceptpop)rS   rU   rL   resultrB   rB   rC   rW   u   s   

zPatternChecker.acceptr   c                 C  s   | j d }|jd ur| |j|}|\}}}n	|t i }}}t|sA|jd urA| jj|t|g||d\}}t|sA|||j< t	|||S Ndefault)
rL   patternrW   r,   is_uninhabitednamerF   #conditional_types_with_intersectionget_type_ranger9   )rS   rU   current_typepattern_typetypr;   type_map_rB   rB   rC   visit_as_pattern|   s   



zPatternChecker.visit_as_patternr   c                 C  sj  | j d }g }|jD ]}| ||}|| |j}q
g }|D ]}t|js,||j qtt}|d j	
 D ]\}}	t|}
||
 ||	f q8t|dd  D ]6\}}dd |j	
 D }| |krq| jtj|j|  |j	
 D ]\}}	t|}
||
 ||	f qvqRi }|
 D ]\}}t }	|D ]	\}}t|	|}	q|	||d d < qt|}t|||S )Nr[   r      c                 S  s   h | ]\}}t |qS rB   )get_var).0exprrg   rB   rB   rC   	<setcomp>       z2PatternChecker.visit_or_pattern.<locals>.<setcomp>)rL   patternsrW   rV   r;   r_   r:   r   listr=   itemsrj   	enumeratekeysrG   failr   OR_PATTERN_ALTERNATIVE_NAMESr,   r	   r!   r9   )rS   rU   rc   pattern_typesr^   rd   typescapture_typesrl   re   nodeivarsr=   varcapture_listrg   other
union_typerB   rB   rC   visit_or_pattern   s>   



zPatternChecker.visit_or_patternr   c                 C  st   | j d }| jj|j}t|}| jj|t|g||d\}}tt	|t
tfs4t|t||gi S t||i S rZ   )rL   rF   expr_checkerrW   rl   r    ra   rb   
isinstancer.   r%   r,   r9   r-   
make_union)rS   rU   rc   re   narrowed_typer;   rB   rB   rC   visit_value_pattern   s   

z"PatternChecker.visit_value_patternr   c                 C  sj   | j d }|j}t|tr| jj|d}n
|d u rt }nJ | jj|t	|g||d\}}t
||i S )Nr[   r1   Fr\   )rL   valuer   boolrF   r   infer_literal_expr_typer&   ra   rb   r9   )rS   rU   rc   r   re   r   r;   rB   rB   rC   visit_singleton_pattern   s   


z&PatternChecker.visit_singleton_patternr   c                 C  s  t | jd }| |s|  S dd t|jD }d }t|dkr'|d }n
t|dkr1J dt|j}|d ur>|d8 }t|tra|j	}t|| }|dk rT|  S |dkr`|d u r`|  S n| 
|}|d u rp| jd	}|gt|j }g }	g }
i }| |||}d
}t|j|D ]&\}}| ||}|\}}}t|rd}n
|	| |
| | || q| |	|t|}| |
|t|}|}|st }n~t|tr g }g }t||D ]\}}| jj|t|g||d\}}|| || qtdd |D rt||j}nt }tdd |D rt||j}n,t }|D ]}t||}q%| ||}t||rJ| jj|t|g||d\}}n|}t|||S )Nr[   c                 S  s   g | ]\}}t |tr|qS rB   )r   r   )rk   rz   prB   rB   rC   
<listcomp>   s    z9PatternChecker.visit_sequence_pattern.<locals>.<listcomp>ri   r      Fz/Parser should prevent multiple starred patternsbuiltins.objectTr\   c                 s  s    | ]}t | V  qd S rQ   r_   rk   re   rB   rB   rC   	<genexpr>'  s    z8PatternChecker.visit_sequence_pattern.<locals>.<genexpr>c                 s  s    | ]}t |V  qd S rQ   r   r   rB   rB   rC   r   ,  s    )r.   rL   can_match_sequenceearly_non_matchrr   ro   lenr   r(   rq   get_sequence_typerF   
named_typecontract_starred_pattern_typesziprW   r_   rV   update_type_mapexpand_starred_pattern_typesr,   ra   rb   allpartial_fallbackr	   construct_sequence_childr   r9   )rS   rU   rc   star_positionsstar_positionrequired_patternsinner_types	size_diff
inner_typecontracted_new_inner_typescontracted_rest_inner_typesr=   contracted_inner_types	can_matchr   trd   re   restrf   new_inner_typesrest_inner_typesr;   new_typenarrowed_inner_typesinner_rest_typesnew_inner_typenarrowed_inner_typeinner_rest_typerg   rB   rB   rC   visit_sequence_pattern   s   










z%PatternChecker.visit_sequence_patternr   Type | Nonec                   s   t |}t|trttj|S t|tr1 fdd|jD }dd |D }t|dkr/t|S d S  j	
|rBt|trB j	|S d S )Nc                   s   g | ]}  |qS rB   )r   rk   itemrS   rB   rC   r   A  s    z4PatternChecker.get_sequence_type.<locals>.<listcomp>c                 S  s   g | ]}|d ur|qS rQ   rB   r   rB   rB   rC   r   B  rn   r   )r.   r   r#   r+   from_another_anyr-   rq   r   r!   rF   type_is_iterabler$   iterable_item_type)rS   r   rq   not_none_itemsrB   r   rC   r   <  s   

z PatternChecker.get_sequence_typerw   star_pos
int | Nonenum_patternsintc                 C  sV   |du r|S |d| }t || }|t||||   |||| d 7 }|S )aj  
        Contracts a list of types in a sequence pattern depending on the position of a starred
        capture pattern.

        For example if the sequence pattern [a, *b, c] is matched against types [bool, int, str,
        bytes] the contracted types are [bool, Union[int, str], bytes].

        If star_pos in None the types are returned unchanged.
        N)r   rV   r!   )rS   rw   r   r   	new_typesstar_lengthrB   rB   rC   r   M  s   z-PatternChecker.contract_starred_pattern_types	num_typesc                 C  sR   |du r|S |d| }|t | d }||| g| 7 }|||d d 7 }|S )zUndoes the contraction done by contract_starred_pattern_types.

        For example if the sequence pattern is [a, *b, c] and types [bool, int, str] are extended
        to length 4 the result is [bool, int, int, str].
        Nri   )r   )rS   rw   r   r   r   r   rB   rB   rC   r   b  s   z+PatternChecker.expand_starred_pattern_typesr   c                 C  sB   i }|j d ur| jd| jd g}|||j < t| jd t |S )Nr5   r[   )capturerF   named_generic_typerL   r9   r,   )rS   rU   r=   	list_typerB   rB   rC   visit_starred_patterns  s
   

z$PatternChecker.visit_starred_patternr   c                 C  s  t | jd }d}i }t|j|jD ],\}}| |||}|d u r)d}| jd}| ||}t	|j
r7d}q| ||j q|jd ur{| jd}	t||	rgt|trgt||	j
}
| jd}t||
j}n| jd}| jd||g}|||j< |r| jd }nt }t|||S )Nr[   TFr   ztyping.Mappingr4   )r.   rL   r   rs   valuesget_mapping_item_typerF   r   rW   r_   r:   r   r=   r   r   r   r$   r   lookup_typeinfoargsr   r,   r9   )rS   rU   rc   r   r=   keyr   r   rd   mappingmapping_instdict_typeinfor;   object_typer   rB   rB   rC   visit_mapping_patternz  s6   


z$PatternChecker.visit_mapping_patternr^   mapping_typer   c                 C  s   t |}t|trY| j }| jj||}| }W d    n1 s%w   Y  |rW| j }| 	|||}| rGd }W d    |S W d    |S 1 sRw   Y  |S | j  | 	|||}W d    |S 1 sqw   Y  |S rQ   )
r.   r   r*   rG   filter_errorsrF   r   visit_typeddict_index_exprhas_new_errorsget_simple_mapping_item_type)rS   r^   r   r   local_errorsrY   has_local_errorsrB   rB   rC   r     s4   




z$PatternChecker.get_mapping_item_typec                 C  s"   | j jd||gtg|\}}|S )N__getitem__)rF   r   check_method_call_by_namer   )rS   r^   r   r   rY   rg   rB   rB   rC   r     s   z+PatternChecker.get_simple_mapping_item_typer   c                  C  s8  t | jd }|jj}|d u rtttjttji S t|t	r/|j
s/| jtj| |  S t|trFttj}t||gt|jj }n't|t	rO|j}nt|trZt|j}n|j}| jtj||j |  S | jj|t|g||d\}}t |r|  S t!||}	g }
t" }i }t|j#dkrN| $|rt|j#dkr| jtj%| | &|j#d |	}t |jst|jt'||j(|j)S |j)}n| j* }t+d||ddd| j|| jd	}|, }W d    n1 sw   Y  |r| jtj-|| |  S t |}t|t.r)t/|}t|j#t|kr(| jtj%| |  S nd gt|j# }t0||j#D ]\}}|
1||f |d urL|2| q7t" }d}t0|j3|j4D ]6\}}|
1||f ||v rx| jtj5|| d}n||v r| jtj6|| d}|2| qZ|r|  S d}|
D ]s\}}d }| j* &}|d urt+||	|ddd| j|| jd	}nttj}|, }W d    n	1 sw   Y  |s|d u rttj}| jtj7||| | &||\}}}t |rd}q| 8|| t |s|}q|st9 }t|||S )	Nr[   r\   r   ri   __match_args__F)original_typerF   T):r.   rL   	class_refry   r9   r#   r+   
from_errorr   r   no_argsrG   rt   r    CLASS_PATTERN_GENERIC_TYPE_ALIASr   r   implementation_artifactr$   r   defn	type_varstargetr   strr:   r`   CLASS_PATTERN_TYPE_REQUIREDformatrF   ra   rb   r_   r   setpositionalsshould_self_match&CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGSrW   r	   r;   r=   r   r   r   MISSING_MATCH_ARGSr(   get_match_arg_namesr   rV   addkeyword_keyskeyword_values(CLASS_PATTERN_KEYWORD_MATCHES_POSITIONAL'CLASS_PATTERN_DUPLICATE_KEYWORD_PATTERNCLASS_PATTERN_UNKNOWN_KEYWORDr   r,   ) rS   rU   rc   	type_infoany_typere   r`   r   r;   r   keyword_pairsmatch_arg_setr=   rd   r   match_args_typer   proper_match_args_typematch_arg_namesarg_nameposkeyword_arg_sethas_duplicatesr   r   r   keywordr^   key_typer   r   inner_capturesrB   rB   rC   visit_class_pattern  s   



















z"PatternChecker.visit_class_patternre   r   c                 C  s>   t |}t|tr|jjrdS | jD ]
}t||r dS qdS )NFT)r.   r   r$   r:   is_named_tuplerM   r   )rS   re   r~   rB   rB   rC   r   Q  s   

z PatternChecker.should_self_matchr'   c                   sb   t |trt fdd|jD S  jD ]}t||ddr  dS q jd}t||p0t||S )Nc                 3  s    | ]
}  t|V  qd S rQ   )r   r.   r   r   rB   rC   r   \  s    z4PatternChecker.can_match_sequence.<locals>.<genexpr>T)ignore_promotionsFtyping.Sequence)r   r-   anyrq   rN   r   rF   r   )rS   re   r~   sequencerB   r   rC   r   Z  s   

z!PatternChecker.can_match_sequence
type_names	list[str]c                 C  sZ   g }|D ]&}z| | j| W q ty* } z|ds |W Y d }~qd }~ww |S )Nz	builtins.)rV   rF   r   KeyError
startswith)rS   r  rw   r`   erB   rB   rC   rR   f  s   
z(PatternChecker.generate_types_from_namesoriginal_type_mapr<   extra_type_mapc                 C  sZ   dd |D }|  D ]\}}t||v r&t|}| jtj|j| q|||< qd S )Nc                 S  s   h | ]}t |qS rB   r
   )rk   rl   rB   rB   rC   rm   v  s    z1PatternChecker.update_type_map.<locals>.<setcomp>)	rq   r   rj   rG   rt   r   MULTIPLE_ASSIGNMENTS_IN_PATTERNr   r`   )rS   r
  r  already_capturedrl   re   ry   rB   rB   rC   r   q  s   
zPatternChecker.update_type_map
outer_typer   c                   s   t |}t|tr fdd|jD }t|S jd g}t|jdrCt |}t|t	s4J t
|j}t||}t||S |S )aJ  
        If outer_type is a child class of typing.Sequence returns a new instance of
        outer_type, that is a Sequence of inner_type. If outer_type is not a child class of
        typing.Sequence just returns a Sequence of inner_type

        For example:
        construct_sequence_child(List[int], str) = List[str]
        c                   s&   g | ]} t|r| qS rB   )r   r.   r   r   r   rS   rB   rC   r     s    
z;PatternChecker.construct_sequence_child.<locals>.<listcomp>r  )r.   r   r-   rq   r!   rF   r   r   r   r$   r/   r:   r   )rS   r  r   proper_typerw   r  
empty_typepartial_typerB   r  rC   r     s   	



z'PatternChecker.construct_sequence_childc                 C  s   t t | jd i S )Nr[   )r9   r,   rL   r   rB   rB   rC   r     s   zPatternChecker.early_non_matchN)rF   rE   rG   r   rH   r   rO   rP   )rU   r   rL   r)   rO   r9   )rU   r   rO   r9   )rU   r   rO   r9   )rU   r   rO   r9   )rU   r   rO   r9   )rU   r   rO   r9   )r   r)   rO   r   )rw   rK   r   r   r   r   rO   rK   )rw   rK   r   r   r   r   rO   rK   )rU   r   rO   r9   )rU   r   rO   r9   )r^   r   r   r)   r   r   rO   r   )r^   r   r   r)   r   r   rO   r)   )rU   r   rO   r9   re   r)   rO   r   )re   r'   rO   r   )r  r  rO   rK   )r
  r<   r  r<   rO   rP   )r  r)   r   r)   rO   r)   )rO   r9   )r>   r?   r@   __doc__rA   rT   rW   rh   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rR   r   r   r   rB   rB   rB   rC   rD   P   s@   
 




1


d




$

 

	


rD   re   r(   rO   list[str | None]c                 C  sJ   g }| j D ]}t|}|d u st|dkr|d  q||d  q|S )Nri   r   )rq   r"   r   rV   )re   r   r   r   rB   rB   rC   r     s   
r   rl   r   r   c                 C  s&   t | tsJ | j}t |tsJ |S )zx
    Warning: this in only true for expressions captured by a match statement.
    Don't call it from anywhere else
    )r   r   ry   r   )rl   ry   rB   rB   rC   rj     s   rj   r)   mypy.checker.TypeRangec                 C  s<   t | } t| tr| jrt| jjtr| j} tjj| ddS )NF)is_upper_bound)	r.   r   r$   last_known_valuer   r   mypychecker	TypeRangere   rB   rB   rC   rb     s   rb   r   c                 C  s   t t| tS rQ   )r   r.   r,   r  rB   rB   rC   r_     s   r_   )re   r(   rO   r  )rl   r   rO   r   )re   r)   rO   r  r  )Mr  
__future__r   collectionsr   typingr   typing_extensionsr   mypy.checkerr  r   mypy.checkmemberr   mypy.expandtyper   	mypy.joinr	   mypy.literalsr   mypy.maptyper   	mypy.meetr   mypy.messagesr   
mypy.nodesr   r   r   r   r   r   mypy.patternsr   r   r   r   r   r   r   r   r   mypy.pluginr   mypy.subtypesr   mypy.typeopsr    r!   r"   
mypy.typesr#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   mypy.typevarsr/   mypy.visitorr0   r7   rA   r8   r9   rD   r   rj   rb   r_   rB   rB   rB   rC   <module>   sD     ,8    
S

