+ LV-jX8a0t$Rt^RIHt^RIt^RIt^RIHt^RIH t ^RI H t H t H t ^RIHtHtHtHt^RIHtHtHtHt^RIHtR)t]P6R*8g]P6R+8dR RltMRRltRRltRRRR/RRllt]R,,tR] R &]!!]!]44t"R] R&!RR ] 4t#!RR ]$4t%!RR] 4t&]&PNt']]&PN,t(R] R &!R!R ]4t)RR"/R#R$llt*R%R&lt+RR/R'R(llt,R#)-zEHigh-level introspection utilities, used to inspect type annotations.) annotationsN) Generator)InitVar)EnumIntEnumauto)AnyLiteral NamedTuplecast) TypeAlias assert_neverget_args get_origin)typing_objectsAnnotationSourceForbiddenQualifierInspectedAnnotation Qualifierc V^8dQhRRRR/#objrreturnbool)formats"p/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/typing_inspection/introspection.py __annotate__rs,,S,,c.\P!V4#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_unionrs"ris_union_originr$s:&&s++rc V^8dQhRRRR/#rr)rs"rrr>sFFSFFrcb\P!V4;'gV\PJ#r!)rr"types UnionTyper#s"rr$r$>s&:&&s+EEseoo/EErc V^8dQhRRRR/#)rvaluerrNoner)rs"rrr^sooso$orc \V\\\\\ \ P34'g%V\ PJd\V R24hR#R#)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) isinstanceintbytesstrrrrNoneType TypeError)r*s"r_literal_type_checkr3^sP usE3dNVxKD R#.pVPFp\P!V4'd5VP p\ WaVR7pVPRV44KSV'd \V4V\PJd$VPR\P34KVPV\V434K \PV4pRV4RjxL R# \d=TR8XdhT'd \T4TPT\T434EK,i;iLP \dR T4RjxL R#i;i5i) 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. ``` skipFNT)r4r5c3:"TFq\V43xK R#5iN)type).0as& r %get_literal_values..s*JAtAw<sr6c3*"TF wrVxK R#5ir=rr?p_s& rrArBs*cdacc3*"TF wrVxK R#5ir=rrDs& rrArBs6odaorG)__args__r3rr1is_typealiastype __value__get_literal_valuesextend NameErrorappendr>dictfromkeysr2) r8r4r5 _has_noneargvalues_and_type alias_valuesub_argsdcts "$$ rrLrLgstf$ &&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 7syA G?G E.G A"G,F  G FGF/'FGFG G7F:8G=GGGr set[Qualifier]_all_qualifiersc]tRt^tRt]!4t]!4t]!4t]!4t ]!4t ]!4t ]!4t ]!4t ]RRl4tRtR#)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. cV^8dQhRR/#)rrrXr)rs"rrAnnotationSource.__annotate__=sNrc V\PJdR0#V\PJdRR0#V\PJd0Rm#V\PJd0Rm#V\P \P \P39d \4#V\PJd\#\V4R#)zIThe allowed [type qualifiers][type qualifier] for this annotation source.final class_varN>r^init_varr_>required read_only not_required) rASSIGNMENT_OR_VARIABLECLASS DATACLASS TYPED_DICT NAMED_TUPLEFUNCTIONBAREsetANYrYr selfs&rallowed_qualifiers#AnnotationSource.allowed_qualifiers<s #:: :9  %++ +[) ) %// /5 5 %00 0< < &224D4M4MO_OdOde e5L %)) )" "  rrN)__name__ __module__ __qualname____firstlineno____doc__rrdrerfrgrhrirlrjpropertyro__static_attributes__rrrrrs "V FE I J &K vH &C 6D rc4]tRtRt$RtR]R&RRltRtR#) riPz-The provided [type qualifier][] is forbidden.r qualifierc V^8dQhRRRR/#)rryrrr+r)rs"rrForbiddenQualifier.__annotate__Vs##)#4#rc WnR#r=ry)rnrys""r__init__ForbiddenQualifier.__init__Vs"rr}N)rqrrrsrtru__annotations__r~rwrrrrrPs7"##rc<]tRtRt]!4tRRltRRltRtR#)_UnknownTypeEnumiZcV^8dQhRR/#rrr0r)rs"rr_UnknownTypeEnum.__annotate__]src R#)UNKNOWNrrms&r__str___UnknownTypeEnum.__str__]srcV^8dQhRR/#rr)rs"rrr`s#rc R#)z rrms&r__repr___UnknownTypeEnum.__repr__`srrN) rqrrrsrtrrrrrwrrrrrZsfGrr _UnkownTypec>]tRtRt$RtR]R&R]R&R]R&R tR #) rikz'The result of the inspected annotation.zAny | _UnkownTyper>rX qualifiersz list[Any]metadatarN)rqrrrsrtrurrwrrrrrks$1  J!rr;c(V^8dQhRRRRRRRR/#) rr8rannotation_sourcerr5r9rrr)rs"rrrs>yAyAyA( yA = yA  yArc(VPp\4p.p\WR7wrV'd We,pK!\V4pVEe\P !V4'd9RV9d \ R4hVPR4VP^,pK\P!V4'd9RV9d \ R4hVPR4VP^,pK\P!V4'd:RV9d \ R4hVPR4VP^,pEK.\P!V4'd:RV9d \ R4hVPR4VP^,pEK\P!V4'd:RV9d \ R4hVPR4VP^,pEKMW\V\4'dARV9d \ R4hVPR4\\ VP"4pEK/\P!V4'd+RV9d \ R4hVPR4\$pMy\P !V4'd+RV9d \ R4hVPR4\$pM3V\Jd*RV9d \ R4hVPR4\$p\'WV4#)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']) ``` )r5r_r^rarcrbr`)rork_unpack_annotatedrr is_classvarraddrIis_final is_requiredis_notrequired is_readonlyr-rr rr>rr)r8rr5rorr_metaorigins"$$ rinspect_annotationrs}p+==!$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 z** , ,$W- -w  # #J / / 0 0$[1 1{# w  / /$Z0 0z" zx @@rc(V^8dQhRRRRRRRR/#) rr8rr5zLiteral['lenient', 'eager']check_annotatedrrtuple[Any, list[Any]]r)rs"rrrs,???*E?X\??rc\V4pV'dX\P!V4'd<VPp\ VP 4p\ WARR7wrFWe,pWE3#\P!V4'd,VPp\ WqRR7wrV'dW3#V.3#\P!V4'd?VPpWpP,p\ WqRR7wrV'dW3#V.3#V.3# \dTR8XdhT.3#i;i \dLKi;i \dTR8XdhT.3#i;i)Fr5rTr6) rr is_annotated __origin__list __metadata___unpack_annotated_innerrJrKrNrIr2) r8r5rrannotated_typersub_metar*typs &&& rrrs #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 D D=D,D)(D), D:9D:=EEc$V^8dQhRRRRRR/#)rr8rr5r9rrr)rs"rrrBs) n n n0S n nrcVR8XdK\P!\V44'd"VP\ VP 43#V.3#\ WRR7#)r;Tr)rrrrrrr)r8r5s"$rrrBsVf$  & &z*'= > >(($z/F/F*GG Gr> ! ":hl mmr)rrrrrLrr$))r )rarcrbr_r`r^)-__conditional_annotations__ru __future__rsysr'collections.abcr dataclassesrenumrrrtypingrr r r typing_extensionsr r rrr__all__ version_infor$r3rLrrrkrYr Exceptionrrrrrrrr)rs@rrs9K" %$$11KK w#"2"2W"<,DF@om+ m+ @G m+`hi 9i"%hy&9":: nwnb##t  " "C !1!9!9: Y:Z"*"0yA @F yAx?F nV] n nr