class_docstr: Displays a progress bar.
  
  Arguments:
      target: Total number of steps expected, None if unknown.
      width: Progress bar width on screen.
      verbose: Verbosity mode, 0 (silent), 1 (verbose), 2 (semi-verbose), 3 (compact table)
      stateful_metrics: Iterable of string names of metrics that should *not* be
        averaged over time. Metrics in this list will be displayed as-is. All
        others will be averaged by the progbar before display.
      interval: Minimum visual progress update interval (in seconds).
      unit_name: Display name for step counts (usually "step" or "sample").
code: def compact_table_progress(self, current, finalize=False):
      now = time.time()
      if now - self._last_update < self.interval and not finalize:
          return
  
      def to_column_name(i):
          # 0,1,2,3,4,5,6,7,8,9,A,B,C,D, etc
          return str(i) if i < 10 else chr(i + 55)
  
      if self.epoch == 0 and (self._last_update == 0 or finalize):
          # first epoch, first or last update: show the metric names
          info = ""
          for i, k in enumerate(
              ["Step/Epoch", "Time"] + self._values_order
          ):
              if k not in self._compact_header_already_printed_names:
                  i = to_column_name(i)
                  info += f"[{i}]{k} | "
                  self._compact_header_already_printed_names += [k]
          # remove the last |
          info = info[:-3]
          if len(info):
              print(info, end="\n", file=sys.stdout, flush=True)
  
      info = " "
      # first column: show step if running, epoch if finished
      if finalize and self.epoch is not None:
          # epoch
          numdigits = int(np.log10(self.target)) + 1
          colstr = f"%{numdigits*2+1}d" % self.epoch
      else:
          # step
          if self.target is not None:
              numdigits = int(np.log10(self.target)) + 1
              colstr = ("%" + str(numdigits) + "d/%d") % (
                  current,
                  self.target,
              )
              progress = float(current) / self.target
          else:
              colstr = "%7d/Unknown" % current
      self._compact_table_column_width[0] = len(colstr)
      info += colstr
  
      # second column: elapsed time
      elapsed = now - self._start
      timestr = f"{elapsed:6.1f}s"
      self._compact_table_column_width[1] = len(timestr)
      info += " | " + timestr
  
      for i, k in enumerate(self._values_order):
          avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))
          if 1e4 >= avg > 1e-3:
              valstr = "%.3f" % avg
          else:
              valstr = "%.3e" % avg
  
          # prepend spaces if necessary to keep column width the same as before
          valstr = (
              " "
              * (
                  self._compact_table_column_width.get(i + 2, 0)
                  - len(valstr)
              )
              + valstr
          )
          self._compact_table_column_width[i + 2] = len(valstr)
          info += " | " + valstr
  
      if self.epoch == 0 and finalize:
          # first epoch, last update: show table separator with column numbers
          if self.target is None:
              self.target = current
  
          sep = " " * len(info) + "\n"
          for i in range(len(self._values_order) + 2):
              colwidth = self._compact_table_column_width[i]
              colname = to_column_name(i)
              colwidth = colwidth - len(f"[{colname}]")
              sep += (
                  "#" * (int(np.ceil(colwidth / 2)) + 1)
                  + f"[{colname}]"
                  + "#" * (int(np.floor(colwidth / 2)) + 1)
                  + "|"
              )
  
          # remove the last |
          sep = sep[:-1]
          print(sep, end="\n", file=sys.stdout, flush=True)
  
      print(
          info,
          end="\r" if self._dynamic_display and not finalize else "\n",
          file=sys.stdout,
          flush=True,
      )
  
imports: import copy
  import os
  import sys
  import time
  import numpy
  from .callback import Callback
label_desc: Use image node_id 4 for calling the Progbar obj's underlying member method code with example usage: obj.compact_table_progress(current, finalize) and returns: unknown