%hXB%SrSSKJr SSKrSSKrSSKJr SSKJr SSK J r J r J r SSK JrJrJrJr SSKJrJrJrJr S S KJr S r\R4S :d\R4S :aS(SjrOS(SjrS)SjrSSS.S*Sjjr\SrS\S'\ "\"\55r!S\S'"SS\ 5r""SS\#5r$"SS\ 5r%\%RLr&\\%RLr'S\S '"S!S"\5r(S#S$.S+S%jjr)S,S&jr*SS$.S-S'jjr+g).zEHigh-level introspection utilities, used to inspect type annotations.) annotationsN) Generator)InitVar)EnumIntEnumauto)AnyLiteral NamedTuplecast) TypeAlias assert_neverget_args get_origin)typing_objects)AnnotationSourceForbiddenQualifierInspectedAnnotation Qualifierget_literal_valuesinspect_annotationis_union_origin))r c.[R"U5$a8Return whether the provided origin is the union form. ```pycon >>> is_union_origin(typing.Union) True >>> is_union_origin(get_origin(int | str)) True >>> is_union_origin(types.UnionType) True ``` !!! note Since Python 3.14, both `Union[, , ...]` and ` | | ...` forms create instances of the same [`typing.Union`][] class. As such, it is recommended to not use this function anymore (provided that you only support Python 3.14 or greater), and instead use the [`typing_objects.is_union()`][typing_inspection.typing_objects.is_union] function directly: ```python from typing import Union, get_origin from typing_inspection import typing_objects typ = int | str # Or Union[int, str] origin = get_origin(typ) if typing_objects.is_union(origin): ... ``` )ris_unionobjs W/var/www/auris/envauris/lib/python3.13/site-packages/typing_inspection/introspection.pyrrs:&&s++c`[R"U5=(d U[RL$r)rrtypes UnionTyper s r"rr>s#:&&s+Eseoo/EEr#c [U[[[[[ [ R45(d"U[ RLa[US35egg)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_checkr0^sP usE3dNnU(a [U5 UbU[RLaU(dSv SnM:Uv M@ g/nURHn[R"U5(a1UR n[ XaUS9nURSU55 MOU(a [U5 U[RLa#URS[R45 MURU[U545 M [RU5nSU5ShvN g![a: US:XaeU(a [U5 URU[U545 GM"f=fNL![a S U5ShvN gf=f7f) aYield the values contained in the provided [`Literal`][typing.Literal] [special form][]. Args: annotation: The [`Literal`][typing.Literal] [special form][] to unpack. type_check: Whether to check if the literal values are [legal parameters][literal-legal-parameters]. Raises a [`TypeError`][] otherwise. 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. Note that this can lead to incorrect results: ```pycon >>> 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. ``` skipFNTr2c3:# UHo[U54v M g7fN)type).0as r" %get_literal_values..s*JAtAw<sr1c3*# UH upUv M g7fr8r:p_s r"r<r=s*cdacc3*# UH upUv M g7fr8r?r@s r"r<r=s6odaorC)__args__r0rr-is_typealiastype __value__rextend NameErrorappendr9dictfromkeysr.) annotationr3r4 _has_noneargvalues_and_type alias_valuesub_argsdcts r"rrgstf$ &&C#C({c^%<%<< J  '8:&&C ..s33 K"%--K 2#Pc H$***J*JJ',.111#**D.2I2I+JK#**Cc+;<5'8 +--0C +c* * *5!=*g5!+C0#**Cc+;<< =4 +  76o6 6 6 7sgBF2 EB F2 F5 F2FF2?F F2 F  F2F/&F)'F/,F2.F//F2)required not_required read_only class_varinit_varfinalr rset[Qualifier]_all_qualifiersc\rSrSrSr\"5r\"5r\"5r\"5r \"5r \"5r \"5r \"5r \SSj5rSrg)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. c|U[RLaS1$U[RLaSS1$U[RLa1Sk$U[RLa1Sk$U[R [R [R4;a [5$U[RLa[$[U5 g)zIThe allowed [type qualifiers][type qualifier] for this annotation source.rYrW>rYrXrW>rTrVrUN) rASSIGNMENT_OR_VARIABLECLASS DATACLASS TYPED_DICT NAMED_TUPLEFUNCTIONBAREsetANYr[rselfs r"allowed_qualifiers#AnnotationSource.allowed_qualifiers<s #:: :9  %++ +[) ) %// /5 5 %00 0< < &224D4M4MO_OdOde e5L %)) )" "  r#r?N)returnrZ)__name__ __module__ __qualname____firstlineno____doc__rr_r`rarbrcrdrgrepropertyrj__static_attributes__r?r#r"rrs "V FE I J &K vH &C 6D r#rc0\rSrSr%SrS\S'SSjrSrg) riPz-The provided [type qualifier][] is forbidden.r qualifiercXlgr8ru)rirus r"__init__ForbiddenQualifier.__init__Vs"r#rwN)rurrlNone)rmrnrorprq__annotations__rxrsr?r#r"rrPs7"#r#rc6\rSrSr\"5rSSjrSSjrSrg)_UnknownTypeEnumiZcg)NUNKNOWNr?rhs r"__str___UnknownTypeEnum.__str__]sr#cg)Nz r?rhs r"__repr___UnknownTypeEnum.__repr__`sr#r?N)rlr+) rmrnrorprrrrrsr?r#r"r}r}ZsfGr#r} _UnkownTypec<\rSrSr%SrS\S'S\S'S\S'S rg ) rikz'The result of the inspected annotation.zAny | _UnkownTyper9rZ qualifiersz list[Any]metadatar?N)rmrnrorprqr{rsr?r#r"rrks$1  J!r#rr6r4cURn[5n/n[XS9upU(aXe-nM[U5nUGb[R "U5(a3SU;a [ S5eURS5 URSnGO[R"U5(a3SU;a [ S5eURS5 URSnGO;[R"U5(a2SU;a [ S5eURS5 URSnO[R"U5(a2SU;a [ S5eURS5 URSnO[R"U5(a2SU;a [ S5eURS5 URSnOTOV[U[5(a=SU;a [ S5eURS5 [[ UR"5nOOGM[R"U5(a)SU;a [ S5eURS5 [$nOu[R "U5(a)SU;a [ S5eURS5 [$nO1U[La(SU;a [ S5eURS5 [$n['XU5$) ay 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']) ``` rrWrrYrTrUrVrX)rjrf_unpack_annotatedrr is_classvarraddrEis_final is_requiredis_notrequired is_readonlyr(rr r r9rr)rMannotation_sourcer4rjrr_metaorigins r"rrsp+==!$JH -jb 'H J'  ))&11&88,[99{+'003 ((00"44,W55w''003 ++F33%77,Z88z*'003 ..v66!);;,^<<~.'003 ++F33&88,^<<{+'003   G , ,!33(44 NN: &c:??3J U Zz** , ,$W- -w  # #J / / 0 0$[1 1{# w  / /$Z0 0z" zx @@r#cz[U5nU(aO[R"U5(a4URn[ UR 5n[ XASS9upFXe-nXE4$[R"U5(a'URn[ XqSS9upU(aX4$U/4$[R"U5(a6URnXpRn[ XqSS9upU(aX4$U/4$U/4$![a US:XaeU/4$f=f![a NDf=f![a US:XaeU/4$f=f)NFr4check_annotatedTr1) rr is_annotated __origin__list __metadata___unpack_annotated_innerrFrGrIrEr.) rMr4rrannotated_typersub_metar/typs r"rrs #F>66v>>#.. //0 $; UZ$  &''  ( ( 4 4 "((E 4PTMC}$r> !  ( ( 0 0 "$$E 112 4PTMC}$r> ! r>Y "g-.V r>Y B   "g-.0 r>3 s6> C9 D# D9DD D D #D:9D:cUS:XaI[R"[U55(a!UR[ UR 54$U/4$[ XSS9$)Nr6Tr)rrrrrrr)rMr4s r"rrBsVf$  & &z*'= > >(($z/F/F*GG Gr> ! ":hl mmr#)r!r rlr,)r/r rlrz)rMr r3r,r4#Literal['skip', 'lenient', 'eager']rlzGenerator[Any])rMr rrr4rrlr)rMr r4zLiteral['lenient', 'eager']rr,rltuple[Any, list[Any]])rMr r4rrlr),rq __future__rsysr%collections.abcr dataclassesrenumrrrtypingr r r r typing_extensionsr rrrr__all__ version_inforr0rrr{rfr[r Exceptionrr}rrrrrrr?r#r"rsK" %$$11KK w#"2"2W"<,DF@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#