o )fA@s|ddlmZddlZddlmZddlZddlZddlZddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZ ddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z%dd lm&Z&dd!lm'Z'dd"lm(Z(dd#lm)Z)dd$lm*Z*dd%lm+Z+dd&lm,Z,dd'lm-Z-dd(lm.Z.ed)e d*Z/ed+Z0ed,dd-Z1ed.dd/Z2ed0Z3ed1dd-Z4ej5r dd2l6m7Z7ne8dZ7e d3Z9e#Z:e$Z;eee eGd7d8d8e(e/Z?Gd9d:d:e(e0e4fZ@e%d;ZAddr?^s  r?c@s eZdZd ddZd dd Zd S) SupportsKeysAndGetItemreturn Iterable[_KT]cCdSNr=)selfr=r=r>keysszSupportsKeysAndGetItem.keys_SupportsKeysAndGetItem__kr+r1cCrErFr=)rGrJr=r=r> __getitem__urIz"SupportsKeysAndGetItem.__getitem__N)rCrD)rJr+rCr1)r8r9r:rHrKr=r=r=r>rBrs rB*Fstr_cleanup_fninclude_generic _already_seencls Type[Any] annotation_AnnotationScanTypeoriginating_modulestrlocals_Mapping[str, Any]rN#Optional[Callable[[str, str], str]]rOboolrPOptional[Set[Any]]rCc s|}t|r |j}t|trr|}t|d}rOt|rOt|sOdur.t|vr4|S|t fdd|j D}t ||S|S)a;Resolve annotations that may be string based into real objects. This is particularly important if a module defines "from __future__ import annotations", as everything inside of __annotations__ is a string. We want to at least have generic containers like ``Mapped``, ``Union``, ``List``, etc. rWin_classNc 3s&|]}t|dVqdS)rMNde_stringify_annotation.0elemrPrQrOrWrUrNr=r> s  z*de_stringify_annotation..) is_fwd_ref__forward_arg__ isinstancerVeval_expression is_generic is_literalsetaddtupler6_copy_generic_annotation_with) rQrSrUrWrNrOrPoriginal_annotationelementsr=rcr>r_|s2     r_GenericProtocol[_T]rpr5r@cCst|dr ||S|j|S)N copy_with)hasattrrrrA)rSrpr=r=r>rns   rnr\ expression module_nameOptional[Mapping[str, Any]]r]Optional[Type[Any]]rc Csztj|j}Wnty}z td|d||d}~wwz'|dur?t|j}||j|||t |||}W|St |||}W|St y[}ztd||d}~ww)NModule z9 isn't present in sys.modules; can't evaluate expression z"Could not de-stringify annotation ) sysmodules__dict__KeyError NameErrordict setdefaultr8updateeval Exception) rtrurWr] base_globalske cls_namespacerSerrr=r=r>rhs:  rhrWnamec Csd|vr t|||dSztj|j}Wnty*}z td|d||d}~wwz||WSty]}z!z tj|WWYd}~StyMYnwtd|d||d}~ww)N.rrxz2 isn't present in sys.modules; can't resolve name zCould not locate name z in module )rhryrzr{r|r}builtins)rrurWrrr=r=r>eval_name_onlys:  rcCs2zt||}Wn ty|YSwt|d|S)Nr8)rr}getattr)rruobjr=r=r>resolve_name_to_real_class_names   rrNcstfdd|jDS)Nc sg|] }t|idqS)rr^)raannorQrUrNr=r> %sz/de_stringify_union_elements..)make_union_typer6)rQrSrUrWrNr=rr>de_stringify_union_elementss rtype_Optional[_AnnotationScanType]cCs|duo t|tuSrF)typing_get_originrrr=r=r> is_pep5932rrTypeGuard[Iterable[Any]]cCst|tjo t|ttf SrF)rgcollections_abcr rVbytes)rr=r=r>is_non_string_iterable6srcCs t|tuSrF)rrrr=r=r>rj<s rjTypeGuard[NewType]cC t|dS)N __supertype__rsrr=r=r> is_newtype@ rTypeGuard[GenericProtocol[Any]]cCst|do t|dS)Nr6rArrr=r=r>riHrriTypeGuard[TypeAliasType]cCs t|tSrF)rgr(rr=r=r> is_pep695Lrrr cCs |j}t|r|j}t|s|SrF)rr)r super_typer=r=r>flatten_newtypePs r check_genericTypeGuard[ForwardRef]cCs2t|trdS|rt|rtdd|jDSdS)NTcss|]}t|dVqdS)TN)re)raargr=r=r>rd]szis_fwd_ref..F)rgrrianyr6)rrr=r=r>reWs  recCrErFr=rr=r=r>de_optionalize_union_typesbrcCrErFr=rr=r=r>rfrcCrErFr=rr=r=r>rjscCsBt|rt|St|rt|j}|t|tt|S|S)zmGiven a type, filter out ``Union`` types that include ``NoneType`` to not include the ``NoneType``. ) re"de_optionalize_fwd_ref_union_types is_optionalrkr6discardr2NoneFwdr)rtypr=r=r>rps   rcCs|j}td|}|r4|ddkrt|dS|ddkr2td|d}tdd|DS|Std |}d |vrJtd d d |DS|S)zreturn the non-optional type for Optional[], Union[None, ...], x|None, etc. without de-stringifying forward refs. unfortunately this seems to require lots of hardcoded heuristics z^(.+?)\[(.+)\]$rrrz,\s*cSsg|] }|dkrt|qS)r3rr`r=r=r>rsz6de_optionalize_fwd_ref_union_types..z\s*\|\s*r3|css|] }|dkr|VqdS)r3Nr=)rapr=r=r>rdsz5de_optionalize_fwd_ref_union_types..)rfrematchgrouprsplitrjoin)rrSmmrp pipe_tokensr=r=r>rs   rtypescGsttt|S)zMake a Union type. This is needed by :func:`.de_optionalize_union_types` which removes ``NoneType`` from a ``Union``. )rrrrK)rr=r=r>rsr include_union discard_noneTuple[Type[Any], ...]cCs@t|rt|j}|r|t|r|ft|St|S|fS)zPReturn a type as a tuple of individual types, expanding for ``Union`` types.)is_unionrkr6rr2rm)rrrrr=r=r> expand_unionss  rTypeGuard[ArgsTypeProcotol]cCst|dddS)Nrr UnionType is_origin_ofrr=r=r>rs rcCst|o tt|vSrF)rr2typing_get_argsrr=r=r>is_optional_unionrrcCr)Nrrrr=r=r>rrr class_obj'Union[Tuple[Type[Any], ...], Type[Any]]cCs(t|}|dur dSt|tot||S)z[return True if the given type has an __origin__ that shares a base with the given classNF)rrgtype issubclass)rroriginr=r=r>is_origin_of_clssr)modulenamesr Optional[str]cGs4t|}|dur dSt||vo|dup|j|S)z\return True if the given type has an __origin__ with the given name and optional module.NF)r_get_type_namer9 startswith)rrrrr=r=r>rs  rcCs0tjr|jSt|dd}|durt|dd}|S)Nr8_name)rpy310r8r)rtyp_namer=r=r>rs   rc@s*eZdZdddZdd d Zdd d ZdS)DescriptorProtoinstanceobjectownerrrCcCrErFr=rGrrr=r=r>__get__rIzDescriptorProto.__get__valuer3cCrErFr=rGrrr=r=r>__set__rIzDescriptorProto.__set__cCrErFr=rGrr=r=r> __delete__rIzDescriptorProto.__delete__N)rrrrrCr)rrrrrCr3rrrCr3)r8r9r:rrrr=r=r=r>rs  r_DESCc@6eZdZdZerddd Zdd d ZdddZdSdS)DescriptorReferenceaa descriptor that refers to a descriptor. used for cases where we need to have an instance variable referring to an object that is itself a descriptor, which typically confuses typing tools as they don't know when they should use ``__get__`` or not when referring to the descriptor assignment as an instance variable. See sqlalchemy.orm.interfaces.PropComparator.prop rrrrrCrcCrErFr=rr=r=r>rrIzDescriptorReference.__get__rr3cCrErFr=rr=r=r>rrIzDescriptorReference.__set__cCrErFr=rr=r=r>rrIzDescriptorReference.__delete__N)rrrrrCr)rrrrrCr3rr8r9r:r;rrrrr=r=r=r>rs  r_DESC_co)r*r-c@r)RODescriptorReferenceza descriptor that refers to a descriptor. same as :class:`.DescriptorReference` but is read-only, so that subclasses can define a subtype as the generically contained element rrrrrCrcCrErFr=rr=r=r>r(rIzRODescriptorReference.__get__rr cCrErFr=rr=r=r>r*rIzRODescriptorReference.__set__cCrErFr=rr=r=r>r,rIz RODescriptorReference.__delete__N)rrrrrCr)rrrrrCr )rrrCr rr=r=r=r>rs  r_FN.c@r)CallableReferenceza descriptor that refers to a callable. works around mypy's limitation of not allowing callables assigned as instance variables rrrrrCrcCrErFr=rr=r=r>r=rIzCallableReference.__get__rr3cCrErFr=rr=r=r>r?rIzCallableReference.__set__cCrErFr=rr=r=r>rArIzCallableReference.__delete__N)rrrrrCr)rrrrrCr3rrr=r=r=r>r2s  r)rQrRrSrTrUrVrWrXrNrYrOrZrPr[rCrR)rSrqrpr5rCr@) rtrVrurVrWrvr]rwrCr)rrVrurVrWrvrCr)rrVrurVrCrV) rQrRrSr4rUrVrWrXrNrYrCrR)rrrCrZ)rrrCr)rrTrCrZ)rrrCr)rrTrCr)rrTrCr)rr rCrR)F)rrTrrZrCr)rrVrCrV)rrRrCrR)rrTrCrT)rrrCrT)rrTrCrR)FF)rrRrrZrrZrCr)rrrCr)rrrCrZ)rrrrrCrZ)rrrrVrrrCrZ)rrRrCrV)a __future__rrcollections.abcabcrrrytypingrrrrrr r r r r rrrrrrrrrtyping_extensionsrrrrrrrrr r!r"r#r$r%r&r'r(r)r+r,r.r0r1rrr2rrrrrVrTr4r?rB _LiteralStarr_rnrhrrrrrrjrrirrrerrrrrrrrrrrrrrrrrr=r=r=r>s                                             F( "