def _convert_anonymous_fields(value, for_spec=False):
"""Type-checks and converts `value` for inclusion in an AnonymousExtensionType."""
if isinstance(value, (int, float, bool, str, bytes, type(None),
dtypes.DType, tensor_shape.TensorShape)):
return value
if isinstance(value, tuple):
return tuple(_convert_anonymous_fields(v, for_spec) for v in value)
if isinstance(value, typing.Mapping):
return immutable_dict.ImmutableDict([
(_convert_anonymous_fields(k, for_spec),
_convert_anonymous_fields(v, for_spec))
for (k, v) in value.items()
])
if (isinstance(value, (ops.Tensor, composite_tensor.CompositeTensor))
and not for_spec):
return value
if isinstance(value, type_spec.TypeSpec) and for_spec:
return value
raise ValueError(f'Cannot convert anonymous fields from '
f'an unsupported `value` argument: {value!r}.')
def _convert_mapping(value, expected_type, path, for_spec):
"""Converts `value` to a mapping with type `expected_type`."""
if not isinstance(value, typing.Mapping):
raise TypeError(f'{"".join(path)}: expected mapping, got {value!r}')
key_type, value_type = type_annotations.get_generic_type_args(expected_type)
return immutable_dict.ImmutableDict([
(_convert_value(k, key_type, path + ('[<key>]',), for_spec),
_convert_value(v, value_type, path + (f'[{k!r}]',), for_spec))
for (k, v) in value.items()
])
def testSetItemFails(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
with self.assertRaises(TypeError):
d['x'] = 5 # pylint: disable=unsupported-assignment-operation
with self.assertRaises(TypeError):
d['z'] = 5 # pylint: disable=unsupported-assignment-operation
def testDelItemFails(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
with self.assertRaises(TypeError):
del d['x'] # pylint: disable=unsupported-delete-operation
with self.assertRaises(TypeError):
del d['z'] # pylint: disable=unsupported-delete-operation
def testItems(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertEqual(set(d.items()), set([('x', 1), ('y', 2)]))
def testNotEqual(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertNotEqual(d, {'x': 1})
def testKeys(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertEqual(set(d.keys()), set(['x', 'y']))
def testValues(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertEqual(set(d.values()), set([1, 2]))
def testRepr(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
s = repr(d)
self.assertTrue(s == "ImmutableDict({'x': 1, 'y': 2})" or
s == "ImmutableDict({'y': 1, 'x': 2})")
def testGet(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertEqual(d.get('x'), 1)
self.assertEqual(d.get('y'), 2)
self.assertIsNone(d.get('z'))
self.assertEqual(d.get('z', 'Foo'), 'Foo')
def testLen(self):
d1 = immutable_dict.ImmutableDict({})
self.assertLen(d1, 0) # pylint: disable=g-generic-assert
d2 = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertLen(d2, 2)
def testContains(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertIn('x', d)
self.assertIn('y', d)
self.assertNotIn('z', d)
def testIter(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertEqual(set(iter(d)), set(['x', 'y']))
def testGetItem(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
self.assertEqual(d['x'], 1)
self.assertEqual(d['y'], 2)
with self.assertRaises(KeyError):
d['z'] # pylint: disable=pointless-statement
def testDelItemFails(self):
d = immutable_dict.ImmutableDict({'x': 1, 'y': 2})
with self.assertRaises(TypeError):
del d['x']
with self.assertRaises(TypeError):
del d['z']
