def testNoSharing(self):
    # Two writers with the same logdir should not share state.
    logdir = self.get_temp_dir()
    with context.eager_mode():
      writer1 = summary_ops.create_file_writer_v2(logdir)
      with writer1.as_default():
        summary_ops.write('tag', 1, step=1)
      event_files = gfile.Glob(os.path.join(logdir, '*'))
      self.assertEqual(1, len(event_files))
      file1 = event_files[0]

      writer2 = summary_ops.create_file_writer_v2(logdir)
      with writer2.as_default():
        summary_ops.write('tag', 1, step=2)
      event_files = gfile.Glob(os.path.join(logdir, '*'))
      self.assertEqual(2, len(event_files))
      event_files.remove(file1)
      file2 = event_files[0]

      # Extra writes to ensure interleaved usage works.
      with writer1.as_default():
        summary_ops.write('tag', 1, step=1)
      with writer2.as_default():
        summary_ops.write('tag', 1, step=2)

    events = iter(events_from_file(file1))
    self.assertEqual('brain.Event:2', next(events).file_version)
    self.assertEqual(1, next(events).step)
    self.assertEqual(1, next(events).step)
    self.assertRaises(StopIteration, lambda: next(events))
    events = iter(events_from_file(file2))
    self.assertEqual('brain.Event:2', next(events).file_version)
    self.assertEqual(2, next(events).step)
    self.assertEqual(2, next(events).step)
    self.assertRaises(StopIteration, lambda: next(events))

 def testCreate_graphTensorArgument_raisesError(self):
   logdir = self.get_temp_dir()
   with context.graph_mode():
     logdir_tensor = constant_op.constant(logdir)
   with context.eager_mode():
     with self.assertRaisesRegex(
         ValueError, 'Invalid graph Tensor argument.*logdir'):
       summary_ops.create_file_writer_v2(logdir_tensor)
   self.assertEmpty(gfile.Glob(os.path.join(logdir, '*')))

 def testCreate_immediateSetAsDefault_retainsReference(self):
   logdir = self.get_temp_dir()
   try:
     with context.eager_mode():
       summary_ops.create_file_writer_v2(logdir).set_as_default()
       summary_ops.flush()
   finally:
     # Ensure we clean up no matter how the test executes.
     context.context().summary_writer_resource = None

 def testAllV2SummaryOps(self):
   logdir = self.get_temp_dir()
   def define_ops():
     result = []
     # TF 2.0 summary ops
     result.append(summary_ops.write('write', 1, step=0))
     result.append(summary_ops.write_raw_pb(b'', step=0, name='raw_pb'))
     # TF 1.x tf.contrib.summary ops
     result.append(summary_ops.generic('tensor', 1, step=1))
     result.append(summary_ops.scalar('scalar', 2.0, step=1))
     result.append(summary_ops.histogram('histogram', [1.0], step=1))
     result.append(summary_ops.image('image', [[[[1.0]]]], step=1))
     result.append(summary_ops.audio('audio', [[1.0]], 1.0, 1, step=1))
     return result
   with context.graph_mode():
     ops_without_writer = define_ops()
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with summary_ops.record_if(True):
         ops_recording_on = define_ops()
       with summary_ops.record_if(False):
         ops_recording_off = define_ops()
     # We should be collecting all ops defined with a default writer present,
     # regardless of whether recording was set on or off, but not those defined
     # without a writer at all.
     del ops_without_writer
     expected_ops = ops_recording_on + ops_recording_off
     self.assertCountEqual(expected_ops, summary_ops.all_v2_summary_ops())

 def testWriteRawPb_invalidValue(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with self.assertRaisesRegex(
           errors.DataLossError,
           'Bad tf.compat.v1.Summary binary proto tensor string'):
         summary_ops.write_raw_pb('notaproto', step=12)

 def testWrite_stringTensor(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('tag', [b'foo', b'bar'], step=12)
   events = events_from_logdir(logdir)
   value = events[1].summary.value[0]
   self.assertAllEqual([b'foo', b'bar'], to_numpy(value))

 def testWrite_ndarray(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('tag', [[1, 2], [3, 4]], step=12)
   events = events_from_logdir(logdir)
   value = events[1].summary.value[0]
   self.assertAllEqual([[1, 2], [3, 4]], to_numpy(value))

 def testWrite_tensor(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     t = constant_op.constant([[1, 2], [3, 4]])
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('tag', t, step=12)
     expected = t.numpy()
   events = events_from_logdir(logdir)
   value = events[1].summary.value[0]
   self.assertAllEqual(expected, to_numpy(value))

 def testWrite(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       output = summary_ops.write('tag', 42, step=12)
       self.assertTrue(output.numpy())
   events = events_from_logdir(logdir)
   self.assertEqual(2, len(events))
   self.assertEqual(12, events[1].step)
   value = events[1].summary.value[0]
   self.assertEqual('tag', value.tag)
   self.assertEqual(42, to_numpy(value))

 def testWriteRawPb(self):
   logdir = self.get_temp_dir()
   pb = summary_pb2.Summary()
   pb.value.add().simple_value = 42.0
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       output = summary_ops.write_raw_pb(pb.SerializeToString(), step=12)
       self.assertTrue(output.numpy())
   events = events_from_logdir(logdir)
   self.assertEqual(2, len(events))
   self.assertEqual(12, events[1].step)
   self.assertProtoEquals(pb, events[1].summary)

 def testMaxQueue(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(
         logdir, max_queue=1, flush_millis=999999).as_default():
       get_total = lambda: len(events_from_logdir(logdir))
       # Note: First tf.Event is always file_version.
       self.assertEqual(1, get_total())
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       # Should flush after second summary since max_queue = 1
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(3, get_total())

 def testWrite_recordIf_constant(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       self.assertTrue(summary_ops.write('default', 1, step=0))
       with summary_ops.record_if(True):
         self.assertTrue(summary_ops.write('set_on', 1, step=0))
       with summary_ops.record_if(False):
         self.assertFalse(summary_ops.write('set_off', 1, step=0))
   events = events_from_logdir(logdir)
   self.assertEqual(3, len(events))
   self.assertEqual('default', events[1].summary.value[0].tag)
   self.assertEqual('set_on', events[2].summary.value[0].tag)

 def testClose_preventsLaterUse(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     writer.close()
     writer.close()  # redundant close() is a no-op
     writer.flush()  # redundant flush() is a no-op
     with self.assertRaisesRegex(RuntimeError, 'already closed'):
       writer.init()
     with self.assertRaisesRegex(RuntimeError, 'already closed'):
       with writer.as_default():
         self.fail('should not get here')
     with self.assertRaisesRegex(RuntimeError, 'already closed'):
       writer.set_as_default()

 def testWrite_metadata(self):
   logdir = self.get_temp_dir()
   metadata = summary_pb2.SummaryMetadata()
   metadata.plugin_data.plugin_name = 'foo'
   with context.eager_mode():
     with summary_ops.create_file_writer_v2(logdir).as_default():
       summary_ops.write('obj', 0, 0, metadata=metadata)
       summary_ops.write('bytes', 0, 0, metadata=metadata.SerializeToString())
       m = constant_op.constant(metadata.SerializeToString())
       summary_ops.write('string_tensor', 0, 0, metadata=m)
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(metadata, events[1].summary.value[0].metadata)
   self.assertEqual(metadata, events[2].summary.value[0].metadata)
   self.assertEqual(metadata, events[3].summary.value[0].metadata)

 def testCreate_withInitAndClose(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=1000, flush_millis=1000000)
     get_total = lambda: len(events_from_logdir(logdir))
     self.assertEqual(1, get_total())  # file_version Event
     # Calling init() again while writer is open has no effect
     writer.init()
     self.assertEqual(1, get_total())
     with writer.as_default():
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       # Calling .close() should do an implicit flush
       writer.close()
       self.assertEqual(2, get_total())

 def __init__(self):
   self._resource = ged_ops.stats_aggregator_handle_v2()
   # There could be a conflict with multiple file writer in the same logdir,
   # (b/37351340). Possible workarounds till this bug is resolved are a) having
   # multiple dataset stats specific file inside log_dir and b) get default
   # summary writer, getting default summary writer quite doesn't solve the
   # problem as there might be summary writers in log dir not set as default
   # e.g. in Keras calback.
   # Creating a summary_writer here could potentially be replaced with getting
   # the default summary_writer if any, creating it otherwise or a public
   # method to associate summary writer.
   self._logdir = tempfile.mkdtemp()
   self._summary_writer = summary_ops_v2.create_file_writer_v2(
       self._logdir, max_queue=_DEFAULT_MAX_QUEUE)
   ged_ops.stats_aggregator_set_summary_writer(self._resource,
                                               self._summary_writer._resource)  # pylint: disable=protected-access

 def testDereference_closesOpenFile(self):
   try:
     import psutil  # pylint: disable=g-import-not-at-top
   except ImportError:
     raise unittest.SkipTest('test requires psutil')
   proc = psutil.Process()
   get_open_filenames = lambda: set(info[0] for info in proc.open_files())
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     files = gfile.Glob(os.path.join(logdir, '*'))
     self.assertEqual(1, len(files))
     eventfile = files[0]
     self.assertIn(eventfile, get_open_filenames())
     del writer
     self.assertNotIn(eventfile, get_open_filenames())

 def testWriterFlush(self):
   logdir = self.get_temp_dir()
   get_total = lambda: len(events_from_logdir(logdir))
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(
         logdir, max_queue=1000, flush_millis=1000000)
     self.assertEqual(1, get_total())  # file_version Event
     with writer.as_default():
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(1, get_total())
       writer.flush()
       self.assertEqual(2, get_total())
       summary_ops.write('tag', 1, step=0)
       self.assertEqual(2, get_total())
     # Exiting the "as_default()" should do an implicit flush
     self.assertEqual(3, get_total())

 def testWrite_recordIf_constant_fromFunction(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     writer = summary_ops.create_file_writer_v2(logdir)
     @def_function.function
     def f():
       with writer.as_default():
         # Use assertAllEqual instead of assertTrue since it works in a defun.
         self.assertAllEqual(summary_ops.write('default', 1, step=0), True)
         with summary_ops.record_if(True):
           self.assertAllEqual(summary_ops.write('set_on', 1, step=0), True)
         with summary_ops.record_if(False):
           self.assertAllEqual(summary_ops.write('set_off', 1, step=0), False)
     f()
   events = events_from_logdir(logdir)
   self.assertEqual(3, len(events))
   self.assertEqual('default', events[1].summary.value[0].tag)
   self.assertEqual('set_on', events[2].summary.value[0].tag)

 def testWrite_recordIf_callable(self):
   logdir = self.get_temp_dir()
   with context.eager_mode():
     step = variables.Variable(-1, dtype=dtypes.int64)
     def record_fn():
       step.assign_add(1)
       return int(step % 2) == 0
     with summary_ops.create_file_writer_v2(logdir).as_default():
       with summary_ops.record_if(record_fn):
         self.assertTrue(summary_ops.write('tag', 1, step=step))
         self.assertFalse(summary_ops.write('tag', 1, step=step))
         self.assertTrue(summary_ops.write('tag', 1, step=step))
         self.assertFalse(summary_ops.write('tag', 1, step=step))
         self.assertTrue(summary_ops.write('tag', 1, step=step))
   events = events_from_logdir(logdir)
   self.assertEqual(4, len(events))
   self.assertEqual(0, events[1].step)
   self.assertEqual(2, events[2].step)
   self.assertEqual(4, events[3].step)