def _parameterized_type(self, base_type, parameters):
"""Return a parameterized type."""
if self._is_literal_base_type(base_type):
return types.pytd_literal(parameters)
elif any(isinstance(p, types.Constant) for p in parameters):
parameters = ", ".join(
p.repr_str() if isinstance(p, types.Constant) else "_"
for p in parameters)
raise ParseError("%s[%s] not supported" %
(pytd_utils.Print(base_type), parameters))
elif pytdgen.is_any(base_type):
return pytd.AnythingType()
elif len(parameters) == 2 and parameters[-1] is self.ELLIPSIS and (
not self._is_callable_base_type(base_type)):
element_type = parameters[0]
if element_type is self.ELLIPSIS:
raise ParseError("[..., ...] not supported")
return pytd.GenericType(base_type=base_type,
parameters=(element_type, ))
else:
parameters = tuple(pytd.AnythingType() if p is self.ELLIPSIS else p
for p in parameters)
if self._is_tuple_base_type(base_type):
return pytdgen.heterogeneous_tuple(base_type, parameters)
elif self._is_callable_base_type(base_type):
return pytdgen.pytd_callable(base_type, parameters)
else:
assert parameters
return pytd.GenericType(base_type=base_type,
parameters=parameters)
def _parameterized_type(self, base_type: Any, parameters):
"""Return a parameterized type."""
if self._matches_named_type(base_type, _LITERAL_TYPES):
return pytd_literal(parameters)
elif self._matches_named_type(base_type, _ANNOTATED_TYPES):
return pytd_annotated(parameters)
elif self._matches_named_type(base_type, _FINAL_TYPES):
typ, = parameters
return pytd.GenericType(pytd.NamedType("typing.Final"), (typ, ))
elif self._matches_named_type(base_type, _TYPEGUARD_TYPES):
# We do not yet support PEP 647, User-Defined Type Guards. To avoid
# blocking typeshed, convert type guards to plain bools.
return pytd.NamedType("bool")
elif any(isinstance(p, types.Pyval) for p in parameters):
parameters = ", ".join(
p.repr_str() if isinstance(p, types.Pyval) else "_"
for p in parameters)
raise ParseError("%s[%s] not supported" %
(pytd_utils.Print(base_type), parameters))
elif pytdgen.is_any(base_type):
return pytd.AnythingType()
elif len(parameters) == 2 and parameters[-1] is self.ELLIPSIS and (
not self._matches_named_type(base_type, _CALLABLE_TYPES)):
element_type = parameters[0]
if element_type is self.ELLIPSIS:
raise ParseError("[..., ...] not supported")
return pytd.GenericType(base_type=base_type,
parameters=(element_type, ))
else:
processed_parameters = []
# We do not yet support PEP 612, Parameter Specification Variables.
# To avoid blocking typeshed from adopting this PEP, we convert new
# features to approximations that only use supported features.
for p in parameters:
if p is self.ELLIPSIS:
processed = pytd.AnythingType()
elif (p in self.param_specs and self._matches_full_name(
base_type, "typing.Generic")):
# Replacing a ParamSpec with a TypeVar isn't correct, but it'll work
# for simple cases in which the filled value is also a ParamSpec.
if not any(t.name == p.name for t in self.type_params):
self.type_params.append(pytd.TypeParameter(p.name))
processed = p
elif (p in self.param_specs
or (isinstance(p, pytd.GenericType)
and self._matches_full_name(p, _CONCATENATE_TYPES))):
processed = pytd.AnythingType()
else:
processed = p
processed_parameters.append(processed)
parameters = tuple(processed_parameters)
if self._matches_named_type(base_type, _TUPLE_TYPES):
return pytdgen.heterogeneous_tuple(base_type, parameters)
elif self._matches_named_type(base_type, _CALLABLE_TYPES):
return pytdgen.pytd_callable(base_type, parameters)
else:
assert parameters
return pytd.GenericType(base_type=base_type,
parameters=parameters)
def _parameterized_type(self, base_type, parameters):
"""Return a parameterized type."""
if self._matches_named_type(base_type, _LITERAL_TYPES):
return types.pytd_literal(parameters)
elif self._matches_named_type(base_type, _ANNOTATED_TYPES):
return types.pytd_annotated(parameters)
elif self._matches_named_type(base_type, _TYPEGUARD_TYPES):
# We do not yet support PEP 647, User-Defined Type Guards. To avoid
# blocking typeshed, convert type guards to plain bools.
return pytd.NamedType("bool")
elif any(isinstance(p, types.Constant) for p in parameters):
parameters = ", ".join(
p.repr_str() if isinstance(p, types.Constant) else "_"
for p in parameters)
raise ParseError("%s[%s] not supported" %
(pytd_utils.Print(base_type), parameters))
elif pytdgen.is_any(base_type):
return pytd.AnythingType()
elif len(parameters) == 2 and parameters[-1] is self.ELLIPSIS and (
not self._matches_named_type(base_type, _CALLABLE_TYPES)):
element_type = parameters[0]
if element_type is self.ELLIPSIS:
raise ParseError("[..., ...] not supported")
return pytd.GenericType(base_type=base_type,
parameters=(element_type, ))
else:
parameters = tuple(pytd.AnythingType() if p is self.ELLIPSIS else p
for p in parameters)
if self._matches_named_type(base_type, _TUPLE_TYPES):
return pytdgen.heterogeneous_tuple(base_type, parameters)
elif self._matches_named_type(base_type, _CALLABLE_TYPES):
callable_parameters = []
for p in parameters:
# We do not yet support PEP 612, Parameter Specification Variables.
# To avoid blocking typeshed from adopting this PEP, we convert new
# features to Any.
if p in self.param_specs or (isinstance(
p, pytd.GenericType) and self._matches_full_name(
p, _CONCATENATE_TYPES)):
callable_parameters.append(pytd.AnythingType())
else:
callable_parameters.append(p)
return pytdgen.pytd_callable(base_type,
tuple(callable_parameters))
else:
assert parameters
return pytd.GenericType(base_type=base_type,
parameters=parameters)
def _parameterized_type(self, base_type, parameters):
"""Return a parameterized type."""
if self._is_literal_base_type(base_type):
return types.pytd_literal(parameters)
elif any(isinstance(p, types.Constant) for p in parameters):
parameters = ", ".join(
p.repr_str() if isinstance(p, types.Constant) else "_"
for p in parameters)
raise ParseError("%s[%s] not supported" %
(pytd_utils.Print(base_type), parameters))
elif pytdgen.is_any(base_type):
return pytd.AnythingType()
elif len(parameters) == 2 and parameters[-1] is self.ELLIPSIS and (
not self._is_callable_base_type(base_type)):
element_type = parameters[0]
if element_type is self.ELLIPSIS:
raise ParseError("[..., ...] not supported")
return pytd.GenericType(base_type=base_type,
parameters=(element_type, ))
else:
parameters = tuple(pytd.AnythingType() if p is self.ELLIPSIS else p
for p in parameters)
if self._is_tuple_base_type(base_type):
return pytdgen.heterogeneous_tuple(base_type, parameters)
elif self._is_callable_base_type(base_type):
callable_parameters = []
for p in parameters:
# We do not yet support PEP 612, Parameter Specification Variables.
# To avoid blocking typeshed from adopting this PEP, we convert new
# features to Any.
if p in self.param_specs or (isinstance(
p, pytd.GenericType) and self._matches_full_name(
p, ("typing.Concatenate",
"typing_extensions.Concatenate"))):
callable_parameters.append(pytd.AnythingType())
else:
callable_parameters.append(p)
return pytdgen.pytd_callable(base_type,
tuple(callable_parameters))
else:
assert parameters
return pytd.GenericType(base_type=base_type,
parameters=parameters)
def is_any(val) -> bool:
if isinstance(val, Ellipsis):
return True
return pytdgen.is_any(val)
