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']