从 typing.Annotated 中递归剥离类型注解的教程

from typing import Annotated, tuple, list

Point3D = Annotated[tuple[float, float, float], "A 3D Point"]
Points = Annotated[list[Point3D], "A collection of points"]

typing.Annotated[list[typing.Annotated[tuple[float, float, float], 'A 3D Point']], 'A collection of points']

from typing import Annotated, get_args, get_origin, TypeVar, Union

# 示例类型定义
Point3D = Annotated[tuple[float, float, float], "A 3D Point"]
Points = Annotated[list[Point3D], "A collection of points"]
ComplexType = Annotated[Union[Point3D, list[float]], "A complex type example"]

def convert_annotated_to_bare_types(type_object: type):
  """
  递归地将类型对象中所有 typing.Annotated 节点转换为其裸类型。

  Args:
    type_object: 待处理的类型对象。

  Returns:
    移除了所有 Annotated 注解的裸类型对象。
  """
  origin, args = get_origin(type_object), get_args(type_object)

  # 1. 基础情况：如果不是泛型类型（没有 origin），直接返回
  if origin is None:
    return type_object

  # 2. 处理 Annotated 类型：
  #    如果是 Annotated，取其第一个参数（即实际类型），并递归处理
  if origin is Annotated:
    bare_type = get_args(type_object)[0]
    return convert_annotated_to_bare_types(bare_type)

  # 3. 处理其他泛型类型：
  #    递归处理所有类型参数，然后使用原始类型和处理后的参数重建泛型
  converted_args = [
    convert_annotated_to_bare_types(arg) for arg in args
  ]

  # 注意：对于像 TypeVar 这样的特殊类型，get_origin 会返回 TypeVar 本身，
  # 但它没有 args，或者 args 已经被处理过。
  # 这里的 origin(*converted_args) 语法适用于所有常见的泛型构造。
  # 对于 TypeVar，get_origin 返回其自身，get_args 返回空，
  # 所以 TypeVar() 依然是 TypeVar。
  try:
      return origin[*converted_args]
  except TypeError:
      # 某些特殊类型（如 TypeVar）可能不支持通过 origin[*args] 方式构造，
      # 或者其 args 经过处理后不再符合原始类型的构造要求。
      # 在这种情况下，我们尝试返回原始类型本身，或者根据具体情况进行更精细的处理。
      # 对于本教程的 Annotated 剥离目的，如果遇到构造失败，
      # 通常意味着这是一个不应被进一步解构的原子类型（如 TypeVar），
      # 或者参数列表已不匹配。
      # 简单起见，这里可以返回原始的 type_object，但更严谨可能需要根据 origin 判断。
      # 针对 TypeVar，get_origin(TypeVar('T')) 会返回 TypeVar('T') 本身，
      # get_args 会返回 ()，所以 converted_args 也是 ()。
      # origin[*()] 也就是 TypeVar('T')()，这会报错。
      # 因此，对于 TypeVar 或类似情况，需要特殊处理。
      if isinstance(origin, TypeVar): # 如果 origin 本身就是 TypeVar
          return type_object # 直接返回原始 TypeVar

      # 否则，尝试返回 origin，或者抛出异常以便调试
      return origin 

# 原始类型
print(f"原始 Points 类型: {Points}")
print(f"原始 ComplexType 类型: {ComplexType}")

# 剥离注解后的类型
bare_points = convert_annotated_to_bare_types(Points)
print(f"剥离注解后的 Points: {bare_points}")

bare_complex_type = convert_annotated_to_bare_types(ComplexType)
print(f"剥离注解后的 ComplexType: {bare_complex_type}")

# 验证结果
# 期望输出: list[tuple[float, float, float]]
# 实际输出: list[tuple[float, float, float]] (取决于 Python 版本和内部表示)
# 注意：在某些 Python 版本中，tuple[float, float, float] 可能显示为 typing.Tuple[float, float, float]
# 但其语义是相同的。

原始 Points 类型: typing.Annotated[list[typing.Annotated[tuple[float, float, float], 'A 3D Point']], 'A collection of points']
原始 ComplexType 类型: typing.Annotated[typing.Union[typing.Annotated[tuple[float, float, float], 'A 3D Point'], list[float]], 'A complex type example']
剥离注解后的 Points: list[tuple[float, float, float]]
剥离注解后的 ComplexType: typing.Union[tuple[float, float, float], list[float]]