docs: def shprint(command, *args, **kwargs):
      '''Runs the command (which should be an sh.Command instance), while
      logging the output.'''
      kwargs["_iter"] = True
      kwargs["_out_bufsize"] = 1
      kwargs["_err_to_out"] = True
      kwargs["_bg"] = True
      is_critical = kwargs.pop('_critical', False)
      tail_n = kwargs.pop('_tail', None)
      full_debug = False
      if "P4A_FULL_DEBUG" in os.environ:
          tail_n = 0
          full_debug = True
      filter_in = kwargs.pop('_filter', None)
      filter_out = kwargs.pop('_filterout', None)
      if len(logger.handlers) > 1:
          logger.removeHandler(logger.handlers[1])
      columns = get_console_width()
      command_path = str(command).split('/')
      command_string = command_path[-1]
      string = ' '.join(['{}->{} running'.format(Out_Fore.LIGHTBLACK_EX,
                                                 Out_Style.RESET_ALL),
                         command_string] + list(args))
  
      # If logging is not in DEBUG mode, trim the command if necessary
      if logger.level > logging.DEBUG:
          logger.info('{}{}'.format(shorten_string(string, columns - 12),
                                    Err_Style.RESET_ALL))
      else:
          logger.debug('{}{}'.format(string, Err_Style.RESET_ALL))
  
      need_closing_newline = False
      try:
          msg_hdr = '           working: '
          msg_width = columns - len(msg_hdr) - 1
          output = command(*args, **kwargs)
          for line in output:
              if isinstance(line, bytes):
                  line = line.decode('utf-8', errors='replace')
              if logger.level > logging.DEBUG:
                  if full_debug:
                      stdout.write(line)
                      stdout.flush()
                      continue
                  msg = line.replace(
                      '\n', ' ').replace(
                          '\t', ' ').replace(
                              '\b', ' ').rstrip()
                  if msg:
                      if "CI" not in os.environ:
                          stdout.write(u'{}\r{}{:<{width}}'.format(
                              Err_Style.RESET_ALL, msg_hdr,
                              shorten_string(msg, msg_width), width=msg_width))
                          stdout.flush()
                          need_closing_newline = True
              else:
                  logger.debug(''.join(['\t', line.rstrip()]))
          if need_closing_newline:
              stdout.write('{}\r{:>{width}}\r'.format(
                  Err_Style.RESET_ALL, ' ', width=(columns - 1)))
              stdout.flush()
      except sh.ErrorReturnCode as err:
          if need_closing_newline:
              stdout.write('{}\r{:>{width}}\r'.format(
                  Err_Style.RESET_ALL, ' ', width=(columns - 1)))
              stdout.flush()
          if tail_n is not None or filter_in or filter_out:
              def printtail(out, name, forecolor, tail_n=0,
                            re_filter_in=None, re_filter_out=None):
                  lines = out.splitlines()
                  if re_filter_in is not None:
                      lines = [l for l in lines if re_filter_in.search(l)]
                  if re_filter_out is not None:
                      lines = [l for l in lines if not re_filter_out.search(l)]
                  if tail_n == 0 or len(lines) <= tail_n:
                      info('{}:\n{}\t{}{}'.format(
                          name, forecolor, '\t\n'.join(lines), Out_Fore.RESET))
                  else:
                      info('{} (last {} lines of {}):\n{}\t{}{}'.format(
                          name, tail_n, len(lines),
                          forecolor, '\t\n'.join([s for s in lines[-tail_n:]]),
                          Out_Fore.RESET))
              printtail(err.stdout.decode('utf-8'), 'STDOUT', Out_Fore.YELLOW, tail_n,
                        re.compile(filter_in) if filter_in else None,
                        re.compile(filter_out) if filter_out else None)
              printtail(err.stderr.decode('utf-8'), 'STDERR', Err_Fore.RED)
          if is_critical:
              env = kwargs.get("env")
              if env is not None:
                  info("{}ENV:{}\n{}\n".format(
                      Err_Fore.YELLOW, Err_Fore.RESET, "\n".join(
                          "set {}={}".format(n, v) for n, v in env.items())))
              info("{}COMMAND:{}\ncd {} && {} {}\n".format(
                  Err_Fore.YELLOW, Err_Fore.RESET, os.getcwd(), command,
                  ' '.join(args)))
              warning("{}ERROR: {} failed!{}".format(
                  Err_Fore.RED, command, Err_Fore.RESET))
              exit(1)
          else:
              raise
  
      return output