in tfx/types/component_spec.py [0:0]
def type_check(self, arg_name: str, value: Any):
"""Perform type check to the parameter passed in."""
# Following helper function is needed due to the lack of subscripted
# type check support in Python 3.7. Here we hold the assumption that no
# nested container type is declared as the parameter type.
# For example:
# Dict[Text, List[str]] <------ Not allowed.
# Dict[Text, Any] <------ Okay.
def _type_check_helper(value: Any, declared: Type): # pylint: disable=g-bare-generic
"""Helper type-checking function."""
if isinstance(value, placeholder.Placeholder):
placeholders_involved = value.placeholders_involved()
if (len(placeholders_involved) != 1 or not isinstance(
placeholders_involved[0], placeholder.RuntimeInfoPlaceholder)):
placeholders_involved_str = [
x.__class__.__name__ for x in placeholders_involved
]
raise TypeError(
'Only simple RuntimeInfoPlaceholders are supported, but while '
'checking parameter %r, the following placeholders were '
'involved: %s' % (arg_name, placeholders_involved_str))
if not issubclass(declared, str):
raise TypeError(
'Cannot use Placeholders except for str parameter, but parameter '
'%r was of type %s' % (arg_name, declared))
return
is_runtime_param = _is_runtime_param(value)
value = _make_default(value)
if declared == Any:
return
if declared.__class__.__name__ in ('_GenericAlias', 'GenericMeta'):
# Should be dict or list
if declared.__origin__ in [Dict, dict]: # pylint: disable=protected-access
key_type, val_type = declared.__args__[0], declared.__args__[1]
if not isinstance(value, dict):
raise TypeError('Expecting a dict for parameter %r, but got %s '
'instead' % (arg_name, type(value)))
for k, v in value.items():
if key_type != Any and not isinstance(k, key_type):
raise TypeError('Expecting key type %s for parameter %r, '
'but got %s instead.' %
(str(key_type), arg_name, type(k)))
if val_type != Any and not isinstance(v, val_type):
raise TypeError('Expecting value type %s for parameter %r, '
'but got %s instead.' %
(str(val_type), arg_name, type(v)))
elif declared.__origin__ in [List, list]: # pylint: disable=protected-access
val_type = declared.__args__[0]
if not isinstance(value, list):
raise TypeError('Expecting a list for parameter %r, '
'but got %s instead.' % (arg_name, type(value)))
if val_type == Any:
return
for item in value:
if not isinstance(item, val_type):
raise TypeError('Expecting item type %s for parameter %r, '
'but got %s instead.' %
(str(val_type), arg_name, type(item)))
else:
raise TypeError('Unexpected type of parameter: %r' % arg_name)
elif isinstance(value, dict) and issubclass(declared, message.Message):
# If a dict is passed in and is compared against a pb message,
# do the type-check by converting it to pb message.
proto_utils.dict_to_proto(value, declared())
elif (isinstance(value, str) and not isinstance(declared, tuple) and
issubclass(declared, message.Message)):
# Skip check for runtime param string proto.
if not is_runtime_param:
# If a text is passed in and is compared against a pb message,
# do the type-check by converting text (as json) to pb message.
proto_utils.json_to_proto(value, declared())
else:
if not isinstance(value, declared):
raise TypeError('Expected type %s for parameter %r '
'but got %s instead.' %
(str(declared), arg_name, value))
_type_check_helper(value, self.type)