[X2Go-Commits] [python-x2go] 02/04: API doc: another white-space cleanup + fixes for all open Sphinx Build warnings.

git-admin at x2go.org git-admin at x2go.org
Tue Mar 6 13:54:16 CET 2018


This is an automated email from the git hooks/post-receive script.

x2go pushed a commit to branch master
in repository python-x2go.

commit 07b865a8bdfe9906ebd2091b9c5a3e779fbedd19
Author: Mike Gabriel <mike.gabriel at das-netzwerkteam.de>
Date:   Tue Mar 6 13:52:33 2018 +0100

    API doc: another white-space cleanup + fixes for all open Sphinx Build warnings.
---
 x2go/__init__.py                     |  24 ++++----
 x2go/_paramiko.py                    |   8 +--
 x2go/backends/control/plain.py       | 110 +++++++++++++++++------------------
 x2go/backends/printing/file.py       |   7 +--
 x2go/backends/printing/winreg.py     |   4 +-
 x2go/backends/profiles/base.py       |   1 -
 x2go/backends/profiles/httpbroker.py |   2 +-
 x2go/backends/proxy/base.py          |  14 ++---
 x2go/backends/proxy/nx3.py           |   2 +-
 x2go/backends/terminal/plain.py      |  38 ++++++------
 x2go/cache.py                        |   4 +-
 x2go/checkhosts.py                   |   8 +--
 x2go/cleanup.py                      |  10 ++--
 x2go/client.py                       |  65 +++++++++------------
 x2go/forward.py                      |   4 +-
 x2go/guardian.py                     |   2 +-
 x2go/inifiles.py                     |   6 +-
 x2go/mimebox.py                      |   3 +-
 x2go/printactions.py                 |   2 +-
 x2go/printqueue.py                   |   7 +--
 x2go/registry.py                     |   4 +-
 x2go/rforward.py                     |  28 ++++-----
 x2go/session.py                      |  23 ++++----
 x2go/sftpserver.py                   |  18 +++---
 x2go/telekinesis.py                  |   2 +-
 x2go/utils.py                        |   2 +-
 x2go/xserver.py                      |   6 +-
 27 files changed, 191 insertions(+), 213 deletions(-)

diff --git a/x2go/__init__.py b/x2go/__init__.py
index 82f6745..8a233a2 100644
--- a/x2go/__init__.py
+++ b/x2go/__init__.py
@@ -50,18 +50,18 @@ API Concept
 
         - L{X2GoClient} --- a whole X2Go client API
         - L{X2GoSession} --- management of an individual X2Go
-        session--either started standalone or from within an L{X2GoClient} instance
+          session--either started standalone or from within an L{X2GoClient} instance
         - L{X2GoClientSettings} --- provide access to X2Go (global and
-        user) configuration node »settings«
+          user) configuration node »settings«
         - L{X2GoClientPrinting} --- provide access to X2Go (global and
-        user) configuration node »printing«
+          user) configuration node »printing«
         - L{X2GoSessionProfiles} --- provide access to X2Go (global and
-        user) configuration node »sessions«
+          user) configuration node »sessions«
 
     Plus two extra classes on MS Windows platforms:
 
        - L{X2GoClientXConfig} and L{X2GoXServer} --- these classes will be initialized
-       during L{X2GoClient} instantiation on MS Windows platforms and start an installed XServer
+         during L{X2GoClient} instantiation on MS Windows platforms and start an installed XServer
 
     Any other of the Python X2Go classes may be subject to internal changes
     and the way of addressing these classes in code may vary between different
@@ -153,16 +153,16 @@ Configuration and Session Management
     will be reflected as a change in your X2Go client behaviour:
 
       - L{X2GoSessionProfiles}: changes to a session profile in
-      the »sessions« node will be available for the next registered
-      L{X2GoSession} instance
+        the »sessions« node will be available for the next registered
+        L{X2GoSession} instance
       - L{X2GoClientPrinting}: on each incoming X2Go print job the
-      »printing« configuration node will be re-read, thus you can
-      change your X2Go client's print setup during a running session
+        »printing« configuration node will be re-read, thus you can
+        change your X2Go client's print setup during a running session
       - L{X2GoClientSettings}: also the configuration node »settings«
-      is re-read whenever needed in the course of X2Go session management
+        is re-read whenever needed in the course of X2Go session management
       - L{X2GoClientXConfig} and L{X2GoXServer} (Windows only): these classes will only be initialized
-      once (starting the XServer on Windows platforms) on construction
-      of an L{X2GoClient} instance
+        once (starting the XServer on Windows platforms) on construction
+        of an L{X2GoClient} instance
 
 Dependencies
 ============
diff --git a/x2go/_paramiko.py b/x2go/_paramiko.py
index aa66761..c600198 100644
--- a/x2go/_paramiko.py
+++ b/x2go/_paramiko.py
@@ -48,10 +48,10 @@ PARAMIKO_FEATURE = {
 def _SSHClient_save_host_keys(self, filename):
     """\
     Available since paramiko 1.11.0...
-    
+
     This method has been taken from SSHClient class in Paramiko and
     has been improved and adapted to latest SSH implementations.
-    
+
     Save the host keys back to a file.
     Only the host keys loaded with
     L{load_host_keys} (plus any added directly) will be saved -- not any
@@ -81,12 +81,12 @@ def _SSHClient_save_host_keys(self, filename):
 def _HostKeys_load(self, filename):
     """\
     Available since paramiko 1.11.0...
-    
+
     Read a file of known SSH host keys, in the format used by openssh.
     This type of file unfortunately doesn't exist on Windows, but on
     posix, it will usually be stored in
     ``os.path.expanduser("~/.ssh/known_hosts")``.
-    
+
     If this method is called multiple times, the host keys are merged,
     not cleared. So multiple calls to ``load`` will just call L{add},
     replacing any existing entries and adding new ones.
diff --git a/x2go/backends/control/plain.py b/x2go/backends/control/plain.py
index d4a9f71..cb58e9b 100644
--- a/x2go/backends/control/plain.py
+++ b/x2go/backends/control/plain.py
@@ -81,10 +81,10 @@ def _rerewrite_blanks(cmd):
 def _rewrite_password(cmd, user=None, password=None):
     """\
     In command strings Python X2Go replaces some macros with actual values:
-    
+
       - X2GO_USER -> the user name under which the user is authenticated via SSH
       - X2GO_PASSWORD -> the password being used for SSH authentication
-    
+
     Both macros can be used to on-the-fly authenticate via RDP.
 
     :param cmd: command that is to be sent to an X2Go server script
@@ -111,7 +111,7 @@ def _rewrite_password(cmd, user=None, password=None):
 class X2GoControlSession(paramiko.SSHClient):
     """\
     In the Python X2Go concept, X2Go sessions fall into two parts: a control session and one to many terminal sessions.
-    
+
     The control session handles the SSH based communication between server and client. It is mainly derived from
     ``paramiko.SSHClient`` and adds on X2Go related functionality.
 
@@ -141,44 +141,44 @@ class X2GoControlSession(paramiko.SSHClient):
 
         A control session normally gets set up by an L{X2GoSession} instance. Do not use it directly!!!
 
-        @param profile_name: the profile name of the session profile this control session works for
-        @type profile_name: ``str``
-        @param add_to_known_hosts: Auto-accept server host validity?
-        @type add_to_known_hosts: ``bool``
-        @param known_hosts: the underlying Paramiko/SSH systems ``known_hosts`` file
-        @type known_hosts: ``str``
-        @param forward_sshagent: forward SSH agent authentication requests to the X2Go client-side
-        @type forward_sshagent: ``bool``
-        @param unique_hostkey_aliases: instead of storing [<hostname>]:<port> in known_hosts file, use the
+        :param profile_name: the profile name of the session profile this control session works for
+        :type profile_name: ``str``
+        :param add_to_known_hosts: Auto-accept server host validity?
+        :type add_to_known_hosts: ``bool``
+        :param known_hosts: the underlying Paramiko/SSH systems ``known_hosts`` file
+        :type known_hosts: ``str``
+        :param forward_sshagent: forward SSH agent authentication requests to the X2Go client-side
+        :type forward_sshagent: ``bool``
+        :param unique_hostkey_aliases: instead of storing [<hostname>]:<port> in known_hosts file, use the
             (unique-by-design) profile ID
-        @type unique_hostkey_aliases: ``bool``
-        @param terminal_backend: X2Go terminal session backend to use
-        @type terminal_backend: ``str``
-        @param info_backend: backend for handling storage of server session information
-        @type info_backend: ``X2GoServerSessionInfo*`` instance
-        @param list_backend: backend for handling storage of session list information
-        @type list_backend: ``X2GoServerSessionList*`` instance
-        @param proxy_backend: backend for handling the X-proxy connections
-        @type proxy_backend: ``X2GoProxy*`` instance
-        @param client_rootdir: client base dir (default: ~/.x2goclient)
-        @type client_rootdir: ``str``
-        @param sessions_rootdir: sessions base dir (default: ~/.x2go)
-        @type sessions_rootdir: ``str``
-        @param ssh_rootdir: ssh base dir (default: ~/.ssh)
-        @type ssh_rootdir: ``str``
-        @param published_applications_no_submenus: published applications menus with less items than ``published_applications_no_submenus``
+        :type unique_hostkey_aliases: ``bool``
+        :param terminal_backend: X2Go terminal session backend to use
+        :type terminal_backend: ``str``
+        :param info_backend: backend for handling storage of server session information
+        :type info_backend: ``X2GoServerSessionInfo*`` instance
+        :param list_backend: backend for handling storage of session list information
+        :type list_backend: ``X2GoServerSessionList*`` instance
+        :param proxy_backend: backend for handling the X-proxy connections
+        :type proxy_backend: ``X2GoProxy*`` instance
+        :param client_rootdir: client base dir (default: ~/.x2goclient)
+        :type client_rootdir: ``str``
+        :param sessions_rootdir: sessions base dir (default: ~/.x2go)
+        :type sessions_rootdir: ``str``
+        :param ssh_rootdir: ssh base dir (default: ~/.ssh)
+        :type ssh_rootdir: ``str``
+        :param published_applications_no_submenus: published applications menus with less items than ``published_applications_no_submenus``
             are rendered without submenus
-        @type published_applications_no_submenus: ``int``
-        @param logger: you can pass an L{X2GoLogger} object to the
+        :type published_applications_no_submenus: ``int``
+        :param logger: you can pass an L{X2GoLogger} object to the
             L{X2GoControlSession} constructor
-        @type logger: L{X2GoLogger} instance
-        @param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
+        :type logger: L{X2GoLogger} instance
+        :param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
             constructed with the given loglevel
-        @type loglevel: ``int``
-        @param low_latency: set this boolean switch for weak connections, it will double all timeout values.
-        @type low_latency: ``bool``
-        @param kwargs: catch any non-defined parameters in ``kwargs``
-        @type kwargs: ``dict``
+        :type loglevel: ``int``
+        :param low_latency: set this boolean switch for weak connections, it will double all timeout values.
+        :type low_latency: ``bool``
+        :param kwargs: catch any non-defined parameters in ``kwargs``
+        :type kwargs: ``dict``
 
         """
         self.associated_terminals = {}
@@ -264,7 +264,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def load_session_host_keys(self):
         """\
         Load known SSH host keys from the ``known_hosts`` file.
-        
+
         If the file does not exist, create it first.
 
 
@@ -290,7 +290,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def _x2go_sftp_put(self, local_path, remote_path, timeout=20):
         """\
         Put a local file on the remote server via sFTP.
-        
+
         During sFTP operations, remote command execution gets blocked.
 
         :param local_path: full local path name of the file to be put on the server
@@ -341,7 +341,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def _x2go_sftp_write(self, remote_path, content, timeout=20):
         """\
         Create a text file on the remote server via sFTP.
-        
+
         During sFTP operations, remote command execution gets blocked.
 
         :param remote_path: full remote path name of the server-side target location, path names have to be Unix-compliant
@@ -397,7 +397,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def _x2go_sftp_remove(self, remote_path, timeout=20):
         """\
         Remote a remote file from the server via sFTP.
-        
+
         During sFTP operations, remote command execution gets blocked.
 
         :param remote_path: full remote path name of the server-side file to be removed, path names have to be Unix-compliant
@@ -448,7 +448,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def _x2go_exec_command(self, cmd_line, loglevel=log.loglevel_INFO, timeout=20, **kwargs):
         """\
         Execute an X2Go server-side command via SSH.
-        
+
         During SSH command executions, sFTP operations get blocked.
 
         :param cmd_line: the command to be executed on the remote server
@@ -460,7 +460,6 @@ class X2GoControlSession(paramiko.SSHClient):
         :type timeout: ``int``
         :param kwargs: parameters that get passed through to the ``paramiko.SSHClient.exec_command()`` method.
         :type kwargs: ``dict``
-        :param **kwargs: 
         :returns: ``True`` if the command could be successfully executed on the remote X2Go server
         :rtype: ``bool``
         :raises X2GoControlSessionException: if the command execution failed (due to a lost connection)
@@ -664,7 +663,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def is_x2gouser(self, username):
         """\
         Is the remote user allowed to launch X2Go sessions?
-        
+
         FIXME: this method is currently non-functional.
 
         :param username: remote user name
@@ -795,20 +794,20 @@ class X2GoControlSession(paramiko.SSHClient):
         SSH client connect method are recited here. The parameters ``add_to_known_hosts``,
         ``force_password_auth``, ``session_instance`` and all SSH proxy related parameters
         have been added as X2Go specific parameters
-        
+
         The server's host key is checked against the system host keys
         (see ``load_system_host_keys``) and any local host keys (``load_host_keys``).
         If the server's hostname is not found in either set of host keys, the missing host
         key policy is used (see ``set_missing_host_key_policy``).  The default policy is
         to reject the key and raise an ``SSHException``.
-        
+
         Authentication is attempted in the following order of priority:
-        
+
             - The ``pkey`` or ``key_filename`` passed in (if any)
             - Any key we can find through an SSH agent
             - Any "id_rsa" or "id_dsa" key discoverable in ``~/.ssh/``
             - Plain username/password auth, if a password was given
-        
+
         If a private key requires a password to unlock it, and a password is
         passed in, that password will be used to attempt to unlock the key.
 
@@ -1303,11 +1302,11 @@ class X2GoControlSession(paramiko.SSHClient):
     def get_published_applications(self, lang=None, refresh=False, raw=False, very_raw=False, max_no_submenus=defaults.PUBAPP_MAX_NO_SUBMENUS):
         """\
         Retrieve the menu tree of published applications from the remote X2Go server.
-        
+
         The ``raw`` option lets this method return a ``list`` of ``dict`` elements. Each ``dict`` elements has a
         ``desktop`` key containing a shortened version of the text output of a .desktop file and an ``icon`` key
         which contains the desktop base64-encoded icon data.
-        
+
         The {very_raw} lets this method return the output of the ``x2gogetapps`` script as is.
 
         :param lang: locale/language identifier (Default value = None)
@@ -1501,7 +1500,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def start(self, **kwargs):
         """\
         Start a new X2Go session.
-        
+
         The L{X2GoControlSession.start()} method accepts any parameter
         that can be passed to any of the ``X2GoTerminalSession`` backend class
         constructors.
@@ -1510,7 +1509,6 @@ class X2GoControlSession(paramiko.SSHClient):
             L{resume()} method, only the ``session_name`` parameter will get removed
             before pass-through
         :type kwargs: ``dict``
-        :param **kwargs: 
         :returns: return: return value of the cascaded L{resume()} method, denoting the success or failure
             of the session startup
         :rtype: ``bool``
@@ -1523,7 +1521,7 @@ class X2GoControlSession(paramiko.SSHClient):
     def resume(self, session_name=None, session_instance=None, session_list=None, **kwargs):
         """\
         Resume a running/suspended X2Go session.
-        
+
         The L{X2GoControlSession.resume()} method accepts any parameter
         that can be passed to any of the ``X2GoTerminalSession*`` backend class constructors.
 
@@ -1534,7 +1532,6 @@ class X2GoControlSession(paramiko.SSHClient):
         :param session_list: Default value = None)
         :param kwargs: catch any non-defined param in kwargs
         :type kwargs: ``dict``
-        :param **kwargs: 
         :returns: True if the session could be successfully resumed
         :rtype: ``bool``
         :raises X2GoUserException: if the remote user is not allowed to launch/resume X2Go sessions.
@@ -1605,7 +1602,8 @@ class X2GoControlSession(paramiko.SSHClient):
         :type display: ``str``
         :param share_mode: desktop sharing mode, 0 stands for VIEW-ONLY, 1 for  FULL-ACCESS mode (Default value = 0)
         :type share_mode: ``int``
-        :param **kwargs: 
+        :param kwargs: catch any non-defined param in kwargs
+        :type kwargs: ``dict``
         :returns: True if the session could be successfully shared
         :rtype: ``bool``
         :raises X2GoDesktopSharingException: if ``username`` and ``dislpay`` do not relate to a
@@ -1863,7 +1861,7 @@ class X2GoControlSession(paramiko.SSHClient):
         """\
         Returns ``True`` if the X2Go session with name ``<session_name>`` has been seen
         by this control session and--in the meantime--has been terminated.
-        
+
         If ``<session_name>`` has not been seen, yet, the method will return ``None``.
 
         :param session_name: X2Go name of the session to be queried
diff --git a/x2go/backends/printing/file.py b/x2go/backends/printing/file.py
index aeaedf9..b0c1bf4 100644
--- a/x2go/backends/printing/file.py
+++ b/x2go/backends/printing/file.py
@@ -68,11 +68,11 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
     L{x2go.backends.printing.file.X2GoClientPrinting} provides access to the X2Go ini-like file
     »printing« as stored in ``~/.x2goclient/printing`` resp. globally
     ``/etc/x2goclient/printing``.
-    
+
     An instance of L{x2go.backends.printing.file.X2GoClientPrinting} is created on each incoming
     print job. This facilitates that on every print job the print action
     for this job is derived from the »printing« configuration file.
-    
+
     Thus, changes on the file are active for the next incoming print job.
 
 
@@ -136,7 +136,7 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
     def print_action(self):
         """\
         Return the print action described by the »printing« configuration file.
-        
+
         This method has property status and wraps around the L{get_print_action}
 
 
@@ -223,7 +223,6 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
         :type print_action: ``str``
         :param print_properties: the printing properties to set for the given print action
         :type print_properties: ``dict``
-        :param **print_properties: 
 
         """
         if print_action == 'DIALOG':
diff --git a/x2go/backends/printing/winreg.py b/x2go/backends/printing/winreg.py
index 303d545..34024c6 100644
--- a/x2go/backends/printing/winreg.py
+++ b/x2go/backends/printing/winreg.py
@@ -46,11 +46,11 @@ class X2GoClientPrinting(object):
     """\
     L{x2go.backends.printing.winreg.X2GoClientPrinting} provides access to the Windows registry
     based configuration of the X2Go client printing setup.
-    
+
     An instance of L{x2go.backends.printing.winreg.X2GoClientPrinting} is created on each incoming
     print job. This facilitates that on every print job the print action for this job is derived from the
     »printing« configuration file.
-    
+
     Thus, changes on the file are active for the next incoming print job.
 
 
diff --git a/x2go/backends/profiles/base.py b/x2go/backends/profiles/base.py
index d200f00..396df70 100644
--- a/x2go/backends/profiles/base.py
+++ b/x2go/backends/profiles/base.py
@@ -516,7 +516,6 @@ class X2GoSessionProfiles(object):
         :type kwargs: ``dict``
         :param force_add: enforce adding of the given profile (Default value = False)
         :type force_add: ``bool``
-        :param **kwargs: 
         :returns: the (auto-generated) profile ID of the new session profile
         :rtype: ``str``
 
diff --git a/x2go/backends/profiles/httpbroker.py b/x2go/backends/profiles/httpbroker.py
index b86f293..3b0fb76 100644
--- a/x2go/backends/profiles/httpbroker.py
+++ b/x2go/backends/profiles/httpbroker.py
@@ -232,7 +232,7 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
     def broker_disconnect(self):
         """\
         Disconnect from an (already) authenticated broker session.
-        
+
         All authentication parameters will be dropped (forgotten) and
         this instance has to re-authenticate against / re-connect to the
         session broker before any new interaction with the broker is possible.
diff --git a/x2go/backends/proxy/base.py b/x2go/backends/proxy/base.py
index 03d56c0..e11f272 100644
--- a/x2go/backends/proxy/base.py
+++ b/x2go/backends/proxy/base.py
@@ -54,11 +54,10 @@ from x2go.defaults import X2GO_SESSIONS_ROOTDIR as _X2GO_SESSIONS_ROOTDIR
 class X2GoProxy(threading.Thread):
     """\
     X2GoProxy is an abstract class for X2Go proxy connections.
-    
+
     This class needs to be inherited from a concrete proxy class. Only
     currently available proxy class is: L{x2go.backends.proxy.nx3.X2GoProxy}.
 
-
     """
     PROXY_CMD = ''
     """Proxy command. Needs to be set by a potential child class, might be OS specific."""
@@ -157,7 +156,6 @@ class X2GoProxy(threading.Thread):
         """\
         End the thread runner and tidy up.
 
-
         """
         self._keepalive = False
         # wait for thread loop to finish...
@@ -170,7 +168,6 @@ class X2GoProxy(threading.Thread):
         Paramiko/SSH based forwarding tunnel (openssh -L option). This tunnel
         gets started here and is forked into background (Greenlet/gevent).
 
-
         """
         self._keepalive = True
         self.proxy = None
@@ -251,16 +248,15 @@ class X2GoProxy(threading.Thread):
         """\
         Override this method to incorporate elements from ``proxy_options``
         into actual proxy subprocess execution.
-        
+
         This method (if overridden) should (by design) never fail nor raise an exception.
         Make sure to catch all possible errors appropriately.
-        
+
         If you want to log ignored proxy_options then
-        
+
             1. remove processed proxy_options from self.proxy_options
             2. once you have finished processing the proxy_options call
-            the parent class method L{x2go.backends.proxy.base.X2GoProxy.process_proxy_options()}
-
+               the parent class method L{x2go.backends.proxy.base.X2GoProxy.process_proxy_options()}
 
         """
         # do the logging of remaining options
diff --git a/x2go/backends/proxy/nx3.py b/x2go/backends/proxy/nx3.py
index 42b699d..0daedc5 100644
--- a/x2go/backends/proxy/nx3.py
+++ b/x2go/backends/proxy/nx3.py
@@ -38,7 +38,7 @@ from x2go.defaults import X2GOCLIENT_OS as _X2GOCLIENT_OS
 class X2GoProxy(base.X2GoProxy):
     """\
     This L{X2GoProxy} class is a NX version 3 based X2Go proxy connection class.
-    
+
     It basically fills L{x2go.backends.proxy.base.X2GoProxy} variables with sensible content. Its
     methods mostly wrap around the corresponding methods of the parent class.
 
diff --git a/x2go/backends/terminal/plain.py b/x2go/backends/terminal/plain.py
index 822cdb6..0b6802d 100644
--- a/x2go/backends/terminal/plain.py
+++ b/x2go/backends/terminal/plain.py
@@ -131,12 +131,11 @@ class X2GoSessionParams(object):
         """\
         Rewrite the X2Go session type, so that the X2Go server
         can understand it (``desktop`` -> ``D``, etc.).
-        
+
         Also if the object's ``command`` property is a known window
         manager, the session type will be set to 'D'
         (i.e. desktop).
 
-
         :returns: D' if session should probably a desktop session,
             'R' for rootless sessions, 'P' for sessions providing published
             applications, and 'S' for desktop sharing sessions
@@ -181,7 +180,6 @@ class X2GoSessionParams(object):
             property names as keys und their values to be update in
             L{X2GoSessionParams} object.
         :type properties_to_be_updated: ``dict``
-        :param **properties_to_be_updated: 
 
         """
         for key in list(properties_to_be_updated.keys()):
@@ -192,19 +190,19 @@ class X2GoSessionParams(object):
 class X2GoTerminalSession(object):
     """\
     Class for managing X2Go terminal sessions on a remote X2Go server via Paramiko/SSH.
-    
+
     With the L{x2go.backends.terminal.plain.X2GoTerminalSession} class you can start new X2Go sessions, resume suspended
     sessions or suspend resp. terminate currently running sessions on a
     connected X2Go server.
-    
+
     An L{x2go.backends.terminal.plain.X2GoTerminalSession} object uses two main data structure classes:
-    
+
         - L{X2GoSessionParams}: stores all parameters that have been passed to the
-        constructor method.
-    
+          constructor method.
+
         - ``X2GoServerSessionInfo*`` backend class: when starting or resuming a session, an object of this class
-        will be used to store all information retrieved from the X2Go server.
-    
+          will be used to store all information retrieved from the X2Go server.
+
     The terminal session instance works closely together (i.e. depends on) a connected control
     session instance (e.g. L{x2go.backends.control.plain.X2GoControlSession}). You never should use either of them as a standalone
     instance. Both, control session and terminal session(s) get managed/controlled via L{X2GoSession} instances.
@@ -545,9 +543,9 @@ class X2GoTerminalSession(object):
     def start_sound(self):
         """\
         Initialize Paramiko/SSH reverse forwarding tunnel for X2Go sound.
-        
+
         Currently supported audio protocols:
-        
+
             - PulseAudio
             - Esound (not tested very much)
 
@@ -708,14 +706,13 @@ class X2GoTerminalSession(object):
     def set_print_action(self, print_action, **kwargs):
         """\
         Set a print action for the next incoming print jobs.
-        
+
         This method is a wrapper for L{X2GoPrintQueue}``.set_print_action()``.
 
         :param print_action: print action name or object (i.e. an instance of ``X2GoPrintAction*`` classes)
         :type print_action: ``str`` or ``X2GoPrintAction*``
         :param kwargs: print action specific parameters
         :type kwargs: ``dict``
-        :param **kwargs: 
 
         """
         self.print_queue.set_print_action(print_action, logger=self.logger, **kwargs)
@@ -773,14 +770,13 @@ class X2GoTerminalSession(object):
     def set_mimebox_action(self, mimebox_action, **kwargs):
         """\
         Set a MIME box action for the next incoming MIME jobs.
-        
+
         This method is a wrapper for L{X2GoMIMEboxQueue}``set_mimebox_action()``.
 
         :param mimebox_action: MIME box action name or object (i.e. an instance of ``X2GoMIMEboxAction*`` classes)
         :type mimebox_action: ``str`` or ``X2GoMIMEboxAction*``
         :param kwargs: MIME box action specific parameters
         :type kwargs: ``dict``
-        :param **kwargs: 
 
         """
         self.mimebox_queue.set_mimebox_action(mimebox_action, logger=self.logger, **kwargs)
@@ -1052,7 +1048,7 @@ class X2GoTerminalSession(object):
     def auto_session_window_title(self, dont_set=False):
         """\
         Automatically generate an appropriate human-readable session window title.
-        
+
         The session window title will be provider in the ``session_title`` property of
         this method.
 
@@ -1098,7 +1094,7 @@ class X2GoTerminalSession(object):
         """\
         Try for <timeout> seconds to find the X2Go session window of this
         terminal session.
-        
+
         A background thread will get spawned for this operation.
 
         :param timeout: try for <timeout> seconds to find the session window (Default value = 60)
@@ -1167,7 +1163,7 @@ class X2GoTerminalSession(object):
     def set_session_window_title(self, title, timeout=60):
         """\
         Modify the session window title.
-        
+
         A background thread will get spawned for this operation.
 
         :param title: new title for the terminal session's session window
@@ -1209,7 +1205,7 @@ class X2GoTerminalSession(object):
         """\
         Try for <timeout> seconds to raise the X2Go session window of this
         terminal session to the top and bring it to focus.
-        
+
         A background thread will get spawned for this operation.
 
         :param timeout: try for <timeout> seconds to raise the session window (Default value = 60)
@@ -1282,7 +1278,7 @@ class X2GoTerminalSession(object):
     def run_command(self, cmd=None, env={}):
         """\
         Run a command in this session.
-        
+
         After L{x2go.backends.terminal.plain.X2GoTerminalSession.start()} has been called
         one or more commands can be executed with L{x2go.backends.terminal.plain.X2GoTerminalSession.run_command()}
         within the current X2Go session.
diff --git a/x2go/cache.py b/x2go/cache.py
index 7422103..0e81d39 100644
--- a/x2go/cache.py
+++ b/x2go/cache.py
@@ -41,12 +41,12 @@ class X2GoListSessionsCache(object):
     For non-blocking operations in client applications using Python X2Go, it is
     recommended to enable the L{X2GoListSessionsCache}. This can be done by calling
     the constructor of the L{X2GoClient} class.
-    
+
     The session list and desktop cache gets updated in regular intervals by a threaded
     L{X2GoSessionGuardian} instance. For the session list and desktop list update, the
     X2Go server commands ``x2golistsessions`` and ``x2godesktopsessions`` are called and
     the command's stdout is cached in the session list cache.
-    
+
     Whenever your client application needs access to either the server's session list
     or the server's desktop list the session cache is queried instead. This assures that
     the server's session/desktop list is available without delay, even on slow internet
diff --git a/x2go/checkhosts.py b/x2go/checkhosts.py
index 7be1a1a..d017511 100644
--- a/x2go/checkhosts.py
+++ b/x2go/checkhosts.py
@@ -189,12 +189,12 @@ class X2GoInteractiveAddPolicy(X2GoMissingHostKeyPolicy):
     Policy for making host key information available to Python X2Go after a
     Paramiko/SSH connect has been attempted. This class needs information
     about the associated L{X2GoSession} instance.
-    
+
     Once called, the L{missing_host_key} method of this class will try to call
     L{X2GoSession.HOOK_check_host_dialog()}. This hook method---if not re-defined
     in your application---will then try to call the L{X2GoClient.HOOK_check_host_dialog()},
     which then will return ``True`` by default if not customized in your application.
-    
+
     To accept host key checks, make sure to either customize the
     L{X2GoClient.HOOK_check_host_dialog()} method or the L{X2GoSession.HOOK_check_host_dialog()}
     method and hook some interactive user dialog to either of them.
@@ -204,12 +204,12 @@ class X2GoInteractiveAddPolicy(X2GoMissingHostKeyPolicy):
     def missing_host_key(self, client, hostname, key):
         """\
         Handle a missing host key situation. This method calls
-        
+
         Once called, the L{missing_host_key} method will try to call
         L{X2GoSession.HOOK_check_host_dialog()}. This hook method---if not re-defined
         in your application---will then try to call the L{X2GoClient.HOOK_check_host_dialog()},
         which then will return ``True`` by default if not customized in your application.
-        
+
         To accept host key checks, make sure to either customize the
         L{X2GoClient.HOOK_check_host_dialog()} method or the L{X2GoSession.HOOK_check_host_dialog()}
         method and hook some interactive user dialog to either of them.
diff --git a/x2go/cleanup.py b/x2go/cleanup.py
index 0c511ce..6fb51d2 100644
--- a/x2go/cleanup.py
+++ b/x2go/cleanup.py
@@ -42,16 +42,16 @@ def x2go_cleanup(e=None, threads=None):
     For every Python X2Go application you write, please make sure to
     capture the ``KeyboardInterrupt`` and the ``SystemExit`` exceptions and
     call this function if either of the exceptions occurs.
-    
+
     Example::
-    
+
         import x2go
-    
+
         try:
             my_x2goclient = x2go.X2GoClient(...)
-    
+
             [... your code ...]
-    
+
             sys.exit(0)
         except (KeyboardInterrupt, SystemExit):
             x2go.x2go_cleanup()
diff --git a/x2go/client.py b/x2go/client.py
index b84c8f5..43d0c0b 100644
--- a/x2go/client.py
+++ b/x2go/client.py
@@ -160,7 +160,7 @@ class X2GoClient(object):
     """\
     The X2GoClient implements _THE_ public Python X2Go API. With it you can
     construct your own X2Go client application in Python.
-    
+
     Most methods in this class require that you have registered a session
     with a remote X2Go server (passing of session options, initialization of the
     session object etc.) and connected to it (authentication). For these two steps
@@ -876,23 +876,23 @@ class X2GoClient(object):
         Register a new L{X2GoSession}. Within one L{X2GoClient}
         instance you can manage several L{X2GoSession} instances on serveral
         remote X2Go servers under different user names.
-        
+
         These sessions can be instantiated by passing direct L{X2GoSession}
         parameters to this method or by specifying the name of an existing session profile
         (as found in the L{X2GoClient}'s ``sessions`` configuration node.
-        
+
         A session profile is a pre-defined set of session options stored in a sessions
         profile node (e.g. a configuration file). With the FILE backend such session
         profiles are stored as a file (by default: ``~/.x2goclient/sessions`` or globally (for all users on the
         client) in ``/etc/x2goclient/sessions``).
-        
+
         Python X2Go also supports starting multiple X2Go sessions for the same
         session profile simultaneously.
-        
+
         This method (L{X2GoClient.register_session()}) accepts a similar set of parameters
         as the L{X2GoSession} constructor itself. For a complete set of session options refer
         there.
-        
+
         Alternatively, you can also pass a profile name or a profile id
         to this method. If you do this, Python X2Go tries to find the specified session
         in the ``sessions`` configuration node and then derives the necessary session parameters
@@ -939,7 +939,6 @@ class X2GoClient(object):
         :type return_object: ``bool``
         :param kwargs: any option that is also valid for the L{X2GoSession} constructor
         :type kwargs: ``dict``
-        :param **kwargs: 
         :returns: a unique identifier (UUID) for the newly registered X2Go session (or an
             X2GoSession object if ``return_object`` is set to True
         :rtype: ``str``
@@ -1410,10 +1409,10 @@ class X2GoClient(object):
         """\
         If X2Go client-side printing is enable within an X2Go session you can use
         this method to alter the way how incoming print spool jobs are handled/processed.
-        
+
         Currently, there are five different print actions available, each defined as an individual
         print action class:
-        
+
             - B{PDFVIEW} (L{X2GoPrintActionPDFVIEW}): view an incoming spool job (a PDF file)
               locally in a PDF viewer
             - B{PDFSAVE} (L{X2GoPrintActionPDFSAVE}): save an incoming spool job (a PDF file)
@@ -1424,7 +1423,7 @@ class X2GoClient(object):
               print job (PDF) file
             - B{DIALOG} (L{X2GoPrintActionDIALOG}): on each incoming spool job this print action
               will call L{X2GoClient.HOOK_open_print_dialog()}
-        
+
         Each of the print action classes accepts different print action arguments. For detail
         information on these print action arguments please refer to the constructor methods of
         each class individually.
@@ -1437,7 +1436,6 @@ class X2GoClient(object):
             action arguments), for possible print action arguments and their values see each individual
             print action class
         :type kwargs: ``dict``
-        :param **kwargs: 
 
         """
         self.session_registry(session_uuid).set_print_action(print_action=print_action, **kwargs)
@@ -1473,7 +1471,7 @@ class X2GoClient(object):
     def session_auto_start_or_resume(self, session_uuid, newest=True, oldest=False, all_suspended=False, start=True):
         """\
         Automatically start or resume one or several sessions.
-        
+
         This method is called from within the session itself on session registration, so this method
         can be used to handle auto-start/-resume events.
 
@@ -1497,7 +1495,7 @@ class X2GoClient(object):
         Start a new X2Go session on the remote X2Go server. This method
         will open---if everything has been successful till here---the X2Go
         session window.
-        
+
         Before calling this method you have to register your desired session
         with L{register_session} (initialization of session parameters) and
         connect to it with L{connect_session} (authentication).
@@ -1506,7 +1504,6 @@ class X2GoClient(object):
         :type session_uuid: ``str``
         :param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.start()} method
         :type sessionopts: ``dict``
-        :param **sessionopts: 
         :returns: returns True if this method has been successful
         :rtype: ``bool``
 
@@ -1548,7 +1545,6 @@ class X2GoClient(object):
         :type sessionopts: ``dict``
         :param check_desktop_list: check if the given desktop is available on the X2Go server; handle with care as
             the server-side ``x2golistdesktops`` command might block client I/O. (Default value = False)
-        :param **sessionopts: 
         :returns: True if the session could be successfully shared.
         :rtype: ``bool``
         :raises X2GoDesktopSharingException: if a given desktop ID does not specify an available desktop session
@@ -1583,7 +1579,6 @@ class X2GoClient(object):
         :type match_profile_name: ``str``
         :param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.resume()} method
         :type sessionopts: ``dict``
-        :param **sessionopts: 
         :returns: returns True if this method has been successful
         :rtype: ``bool``
         :raises X2GoClientException: if the method does not know what session to resume
@@ -1608,13 +1603,13 @@ class X2GoClient(object):
     def suspend_session(self, session_uuid, session_name=None, match_profile_name=None, **sessionopts):
         """\
         Suspend an X2Go session.
-        
+
         Normally, you will use this method to suspend a registered session that you
         have formerly started/resumed from within your recent
         L{X2GoClient} instance. For this you simply call this method
         using the session's ``session_uuid``, leave the ``session_name``
         empty.
-        
+
         Alternatively, you can suspend a non-associated X2Go session:
         To do this you simply neeed to register (with the L{register_session}
         method) an X2Go session on the to-be-addressed remote X2Go server and
@@ -1631,7 +1626,6 @@ class X2GoClient(object):
         :type match_profile_name: ``str``
         :param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.suspend()} method
         :type sessionopts: ``dict``
-        :param **sessionopts: 
         :returns: returns True if this method has been successful
         :rtype: ``bool``
 
@@ -1661,13 +1655,13 @@ class X2GoClient(object):
     def terminate_session(self, session_uuid, session_name=None, match_profile_name=None, **sessionopts):
         """\
         Terminate an X2Go session.
-        
+
         Normally you will use this method to terminate a registered session that you
         have formerly started/resumed from within your recent
         L{X2GoClient} instance. For this you simply call this method
         using the session's ``session_uuid``, leave the ``session_name``
         empty.
-        
+
         Alternatively, you can terminate a non-associated X2Go session:
         To do this you simply neeed to register (L{register_session})
         an X2Go session on the to-be-addressed remote X2Go server and
@@ -1683,7 +1677,6 @@ class X2GoClient(object):
         :type match_profile_name: ``str``
         :param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.terminate()} method
         :type sessionopts: ``dict``
-        :param **sessionopts: 
         :returns: returns True if this method has been successful
         :rtype: ``bool``
 
@@ -1714,10 +1707,10 @@ class X2GoClient(object):
         """\
         Retrieve the profile name of the session that has been registered
         under ``session_uuid``.
-        
+
         For profile based sessions this will be the profile name as used
         in x2goclient's »sessions« configuration file.
-        
+
         For non-profile based session this will either be a ``profile_name`` that
         was passed to L{register_session} or it will be the application that
         instantiated this L{X2GoClient} instance.
@@ -1735,12 +1728,12 @@ class X2GoClient(object):
         """\
         Retrieve the profile id of the session that has been registered
         under ``session_uuid``.
-        
+
         For profile based sessions this will be the profile id as used
         in x2goclient's »sessions« configuration node (section header of
         a session profile in the config, normally a timestamp created on
         session profile creation/modification).
-        
+
         For non-profile based sessions this will be a timestamp created on
         X2Go session registration by ``register_session``.
 
@@ -1895,7 +1888,7 @@ class X2GoClient(object):
     def share_local_folder(self, session_uuid=None, local_path=None, profile_name=None, folder_name=None):
         """\
         Share a local folder with the X2Go session registered as ``session_uuid``.
-        
+
         When calling this method the given client-side folder is mounted
         on the X2Go server (via sshfs) and (if in desktop mode) provided as a
         desktop icon on your remote session's desktop.
@@ -1934,7 +1927,7 @@ class X2GoClient(object):
         """\
         Unshare all local folders mounted in X2Go session registered as
         ``session_uuid``.
-        
+
         When calling this method all client-side mounted folders on the X2Go
         server (via sshfs) for session with ID <session_uuid> will get
         unmounted.
@@ -1964,7 +1957,7 @@ class X2GoClient(object):
         """\
         Unshare local folder that is mounted in the X2Go session registered as
         ``session_uuid``.
-        
+
         When calling this method the given client-side mounted folder on the X2Go
         server (via sshfs) for session with ID <session_uuid> will get
         unmounted.
@@ -2412,7 +2405,7 @@ class X2GoClient(object):
     def server_is_alive(self, session_uuid):
         """\
         Test if server that corresponds to the terminal session ``session_uuid`` is alive.
-        
+
         If the session is not connected anymore the L{X2GoClient.HOOK_on_control_session_death()} gets called.
 
         :param session_uuid: the X2Go session's UUID registry hash
@@ -2560,7 +2553,7 @@ class X2GoClient(object):
         """\
         Find running X2Go sessions that have previously been started by the
         connected user on the remote X2Go server and terminate them.
-        
+
         Before calling this method you have to setup a pro forma remote X2Go session
         with L{X2GoClient.register_session()} (even if you do not intend to open
         a real X2Go session window on the remote server) and connect to this session (with
@@ -2592,7 +2585,7 @@ class X2GoClient(object):
         Use the X2Go session registered under ``session_uuid`` to
         retrieve a list of running or suspended X2Go sessions from the
         connected X2Go server (for the authenticated user).
-        
+
         Before calling this method you have to setup a pro forma remote X2Go session
         with L{X2GoClient.register_session()} (even if you do not intend to open
         a real X2Go session window on the remote server) and connect to this session (with
@@ -2673,7 +2666,7 @@ class X2GoClient(object):
         Use the X2Go session registered under ``session_uuid`` to
         retrieve a list of X2Go desktop sessions that are available
         for desktop sharing.
-        
+
         Before calling this method you have to setup a pro forma remote X2Go session
         with L{X2GoClient.register_session()} (even if you do not intend to open
         a real X2Go session window on the remote server) and connect to this session (with
@@ -2819,7 +2812,7 @@ class X2GoClient(object):
     def get_profiles(self):
         """\
         Returns the L{X2GoClient} instance's ``X2GoSessionProfiles*`` object.
-        
+
         Use this method for object retrieval if you want to modify the »sessions«
         configuration node (e.g. in ~/.x2goclient with the FILE backend) from within your
         Python X2Go based application.
@@ -2848,7 +2841,7 @@ class X2GoClient(object):
     def get_client_settings(self):
         """\
         Returns the L{X2GoClient} instance's ``X2GoClientSettings*`` object.
-        
+
         Use this method for object retrieval if you want to modify the »settings«
         configuration node (e.g. in ~/.x2goclient with the FILE backend) from within your
         Python X2Go based application.
@@ -2865,7 +2858,7 @@ class X2GoClient(object):
     def get_client_printing(self):
         """\
         Returns the L{X2GoClient} instance's ``X2GoClientPrinting*`` object.
-        
+
         Use this method for object retrieval if you want to modify the printing
         configuration node (e.g. in ~/.x2goclient with the FILE backend) from within your
         Python X2Go based application.
diff --git a/x2go/forward.py b/x2go/forward.py
index a70b22a..964a9db 100644
--- a/x2go/forward.py
+++ b/x2go/forward.py
@@ -41,7 +41,7 @@ class X2GoFwServer(StreamServer):
     """\
     L{X2GoFwServer} implements a gevent's StreamServer based Paramiko/SSH port
     forwarding server.
-    
+
     An L{X2GoFwServer} class object is used to tunnel graphical trafic
     through an external proxy command launched by a ``X2GoProxy*`` backend.
 
@@ -237,7 +237,7 @@ def start_forward_tunnel(local_host='127.0.0.1', local_port=22022,
                          logger=None, ):
     """\
     Setup up a Paramiko/SSH port forwarding tunnel (like openssh -L option).
-    
+
     The tunnel is used to transport X2Go graphics data through a proxy application like nxproxy.
 
     :param local_host: local starting point of the forwarding tunnel (Default value = '127.0.0.1')
diff --git a/x2go/guardian.py b/x2go/guardian.py
index 6581c4a..884f299 100644
--- a/x2go/guardian.py
+++ b/x2go/guardian.py
@@ -42,7 +42,7 @@ class X2GoSessionGuardian(threading.Thread):
     L{X2GoSessionGuardian} thread controls X2Go session threads and their sub-threads (like
     reverse forwarding tunnels, Paramiko transport threads, etc.). Its main function is
     to tidy up once a session gets interrupted (SIGTERM, SIGINT).
-    
+
     There is one L{X2GoSessionGuardian} for each L{X2GoClient} instance (thus: for normal
     setups there should be _one_ L{X2GoClient} and _one_ L{X2GoSessionGuardian} in use).
 
diff --git a/x2go/inifiles.py b/x2go/inifiles.py
index e4d102d..45833f9 100644
--- a/x2go/inifiles.py
+++ b/x2go/inifiles.py
@@ -52,7 +52,7 @@ class X2GoIniFile(object):
     Base class for processing the different ini files used by X2Go
     clients. Primarily used to standardize the content of the different
     X2Go client ini file (settings, printing, sessions, xconfig).
-    
+
     If entries are omitted in an ini file, they are filled with
     default values (as hard coded in Python X2Go), so the resulting objects
     always contain the same fields.
@@ -148,7 +148,7 @@ class X2GoIniFile(object):
     def _storeValue(self, section, key, value):
         """\
         Stores a value for a given section and key.
-        
+
         This methods affects a SafeConfigParser object held in
         RAM. No configuration file is affected by this
         method. To write the configuration to disk use
@@ -207,7 +207,7 @@ class X2GoIniFile(object):
     def write(self):
         """\
         Write the ini file modifications (SafeConfigParser object) from RAM to disk.
-        
+
         For writing the first of the ``config_files`` specified on instance construction
         that is writable will be used.
 
diff --git a/x2go/mimebox.py b/x2go/mimebox.py
index e9ba763..ce2f9c3 100644
--- a/x2go/mimebox.py
+++ b/x2go/mimebox.py
@@ -172,7 +172,6 @@ class X2GoMIMEboxQueue(threading.Thread):
         :type mimebox_action: ``str`` or ``obj``
         :param kwargs: extra options for the specified MIME box action
         :type kwargs: ``dict``
-        :param **kwargs: 
 
         """
         if mimebox_action in list(defaults.X2GO_MIMEBOX_ACTIONS.keys()):
@@ -271,7 +270,7 @@ class X2GoMIMEboxJob(threading.Thread):
     """\
     For each X2Go MIME box job we create a sub-thread that let's
     the MIME box job be processed in the background.
-    
+
     As a handler for this class the function L{x2go_mimeboxjob_handler()}
     is used.
 
diff --git a/x2go/printactions.py b/x2go/printactions.py
index 1f7d6f5..722eee9 100644
--- a/x2go/printactions.py
+++ b/x2go/printactions.py
@@ -439,7 +439,7 @@ class X2GoPrintActionPRINT(X2GoPrintAction):
 class X2GoPrintActionPRINTCMD(X2GoPrintAction):
     """\
     Print action that calls an external command for further processing of incoming print jobs.
-    
+
     The print job's PDF filename will be prepended as last argument to the print command
     used in L{X2GoPrintActionPRINTCMD} instances.
 
diff --git a/x2go/printqueue.py b/x2go/printqueue.py
index 4218146..dbbbdae 100644
--- a/x2go/printqueue.py
+++ b/x2go/printqueue.py
@@ -172,7 +172,7 @@ class X2GoPrintQueue(threading.Thread):
         """\
         Modify the print action of this L{X2GoPrintQueue} thread during runtime. The
         change of print action will be valid for the next incoming print job.
-        
+
         As kwargs you can pass arguments for the print action class to be set. Refer
         to the class descriptions of L{X2GoPrintActionDIALOG}, L{X2GoPrintActionPDFVIEW},
         L{X2GoPrintActionPRINT}, etc.
@@ -181,7 +181,6 @@ class X2GoPrintQueue(threading.Thread):
         :type print_action: ``str`` or ``class``
         :param kwargs: extra options for the specified print action
         :type kwargs: ``dict``
-        :param **kwargs: 
 
         """
         if print_action in list(defaults.X2GO_PRINT_ACTIONS.keys()):
@@ -229,7 +228,7 @@ def x2go_printjob_handler(job_file=None, pdf_file=None, job_title=None, print_ac
     """\
     This function is called as a handler function for each incoming X2Go print job
     represented by the class L{X2GoPrintJob}.
-    
+
     The handler function will (re-)read the »printing« configuration file (if no
     explicit ``print_action`` is passed to this function...). It then will
     execute the ``<print_action>.do_print()`` command.
@@ -289,7 +288,7 @@ class X2GoPrintJob(threading.Thread):
     """\
     For each X2Go print job we create a sub-thread that let's
     the print job be processed in the background.
-    
+
     As a handler for this class the function L{x2go_printjob_handler()}
     is used.
 
diff --git a/x2go/registry.py b/x2go/registry.py
index d3e0ed8..7ca2988 100644
--- a/x2go/registry.py
+++ b/x2go/registry.py
@@ -511,14 +511,14 @@ class X2GoSessionRegistry(object):
         :param ssh_rootdir: ssh base dir (default: ~/.ssh)
         :type ssh_rootdir: ``str``
         :param keep_controlsession_alive: On last L{X2GoSession.disconnect()} keep the associated ``X2GoControlSession`` instance alive?
-        @ŧype keep_controlsession_alive: ``bool``
+        :type keep_controlsession_alive: ``bool``
         :param add_to_known_hosts: Auto-accept server host validity?
         :type add_to_known_hosts: ``bool``
         :param known_hosts: the underlying Paramiko/SSH systems ``known_hosts`` file
         :type known_hosts: ``str``
         :param kwargs: all other options will be passed on to the constructor of the to-be-instantiated L{X2GoSession} instance
         :type kwargs: ``dict``
-        :param _X2GO_CLIENT_ROOTDIR: 
+        :param _X2GO_CLIENT_ROOTDIR:
         :returns: the session UUID of the newly registered (or re-registered) session
         :rtype: ``str``
 
diff --git a/x2go/rforward.py b/x2go/rforward.py
index 8748ad4..60bcaf5 100644
--- a/x2go/rforward.py
+++ b/x2go/rforward.py
@@ -43,15 +43,15 @@ from . import log
 def x2go_transport_tcp_handler(chan, origin, server):
     """\
     An X2Go customized TCP handler for the Paramiko/SSH ``Transport()`` class.
-    
+
     Incoming channels will be put into Paramiko's default accept queue. This corresponds to
     the default behaviour of Paramiko's ``Transport`` class.
-    
+
     However, additionally this handler function checks the server port of the incoming channel
     and detects if there are Paramiko/SSH reverse forwarding tunnels waiting for the incoming
     channels. The Paramiko/SSH reverse forwarding tunnels are initiated by an L{X2GoSession} instance
     (currently supported: reverse tunneling auf audio data, reverse tunneling of SSH requests).
-    
+
     If the server port of an incoming Paramiko/SSH channel matches the configured port of an L{X2GoRevFwTunnel}
     instance, this instance gets notified of the incoming channel and a new L{X2GoRevFwChannelThread} is
     started. This L{X2GoRevFwChannelThread} then takes care of the new channel's incoming data stream.
@@ -192,11 +192,11 @@ class X2GoRevFwTunnel(threading.Thread):
     def notify(self):
         """\
         Notify an L{X2GoRevFwTunnel} instance of an incoming Paramiko/SSH channel.
-        
+
         If an incoming reverse tunnel channel appropriate for this instance has
         been detected, this method gets called from the L{X2GoSession}'s transport
         TCP handler.
-        
+
         The sent notification will trigger a ``thread.Condition()`` waiting for notification
         in L{X2GoRevFwTunnel.run()}.
 
@@ -240,16 +240,16 @@ class X2GoRevFwTunnel(threading.Thread):
         L{start()} method. Use L{X2GoRevFwTunnel}.stop_thread() to stop the
         reverse forwarding tunnel again. You can also temporarily lock the tunnel
         down with L{X2GoRevFwTunnel.pause()} and L{X2GoRevFwTunnel.resume()}).
-        
+
         L{X2GoRevFwTunnel.run()} waits for notifications of an appropriate incoming
         Paramiko/SSH channel (issued by L{X2GoRevFwTunnel.notify()}). Appropriate in
         this context means, that its start point on the X2Go server matches the class's
         property ``server_port``.
-        
+
         Once a new incoming channel gets announced by the L{notify()} method, a new
         L{X2GoRevFwChannelThread} instance will be initialized. As a data stream handler,
         the function L{x2go_rev_forward_channel_handler()} will be used.
-        
+
         The channel will last till the connection gets dropped on the X2Go server side or
         until the tunnel gets paused by an L{X2GoRevFwTunnel.pause()} call or stopped via the
         L{X2GoRevFwTunnel.stop_thread()} method.
@@ -292,15 +292,15 @@ def x2go_rev_forward_channel_handler(chan=None, addr='', port=0, parent_thread=N
     """\
     Handle the data stream of a requested channel that got set up by a L{X2GoRevFwTunnel} (Paramiko/SSH
     reverse forwarding tunnel).
-    
+
     The channel (and the corresponding connections) close either ...
-    
+
         - ... if the connecting application closes the connection and thus, drops
-        the channel, or
+          the channel, or
         - ... if the L{X2GoRevFwTunnel} parent thread gets paused. The call
-        of L{X2GoRevFwTunnel.pause()} on the instance can be used to shut down all incoming
-        tunneled SSH connections associated to this L{X2GoRevFwTunnel} instance
-        from within a Python X2Go application.
+          of L{X2GoRevFwTunnel.pause()} on the instance can be used to shut down all incoming
+          tunneled SSH connections associated to this L{X2GoRevFwTunnel} instance
+          from within a Python X2Go application.
 
     :param chan: channel (Default value = None)
     :type chan: ``class``
diff --git a/x2go/session.py b/x2go/session.py
index 6fcacf1..4b81684 100644
--- a/x2go/session.py
+++ b/x2go/session.py
@@ -127,7 +127,7 @@ class X2GoSession(object):
     Public API class for launching X2Go sessions. Recommended is to manage X2Go sessions from
     within an L{X2GoClient} instance. However, Python X2Go is designed in a way that it also
     allows the management of singel L{X2GoSession} instance.
-    
+
     Thus, you can use the L{X2GoSession} class to manually set up X2Go sessions without
     L{X2GoClient} context (session registry, session list cache, auto-registration of new
     sessions etc.).
@@ -652,10 +652,10 @@ class X2GoSession(object):
     def is_master_session(self):
         """\
         Is this session a/the master session of sessions.
-        
+
         The master session is the session has been launched first for a specific connection,
         it also is _the_ session that controls the client-side shared folders.
-        
+
         If this L{X2GoSession} instance is a standalone instance (without parent L{X2GoClient})
         this method will always return ``True``.
 
@@ -673,7 +673,7 @@ class X2GoSession(object):
     def set_master_session(self, wait=0, max_wait=20):
         """\
         Declare this as a master session of a connection channel.
-        
+
         This method gets called by the L{X2GoSessionRegistry} while sessions are starting or resuming and it relies on
         an already set-up terminal session.
 
@@ -1045,7 +1045,7 @@ class X2GoSession(object):
     def get_session_type(self):
         """\
         Retrieve the session type of a session (R, D, S or P).
-        
+
           - R: rootless session
           - D: desktop session
           - S: shadow session
@@ -1513,17 +1513,16 @@ class X2GoSession(object):
         """\
         If X2Go client-side printing is enable within this X2Go session you can use
         this method to alter the way how incoming print spool jobs are handled/processed.
-        
+
         For further information, please refer to the documentation of the L{X2GoClient.set_session_print_action()}
         method.
 
         :param print_action: one of the named above print actions, either as string or class instance
         :type print_action: ``str`` or ``instance``
-        :param kwargs: additional information for the given print action (print
-            action arguments), for possible print action arguments and their values see each individual
+        :param kwargs: additional information for the given print action (print \
+            action arguments), for possible print action arguments and their values see each individual \
             print action class
         :type kwargs: ``dict``
-        :param **kwargs: 
 
         """
         if type(print_action) is not bytes:
@@ -1636,10 +1635,10 @@ class X2GoSession(object):
         Update the current session status. The L{X2GoSession} instance uses an internal
         session status cache that allows to query the session status without the need
         of retrieving data from the remote X2Go server for each query.
-        
+
         The session status (if initialized properly with the L{X2GoClient} constructor gets
         updated in regularly intervals.
-        
+
         In case you use the L{X2GoSession} class in standalone instances (that is: without
         being embedded into an L{X2GoSession} context) then run this method in regular
         intervals to make sure the L{X2GoSession}'s internal status cache information
@@ -1773,7 +1772,7 @@ class X2GoSession(object):
         Automatically start or resume this session, if already associated with a server session. Otherwise
         resume a server-side available/suspended session (see options to declare which session to resume).
         If no session is available for resuming a new session will be launched.
-        
+
         Sessions in published applications mode are not resumed/started by this method.
 
         :param newest: if resuming, only resume newest/youngest session (Default value = True)
diff --git a/x2go/sftpserver.py b/x2go/sftpserver.py
index bf268cf..22c2213 100644
--- a/x2go/sftpserver.py
+++ b/x2go/sftpserver.py
@@ -540,16 +540,16 @@ class X2GoRevFwTunnelToSFTP(rforward.X2GoRevFwTunnel):
         This method gets run once an L{X2GoRevFwTunnelToSFTP} has been started with its
         L{start()} method. Use L{X2GoRevFwTunnelToSFTP}.stop_thread() to stop the
         reverse forwarding tunnel again (refer also to its pause() and resume() method).
-        
+
         L{X2GoRevFwTunnelToSFTP.run()} waits for notifications of an appropriate incoming
         Paramiko/SSH channel (issued by L{X2GoRevFwTunnelToSFTP.notify()}). Appropriate in
         this context means, that its starting point on the X2Go server matches the class's
         property ``server_port``.
-        
+
         Once a new incoming channel gets announced by the L{notify()} method, a new
         L{X2GoRevFwSFTPChannelThread} instance will be initialized. As a data stream handler,
         the function L{x2go_rev_forward_sftpchannel_handler()} will be used.
-        
+
         The channel will last till the connection gets dropped on the X2Go server side or
         until the tunnel gets paused by an L{X2GoRevFwTunnelToSFTP.pause()} call or
         stopped via the ``X2GoRevFwTunnelToSFTP.stop_thread()`` method.
@@ -590,15 +590,15 @@ class X2GoRevFwTunnelToSFTP(rforward.X2GoRevFwTunnel):
 def x2go_rev_forward_sftpchannel_handler(chan=None, auth_key=None, logger=None):
     """\
     Handle incoming sFTP channels that got setup by an L{X2GoRevFwTunnelToSFTP} instance.
-    
+
     The channel (and the corresponding connections) close either ...
-    
+
         - ... if the connecting application closes the connection and thus, drops
-        the sFTP channel, or
+          the sFTP channel, or
         - ... if the L{X2GoRevFwTunnelToSFTP} parent thread gets paused. The call
-        of L{X2GoRevFwTunnelToSFTP.pause()} on the instance can be used to shut down all incoming
-        tunneled SSH connections associated to this L{X2GoRevFwTunnelToSFTP} instance
-        from within a Python X2Go application.
+          of L{X2GoRevFwTunnelToSFTP.pause()} on the instance can be used to shut down all incoming
+          tunneled SSH connections associated to this L{X2GoRevFwTunnelToSFTP} instance
+          from within a Python X2Go application.
 
     :param chan: an incoming sFTP channel (Default value = None)
     :type chan: paramiko.Channel instance
diff --git a/x2go/telekinesis.py b/x2go/telekinesis.py
index 70aaca4..d042f28 100644
--- a/x2go/telekinesis.py
+++ b/x2go/telekinesis.py
@@ -54,7 +54,7 @@ from x2go.defaults import CURRENT_LOCAL_USER as _CURRENT_LOCAL_USER
 class X2GoTelekinesisClient(threading.Thread):
     """\
     Telekinesis is a communication framework used by X2Go.
-    
+
     This class implements the startup of the telekinesis client used by
     Python X2Go.
 
diff --git a/x2go/utils.py b/x2go/utils.py
index 29f43fc..b21f722 100644
--- a/x2go/utils.py
+++ b/x2go/utils.py
@@ -682,7 +682,7 @@ def get_workarea_geometry():
     """\
     Get the geometry of the current screen's work area by
     wrapping around::
-    
+
         xprop -root '_NET_WORKAREA'
 
 
diff --git a/x2go/xserver.py b/x2go/xserver.py
index 9d79582..6a63733 100644
--- a/x2go/xserver.py
+++ b/x2go/xserver.py
@@ -50,7 +50,7 @@ from . import utils
 class X2GoClientXConfig(inifiles.X2GoIniFile):
     """\
     Configuration file based XServer startup settings for X2GoClient instances.
-    
+
     This class is needed for Windows systems and (maybe soon) for Unix desktops using Wayland.
 
 
@@ -99,7 +99,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
     def write(self):
         """\
         Store the Xserver configuration to the storage backend (i.e. on disk).
-        
+
         For writing the first of the ``config_files`` specified on instance construction
         that is writable will be used.
 
@@ -274,7 +274,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
 class X2GoXServer(threading.Thread):
     """\
     This class is responsible for starting/stopping an external XServer application.
-    
+
     X2Go applications require a running XServer on the client system. This class will
     manage/handle the XServer while your X2Go application is running.
 

--
Alioth's /home/x2go-admin/maintenancescripts/git/hooks/post-receive-email on /srv/git/code.x2go.org/python-x2go.git


More information about the x2go-commits mailing list