docs: def unflat_unique_rowid_map(func, unflat_rowids, **kwargs):
      """
      performs only one call to the underlying func with unique rowids the func
      must be some lookup function
  
      TODO: move this to a better place.
  
      CommandLine:
          python -m utool.util_list --test-unflat_unique_rowid_map:0
          python -m utool.util_list --test-unflat_unique_rowid_map:1
  
      Example0:
          >>> # ENABLE_DOCTEST
          >>> from utool.util_list import *  # NOQA
          >>> import utool as ut
          >>> kwargs = {}
          >>> unflat_rowids = [[1, 2, 3], [2, 5], [1], []]
          >>> num_calls0 = [0]
          >>> num_input0 = [0]
          >>> def func0(rowids, num_calls0=num_calls0, num_input0=num_input0):
          ...     num_calls0[0] += 1
          ...     num_input0[0] += len(rowids)
          ...     return [rowid + 10 for rowid in rowids]
          >>> func = func0
          >>> unflat_vals = unflat_unique_rowid_map(func, unflat_rowids, **kwargs)
          >>> result = [arr.tolist() for arr in unflat_vals]
          >>> print(result)
          >>> ut.assert_eq(num_calls0[0], 1)
          >>> ut.assert_eq(num_input0[0], 4)
          [[11, 12, 13], [12, 15], [11], []]
  
      Example1:
          >>> # ENABLE_DOCTEST
          >>> from utool.util_list import *  # NOQA
          >>> import utool as ut
          >>> import numpy as np
          >>> kwargs = {}
          >>> unflat_rowids = [[1, 2, 3], [2, 5], [1], []]
          >>> num_calls1 = [0]
          >>> num_input1 = [0]
          >>> def func1(rowids, num_calls1=num_calls1, num_input1=num_input1, np=np):
          ...     num_calls1[0] += 1
          ...     num_input1[0] += len(rowids)
          ...     return [np.array([rowid + 10, rowid, 3]) for rowid in rowids]
          >>> func = func1
          >>> unflat_vals = unflat_unique_rowid_map(func, unflat_rowids, **kwargs)
          >>> result = [arr.tolist() for arr in unflat_vals]
          >>> print(result)
          >>> ut.assert_eq(num_calls1[0], 1)
          >>> ut.assert_eq(num_input1[0], 4)
          [[[11, 1, 3], [12, 2, 3], [13, 3, 3]], [[12, 2, 3], [15, 5, 3]], [[11, 1, 3]], []]
  
      """
      import utool as ut
      # First flatten the list, and remember the original dimensions
      flat_rowids, reverse_list = ut.invertible_flatten2(unflat_rowids)
      # Then make the input unique
      flat_rowids_arr = np.array(flat_rowids)
      unique_flat_rowids, inverse_unique = np.unique(flat_rowids_arr, return_inverse=True)
      # Then preform the lookup / implicit mapping
      unique_flat_vals = func(unique_flat_rowids, **kwargs)
      # Then broadcast unique values back to original flat positions
      flat_vals_ = np.array(unique_flat_vals)[inverse_unique]
      #flat_vals_ = np.array(unique_flat_vals).take(inverse_unique, axis=0)
      output_shape = tuple(list(flat_rowids_arr.shape) + list(flat_vals_.shape[1:]))
      flat_vals = np.array(flat_vals_).reshape(output_shape)
      # Then _unflatten the results to the original input dimensions
      unflat_vals = ut.unflatten2(flat_vals, reverse_list)
      return unflat_vals