docs: def tail(
          self, line_prefix=None, callback=None, output_callback=None, stop_callback=lambda x: False,
          timeout=None
      ):
          """
          This function takes control of an SSH channel and displays line
          by line of output as \n is recieved.  This function is specifically
          made for tail-like commands.
  
          :param line_prefix: Text to append to the left of each line of output.
                              This is especially useful if you are using my
                              MultiSSH class to run tail commands over multiple
                              servers.
          :param callback: You may optionally supply a callback function which
                           takes two paramaters.  The first is the line prefix
                           and the second is current line of output. The
                           callback should return the string that is to be
                           displayed (including the \n character).  This allows
                           users to grep the output or manipulate it as
                           required.
          :param output_callback: A function used to print ssh output. Printed to stdout
                          by default. A user-defined logger may be passed like
                          output_callback=lambda m: mylog.debug(m)
          :param stop_callback: A function usesd to stop the tail, when function retruns
                          True tail will stop, by default stop_callback=lambda x: False
          :param timeout: how much time to wait for data, default to None which
                          mean almost forever.
          """
  
          output_callback = output_callback if output_callback else self.output_callback
  
          # Set the channel timeout to the maximum integer the server allows,
          # setting this to None breaks the KeyboardInterrupt exception and
          # won't allow us to Ctrl+C out of teh script
          timeout = timeout if timeout else 2 ** (struct.Struct(str('i')).size * 8 - 1) - 1
          self.channel.settimeout(timeout)
  
          # Create an empty line buffer and a line counter
          current_line = b''
          line_counter = 0
          line_feed_byte = '\n'.encode(self.encoding)
  
          # Loop forever, Ctrl+C (KeyboardInterrupt) is used to break the tail
          while True:
  
              # Read the output one byte at a time so we can detect \n correctly
              buffer = self.channel.recv(1)
  
              # If we have an empty buffer, then the SSH session has been closed
              if len(buffer) == 0:
                  break
  
              # Add the currently read buffer to the current line output
              current_line += buffer
  
              # Display the last read line in realtime when we reach a \n
              # character
              if buffer == line_feed_byte:
                  current_line_decoded = current_line.decode(self.encoding)
                  if line_counter:
                      if callback:
                          output_callback(callback(line_prefix, current_line_decoded))
                      else:
                          if line_prefix:
                              output_callback(line_prefix)
                          output_callback(current_line_decoded)
  
                  if stop_callback(current_line_decoded):
                      break
  
                  line_counter += 1
                  current_line = b''