U Qht@sUdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddlm Z mZmZddlZddlmZmZmZmZddlmZmZmZmZejd kredZeeZndd lmZdd lmZe rdd lm Z e dd dddddZ!ddddddZ"dddddZ#dddddZ$dddddZ%dd dd!d"Z&dddd#d$Z'dd%dd&d'Z(dddd(d)Z)dd%dd*d+Z*dddd,d-Z+dddd.d/Z,dddd0d1Z-dddd2d3Z.ej/fZ0d4e1d5<ejd kre0ej/fZ0dddd6d7Z2ej3fZ4d8e1d9<ejd:kr.e4ej3fZ4dd;ddd?Z6e7d@Z8ddddAdBZ9ddddCdDZ:ddddEdFZ;ddddGdHZejfZ?dMe1dN<e@e dOre?e jfZ?ddPdQdRdSZAdeejBdejBdfZCde1dT<ddddUdVZDddddWdXZEejdYkrNddddZd[ZFndd\lGmHZHdd]dd^d[ZFejd krdddd_d`ZIdaddbdcddZJn dddded`ZIddddfddZJejdYkrejKfZLde1dg<n:ejd krejKejMfZLde1dg<nejKejMejNfZLde1dg<ejOZPde1dh<didjdkdlddmdndodpZQdddqdrdsZRddtdudvdwdxdydzZSddtdadvd{dxd|d}ZTddd~dddddZUddd~dddddZVedddddd~dddddZWddd~ddddddZXddd~ddddddZYddd~ddddddZZdddddZ[ddddddd~dd{dddZ\ejdkshd ejkrddkrnnddjddddddddZ]nej^Z]ejd krej_Z_nej`dddmdmdd{dddZ_dS)zoLogic for interacting with type annotations, mostly extensions, shims and hacks to wrap Python's typing module.) annotationsN) lru_cachepartial) TYPE_CHECKINGAnyCallable)TypeIs deprecatedget_args get_origin)GlobalsNamespaceMappingNamespace NsResolverget_module_ns_of ) EllipsisType)NoneType) BaseModel)maxsizestrztuple[Any, ...])namereturncs0tfddttfD}|s,td|S)zVGet the member named `name` from both `typing` and `typing-extensions` (if it exists).c3s"|]}t|rt|VqdSN)hasattrgetattr).0modulerF./venv/lib/python3.8/site-packages/pydantic/_internal/_typing_extra.py #s z1_get_typing_objects_by_name_of..z>Neither `typing` nor `typing_extensions` has an object called )tupletypingtyping_extensions ValueError)rresultr!r r"_get_typing_objects_by_name_of sr)objectbool)objrrcCs t|D]}||krdSqdS)zmReturn whether `obj` is the member of the typing modules (includes the `typing-extensions` one) named `name`.TF)r))r,rthingr!r!r"_is_typing_name,s r.r)tprcCs t|ddS)zReturn whether the provided argument is the `Any` special form. ```python {test="skip" lint="skip"} is_any(Any) #> True ``` rr r.r/r!r!r"is_any5sr2cCstt|ddS)zReturn whether the provided argument is a `Union` special form. ```python {test="skip" lint="skip"} is_union(Union[int, str]) #> True is_union(int | str) #> False ``` Unionr r.r r1r!r!r"is_union@s r5cCstt|ddS)zReturn whether the provided argument is a `Literal` special form. ```python {test="skip" lint="skip"} is_literal(Literal[42]) #> True ``` Literalr r4r1r!r!r" is_literalMsr7z list[Any]cCs$t|s|gSt|}dd|DS)zCReturn the values contained in the provided `Literal` special form.cSsg|]}t|D]}|qqSr!)literal_values)rvaluexr!r!r" `s z"literal_values..)r7r )r/valuesr!r!r"r8Zsr8cCstt|ddS)zReturn whether the provided argument is a `Annotated` special form. ```python {test="skip" lint="skip"} is_annotated(Annotated[int, ...]) #> True ``` Z Annotatedr r4r1r!r!r" is_annotatedcsr=z Any | NonecCst|rt|dSdS)z;Return the type of the `Annotated` special form, or `None`.rN)r=r r1r!r!r"annotated_typensr>cCstt|ddS)zReturn whether the provided argument is a `Unpack` special form. ```python {test="skip" lint="skip"} is_unpack(Unpack[Ts]) #> True ``` ZUnpackr r4r1r!r!r" is_unpackssr?cCst|rt|dSdS)z@Return the type wrapped by the `Unpack` special form, or `None`.rN)r?r r1r!r!r" unpack_type~sr@cCs t|ddS)zReturn whether the provided argument is the `Self` special form. ```python {test="skip" lint="skip"} is_self(Self) #> True ``` ZSelfr r0r1r!r!r"is_selfsrAcCs(tjdkrt|dStt|ddSdS)zReturn whether the provided argument is a `NewType`. ```python {test="skip" lint="skip"} is_new_type(NewType('MyInt', int)) #> True ``` rZ __supertype__ZNewTyper N)sys version_inforr.typer1r!r!r" is_new_types  rEcCs|tjjkpt|tjjkS)zReturn whether the provided argument is the `Hashable` class. ```python {test="skip" lint="skip"} is_hashable(Hashable) #> True ``` ) collectionsabcHashabler r1r!r!r" is_hashables rIcCs|tjjkpt|tjjkS)aReturn whether the provided argument is a `Callable`, parametrized or not. ```python {test="skip" lint="skip"} is_callable(Callable[[int], str]) #> True is_callable(typing.Callable) #> True is_callable(collections.abc.Callable) #> True ``` )rFrGrr r1r!r!r" is_callablesrJz-tuple[type[typing_extensions.ParamSpec], ...]_PARAMSPEC_TYPEScCs t|tS)zReturn whether the provided argument is a `ParamSpec`. ```python {test="skip" lint="skip"} P = ParamSpec('P') is_paramspec(P) #> True ``` ) isinstancerKr1r!r!r" is_paramspecs rMz1tuple[type[typing_extensions.TypeAliasType], ...]_TYPE_ALIAS_TYPES)r z'TypeIs[typing_extensions.TypeAliasType]cCs t|tS)aReturn whether the provided argument is an instance of `TypeAliasType`. ```python {test="skip" lint="skip"} type Int = int is_type_alias_type(Int) #> True Str = TypeAliasType('Str', str) is_type_alias_type(Str) #> True ``` )rLrNr1r!r!r"is_type_alias_types rPcCst|ddptt|ddS)aReturn whether the provided argument is a `ClassVar` special form, parametrized or not. Note that in most cases, you will want to use the `is_classvar_annotation` function, which is used to check if an annotation (in the context of a Pydantic model or dataclass) should be treated as being a class variable. ```python {test="skip" lint="skip"} is_classvar(ClassVar[int]) #> True is_classvar(ClassVar) #> True ZClassVarr r4r1r!r!r" is_classvarsrQz(((\w+\.)?Annotated\[)?(\w+\.)?ClassVar\[cCsbt|s t|}dk r$t|r$dSd}t|tjr:|j}t|trH|}|dk r^t|r^dSdS)a?Return whether the provided argument represents a class variable annotation. Although not explicitly stated by the typing specification, `ClassVar` can be used inside `Annotated` and as such, this function checks for this specific scenario. Because this function is used to detect class variables before evaluating forward references (or because evaluation failed), we also implement a naive regex match implementation. This is required because class variables are inspected before fields are collected, so we try to be as accurate as possible. NTF) rQr>rLr% ForwardRef__forward_arg__r _classvar_rematch)r/ZanntpZstr_annr!r!r"is_classvar_annotations   rVcCst|ddptt|ddS)zReturn whether the provided argument is a `Final` special form, parametrized or not. ```python {test="skip" lint="skip"} is_finalvar(Final[int]) #> True is_finalvar(Final) #> True ZFinalr r4r1r!r!r" is_finalvars rWcCstt|ddS)zReturn whether the provided argument is a `Required` special form. ```python {test="skip" lint="skip"} is_required(Required[int]) #> True ZRequiredr r4r1r!r!r" is_requiredsrXcCstt|ddS)zReturn whether the provided argument is a `NotRequired` special form. ```python {test="skip" lint="skip"} is_required(Required[int]) #> True Z NotRequiredr r4r1r!r!r"is_not_required(srYcCs t|ddS)zReturn whether the provided argument is the `NoReturn` special form. ```python {test="skip" lint="skip"} is_no_return(NoReturn) #> True ``` ZNoReturnr r0r1r!r!r" is_no_return2srZcCs t|ddS)zReturn whether the provided argument is the `Never` special form. ```python {test="skip" lint="skip"} is_never(Never) #> True ``` ZNeverr r0r1r!r!r"is_never=sr[z.tuple[type[typing_extensions.deprecated], ...]_DEPRECATED_TYPESr zTypeIs[deprecated])r,rcCs t|tS)zrReturn whether the argument is an instance of the `warnings.deprecated` class or the `typing_extensions` backport.)rLr\)r,r!r!r"is_deprecated_instanceMsr] _NONE_TYPEScCs|tkS)aReturn whether the argument represents the `None` type as part of an annotation. ```python {test="skip" lint="skip"} is_none_type(None) #> True is_none_type(NoneType) #> True is_none_type(Literal[None]) #> True is_none_type(type[None]) #> False )r^r1r!r!r" is_none_typeUs r_cCs ddlm}||tot|dS)zReturn whether the provided argument is a named tuple class. The class can be created using `typing.NamedTuple` or `collections.namedtuple`. Parametrized generic classes are *not* assumed to be named tuples. r )lenient_issubclass_fields)Z_utilsr`r$r)r/r`r!r!r" is_namedtuplees rbr cCsdS)EReturn whether the provided argument is the `zoneinfo.ZoneInfo` type.Fr!r1r!r!r"is_zoneinfo_typersrfZoneInfozTypeIs[type[ZoneInfo]]cCs|tkS)rergr1r!r!r"rfyscCs t|ddS)zAReturn whether the provided argument is the `Union` special form.r3r r0r1r!r!r"origin_is_unionsriz type[Any])type_rcCs t|tjSr)rLr% _GenericAlias)rjr!r!r"is_generic_aliassrlcCst|ddp|tjkS)zTReturn whether the provided argument is the `Union` special form or the `UnionType`.r3r )r.types UnionTyper1r!r!r"riscCst|tjtjfSr)rLrm GenericAliasr%rkr1r!r!r"rls WithArgsTypes typing_baseF) parent_depthforceintzdict[str, Any] | None)rsrtrcCs4t|}|r|jS|jdks*|jjdkr.dS|jS)aWe allow use of items in parent namespace to get around the issue with `get_type_hints` only looking in the global module namespace. See https://github.com/pydantic/pydantic/issues/2678#issuecomment-1008139014 -> Scope and suggestion at the end of the next comment by @gvanrossum. WARNING 1: it matters exactly where this is called. By default, this function will build a namespace from the parent of where it is called. WARNING 2: this only looks in the parent namespace, not other parents since (AFAIK) there's no way to collect a dict of exactly what's in scope. Using `f_back` would work sometimes but would be very wrong and confusing in many other cases. See https://discuss.python.org/t/is-there-a-way-to-access-parent-nested-namespaces/20659. There are some cases where we want to force fetching the parent namespace, ex: during a `model_rebuild` call. In this case, we want both the namespace of the class' module, if applicable, and the parent namespace of the module where the rebuild is called. In other cases, like during initial schema build, if a class is defined at the top module level, we don't need to fetch that module's namespace, because the class' __module__ attribute can be used to access the parent namespace. This is done in `_namespace_utils.get_module_ns_of`. Thus, there's no need to cache the parent frame namespace in this case. Nz)rB _getframef_localsf_backf_codeco_name)rsrtframer!r!r"parent_frame_namespaces  r|)argrcCs(|dkr tSt|tr$t|dddS|S)aConvert `None` to `NoneType` and strings to `ForwardRef` instances. This is a backport of the private `typing._type_convert` function. When evaluating a type, `ForwardRef._evaluate` ends up being called, and is responsible for making this conversion. However, we still have to apply it for the first argument passed to our type evaluation functions, similarly to the `typing.get_type_hints` function. NFT is_argumentis_class)rrLr_make_forward_ref)r}r!r!r" _type_converts  r) ns_resolverztype[BaseModel]zNsResolver | Nonezdict[str, tuple[Any, bool]])r,rrc Csi}|p t}t|jD]}|jd}|rt|tjr:q||t|j \}}| D]Z\}}| drzt |||||<Wqt k r|df||<YqXqXt |||||<qXW5QRXq|S)aCollect annotations from a Pydantic model class, including those from parent classes. Args: obj: The Pydantic model to inspect. ns_resolver: A namespace resolver instance to use. Defaults to an empty instance. Returns: A dictionary mapping annotation names to a two-tuple: the first element is the evaluated type or the original annotation if a `NameError` occurred, the second element is a boolean indicating if whether the evaluation succeeded. __annotations___F)rreversed__mro____dict__getrLrmGetSetDescriptorTypepushtypes_namespaceitems startswith try_eval_type Exception r,rhintsbaseannglobalnslocalnsrr9r!r!r"get_model_type_hintss      rzdict[str, Any]c Csi}|p t}t|jD]d}|jd}|rt|tjr:q||2|j \}}| D]\}}t |||||<qXW5QRXq|S)zCollect annotations from a class, including those from parent classes. Args: obj: The class to inspect. ns_resolver: A namespace resolver instance to use. Defaults to an empty instance. r) rrrrrrLrmrrrr eval_typerr!r!r"get_cls_type_hintss     rzGlobalsNamespace | NonezMappingNamespace | Noneztuple[Any, bool])r9rrrcCs<t|}zt|||dfWStk r6|dfYSXdS)aTry evaluating the annotation using the provided namespaces. Args: value: The value to evaluate. If `None`, it will be replaced by `type[None]`. If an instance of `str`, it will be converted to a `ForwardRef`. localns: The global namespace to use during annotation evaluation. globalns: The local namespace to use during annotation evaluation. Returns: A two-tuple containing the possibly evaluated type and a boolean indicating whether the evaluation succeeded or not. TFN)reval_type_backport NameErrorr9rrr!r!r"rs rcCst|}t|||S)aEvaluate the annotation using the provided namespaces. Args: value: The value to evaluate. If `None`, it will be replaced by `type[None]`. If an instance of `str`, it will be converted to a `ForwardRef`. localns: The global namespace to use during annotation evaluation. globalns: The local namespace to use during annotation evaluation. )rrrr!r!r"r3s rz?`eval_type_lenient` is deprecated, use `try_eval_type` instead.)categorycCst|||\}}|Sr)r)r9rrZevrr!r!r"eval_type_lenientDs rztuple[Any, ...] | None)r9rr type_paramsrc Cszt||||WStk r}zRdt|kr0t|tjs@td|jd}tj dkrf| |n t||W5d}~XYnXdS)aAn enhanced version of `typing._eval_type` which will fall back to using the `eval_type_backport` package if it's installed to let older Python versions use newer typing constructs. Specifically, this transforms `X | Y` into `typing.Union[X, Y]` and `list[X]` into `typing.List[X]` (as well as all the types made generic in PEP 585) if the original syntax is not supported in the current Python version. This function will also display a helpful error if the value passed fails to evaluate. z"Unable to evaluate type annotation#Unable to evaluate type annotation .)r N) _eval_type_backport TypeErrorrrLr%rRAssertionErrorrSrBrCZadd_note)r9rrremessager!r!r"rQs   rc Cszt||||WStk r}zht|tjr6t|s8zddlm}Wn(tk rptd|jd|YnX||||ddWYSd}~XYnXdS)Nr)rra. If you are making use of the new typing syntax (unions using `|` since Python 3.10 or builtins subscripting since Python 3.9), you should either replace the use of new syntax with the existing `typing` constructs or install the `eval_type_backport` package.F)Z try_default) _eval_typerrLr%rRis_backport_fixable_errorr ImportErrorrS)r9rrrrrr!r!r"rrs& rcCs.tjdkrtj||||dSt|||SdS)N)r )r)rBrCr%r)r9rrrr!r!r"rs rr)rrcCs.t|}tjdkr|dp,tjdko,d|kS)Nrz#unsupported operand type(s) for |: rcz' object is not subscriptable)rrBrCr)rmsgr!r!r"rs  r) include_keysrrzCallable[..., Any]zset[str] | None)functionrrrrc Cszt|tr|jj}n|j}Wn6tk rTt|}t|trL|d||YSX|dkrft|}d}|dkr~t |dd}i}| D]L\}}|dk r||krq|dkrt }nt|t rt |}t||||||<q|S)a'Return type hints for a function. This is similar to the `typing.get_type_hints` function, with a few differences: - Support `functools.partial` by using the underlying `func` attribute. - If `function` happens to be a built-in type (e.g. `int`), assume it doesn't have annotations but specify the `return` key as being the actual type. - Do not wrap type annotation of a parameter with `Optional` if it has a default value of `None` (related bug: https://github.com/python/cpython/issues/90353, only fixed in 3.11+). rNZ__type_params__r!)rLrfuncrAttributeErrorget_type_hintsrD setdefaultrrrrrrr) rrrrrZ type_hintsrrr9r!r!r"get_function_type_hintss0        r)rrd)rrr T)rztyping.ForwardRef)r}rrrcCs t||S)a5Wrapper for ForwardRef that accounts for the `is_class` argument missing in older versions. The `module` argument is omitted as it breaks <3.9.8, =3.10.0 and isn't used in the calls below. See https://github.com/python/cpython/pull/28560 for some background. The backport happened on 3.9.8, see: https://github.com/pydantic/pydantic/discussions/6244#discussioncomment-6275458, and on 3.10.1 for the 3.10 branch, see: https://github.com/pydantic/pydantic/issues/6912 Implemented as EAFP with memory. )r%rR)r}rrr!r!r"rsr)r,rrinclude_extrasrc Csdt|ddriSt|tri}t|jD]}|dkrPttj|jddi}n|}|j di}t|t j rri}|dkrt t |n|}|dkr|dkr||}}|D]D\} } | dkrtd} t| trt| ddd} t| ||} | || <qq*|sttdrd d |DS|S|dkrrt|t jr<|j }n&|} t| d rV| j} q@t| d i}|dkr|}n|dkr|}t|dd}|dkrt|tjriSt|d t|} t |}|D]v\} } | dkrtd} t| trt| t|t j dd} t| ||} | | kr<| | dkrPsz"get_type_hints.. __wrapped__ __globals__z- is not a module, class, method, or function.cSsi|]\}}|t|qSr!rrr!r!r"r}s)rrLrDrrrBmodulesr __module__rrmrdictvarsrrrrrr% ModuleTyperZ_allowed_typesrZ _get_defaultsZOptional) r,rrrrrZ base_globalsrZ base_localsrr9Znsobjdefaultsr!r!r"rst0                      r)NN)NN)NN)NNN)NNN)NNN)T)NNF)a__doc__Z __future__rZcollections.abcrFrerBrmr%warnings functoolsrrrrrr&rr r r Z_namespace_utilsr rrrrCrDrEllipsisrZpydanticrr)r.r2r5r7r8r=r>r?r@rArErIrJZ ParamSpecrKrrMZ TypeAliasTyperNrPrQcompilerTrVrWrXrYrZr[r\rr]r6r^r_rbrfZzoneinforhrirlrkrprornZ_Finalrqr|rrrrrrrrrrrrrRrZ no_type_checkr!r!r!r"s                                   $, # 4*