def testSkipEagerTensorListGetItemGradAggregation(self):
   l = list_ops.tensor_list_reserve(
       element_shape=[], num_elements=1, element_dtype=dtypes.float32)
   x = constant_op.constant(1.0)
   l = list_ops.tensor_list_set_item(l, 0, x)
   l_read1 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
   l_read2 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
   grad = gradients_impl.gradients([l_read1, l_read2], [x])
   with self.cached_session() as sess:
     self.assertSequenceEqual(self.evaluate(grad), [2.])

 def testUnevenSplit(self):
   l = list_ops.tensor_list_split([1., 2., 3., 4., 5],
                                  element_shape=None,
                                  lengths=[3, 2])
   self.assertAllEqual(list_ops.tensor_list_length(l), 2)
   self.assertAllEqual(
       list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32),
       [1., 2., 3.])
   self.assertAllEqual(
       list_ops.tensor_list_get_item(l, 1, element_dtype=dtypes.float32),
       [4., 5.])

 def testGetSetReservedNonScalar(self):
   with self.cached_session() as sess, self.test_scope():
     l = list_ops.tensor_list_reserve(
         element_dtype=dtypes.float32,
         element_shape=(7, 15),
         num_elements=2)
     l = list_ops.tensor_list_set_item(
         l, 0, constant_op.constant(1.0, shape=(7, 15)))
     e1 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     e2 = list_ops.tensor_list_get_item(l, 1, element_dtype=dtypes.float32)
     self.assertAllEqual(sess.run(e1), np.ones((7, 15)))
     self.assertAllEqual(sess.run(e2), np.zeros((7, 15)))

 def testScatterGrad(self):
   with backprop.GradientTape() as tape:
     c0 = constant_op.constant([1.0, 2.0])
     tape.watch(c0)
     l = list_ops.tensor_list_scatter(
         c0, [1, 0], ops.convert_to_tensor([], dtype=dtypes.int32))
     t0 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     t1 = list_ops.tensor_list_get_item(l, 1, element_dtype=dtypes.float32)
     self.assertAllEqual(self.evaluate(t0), 2.0)
     self.assertAllEqual(self.evaluate(t1), 1.0)
     loss = t0 * t0 + t1 * t1
   dt = tape.gradient(loss, c0)
   self.assertAllEqual(self.evaluate(dt), [2., 4.])

 def testGetSetGradients(self):
   with backprop.GradientTape() as tape:
     c = constant_op.constant([1.0, 2.0])
     tape.watch(c)
     l = list_ops.tensor_list_from_tensor(c, element_shape=[])
     c2 = constant_op.constant(3.0)
     tape.watch(c2)
     l = list_ops.tensor_list_set_item(l, 0, c2)
     e = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     ee = list_ops.tensor_list_get_item(l, 1, element_dtype=dtypes.float32)
     y = e * e + ee * ee
   grad_c, grad_c2 = tape.gradient(y, [c, c2])
   self.assertAllEqual(self.evaluate(grad_c), [0.0, 4.0])
   self.assertAllEqual(self.evaluate(grad_c2), 6.0)

def _tf_tensor_list_get_item(target, i, opts):
  """Overload of get_item that stages a Tensor list read."""
  if opts.element_dtype is None:
    raise ValueError('cannot retrieve from a list without knowing its '
                     'element type; use set_element_type to annotate it')
  x = list_ops.tensor_list_get_item(target, i, element_dtype=opts.element_dtype)
  return x

 def testGetSetItem(self):
   t = constant_op.constant([1.0, 2.0])
   l = list_ops.tensor_list_from_tensor(t, element_shape=[])
   e0 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
   self.assertAllEqual(self.evaluate(e0), 1.0)
   l = list_ops.tensor_list_set_item(l, 0, 3.0)
   t = list_ops.tensor_list_stack(l, element_dtype=dtypes.float32)
   self.assertAllEqual(self.evaluate(t), [3.0, 2.0])

 def testGetSetReserved(self):
   with self.cached_session(), self.test_scope():
     l = list_ops.tensor_list_reserve(
         element_dtype=dtypes.float32, element_shape=[], num_elements=2)
     e0 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     self.assertAllEqual(e0, 0.0)
     l = list_ops.tensor_list_set_item(l, 0, 3.0)
     t = list_ops.tensor_list_stack(l, element_dtype=dtypes.float32)
     self.assertAllEqual(t, [3.0, 0.0])

 def testGetSet(self):
   with self.cached_session(), self.test_scope():
     t = constant_op.constant([1.0, 2.0])
     l = list_ops.tensor_list_from_tensor(t, element_shape=[])
     e0 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     self.assertAllEqual(e0, 1.0)
     l = list_ops.tensor_list_set_item(l, 0, 3.0)
     t = list_ops.tensor_list_stack(l, element_dtype=dtypes.float32)
     self.assertAllEqual(t, [3.0, 2.0])

 def testSetGetGrad(self):
   with backprop.GradientTape() as tape:
     t = constant_op.constant(5.)
     tape.watch(t)
     l = list_ops.tensor_list_reserve(
         element_dtype=dtypes.float32, element_shape=[], num_elements=3)
     l = list_ops.tensor_list_set_item(l, 1, 2. * t)
     e = list_ops.tensor_list_get_item(l, 1, element_dtype=dtypes.float32)
     self.assertAllEqual(self.evaluate(e), 10.0)
   self.assertAllEqual(self.evaluate(tape.gradient(e, t)), 2.0)

 def read(self, index, name=None):
   """See TensorArray."""
   value = list_ops.tensor_list_get_item(
       input_handle=self._flow,
       index=index,
       element_dtype=self._dtype,
       name=name)
   if self._element_shape:
     value.set_shape(self._element_shape[0].dims)
   return value

 def testListFromTensor(self):
   with self.cached_session(), self.test_scope():
     t = constant_op.constant([1.0, 2.0])
     l = list_ops.tensor_list_from_tensor(t, element_shape=[])
     e = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     self.assertAllEqual(e, 1.0)
     l, e0 = list_ops.tensor_list_pop_back(l, element_dtype=dtypes.float32)
     self.assertAllEqual(e0, 2.0)
     l, e1 = list_ops.tensor_list_pop_back(l, element_dtype=dtypes.float32)
     self.assertAllEqual(e1, 1.0)
     self.assertAllEqual(list_ops.tensor_list_length(l), 0)

 def testSkipEagerSetItemWithMismatchedShapeFails(self):
   with self.cached_session() as sess:
     ph = array_ops.placeholder(dtypes.float32)
     c = constant_op.constant([1.0, 2.0])
     l = list_ops.tensor_list_from_tensor(c, element_shape=[])
     # Set a placeholder with unknown shape to satisfy the shape inference
     # at graph building time.
     l = list_ops.tensor_list_set_item(l, 0, ph)
     l_0 = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     with self.assertRaisesRegexp(errors.InvalidArgumentError,
                                  "incompatible shape"):
       sess.run(l_0, {ph: [3.0]})

 def testScatterUpdateVariant(self):
   with context.eager_mode():
     v = resource_variable_ops.ResourceVariable([
         list_ops.empty_tensor_list(
             element_dtype=dtypes.float32, element_shape=[])
     ])
     v.scatter_update(
         ops.IndexedSlices(
             list_ops.tensor_list_from_tensor([1., 2.], element_shape=[]), 0))
     self.assertAllEqual(
         list_ops.tensor_list_get_item(v[0], 0, element_dtype=dtypes.float32),
         1.)

 def testStack(self):
   with self.cached_session(), self.test_scope():
     l = list_ops.empty_tensor_list(
         element_dtype=dtypes.float32,
         element_shape=[],
         max_num_elements=2)
     l = list_ops.tensor_list_push_back(l, constant_op.constant(1.0))
     e = list_ops.tensor_list_get_item(l, 0, element_dtype=dtypes.float32)
     self.assertAllEqual(e, 1.0)
     l = list_ops.tensor_list_push_back(l, constant_op.constant(2.0))
     t = list_ops.tensor_list_stack(l, element_dtype=dtypes.float32)
     self.assertAllEqual(t.shape.as_list(), [None])
     self.assertAllEqual(t, [1.0, 2.0])

 def testAddNNestedList(self):
   l1 = list_ops.tensor_list_from_tensor([1.0, 2.0], element_shape=[])
   l2 = list_ops.tensor_list_from_tensor([3.0, 4.0], element_shape=[])
   l3 = list_ops.tensor_list_from_tensor([5.0, 6.0], element_shape=[])
   l4 = list_ops.tensor_list_from_tensor([7.0, 8.0], element_shape=[])
   a = list_ops.empty_tensor_list(
       element_dtype=dtypes.variant, element_shape=[])
   a = list_ops.tensor_list_push_back(a, l1)
   a = list_ops.tensor_list_push_back(a, l2)
   b = list_ops.empty_tensor_list(
       element_dtype=dtypes.variant, element_shape=[])
   b = list_ops.tensor_list_push_back(b, l3)
   b = list_ops.tensor_list_push_back(b, l4)
   result = math_ops.add_n((a, b))
   result_0 = list_ops.tensor_list_stack(
       list_ops.tensor_list_get_item(result, 0, element_dtype=dtypes.variant),
       element_dtype=dtypes.float32)
   result_1 = list_ops.tensor_list_stack(
       list_ops.tensor_list_get_item(result, 1, element_dtype=dtypes.variant),
       element_dtype=dtypes.float32)
   self.assertAllEqual(self.evaluate(result_0), [6., 8.])
   self.assertAllEqual(self.evaluate(result_1), [10., 12.])

 def read(self, index, name=None):
   """See TensorArray."""
   with ops.name_scope(name, "TensorArrayV2Read", [self._flow, index]):
     if self._element_shape:
       element_shape = self._element_shape[0]
     else:
       element_shape = tensor_shape.unknown_shape(None)
     value = list_ops.tensor_list_get_item(
         input_handle=self._flow,
         index=index,
         element_dtype=self._dtype,
         element_shape=element_shape,
         name=name)
     return value

 def __getitem__(self, key):
   return list_ops.tensor_list_get_item(self.list_, key, self.dtype)