code: def __call__(self, direction, factor, values):
      if len(values) == 0:
          return []
  
      ss = np.sign(values)
      signs = ["-" if v < 0 else "" for v in values]
  
      factor, number_fraction = self._get_number_fraction(factor)
  
      values = np.abs(values)
  
      if number_fraction is not None:
          values, frac_part = divmod(values, 10**number_fraction)
          frac_fmt = "%%0%dd" % (number_fraction,)
          frac_str = [frac_fmt % (f1,) for f1 in frac_part]
  
      if factor == 1:
          if number_fraction is None:
              return [
                  self.fmt_d % (s * int(v),) for s, v in zip(ss, values)
              ]
          else:
              return [
                  self.fmt_ds % (s * int(v), f1)
                  for s, v, f1 in zip(ss, values, frac_str)
              ]
      elif factor == 60:
          deg_part, min_part = divmod(values, 60)
          if number_fraction is None:
              return [
                  self.fmt_d_m % (s1, d1, m1)
                  for s1, d1, m1 in zip(signs, deg_part, min_part)
              ]
          else:
              return [
                  self.fmt_d_ms % (s, d1, m1, f1)
                  for s, d1, m1, f1 in zip(
                      signs, deg_part, min_part, frac_str
                  )
              ]
  
      elif factor == 3600:
          if ss[-1] == -1:
              inverse_order = True
              values = values[::-1]
              signs = signs[::-1]
          else:
              inverse_order = False
  
          l_hm_old = ""
          r = []
  
          deg_part, min_part_ = divmod(values, 3600)
          min_part, sec_part = divmod(min_part_, 60)
  
          if number_fraction is None:
              sec_str = [self.fmt_s_partial % (s1,) for s1 in sec_part]
          else:
              sec_str = [
                  self.fmt_ss_partial % (s1, f1)
                  for s1, f1 in zip(sec_part, frac_str)
              ]
  
          for s, d1, m1, s1 in zip(signs, deg_part, min_part, sec_str):
              l_hm = self.fmt_d_m_partial % (s, d1, m1)
              if l_hm != l_hm_old:
                  l_hm_old = l_hm
                  l = l_hm + s1
              else:
                  l = "$" + s + s1
              r.append(l)
  
          if inverse_order:
              return r[::-1]
          else:
              return r
  
      else:  # factor > 3600.
          return [r"$%s^{\circ}$" % v for v in ss * values]
  
imports: import numpy
  import math
  from mpl_toolkits.axisartist.grid_finder import ExtremeFinderSimple
label_desc: Use image node_id 2 for calling the FormatterDMS obj's underlying member method code with example usage: obj.__call__(direction, factor, values) and returns: list, unknown, unknown, unknown, unknown, unknown, r, r