class_docstr: Lazy auto-converting wrapper for a callable that returns a `tf.Tensor`.
  
  This class wraps an arbitrary callable that returns a `Tensor` so that it
  will be automatically converted to a `Tensor` by any logic that calls
  `tf.convert_to_tensor()`. This also memoizes the callable so that it is
  called at most once.
  
  The intended use of this class is to defer the construction of a `Tensor`
  (e.g. to avoid unnecessary wasted computation, or ensure any new ops are
  created in a context only available later on in execution), while remaining
  compatible with APIs that expect to be given an already materialized value
  that can be converted to a `Tensor`.
  
  This class is thread-safe.
code: def __call__(self):
      if (
          self._tensor is None
          or self._tensor is _CALL_IN_PROGRESS_SENTINEL
      ):
          with self._tensor_lock:
              if self._tensor is _CALL_IN_PROGRESS_SENTINEL:
                  raise RuntimeError(
                      "Cannot use LazyTensorCreator with reentrant callable"
                  )
              elif self._tensor is None:
                  self._tensor = _CALL_IN_PROGRESS_SENTINEL
                  self._tensor = self._tensor_callable()
      return self._tensor
  
imports: import threading
  from tensorboard.compat import tf2
label_desc: Use image node_id 2 for calling the LazyTensorCreator obj's underlying member method code with example usage: obj.__call__() and returns: self