def __class_getitem__(cls, params):
if not isinstance(params, tuple):
params = (params, )
if not params and cls is not Tuple:
raise TypeError(
"Parameter list to {}[...] cannot be empty".format(
cls.__qualname__))
msg = "Parameters to generic types must be types."
params = tuple(_type_check(p, msg) for p in params)
if cls is Protocol:
# Generic can only be subscripted with unique type variables.
if not all(isinstance(p, TypeVar) for p in params):
i = 0
while isinstance(params[i], TypeVar):
i += 1
raise TypeError(
"Parameters to Protocol[...] must all be type variables."
" Parameter {} is {}".format(i + 1, params[i]))
if len(set(params)) != len(params):
raise TypeError(
"Parameters to Protocol[...] must all be unique")
else:
# Subscripting a regular Generic subclass.
_check_generic(cls, params)
return _GenericAlias(cls, params)
def __getitem__(self, parameters):
if parameters == ():
raise TypingError('cannot take a Bro record of no types.')
if not isinstance(parameters, tuple):
parameters = (parameters,)
parameters = typing._remove_dups_flatten(parameters) # pylint: disable=protected-access
if len(parameters) == 1:
return parameters[0]
return typing._GenericAlias(self, parameters) # pylint: disable=protected-access
def __getitem__(self, parameters):
if self._name in ('ClassVar', 'Final'):
item = _type_check(parameters, f'{self._name} accepts only single type.')
return _GenericAlias(self, (item,))
if self._name == 'Union':
if parameters == ():
raise TypeError("Cannot take a Union of no types.")
if not isinstance(parameters, tuple):
parameters = (parameters,)
msg = "Union[arg, ...]: each arg must be a type."
parameters = tuple(_type_check(p, msg) for p in parameters)
parameters = _remove_dups_flatten(parameters)
if len(parameters) == 1:
return parameters[0]
return _GenericAlias(self, parameters)
if self._name == 'Optional':
arg = _type_check(parameters, "Optional[t] requires a single type.")
return Union[arg, type(None)]
if self._name == 'Literal':
# There is no '_type_check' call because arguments to Literal[...] are
# values, not types.
return _GenericAlias(self, parameters)
raise TypeError(f"{self} is not subscriptable")
def pytype_to_myiatype(pytype):
"""Convert a Python type into a Myia type.
Arguments:
pytype: The Python type to convert.
"""
return _simple_types[pytype]
#############################################
# Extra types compatible with typing module #
#############################################
T = typing.TypeVar('T')
Array = typing._GenericAlias(numpy.ndarray, T)
class External(typing.Generic[T]):
"""Represents a type external to Myia (essentially invalid)."""
obj: T
__all__ = [
'Bool',
'Dict',
'EnvType',
'ExceptionType',
'External',
'Float',
import sage.sets.family
def specialize(type, value):
"""
Return a callable type that takes a GAP handle and make
"""
if hasattr(type, "specialize"):
return type.specialize(value)
else:
return type
def GenericMeta_specialize(self, value):
return self.copy_with(tuple(specialize(a, value) for a in self.__args__))
_GenericAlias.specialize = GenericMeta_specialize
Family = _GenericAlias(sage.sets.family.TrivialFamily, typing.T)
class _Facade:
pass
Facade = _GenericAlias(_Facade, typing.T)
Sage = attrcall("sage")
# Class for dependent types constructed from a callable value -> type
#
class DependentType:#(typing._TypingBase): # Singleton
#__metaclass__ = typing.TypingMeta
__slots__ = ("name", "specialize")
# Should be callable?
def __init__(self, specialize, name):
self.name = name
self.specialize = specialize
def __class_getitem__(cls, item):
"""Define this to override the patch that koalas performs on pandas.
https://github.com/databricks/koalas/blob/master/databricks/koalas/__init__.py#L207-L223
"""
return _GenericAlias(cls, item)
bar: fn(tp)
with pytest.raises(XmlTypeError) as exc_info:
xml_dataclass(Foo)
msg = str(exc_info.value)
assert "Invalid type" in msg
assert "'bar'" in msg
cause = exc_info.value.__cause__
assert isinstance(cause, XmlTypeError)
@pytest.mark.parametrize(
"tp,err",
[
(_GenericAlias(
list, (int, str)), "List type has invalid number of arguments"),
(List[Optional[XmlDt1]], "Nested type cannot be optional"),
(Optional[List[Optional[XmlDt1]]], "Nested type cannot be optional"),
(Union[XmlDt1, XmlDt2], "different namespaces"),
],
)
def test_invalid_field_types_2(tp, err):
class Foo:
__ns__ = None
bar: tp
with pytest.raises(XmlTypeError) as exc_info:
xml_dataclass(Foo)
msg = str(exc_info.value)
assert "Invalid type" in msg
def __getitem__(self, parameters):
return _GenericAlias(self, parameters)
def __getitem__(self, parameters):
item = _type_check(parameters, "Static accepts only single type.")
return _GenericAlias(self, (item, ))
def __class_getitem__(cls, params):
ty = _GenericAlias(cls.__special_form__, params)
ty.__apix_param_type__ = cls.__apix_param_type__
return ty
