paramiko.Transport

From 176c6caf4ea7918e1698438634b237fab8456471 Mon Sep 17 00:00:00 2001 From: "Jeremy T. Bouse" Date: Fri, 27 Nov 2009 16:20:09 -0500 Subject: Imported Upstream version 1.5.2 --- docs/public/paramiko.Transport-class.html | 1524 +++++++++++++++++++++++++++++ 1 file changed, 1524 insertions(+) create mode 100644 docs/public/paramiko.Transport-class.html (limited to 'docs/public/paramiko.Transport-class.html') diff --git a/docs/public/paramiko.Transport-class.html b/docs/public/paramiko.Transport-class.html new file mode 100644 index 0000000..562982b --- /dev/null +++ b/docs/public/paramiko.Transport-class.html @@ -0,0 +1,1524 @@ + + + + + paramiko.Transport + + + + + + + + + + + + + + + + + + +

+ + Package paramiko :: + Class Transport +
+

+ + +

[show private | hide private]

[frames | no frames]

+ + +

Type Transport

+ +

+object --+        
+         |        
+  _Verbose --+    
+             |    
+        Thread --+
+                 |
+                Transport
+

+ +

+ +An SSH Transport attaches to a stream (usually a socket), negotiates +an encrypted session, authenticates, and then creates stream tunnels, +called Channels, across the session. Multiple +channels can be multiplexed across a single session (and often are, in +the case of port forwardings). +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Method Summary
	`__init__(self, + sock)` + +Create a new SSH session over an existing socket, or socket-like +object.
	`__del__(self)` +
str +	`__repr__(self)` + +Returns a string representation of this object, for debugging.
`Channel` +	`accept(self, + timeout)` + +Return the next channel opened by the client over this transport, in +server mode.
	`add_server_key(self, + key)` + +Add a host key to the list of keys used for server mode.
list +	`auth_interactive(self, + username, + handler, + submethods)` + +Authenticate to the server interactively.
list +	`auth_none(self, + username)` + +Try to authenticate to the server using no authentication at all.
list +	`auth_password(self, + username, + password, + event, + fallback)` + +Authenticate to the server using a password.
list +	`auth_publickey(self, + username, + key, + event)` + +Authenticate to the server using a private key.
	`close(self)` + +Close this session, and any open channels that are tied to it.
	`connect(self, + hostkey, + username, + password, + pkey)` + +Negotiate an SSH2 session, and optionally verify the server's host key +and authenticate using a password or private key.
Exception +	`get_exception(self)` + +Return any exception that happened during the last server request.
bool +	`get_hexdump(self)` + +Return `True` if the transport is currently logging hex +dumps of protocol traffic.
str +	`get_log_channel(self)` + +Return the channel name used for this transport's logging.
`PKey` +	`get_remote_server_key(self)` + +Return the host key of the server (in client mode).
`SecurityOptions` +	`get_security_options(self)` + +Return a `SecurityOptions` object which can be used to +tweak the encryption algorithms this transport will permit, and the order +of preference for them.
`PKey` +	`get_server_key(self)` + +Return the active host key, in server mode.
string +	`get_username(self)` + +Return the username this connection is authenticated for.
`Message` +	`global_request(self, + kind, + data, + wait)` + +Make a global request to the remote host.
bool +	`is_active(self)` + +Return true if this session is active (open).
bool +	`is_authenticated(self)` + +Return true if this session is active and authenticated.
bool +	`load_server_moduli(filename)` + +(optional) Load a file of prime moduli for use in doing +group-exchange key negotiation in server mode. (Static method) +
`Channel` +	`open_channel(self, + kind, + dest_addr, + src_addr)` + +Request a new channel to the server.
`Channel` +	`open_session(self)` + +Request a new channel to the server, of type +`"session"`.
`SFTPClient` +	`open_sftp_client(self)` + +Create an SFTP client channel from an open transport.
bool +	`renegotiate_keys(self)` + +Force this session to switch to new keys.
	`run(self)` +
	`send_ignore(self, + bytes)` + +Send a junk packet across the encrypted link.
	`set_hexdump(self, + hexdump)` + +Turn on/off logging a hex dump of protocol traffic at DEBUG level in +the logs.
	`set_keepalive(self, + interval)` + +Turn on/off keepalive packets (default is off).
	`set_log_channel(self, + name)` + +Set the channel for this transport's logging.
	`set_subsystem_handler(self, + name, + handler, + larg, + *kwarg)` + +Set the handler class for a subsystem in server mode.
	`start_client(self, + event)` + +Negotiate a new SSH2 session as a client.
	`start_server(self, + event, + server)` + +Negotiate a new SSH2 session as a server.
	`stop_thread(self)` +
	`use_compression(self, + compress)` + +Turn on/off compression.
Inherited from Thread
	`getName(self)` +
	`isAlive(self)` +
	`isDaemon(self)` +
	`join(self, + timeout)` +
	`setDaemon(self, + daemonic)` +
	`setName(self, + name)` +
	`start(self)` +
Inherited from object
	`__delattr__(...)` + +x.__delattr__('name') <==> del x.name
	`__getattribute__(...)` + +x.__getattribute__('name') <==> x.name
	`__hash__(x)` + +x.__hash__() <==> hash(x)
	`__new__(T, + S, + ...)` + +T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__reduce__(...)` + +helper for pickle
	`__reduce_ex__(...)` + +helper for pickle
	`__setattr__(...)` + +x.__setattr__('name', value) <==> x.name = value
	`__str__(x)` + +x.__str__() <==> str(x)

+ + + + + + +

Instance Method Details

+ + +

init(self, + sock) +
(Constructor) +

Create a new SSH session over an existing socket, or socket-like + object. This only creates the Transport object; it doesn't begin the + SSH session yet. Use connect or start_client to begin a client session, + or start_server to begin a server + session.

+ If the object is not actually a socket, it must have the following + methods: +

+ send(str): Writes from 1 to len(str) + bytes, and returns an int representing the number of bytes written. + Returns 0 or raises EOFError if the stream has been + closed. +
+ recv(int): Reads from 1 to int bytes + and returns them as a string. Returns 0 or raises + EOFError if the stream has been closed. +
+ close(): Closes the socket. +
+ settimeout(n): Sets a (float) timeout on I/O + operations. +

+ For ease of use, you may also pass in an address (as a tuple) or a + host string as the sock argument. (A host string is a + hostname with an optional port (separated by + ":") which will be converted into a tuple of + (hostname, port).) A socket will be connected to this + address and used for communication. Exceptions from the + socket call may be thrown in this case. +

Parameters:: sock - + a socket or socket-like object to create the session over. +
+ (type=socket) +

Overrides:: threading.Thread.__init__

+ + +

repr(self) +
(Representation operator) +

+ Returns a string representation of this object, for debugging. +

Returns:: + str +

Overrides:: threading.Thread.__repr__

+ + +

accept(self, + timeout=None) +

+ Return the next channel opened by the client over this transport, in + server mode. If no channel is opened before the given timeout, + None is returned. +

Parameters:: timeout - + seconds to wait for a channel, or None to wait + forever +
+ (type=int) +

Returns:: + a new Channel opened by the client +
+ (type=Channel) +

+ + +

add_server_key(self, + key) +

+ Add a host key to the list of keys used for server mode. When + behaving as a server, the host key is used to sign certain packets + during the SSH2 negotiation, so that the client can trust that we are + who we say we are. Because this is used for signing, the key must + contain private key info, not just the public half. Only one key of + each type (RSA or DSS) is kept. +

Parameters:: key - + the host key to add, usually an RSAKey or DSSKey. +
+ (type=PKey) +

+ + +

auth_interactive(self, + username, + handler, + submethods='') +

Authenticate to the server interactively. A handler is used to + answer arbitrary questions from the server. On many servers, this is + just a dumb wrapper around PAM.

This method will block until the authentication succeeds or fails, + peroidically calling the handler asynchronously to get answers to + authentication questions. The handler may be called more than once if + the server continues to ask questions.

The handler is expected to be a callable that will handle calls of + the form: handler(title, instructions, prompt_list). The + title is meant to be a dialog-window title, and the + instructions are user instructions (both are strings). + prompt_list will be a list of prompts, each prompt being a + tuple of (str, bool). The string is the prompt and the + boolean indicates whether the user text should be echoed.

A sample call would thus be: handler('title', 'instructions', + [('Password:', False)]).

The handler should return a list or tuple of answers to the server's + questions.

+ If the server requires multi-step authentication (which is very + rare), this method will return a list of auth types permissible for the + next step. Otherwise, in the normal case, an empty list is + returned. +

Parameters:: username - + the username to authenticate as +
+ (type=string) +; handler - + a handler for responding to server questions +
+ (type=callable) +; submethods - + a string list of desired submethods (optional) +
+ (type=str) +

Returns:: + list of auth types permissible for the next stage of + authentication (normally empty). +
+ (type=list) +

Raises:: BadAuthenticationType - + if public-key authentication isn't allowed by the server for + this user +; SSHException - + if the authentication failed +

Since: 1.5 +

+ +

+ + +

auth_none(self, + username) +

+ Try to authenticate to the server using no authentication at all. + This will almost always fail. It may be useful for determining the list + of authentication types supported by the server, by catching the BadAuthenticationType exception + raised. +

Parameters:: username - + the username to authenticate as +
+ (type=string) +

Returns:: + list of auth types permissible for the next stage of + authentication (normally empty) +
+ (type=list) +

Raises:: BadAuthenticationType - + if "none" authentication isn't allowed by the server + for this user +; SSHException - + if the authentication failed due to a network error +

Since: 1.5 +

+ +

+ + +

auth_password(self, + username, + password, + event=None, + fallback=True) +

Authenticate to the server using a password. The username and + password are sent over an encrypted link.

If an event is passed in, this method will return + immediately, and the event will be triggered once authentication + succeeds or fails. On success, is_authenticated will return + True. On failure, you may use get_exception to get more detailed error + information.

Since 1.1, if no event is passed, this method will block until the + authentication succeeds or fails. On failure, an exception is raised. + Otherwise, the method simply returns.

Since 1.5, if no event is passed and fallback is + True (the default), if the server doesn't support plain + password authentication but does support so-called + "keyboard-interactive" mode, an attempt will be made to + authenticate using this interactive mode. If it fails, the normal + exception will be thrown as if the attempt had never been made. This is + useful for some recent Gentoo and Debian distributions, which turn off + plain password authentication in a misguided belief that interactive + authentication is "more secure". (It's not.)

Parameters:: username - + the username to authenticate as +
+ (type=string) +; password - + the password to authenticate with +
+ (type=string) +; event - + an event to trigger when the authentication attempt is + complete (whether it was successful or not) +
+ (type=threading.Event) +; fallback - + True if an attempt at an automated + "interactive" password auth should be made if the + server doesn't support normal password auth +
+ (type=bool) +

Returns:: + list of auth types permissible for the next stage of + authentication (normally empty) +
+ (type=list) +

Raises:: BadAuthenticationType - + if password authentication isn't allowed by the server for + this user (and no event was passed in) +; SSHException - + if the authentication failed (and no event was passed in) +

+ + +

auth_publickey(self, + username, + key, + event=None) +

Authenticate to the server using a private key. The key is used to + sign data from the server, so it must include the private part.

Since 1.1, if no event is passed, this method will block until the + authentication succeeds or fails. On failure, an exception is raised. + Otherwise, the method simply returns.

Parameters:: username - + the username to authenticate as +
+ (type=string) +; key - + the private key to authenticate with +
+ (type=PKey) +; event - + an event to trigger when the authentication attempt is + complete (whether it was successful or not) +
+ (type=threading.Event) +

Returns:: + list of auth types permissible for the next stage of + authentication (normally empty). +
+ (type=list) +

Raises:: BadAuthenticationType - + if public-key authentication isn't allowed by the server for + this user (and no event was passed in). +; SSHException - + if the authentication failed (and no event was passed in). +

+ + +

close(self) +

+ Close this session, and any open channels that are tied to it. +

: +

+ + +

connect(self, + hostkey=None, + username='', + password=None, + pkey=None) +

Negotiate an SSH2 session, and optionally verify the server's host + key and authenticate using a password or private key. This is a + shortcut for start_client, get_remote_server_key, and Transport.auth_password or Transport.auth_publickey. Use those + methods if you want more control.

+ You can use this method immediately after creating a Transport to + negotiate encryption with a server. If it fails, an exception will be + thrown. On success, the method will return cleanly, and an encrypted + session exists. You may immediately call open_channel or open_session to get a Channel object, which is used for data + transfer. +

Parameters:: hostkey - + the host key expected from the server, or None if + you don't want to do host key verification. +
+ (type=PKey) +; username - + the username to authenticate as. +
+ (type=str) +; password - + a password to use for authentication, if you want to use + password authentication; otherwise None. +
+ (type=str) +; pkey - + a private key to use for authentication, if you want to use + private key authentication; otherwise None. +
+ (type=PKey) +

Raises:: SSHException - + if the SSH2 negotiation fails, the host key supplied by the + server is incorrect, or authentication fails. +

Note: If you fail to supply a password or private key, this method may +succeed, but a subsequent open_channel or open_session call may fail because you +haven't authenticated yet. +

+ +

Since: doduo +

+ +

+ + +

get_exception(self) +

+ Return any exception that happened during the last server request. + This can be used to fetch more specific error information after using + calls like start_client. The exception (if any) is + cleared after this call. +

Returns:: + an exception, or None if there is no stored + exception. +
+ (type=Exception) +

Since: 1.1 +

+ +

+ + +

get_hexdump(self) +

+ Return True if the transport is currently logging hex + dumps of protocol traffic. +

Returns:: + True if hex dumps are being logged +
+ (type=bool) +

Since: 1.4 +

+ +

+ + +

get_log_channel(self) +

+ Return the channel name used for this transport's logging. +

Returns:: + channel name. +
+ (type=str) +

Since: 1.2 +

+ +

+ + +

get_remote_server_key(self) +

+ Return the host key of the server (in client mode). +

Returns:: + public key of the remote server. +
+ (type=PKey) +

Raises:: SSHException - + if no session is currently active. +

Note: Previously this call returned a tuple of (key type, key string). You +can get the same effect by calling PKey.get_name for the key type, and +str(key) for the key string. +

+ +

+ + +

get_security_options(self) +

+ Return a SecurityOptions object which can be used + to tweak the encryption algorithms this transport will permit, and the + order of preference for them. +

Returns:: + an object that can be used to change the preferred algorithms + for encryption, digest (hash), public key, and key exchange. +
+ (type=SecurityOptions) +

Since: ivysaur +

+ +

+ + +

get_server_key(self) +

+ Return the active host key, in server mode. After negotiating with + the client, this method will return the negotiated host key. If only + one type of host key was set with add_server_key, that's the only key that + will ever be returned. But in cases where you have set more than one + type of host key (for example, an RSA key and a DSS key), the key type + will be negotiated by the client, and this method will return the key + of the type agreed on. If the host key has not been negotiated yet, + None is returned. In client mode, the behavior is + undefined. +

Returns:: + host key of the type negotiated by the client, or + None. +
+ (type=PKey) +

+ + +

get_username(self) +

+ Return the username this connection is authenticated for. If the + session is not authenticated (or authentication failed), this method + returns None. +

Returns:: + username that was authenticated, or None. +
+ (type=string) +

Since: fearow +

+ +

+ + +

global_request(self, + kind, + data=None, + wait=True) +

+ Make a global request to the remote host. These are normally + extensions to the SSH2 protocol. +

Parameters:: kind - + name of the request. +
+ (type=str) +; data - + an optional tuple containing additional data to attach to the + request. +
+ (type=tuple) +; wait - + True if this method should not return until a + response is received; False otherwise. +
+ (type=bool) +

Returns:: + a Message containing possible + additional data if the request was successful (or an empty Message if wait was + False); None if the request was + denied. +
+ (type=Message) +

Since: fearow +

+ +

+ + +

is_active(self) +

+ Return true if this session is active (open). +

Returns:: + True if the session is still active (open); False if the + session is closed. +
+ (type=bool) +

+ + +

is_authenticated(self) +

+ Return true if this session is active and authenticated. +

Returns:: + True if the session is still open and has been authenticated + successfully; False if authentication failed and/or the session + is closed. +
+ (type=bool) +

+ + +

open_channel(self, + kind, + dest_addr=None, + src_addr=None) +

+ Request a new channel to the server. Channels are socket-like objects used for + the actual transfer of data across the session. You may only request a + channel after negotiating encryption (using connect or start_client) and authenticating. +

Parameters:: kind - + the kind of channel requested (usually + "session", + "forwarded-tcpip" or + "direct-tcpip"). +
+ (type=str) +; dest_addr - + the destination address of this port forwarding, if + kind is "forwarded-tcpip" or + "direct-tcpip" (ignored for other channel + types). +
+ (type=(str, int)) +; src_addr - + the source address of this port forwarding, if + kind is "forwarded-tcpip" or + "direct-tcpip". +
+ (type=(str, int)) +

Returns:: + a new Channel on success, or + None if the request is rejected or the session ends + prematurely. +
+ (type=Channel) +

+ + +

open_session(self) +

+ Request a new channel to the server, of type + "session". This is just an alias for + open_channel('session'). +

Returns:: + a new Channel on success, or + None if the request is rejected or the session ends + prematurely. +
+ (type=Channel) +

+ + +

open_sftp_client(self) +

+ Create an SFTP client channel from an open transport. On success, an + SFTP session will be opened with the remote host, and a new SFTPClient + object will be returned. +

Returns:: + a new SFTPClient object, referring to an + sftp session (channel) across this transport +
+ (type=SFTPClient) +

+ + +

renegotiate_keys(self) +

+ Force this session to switch to new keys. Normally this is done + automatically after the session hits a certain number of packets or + bytes sent or received, but this method gives you the option of forcing + new keys whenever you want. Negotiating new keys causes a pause in + traffic both ways as the two sides swap keys and do computations. This + method returns when the session has switched to new keys, or the + session has died mid-negotiation. +

Returns:: + True if the renegotiation was successful, and the link is + using new keys; False if the session dropped during + renegotiation. +
+ (type=bool) +

+ + +

send_ignore(self, + bytes=None) +

+ Send a junk packet across the encrypted link. This is sometimes used + to add "noise" to a connection to confuse would-be attackers. + It can also be used as a keep-alive for long lived connections + traversing firewalls. +

Parameters:: bytes - + the number of random bytes to send in the payload of the + ignored packet -- defaults to a random number from 10 to 41. +
+ (type=int) +

Since: fearow +

+ +

+ + +

set_hexdump(self, + hexdump) +

+ Turn on/off logging a hex dump of protocol traffic at DEBUG level in + the logs. Normally you would want this off (which is the default), but + if you are debugging something, it may be useful. +

Parameters:: hexdump - + True to log protocol traffix (in hex) to the log; + False otherwise. +
+ (type=bool) +

+ + +

set_keepalive(self, + interval) +

+ Turn on/off keepalive packets (default is off). If this is set, + after interval seconds without sending any data over the + connection, a "keepalive" packet will be sent (and ignored by + the remote host). This can be useful to keep connections alive over a + NAT, for example. +

Parameters:: interval - + seconds to wait before sending a keepalive packet (or 0 to + disable keepalives). +
+ (type=int) +

Since: fearow +

+ +

+ + +

set_log_channel(self, + name) +

+ Set the channel for this transport's logging. The default is + "paramiko.transport" but it can be set to + anything you want. (See the logging module for more info.) + SSH Channels will log to a sub-channel of the one specified. +

Parameters:: name - + new channel name for logging. +
+ (type=str) +

Since: 1.1 +

+ +

+ + +

set_subsystem_handler(self, + name, + handler, + *larg, + **kwarg) +

Set the handler class for a subsystem in server mode. If a request + for this subsystem is made on an open ssh channel later, this handler + will be constructed and called -- see SubsystemHandler for more detailed + documentation.

+ Any extra parameters (including keyword arguments) are saved and + passed to the SubsystemHandler constructor later. +

Parameters:: name - + name of the subsystem. +
+ (type=str) +; handler - + subclass of SubsystemHandler that handles this + subsystem. +
+ (type=class) +

+ + +

start_client(self, + event=None) +

Negotiate a new SSH2 session as a client. This is the first step + after creating a new Transport. A separate thread is created + for protocol negotiation.

If an event is passed in, this method returns immediately. When + negotiation is done (successful or not), the given Event + will be triggered. On failure, is_active will return + False.

(Since 1.4) If event is None, this method + will not return until negotation is done. On success, the method + returns normally. Otherwise an SSHException is raised.

+ After a successful negotiation, you will usually want to + authenticate, calling auth_password or auth_publickey. +

Parameters:: event - + an event to trigger when negotiation is complete + (optional) +
+ (type=threading.Event) +

Raises:: SSHException - + if negotiation fails (and no event was passed + in) +

Notes: +

connect is a simpler method for connecting +as a client. +
After calling this method (or start_server or connect), you should no longer directly +read from or write to the original socket object. + +

+ +

+ + +

start_server(self, + event=None, + server=None) +

Negotiate a new SSH2 session as a server. This is the first step + after creating a new Transport and setting up your server host + key(s). A separate thread is created for protocol negotiation.

If an event is passed in, this method returns immediately. When + negotiation is done (successful or not), the given Event + will be triggered. On failure, is_active will return + False.

(Since 1.4) If event is None, this method + will not return until negotation is done. On success, the method + returns normally. Otherwise an SSHException is raised.

After a successful negotiation, the client will need to + authenticate. Override the methods get_allowed_auths, check_auth_none, check_auth_password, and check_auth_publickey in the given + server object to control the authentication process.

+ After a successful authentication, the client should request to open + a channel. Override check_channel_request in the given + server object to allow channels to be opened. +

Parameters:: event - + an event to trigger when negotiation is complete. +
+ (type=threading.Event) +; server - + an object used to perform authentication and create Channels. +
+ (type=server.ServerInterface) +

Raises:: SSHException - + if negotiation fails (and no event was passed + in) +

Note: After calling this method (or start_client or connect), you should no longer directly +read from or write to the original socket object. +

+ +

+ + +

use_compression(self, + compress=True) +

+ Turn on/off compression. This will only have an affect before + starting the transport (ie before calling connect, etc). By default, compression is + off since it negatively affects interactive sessions and is not fully + tested. +

Parameters:: compress - + True to ask the remote client/server to compress + traffic; False to refuse compression +
+ (type=bool) +

Since: 1.5.2 +

+ +

+
+ + + + + + +

Static Method Details

+ + +

load_server_moduli(filename=None) +

(optional) Load a file of prime moduli for use in doing + group-exchange key negotiation in server mode. It's a rather obscure + option and can be safely ignored.

+ In server mode, the remote client may request + "group-exchange" key negotiation, which asks the server to + send a random prime number that fits certain criteria. These primes are + pretty difficult to compute, so they can't be generated on demand. But + many systems contain a file of suitable primes (usually named something + like /etc/ssh/moduli). If you call + load_server_moduli and it returns True, then + this file of primes has been loaded and we will support + "group-exchange" in server mode. Otherwise server mode will + just claim that it doesn't support that method of key negotiation. +

Parameters:: filename - + optional path to the moduli file, if you happen to know that + it's not in a standard location. +
+ (type=str) +

Returns:: + True if a moduli file was successfully loaded; False + otherwise. +
+ (type=bool) +

Note: This has no effect when used in client mode. +

+ +

Since: doduo +

+ +

+
+ + + + + + + + + + + + + + + + + + +

Generated by Epydoc 2.1 on Sun Dec 4 11:16:48 2005

http://epydoc.sf.net

+ + -- cgit v1.2.3

Type Transport

__init__(self, + sock) + (Constructor) +

__repr__(self) + (Representation operator) +

accept(self, + timeout=None) +

add_server_key(self, + key) +

auth_interactive(self, + username, + handler, + submethods='') +

auth_none(self, + username) +

auth_password(self, + username, + password, + event=None, + fallback=True) +

auth_publickey(self, + username, + key, + event=None) +

close(self) +

connect(self, + hostkey=None, + username='', + password=None, + pkey=None) +

get_exception(self) +

get_hexdump(self) +

get_log_channel(self) +

get_remote_server_key(self) +

get_security_options(self) +

get_server_key(self) +

get_username(self) +

global_request(self, + kind, + data=None, + wait=True) +

is_active(self) +

is_authenticated(self) +

open_channel(self, + kind, + dest_addr=None, + src_addr=None) +

open_session(self) +

open_sftp_client(self) +

renegotiate_keys(self) +

send_ignore(self, + bytes=None) +

set_hexdump(self, + hexdump) +

set_keepalive(self, + interval) +

set_log_channel(self, + name) +

set_subsystem_handler(self, + name, + handler, + *larg, + **kwarg) +

start_client(self, + event=None) +

start_server(self, + event=None, + server=None) +

use_compression(self, + compress=True) +

load_server_moduli(filename=None) +

init(self, + sock) +
(Constructor) +

repr(self) +
(Representation operator) +