o $6d@@sJUdZddlmZddlZddlZddlZddlZddlm Z ddl m Z ddlm Z ddlm Z mZmZddlmZmZmZmZmZmZmZe rOd d lmZzdd lmZWneyfdd lmZYnweZejd krqdZnddlm Zejdkrddlm!Z!m"Z"nddlm!Z!m"Z"ejdkrdzddZ#efZ$n dzddZ#ej%ej ej&fZ$ejdkre'dZ(e'e)Z*nddlm(Z(ehZ+de,d<e-edre+.ejde(gdde+DRZ/d e,d!<eZ0d{d$d%Z1d|d'd(Z2d|d)d*Z3d}d+d,Z4d~d.d/Z5dd1d2Z6d|d3d4Z7e8d5e9Z:d|d6d7Z;dd9d:ZZ>dd?d@Z?dAdBddFdGZ@dddKdLZAdddOdPZBdddQdRZCddUdVZDdddWdd]d^ZEejd_ks_dejkr]d`krjnn addbdcddhdiZFnejZFejdkrwejGZGn ejH   bdddkdlZGejd kr dddodpZIn dddqdpZIddtduZJddxdyZKdS)zoLogic for interacting with type annotations, mostly extensions, shims and hacks to wrap python's typing module.) annotationsN)Callable)partial)GetSetDescriptorType) TYPE_CHECKINGAny ForwardRef) AnnotatedFinalLiteral TypeAliasType TypeGuardget_args get_origin)StandardDataclass) _TypingBase)_Final) ) GenericAlias)r ) NotRequiredRequired)r tptype[Any] | NonereturnboolcCs |tjuSN)typingUnionrrrwC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\pydantic/_internal/_typing_extra.pyorigin_is_union) r%cCs|tjup |tjuSr )r!r"types UnionTyper#rrr$r%0)NoneTypezset[Any] LITERAL_TYPESr ccs|]}|dVqdSr r).0rrrr$ Asr-tuple[Any, ...] NONE_TYPEStype_rcCs|tvSr )r/r0rrr$ is_none_typeGr2 type[Any]cCs|tup t|tuSr )rrr1rrr$is_callable_typeKr)r5cCstduo t|tvSr )r rr+r1rrr$is_literal_typeOr)r6cCst|Sr )rr1rrr$literal_valuesSr3r7 list[Any]cCs(t|s|gSt|}tdd|DS)zThis method is used to retrieve all Literal values as Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586) e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`. css"|] }t|D]}|VqqdSr )all_literal_values)r,valuexrrr$r-`s z%all_literal_values..)r6r7list)r0valuesrrr$r9Wsr9ann_typecCs&ddlm}t|}|duo||tS)Nrlenient_issubclass)_utilsr@rr )r>r@originrrr$ is_annotatedcs rCcCs ddlm}||tot|dS)zuCheck if a given class is a named tuple. It can be either a `typing.NamedTuple` or `collections.namedtuple`. rr?_fields)rAr@tuplehasattr)r0r@rrr$ is_namedtuplejs rG test_new_typecCst|tjo t|dS)zlCheck whether type_ was created using typing.NewType. Can't use isinstance because it fails <3.10. __supertype__) isinstancerH __class__rFr1rrr$ is_new_typevsrLvcCs*|durdS|jtjjkot|dddkS)NF_nameClassVar)rKr!rOgetattrrMrrr$_check_classvar~srRcCs8t|s tt|r dS|jtjkr|jdrdSdS)NTz ClassVar[F)rRrrKr!r__forward_arg__ startswithr>rrr$ is_classvars rVcCs2|durdS|jtjkotjdkpt|dddkS)z/Check if a given type is a `typing.Final` type.NF)rrNr )rKr sys version_inforPrQrrr$_check_finalvars&rZcCst|p tt|Sr )rZrrUrrr$ is_finalvarr)r[) parent_depthr]intdict[str, Any] | NonecCst|}|jdur 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. N)rX _getframef_backf_locals)r]framerrr$parent_frame_namespaces rdobjglobalnsdict[str, Any]cCsTt|dd}|r&ztj|j}Wn tyYn w|r"i||S|S|p)iS)N __module__)rPrXmodules__dict__KeyErrorcopy)rerf module_nameZmodule_globalnsrrr$add_module_globalss   rnclsparent_namespacecCst||}|||j<|Sr )rn__name__)rorpnsrrr$get_cls_types_namespaces  rscCsbi}t|jD]'}|jd}tt|}|dur.|tur.|D] \}}t|||||<q!q|S)zCollect annotations from a class, including those from parent classes. Unlike `typing.get_type_hints`, this function will not error if a forward reference is not resolvable. __annotations__N) reversed__mro__rjgetdictvarsritemseval_type_lenient)rerfhintsbaseannlocalnsnamer:rrr$get_cls_type_hints_lenients  rr:rcCsN|durt}n t|trt|ddd}zt|||WSty&|YSw)zhBehaves like typing._eval_type, except it won't raise an error if a forward reference can't be resolved.NFT is_argumentis_class)r*rJstr_make_forward_refr! _eval_type NameError)r:rfrrrr$r{s  r{) include_keystypes_namespacefunctionCallable[..., Any]rset[str] | NonercCst|tr |jj}n|j}t|}i}|D]&\}}|dur$||vr$q|dur+t}n t|tr4t|}t |||||<q|S)zLike `typing.get_type_hints`, but doesn't convert `X` to `Optional[X]` if the default value is `None`, also copes with `partial`. N) rJrfuncrtrnrzr*rrr!r)rrrrrfZ type_hintsrr:rrr$get_function_type_hintss   r)rrrW)rrrTF)rargrrtyping.ForwardRefcCs 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!r)rrrrrr$rs rinclude_extrasc CsJt|ddriSt|tri}t|jD]e}|dur'ttj|jddi}n|}|j di}t|t j r8i}|durBt t |n|}|durQ|durQ||}}|D]#\} } | duratd} t| trmt| ddd} t| ||} | || <qUq|r~|Sdd |DS|durt|t jr|j }n|} t| d r| j} t| d st| d i}|dur|}n|dur|}t|dd}|durt|tjriSt|d t|} t |}|D]9\} } | durtd} t| trt| t|t j dd} t| ||} | | vr| | durtj| } | || <q|r|Sd d |DS)aTaken verbatim from python 3.10.8 unchanged, except: * type annotations of the function definition above. * prefixing `typing.` where appropriate * Use `_make_forward_ref` instead of `typing.ForwardRef` to handle the `is_class` argument. https://github.com/python/cpython/blob/aaaf5174241496afca7ce4d4584570190ff972fe/Lib/typing.py#L1773-L1875 DO NOT CHANGE THIS METHOD UNLESS ABSOLUTELY NECESSARY. ====================================================== Return type hints for an object. This is often the same as obj.__annotations__, but it handles forward references encoded as string literals, adds Optional[t] if a default value equal to None is set and recursively replaces all 'Annotated[T, ...]' with 'T' (unless 'include_extras=True'). The argument may be a module, class, method, or function. The annotations are returned as a dictionary. For classes, annotations include also inherited members. TypeError is raised if the argument is not of a type that can contain annotations, and an empty dictionary is returned if no annotations are present. BEWARE -- the behavior of globalns and localns is counterintuitive (unless you are familiar with how eval() and exec() work). The search order is locals first, then globals. - If no dict arguments are passed, an attempt is made to use the globals from obj (or the respective module's globals for classes), and these are also used as the locals. If the object does not appear to have globals, an empty dictionary is used. For classes, the search order is globals first then locals. - If one dict argument is passed, it is used for both globals and locals. - If two dict arguments are passed, they specify globals and locals, respectively. __no_type_check__NrjrtFTrcSi|] \}}|t|qSrr!_strip_annotationsr,ktrrr$ qz"get_type_hints.. __wrapped__ __globals__z- is not a module, class, method, or function.cSrrrrrrr$rr)rPrJtyperurvrXrirwrhrjr'rrxryrzrrr!r ModuleTyperFr_allowed_types TypeError _get_defaultsOptional) rerfrrr|r} base_globalsr~ base_localsrr:nsobjdefaultsrrr$get_type_hints"sx 0                rrefrcCs|j||dS)N)rfr) _evaluaterrfrrrr$evaluate_fwd_refsrcCs|j||tdS)N)rfrrecursive_guard)r frozensetrrrr$rs_cls"TypeGuard[type[StandardDataclass]]cCs t|Sr ) dataclasses is_dataclass)rrrr$rs rrBTypeGuard[TypeAliasType]cCs t|tSr )rJr )rBrrr$origin_is_type_alias_typer&r)rrrr)r0rrr)r0r4rr)r0r4rr.)r0r4rr8)r>rrr)rMrrr)r>r4rr)r]r^rr_r )rerrfr_rrg)ror4rpr_rrg)r:rrfr_rr_rr)rrrrrr_rrg)T)rrrrrrrr)NNF) rerrfr_rr_rrrrg)NN)rrrfr_rr_rr)rr4rr)rBrrr)L__doc__ __future__rZ _annotationsrrXr'r!collections.abcr functoolsrrrrrZtyping_extensionsr r r r r rr _dataclassesrr ImportErrorrZ typing_baserYZTypingGenericAliasrrrr%Z WithArgsTypes _GenericAliasr(rr*Ellipsis EllipsisTyper+rtrFaddr/Z TypeVarTyper2r5r6r7r9rCrGNewTyperrHrLrRrVrZr[rdrnrsrr{rrr no_type_checkrrrrrrr$s    $                            *  z