def make_named_tuple(api: TypeChecker, fields: 'OrderedDict[str, Type]',
name: str) -> Type:
if not fields:
# No fields specified, so fallback to a subclass of NamedTuple that allows
# __getattr__ / __setattr__ for any attribute name.
fallback = api.named_generic_type('django._NamedTupleAnyAttr', [])
else:
fallback = build_class_with_annotated_fields(
api=api,
base=api.named_generic_type('typing.NamedTuple', []),
fields=fields,
name=name)
return TupleType(list(fields.values()), fallback=fallback)
def get_generic_type(api: TypeChecker, name: str) -> Optional[Instance]:
"""Parse generic type definition from type hint string
For example list[str], dict(str, str), etc.
"""
# TODO: pretty sure this is implemented somewhere inside mypy, byt I was not able to find it
start: str = ""
close: Dict[str, str] = {"(": ")", "[": "]"}
square = name.find("[")
paren = name.find("(")
if square != -1 and paren != -1:
if square < paren:
start = "["
elif paren < square:
start = "("
elif square != -1:
start = "["
elif paren != -1:
start = "("
type_name = name.split(start)[0]
args = name[name.find(start) + 1:name.rfind(close[start])].split(",")
type_args: List[MypyType] = []
for arg in args:
type_arg = get_attribute_type(api, arg.strip())
if type_arg is not None:
type_args.append(type_arg)
return api.named_generic_type(type_name, type_args)
def make_typeddict(api: TypeChecker, fields: 'OrderedDict[str, Type]',
required_keys: typing.Set[str]) -> Type:
object_type = api.named_generic_type('mypy_extensions._TypedDict', [])
typed_dict_type = TypedDictType(fields,
required_keys=required_keys,
fallback=object_type)
return typed_dict_type
def make_oneoff_named_tuple(api: TypeChecker, name: str,
fields: 'OrderedDict[str, MypyType]') -> TupleType:
current_module = get_current_module(api)
namedtuple_info = add_new_class_for_module(
current_module,
name,
bases=[api.named_generic_type('typing.NamedTuple', [])],
fields=fields)
return TupleType(list(fields.values()),
fallback=Instance(namedtuple_info, []))
def make_oneoff_named_tuple(
api: TypeChecker,
name: str,
fields: "OrderedDict[str, MypyType]",
extra_bases: Optional[List[Instance]] = None) -> TupleType:
current_module = get_current_module(api)
if extra_bases is None:
extra_bases = []
namedtuple_info = add_new_class_for_module(
current_module,
name,
bases=[api.named_generic_type("typing.NamedTuple", [])] + extra_bases,
fields=fields)
return TupleType(list(fields.values()),
fallback=Instance(namedtuple_info, []))
def make_tuple(api: TypeChecker, fields: typing.List[Type]) -> Type:
implicit_any = AnyType(TypeOfAny.special_form)
fallback = api.named_generic_type('builtins.tuple', [implicit_any])
return TupleType(fields, fallback=fallback)
