docs: def dict_itemstr_list(dict_, **dictkw):
      r"""
      Returns:
          list: a list of human-readable dictionary items
  
      Args:
          explicit : if True uses dict(key=val,...) format instead of {key:val,...}
      """
      import utool as ut
  
      explicit = dictkw.get('explicit', False)
      dictkw['explicit'] = _rectify_countdown_or_bool(explicit)
  
      dosort = dictkw.get('sorted_', None)
      if dosort is None:
          dosort = True
  
      if dosort and not isinstance(dict_, collections.OrderedDict):
          key_order = dictkw.get('key_order', None)
          def iteritems(d):
              if key_order is None:
                  # specify order explicilty
                  try:
                      return iter(sorted(six.iteritems(d)))
                  except TypeError:
                      # catches case where keys are of different types
                      return six.iteritems(d)
              else:
                  # Enforce specific key order
                  # TODO: depricate and just use ordered dicts
                  unordered_keys = list(d.keys())
                  other_keys = sorted(list(set(unordered_keys) - set(key_order)))
                  keys = key_order + other_keys
                  return ((key, d[key]) for key in keys)
      else:
          iteritems = six.iteritems
  
      _valstr = _make_valstr(**dictkw)
  
      precision = dictkw.get('precision', None)
      kvsep = dictkw.get('kvsep', ': ')
      if explicit:
          kvsep = '='
  
      def make_item_str(key, val):
          if explicit or dictkw.get('strkeys', False):
              key_str = six.text_type(key)
          else:
              key_str = repr2(key, precision=precision)
  
          prefix = key_str + kvsep
          val_str = _valstr(val)
  
          # FIXME: get indentation right
          if util_type.HAVE_NUMPY and isinstance(val, np.ndarray):
              item_str = hz_str(prefix, val_str)
          else:
              # padded_indent = ' ' * min(len(indent_), len(prefix))
              # val_str = val_str.replace('\n', '\n' + padded_indent)
              item_str = prefix + val_str
          return item_str
  
      itemstr_list = [make_item_str(key, val)
                      for (key, val) in iteritems(dict_)]
  
      reverse = False
      key_order_metric = dictkw.get('key_order_metric', None)
      if key_order_metric is not None:
          if key_order_metric.startswith('-'):
              key_order_metric = key_order_metric[1:]
              reverse = True
  
      if key_order_metric == 'strlen':
          metric_list = [len(itemstr) for itemstr in itemstr_list]
          itemstr_list = ut.sortedby(itemstr_list, metric_list, reverse=reverse)
      elif key_order_metric == 'val':
          metric_list = [val for (key, val) in iteritems(dict_)]
          itemstr_list = ut.sortedby(itemstr_list, metric_list, reverse=reverse)
  
      maxlen = dictkw.get('maxlen', None)
      if maxlen is not None and len(itemstr_list) > maxlen:
          itemstr_list = itemstr_list[0:maxlen]
      return itemstr_list