11.14.1 Telnet Objects

##
11.14.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.

`read_sb_data`( | )

  Return the data collected between a SB/SE pair (suboption begin/end). The callback should access these data when it was invoked with a `SE` command. This method never blocks.

  New in version 2.3.

`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.