def testFlattenAndPack(self):

structure = ((3, 4), 5, (6, 7, (9, 10), 8))

flat = ["a", "b", "c", "d", "e", "f", "g", "h"]

self.assertEqual(nest.flatten(structure), [3, 4, 5, 6, 7, 9, 10, 8])

self.assertEqual(

nest.pack_sequence_as(structure, flat), (("a", "b"), "c",

("d", "e", ("f", "g"), "h")))

point = collections.namedtuple("Point", ["x", "y"])

structure = (point(x=4, y=2), ((point(x=1, y=0),),))

flat = [4, 2, 1, 0]

self.assertEqual(nest.flatten(structure), flat)

restructured_from_flat = nest.pack_sequence_as(structure, flat)

self.assertEqual(restructured_from_flat, structure)

self.assertEqual(restructured_from_flat[0].x, 4)

self.assertEqual(restructured_from_flat[0].y, 2)

self.assertEqual(restructured_from_flat[1][0][0].x, 1)

self.assertEqual(restructured_from_flat[1][0][0].y, 0)

self.assertEqual([5], nest.flatten(5))

self.assertEqual([np.array([5])], nest.flatten(np.array([5])))

self.assertEqual("a", nest.pack_sequence_as(5, ["a"]))

self.assertEqual(

np.array([5]), nest.pack_sequence_as("scalar", [np.array([5])]))

with self.assertRaisesRegexp(ValueError, "Structure is a scalar"):

nest.pack_sequence_as("scalar", [4, 5])

with self.assertRaisesRegexp(TypeError, "flat_sequence"):

nest.pack_sequence_as([4, 5], "bad_sequence")

with self.assertRaises(ValueError):

nest.pack_sequence_as([5, 6, [7, 8]], ["a", "b", "c"])

def testIsSequence(self):

self.assertFalse(nest.is_sequence("1234"))

self.assertTrue(nest.is_sequence([1, 3, [4, 5]]))

self.assertTrue(nest.is_sequence(((7, 8), (5, 6))))

self.assertTrue(nest.is_sequence([]))

self.assertFalse(nest.is_sequence(set([1, 2])))

ones = array_ops.ones([2, 3])

self.assertFalse(nest.is_sequence(ones))

self.assertFalse(nest.is_sequence(math_ops.tanh(ones)))

self.assertFalse(nest.is_sequence(np.ones((4, 5))))

def testFlattenDictItems(self):

dictionary = {(4, 5, (6, 8)): ("a", "b", ("c", "d"))}

flat = {4: "a", 5: "b", 6: "c", 8: "d"}

self.assertEqual(nest.flatten_dict_items(dictionary), flat)

with self.assertRaises(TypeError):

nest.flatten_dict_items(4)

bad_dictionary = {(4, 5, (4, 8)): ("a", "b", ("c", "d"))}

with self.assertRaisesRegexp(ValueError, "not unique"):

nest.flatten_dict_items(bad_dictionary)

another_bad_dictionary = {(4, 5, (6, 8)): ("a", "b", ("c", ("d", "e")))}

with self.assertRaisesRegexp(

ValueError, "Key had [0-9]* elements, but value had [0-9]* elements"):

nest.flatten_dict_items(another_bad_dictionary)

def testAssertSameStructure(self):

structure1 = (((1, 2), 3), 4, (5, 6))

structure2 = ((("foo1", "foo2"), "foo3"), "foo4", ("foo5", "foo6"))

structure_different_num_elements = ("spam", "eggs")

structure_different_nesting = (((1, 2), 3), 4, 5, (6,))

nest.assert_same_structure(structure1, structure2)

nest.assert_same_structure("abc", 1.0)

nest.assert_same_structure("abc", np.array([0, 1]))

nest.assert_same_structure("abc", constant_op.constant([0, 1]))

with self.assertRaisesRegexp(ValueError,

"don't have the same number of elements"):

nest.assert_same_structure(structure1, structure_different_num_elements)

with self.assertRaisesRegexp(ValueError,

"don't have the same number of elements"):

nest.assert_same_structure([0, 1], np.array([0, 1]))

with self.assertRaisesRegexp(ValueError,

"don't have the same number of elements"):

nest.assert_same_structure(0, [0, 1])

self.assertRaises(TypeError, nest.assert_same_structure, (0, 1), [0, 1])

with self.assertRaisesRegexp(ValueError,

"don't have the same nested structure"):

nest.assert_same_structure(structure1, structure_different_nesting)

named_type_0 = collections.namedtuple("named_0", ("a", "b"))

named_type_1 = collections.namedtuple("named_1", ("a", "b"))

self.assertRaises(TypeError, nest.assert_same_structure, (0, 1),

named_type_0("a", "b"))

nest.assert_same_structure(named_type_0(3, 4), named_type_0("a", "b"))

self.assertRaises(TypeError, nest.assert_same_structure,

named_type_0(3, 4), named_type_1(3, 4))

with self.assertRaisesRegexp(ValueError,

"don't have the same nested structure"):

nest.assert_same_structure(named_type_0(3, 4), named_type_0([3], 4))

with self.assertRaisesRegexp(ValueError,

"don't have the same nested structure"):

nest.assert_same_structure([[3], 4], [3, [4]])

def testMapStructure(self):

structure1 = (((1, 2), 3), 4, (5, 6))

structure2 = (((7, 8), 9), 10, (11, 12))

structure1_plus1 = nest.map_structure(lambda x: x + 1, structure1)

nest.assert_same_structure(structure1, structure1_plus1)

self.assertAllEqual(

[2, 3, 4, 5, 6, 7],

nest.flatten(structure1_plus1))

structure1_plus_structure2 = nest.map_structure(

lambda x, y: x + y, structure1, structure2)

self.assertEqual(

(((1 + 7, 2 + 8), 3 + 9), 4 + 10, (5 + 11, 6 + 12)),

structure1_plus_structure2)

self.assertEqual(3, nest.map_structure(lambda x: x - 1, 4))

self.assertEqual(7, nest.map_structure(lambda x, y: x + y, 3, 4))

with self.assertRaisesRegexp(TypeError, "callable"):

nest.map_structure("bad", structure1_plus1)

with self.assertRaisesRegexp(ValueError, "same nested structure"):

nest.map_structure(lambda x, y: None, 3, (3,))

with self.assertRaisesRegexp(TypeError, "same sequence type"):

nest.map_structure(lambda x, y: None, ((3, 4), 5), [(3, 4), 5])

with self.assertRaisesRegexp(ValueError, "same nested structure"):