##
11.13.1 Telnet Objects

`Telnet` instances have the following methods:

`read_until`(expected[, timeout])
  Read until a given string, expected, is encountered or until timeout seconds have passed.

  When no match is found, return whatever is available instead, possibly the empty string. Raise `EOFError` if the connection is closed and no cooked data is available.

`read_all`()
  Read all data until EOF; block until connection closed.

`read_some`()
  Read at least one byte of cooked data unless EOF is hit. Return `''` if EOF is hit. Block if no data is immediately available.

`read_very_eager`()
  Read everything that can be without blocking in I/O (eager).

  Raise `EOFError` if connection closed and no cooked data available. Return `''` if no cooked data available otherwise. Do not block unless in the midst of an IAC sequence.

`read_eager`()
  Read readily available data.

  Raise `EOFError` if connection closed and no cooked data available. Return `''` if no cooked data available otherwise. Do not block unless in the midst of an IAC sequence.

`read_lazy`()
  Process and return data already in the queues (lazy).

  Raise `EOFError` if connection closed and no data available. Return `''` if no cooked data available otherwise. Do not block unless in the midst of an IAC sequence.

`read_very_lazy`()
  Return any data available in the cooked queue (very lazy).

  Raise `EOFError` if connection closed and no data available. Return `''` if no cooked data available otherwise. This method never blocks.

`open`(host[, port])
  Connect to a host. The optional second argument is the port number, which defaults to the standard Telnet port (23).

  Do not try to reopen an already connected instance.

`msg`(msg[, *args])
  Print a debug message when the debug level is `>` 0. If extra arguments are present, they are substituted in the message using the standard string formatting operator.

`set_debuglevel`(debuglevel)
  Set the debug level. The higher the value of debuglevel, the more debug output you get (on `sys.stdout`).

`close`()
  Close the connection.

`get_socket`()
  Return the socket object used internally.

`fileno`()
  Return the file descriptor of the socket object used internally.

`write`(buffer)
  Write a string to the socket, doubling any IAC characters. This can block if the connection is blocked. May raise `socket.error` if the connection is closed.

`interact`()
  Interaction function, emulates a very dumb Telnet client.

`mt_interact`()
  Multithreaded version of `interact()`.

`expect`(list[, timeout])
  Read until one from a list of a regular expressions matches.

  The first argument is a list of regular expressions, either compiled (`re.RegexObject` instances) or uncompiled (strings). The optional second argument is a timeout, in seconds; the default is to block indefinitely.

  Return a tuple of three items: the index in the list of the first regular expression that matches; the match object returned; and the text read up till and including the match.

  If end of file is found and no text was read, raise `EOFError`. Otherwise, when nothing matches, return `(-1, None, text)` where text is the text received so far (may be the empty string if a timeout happened).

  If a regular expression ends with a greedy match (such as `.*`) or if more than one expression can match the same input, the results are indeterministic, and may depend on the I/O timing.

`set_option_negotiation_callback`(callback)
  Each time a telnet option is read on the input flow, this callback (if set) is called with the following parameters : callback(telnet socket, command (DO/DONT/WILL/WONT), option). No other action is done afterwards by telnetlib.