IhQUdZddlmZddlZddlZddlmZmZddlm Z ddl m Z m Z m Z ddlmZmZmZmZddlmZmZmZmZd d lmZd Zej6d k\rd'd Znd'dZd(dZddd d)dZedZde d< e!eeZ"de d<Gdde Z#Gdde$Z%Gdde Z&e&jNZ' ee&jNZ(de d< Gd d!eZ)d"d# d*d$Z* d+d%Z+dd# d,d&Z,y)-zEHigh-level introspection utilities, used to inspect type annotations.) annotationsN) GeneratorSequence)InitVar)EnumIntEnumauto)AnyLiteral NamedTuplecast) TypeAlias assert_neverget_args get_origin)typing_objects)AnnotationSourceForbiddenQualifierInspectedAnnotation Qualifierget_literal_valuesinspect_annotationis_union_origin) cTtj|xs|tjuSzReturn whether the provided origin is the union form. ```pycon >>> is_union_origin(typing.Union) True >>> is_union_origin(get_origin(int | str)) True ``` )ris_uniontypes UnionTypeobjs S/var/www/test/myenv/lib/python3.12/site-packages/typing_inspection/introspection.pyrrs#&&s+Eseoo/EEc,tj|Sr)rrr"s r$rr*s&&s++r%c t|ttttt t jfs!|t jurt|dyy)zCType check the provided literal value against the legal parameters.zK is not a valid literal value, must be one of: int, bytes, str, Enum, None.N) isinstanceintbytesstrboolrrNoneType TypeError)values r$_literal_type_checkr07sM usE3dN>> type MyAlias = Literal[1, 2] >>> list(get_literal_values(Literal[MyAlias, 3], unpack_type_aliases="skip")) [MyAlias, 3] ``` - `'lenient'`: Try to parse type aliases, and fallback to `'skip'` if the type alias can't be inspected (because of an undefined forward reference). - `'eager'`: Parse type aliases and raise any encountered [`NameError`][] exceptions (the default): ```pycon >>> type MyAlias = Literal[1, 2] >>> list(get_literal_values(Literal[MyAlias, 3], unpack_type_aliases="eager")) [1, 2, 3] ``` Note: While `None` is [equivalent to][none] `type(None)`, the runtime implementation of [`Literal`][typing.Literal] does not de-duplicate them. This function makes sure this de-duplication is applied: ```pycon >>> list(get_literal_values(Literal[NoneType, None])) [None] ``` Example: ```pycon >>> type Ints = Literal[1, 2] >>> list(get_literal_values(Literal[1, Ints], unpack_type_alias="skip")) ["a", Ints] >>> list(get_literal_values(Literal[1, Ints])) [1, 2] >>> list(get_literal_values(Literal[1.0], type_check=True)) Traceback (most recent call last): ... TypeError: 1.0 is not a valid literal value, must be one of: int, bytes, str, Enum, None. ``` skipFNTr2c36K|]}|t|fywN)type).0as r$ z%get_literal_values..s*JAAtAw<*Jsr1c3&K|] \}}| ywr8r:p_s r$r<z%get_literal_values..s*da*c3&K|] \}}| ywr8r>r?s r$r<z%get_literal_values..s6da6rB)__args__r0rr-is_typealiastype __value__rextend NameErrorappendr9dictfromkeysr.) annotationr3r4 _has_noneargvalues_and_type alias_valuesub_argsdcts r$rr@stf$ && C#C({c^%<%<< J   8:&& =C ..s3 K"%--K 2# Pc H$***J*JJ',.111#**D.2I2I+JK#**Cc+;<5 =8 +--0C +c* * *5!=*g5!+C0#**Cc+;< =4 +  76o6 6 6 7sgA.F 1 D+=BF E, F %E*&F +8E'#F &E''F ,F FF F  F  F )required not_required read_only class_varinit_varfinalrrset[Qualifier]_all_qualifiersceZdZdZeZ eZ eZ eZ eZ eZ eZ eZ e ddZy)rzThe source of an annotation, e.g. a class or a function. Depending on the source, different [type qualifiers][type qualifier] may be (dis)allowed. cn|tjurdhS|tjurddhS|tjurhdS|tjurhdS|tj tj tjfvr tS|tjurtSt|y)zIThe allowed [type qualifiers][type qualifier] for this annotation source.rXrV>rXrWrV>rSrUrTN) rASSIGNMENT_OR_VARIABLECLASS DATACLASS TYPED_DICT NAMED_TUPLEFUNCTIONBAREsetANYrZrselfs r$allowed_qualifiersz#AnnotationSource.allowed_qualifierss #:: :9  %++ +[) ) %// /5 5 %00 0< < &224D4M4MO_OdOde e5L %)) )" "  r%N)returnrY)__name__ __module__ __qualname____doc__r r]r^r_r`rarbrercpropertyrhr>r%r$rrs "V FE I J &K vH &C 6D r%rc&eZdZUdZded< ddZy)rz-The provided [type qualifier][] is forbidden.r qualifierc||_yr8)rp)rgrps r$__init__zForbiddenQualifier.__init__/s "r%N)rprriNone)rjrkrlrm__annotations__rrr>r%r$rr)s7"#r%rc*eZdZeZddZddZy)_UnknownTypeEnumcy)NUNKNOWNr>rfs r$__str__z_UnknownTypeEnum.__str__6sr%cy)Nz r>rfs r$__repr__z_UnknownTypeEnum.__repr__9sr%N)rir+)rjrkrlr rxryr{r>r%r$rvrv3sfGr%rv _UnkownTypec4eZdZUdZded< ded< ded<y) rz'The result of the inspected annotation.zAny | _UnkownTyper9rY qualifiersz Sequence[Any]metadataN)rjrkrlrmrtr>r%r$rrDs$1  J!r%rr6r4c:|j}t}g} t||\}}|r||z}t|}|\t j |r1d|vr t d|jd|jd}nbt j|r1d|vr t d|jd|jd}nt j|r0d|vr t d|jd|jd}nt j|r0d|vr t d|jd|jd}nt j|r0d|vr t d|jd|jd}nMnNt|tr;d|vr t d|jdtt |j"}nnt j|r'd|vr t d|jdt$}njt j |r'd|vr t d|jdt$}n.|tur&d|vr t d|jdt$}t'|||S) a Inspect an [annotation expression][], extracting any [type qualifier][] and metadata. An [annotation expression][] is a [type expression][] optionally surrounded by one or more [type qualifiers][type qualifier] or by [`Annotated`][typing.Annotated]. This function will: - Unwrap the type expression, keeping track of the type qualifiers. - Unwrap [`Annotated`][typing.Annotated] forms, keeping track of the annotated metadata. Args: annotation: The annotation expression to be inspected. annotation_source: The source of the annotation. Depending on the source (e.g. a class), different type qualifiers may be (dis)allowed. To allow any type qualifier, use [`AnnotationSource.ANY`][typing_inspection.introspection.AnnotationSource.ANY]. unpack_type_aliases: What to do when encountering [PEP 695](https://peps.python.org/pep-0695/) [type aliases][type-aliases]. Can be one of: - `'skip'`: Do not try to parse type aliases (the default): ```pycon >>> type MyInt = Annotated[int, 'meta'] >>> inspect_annotation(MyInt, annotation_source=AnnotationSource.BARE, unpack_type_aliases='skip') InspectedAnnotation(type=MyInt, qualifiers={}, metadata=[]) ``` - `'lenient'`: Try to parse type aliases, and fallback to `'skip'` if the type alias can't be inspected (because of an undefined forward reference): ```pycon >>> type MyInt = Annotated[Undefined, 'meta'] >>> inspect_annotation(MyInt, annotation_source=AnnotationSource.BARE, unpack_type_aliases='lenient') InspectedAnnotation(type=MyInt, qualifiers={}, metadata=[]) >>> Undefined = int >>> inspect_annotation(MyInt, annotation_source=AnnotationSource.BARE, unpack_type_aliases='lenient') InspectedAnnotation(type=int, qualifiers={}, metadata=['meta']) ``` - `'eager'`: Parse type aliases and raise any encountered [`NameError`][] exceptions. Returns: The result of the inspected annotation, where the type expression, used qualifiers and metadata is stored. Example: ```pycon >>> inspect_annotation( ... Final[Annotated[ClassVar[Annotated[int, 'meta_1']], 'meta_2']], ... annotation_source=AnnotationSource.CLASS, ... ) ... InspectedAnnotation(type=int, qualifiers={'class_var', 'final'}, metadata=['meta_1', 'meta_2']) ``` rrVrrXrSrTrUrW)rhrd_unpack_annotatedrr is_classvarraddrDis_final is_requiredis_notrequired is_readonlyr(rr r r9rxr)rLannotation_sourcer4rhr~r_metaorigins r$rr\sup+==!$JH -jNab E x'H J'  ))&1&88,[99{+'003 ((0"44,W55w''003 ++F3%77,Z88z*'003 ..v6!);;,^<<~.'003 ++F3&88,^<<{+'003   G ,!33(44 NN: &c:??3J U Zz* , ,$W- -w  # #J / 0 0$[1 1{# w  / /$Z0 0z" z:x @@r%cVt|}|rPtj|r;|j}t |j }t ||d\}}||z}||fStj|r( |j}t ||d\}}|r||fS|gfStj|r8 |j} ||j}t ||d\}}|r||fS|gfS|gfS#t$r |dk(rY|gfSwxYw#t$rYBwxYw#t$r |dk(rY|gfSwxYw)NFr4check_annotatedTr1) rr is_annotated __origin__list __metadata___unpack_annotated_innerrErFrHrDr.) rLr4rrannotated_typersub_metar/typs r$rrs #F>66v>#.. //0 $; 0CUZ$  h&x''  ( ( 4 "((E 4+>PTMCH}$r> !  ( ( 0 "$$E j112 4+>PTMCH}$r> ! r>Y "g-.V r>Y B   "g-.0 r>3 s64 C,1 D>D,DD DDD('D(c|dk(rCtjt|r!|jt |j fS|gfSt ||dS)Nr6Tr)rrrrrrr)rLr4s r$rrsVf$  & &z*'= >(($z/F/F*GG Gr> ! ":CVhl mmr%)r#r rir,)r/r rirs)rLr r3r,r4#Literal['skip', 'lenient', 'eager']rizGenerator[Any])rLr rrr4rrir)rLr r4zLiteral['lenient', 'eager']rr,rituple[Any, list[Any]])rLr r4rrir)-rm __future__rsysr collections.abcrr dataclassesrenumrrr typingr r r r typing_extensionsrrrrr__all__ version_inforr0rrrtrdrZr Exceptionrrvrxr|rrrrr>r%r$rsK" /$$11KK w F ,o?F m+m+ m+ = m+  m+`hi 9i"%hy&9":: nwnb##t  " "C !1!9!9: Y:Z"*":@F yAyA( yA = yA  yAx??*E?X\??HW^ n n0S n nr%