class_docstr: Report on the state of dataset content.
  
  This is an analog to `git status` that is simultaneously crippled and more
  powerful. It is crippled, because it only supports a fraction of the
  functionality of its counter part and only distinguishes a subset of the
  states that Git knows about. But it is also more powerful as it can handle
  status reports for a whole hierarchy of datasets, with the ability to
  report on a subset of the content (selection of paths) across any number
  of datasets in the hierarchy.
  
  *Path conventions*
  
  All reports are guaranteed to use absolute paths that are underneath the
  given or detected reference dataset, regardless of whether query paths are
  given as absolute or relative paths (with respect to the working directory,
  or to the reference dataset, when such a dataset is given explicitly).
  Moreover, so-called "explicit relative paths" (i.e. paths that start with
  '.' or '..') are also supported, and are interpreted as relative paths with
  respect to the current working directory regardless of whether a reference
  dataset with specified.
  
  When it is necessary to address a subdataset record in a superdataset
  without causing a status query for the state _within_ the subdataset
  itself, this can be achieved by explicitly providing a reference dataset
  and the path to the root of the subdataset like so::
  
    datalad status --dataset . subdspath
  
  In contrast, when the state of the subdataset within the superdataset is
  not relevant, a status query for the content of the subdataset can be
  obtained by adding a trailing path separator to the query path (rsync-like
  syntax)::
  
    datalad status --dataset . subdspath/
  
  When both aspects are relevant (the state of the subdataset content
  and the state of the subdataset within the superdataset), both queries
  can be combined::
  
    datalad status --dataset . subdspath subdspath/
  
  When performing a recursive status query, both status aspects of subdataset
  are always included in the report.
  
  
  *Content types*
  
  The following content types are distinguished:
  
  - 'dataset' -- any top-level dataset, or any subdataset that is properly
    registered in superdataset
  - 'directory' -- any directory that does not qualify for type 'dataset'
  - 'file' -- any file, or any symlink that is placeholder to an annexed
    file when annex-status reporting is enabled
  - 'symlink' -- any symlink that is not used as a placeholder for an annexed
    file
  
  *Content states*
  
  The following content states are distinguished:
  
  - 'clean'
  - 'added'
  - 'modified'
  - 'deleted'
  - 'untracked'
code: def custom_result_summary_renderer(results):  # pragma: more cover
      # fish out sizes of annexed files. those will only be present
      # with --annex ...
      annexed = [
          (
              r.get("bytesize", None),
              r.get("has_content", None),
              r["path"],
          )
          for r in results
          if r.get("action", None) == "status" and "key" in r
      ]
      if annexed:
          # convert to int and interrogate files with content but
          # with unknown size (e.g. for --relaxed URLs), and drop 'path'
          annexed = [
              (
                  int(bytesize)
                  if bytesize is not None
                  else (
                      int(os.stat(path).st_size) if has_content else 0
                  ),
                  has_content,
              )
              for bytesize, has_content, path in annexed
          ]
          have_availability = any(a[1] is not None for a in annexed)
          total_size = bytes2human(sum(a[0] for a in annexed))
          # we have availability info encoded in the results
          from datalad.ui import ui
  
          if have_availability:
              ui.message(
                  "{} annex'd {} ({}/{} present/total size)".format(
                      len(annexed),
                      single_or_plural("file", "files", len(annexed)),
                      bytes2human(sum(a[0] for a in annexed if a[1])),
                      total_size,
                  )
              )
          else:
              ui.message(
                  "{} annex'd {} ({} recorded total size)".format(
                      len(annexed),
                      single_or_plural("file", "files", len(annexed)),
                      total_size,
                  )
              )
      if all(
          r.get("action", None) == "status"
          and r.get("state", None) == "clean"
          for r in results
      ):
          from datalad.ui import ui
  
          ui.message("nothing to save, working tree clean")
  
imports: import logging
  import os
  import os.path
  from collections import OrderedDict
  import warnings
  from datalad.utils import bytes2human, ensure_list, ensure_unicode, get_dataset_root
  from datalad.interface.base import Interface, build_doc, eval_results
  from datalad.interface.common_opts import recursion_limit, recursion_flag
  from datalad.interface.utils import generic_result_renderer
  import datalad.support.ansi_colors
  from datalad.support.param import Parameter
  from datalad.support.constraints import EnsureChoice, EnsureNone, EnsureStr
  from datalad.distribution.dataset import Dataset, EnsureDataset, datasetmethod, require_dataset, resolve_path, path_under_rev_dataset
  import datalad.utils
  from datalad.dochelpers import single_or_plural
label_desc: Use image node_id 3 for calling the Status obj's underlying member method code with example usage: obj.custom_result_summary_renderer(results) without return types