code: def type_complexity(type_):
      
      if (not typing
        or not isinstance(type_, (typing.TypingMeta, GenericWrapperMeta))
        or type_ is AnyType):
          return 0
      if issubclass(type_, typing.Union):
          return reduce(operator.or_, map(type_complexity, type_.__union_params__))
      if issubclass(type_, typing.Tuple):
          if type_.__tuple_params__ is None:
              return 1
          elif type_.__tuple_use_ellipsis__:
              return 2
          else:
              return 8
      if isinstance(type_, GenericWrapperMeta):
          type_count = 0
          for p in reversed(type_.parameters):
              if type_count > 0:
                  type_count += 1
              if p is AnyType:
                  continue
              if not isinstance(p, typing.TypeVar) or p.__constraints__ or p.__bound__:
                  type_count += 1
          return 1 << min(type_count, 2)
      return 0
docs: Computes an indicator for the complexity of `type_`.
  
      If the return value is 0, the supplied type is not parameterizable.
      Otherwise, set bits in the return value denote the following features:
      - bit 0: The type could be parameterized but is not.
      - bit 1: The type represents an iterable container with 1 constrained type parameter.
      - bit 2: The type represents a mapping with a constrained value type (2 parameters).
      - bit 3: The type represents an n-tuple (n parameters).
      Since these features are mutually exclusive, only a `Union` can have more than one bit set.