def compute_signatures_from_typeobjects(
types_in, backend_type_formatter) -> List[List[str]]:
"""Compute a list of lists (signatures) of strings (backend types)
"""
if isinstance(types_in, dict):
types_in = types_in.values()
types = []
for type_ in types_in:
if isinstance(type_, str):
type_ = str2type(type_)
types.append(type_)
template_parameters = set()
for type_ in types:
if hasattr(type_, "get_template_parameters"):
template_parameters.update(type_.get_template_parameters())
if not template_parameters:
if "_empty" in types:
raise ValueError(
"At least one annotation type lacking in a signature.\n"
f"types = {types}")
str_types = [
format_type_as_backend_type(type_, backend_type_formatter)
for type_ in types
]
return (str_types, )
if not all(param.values for param in template_parameters):
raise ValueError(
f"{template_parameters}, {[param.values for param in template_parameters]}"
)
values_template_parameters = {}
for param in template_parameters:
values_template_parameters[param.__name__] = param.values
backend_types = []
names = values_template_parameters.keys()
for set_types in itertools.product(*values_template_parameters.values()):
template_variables = dict(zip(names, set_types))
backend_types.append(
_format_types_as_backend_types(types, backend_type_formatter,
**template_variables))
return backend_types
def _format_types_as_backend_types(types, backend_type_formatter, **kwargs):
"""Compute a list of Pythran/Cython/... types
"""
backend_types = []
for type_ in types:
backend_types.append(
format_type_as_backend_type(type_, backend_type_formatter,
**kwargs))
# TODO: handle this with an exception
if "_empty" in backend_types:
raise ValueError(
"At least one annotation type lacking in a signature.\n"
f"types = {types}")
return backend_types
def get_name_cython_type(ttype):
ttype_name = get_ttype_name(ttype)
name_cython_type = f"__{fdef.name}__{ttype_name}"
if name_cython_type in cython_fused_types:
return name_cython_type
return format_type_as_backend_type(ttype, self.type_formatter)
def compute_typename_from_object(self, obj: object):
"""return the backend type name"""
transonic_type = typeof(obj)
return format_type_as_backend_type(transonic_type, self.type_formatter)
def make_tuple_code(self, types, **kwargs):
strings = [
format_type_as_backend_type(type_, self, **kwargs) for type_ in types
]
return f"({', '.join(strings)})"
def make_list_code(self, type_elem, **kwargs):
return format_type_as_backend_type(type_elem, self, **kwargs) + " list"
def make_set_code(self, type_keys, **kwargs):
key = format_type_as_backend_type(type_keys, self, **kwargs)
return f"{key} set"
def make_dict_code(self, type_keys, type_values, **kwargs):
key = format_type_as_backend_type(type_keys, self, **kwargs)
value = format_type_as_backend_type(type_values, self, **kwargs)
return f"{key}: {value} dict"