From c2ca09b9b939b1309d82d092bd88f7e9a2a99ec6 Mon Sep 17 00:00:00 2001
From: afabiani <alessio.fabiani@geo-solutions.it>
Date: Thu, 15 Nov 2018 13:10:44 +0100
Subject: [PATCH]  - preparing for test suite / introducing pep8 format checks

---
 autopep8.sh                                   |   6 +
 flake8.sh                                     |   6 +
 requirements.txt                              |  23 +-
 setup.cfg                                     |   5 +
 setup.py                                      |  69 ++--
 src/wpsremote/ConfigParser.py                 |  37 ++-
 src/wpsremote/__init__.py                     |   1 -
 src/wpsremote/action.py                       |  22 +-
 src/wpsremote/bus.py                          |   5 +-
 src/wpsremote/busIndipendentMessages.py       |  41 ++-
 src/wpsremote/command_line_parameter.py       |  22 +-
 src/wpsremote/computation_job_const.py        |   6 +-
 src/wpsremote/computation_job_input.py        |  85 ++---
 src/wpsremote/computation_job_inputs.py       |  56 ++--
 src/wpsremote/computation_job_param.py        |  20 +-
 .../computational_job_input_action.py         |   1 +
 ...omputational_job_input_action_cmd_param.py |  27 +-
 ...computational_job_input_action_copyfile.py |   5 +-
 ...ional_job_input_action_create_json_file.py |  39 +--
 ...tional_job_input_action_update_ini_file.py |  65 ++--
 ...ional_job_input_action_update_json_file.py |  40 +--
 .../computational_job_input_actions.py        |  65 ++--
 src/wpsremote/configInstance.py               |  81 ++---
 src/wpsremote/config_file_parameter.py        |  17 +-
 .../config_file_parameter_cmre_oaa.py         | 164 ++++++----
 src/wpsremote/decryptor.py                    |   8 +-
 src/wpsremote/encryptor.py                    |   8 +-
 src/wpsremote/ftpUpload.py                    |  28 +-
 src/wpsremote/ftpsUpload.py                   |  39 ++-
 src/wpsremote/input_parameter.py              |  67 ++--
 src/wpsremote/input_parameters.py             | 158 +++++-----
 src/wpsremote/introspection.py                |  31 +-
 src/wpsremote/mockutils.py                    |  11 +-
 src/wpsremote/output_file_parameter.py        | 149 +++++----
 src/wpsremote/output_parameters.py            |  69 ++--
 src/wpsremote/path.py                         |  72 +++--
 src/wpsremote/process_test.py                 |  26 +-
 src/wpsremote/processbot.py                   | 296 +++++++++++-------
 src/wpsremote/resource_cleaner.py             | 233 +++++++-------
 src/wpsremote/resource_monitor.py             |  47 ++-
 src/wpsremote/serviceTester.py                | 199 ++++++------
 src/wpsremote/servicebot.py                   | 192 +++++++-----
 src/wpsremote/sftpUpload.py                   |  30 +-
 src/wpsremote/termination_handler.py          |  45 +--
 src/wpsremote/upload.py                       |   3 +-
 src/wpsremote/wpsagent.py                     | 163 ++++++----
 src/wpsremote/xmppBus.py                      | 135 ++++----
 src/wpsremote/xmppMessages.py                 | 120 +++----
 .../xmpp_data/configs/myservice/code/test.py  |  35 +--
 test/__init__.py                              |   1 -
 test/test_computation_job_inputs.py           | 291 +++++++++--------
 test/test_process_input_parameters.py         |  61 ++--
 test_suite.sh                                 |   9 +
 53 files changed, 1944 insertions(+), 1490 deletions(-)
 create mode 100644 autopep8.sh
 create mode 100644 flake8.sh
 create mode 100644 test_suite.sh

diff --git a/autopep8.sh b/autopep8.sh
new file mode 100644
index 0000000..d0aa246
--- /dev/null
+++ b/autopep8.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+
+autopep8 -v -i -a -a -r *.py
+autopep8 -v -i -a -a -r src
+autopep8 -v -i -a -a -r test
diff --git a/flake8.sh b/flake8.sh
new file mode 100644
index 0000000..370efd0
--- /dev/null
+++ b/flake8.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+
+flake8 *.py
+flake8 src/wpsremote
+flake8 test
diff --git a/requirements.txt b/requirements.txt
index ca7898b..ff7fb47 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,15 +1,28 @@
+asn1crypto==0.24.0
 astroid==1.4.4
+autopep8==1.4.3
+bcrypt==3.1.4
+cffi==1.11.5
 colorama==0.3.6
+cryptography==2.3.1
+enum34==1.1.6
 flake8==2.5.4
 functools32==3.2.3.post2
+idna==2.7
+ipaddress==1.0.22
 jsonschema==2.5.1
 lazy-object-proxy==1.2.1
 mccabe==0.4.0
-pep8==1.7.0
-psutil==4.0.0
+paramiko==2.4.1
+pep8==1.7.1
+psutil==5.4.7
+pyasn1==0.4.4
+pycodestyle==2.4.0
+pycparser==2.18
+pycrypto==2.6.1
 pyflakes==1.0.0
 pylint==1.5.4
+PyNaCl==1.2.1
 six==1.10.0
-sleekxmpp==1.3.1
-wheel==0.24.0
-wrapt==1.10.6
+sleekxmpp==1.3.3
+wrapt==1.10.10
diff --git a/setup.cfg b/setup.cfg
index b88034e..79f906a 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,2 +1,7 @@
 [metadata]
 description-file = README.md
+
+[flake8]
+max-line-length = 120
+exclude=management,scripts,docs,static
+ignore=E121,E122,E124,E126,E226
diff --git a/setup.py b/setup.py
index fc9375f..a5d6944 100644
--- a/setup.py
+++ b/setup.py
@@ -24,25 +24,38 @@
       python setup.py bdist --format=gztar upload -r pypi
       python setup.py bdist_wheel upload -r pypi
 """
-from setuptools import setup, find_packages
+try:  # for pip >= 10
+    from pip._internal.req import parse_requirements
+    from pip._internal.download import PipSession
+except ImportError:  # for pip <= 9.0.3
+    from pip.req import parse_requirements
+    from pip.download import PipSession
+from distutils.core import setup
+
+from setuptools import find_packages
+
+# Parse requirements.txt to get the list of dependencies
+inst_req = parse_requirements('requirements.txt',
+                              session=PipSession())
+REQUIREMENTS = [str(r.req) for r in inst_req]
 
 try:
     readme_text = file('README.md', 'rb').read()
-except IOError,e:
+except IOError as e:
     readme_text = ''
 
 setup(
-    name = "wps-remote",
-    version = "2.15.0",
-    author = "GeoServer Developers",
-    author_email = "geoserver-devel@lists.sourceforge.net",
-    description = "A library that allows users to publish their executables as GeoServer WPS Processes through the XMPP protocol",
-    keywords = "XMPP Beckend for GeoServer Remote WPS ProcessFactory.",
-    long_description = readme_text,
-    license = "GPL",
-    url = "https://github.com/geoserver/wps-remote",
-    #https://pypi.python.org/pypi?%3Aaction=list_classifiers
-    classifiers = [
+    name="wps-remote",
+    version="2.15.0",
+    author="GeoServer Developers",
+    author_email="geoserver-devel@lists.sourceforge.net",
+    description="A library that allows users to publish their executables as GeoServer WPS Processes through the XMPP protocol",  # noqa
+    keywords="XMPP Beckend for GeoServer Remote WPS ProcessFactory.",
+    long_description=readme_text,
+    license="GPL",
+    url="https://github.com/geoserver/wps-remote",
+    # https://pypi.python.org/pypi?%3Aaction=list_classifiers
+    classifiers=[
         'Environment :: Web Environment',
         'License :: OSI Approved :: GNU General Public License v2 (GPLv2)',
         'Intended Audience :: Developers',
@@ -51,9 +64,9 @@
         'Programming Language :: Python',
         'Topic :: Scientific/Engineering :: GIS',
     ],
-    package_dir = {'':'src'},
-    packages = find_packages('src'),
-    package_data = {
+    package_dir={'': 'src'},
+    packages=find_packages('src'),
+    package_data={
         '': [
             'xmpp_data/*.*',
             'xmpp_data/configs/*.*',
@@ -67,25 +80,7 @@
             'xmpp_data/test/*.*',
         ]
     },
-    include_package_data = True,
-    test_suite = "test",
-    install_requires = [
-        "astroid==1.4.4",
-        "colorama==0.3.6",
-        "flake8==2.5.4",
-        "functools32",
-        "jsonschema==2.5.1",
-        "lazy-object-proxy==1.2.1",
-        "mccabe==0.4.0",
-        "paramiko",
-        "pep8==1.7.0",
-        "psutil>=4.0.0",
-        "pycrypto",
-        "pyflakes==1.0.0",
-        "pylint==1.5.4",
-        "six==1.10.0",
-        "sleekxmpp>=1.3.1",
-        "wheel==0.24.0",
-        "wrapt==1.10.10",
-    ],
+    include_package_data=True,
+    test_suite="test",
+    install_requires=REQUIREMENTS,
 )
diff --git a/src/wpsremote/ConfigParser.py b/src/wpsremote/ConfigParser.py
index a6a18c0..ef12c9e 100644
--- a/src/wpsremote/ConfigParser.py
+++ b/src/wpsremote/ConfigParser.py
@@ -4,6 +4,9 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import re
+import UserDict as _UserDict
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
@@ -103,8 +106,6 @@
     # fallback for setup.py which hasn't yet built _collections
     _default_dict = dict
 
-import re
-
 __all__ = ["NoSectionError", "DuplicateSectionError", "NoOptionError",
            "InterpolationError", "InterpolationDepthError",
            "InterpolationSyntaxError", "ParsingError",
@@ -117,7 +118,6 @@
 MAX_INTERPOLATION_DEPTH = 10
 
 
-
 # exception classes
 class Error(Exception):
     """Base class for ConfigParser exceptions."""
@@ -146,6 +146,7 @@ def __repr__(self):
 
     __str__ = __repr__
 
+
 class NoSectionError(Error):
     """Raised when no section matches a requested option."""
 
@@ -154,6 +155,7 @@ def __init__(self, section):
         self.section = section
         self.args = (section, )
 
+
 class DuplicateSectionError(Error):
     """Raised when a section is multiply-created."""
 
@@ -162,6 +164,7 @@ def __init__(self, section):
         self.section = section
         self.args = (section, )
 
+
 class NoOptionError(Error):
     """A requested option was not found."""
 
@@ -172,6 +175,7 @@ def __init__(self, option, section):
         self.section = section
         self.args = (option, section)
 
+
 class InterpolationError(Error):
     """Base class for interpolation-related exceptions."""
 
@@ -181,6 +185,7 @@ def __init__(self, option, section, msg):
         self.section = section
         self.args = (option, section, msg)
 
+
 class InterpolationMissingOptionError(InterpolationError):
     """A string substitution required a setting which was not available."""
 
@@ -195,10 +200,12 @@ def __init__(self, option, section, rawval, reference):
         self.reference = reference
         self.args = (option, section, rawval, reference)
 
+
 class InterpolationSyntaxError(InterpolationError):
     """Raised when the source text into which substitutions are made
     does not conform to the required syntax."""
 
+
 class InterpolationDepthError(InterpolationError):
     """Raised when substitutions are nested too deeply."""
 
@@ -211,6 +218,7 @@ def __init__(self, option, section, rawval):
         InterpolationError.__init__(self, option, section, msg)
         self.args = (option, section, rawval)
 
+
 class ParsingError(Error):
     """Raised when a configuration file does not follow legal syntax."""
 
@@ -224,6 +232,7 @@ def append(self, lineno, line):
         self.errors.append((lineno, line))
         self.message += '\n\t[line %2d]: %s' % (lineno, line)
 
+
 class MissingSectionHeaderError(ParsingError):
     """Raised when a key-value pair is found before any section header."""
 
@@ -268,7 +277,7 @@ def add_section(self, section):
         case-insensitive variants.
         """
         if section.lower() == "default":
-            raise ValueError, 'Invalid section name: %s' % section
+            raise ValueError('Invalid section name: %s' % section)
 
         if section in self._sections:
             raise DuplicateSectionError(section)
@@ -377,7 +386,7 @@ def getfloat(self, section, option):
     def getboolean(self, section, option):
         v = self.get(section, option)
         if v.lower() not in self._boolean_states:
-            raise ValueError, 'Not a boolean: %s' % v
+            raise ValueError('Not a boolean: %s' % v)
         return self._boolean_states[v.lower()]
 
     def optionxform(self, optionstr):
@@ -392,8 +401,8 @@ def has_option(self, section, option):
             return False
         else:
             option = self.optionxform(option)
-            return (option in self._sections[section]
-                    or option in self._defaults)
+            return (option in self._sections[section] or
+                    option in self._defaults)
 
     def set(self, section, option, value=None):
         """Set an option."""
@@ -452,7 +461,7 @@ def remove_section(self, section):
         r'\['                                 # [
         r'(?P<header>[^]]+)'                  # very permissive!
         r'\]'                                 # ]
-        )
+    )
     OPTCRE = re.compile(
         r'(?P<option>[^:=\s][^:=]*)'          # very permissive!
         r'\s*(?P<vi>[:=])\s*'                 # any number of space/tab,
@@ -460,7 +469,7 @@ def remove_section(self, section):
                                               # (either : or =), followed
                                               # by any # space/tab
         r'(?P<value>.*)$'                     # everything up to eol
-        )
+    )
     OPTCRE_NV = re.compile(
         r'(?P<option>[^:=\s][^:=]*)'          # very permissive!
         r'\s*(?:'                             # any number of space/tab,
@@ -469,7 +478,7 @@ def remove_section(self, section):
                                               # =), followed by any #
                                               # space/tab
         r'(?P<value>.*))?$'                   # everything up to eol
-        )
+    )
 
     def _read(self, fp, fpname):
         """Parse a sectioned setup file.
@@ -563,7 +572,6 @@ def _read(self, fp, fpname):
                 if isinstance(val, list):
                     options[name] = '\n'.join(val)
 
-import UserDict as _UserDict
 
 class _Chainmap(_UserDict.DictMixin):
     """Combine multiple mappings for successive lookups.
@@ -595,6 +603,7 @@ def keys(self):
                     seen.add(key)
         return result
 
+
 class ConfigParser(RawConfigParser):
 
     def get(self, section, option, raw=False, vars=None):
@@ -674,7 +683,7 @@ def _interpolate(self, section, option, rawval, vars):
                 value = self._KEYCRE.sub(self._interpolation_replace, value)
                 try:
                     value = value % vars
-                except KeyError, e:
+                except KeyError as e:
                     raise InterpolationMissingOptionError(
                         option, section, rawval, e.args[0])
             else:
@@ -723,7 +732,7 @@ def _interpolate_some(self, option, accum, rest, section, map, depth):
                 m = self._interpvar_re.match(rest)
                 if m is None:
                     raise InterpolationSyntaxError(option, section,
-                        "bad interpolation variable reference %r" % rest)
+                                                   "bad interpolation variable reference %r" % rest)
                 var = self.optionxform(m.group(1))
                 rest = rest[m.end():]
                 try:
@@ -759,5 +768,5 @@ def set(self, section, option, value=None):
             # then, check if there's a lone percent sign left
             if '%' in tmp_value:
                 raise ValueError("invalid interpolation syntax in %r at "
-                                "position %d" % (value, tmp_value.find('%')))
+                                 "position %d" % (value, tmp_value.find('%')))
         ConfigParser.set(self, section, option, value)
diff --git a/src/wpsremote/__init__.py b/src/wpsremote/__init__.py
index b598346..93b8b0a 100644
--- a/src/wpsremote/__init__.py
+++ b/src/wpsremote/__init__.py
@@ -3,4 +3,3 @@
 # (c) 2013 - 2014 German Aerospace Center (DLR)
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
-
diff --git a/src/wpsremote/action.py b/src/wpsremote/action.py
index 25e8047..b2ca7e2 100644
--- a/src/wpsremote/action.py
+++ b/src/wpsremote/action.py
@@ -4,31 +4,33 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 from collections import OrderedDict
 import path
 import introspection
 import ConfigParser
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 def action_factory(config_section_items):
     actions = OrderedDict()
     for a in config_section_items:
         d = dict(config_section_items[a])
         if ('type' in d):
-            actions[a] = introspection.get_class_one_arg( d['type'], d )
+            actions[a] = introspection.get_class_one_arg(d['type'], d)
 
     return actions
 
+
 class CopyFile(object):
     def __init__(self, param_dict):
         self.source = path.path(param_dict['source'])
         self.target = path.path(param_dict['target'])
 
     def execute(self, input_values):
-         self.source.copy(self.target)
+        self.source.copy(self.target)
 
 
 class CopyINIFileAddParam(object):
@@ -42,11 +44,11 @@ def __init__(self, param_dict):
     def execute(self, input_values):
         self.source.copy(self.target)
         config = ConfigParser.ConfigParser(allow_no_value=True)
-        fp = self.target.open() 
-        config.readfp( fp  )
+        fp = self.target.open()
+        config.readfp(fp)
         fp.close()
 
         config.set(self.param_section, self.param_name, input_values[self.param_value_ref])
-       
+
         with self.target.open('wb') as configfile:
-            config.write(configfile)
\ No newline at end of file
+            config.write(configfile)
diff --git a/src/wpsremote/bus.py b/src/wpsremote/bus.py
index ebdf35e..3844340 100644
--- a/src/wpsremote/bus.py
+++ b/src/wpsremote/bus.py
@@ -8,9 +8,10 @@
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
+
 class Bus(object):
     def __init__(self, id):
-        self.callbacks={}
+        self.callbacks = {}
         self.id = id
 
     def Listen(self):
@@ -19,7 +20,7 @@ def Listen(self):
     def CheckServerIdentity(self, serverId):
         pass
 
-    def SendMessage(self,Message):
+    def SendMessage(self, Message):
         pass
 
     def Stop(self, Message):
diff --git a/src/wpsremote/busIndipendentMessages.py b/src/wpsremote/busIndipendentMessages.py
index 175faac..f8afc2b 100644
--- a/src/wpsremote/busIndipendentMessages.py
+++ b/src/wpsremote/busIndipendentMessages.py
@@ -4,27 +4,31 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import pickle
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import pickle
 
 class BusInipendentMessage(object):
     pass
 
+
 class PresenceMessage(BusInipendentMessage):
     pass
 
+
 class InviteMessage(BusInipendentMessage):
 
     def __init__(self, payload, originator):
-        self._originator=originator
-        self._payload=payload
+        self._originator = originator
+        self._payload = payload
 
     def originator(self):
         return self._originator
 
+
 class RegisterMessage(BusInipendentMessage):
 
     def __init__(self, originator, service, namespace, descritpion, par, output):
@@ -41,12 +45,12 @@ def input_parameters(self):
     def originator(self):
         return self._originator
 
+
 class ExecuteMessage(BusInipendentMessage):
 
     @staticmethod
     def deserialize(filepath):
-        fp=open(filepath)
-        #exe_msg = json.load(json_file)
+        fp = open(filepath)
         exe_msg = pickle.load(fp)
         fp.close()
         return exe_msg
@@ -70,37 +74,41 @@ def BaseURL(self):
         return self._baseURL
 
     def serialize(self, fileptr):
-        #json.dump( self._originator , fileptr)
         pickle.dump(self, fileptr)
 
+
 class ProgressMessage(BusInipendentMessage):
 
-   def __init__(self,  originator, progress):
+    def __init__(self, originator, progress):
         self.originator = originator
         self.progress = progress
 
+
 class LogMessage(BusInipendentMessage):
 
-   def __init__(self,  originator, level, msg):
+    def __init__(self, originator, level, msg):
         self.level = level
         self.originator = originator
         self.msg = msg
 
+
 class CompletedMessage(BusInipendentMessage):
 
     def __init__(self, originator, base_url, outputs):
         self.originator = originator
-        self.base_url=base_url
+        self.base_url = base_url
         self._outputs = outputs
 
     def outputs(self):
         return self._outputs
 
+
 class FinishMessage(BusInipendentMessage):
 
     def __init__(self, payload, originator):
-        self.originator=originator
-        self.payload=payload
+        self.originator = originator
+        self.payload = payload
+
 
 class ErrorMessage(BusInipendentMessage):
 
@@ -109,21 +117,24 @@ def __init__(self, originator, msg, id=None):
         self.msg = msg
         self.id = id
 
+
 class AbortMessage(BusInipendentMessage):
 
     def __init__(self, payload, originator):
-        self.originator=originator
-        self.payload=payload
+        self.originator = originator
+        self.payload = payload
+
 
 class GetLoadAverageMessage(BusInipendentMessage):
 
     def __init__(self, payload, originator):
-        self._originator=originator
-        self._payload=payload
+        self._originator = originator
+        self._payload = payload
 
     def originator(self):
         return self._originator
 
+
 class LoadAverageMessage(BusInipendentMessage):
 
     def __init__(self, originator, outputs):
diff --git a/src/wpsremote/command_line_parameter.py b/src/wpsremote/command_line_parameter.py
index 7abcfe0..037f6bb 100644
--- a/src/wpsremote/command_line_parameter.py
+++ b/src/wpsremote/command_line_parameter.py
@@ -4,26 +4,27 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import input_parameter
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import input_parameter
 
 class CommandLineParameter(input_parameter.InputParameter):
     def __init__(self, name):
         input_parameter.InputParameter.__init__(self, name)
-        self._template=None
+        self._template = None
 
     def get_cmd_line(self):
-        cmd=''
+        cmd = ''
         hasName = False
         hasValue = False
         if 'name' in self._template:
             self._template = self._template.replace("name", "%s")
             hasName = True
         if 'value' in self._template:
-            self._template = self._template.replace("value","%s")  
+            self._template = self._template.replace("value", "%s")
             hasValue = True
         for v in self._value:
             if (hasName and hasValue):
@@ -34,18 +35,23 @@ def get_cmd_line(self):
                 cmd += self._template % (v) + " "
             else:
                 raise Exception("Bad template for command line parameter " + self.get_name())
-        return cmd 
+        return cmd
+
 
 class CommandLineParameterConst(CommandLineParameter):
     def __init__(self, name):
         CommandLineParameter.__init__(self, name)
-        self._template=None
+        self._template = None
 
     def inject_values(self, paremeters_types_defs):
         super(CommandLineParameterConst, self).inject_values(paremeters_types_defs)
-        if type(self._value) is not list:
+        if not isinstance(self._value, list):
             self._value = [self._value]
 
     def set_actual_value(self, value):
-        """override this function because in this case the param value is set in the constructor not with this function"""
+        """
+        Override this function because in this case the param value is set in the
+        constructor not with this function
+        """
+
         pass
diff --git a/src/wpsremote/computation_job_const.py b/src/wpsremote/computation_job_const.py
index 2e0dc2c..fb06515 100644
--- a/src/wpsremote/computation_job_const.py
+++ b/src/wpsremote/computation_job_const.py
@@ -4,15 +4,15 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import computation_job_input
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import computation_job_input
 
 class ComputationJobConst(computation_job_input.ComputationJobInput):
 
     def __init__(self, name, input_type, title, descr, value):
         super(ComputationJobConst, self).__init__(name, input_type, title, descr)
-        self.set_value( value)
-
+        self.set_value(value)
diff --git a/src/wpsremote/computation_job_input.py b/src/wpsremote/computation_job_input.py
index 316237d..3618daa 100644
--- a/src/wpsremote/computation_job_input.py
+++ b/src/wpsremote/computation_job_input.py
@@ -4,13 +4,14 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import string
+import datetime
+import json
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import string
-import datetime
-import json
 
 class ComputationJobInput(object):
 
@@ -24,38 +25,38 @@ def __init__(self, name, input_type, title, description, default=None, formatter
         self._input_mime_type = input_mime_type
         self._value = None
         self._value_converted = None
-        self._allowed_chars = string.printable.replace(' ','')
+        self._allowed_chars = string.printable.replace(' ', '')
         self._allowed_chars_url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~:/?#[]@!$&'()*+,;="
 
     def _validate_and_convert(self, value):
-        if (self._type=='int'):
+        if (self._type == 'int'):
             return int(value)
-        elif (self._type=='float'):
+        elif (self._type == 'float'):
             return float(value)
-        elif (self._type=='string'):
-            if all(c in  self._allowed_chars for c in value):
+        elif (self._type == 'string'):
+            if all(c in self._allowed_chars for c in value):
                 return value
-        elif (self._type=='url'):
-            if all(c in  self._allowed_chars_url for c in value):
+        elif (self._type == 'url'):
+            if all(c in self._allowed_chars_url for c in value):
                 return value
         elif self._type in ['application/json', 'application/xml']:
             return json.loads(value)
-        elif (self._type=='datetime'):
+        elif (self._type == 'datetime'):
             if self._formatter:
                 try:
                     date_value = value.strftime(self._formatter)
                     return date_value
-                except:
+                except BaseException:
                     pass
 
-            if all(c in  self._allowed_chars for c in value):
+            if all(c in self._allowed_chars for c in value):
                 return value
 
         raise TypeError("Cannot validate and convert value " + str(value) + " for type " + self._type)
 
     def _type_checking(self, value):
         try:
-            self._validate_and_convert( value )
+            self._validate_and_convert(value)
             return self._type
         except TypeError:
             return False
@@ -65,18 +66,19 @@ def validate(self):
             raise TypeError("cannot find a value for parameter " + self.get_name())
 
         res = map(self._type_checking, self._value)
-        #remove duplicates
+        # remove duplicates
         res = list(set(res))
 
-        #if res has one element equal to True means all items in the list passed type checking
-        if (len(res)==1 and res[0]):
+        # if res has one element equal to True means all items in the list passed type checking
+        if (len(res) == 1 and res[0]):
             self._value_converted = map(self._validate_and_convert, self._value)
             return True
         else:
-            raise TypeError("cannot validate value " + str(self._value) + " for parameter " + self.get_name() + " with type " + self._type)
+            raise TypeError("cannot validate value " + str(self._value) +
+                            " for parameter " + self.get_name() + " with type " + self._type)
 
     def set_value(self, value):
-        if type(value) is not list:
+        if not isinstance(value, list):
             self._value = [value]
         else:
             self._value = value
@@ -85,12 +87,14 @@ def set_value(self, value):
         try:
             res = self.validate()
             if not res:
-                raise TypeError("cannot set value " + str(self._value) + " for parameter " + self.get_name() + " with type " + self._type)
-        except:
-            raise TypeError("cannot set value " + str(self._value) + " for parameter " + self.get_name() + " with type " + self._type)
+                raise TypeError("cannot set value " + str(self._value) + " for parameter " +
+                                self.get_name() + " with type " + self._type)
+        except BaseException:
+            raise TypeError("cannot set value " + str(self._value) + " for parameter " +
+                            self.get_name() + " with type " + self._type)
 
     def get_value(self):
-        if type(self._value_converted) is list and len(self._value_converted)==1:
+        if isinstance(self._value_converted, list) and len(self._value_converted) == 1:
             return self._value_converted[0]
         else:
             return self._value_converted
@@ -102,8 +106,8 @@ def get_input_mime_type(self):
         return self._input_mime_type
 
     def get_value_string(self):
-        if type(self._value) is list and len(self._value)==1:
-            if type(self._value[0]) is datetime.datetime:
+        if isinstance(self._value, list) and len(self._value) == 1:
+            if isinstance(self._value[0], datetime.datetime):
                 return self._value[0].strftime(self._formatter)
             else:
                 return self._value[0]
@@ -112,35 +116,42 @@ def get_value_string(self):
 
     def get_value_as_JSON_literal(self):
         res = map(self._JSON_token_converter, self._value_converted)
-        if type(res) is list and len(res)==1:
+        if isinstance(res, list) and len(res) == 1:
             return res[0]
         else:
             return res
 
     def _JSON_token_converter(self, value):
-        if self._type=='int' or self._type=='float':
+        if self._type == 'int' or self._type == 'float':
             return str(value)
-        elif self._type=='string':
+        elif self._type == 'string':
             return "'" + str(value) + "'"
-        elif self._type=='datetime':
-            return "'" +  value.strftime(self._formatter) + "'"
-        elif self._type=='application/json':
+        elif self._type == 'datetime':
+            return "'" + value.strftime(self._formatter) + "'"
+        elif self._type == 'application/json':
             raise TypeError("cannot convert json in json")
         else:
-            raise TypeError("unknown type for value " + self.get_name() )
+            raise TypeError("unknown type for value " + self.get_name())
 
     def has_value(self):
-        return self._value != None
+        return self._value is not None
 
     def get_name(self):
         return self._name
 
     def as_json_string(self):
-        #{"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
-        res={}
-        attrib_to_convert = ['_type', '_title', '_default', '_description', '_min', '_max', '_input_mime_type'] #missing _enum
+        # {"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
+        res = {}
+        attrib_to_convert = [
+    '_type',
+    '_title',
+    '_default',
+    '_description',
+    '_min',
+    '_max',
+     '_input_mime_type']  # missing _enum
         attribute_list = [a for a in dir(self) if not a.startswith('__') and not callable(getattr(self, a))]
         attribute_list_filtered = [x for x in attribute_list if x in attrib_to_convert]
         for a in attribute_list_filtered:
             res[a[1:]] = getattr(self, a)
-        return  json.dumps(res)
+        return json.dumps(res)
diff --git a/src/wpsremote/computation_job_inputs.py b/src/wpsremote/computation_job_inputs.py
index 039abb1..e9b8e91 100644
--- a/src/wpsremote/computation_job_inputs.py
+++ b/src/wpsremote/computation_job_inputs.py
@@ -4,35 +4,41 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+from collections import OrderedDict
+
+import computation_job_param
+import computation_job_const
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-from collections import OrderedDict
 
-import computation_job_param
-import computation_job_const
 class ComputationJobInputs(object):
     """Encapsulate a set of input parameters"""
 
     @staticmethod
     def create_from_config(input_sections):
-        '''Static constructor: 
-        create a ComputationJobInputs object from a input_sections: a dictionary such as { input1 : [( 'par1_input1_name' , par1_input1_value ), ( 'par2_input1_name' , par2_input1_value ), ...], input2 : [ .... ], ... }
+        '''Static constructor:
+        create a ComputationJobInputs object from a input_sections: a dictionary such as
+            { input1 : [( 'par1_input1_name' , par1_input1_value ), ( 'par2_input1_name' , par2_input1_value ), ...],
+              input2 : [ .... ], ... }
         '''
-        input_sections_reshaped=OrderedDict()
-        #force the order of sections in config files: [input1], [input2], etc
+        input_sections_reshaped = OrderedDict()
+        # force the order of sections in config files: [input1], [input2], etc
         for k in sorted(input_sections):
-            d=dict(input_sections[k])
+            d = dict(input_sections[k])
             name = d['name']
             del d['name']
             input_sections_reshaped[name] = d
-        return ComputationJobInputs.create_from_dict( input_sections_reshaped )
+        return ComputationJobInputs.create_from_dict(input_sections_reshaped)
 
     @staticmethod
     def create_from_dict(paremeters_types_defs):
-        '''Static constructor: 
-        create a ComputationJobInputs object from paremeters_types_defs: {par1_name : { 'par1_attrubute1_name' : par1_attrubute1_value, ... }, par2_name : { 'par2_attrubute1_name' : par2_attrubute1_value, ... }, ... }
+        '''Static constructor:
+        create a ComputationJobInputs object from paremeters_types_defs:
+            {par1_name : { 'par1_attrubute1_name' : par1_attrubute1_value, ... },
+             par2_name : { 'par2_attrubute1_name' : par2_attrubute1_value, ... }, ... }
         '''
         cji = ComputationJobInputs()
         input_to_add = None
@@ -45,15 +51,17 @@ def create_from_dict(paremeters_types_defs):
                     mininum = int(d['min']) if "min" in d else 1
                     maximum = int(d['max']) if "max" in d else 1
                     input_mime_type = d['input_mime_type'] if "input_mime_type" in d else None
-                    input_to_add = computation_job_param.ComputationJobParam(name, d['type'], title, d['description'], default, formatter, mininum, maximum, input_mime_type)
+                    input_to_add = computation_job_param.ComputationJobParam(
+    name, d['type'], title, d['description'], default, formatter, mininum, maximum, input_mime_type)
                 elif d['class'] == 'const':
                     title = d['title'] if "title" in d else None
-                    input_to_add = computation_job_const.ComputationJobConst(name, d['type'], title, d['description'], d['value'])
+                    input_to_add = computation_job_const.ComputationJobConst(
+                        name, d['type'], title, d['description'], d['value'])
                 else:
-                    raise TypeError("Unknown class value "+ str(d['class']) + " for input " + str(name))
+                    raise TypeError("Unknown class value " + str(d['class']) + " for input " + str(name))
             else:
                 raise TypeError("Cannot create computational job input without attribute class")
-            cji.add_input( input_to_add )
+            cji.add_input(input_to_add)
 
         return cji
 
@@ -67,16 +75,16 @@ def validate(self):
         pass
 
     def add_input(self, inputs):
-        if (type(inputs) is list):
-            self._inputs.update (dict( (v.get_name(), v) for v in inputs) )
+        if (isinstance(inputs, list)):
+            self._inputs.update(dict((v.get_name(), v) for v in inputs))
         else:
-            v=inputs
-            self._inputs[ v.get_name() ] = v
+            v = inputs
+            self._inputs[v.get_name()] = v
 
     def set_values(self, values):
         for name, val in values.items():
             if name in self._inputs:
-                self._inputs[name].set_value( val )
+                self._inputs[name].set_value(val)
 
     def values(self):
         for v in self._inputs.itervalues():
@@ -87,15 +95,15 @@ def names(self):
             yield k
 
     def __getitem__(self, k):
-        return self._inputs[k] 
+        return self._inputs[k]
 
     def as_DLR_protocol(self):
-        #[('result', '{"type": "string", ...ut.xml" }')]
+        # [('result', '{"type": "string", ...ut.xml" }')]
         res = []
         for k in self._inputs.keys():
-            if type(self._inputs[k]) is computation_job_const.ComputationJobConst:
+            if isinstance(self._inputs[k], computation_job_const.ComputationJobConst):
                 continue
             n = self._inputs[k].get_name()
             j = self._inputs[k].as_json_string()
-            res.append( (n,j) )
+            res.append((n, j))
         return res
diff --git a/src/wpsremote/computation_job_param.py b/src/wpsremote/computation_job_param.py
index b676cd0..4936ce8 100644
--- a/src/wpsremote/computation_job_param.py
+++ b/src/wpsremote/computation_job_param.py
@@ -4,15 +4,26 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import computation_job_input
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import computation_job_input
 
 class ComputationJobParam(computation_job_input.ComputationJobInput):
 
-    def __init__(self, name, input_type, title, descr, default=None, formatter=None, min_occurencies=0, max_occurencies=1, input_mime_type=None):
+    def __init__(
+    self,
+    name,
+    input_type,
+    title,
+    descr,
+    default=None,
+    formatter=None,
+    min_occurencies=0,
+    max_occurencies=1,
+     input_mime_type=None):
         super(ComputationJobParam, self).__init__(name, input_type, title, descr, default, formatter, input_mime_type)
         self._min = min_occurencies
         self._max = max_occurencies
@@ -21,8 +32,3 @@ def validate(self):
         if not (self._min <= len(self._value) and len(self._value) <= self._max):
             raise TypeError("Actual value for parameter has wrong multiplicity")
         return super(ComputationJobParam, self).validate()
-
-
-
-
-
diff --git a/src/wpsremote/computational_job_input_action.py b/src/wpsremote/computational_job_input_action.py
index 016485e..9ada47c 100644
--- a/src/wpsremote/computational_job_input_action.py
+++ b/src/wpsremote/computational_job_input_action.py
@@ -8,6 +8,7 @@
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
+
 class ComputationalJobInputAction(object):
 
     def __init__(self):
diff --git a/src/wpsremote/computational_job_input_action_cmd_param.py b/src/wpsremote/computational_job_input_action_cmd_param.py
index 50404af..3bfdf7a 100644
--- a/src/wpsremote/computational_job_input_action_cmd_param.py
+++ b/src/wpsremote/computational_job_input_action_cmd_param.py
@@ -4,34 +4,36 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import copy
+import computational_job_input_action
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import copy
-import computational_job_input_action
 
-class ComputationalJobInputActionCmdParam(computational_job_input_action.ComputationalJobInputAction): #computational_job_input_action.ComputationalJobInputAction
+class ComputationalJobInputActionCmdParam(
+        computational_job_input_action.ComputationalJobInputAction):
 
     def __init__(self, input_ref, template="--name=value", alias=None):
         super(ComputationalJobInputActionCmdParam, self).__init__()
-        #if not type(input_refs) is list:
+        # if not type(input_refs) is list:
         #    self._input_refs = [input_refs]
-        #else:
+        # else:
         self._input_ref = input_ref
         self._template = template
         self._cmdline = ""
         self._alias = alias
 
     def set_inputs(self, inputs):
-        #for varname in self._input_ref:
+        # for varname in self._input_ref:
         if self._input_ref in inputs.names():
-            self._cmdline += ' ' + self._instance_template( self._input_ref, inputs[self._input_ref].get_value_string() ) 
+            self._cmdline += ' ' + self._instance_template(self._input_ref, inputs[self._input_ref].get_value_string())
         self._cmdline = self._cmdline.strip()
 
     def _instance_template(self, name, value_str):
-        cmd=''
-        if self._alias!=None:
+        cmd = ''
+        if self._alias is not None:
             name = self._alias
         hasName = False
         hasValue = False
@@ -40,11 +42,11 @@ def _instance_template(self, name, value_str):
             template = template.replace("name", "%s")
             hasName = True
         if 'value' in self._template:
-            template =template.replace("value","%s")  
+            template = template.replace("value", "%s")
             hasValue = True
 
         if (hasName and hasValue):
-            cmd += template % (name, value_str) 
+            cmd += template % (name, value_str)
         elif hasName:
             cmd += template % (name)
         elif hasValue:
@@ -52,8 +54,7 @@ def _instance_template(self, name, value_str):
         else:
             raise Exception("Bad template for command line parameter " + name)
 
-        return cmd 
+        return cmd
 
     def get_cmd_line(self):
         return self._cmdline
-
diff --git a/src/wpsremote/computational_job_input_action_copyfile.py b/src/wpsremote/computational_job_input_action_copyfile.py
index 9fecc9e..77ffd8b 100644
--- a/src/wpsremote/computational_job_input_action_copyfile.py
+++ b/src/wpsremote/computational_job_input_action_copyfile.py
@@ -4,12 +4,13 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import path
+import computational_job_input_action
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import path
-import computational_job_input_action
 
 class ComputationalJobInputActionCopyFile(computational_job_input_action.ComputationalJobInputAction):
 
diff --git a/src/wpsremote/computational_job_input_action_create_json_file.py b/src/wpsremote/computational_job_input_action_create_json_file.py
index 15321d5..414703c 100644
--- a/src/wpsremote/computational_job_input_action_create_json_file.py
+++ b/src/wpsremote/computational_job_input_action_create_json_file.py
@@ -4,16 +4,17 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import json
 import path
 import computational_job_input_action
 import logging
 import jsonschema
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 class ComputationalJobInputActionCreateJSONFile(computational_job_input_action.ComputationalJobInputAction):
 
     def __init__(self, input_ref, json_filepath, json_path_expr=None, json_schema=None):
@@ -22,7 +23,9 @@ def __init__(self, input_ref, json_filepath, json_path_expr=None, json_schema=No
         self._json_filepath = json_filepath if isinstance(json_filepath, path.path) else path.path(json_filepath)
 
         # Python-like expression to access json data in memory.
-        # This value is used in case of multiple json file creation to enumerate the file names (e.g. outfile1.json, outfile2.json) using an id from the input json data
+        # This value is used in case of multiple json file creation to enumerate
+        # the file names (e.g. outfile1.json, outfile2.json) using an id from the
+        # input json data
         self._json_path_expr = json_path_expr
         self.json_files_created = []
 
@@ -31,30 +34,30 @@ def __init__(self, input_ref, json_filepath, json_path_expr=None, json_schema=No
         else:
             self._json_schema = json.loads(json_schema)
 
-
     def set_inputs(self, inputs):
-        #for par_name in self._input_refs:
+        # for par_name in self._input_refs:
         logger = logging.getLogger("ComputationalJobInputActionCreateJSONFile.set_inputs")
         logger.debug("start creating JSON file")
         if self._input_ref in inputs.names():
             text2write = inputs[self._input_ref].get_value()
-            if type(text2write) == list:
+            if isinstance(text2write, list):
                 logger.debug("a list of asset is given, iterate over json texts")
                 for single_json_text in text2write:
                     if self.validate_json(single_json_text):
                         self.create_json_file(single_json_text)
-            elif type(text2write) != list:
+            elif not isinstance(text2write, list):
                 logger.debug("only one json string is give, just write the file with the value of the json path expr")
                 if self.validate_json(text2write):
                     self.create_json_file(text2write)
             else:
-                msg="Cannot produce JSON file with current configuration and input in ComputationalJobInputActionCreateJSONFile"
+                msg = "Cannot produce JSON file with current configuration and input in \
+                    ComputationalJobInputActionCreateJSONFile"
                 logger.debug(msg)
                 raise Exception(msg)
 
     def validate_json(self, json_text):
         logger = logging.getLogger("ComputationalJobInputActionCreateJSONFile.validate_json")
-        if self._json_schema == None:
+        if self._json_schema is None:
             logger.warning("cannot validate json input against json schema")
             return True
         try:
@@ -67,16 +70,14 @@ def validate_json(self, json_text):
 
     def create_json_file(self, json_text):
         json_filepath = self._extract_id_from_json(json_text)
-        #json_filepath.write_text( json_text )
         fp = json_filepath.open('w')
-        json.dump( json_text, fp )
+        json.dump(json_text, fp)
         fp.close()
-        self.json_files_created.append( json_filepath )
-
+        self.json_files_created.append(json_filepath)
 
     def _extract_id_from_json(self, json_text):
-        if self._json_path_expr != None and self._json_path_expr != '':
-            _id = eval( "json_text" + self._json_path_expr )
+        if self._json_path_expr is not None and self._json_path_expr != '':
+            _id = eval("json_text" + self._json_path_expr)
             self._json_filepath = str(self._json_filepath).replace('${json_path_expr}', '%i')
             fp = self._json_filepath % _id
         else:
@@ -84,6 +85,6 @@ def _extract_id_from_json(self, json_text):
         return path.path(fp)
 
     def exists(self):
-        files_exists = map(lambda fp: fp.exists(),  self.json_files_created)
+        files_exists = map(lambda fp: fp.exists(), self.json_files_created)
         files_exists = list(set(files_exists))
-        return len(files_exists)==1 and files_exists[0]
+        return len(files_exists) == 1 and files_exists[0]
diff --git a/src/wpsremote/computational_job_input_action_update_ini_file.py b/src/wpsremote/computational_job_input_action_update_ini_file.py
index d69b20c..20a7f39 100644
--- a/src/wpsremote/computational_job_input_action_update_ini_file.py
+++ b/src/wpsremote/computational_job_input_action_update_ini_file.py
@@ -4,31 +4,31 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import ConfigParser
+import path
+
+import computational_job_input_action
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-#[Action8]
-#class = updateINIfile
-#input_ref = timeHorizon
-#source_filepath = wcsOAAonDemand_template.properties
-#target_filepath= %(workdir)s\wcsOAAonDemand.properties
-#section = DEFAULT
-#alias = time_horizont_days
+# [Action8]
+# class = updateINIfile
+# input_ref = timeHorizon
+# source_filepath = wcsOAAonDemand_template.properties
+# target_filepath= %(workdir)s\wcsOAAonDemand.properties
+# section = DEFAULT
+# alias = time_horizont_days
 
-import ConfigParser
-import path
-
-import computational_job_input_action
 
 class ComputationalJobInputActionUpdateINIFile(computational_job_input_action.ComputationalJobInputAction):
 
-
     def __init__(self, input_ref, source, target, section, alias=None):
         super(ComputationalJobInputActionUpdateINIFile, self).__init__()
-        #if not type(input_refs) is list:
+        # if not type(input_refs) is list:
         #    self._input_refs = [input_refs]
-        #else:
+        # else:
         self._input_ref = input_ref
         self._source = source if isinstance(source, path.path) else path.path(source)
         self._target = target if isinstance(target, path.path) else path.path(target)
@@ -36,35 +36,34 @@ def __init__(self, input_ref, source, target, section, alias=None):
         self._alias = alias
         self._value = None
 
-
     def set_inputs(self, inputs):
         if self._input_ref in inputs.names():
             self._value = inputs[self._input_ref].get_value()
-            if not self.exists() and self._source != None:
-                self._source.copyfile( self._target )
+            if not self.exists() and self._source is not None:
+                self._source.copyfile(self._target)
                 self.update_file(inputs)
-            elif not self.exists() and self._source == None:
-                raise Exception("Cannot find target INI file " + str(self._target) )
+            elif not self.exists() and self._source is None:
+                raise Exception("Cannot find target INI file " + str(self._target))
             else:
                 self.update_file(inputs)
 
     def update_file(self, inputs):
         srcINI = ConfigParser.RawConfigParser()
-        #read
+        # read
         src = self._target.open()
         srcINI.readfp(src)
         src.close()
 
-        #update
+        # update
         srcINI.set(self._section, self.get_attribute_name(), self._value)
-                
-        #write
+
+        # write
         trg = self._target.open('w')
-        srcINI.write( trg )
+        srcINI.write(trg)
         trg.close()
 
     def get_attribute_name(self):
-        return self._input_ref if self._alias==None else self._alias
+        return self._input_ref if self._alias is None else self._alias
 
     def exists(self):
         return self._target.exists()
@@ -72,26 +71,22 @@ def exists(self):
 
 class ComputationalJobInputActionUpdateINIFileAsList(ComputationalJobInputActionUpdateINIFile):
 
-
     def __init__(self, input_ref, source, target, section, alias=None):
         super(ComputationalJobInputActionUpdateINIFileAsList, self).__init__(input_ref, source, target, section, alias)
 
-
-
     def update_file(self, inputs):
         srcINI = ConfigParser.RawConfigParser()
-        #read
+        # read
         src = self._target.open()
         srcINI.readfp(src)
         src.close()
 
-        json_list_str = ",".join( [ '"' + str(token) + '"' for token in self._value.split(",")] )
+        json_list_str = ",".join(['"' + str(token) + '"' for token in self._value.split(",")])
 
-        #update
+        # update
         srcINI.set(self._section, self.get_attribute_name(), "[" + json_list_str + "]")
-                
-        #write
+
+        # write
         trg = self._target.open('w')
-        srcINI.write( trg )
+        srcINI.write(trg)
         trg.close()
-
diff --git a/src/wpsremote/computational_job_input_action_update_json_file.py b/src/wpsremote/computational_job_input_action_update_json_file.py
index 86a9d1c..03d1f5a 100644
--- a/src/wpsremote/computational_job_input_action_update_json_file.py
+++ b/src/wpsremote/computational_job_input_action_update_json_file.py
@@ -4,49 +4,49 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import json
 import path
 
 import computational_job_input_action
 
-class ComputationalJobInputActionUpdateJSONFile(computational_job_input_action.ComputationalJobInputAction):
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
 
 
+class ComputationalJobInputActionUpdateJSONFile(computational_job_input_action.ComputationalJobInputAction):
+
     def __init__(self, input_ref, target_json_file, json_path_expr, source_template_json_file):
         super(ComputationalJobInputActionUpdateJSONFile, self).__init__()
-        #if not type(input_refs) is list:
+        # if not type(input_refs) is list:
         #    self._input_refs = [input_refs]
-        #else:
+        # else:
         self._input_ref = input_ref
-        #file path that will be updated
-        #self._target_json_file = target_json_file
-        self._target_json_file = target_json_file if isinstance(target_json_file, path.path) else path.path(target_json_file)
+        # file path that will be updated
+        # self._target_json_file = target_json_file
+        self._target_json_file = target_json_file if isinstance(
+    target_json_file, path.path) else path.path(target_json_file)
         # Python-like expression to reference the attribute in the json file to be set
         self.jsonpath_expr = json_path_expr
         # If target file doesn't exists it will be created using the template at this file path
-        self._config_file_template = source_template_json_file if isinstance(source_template_json_file, path.path) else path.path(source_template_json_file)
-        
+        self._config_file_template = source_template_json_file if isinstance(
+    source_template_json_file, path.path) else path.path(source_template_json_file)
 
     def set_inputs(self, inputs):
         if self._input_ref in inputs.names():
-            if not self.exists() and self._config_file_template!= None:
-                self._config_file_template.copyfile( self._target_json_file )
+            if not self.exists() and self._config_file_template is not None:
+                self._config_file_template.copyfile(self._target_json_file)
                 self.update_file(inputs)
-            elif not self.exists() and self._config_file_template== None:
-                raise Exception("Cannot find target JSON file " + str(self._target_json_file) )
+            elif not self.exists() and self._config_file_template is None:
+                raise Exception("Cannot find target JSON file " + str(self._target_json_file))
             else:
                 self.update_file(inputs)
 
     def update_file(self, inputs):
         json_text = self._target_json_file.text()
-        j=json.loads(json_text)
-        exec( "j" + self.jsonpath_expr + "=" + str(  inputs[self._input_ref].get_value_as_JSON_literal() ) )
-        json.dump( j, self._target_json_file.open('w'), indent=4 )
+        j = json.loads(json_text)
+        exec("j" + self.jsonpath_expr + "=" + str(inputs[self._input_ref].get_value_as_JSON_literal()))
+        json.dump(j, self._target_json_file.open('w'), indent=4)
 
     def exists(self):
         return self._target_json_file.exists()
-
diff --git a/src/wpsremote/computational_job_input_actions.py b/src/wpsremote/computational_job_input_actions.py
index 9c44060..c2defd0 100644
--- a/src/wpsremote/computational_job_input_actions.py
+++ b/src/wpsremote/computational_job_input_actions.py
@@ -4,10 +4,6 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 from collections import OrderedDict
 import path
 
@@ -17,28 +13,35 @@
 import computational_job_input_action_copyfile
 import computational_job_input_action_update_ini_file
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 class ComputationalJobInputActions(object):
 
     @staticmethod
     def create_from_config(input_sections):
         '''Create a InputParameters object.
-
-        input_sections: a dictionary such as { action1 : [( 'par1_input1_name' , par1_input1_value ), ( 'par2_input1_name' , par2_input1_value ), ...], action2 : [ .... ], ... }
+        input_sections: a dictionary such as
+            { action1 : [( 'par1_input1_name' , par1_input1_value ),
+                         ( 'par2_input1_name' , par2_input1_value ), ...],
+              action2 : [ .... ], ...
+            }
         '''
-        input_sections_reshaped=OrderedDict()
-        #force the order of sections in config files: [action1], [action2], etc
+        input_sections_reshaped = OrderedDict()
+        # force the order of sections in config files: [action1], [action2], etc
         for k in sorted(input_sections):
-            d=dict(input_sections[k])
-            #input_ref = d['input_ref']
-            #del d['input_ref']
+            d = dict(input_sections[k])
             input_sections_reshaped[k] = d
-        return ComputationalJobInputActions.create_from_dict( input_sections_reshaped )
+        return ComputationalJobInputActions.create_from_dict(input_sections_reshaped)
 
     @staticmethod
     def create_from_dict(input_action_def_dict):
         '''Create a input parameters set from a definitions
-
-        paremeters_types_defs is a dictionary such as {input_ref1 : { 'action1_attrubute1_name' : action1_attrubute1_value, ... }, input_ref2 : { 'action2_attrubute1_name' : action2_attrubute1_value, ... }, ... }
+        paremeters_types_defs is a dictionary such as
+            {input_ref1 : { 'action1_attrubute1_name' : action1_attrubute1_value, ... },
+             input_ref2 : { 'action2_attrubute1_name' : action2_attrubute1_value, ... }, ... }
         '''
         cja = ComputationalJobInputActions()
         action2add = None
@@ -46,26 +49,38 @@ def create_from_dict(input_action_def_dict):
             if ('class' in d):
                 if d['class'] == 'cmdline':
                     alias = d['alias'] if "alias" in d else None
-                    action2add = computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam( d['input_ref'], d['template'], alias = alias ) 
+                    action2add = computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam(
+                        d['input_ref'], d['template'], alias=alias)
                 elif d['class'] == 'createJSONfile':
-                    #remove_if_exists = d['remove_if_exists'] if "remove_if_exists" in d else None
                     json_path_expr = d['json_path_expr'] if "json_path_expr" in d else None
-                    action2add = computational_job_input_action_create_json_file.ComputationalJobInputActionCreateJSONFile(d['input_ref'], d['target_filepath'], json_path_expr, path.path(d['json_schema']) )
+                    action2add = computational_job_input_action_create_json_file.\
+                        ComputationalJobInputActionCreateJSONFile(
+                            d['input_ref'], d['target_filepath'], json_path_expr, path.path(d['json_schema']))
                 elif d['class'] == 'updateJSONfile':
-                    action2add = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile(  d['input_ref'], d['target_filepath'], d['json_path_expr'], d['source_filepath'] )
+                    action2add = computational_job_input_action_update_json_file.\
+                        ComputationalJobInputActionUpdateJSONFile(
+                            d['input_ref'], d['target_filepath'], d['json_path_expr'], d['source_filepath'])
                 elif d['class'] == 'copyfile':
-                    action2add = computational_job_input_action_copyfile.ComputationalJobInputActionCopyFile( d['source_filepath'], d['target_filepath'] )
+                    action2add = computational_job_input_action_copyfile.\
+                        ComputationalJobInputActionCopyFile(
+                            d['source_filepath'], d['target_filepath'])
                 elif d['class'] == 'updateINIfile':
                     alias = d['alias'] if "alias" in d else None
-                    action2add = computational_job_input_action_update_ini_file.ComputationalJobInputActionUpdateINIFile( d['input_ref'], d['source_filepath'], d['target_filepath'], d['section'], alias)
+                    action2add = computational_job_input_action_update_ini_file.\
+                        ComputationalJobInputActionUpdateINIFile(
+                            d['input_ref'], d['source_filepath'], d['target_filepath'], d['section'], alias)
                 elif d['class'] == 'updateINIfileList':
                     alias = d['alias'] if "alias" in d else None
-                    action2add = computational_job_input_action_update_ini_file.ComputationalJobInputActionUpdateINIFileAsList( d['input_ref'], d['source_filepath'], d['target_filepath'], d['section'], alias)
+                    action2add = computational_job_input_action_update_ini_file.\
+                        ComputationalJobInputActionUpdateINIFileAsList(
+                            d['input_ref'], d['source_filepath'], d['target_filepath'], d['section'], alias)
                 else:
-                    raise TypeError("Unknown class value "+ str(d['class']) + " for action related to input " + str(d['input_ref']))
+                    raise TypeError("Unknown class value " + str(d['class']) +
+                                    " for action related to input " + str(d['input_ref']))
             else:
-                raise TypeError("Cannot create computational job action related to input " + str(d['input_ref']) + " without attribute class")
-            cja.add_actions( action2add )
+                raise TypeError("Cannot create computational job action related to input " +
+                                str(d['input_ref']) + " without attribute class")
+            cja.add_actions(action2add)
         return cja
 
     def __init__(self):
@@ -81,7 +96,7 @@ def get_cmd_line(self):
 
     def execute(self, input_values):
         for a in self._actions:
-            a.set_inputs( input_values )
+            a.set_inputs(input_values)
 
     def add_actions(self, a):
         self._actions.append(a)
diff --git a/src/wpsremote/configInstance.py b/src/wpsremote/configInstance.py
index 3a3f291..847e8ed 100644
--- a/src/wpsremote/configInstance.py
+++ b/src/wpsremote/configInstance.py
@@ -4,43 +4,45 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import ConfigParser
 import path
 import types
 from string import strip
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 def create(filePath, moreSerchPath=[], variables={}, raw=False, case_sensitive=False):
 
     config = ConfigParser.ConfigParser(allow_no_value=raw, defaults=variables)
 
-    #force config lookup paramters to be to case sensitive
+    # force config lookup paramters to be to case sensitive
     if case_sensitive:
         config.optionxform = lambda option: option
-    fp=open(filePath)
-    config.readfp( fp  )
+    fp = open(filePath)
+    config.readfp(fp)
     fp.close()
 
-    config.items_without_defaults = types.MethodType(items_without_defaults,config)
+    config.items_without_defaults = types.MethodType(items_without_defaults, config)
     config.get_list = types.MethodType(get_list_impl, config)
     config.get_list_list = types.MethodType(get_list_list_impl, config)
     config.get_list_int = types.MethodType(get_list_int_impl, config)
     config.get_list_float = types.MethodType(get_list_float_impl, config)
-    config.get_password =  types.MethodType(get_password, config)
-    config.get_path =  types.MethodType(get_path, config)
+    config.get_password = types.MethodType(get_password, config)
+    config.get_path = types.MethodType(get_path, config)
     config.get_list_path = types.MethodType(get_list_path_impl, config)
     return config
 
+
 def items_without_defaults(target, section_name, raw=False):
-    #return [s for s in target.items(section_name, raw=raw) if not s[0] in target.defaults().keys()]
-    res=[]
+    # return [s for s in target.items(section_name, raw=raw) if not s[0] in target.defaults().keys()]
+    res = []
     default_section_items = dict(target.items('DEFAULT', raw=raw))
-    for s in target.items(section_name, raw=raw) :
-        if s[0] in target.defaults().keys(): #same name in defaults+section_name and defaults
-            if s[1] == default_section_items[s[0]]: #same value defaults+section_name and defaults
+    for s in target.items(section_name, raw=raw):
+        if s[0] in target.defaults().keys():  # same name in defaults+section_name and defaults
+            if s[1] == default_section_items[s[0]]:  # same value defaults+section_name and defaults
                 pass
             else:
                 res.append(s)
@@ -50,64 +52,69 @@ def items_without_defaults(target, section_name, raw=False):
 
 
 def get_list_impl(target, section, itemname):
-    v=target.get(section, itemname)
-    if (v==None or v==''):
+    v = target.get(section, itemname)
+    if (v is None or v == ''):
         return None
     v = v.strip()
     v = v[1:-1]
     t = v.split(",")
     return map(strip, t)
 
+
 def get_list_list_impl(target, section, itemname):
     l1 = get_list_impl(target, section, itemname)
-    res=[]
+    res = []
     for el in l1:
-        tmp=el.split("|")
-        res.append ( map(strip, tmp) )
+        tmp = el.split("|")
+        res.append(map(strip, tmp))
     return res
 
 
 def get_list_int_impl(target, section, itemname):
-    v=target.get(section, itemname)
-    if (v==None or v==''):
+    v = target.get(section, itemname)
+    if (v is None or v == ''):
         return None
     v = v.strip()
     v = v[1:-1]
     t = v.split(",")
-    res=map(strip, t)
-    return map(int,res)
+    res = map(strip, t)
+    return map(int, res)
+
 
 def get_list_float_impl(target, section, itemname):
-    v=target.get(section, itemname)
-    if (v==None or v==''):
+    v = target.get(section, itemname)
+    if (v is None or v == ''):
         return None
     v = v.strip()
     v = v[1:-1]
     t = v.split(",")
-    res=map(strip, t)
-    return map(float,res)
+    res = map(strip, t)
+    return map(float, res)
+
 
 def get_list_path_impl(target, section, itemname):
-    v=target.get(section, itemname)
-    if (v==None or v==''):
+    v = target.get(section, itemname)
+    if (v is None or v == ''):
         return None
     v = v.strip()
     v = v[1:-1]
     t = v.split(",")
-    res=map(strip, t)
-    return map(path.path,res)
+    res = map(strip, t)
+    return map(path.path, res)
+
 
 def get_password(target, section, itemname):
-    psw=target.get(section, itemname)
-    if (psw==None):
+    psw = target.get(section, itemname)
+    if (psw is None):
         return None
-    if psw=="ask":
+    if psw == "ask":
         import getpass
         psw = getpass.getpass("insert password:")
     return psw
 
+
 def get_path(target, section, itemname):
-    p=target.get(section, itemname)
-    if (p==None):
+    p = target.get(section, itemname)
+    if (p is None):
         return None
     return path.path(p)
diff --git a/src/wpsremote/config_file_parameter.py b/src/wpsremote/config_file_parameter.py
index db0488d..eeb7f1e 100644
--- a/src/wpsremote/config_file_parameter.py
+++ b/src/wpsremote/config_file_parameter.py
@@ -4,23 +4,18 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import path
+import input_parameter
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import json
-import string
-
-import path
-
-import input_parameters
-import input_parameter
-
 
 class ConfigFileParameter(input_parameter.InputParameter):
-    def __init__(self, name): 
+    def __init__(self, name):
         input_parameter.InputParameter.__init__(self, name)
-        self._filepath=None
+        self._filepath = None
 
     def inject_values(self, paremeters_types_defs):
         super(ConfigFileParameter, self).inject_values(paremeters_types_defs)
@@ -30,6 +25,6 @@ def get_cmd_line(self):
         self.update_file()
         return ' '
 
-    #todo: rename to write file
+    # todo: rename to write file
     def update_file(self):
         pass
diff --git a/src/wpsremote/config_file_parameter_cmre_oaa.py b/src/wpsremote/config_file_parameter_cmre_oaa.py
index 89314dc..98808f4 100644
--- a/src/wpsremote/config_file_parameter_cmre_oaa.py
+++ b/src/wpsremote/config_file_parameter_cmre_oaa.py
@@ -4,20 +4,20 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
-"""todo: move this module out of  the project in cmre dedicated section"""
 import json
 import unittest
-import datetime
-
 import path
 
 import config_file_parameter
 import input_parameters
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+"""todo: move this module out of  the project in cmre dedicated section"""
+
+
 class CMREOAA_AssetConfigFile(config_file_parameter.ConfigFileParameter):
 
     shrot_name = "OAAAssetFile"
@@ -30,17 +30,16 @@ def _get_file_path(self, id):
         return path.path(self._filepath.replace(self._template_file_path, str(id)))
 
     def update_file(self):
-        asset_id=0
+        asset_id = 0
         for v in self._value:
-            asset_json=json.loads(v)
+            asset_json = json.loads(v)
             asset_id = int(asset_json['Asset']['id'])
-            asset_file= self._get_file_path(asset_id)
-            #asset_file.write_text( v )
+            asset_file = self._get_file_path(asset_id)
+            # asset_file.write_text( v )
             with asset_file.open('wb') as outfile:
                 json.dump(asset_json, outfile, indent=4)
 
 
-
 class CMREOAA_MainConfigFile(config_file_parameter.ConfigFileParameter):
 
     shrot_name = "OAAConfigFile"
@@ -53,84 +52,89 @@ def inject_values(self, paremeters_types_defs):
         super(CMREOAA_MainConfigFile, self).inject_values(paremeters_types_defs)
         if (self._filepath.exists()):
             self._filepath.remove()
-      
 
     def update_file(self):
-        #if target files exists open it and update, if doesnt exists load the template, modify it and save to target (it is useful for multiple update on the same file)        
+        # if target files exists open it and update, if doesnt exists load the
+        # template, modify it and save to target (it is useful for multiple update
+        # on the same file)
         if (self._filepath.exists()):
             template = json.load(self._filepath.open())
         else:
             template = json.load(self._config_file_template.open())
 
-
         if (self.get_name() == 'timeHorizon'):
             template['Config']['timeHorizon'] = int(self._value[0])
 
         elif (self.get_name() == 'nEvaluations'):
             template['Config']['nEvaluations'] = int(self._value[0])
         else:
-            pass #todo: log "Cannot write input pararmeter " + name + " in config file " + str( self._config_file_path )
+            # todo: log "Cannot write input pararmeter " + name + " in config file " + str( self._config_file_path )
+            pass
 
         with self._filepath.open('wb') as outfile:
             json.dump(template, outfile, indent=4)
 
 
-
-
 class Test(unittest.TestCase):
 
     def test_asset_config_object(self):
 
-        a1=path.path("d:\\tmp\\asset_1.json")
-        a2=path.path("d:\\tmp\\asset_2.json")
+        a1 = path.path("d:\\tmp\\asset_1.json")
+        a2 = path.path("d:\\tmp\\asset_2.json")
 
         if a1.exists():
             a1.remove()
         if a2.exists():
             a2.remove()
 
-        paramsDef = [('assets' , {"type": "application/json",  "description": "Assets config", "max": 10, "filepath" : "d:\\tmp\\asset_$i.json", "template_file_path" : "$i", "class" : "config_file_parameter_cmre_oaa.CMREOAA_AssetConfigFile"} ) ]
+        paramsDef = [('assets',
+                      {"type": "application/json",
+                       "description": "Assets config",
+                       "max": 10,
+                       "filepath": "d:\\tmp\\asset_$i.json",
+                       "template_file_path": "$i",
+                       "class": "config_file_parameter_cmre_oaa.CMREOAA_AssetConfigFile"})]
 
         paramValue = {'assets': ['''{
             "Asset": {
-                "Pfa": 0.001, 
-                "maxSpeed": 10, 
-                "minSpeed": 2, 
-                "maxHeading": 2.1, 
-                "minHeading": -2.1, 
-                "lat0": 12.08, 
-                "cost": 1e-06, 
-                "obsRange": 50000, 
-                "heading0": 0, 
-                "lon0": 63.17, 
-                "type": "Frigate", 
-                "id": 1, 
-                "Pd": 0.6, 
+                "Pfa": 0.001,
+                "maxSpeed": 10,
+                "minSpeed": 2,
+                "maxHeading": 2.1,
+                "minHeading": -2.1,
+                "lat0": 12.08,
+                "cost": 1e-06,
+                "obsRange": 50000,
+                "heading0": 0,
+                "lon0": 63.17,
+                "type": "Frigate",
+                "id": 1,
+                "Pd": 0.6,
                 "name": "Ship 1"
             }
         }''', '''{
             "Asset": {
-                "Pfa": 0.001, 
-                "maxSpeed": 10, 
-                "minSpeed": 2, 
-                "maxHeading": 2.1, 
-                "minHeading": -2.1, 
-                "lat0": 13.66, 
-                "cost": 1e-06, 
-                "obsRange": 50000, 
-                "heading0": 0, 
-                "lon0": 58.9, 
-                "type": "Frigate", 
-                "id": 2, 
-                "Pd": 0.6, 
+                "Pfa": 0.001,
+                "maxSpeed": 10,
+                "minSpeed": 2,
+                "maxHeading": 2.1,
+                "minHeading": -2.1,
+                "lat0": 13.66,
+                "cost": 1e-06,
+                "obsRange": 50000,
+                "heading0": 0,
+                "lon0": 58.9,
+                "type": "Frigate",
+                "id": 2,
+                "Pd": 0.6,
                 "name": "Ship 2"
             }
-        }'''], 
-        'numberOfEvaluations': 600, 'timeHorizont': 259200}
+        }'''],
+                      'numberOfEvaluations': 600, 'timeHorizont': 259200}
 
         pip = input_parameters.InputParameters(paramsDef)
-        pip.parse( paramValue )
-        
+        pip.parse(paramValue)
+
         res = pip.get_cmd_line()
 
         self.assertEquals(res.strip(), "")
@@ -139,37 +143,59 @@ def test_asset_config_object(self):
         self.assertTrue(a2.exists())
 
     def test_OAA_main_config_file(self):
-        a1=path.path("d:\\tmp\\oaa_config.json")
+        a1 = path.path("d:\\tmp\\oaa_config.json")
 
         if a1.exists():
             a1.remove()
 
-
-        paramsDef = [
-            ('numberOfEvaluations',   {"type": "int", "description": "number of optimizer iterations", "max": 1,  "alias" : "nEvaluations", "class" : "config_file_parameter_cmre_oaa.CMREOAA_MainConfigFile", "filepath" : "d:\\tmp\\oaa_config.json" }), 
-            ('referenceDate',         {"type": "datetime", "description": "start date of optimizer", "max": 1, "alias" : "refDate", "formatter" : "%Y%m%d", "class" : "config_file_parameter_cmre_oaa.CMREOAA_MainConfigFile", "filepath" : "d:\\tmp\\oaa_config.json" }), 
-            ('timeHorizon',           {"type": "int", "description": "Time horizon in seconds of the optimizer", "max": 1, "class" : "config_file_parameter_cmre_oaa.CMREOAA_MainConfigFile", "filepath" : "d:\\tmp\\oaa_config.json" }),
-            ('executiontType',        {"type": "string", "description": "etl execution type", "max": 1, "template" : "value"})
-        ]
-
-        paramValue = {'argx' : 'test' }
-        paramValue = { 'numberOfEvaluations': 600, 'referenceDate' : '20140901', 'timeHorizon': 259200, 'executiontType' : 'oaaOnDemand' }
+        paramsDef = [('numberOfEvaluations',
+                      {"type": "int",
+                       "description": "number of optimizer iterations",
+                       "max": 1,
+                       "alias": "nEvaluations",
+                       "class": "config_file_parameter_cmre_oaa.CMREOAA_MainConfigFile",
+                       "filepath": "d:\\tmp\\oaa_config.json"}),
+                     ('referenceDate',
+                      {"type": "datetime",
+                       "description": "start date of optimizer",
+                       "max": 1,
+                       "alias": "refDate",
+                       "formatter": "%Y%m%d",
+                       "class": "config_file_parameter_cmre_oaa.CMREOAA_MainConfigFile",
+                       "filepath": "d:\\tmp\\oaa_config.json"}),
+                     ('timeHorizon',
+                      {"type": "int",
+                       "description": "Time horizon in seconds of the optimizer",
+                       "max": 1,
+                       "class": "config_file_parameter_cmre_oaa.CMREOAA_MainConfigFile",
+                       "filepath": "d:\\tmp\\oaa_config.json"}),
+                     ('executiontType',
+                      {"type": "string",
+                       "description": "etl execution type",
+                       "max": 1,
+                       "template": "value"})]
+
+        paramValue = {'argx': 'test'}
+        paramValue = {
+    'numberOfEvaluations': 600,
+    'referenceDate': '20140901',
+    'timeHorizon': 259200,
+     'executiontType': 'oaaOnDemand'}
 
         pip = input_parameters.InputParameters(paramsDef)
-        pip.parse( paramValue )
-        
-        res = pip.get_cmd_line()
+        pip.parse(paramValue)
 
+        res = pip.get_cmd_line()
 
-        self.assertEquals(res.strip(), "--referencedate==20140901 oaaOnDemand" )
+        self.assertEquals(res.strip(), "--referencedate==20140901 oaaOnDemand")
 
-        self.assertTrue( a1.exists() )
+        self.assertTrue(a1.exists())
 
-        configs  = json.load( a1.open() )
+        configs = json.load(a1.open())
         self.assertEqual(configs['Config']['nEvaluations'], 600)
         self.assertEqual(configs['Config']['refDate'], '2014-09-01T00:00:00Z')
         self.assertEqual(configs['Config']['timeHorizon'], 259200)
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/src/wpsremote/decryptor.py b/src/wpsremote/decryptor.py
index 4f01d0a..dda825c 100644
--- a/src/wpsremote/decryptor.py
+++ b/src/wpsremote/decryptor.py
@@ -1,9 +1,10 @@
-from Crypto.PublicKey import RSA
-from Crypto.Signature import PKCS1_v1_5
-from Crypto.Hash import SHA
+from Crypto.PublicKey import RSA  # noqa
+from Crypto.Signature import PKCS1_v1_5  # noqa
+from Crypto.Hash import SHA  # noqa
 import base64
 import sys
 
+
 def decrypt(message, externKey, passphrase):
     privatekey = open(externKey, "r")
     rsa_key = RSA.importKey(privatekey, passphrase=passphrase)
@@ -12,6 +13,7 @@ def decrypt(message, externKey, passphrase):
     decriptedData = rsa_key.decrypt(base64.b64decode(message))
     print(decriptedData)
 
+
 if __name__ == "__main__":
     if len(sys.argv) == 4:
         decrypt(sys.argv[1], sys.argv[2], sys.argv[3])
diff --git a/src/wpsremote/encryptor.py b/src/wpsremote/encryptor.py
index af9ea3e..69f7f3b 100644
--- a/src/wpsremote/encryptor.py
+++ b/src/wpsremote/encryptor.py
@@ -1,9 +1,10 @@
-from Crypto.PublicKey import RSA
-from Crypto.Signature import PKCS1_v1_5
-from Crypto.Hash import SHA
+from Crypto.PublicKey import RSA  # noqa
+from Crypto.Signature import PKCS1_v1_5  # noqa
+from Crypto.Hash import SHA  # noqa
 import base64
 import sys
 
+
 def encrypt(message, externKey, passphrase):
     publickey = open(externKey, "r")
     rsa_key = RSA.importKey(publickey, passphrase=passphrase)
@@ -12,6 +13,7 @@ def encrypt(message, externKey, passphrase):
     encriptedData = rsa_key.encrypt(message, 0)
     print(base64.b64encode(encriptedData[0]))
 
+
 if __name__ == "__main__":
     if len(sys.argv) == 4:
         encrypt(sys.argv[1], sys.argv[2], sys.argv[3])
diff --git a/src/wpsremote/ftpUpload.py b/src/wpsremote/ftpUpload.py
index d42b4d3..97a3710 100644
--- a/src/wpsremote/ftpUpload.py
+++ b/src/wpsremote/ftpUpload.py
@@ -4,6 +4,15 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import ftplib
+import pickle
+import md5
+import os
+import string
+import logging      # if not std, http://www.red-dove.com/python_logging.html
+import path         # http://www.jorendorff.com/articles/python/path
+import upload
+
 __author__ = "Ned Batchelder"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
@@ -22,11 +31,6 @@
    Alessio Fabiani, GeoSolutions S.A.S.
 """
 
-import ftplib, pickle, sys, md5, os, string
-import logging      # if not std, http://www.red-dove.com/python_logging.html
-import path         # http://www.jorendorff.com/articles/python/path
-import upload
-
 
 class EzFtp:
     """
@@ -35,6 +39,7 @@ class EzFtp:
     Lets you use full pathnames, with server-side
     directory management handled automatically.
     """
+
     def __init__(self, ftp):
         self.ftp = ftp
         self.serverDir = ''
@@ -66,7 +71,7 @@ def cd(self, dir, create=1):
                     try:
                         logging.info("ftpcd %s" % d)
                         self.ftp.cwd(d)
-                    except:
+                    except BaseException:
                         if create:
                             logging.info("ftpmkdir %s" % d)
                             self.ftp.mkd(d)
@@ -85,8 +90,8 @@ def putasc(self, this, that):
         f = open(this, "r")
         logging.info("ftpstorasc %s" % that)
         try:
-            self.ftp.storlines("STOR %s" % (thatFile),f)
-        except Exception, e:
+            self.ftp.storlines("STOR %s" % (thatFile), f)
+        except Exception as e:
             logging.exception(e)
             raise
 
@@ -100,7 +105,7 @@ def putbin(self, this, that):
         logging.info("ftpstorbin %s" % that)
         try:
             self.ftp.storbinary("STOR %s" % (thatFile), f, 1024)
-        except Exception, e:
+        except Exception as e:
             logging.exception(e)
             raise
 
@@ -113,7 +118,7 @@ def delete(self, that):
             logging.info("ftpdel %s" % that)
             try:
                 self.ftp.delete(thatFile)
-            except:
+            except BaseException:
                 pass
 
     def quit(self):
@@ -169,7 +174,7 @@ def setHost(self, host, username, password):
         if not self.ftp:
             try:
                 hoststr, portstr = host.split(':')
-            except:
+            except BaseException:
                 hoststr = host
                 portstr = None
             self.ftp = ftplib.FTP()
@@ -287,4 +292,3 @@ def finish(self):
             outf = open(self.md5file, "w")
             pickle.dump(self.md5DictUp, outf)
             outf.close()
-
diff --git a/src/wpsremote/ftpsUpload.py b/src/wpsremote/ftpsUpload.py
index a5f278d..1f4ecde 100644
--- a/src/wpsremote/ftpsUpload.py
+++ b/src/wpsremote/ftpsUpload.py
@@ -4,6 +4,11 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import ftpUpload
+import ftplib
+import ssl
+import upload
+
 __author__ = "Ned Batchelder"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
@@ -22,11 +27,7 @@
    Alessio Fabiani, GeoSolutions S.A.S.
 """
 
-import ftpUpload
-import ftplib, socket, ssl, pickle, sys, md5, os, string
-import logging      # if not std, http://www.red-dove.com/python_logging.html
-import path         # http://www.jorendorff.com/articles/python/path
-import upload
+CRLF = "\n\r"
 
 
 class tyFTP(ftplib.FTP_TLS):
@@ -84,11 +85,13 @@ def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None):
         self.voidcmd('TYPE I')
         conn = self.transfercmd(cmd, rest)
         try:
-            while 1:
+            while True:
                 buf = fp.read(blocksize)
-                if not buf: break
+                if not buf:
+                    break
                 conn.sendall(buf)
-                if callback: callback(buf)
+                if callback:
+                    callback(buf)
             # shutdown ssl layer
             if isinstance(conn, ssl.SSLSocket):
                 conn.unwrap()
@@ -100,22 +103,25 @@ def storlines(self, cmd, fp, callback=None):
         self.voidcmd('TYPE A')
         conn = self.transfercmd(cmd)
         try:
-            while 1:
+            while True:
                 buf = fp.readline(self.maxline + 1)
                 if len(buf) > self.maxline:
-                    raise Error("got more than %d bytes" % self.maxline)
-                if not buf: break
+                    raise Exception("got more than %d bytes" % self.maxline)
+                if not buf:
+                    break
                 if buf[-2:] != CRLF:
-                    if buf[-1] in CRLF: buf = buf[:-1]
+                    if buf[-1] in CRLF:
+                        buf = buf[:-1]
                     buf = buf + CRLF
                 conn.sendall(buf)
-                if callback: callback(buf)
+                if callback:
+                    callback(buf)
             # shutdown ssl layer
             if isinstance(conn, ssl.SSLSocket):
                 conn.unwrap()
         finally:
             conn.close()
-        return self.voidresp()    
+        return self.voidresp()
 
 
 class FtpsUpload(ftpUpload.FtpUpload):
@@ -164,7 +170,7 @@ def setHost(self, host, username, password):
         if not self.ftp:
             try:
                 hoststr, portstr = host.split(':')
-            except:
+            except BaseException:
                 hoststr = host
                 portstr = None
             self.ftp = tyFTP(timeout=60)
@@ -174,7 +180,8 @@ def setHost(self, host, username, password):
                 self.ftp.connect(hoststr, port)
             else:
                 self.ftp.connect(hoststr, 22)
-            # switch to secure data connection.. IMPORTANT! Otherwise, only the user and password is encrypted and not all the file data.
+            # switch to secure data connection.. IMPORTANT! Otherwise, only the user
+            # and password is encrypted and not all the file data.
             self.ftp.auth()
             self.ftp.login(username, password)
             self.ftp.prot_p()
diff --git a/src/wpsremote/input_parameter.py b/src/wpsremote/input_parameter.py
index c05ab0e..6fb7840 100644
--- a/src/wpsremote/input_parameter.py
+++ b/src/wpsremote/input_parameter.py
@@ -4,72 +4,73 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import string
+import datetime
+import json
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import string
-import datetime
-import json
 
 class InputParameter(object):
 
     def __init__(self, name):
-        self._name=name
-        self._alias=None
-        self._type=None
-        self._title=None
+        self._name = name
+        self._alias = None
+        self._type = None
+        self._title = None
         self._description = None
-        self._min=0
-        self._max=1
+        self._min = 0
+        self._max = 1
         self._default = None
         self._formatter = None
         self._input_mime_type = None
-        self._allowed_chars = string.printable.replace('-','').replace(' ','')
+        self._allowed_chars = string.printable.replace('-', '').replace(' ', '')
 
-        self._value=None
+        self._value = None
 
     def inject_values(self, paremeters_types_defs):
-        #override defaults with actual values
-        for k,v in paremeters_types_defs.items():
+        # override defaults with actual values
+        for k, v in paremeters_types_defs.items():
             if hasattr(self, "_" + k):
                 setattr(self, "_" + k, v)
 
-        self._min=int(self._min)
-        self._max=int(self._max)
+        self._min = int(self._min)
+        self._max = int(self._max)
 
     def set_actual_value(self, value):
-        if type(value) is not list:
+        if not isinstance(value, list):
             self._value = [value]
         else:
             self._value = value
 
-    def has_value(self):    
-        return self._value <> None
+    def has_value(self):
+        return self._value is not None
 
     def get_value(self):
         return self._value
 
     def _type_checking(self, value):
         try:
-            if (self._type=='int'):
+            if (self._type == 'int'):
                 int(value)
                 return self._type
-            elif (self._type=='float'):
+            elif (self._type == 'float'):
                 float(value)
                 return self._type
-            elif (self._type=='string'):
-                return all(c in  self._allowed_chars for c in value)
-            elif (self._type=='datetime' and self._formatter!=None):
-                #to check
+            elif (self._type == 'string'):
+                return all(c in self._allowed_chars for c in value)
+            elif (self._type == 'datetime' and self._formatter is not None):
+                # to check
                 datetime.datetime.strptime(value, self._formatter)
                 return self._type
-            elif (self._type=='application/json'):
+            elif (self._type == 'application/json'):
                 json.loads(value)
                 return self._type
             else:
-                return False        
-        except:
+                return False
+        except BaseException:
             return False
 
     def validate(self):
@@ -80,17 +81,17 @@ def validate(self):
             raise Exception("Actual value for parameter has wrong multiplicity")
 
         res = map(self._type_checking, self._value)
-        #remove duplicates
+        # remove duplicates
         res = list(set(res))
 
-        #if res has one element equal to True means all items in the list passed type checking
-        if (len(res)==1 and res[0]):
+        # if res has one element equal to True means all items in the list passed type checking
+        if (len(res) == 1 and res[0]):
             return True
         else:
             raise Exception("Bad type")
 
     def get_name(self):
-        return self._alias if self._alias <> None else self._name
+        return self._alias if self._alias is not None else self._name
 
     def get_input_mime_type(self):
         return self._input_mime_type
@@ -102,8 +103,8 @@ def get_cmd_line(self):
         pass
 
     def as_json_string(self):
-        #{"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
-        res={}
+        # {"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
+        res = {}
         attrib_to_convert = ['_type', '_title', '_description', '_min', '_max', '_default', '_input_mime_type']
         attribute_list = [a for a in dir(self) if not a.startswith('__') and not callable(getattr(self, a))]
         attribute_list_filtered = [x for x in attribute_list if x in attrib_to_convert]
diff --git a/src/wpsremote/input_parameters.py b/src/wpsremote/input_parameters.py
index f6e7caa..1d7c928 100644
--- a/src/wpsremote/input_parameters.py
+++ b/src/wpsremote/input_parameters.py
@@ -4,95 +4,101 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import introspection
 from collections import OrderedDict
 
 import command_line_parameter
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 class InputParameters(object):
 
-        @staticmethod
-        def create_from_config(input_sections):
-            '''Create a InputParameters object.
+    @staticmethod
+    def create_from_config(input_sections):
+        '''Create a InputParameters object.
+        input_sections: a dictionary such as
+            { input1 : [( 'par1_input1_name' , par1_input1_value ), ( 'par2_input1_name' , par2_input1_value ), ...],
+              input2 : [ .... ], ... }
+        '''
+        input_sections_reshaped = OrderedDict()
+        # force the order of sections in config files: [input1], [input2], etc
+        for k in sorted(input_sections):
+            d = dict(input_sections[k])
+            name = d['name']
+            del d['name']
+            input_sections_reshaped[name] = d
+        return InputParameters(input_sections_reshaped)
 
-            input_sections: a dictionary such as { input1 : [( 'par1_input1_name' , par1_input1_value ), ( 'par2_input1_name' , par2_input1_value ), ...], input2 : [ .... ], ... }
-            '''
-            input_sections_reshaped = OrderedDict()
-            #force the order of sections in config files: [input1], [input2], etc
-            for k in sorted(input_sections):
-                d=dict(input_sections[k])
-                name = d['name']
-                del d['name']
-                input_sections_reshaped[name] = d
-            return InputParameters( input_sections_reshaped )
+    def __init__(self, paremeters_types_defs):
+        '''Create a input parameters set from a definitions
+        paremeters_types_defs is a dictionary such as
+            {par1_name : { 'par1_attrubute1_name' : par1_attrubute1_value, ... },
+             par2_name : { 'par2_attrubute1_name' : par2_attrubute1_value, ... }, ... }
+        '''
+        self._params = OrderedDict()
 
-        def __init__(self, paremeters_types_defs):
-            '''Create a input parameters set from a definitions
+        for name, d in OrderedDict(paremeters_types_defs).items():
+            if ('class' in d):
+                try:
+                    self._params[name] = introspection.get_class_one_arg(d['class'], name)
+                except BaseException:
+                    raise  # log("Cannot create parameter object from class name "+d['class']+" for parameter " + name)
+            else:
+                self._params[name] = command_line_parameter.CommandLineParameter(name)
+            self._params[name].inject_values(d)
 
-            paremeters_types_defs is a dictionary such as {par1_name : { 'par1_attrubute1_name' : par1_attrubute1_value, ... }, par2_name : { 'par2_attrubute1_name' : par2_attrubute1_value, ... }, ... }
-            '''
-            self._params = OrderedDict()
+    def parse(self, input_variables=None):
+        """
+        if input_variables is None all params are of type CommandLineParameterConst
+        and input data is read from config file
+        """
+        for n, v in input_variables.items():
+            if n in self._params.keys():
+                self._params[n].set_actual_value(v)
+            else:
+                pass  # todo: log "received unknown input parameter " + n
+        self.validate()
 
-            for name, d in OrderedDict(paremeters_types_defs).items():
-                if ('class' in d):
-                    try:
-                        self._params[name] = introspection.get_class_one_arg( d['class'], name )
-                    except:
-                        raise #log("Cannot create parameter object from class name "+d['class']+" for parameter " + name)
-                else:
-                    self._params[name] = command_line_parameter.CommandLineParameter(name)
-                self._params[name].inject_values( d ) 
+    def validate(self):
+        for k in self._params.keys():
+            self._params[k].validate()
 
-        def parse(self, input_variables=None):
-            """if input_variables is None all params are of type CommandLineParameterConst and input data is read from config file"""
-            for n,v in input_variables.items():
-                if n in self._params.keys():
-                    self._params[n].set_actual_value(v)
-                else:
-                    pass #todo: log "received unknown input parameter " + n 
-            self.validate()
+    def get_cmd_line(self):
+        cmd_line = ''
+        for k in self._params.keys():
+            c = self._params[k].get_cmd_line()
+            if c is not None:
+                cmd_line += c
+        return cmd_line
 
-        def validate(self):
-            for k in self._params.keys():
-                self._params[k].validate()  
+    def as_DLR_protocol(self):
+        # [('result', '{"type": "string", ...ut.xml" }')]
+        res = []
+        for k in self._params.keys():
+            n = self._params[k].get_name_no_alias()
+            j = self._params[k].as_json_string()
+            res.append((n, j))
+        return res
 
-        def get_cmd_line(self):
-            cmd_line=''
-            for k in self._params.keys():
-                c = self._params[k].get_cmd_line()
-                if c <> None:
-                    cmd_line +=  c 
-            return cmd_line
+    def checkForCodeInsertion(self, argList):
+        ''' Check user input for bad code insertion
 
-        def as_DLR_protocol(self):
-            #[('result', '{"type": "string", ...ut.xml" }')]
-            res = []
-            for k in self._params.keys():
-                n = self._params[k].get_name_no_alias()
-                j = self._params[k].as_json_string()
-                res.append( (n,j) )
-            return res
-        
-        def checkForCodeInsertion(self, argList):
-            ''' Check user input for bad code insertion
-            
-                @param argList: user arguments
-                @return: False if bad code found, else True
-            '''
-            # Check command line insertions
-            maliciousCommands = ['>', '<', '>>', '|', '>&', '<&']
-            # Check for bad code insertion
-            maliciousCode = ['eval(', 'exec(', 'execfile(', 'input(']
+            @param argList: user arguments
+            @return: False if bad code found, else True
+        '''
+        # Check command line insertions
+        maliciousCommands = ['>', '<', '>>', '|', '>&', '<&']
+        # Check for bad code insertion
+        maliciousCode = ['eval(', 'exec(', 'execfile(', 'input(']
 
-            # Evaluate malicious commands
-            if any(e in maliciousCommands for e in argList):
-                raise IOError('Found bad code in user input')
-            # Evaluate maliciousCode
-            for element in argList:
-                for code in maliciousCode:
-                    if code in element:
-                        raise IOError('Found bad code in user input')
+        # Evaluate malicious commands
+        if any(e in maliciousCommands for e in argList):
+            raise IOError('Found bad code in user input')
+        # Evaluate maliciousCode
+        for element in argList:
+            for code in maliciousCode:
+                if code in element:
+                    raise IOError('Found bad code in user input')
diff --git a/src/wpsremote/introspection.py b/src/wpsremote/introspection.py
index e0b43fa..01d6b53 100644
--- a/src/wpsremote/introspection.py
+++ b/src/wpsremote/introspection.py
@@ -8,44 +8,49 @@
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-#todo: one arg, two arg, etc is really ugly => find more pythoninc way
+# todo: one arg, two arg, etc is really ugly => find more pythoninc way
 
-def get_class_no_arg( class_name ):
+
+def get_class_no_arg(class_name):
     parts = class_name.split('.')
     module = parts[0]
-    m = __import__( module )
+    m = __import__(module)
     for comp in parts[1:]:
-        m = getattr(m, comp)         
+        m = getattr(m, comp)
     return m()
 
-def get_class_one_arg( class_name, par1 ):
+
+def get_class_one_arg(class_name, par1):
     parts = class_name.split('.')
     module = parts[0]
-    m = __import__( module )
+    m = __import__(module)
     for comp in parts[1:]:
         m = getattr(m, comp)
     return m(par1)
 
-def get_class_two_arg( class_name, par1, par2 ):
+
+def get_class_two_arg(class_name, par1, par2):
     parts = class_name.split('.')
     module = parts[0]
-    m = __import__( module )
+    m = __import__(module)
     for comp in parts[1:]:
         m = getattr(m, comp)
     return m(par1, par2)
 
-def get_class_three_arg( class_name, par1, par2, par3 ):
+
+def get_class_three_arg(class_name, par1, par2, par3):
     parts = class_name.split('.')
     module = parts[0]
-    m = __import__( module )
+    m = __import__(module)
     for comp in parts[1:]:
         m = getattr(m, comp)
     return m(par1, par2, par3)
 
-def get_class_four_arg( class_name, par1, par2, par3, par4 ):
+
+def get_class_four_arg(class_name, par1, par2, par3, par4):
     parts = class_name.split('.')
     module = parts[0]
-    m = __import__( module )
+    m = __import__(module)
     for comp in parts[1:]:
         m = getattr(m, comp)
-    return m(par1, par2, par3, par4)
\ No newline at end of file
+    return m(par1, par2, par3, par4)
diff --git a/src/wpsremote/mockutils.py b/src/wpsremote/mockutils.py
index 0f31123..834dce8 100644
--- a/src/wpsremote/mockutils.py
+++ b/src/wpsremote/mockutils.py
@@ -8,22 +8,19 @@
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import os
 
 class FileLikeObjectMock(object):
     def __init__(self, lines, linesep="\n"):
-        if type(lines) is list:
+        if isinstance(lines, list):
             self._lines = lines
         else:
             self._lines = lines.split(linesep)
-            self._lines = map(lambda l : l.strip(), self._lines)
-        self._lp=0
-    
+            self._lines = map(lambda l: l.strip(), self._lines)
+        self._lp = 0
+
     def readline(self):
         if self._lp-1 >= len(self._lines):
             return ''
         else:
             self._lp += 1
             return self._lines[self._lp-1]
-
-
diff --git a/src/wpsremote/output_file_parameter.py b/src/wpsremote/output_file_parameter.py
index dfb194b..ad0e0da 100644
--- a/src/wpsremote/output_file_parameter.py
+++ b/src/wpsremote/output_file_parameter.py
@@ -4,27 +4,29 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import os
 import tempfile
 import path
 import json
 import uuid
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
 # ############################################################################################################# #
 #                                                                                                               #
 #    Text/Plain Output Map Format                                                                               #
 #                                                                                                               #
 # ############################################################################################################# #
+
+
 class OutputFileParameter(object):
 
     def __init__(self, par_name, d, template_vars_for_param_types=None, wps_execution_shared_dir=None, uploader=None):
-        #{"type": "string", "description": "xml OAA output file", "filepath" : "%workdir\\\\output_file.xml" }
-        self._name=par_name
-        self._type=None
+        # {"type": "string", "description": "xml OAA output file", "filepath" : "%workdir\\\\output_file.xml" }
+        self._name = par_name
+        self._type = None
         self._description = None
         self._title = None
         self._filepath = None
@@ -41,12 +43,12 @@ def __init__(self, par_name, d, template_vars_for_param_types=None, wps_executio
         self._publish_target_workspace = None
         self._publish_metadata = None
 
-        for k,v in d.items():
+        for k, v in d.items():
             if hasattr(self, "_" + k):
-                if template_vars_for_param_types != None and isinstance(v, basestring):
+                if template_vars_for_param_types is not None and isinstance(v, basestring):
                     for var, val in template_vars_for_param_types.items():
                         if var in v:
-                            v=v.replace("%" + var,val)
+                            v = v.replace("%" + var, val)
 
                 setattr(self, "_" + k, v)
 
@@ -56,9 +58,17 @@ def get_name(self):
         return self._name
 
     def as_json_string(self):
-        #{"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
-        res={}
-        attrib_to_convert = ['_type', '_description', '_title', '_output_mime_type', '_publish_as_layer', '_publish_layer_name', '_publish_default_style', '_publish_target_workspace']
+        # {"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
+        res = {}
+        attrib_to_convert = [
+    '_type',
+    '_description',
+    '_title',
+    '_output_mime_type',
+    '_publish_as_layer',
+    '_publish_layer_name',
+    '_publish_default_style',
+     '_publish_target_workspace']
         attribute_list = [a for a in dir(self) if not a.startswith('__') and not callable(getattr(self, a))]
         attribute_list_filtered = [x for x in attribute_list if x in attrib_to_convert]
         for a in attribute_list_filtered:
@@ -66,7 +76,8 @@ def as_json_string(self):
         return json.dumps(res)
 
     def get_value(self):
-        if self._backup_on_wps_execution_shared_dir != None and self._backup_on_wps_execution_shared_dir.lower() == "true" and self._wps_execution_shared_dir != None:
+        if self._backup_on_wps_execution_shared_dir is not None and self._backup_on_wps_execution_shared_dir.lower(
+        ) == "true" and self._wps_execution_shared_dir is not None:
             unique_dirname = str(uuid.uuid4())
             bkp_dir = path.path(self._wps_execution_shared_dir + "/" + unique_dirname)
             bkp_dir.makedirs()
@@ -76,7 +87,7 @@ def get_value(self):
             dst = path.path(dst)
 
             return dst.text()
-        elif self._upload_data != None and self._upload_data.lower() == "true" and self._uploader != None:
+        elif self._upload_data is not None and self._upload_data.lower() == "true" and self._uploader is not None:
             unique_dirname = str(uuid.uuid4())
             bkp_dir = path.path(tempfile.gettempdir() + '/' + unique_dirname)
             bkp_dir.makedirs()
@@ -107,7 +118,7 @@ def get_output_mime_type(self):
         return self._output_mime_type
 
     def is_publish_as_layer(self):
-        return (self._publish_as_layer != None and self._publish_as_layer.lower() == "true")
+        return (self._publish_as_layer is not None and self._publish_as_layer.lower() == "true")
 
     def get_publish_layer_name(self):
         return self._publish_layer_name
@@ -119,7 +130,7 @@ def get_publish_target_workspace(self):
         return self._publish_target_workspace
 
     def get_metadata(self):
-        if self._publish_metadata != None:
+        if self._publish_metadata is not None:
             metadata_file = path.path(self._publish_metadata)
 
             if metadata_file.isfile():
@@ -131,12 +142,14 @@ def get_metadata(self):
 #    RAW File Output Map Format                                                                                 #
 #                                                                                                               #
 # ############################################################################################################# #
+
+
 class RawFileParameter(object):
 
     def __init__(self, par_name, d, template_vars_for_param_types=None, wps_execution_shared_dir=None, uploader=None):
-        #{"type": "string", "description": "xml OAA output file", "filepath" : "%workdir\\\\output_file.xml" }
-        self._name=par_name
-        self._type=None
+        # {"type": "string", "description": "xml OAA output file", "filepath" : "%workdir\\\\output_file.xml" }
+        self._name = par_name
+        self._type = None
         self._description = None
         self._title = None
         self._filepath = None
@@ -153,12 +166,12 @@ def __init__(self, par_name, d, template_vars_for_param_types=None, wps_executio
         self._publish_target_workspace = None
         self._publish_metadata = None
 
-        for k,v in d.items():
+        for k, v in d.items():
             if hasattr(self, "_" + k):
-                if template_vars_for_param_types != None and isinstance(v, basestring):
+                if template_vars_for_param_types is not None and isinstance(v, basestring):
                     for var, val in template_vars_for_param_types.items():
                         if var in v:
-                            v=v.replace("%" + var,val)
+                            v = v.replace("%" + var, val)
 
                 setattr(self, "_" + k, v)
 
@@ -168,17 +181,26 @@ def get_name(self):
         return self._name
 
     def as_json_string(self):
-        #{"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
-        res={}
-        attrib_to_convert = ['_type', '_description', '_title', '_output_mime_type', '_publish_as_layer', '_publish_layer_name', '_publish_default_style', '_publish_target_workspace']
+        # {"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
+        res = {}
+        attrib_to_convert = [
+    '_type',
+    '_description',
+    '_title',
+    '_output_mime_type',
+    '_publish_as_layer',
+    '_publish_layer_name',
+    '_publish_default_style',
+     '_publish_target_workspace']
         attribute_list = [a for a in dir(self) if not a.startswith('__') and not callable(getattr(self, a))]
         attribute_list_filtered = [x for x in attribute_list if x in attrib_to_convert]
         for a in attribute_list_filtered:
             res[a[1:]] = getattr(self, a)
-        return  json.dumps(res)
+        return json.dumps(res)
 
     def get_value(self):
-        if self._backup_on_wps_execution_shared_dir != None and self._backup_on_wps_execution_shared_dir.lower() == "true" and self._wps_execution_shared_dir != None:
+        if self._backup_on_wps_execution_shared_dir is not None and self._backup_on_wps_execution_shared_dir.lower(
+        ) == "true" and self._wps_execution_shared_dir is not None:
             unique_dirname = str(uuid.uuid4())
             bkp_dir = path.path(self._wps_execution_shared_dir + "/" + unique_dirname)
             bkp_dir.makedirs()
@@ -188,7 +210,7 @@ def get_value(self):
             dst = path.path(dst)
 
             return dst
-        elif self._upload_data != None and self._upload_data.lower() == "true" and self._uploader != None:
+        elif self._upload_data is not None and self._upload_data.lower() == "true" and self._uploader is not None:
             unique_dirname = str(uuid.uuid4())
 
             if self._upload_data_root:
@@ -215,7 +237,7 @@ def get_output_mime_type(self):
         return self._output_mime_type
 
     def is_publish_as_layer(self):
-        return (self._publish_as_layer != None and self._publish_as_layer.lower() == "true")
+        return (self._publish_as_layer is not None and self._publish_as_layer.lower() == "true")
 
     def get_publish_layer_name(self):
         return self._publish_layer_name
@@ -227,7 +249,7 @@ def get_publish_target_workspace(self):
         return self._publish_target_workspace
 
     def get_metadata(self):
-        if self._publish_metadata != None:
+        if self._publish_metadata is not None:
             metadata_file = path.path(self._publish_metadata)
 
             if metadata_file.isfile():
@@ -242,10 +264,17 @@ def get_metadata(self):
 # ############################################################################################################# #
 class OWCFileParameter(object):
 
-    def __init__(self, par_name, d, parameters_types_defs, template_vars_for_param_types=None, wps_execution_shared_dir=None, uploader=None):
-        #{"type": "string", "description": "xml OAA output file", "filepath" : "%workdir\\\\output_file.xml" }
-        self._name=par_name
-        self._type=None
+    def __init__(
+    self,
+    par_name,
+    d,
+    parameters_types_defs,
+    template_vars_for_param_types=None,
+    wps_execution_shared_dir=None,
+     uploader=None):
+        # {"type": "string", "description": "xml OAA output file", "filepath" : "%workdir\\\\output_file.xml" }
+        self._name = par_name
+        self._type = None
         self._description = None
         self._title = None
         self._output_mime_type = None
@@ -261,53 +290,63 @@ def __init__(self, par_name, d, parameters_types_defs, template_vars_for_param_t
         self._publish_layer_name = None
         self._publish_metadata = None
 
-        for k,v in d.items():
+        for k, v in d.items():
             if hasattr(self, "_" + k):
-                if template_vars_for_param_types != None and isinstance(v, basestring):
+                if template_vars_for_param_types is not None and isinstance(v, basestring):
                     for var, val in template_vars_for_param_types.items():
                         if var in v:
-                            v=v.replace("%" + var,val)
+                            v = v.replace("%" + var, val)
 
                 setattr(self, "_" + k, v)
 
-        self._files_to_publish  = ''
-        self._default_styles    = ''
+        self._files_to_publish = ''
+        self._default_styles = ''
         self._target_workspaces = ''
 
-        if self._layers_to_publish != None:
+        if self._layers_to_publish is not None:
             self._parameters_types_defs = parameters_types_defs
 
             layer_names = self._layers_to_publish.split(';')
             for name in layer_names:
-                if self._parameters_types_defs[name] != None:
+                if self._parameters_types_defs[name] is not None:
                     publish_layer_name = self._parameters_types_defs[name].get('publish_layer_name')
-                    publish_layer_name = publish_layer_name if publish_layer_name != None else ' '
+                    publish_layer_name = publish_layer_name if publish_layer_name is not None else ' '
 
                     publish_default_style = self._parameters_types_defs[name].get('publish_default_style')
-                    publish_default_style = publish_default_style if publish_default_style != None else ' '
+                    publish_default_style = publish_default_style if publish_default_style is not None else ' '
 
                     publish_target_workspace = self._parameters_types_defs[name].get('publish_target_workspace')
-                    publish_target_workspace = publish_target_workspace if publish_target_workspace != None else ' '
+                    publish_target_workspace = publish_target_workspace if publish_target_workspace is not None else ' '
 
                     self._files_to_publish += publish_layer_name + ";"
-                    self._default_styles   += publish_default_style + ";"
-                    self._target_workspaces+= publish_target_workspace + ";"
+                    self._default_styles += publish_default_style + ";"
+                    self._target_workspaces += publish_target_workspace + ";"
 
     def get_name(self):
         return self._name
 
     def as_json_string(self):
-        #{"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
-        res={}
-        attrib_to_convert = ['_type', '_description', '_title', '_output_mime_type', '_publish_as_layer', '_publish_layer_name', '_files_to_publish', '_default_styles', '_target_workspaces']
+        # {"type": "string", "description": "A persons surname", "max": 1, "default": "Meier"}
+        res = {}
+        attrib_to_convert = [
+    '_type',
+    '_description',
+    '_title',
+    '_output_mime_type',
+    '_publish_as_layer',
+    '_publish_layer_name',
+    '_files_to_publish',
+    '_default_styles',
+     '_target_workspaces']
         attribute_list = [a for a in dir(self) if not a.startswith('__') and not callable(getattr(self, a))]
         attribute_list_filtered = [x for x in attribute_list if x in attrib_to_convert]
         for a in attribute_list_filtered:
             res[a[1:]] = getattr(self, a)
-        return  json.dumps(res)
+        return json.dumps(res)
 
     def get_value(self):
-        if self._backup_on_wps_execution_shared_dir != None and self._backup_on_wps_execution_shared_dir.lower() == "true" and self._wps_execution_shared_dir != None:
+        if self._backup_on_wps_execution_shared_dir is not None and self._backup_on_wps_execution_shared_dir.lower(
+        ) == "true" and self._wps_execution_shared_dir is not None:
             unique_dirname = str(uuid.uuid4())
             bkp_dir = path.path(self._wps_execution_shared_dir + "/" + unique_dirname)
             bkp_dir.makedirs()
@@ -326,7 +365,7 @@ def get_value(self):
                 files_to_publish = files_to_publish + dst.abspath()
 
             return files_to_publish
-        elif self._upload_data != None and self._upload_data.lower() == "true" and self._uploader != None:
+        elif self._upload_data is not None and self._upload_data.lower() == "true" and self._uploader is not None:
             unique_dirname = str(uuid.uuid4())
             bkp_dir = path.path(tempfile.gettempdir() + '/' + unique_dirname)
             bkp_dir.makedirs()
@@ -366,7 +405,7 @@ def get_output_mime_type(self):
         return self._output_mime_type
 
     def is_publish_as_layer(self):
-        return (self._publish_as_layer != None and self._publish_as_layer.lower() == "true")
+        return (self._publish_as_layer is not None and self._publish_as_layer.lower() == "true")
 
     def get_publish_layer_name(self):
         return self._publish_layer_name
@@ -378,7 +417,7 @@ def get_publish_target_workspace(self):
         return self._target_workspaces
 
     def get_metadata(self):
-        if self._publish_metadata != None:
+        if self._publish_metadata is not None:
             metadata_file = path.path(self._publish_metadata)
 
             if metadata_file.isfile():
diff --git a/src/wpsremote/output_parameters.py b/src/wpsremote/output_parameters.py
index e53c18c..d68bd7a 100644
--- a/src/wpsremote/output_parameters.py
+++ b/src/wpsremote/output_parameters.py
@@ -4,62 +4,75 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import unittest
 import output_file_parameter
 import path
 from collections import OrderedDict
 import logging
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 class OutputParameters(object):
 
     @staticmethod
     def create_from_config(output_sections, wps_execution_shared_dir=None, uploader=None):
         '''Static constructor.
-        input_sections: a dictionary such as { par1_name : [( 'par1_attrubute1_name' : par1_attrubute1_value ), ( 'par2_attrubute1_name' : par2_attrubute1_value ), ...], par2_name : { ... }, ... }
+        input_sections: a dictionary such as
+            { par1_name : [( 'par1_attrubute1_name' : par1_attrubute1_value ),
+                           ( 'par2_attrubute1_name' : par2_attrubute1_value ), ...],
+              par2_name : { ... }, ... }
         '''
-        output_sections_reshaped={}
-        #force the order of sections in config files: [output1], [output2], etc
+        output_sections_reshaped = {}
+        # force the order of sections in config files: [output1], [output2], etc
         for k in sorted(output_sections):
-            d=dict(output_sections[k])
+            d = dict(output_sections[k])
             name = d['name']
             del d['name']
             output_sections_reshaped[name] = d
-        return OutputParameters( output_sections_reshaped, wps_execution_shared_dir, uploader )
+        return OutputParameters(output_sections_reshaped, wps_execution_shared_dir, uploader)
 
     def __init__(self, parameters_types_defs, wps_execution_shared_dir, uploader):
         '''
         Static constructor.
-        parameters_types: ('out_par_name1', {"out_par_name1_attrib1": "value1", "out_par_name1_attrib1": "value2", ...})
+        parameters_types:
+            ('out_par_name1', {"out_par_name1_attrib1": "value1", "out_par_name1_attrib1": "value2", ...})
         '''
-        self._wps_execution_shared_dir=wps_execution_shared_dir;
-        self._params={}
+        self._wps_execution_shared_dir = wps_execution_shared_dir
+        self._params = {}
 
         for name, d in OrderedDict(parameters_types_defs).items():
             if ('type' in d):
 
                 if ('string' == d['type']):
-                    self._params[name] = output_file_parameter.OutputFileParameter( name, d, wps_execution_shared_dir=self._wps_execution_shared_dir, uploader=uploader)
-
-                elif ('image/geotiff' in d['type'] or 'text/xml' in d['type'] or 'application/gml' in d['type'] or 'application/zip' in d['type'] or 'application/x-netcdf' in d['type'] or 'video/mp4' in d['type']):
-                    self._params[name] = output_file_parameter.RawFileParameter( name, d, wps_execution_shared_dir=self._wps_execution_shared_dir, uploader=uploader)
+                    self._params[name] = output_file_parameter.OutputFileParameter(
+    name, d, wps_execution_shared_dir=self._wps_execution_shared_dir, uploader=uploader)
+
+                elif ('image/geotiff' in d['type'] or
+                      'text/xml' in d['type'] or
+                      'application/gml' in d['type'] or
+                      'application/zip' in d['type'] or
+                      'application/x-netcdf' in d['type'] or
+                      'video/mp4' in d['type']):
+                    self._params[name] = output_file_parameter.RawFileParameter(
+    name, d, wps_execution_shared_dir=self._wps_execution_shared_dir, uploader=uploader)
 
                 elif ('application/owc' in d['type']):
-                    self._params[name] = output_file_parameter.OWCFileParameter( name, d, parameters_types_defs, wps_execution_shared_dir=self._wps_execution_shared_dir, uploader=uploader)
+                    self._params[name] = output_file_parameter.OWCFileParameter(
+    name, d, parameters_types_defs, wps_execution_shared_dir=self._wps_execution_shared_dir, uploader=uploader)
 
                 else:
                     logger = logging.getLogger("OutputParameters.__init__")
-                    msg="Unknown output parameter " + name + " type"
+                    msg = "Unknown output parameter " + name + " type"
                     logger.critical(msg)
                     raise Exception(msg)
             else:
                 pass
 
     def get_values(self):
-        res=[]
+        res = []
         for k in self._params:
             res.append(self._params[k].get_value())
         return res
@@ -69,32 +82,34 @@ def parameters(self):
             yield p
 
     def as_DLR_protocol(self):
-        #[('result', '{"type": "string", ...ut.xml" }')]
+        # [('result', '{"type": "string", ...ut.xml" }')]
         res = []
         for k in self._params.keys():
             n = self._params[k].get_name()
             j = self._params[k].as_json_string()
-            res.append( (n,j) )
+            res.append((n, j))
         return res
 
+
 class Test(unittest.TestCase):
-    
+
     def test_output_par_from_file(self):
 
-        f=path.path("d:\\tmp\\test.txt")
-        msg="this is a test"
+        f = path.path("d:\\tmp\\test.txt")
+        msg = "this is a test"
         f.write_text(msg)
-        
-        p = OrderedDict( {"type": "string", "description": "xml OAA output file", "filepath" : "d:\\tmp\\test.txt"}   )
+
+        p = OrderedDict({"type": "string", "description": "xml OAA output file", "filepath": "d:\\tmp\\test.txt"})
         par_types = [('result', p)]
 
         pop = OutputParameters(par_types)
 
         it = pop.parameters()
         val = next(it)
-        self.assertEqual( val, msg)
+        self.assertEqual(val, msg)
 
         f.remove()
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/src/wpsremote/path.py b/src/wpsremote/path.py
index 259b7a3..9e0d7c6 100644
--- a/src/wpsremote/path.py
+++ b/src/wpsremote/path.py
@@ -6,6 +6,15 @@
 
 from __future__ import generators
 
+import sys
+import warnings
+import os
+import fnmatch
+import glob
+import shutil
+import codecs
+import md5
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
@@ -27,7 +36,6 @@
 Date:    9 Mar 2007
 """
 
-
 # TODO
 #   - Tree-walking functions don't avoid symlink loops.  Matt Harrison
 #     sent me a patch for this.
@@ -39,8 +47,6 @@
 #   - guess_content_type() method?
 #   - Perhaps support arguments to touch().
 
-import sys, warnings, os, fnmatch, glob, shutil, codecs, md5
-
 __version__ = '2.2'
 __all__ = ['path']
 
@@ -87,6 +93,7 @@
 class TreeWalkWarning(Warning):
     pass
 
+
 class path(_base):
     """ Represents a filesystem path.
 
@@ -103,7 +110,7 @@ def __repr__(self):
     def __add__(self, more):
         try:
             resultStr = _base.__add__(self, more)
-        except TypeError:  #Python bug
+        except TypeError:  # Python bug
             resultStr = NotImplemented
         if resultStr is NotImplemented:
             return resultStr
@@ -132,19 +139,32 @@ def getcwd(cls):
         return cls(_getcwd())
     getcwd = classmethod(getcwd)
 
-
     # --- Operations on path strings.
 
     isabs = os.path.isabs
-    def abspath(self):       return self.__class__(os.path.abspath(self))
-    def normcase(self):      return self.__class__(os.path.normcase(self))
-    def normpath(self):      return self.__class__(os.path.normpath(self))
-    def realpath(self):      return self.__class__(os.path.realpath(self))
-    def expanduser(self):    return self.__class__(os.path.expanduser(self))
-    def expandvars(self):    return self.__class__(os.path.expandvars(self))
-    def dirname(self):       return self.__class__(os.path.dirname(self))
     basename = os.path.basename
 
+    def abspath(self):
+        return self.__class__(os.path.abspath(self))
+
+    def normcase(self):
+        return self.__class__(os.path.normcase(self))
+
+    def normpath(self):
+        return self.__class__(os.path.normpath(self))
+
+    def realpath(self):
+        return self.__class__(os.path.realpath(self))
+
+    def expanduser(self):
+        return self.__class__(os.path.expanduser(self))
+
+    def expandvars(self):
+        return self.__class__(os.path.expandvars(self))
+
+    def dirname(self):
+        return self.__class__(os.path.dirname(self))
+
     def expand(self):
         """ Clean up a filename by calling expandvars(),
         expanduser(), and normpath() on it.
@@ -363,7 +383,7 @@ def files(self, pattern=None):
         whose names match the given pattern.  For example,
         d.files('*.pyc').
         """
-        
+
         return [p for p in self.listdir(pattern) if p.isfile()]
 
     def walk(self, pattern=None, errors='strict'):
@@ -484,7 +504,7 @@ def walkfiles(self, pattern=None, errors='strict'):
             try:
                 isfile = child.isfile()
                 isdir = not isfile and child.isdir()
-            except:
+            except BaseException:
                 if errors == 'ignore':
                     continue
                 elif errors == 'warn':
@@ -522,7 +542,6 @@ def glob(self, pattern):
         cls = self.__class__
         return [cls(s) for s in glob.glob(_base(self / pattern))]
 
-
     # --- Reading or writing an entire file at once.
 
     def open(self, mode='r'):
@@ -790,13 +809,13 @@ def read_md5(self):
     # --- Methods for querying the filesystem.
 
     exists = os.path.exists
-    
-    #isdir = os.path.isdir
-    #fix by gimapaolo cimino
+
+    # isdir = os.path.isdir
+    # fix by gimapaolo cimino
     def isdir(self):
         return os.path.isdir(str(self))
-    #end fix
-    
+    # end fix
+
     isfile = os.path.isfile
     islink = os.path.islink
     ismount = os.path.ismount
@@ -876,7 +895,6 @@ def statvfs(self):
         def pathconf(self, name):
             return os.pathconf(self, name)
 
-
     # --- Modifying operations on files and directories
 
     def utime(self, times):
@@ -896,13 +914,12 @@ def rename(self, new):
     def renames(self, new):
         os.renames(self, new)
 
-
     # --- Create/delete operations on directories
 
-    def mkdir(self, mode=0777):
+    def mkdir(self, mode=0o777):
         os.mkdir(self, mode)
 
-    def makedirs(self, mode=0777):
+    def makedirs(self, mode=0o777):
         os.makedirs(self, mode)
 
     def rmdir(self):
@@ -911,14 +928,13 @@ def rmdir(self):
     def removedirs(self):
         os.removedirs(self)
 
-
     # --- Modifying operations on files
 
     def touch(self):
         """ Set the access/modified times of this file to the current time.
         Create the file if it does not exist.
         """
-        fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
+        fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0o666)
         os.close(fd)
         os.utime(self, None)
 
@@ -928,7 +944,6 @@ def remove(self):
     def unlink(self):
         os.unlink(self)
 
-
     # --- Links
 
     if hasattr(os, 'link'):
@@ -960,7 +975,6 @@ def readlinkabs(self):
             else:
                 return (self.parent / p).abspath()
 
-
     # --- High-level functions from shutil
 
     copyfile = shutil.copyfile
@@ -973,7 +987,6 @@ def readlinkabs(self):
         move = shutil.move
     rmtree = shutil.rmtree
 
-
     # --- Special stuff from os
 
     if hasattr(os, 'chroot'):
@@ -983,4 +996,3 @@ def chroot(self):
     if hasattr(os, 'startfile'):
         def startfile(self):
             os.startfile(self)
-
diff --git a/src/wpsremote/process_test.py b/src/wpsremote/process_test.py
index 2c83484..ab8d461 100644
--- a/src/wpsremote/process_test.py
+++ b/src/wpsremote/process_test.py
@@ -1,41 +1,41 @@
 import os
 import psutil
 import time
- 
+
 logPath = r'C:\tmp\processlogs'
 if not os.path.exists(logPath):
     os.mkdir(logPath)
- 
+
 separator = "-" * 150
-format  = "%7s %7s %7s %7s %7s %12s %12s %30s %30s, %s"
+format = "%7s %7s %7s %7s %7s %12s %12s %30s %30s, %s"
 format2 = "%7s %7s %7s %7.4f %7.2f %12s %12s %30s %30s, %s"
-while 1:
+while True:
     logPath = r'C:\tmp\processlogs\procLog%i.log' % int(time.time())
     f = open(logPath, 'w')
     f.write(separator + "\n")
     f.write(time.ctime() + "\n")
     f.write(format % ("PID", "PPID", "STATUS", "%CPU", "%MEM", "VMS", "RSS", "USER", "NAME", "PATH"))
     f.write("\n")
- 
-    for proc in psutil.process_iter(): 
-        
-        process = psutil.Process(proc.pid).as_dict() # Get the process info using PID
 
-        pid    = str(process["pid"])
-        ppid   = str(process["ppid"])
+    for proc in psutil.process_iter():
+
+        process = psutil.Process(proc.pid).as_dict()  # Get the process info using PID
+
+        pid = str(process["pid"])
+        ppid = str(process["ppid"])
         status = process["status"]
 
         cpu_percent = process["cpu_percent"]
         mem_percent = process["memory_percent"]
-        
+
         rss = str(process["memory_info"].rss)
         vms = str(process["memory_info"].vms)
         username = process["username"]
-        name = process["name"] # Here is the process name
+        name = process["name"]  # Here is the process name
         path = process["cwd"]
         f.write(format2 % (pid, ppid, status, cpu_percent, mem_percent, vms, rss, username, name, path))
         f.write("\n\n")
     f.close()
     print "Finished log update!"
     time.sleep(300)
-    print "writing new log data!"
\ No newline at end of file
+    print "writing new log data!"
diff --git a/src/wpsremote/processbot.py b/src/wpsremote/processbot.py
index 25add40..ecb8daa 100644
--- a/src/wpsremote/processbot.py
+++ b/src/wpsremote/processbot.py
@@ -4,17 +4,12 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import subprocess
 import thread
 import re
 import datetime
 import os
 import introspection
-import thread
 import logging
 import traceback
 import base64
@@ -25,53 +20,64 @@
 import computational_job_input_actions
 import configInstance
 import output_parameters
-import action
 import resource_cleaner
 from time import sleep
 from collections import OrderedDict
 from Crypto.PublicKey import RSA
-from Crypto.Signature import PKCS1_v1_5
-from Crypto.Hash import SHA
+
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
 
 
 class ProcessBot(object):
     """
     This script starts when the user call a new WPS execution.
-    His task is to call the proper external executable/scripts according to the service.config file (provided in the cmd line with -s option) and send back to the WPS logging/progress
+    His task is to call the proper external executable/scripts according to the
+    service.config file (provided in the cmd line with -s option) and send back to the WPS logging/progress
     information and error information if something unexpected happens.
-    All the output including the log file is generated in a sand box directory created with joint information from service.config and external process start-up information.
+    All the output including the log file is generated in a sand box directory
+    created with joint information from service.config and external process start-up information.
     """
+
     def __init__(self, remote_config_filepath, service_config_filepath, execute_message):
         self._uniqueExeId = execute_message.UniqueId()
         self._remote_wps_endpoint = execute_message.originator()
         self._remote_wps_baseurl = execute_message.BaseURL()
         self._input_values = execute_message.variables()
 
-        #read remote config
+        # read remote config
         remote_config = configInstance.create(remote_config_filepath)
         bus_class_name = remote_config.get("DEFAULT", "bus_class_name")
         uploader_class_name = None
         try:
             uploader_class_name = remote_config.get("UPLOADER", "uploader_class_name")
-        except:
+        except BaseException:
             pass
         self._resource_file_dir = remote_config.get_path("DEFAULT", "resource_file_dir")
         if remote_config.has_option("DEFAULT", "wps_execution_shared_dir"):
             self._wps_execution_shared_dir = remote_config.get_path("DEFAULT", "wps_execution_shared_dir")
 
-            #ensure outdir exists
+            # ensure outdir exists
             if not self._wps_execution_shared_dir.exists():
                 self._wps_execution_shared_dir.mkdir()
         else:
             self._wps_execution_shared_dir = None
 
-        #the config file is read with raw=False because the unique_exe_id value will be used (interpolated) in the config
-        serviceConfig = configInstance.create(service_config_filepath, case_sensitive=True, variables = {'unique_exe_id' : self._uniqueExeId, 'wps_execution_shared_dir' : self._wps_execution_shared_dir}, raw=False)
-
-        self.service = serviceConfig.get("DEFAULT", "service") #todo: what is?
+        # the config file is read with raw=False because the unique_exe_id value
+        # will be used (interpolated) in the config
+        serviceConfig = configInstance.create(
+    service_config_filepath,
+    case_sensitive=True,
+    variables={
+        'unique_exe_id': self._uniqueExeId,
+        'wps_execution_shared_dir': self._wps_execution_shared_dir},
+         raw=False)
+
+        self.service = serviceConfig.get("DEFAULT", "service")  # todo: what is?
         self.namespace = serviceConfig.get("DEFAULT", "namespace")
         self.description = serviceConfig.get("DEFAULT", "description")
-        self._active = serviceConfig.get("DEFAULT", "active").lower() == "true" #True
+        self._active = serviceConfig.get("DEFAULT", "active").lower() == "true"  # True
 
         self._executable_path = serviceConfig.get("DEFAULT", "executable_path")
         self._executable_cmd = serviceConfig.get("DEFAULT", "executable_cmd")
@@ -82,25 +88,27 @@ def __init__(self, remote_config_filepath, service_config_filepath, execute_mess
 
         self._stdout_parser = serviceConfig.get_list("Logging", "stdout_parser")
         self._stdout_action = serviceConfig.get_list("Logging", "stdout_action")
-        self._output_dir =  serviceConfig.get_path("DEFAULT", "output_dir")
+        self._output_dir = serviceConfig.get_path("DEFAULT", "output_dir")
         if not os.path.isabs(self._output_dir):
             self._output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), self._output_dir)
-        self._max_running_time = datetime.timedelta(seconds = serviceConfig.getint("DEFAULT", "max_running_time_seconds"))
+        self._max_running_time = datetime.timedelta(seconds=serviceConfig.getint("DEFAULT", "max_running_time_seconds"))
 
-        #create the concrete uploader object
+        # create the concrete uploader object
         if uploader_class_name:
             uploader_host = remote_config.get("UPLOADER", "uploader_host")
             uploader_username = remote_config.get("UPLOADER", "uploader_username")
             uploader_password = remote_config.get("UPLOADER", "uploader_password")
 
-            if remote_config.has_option("UPLOADER", "uploader_private_rsa_key") and remote_config.has_option("UPLOADER", "uploader_passphrase"):
+            if remote_config.has_option("UPLOADER", "uploader_private_rsa_key") and \
+               remote_config.has_option("UPLOADER", "uploader_passphrase"):
                 uploader_private_rsa_key = remote_config.get("UPLOADER", "uploader_private_rsa_key")
                 uploader_passphrase = remote_config.get("UPLOADER", "uploader_passphrase")
                 privatekey = open(uploader_private_rsa_key, "r")
                 rsa_key = RSA.importKey(privatekey, passphrase=uploader_passphrase)
                 uploader_password = rsa_key.decrypt(base64.b64decode(uploader_password))
 
-            self._uploader = introspection.get_class_four_arg(uploader_class_name, uploader_host, uploader_username, uploader_password, self._uniqueExeId)
+            self._uploader = introspection.get_class_four_arg(
+    uploader_class_name, uploader_host, uploader_username, uploader_password, self._uniqueExeId)
         else:
             self._uploader = None
 
@@ -109,23 +117,29 @@ def __init__(self, remote_config_filepath, service_config_filepath, execute_mess
             input_sections[input_section] = serviceConfig.items_without_defaults(input_section, raw=False)
         self._input_parameters_defs = computation_job_inputs.ComputationJobInputs.create_from_config(input_sections)
 
-        output_sections=OrderedDict()
+        output_sections = OrderedDict()
         for output_section in [s for s in serviceConfig.sections() if 'output' in s.lower()]:
             output_sections[output_section] = serviceConfig.items_without_defaults(output_section, raw=False)
-        self._output_parameters_defs = output_parameters.OutputParameters.create_from_config( output_sections, self._wps_execution_shared_dir, self._uploader)
+        self._output_parameters_defs = output_parameters.OutputParameters.create_from_config(
+            output_sections, self._wps_execution_shared_dir, self._uploader)
 
-        action_sections=OrderedDict()
+        action_sections = OrderedDict()
         for action_section in [s for s in serviceConfig.sections() if 'action' in s.lower()]:
             action_sections[action_section] = serviceConfig.items_without_defaults(action_section, raw=False)
-        self._input_params_actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config(action_sections)
+        self._input_params_actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config(
+            action_sections)
 
-        #create the concrete bus object
-        self._lock_bus =  thread.allocate_lock()
-        self.bus = introspection.get_class_four_arg(bus_class_name, remote_config, self.service, self.namespace, self._uniqueExeId)
+        # create the concrete bus object
+        self._lock_bus = thread.allocate_lock()
+        self.bus = introspection.get_class_four_arg(bus_class_name,
+                                                    remote_config,
+                                                    self.service,
+                                                    self.namespace,
+                                                    self._uniqueExeId)
 
         self._finished = False
 
-        #event handlers
+        # event handlers
         self.bus.RegisterMessageCallback(busIndipendentMessages.FinishMessage, self.handle_finish)
         self.bus.RegisterMessageCallback(busIndipendentMessages.AbortMessage, self.handle_abort)
 
@@ -148,9 +162,9 @@ def workdir(self):
         return self._output_dir / self._uniqueExeId
 
     def run(self):
-        #create the computational job process asynchronously
+        # create the computational job process asynchronously
         thread.start_new_thread(self.SpawnProcess, ())
-        #start listen the bus to catch abort or finish messages
+        # start listen the bus to catch abort or finish messages
         self.bus.Listen()
 
     def SpawnProcess(self):
@@ -158,43 +172,54 @@ def SpawnProcess(self):
             logger = logging.getLogger("ProcessBot.SpawnProcess")
             self.ensure_output_dir_exists()
 
-            #set the actual value of input parameters to input parameters definitions
-            self._input_parameters_defs.set_values( self._input_values )
+            # set the actual value of input parameters to input parameters definitions
+            self._input_parameters_defs.set_values(self._input_values)
 
-            #execute actions associated to input parameters
-            self._input_params_actions.execute( self._input_parameters_defs )
+            # execute actions associated to input parameters
+            self._input_params_actions.execute(self._input_parameters_defs)
 
-            #prepare cmd line
-            cmd = self._executable_cmd + " " +  self._input_params_actions.get_cmd_line()
+            # prepare cmd line
+            cmd = self._executable_cmd + " " + self._input_params_actions.get_cmd_line()
 
-            #spawn the computational job process
-            invoked_process = subprocess.Popen(args=cmd.split(), cwd=self._executable_path, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False)
-            logger.info("process " + self.service +  " created with PId " + str(invoked_process.pid) + " and command line: " + cmd)
+            # spawn the computational job process
+            invoked_process = subprocess.Popen(args=cmd.split(),
+                                               cwd=self._executable_path,
+                                               stdin=subprocess.PIPE,
+                                               stdout=subprocess.PIPE,
+                                               stderr=subprocess.STDOUT,
+                                               shell=False)
+            logger.info("process " + self.service + " created with PId " +
+                        str(invoked_process.pid) + " and command line: " + cmd)
 
-            #read the resource file
+            # read the resource file
             rc = resource_cleaner.Resource.create_from_file(self._uniqueExeId, os.getpid())
-            #add the pid of the computational job to the resource file
-            rc.set_from_processbot( os.getpid(), [ invoked_process.pid ] ) #todo: check if cmds contains ","!!! --> pickle?
+            # add the pid of the computational job to the resource file
+            # todo: check if cmds contains ","!!! --> pickle?
+            rc.set_from_processbot(os.getpid(), [invoked_process.pid])
             rc.write()
         except Exception as ex:
-            logging.exception( "Process "+str(self._uniqueExeId)+" Exception: "+str(traceback.format_exc(sys.exc_info())))
+            logging.exception("Process "+str(self._uniqueExeId)+" Exception: " +
+                              str(traceback.format_exc(sys.exc_info())))
             error_message = "process failure\n" + str(ex)
-            self.send_error_message( error_message )
-            #self.bus.disconnect()
-            logger.info( "after send job-error message to WPS")
+            self.send_error_message(error_message)
+            # self.bus.disconnect()
+            logger.info("after send job-error message to WPS")
             thread.interrupt_main()
-            os._exit(return_code)
+            os._exit(-1)
 
-        #go to process output synchronuosly
-        self.process_output_parser( invoked_process )
+        # go to process output synchronuosly
+        self.process_output_parser(invoked_process)
 
     def process_output_parser(self, invoked_process):
         logger = logging.getLogger("ProcessBot.process_output_parser")
-        logger.info( "start parsing stdout of created process " + self.service )
+        logger.info("start parsing stdout of created process " + self.service)
 
         with self._lock_bus:
             if self.bus.state() == 'connected':
-                self.bus.SendMessage( busIndipendentMessages.LogMessage(  self._remote_wps_endpoint, "INFO", "start parsing stdout of created process " + self.service ) )
+                self.bus.SendMessage(busIndipendentMessages.
+                                     LogMessage(self._remote_wps_endpoint,
+                                                "INFO",
+                                                "start parsing stdout of created process " + self.service))
             else:
                 try:
                     self.bus.xmpp.reconnect()
@@ -202,11 +227,18 @@ def process_output_parser(self, invoked_process):
                     # self.bus.xmpp.get_roster()
 
                     if self.bus.state() == 'connected':
-                        self.bus.SendMessage( busIndipendentMessages.LogMessage(  self._remote_wps_endpoint, "INFO", "start parsing stdout of created process " + self.service ) )
+                        self.bus.SendMessage(busIndipendentMessages.
+                                             LogMessage(self._remote_wps_endpoint,
+                                                        "INFO",
+                                                        "start parsing stdout of created process " + self.service))
                     else:
-                        logger.info( "[XMPP Disconnected]: Process "+str(self._uniqueExeId)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
-                except:
-                    logger.info( "[XMPP Disconnected]: Process "+str(self._uniqueExeId)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
+                        logger.info("[XMPP Disconnected]: Process " +
+                                    str(self._uniqueExeId) +
+                                    " Could not send info message to GeoServer Endpoint " +
+                                    str(self._remote_wps_endpoint))
+                except BaseException:
+                    logger.info("[XMPP Disconnected]: Process "+str(self._uniqueExeId) +
+                                " Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
 
         # Listen to stdout
         stdout_parser_compiled = [re.compile(r) for r in self._stdout_parser]
@@ -215,76 +247,102 @@ def process_output_parser(self, invoked_process):
             line = invoked_process.stdout.readline()
             if line != '':
                 line = line.strip()
-                logger.debug( "Received line: " + line)
+                logger.debug("Received line: " + line)
                 stack_trace.append(line)
-                match=False
-                #todo: define a line to get pid of computational job process
-                for rgx,action in zip(stdout_parser_compiled, self._stdout_action):
+                # match = False
+                # todo: define a line to get pid of computational job process
+                for rgx, action in zip(stdout_parser_compiled, self._stdout_action):
                     res = rgx.match(line)
                     if (res):
-                        if (action=="progress"):
+                        if (action == "progress"):
                             with self._lock_bus:
                                 if self.bus.state() != 'connected':
                                     try:
                                         self.bus.xmpp.reconnect()
                                         self.bus.xmpp.send_presence()
                                         # self.bus.xmpp.get_roster()
-                                    except:
-                                        logger.info( "[XMPP Disconnected]: Process "+str(self._uniqueExeId)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
-                                self.bus.SendMessage( busIndipendentMessages.ProgressMessage(  self._remote_wps_endpoint, float(res.group(1).strip() ) ) )
-                            match=True
+                                    except BaseException:
+                                        logger.info("[XMPP Disconnected]: Process " +
+                                                    str(self._uniqueExeId) +
+                                                    " Could not send info message to GeoServer Endpoint " +
+                                                    str(self._remote_wps_endpoint))
+                                self.bus.SendMessage(busIndipendentMessages.
+                                                     ProgressMessage(self._remote_wps_endpoint,
+                                                                     float(res.group(1).strip())))
+                            # match = True
                             break
-                        elif (action=="log"):
+                        elif (action == "log"):
                             with self._lock_bus:
                                 if self.bus.state() != 'connected':
                                     try:
                                         self.bus.xmpp.reconnect()
                                         self.bus.xmpp.send_presence()
                                         # self.bus.xmpp.get_roster()
-                                    except:
-                                        logger.info( "[XMPP Disconnected]: Process "+str(self._uniqueExeId)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
-                                self.bus.SendMessage( busIndipendentMessages.LogMessage(  self._remote_wps_endpoint, res.group(1).strip(), res.group(2).strip() ) )
-                            match=True
+                                    except BaseException:
+                                        logger.info("[XMPP Disconnected]: Process " +
+                                                    str(self._uniqueExeId) +
+                                                    " Could not send info message to GeoServer Endpoint " +
+                                                    str(self._remote_wps_endpoint))
+                                self.bus.SendMessage(busIndipendentMessages.
+                                                     LogMessage(self._remote_wps_endpoint,
+                                                                res.group(1).strip(),
+                                                                res.group(2).strip()))
+                            # match = True
                             break
-                        elif (action=="abort"):
+                        elif (action == "abort"):
                             with self._lock_bus:
                                 if self.bus.state() != 'connected':
                                     try:
                                         self.bus.xmpp.reconnect()
                                         self.bus.xmpp.send_presence()
                                         # self.bus.xmpp.get_roster()
-                                    except:
-                                        logger.info( "[XMPP Disconnected]: Process "+str(self._uniqueExeId)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
-                                self.bus.SendMessage( busIndipendentMessages.ErrorMessage(  self._remote_wps_endpoint, res.group(2).strip() ) )
-                            match=True
+                                    except BaseException:
+                                        logger.info("[XMPP Disconnected]: Process " +
+                                                    str(self._uniqueExeId) +
+                                                    " Could not send info message to GeoServer Endpoint " +
+                                                    str(self._remote_wps_endpoint))
+                                self.bus.SendMessage(busIndipendentMessages.
+                                                     ErrorMessage(self._remote_wps_endpoint,
+                                                                  res.group(2).strip()))
+                            # match = True
                             break
-                        elif (action=="ignore"):
-                            match=True
+                        elif (action == "ignore"):
+                            # match = True
                             break
                         else:
                             pass
             else:
-                #end of stream
+                # end of stream
                 break
-        logger.debug( "process " + self.service + "stdout is over")
-        #wait for process exit code
+        logger.debug("process " + self.service + "stdout is over")
+        # wait for process exit code
         return_code = invoked_process.wait()
-        logger.info( "process exit code is " + str(return_code))
+        logger.info("process exit code is " + str(return_code))
 
-        if return_code==0:
-            #success
+        if return_code == 0:
+            # success
             logger.info("process exit code is " + str(return_code) + ": success")
             logger.info("send job-completed message to WPS with output parameter")
             outputs = dict()
             try:
                 for p in self._output_parameters_defs.parameters():
-                    outputs[p.get_name()] = [p.get_value(), p.get_description(), p.get_title(), p.get_type(), p.is_publish_as_layer(), p.get_publish_layer_name(), p.get_publish_default_style(), p.get_publish_target_workspace(), p.get_metadata()]
-            except:
-                logging.exception( "Process "+str(self._uniqueExeId)+" Exception: "+str(traceback.format_exc(sys.exc_info())))
-                error_message = "process exit code is " + str(return_code) + ": failure\n" + "\n".join(str(e) for e in stack_trace)
-                self.send_error_message( error_message )
-                #self.bus.disconnect()
-                logger.info( "after send job-error message to WPS")
+                    outputs[p.get_name()] = [p.get_value(),
+                                             p.get_description(),
+                                             p.get_title(),
+                                             p.get_type(),
+                                             p.is_publish_as_layer(),
+                                             p.get_publish_layer_name(),
+                                             p.get_publish_default_style(),
+                                             p.get_publish_target_workspace(),
+                                             p.get_metadata()]
+            except BaseException:
+                logging.exception("Process "+str(self._uniqueExeId)+" Exception: " +
+                                  str(traceback.format_exc(sys.exc_info())))
+                error_message = "process exit code is " + \
+                    str(return_code) + ": failure\n" + "\n".join(str(e) for e in stack_trace)
+                self.send_error_message(error_message)
+                # self.bus.disconnect()
+                logger.info("after send job-error message to WPS")
                 thread.interrupt_main()
                 os._exit(return_code)
 
@@ -296,31 +354,37 @@ def process_output_parser(self, invoked_process):
                         self.bus.xmpp.reconnect()
                         self.bus.xmpp.send_presence()
                         # self.bus.xmpp.get_roster()
-                    except:
-                        logger.info( "[XMPP Disconnected]: Process "+str(self._uniqueExeId)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
+                    except BaseException:
+                        logger.info("[XMPP Disconnected]: Process " +
+                                    str(self._uniqueExeId) +
+                                    " Could not send info message to GeoServer Endpoint " +
+                                    str(self._remote_wps_endpoint))
 
                 counter = 1
                 while not self._finished:
                     logger.info("sending 'completed' message tentative #" + str(counter))
-                    self.bus.SendMessage(busIndipendentMessages.CompletedMessage( self._remote_wps_endpoint, self._remote_wps_baseurl, outputs ))
+                    self.bus.SendMessage(busIndipendentMessages.
+                                         CompletedMessage(self._remote_wps_endpoint,
+                                                          self._remote_wps_baseurl, outputs))
                     counter = counter + 1
                     if counter < 100:
                         sleep(10)
                     else:
-                        logger.error("Could not contact Remote WPS with. Forcibly shutdown the process..." )
+                        logger.error("Could not contact Remote WPS with. Forcibly shutdown the process...")
                         thread.interrupt_main()
                         os._exit(-1)
 
-            logger.info( "after send job-completed message to WPS")
+            logger.info("after send job-completed message to WPS")
         else:
-            error_message = "process exit code is " + str(return_code) + ": failure\n" + "\n".join(str(e) for e in stack_trace)
-            logger.critical( "process exit code is " + str(return_code) + ": failure")
+            error_message = "process exit code is " + \
+                str(return_code) + ": failure\n" + "\n".join(str(e) for e in stack_trace)
+            logger.critical("process exit code is " + str(return_code) + ": failure")
 
-            #todo: should i wait for finish message here as well? No
-            self.send_error_message( error_message )
+            # todo: should i wait for finish message here as well? No
+            self.send_error_message(error_message)
 
-            #self.bus.disconnect()
-            logger.info( "after send job-error message to WPS")
+            # self.bus.disconnect()
+            logger.info("after send job-error message to WPS")
             thread.interrupt_main()
             os._exit(return_code)
 
@@ -346,10 +410,10 @@ def handle_abort(self, aborted_message):
 
     def send_error_message(self, msg):
         logger = logging.getLogger("ProcessBot.send_error_message to " + str(self._remote_wps_endpoint))
-        logger.error( msg )
+        logger.error(msg)
         with self._lock_bus:
             if self.bus.state() == 'connected':
-                self.bus.SendMessage( busIndipendentMessages.ErrorMessage( self._remote_wps_endpoint, msg ) )
+                self.bus.SendMessage(busIndipendentMessages.ErrorMessage(self._remote_wps_endpoint, msg))
             else:
                 try:
                     self.bus.xmpp.reconnect()
@@ -357,13 +421,23 @@ def send_error_message(self, msg):
                     # self.bus.xmpp.get_roster()
 
                     if self.bus.state() == 'connected':
-                        self.bus.SendMessage( busIndipendentMessages.ErrorMessage( self._remote_wps_endpoint, msg ) )
+                        self.bus.SendMessage(busIndipendentMessages.ErrorMessage(self._remote_wps_endpoint, msg))
                     else:
-                        sys.stdout.write( "[XMPP Disconnected]: Process <UID>"+str(self._uniqueExeId)+"</UID> Could not send error message to GeoServer Endpoint <JID>"+str(self._remote_wps_endpoint)+"</JID> <MSG>"+msg.replace('\n', ' ').replace('\r', '')+"</MSG>")
-                except:
-                    sys.stdout.write( "[XMPP Disconnected]: Process <UID>"+str(self._uniqueExeId)+"</UID> Could not send error message to GeoServer Endpoint <JID>"+str(self._remote_wps_endpoint)+"</JID> <MSG>"+msg.replace('\n', ' ').replace('\r', '')+"</MSG>")
-
-        logger.debug( "send error msg complete" )
+                        sys.stdout.write("[XMPP Disconnected]: Process <UID>" +
+                                         str(self._uniqueExeId) +
+                                         "</UID> Could not send error message to GeoServer Endpoint <JID>" +
+                                         str(self._remote_wps_endpoint) +
+                                         "</JID> <MSG>" +
+                                         msg.replace('\n', ' ').replace('\r', '') + "</MSG>")
+                except BaseException:
+                    sys.stdout.write("[XMPP Disconnected]: Process <UID>" +
+                                     str(self._uniqueExeId) +
+                                     "</UID> Could not send error message to GeoServer Endpoint <JID>" +
+                                     str(self._remote_wps_endpoint) +
+                                     "</JID> <MSG>" +
+                                     msg.replace('\n', ' ').replace('\r', '') + "</MSG>")
+
+        logger.debug("send error msg complete")
         thread.interrupt_main()
         os._exit(-1)
 
diff --git a/src/wpsremote/resource_cleaner.py b/src/wpsremote/resource_cleaner.py
index c9a22e2..2afb2dd 100644
--- a/src/wpsremote/resource_cleaner.py
+++ b/src/wpsremote/resource_cleaner.py
@@ -4,10 +4,6 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import configInstance
 import os
 import path
@@ -20,21 +16,28 @@
 import logging
 import traceback
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
 
 class Resource(object):
     """
     Identify a process generated by a remote WPS call.
-    Every processbot (aka request handler) create a resource file in pid_files_dir once started. 
-    The method Resource.cleanup() looks fore pending resource files and if found might decide to kill process id found inside the file.
+    Every processbot (aka request handler) create a resource file in pid_files_dir once started.
+    The method Resource.cleanup() looks fore pending resource files and if found
+    might decide to kill process id found inside the file.
     """
     sleep_time_seconds = 3600
     process_time_threshold = None
     workdir_time_threshold = None
-    pid_files_dir = None #dir where file for each resource is stored
-    
+    pid_files_dir = None  # dir where file for each resource is stored
+
     @staticmethod
     def get_pid_files_dir():
-        return Resource.pid_files_dir if isinstance(Resource.pid_files_dir, path.path) else path.path(Resource.pid_files_dir)
+        return Resource.pid_files_dir if isinstance(
+    Resource.pid_files_dir, path.path) else path.path(
+        Resource.pid_files_dir)
 
     @staticmethod
     def clean_up_all():
@@ -47,7 +50,7 @@ def clean_up_all():
     @staticmethod
     def clean_up_iteration():
         logger = logging.getLogger("Resource.clean_up")
-        logger.debug("Sleep for " +  str(Resource.sleep_time_seconds.total_seconds()) + " seconds")
+        logger.debug("Sleep for " + str(Resource.sleep_time_seconds.total_seconds()) + " seconds")
         time.sleep(Resource.sleep_time_seconds.total_seconds())
         logger.debug("look for resources to clean up")
         Resource.pid_files_dir = Resource.get_pid_files_dir()
@@ -60,23 +63,23 @@ def clean_up_iteration():
     @staticmethod
     def create_from_file(unique_id, process_bot_pid=None):
         r = Resource()
-        if process_bot_pid ==  None:
-            r.set_processbot_pid(os.getpid()) 
+        if process_bot_pid is None:
+            r.set_processbot_pid(os.getpid())
         else:
-            r.set_processbot_pid(process_bot_pid) 
-        r.set_unique_id(unique_id) 
+            r.set_processbot_pid(process_bot_pid)
+        r.set_unique_id(unique_id)
         r.read()
         return r
 
     def __init__(self):
-        self._start_time = None #process start time
-        self._processbot_cmd_line = None #processbot (aka request handler) cmd line
-        self._unique_id = None #processbot (aka request handler) unique execution id (used to crate sand box dir)
-        self._sandbox_path = None #processbot (aka request handler) sandbox path
-        self._processbot_pid = None #processbot (aka request handler) Process id
-        self._spawned_process_pids = None #processbot (aka request handler) spawned processes ids
-        self._spawned_process_cmd = None #processbot (aka request handler) spawned processes cmd lines
-        self._path =  Resource.get_pid_files_dir() #dir where file for each resource is stored
+        self._start_time = None  # process start time
+        self._processbot_cmd_line = None  # processbot (aka request handler) cmd line
+        self._unique_id = None  # processbot (aka request handler) unique execution id (used to crate sand box dir)
+        self._sandbox_path = None  # processbot (aka request handler) sandbox path
+        self._processbot_pid = None  # processbot (aka request handler) Process id
+        self._spawned_process_pids = None  # processbot (aka request handler) spawned processes ids
+        self._spawned_process_cmd = None  # processbot (aka request handler) spawned processes cmd lines
+        self._path = Resource.get_pid_files_dir()  # dir where file for each resource is stored
 
     def start_time(self):
         return self._start_time
@@ -88,7 +91,7 @@ def cmd_line(self):
         return self._processbot_cmd_line
 
     def unique_id(self):
-        return self._unique_id 
+        return self._unique_id
 
     def set_unique_id(self, unique_id):
         self._unique_id = unique_id
@@ -103,71 +106,71 @@ def set_processbot_pid(self, pid):
         self._processbot_pid = int(pid)
 
     def spawned_process_pids(self):
-        return self._spawned_process_pids 
+        return self._spawned_process_pids
 
     def spawned_process_cmd(self):
         return self._spawned_process_cmd
 
     def set_from_servicebot(self, unique_id, sendbox_path):
-        self._start_time = self.now() 
+        self._start_time = self.now()
         self._unique_id = unique_id
         self._sandbox_path = sendbox_path
-    
+
     def set_from_processbot(self, processbot_pid, spawned_process_pids):
         """create the resource except for the information realted to the processbot spawned processes"""
-        #if not processbot_pid in psutil.pids():
+        # if not processbot_pid in psutil.pids():
         if not psutil.pid_exists(processbot_pid):
             raise Exception("cannot find process bot pid + " + str(processbot_pid))
-        proc = psutil.Process( processbot_pid )
+        proc = psutil.Process(processbot_pid)
         try:
             self._processbot_cmd_line = ' '.join(proc.cmdline())
-        except:
+        except BaseException:
             self._processbot_cmd_line = ' '.join(proc.cmdline)
         self._processbot_pid = processbot_pid
 
         """add the processbot spawned processes pids and cmdline to the resource"""
-        self._spawned_process_pids=spawned_process_pids
+        self._spawned_process_pids = spawned_process_pids
         self._spawned_process_cmd = []
-        removed=[]
+        removed = []
         for pid in self._spawned_process_pids:
             pid = int(pid)
-            #if pid is dead remove it from the list
-            #if not pid in psutil.pids():
+            # if pid is dead remove it from the list
+            # if not pid in psutil.pids():
             if not psutil.pid_exists(pid):
-                removed.append( pid )
+                removed.append(pid)
             else:
                 try:
-                    #here pid *should* exists, however get cmd line in try, except block
-                    proc = psutil.Process( pid )
+                    # here pid *should* exists, however get cmd line in try, except block
+                    proc = psutil.Process(pid)
                     try:
-                        self._spawned_process_cmd.append( ' '.join(proc.cmdline()) )
-                    except:
-                        self._spawned_process_cmd.append( ' '.join(proc.cmdline) )
-                except:
-                    removed.append( pid )
+                        self._spawned_process_cmd.append(' '.join(proc.cmdline()))
+                    except BaseException:
+                        self._spawned_process_cmd.append(' '.join(proc.cmdline))
+                except BaseException:
+                    removed.append(pid)
         self._spawned_process_pids = list(set(self._spawned_process_pids) - set(removed))
 
     def now(self):
         return datetime.datetime.now()
 
     def filepath(self):
-        #return self._path / str(self._processbot_pid) + "__" + str(self._unique_id) + ".pid"
+        # return self._path / str(self._processbot_pid) + "__" + str(self._unique_id) + ".pid"
         return self._path / str(self._unique_id) + ".pid"
 
     def read(self):
         if self.filepath().exists():
-            self.read_from_file(  self.filepath() )
+            self.read_from_file(self.filepath())
 
     def read_from_file(self, filepath):
-        config = configInstance.create( filepath, raw= True) #todo: use file lock
+        config = configInstance.create(filepath, raw=True)  # todo: use file lock
         self._start_time = config.get("DEFAULT", "start_time")
-        try: 
-            self._start_time = datetime.datetime.strptime( self._start_time, "%Y-%m-%dT%H:%M:%S" )
-        except:
-            self._start_time = datetime.datetime.strptime( "2000-01-01T00:00:00", "%Y-%m-%dT%H:%M:%S" )
+        try:
+            self._start_time = datetime.datetime.strptime(self._start_time, "%Y-%m-%dT%H:%M:%S")
+        except BaseException:
+            self._start_time = datetime.datetime.strptime("2000-01-01T00:00:00", "%Y-%m-%dT%H:%M:%S")
 
         self._processbot_cmd_line = config.get("DEFAULT", "cmd_line")
-        if self._processbot_cmd_line != None and self._processbot_cmd_line !='':
+        if self._processbot_cmd_line is not None and self._processbot_cmd_line != '':
             self._processbot_cmd_line = json.loads(self._processbot_cmd_line)
 
         self._unique_id = config.get("DEFAULT", "unique_id")
@@ -178,47 +181,47 @@ def read_from_file(self, filepath):
             self._processbot_pid = config.get("DEFAULT", "processbot_pid")
 
         self._spawned_process_pids = config.get("DEFAULT", "spawned_process_pids")
-        if self._spawned_process_pids != None and self._spawned_process_pids !='':
-            self._spawned_process_pids = json.loads( self._spawned_process_pids )
-        
+        if self._spawned_process_pids is not None and self._spawned_process_pids != '':
+            self._spawned_process_pids = json.loads(self._spawned_process_pids)
+
         self._spawned_process_cmd = config.get("DEFAULT", "spawned_process_cmd")
-        if self._spawned_process_cmd != None and self._spawned_process_cmd !='':
+        if self._spawned_process_cmd is not None and self._spawned_process_cmd != '':
             self._spawned_process_cmd = json.loads(self._spawned_process_cmd)
-    
+
     def write(self):
         logger = logging.getLogger("Resource.write")
 
         if self.filepath().exists():
             self.filepath().remove()
-        
+
         config = ConfigParser.ConfigParser()
 
-        config.set("DEFAULT", "start_time",  self.start_time_as_str() if self._start_time != None else "") 
-        config.set("DEFAULT", "unique_id", self._unique_id )
-        config.set("DEFAULT", "sendbox_path", str(self._sandbox_path) )
+        config.set("DEFAULT", "start_time", self.start_time_as_str() if self._start_time is not None else "")
+        config.set("DEFAULT", "unique_id", self._unique_id)
+        config.set("DEFAULT", "sendbox_path", str(self._sandbox_path))
 
-        if self._processbot_pid != None:
-            config.set("DEFAULT", "processbot_pid", str(self._processbot_pid) ) 
+        if self._processbot_pid is not None:
+            config.set("DEFAULT", "processbot_pid", str(self._processbot_pid))
         else:
-            config.set("DEFAULT", "processbot_pid", "" ) 
+            config.set("DEFAULT", "processbot_pid", "")
 
-        if self._processbot_cmd_line != None:
-            config.set("DEFAULT", "cmd_line", json.dumps(self._processbot_cmd_line) ) 
+        if self._processbot_cmd_line is not None:
+            config.set("DEFAULT", "cmd_line", json.dumps(self._processbot_cmd_line))
         else:
-            config.set("DEFAULT", "cmd_line", "" ) 
+            config.set("DEFAULT", "cmd_line", "")
 
-        if self._spawned_process_pids != None:
-            config.set("DEFAULT", "spawned_process_pids", json.dumps(self._spawned_process_pids) ) 
+        if self._spawned_process_pids is not None:
+            config.set("DEFAULT", "spawned_process_pids", json.dumps(self._spawned_process_pids))
         else:
-            config.set("DEFAULT", "spawned_process_pids", "" ) 
+            config.set("DEFAULT", "spawned_process_pids", "")
 
-        if self._spawned_process_cmd != None:
-            config.set("DEFAULT", "spawned_process_cmd", json.dumps(self._spawned_process_cmd) ) 
+        if self._spawned_process_cmd is not None:
+            config.set("DEFAULT", "spawned_process_cmd", json.dumps(self._spawned_process_cmd))
         else:
-            config.set("DEFAULT", "spawned_process_cmd", "" ) 
+            config.set("DEFAULT", "spawned_process_cmd", "")
 
         try:
-            fp = self.filepath().open('wb') #todo: use file lock
+            fp = self.filepath().open('wb')  # todo: use file lock
             config.write(fp)
             fp.close()
         except Exception as ex:
@@ -230,10 +233,10 @@ def kill_spawned_process(self):
         res = []
         logger = logging.getLogger("Resource.kill_spawned_process")
         logger.info("Try to kill computational job process(es)")
-        for p,c in zip(self._spawned_process_pids, self._spawned_process_cmd):
-            res.append ( self.kill_process(p, c) )
+        for p, c in zip(self._spawned_process_pids, self._spawned_process_cmd):
+            res.append(self.kill_process(p, c))
         res = list(set(res))
-        return len(res)==0 or (len(res)==1 and res[0]) #all success
+        return len(res) == 0 or (len(res) == 1 and res[0])  # all success
 
     def kill_processbot(self):
         return self.kill_process(self._processbot_pid, self._processbot_cmd_line)
@@ -244,10 +247,10 @@ def kill_process(self, pid, cmd_line):
             try:
                 logger.info("request for killing process " + str(pid))
                 pid = int(pid)
-                #if pid in psutil.pids():
+                # if pid in psutil.pids():
                 if psutil.pid_exists(pid):
                     logger.info("process " + str(pid) + " exists try to kill...")
-                    proc = psutil.Process( pid )
+                    proc = psutil.Process(pid)
                     if proc.cmdline() == cmd_line:
                         try:
                             proc.kill()
@@ -255,15 +258,18 @@ def kill_process(self, pid, cmd_line):
                             return True
                         except Exception as ex:
                             logger.warning("Failure trying to kill process " + str(pid) + " due to: " + str(ex))
-                            logger.debug( traceback.format_exc() )
+                            logger.debug(traceback.format_exc())
                             return False
                     else:
-                        logger.info("pid " + str(pid) + " found but with wrong command line. Assuming resource was already correcly cleaned-up")
+                        logger.info(
+    "pid " +
+    str(pid) +
+     " found but with wrong command line. Assuming resource was already correcly cleaned-up")
                     return True
                 else:
                     logger.warning("pid " + str(pid) + " doesn't exist")
                     return True
-            except:
+            except BaseException:
                 logger.info("could not kill process " + str(pid))
 
     def delete_sandbox_dir(self):
@@ -276,7 +282,7 @@ def delete_sandbox_dir(self):
                 return True
             except Exception as ex:
                 logger.warning("Failure in deleting directory " + str(self._sandbox_path) + " due to: " + str(ex))
-                logger.debug( traceback.format_exc() )
+                logger.debug(traceback.format_exc())
                 return False
 
         else:
@@ -285,66 +291,77 @@ def delete_sandbox_dir(self):
 
     def clean_up(self):
         logger = logging.getLogger("Resource.clean_up")
-        now = self.now() 
-        dt = now - self._start_time 
+        now = self.now()
+        dt = now - self._start_time
         if dt > Resource.process_time_threshold:
-            logger.info("start to clean up resource: " + str(self) )    
-            res=[]
-            res.append( self.kill_spawned_process() )
-            res.append( self.kill_processbot() )
-            res.append( self.delete_sandbox_dir() )
-            
-            logger.debug( "kill computational job, kill request handler process,  delete sandbox dir = " + str(res))
+            logger.info("start to clean up resource: " + str(self))
+            res = []
+            res.append(self.kill_spawned_process())
+            res.append(self.kill_processbot())
+            res.append(self.delete_sandbox_dir())
+
+            logger.debug("kill computational job, kill request handler process,  delete sandbox dir = " +
+                         str(res))
             res = list(set(res))
-            if (len(res)==1 and res[0]): #all success
-                logger.info("all pending resource have been deallocated, remove resource file " + str(self.filepath()))
+            if (len(res) == 1 and res[0]):  # all success
+                logger.info("all pending resource have been deallocated, remove resource file " +
+                            str(self.filepath()))
                 self.filepath().remove()
             else:
-                logger.info("Cannot deallocate all pending resource, do not remove resource file " + str(self.filepath()))
+                logger.info("Cannot deallocate all pending resource, do not remove resource file " +
+                            str(self.filepath()))
         else:
-            logger.debug(str(self) + " is "+str(dt.total_seconds()) +" seconds old and it is not yet ready to be cleaned up, wait for next round")    
+            logger.debug(str(self) + " is "+str(dt.total_seconds()) +
+                         " seconds old and it is not yet ready to be cleaned up, wait for next round")
 
     def __str__(self):
-        return "process " + str(self._processbot_pid) + " working on " + str(self._sandbox_path) + " from " + self.start_time_as_str()
+        return "process " + str(self._processbot_pid) + " working on " + \
+                                str(self._sandbox_path) + " from " + self.start_time_as_str()
+
 
 class Test(unittest.TestCase):
 
     def test_workflow(self):
-        
+
         import subprocess
         import random
         sendbox_root = path.path("./")
 
-        Resource.sleep_time_seconds = datetime.timedelta( seconds=5)
-        Resource.process_time_threshold = datetime.timedelta( seconds=1)
-        Resource.workdir_time_threshold = datetime.timedelta( seconds=1)
+        Resource.sleep_time_seconds = datetime.timedelta(seconds=5)
+        Resource.process_time_threshold = datetime.timedelta(seconds=1)
+        Resource.workdir_time_threshold = datetime.timedelta(seconds=1)
         Resource.pid_files_dir = path.path("./")
 
-        #srv bot
-        #create process bot
+        # srv bot
+        # create process bot
         cmd = 'python -c "import time; time.sleep(80000)"'
-        invoked_process = subprocess.Popen(args=cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        invoked_process = subprocess.Popen(
+    args=cmd,
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE,
+     stderr=subprocess.STDOUT)
         prcbot_pid = invoked_process.pid
         unique_id = str(random.randint(1, 1000)).zfill(5)
-        sendbox_path =  sendbox_root / str(unique_id)
+        sendbox_path = sendbox_root / str(unique_id)
 
         r = Resource()
         r.set_from_servicebot(unique_id, sendbox_path)
         r.write()
 
-        #proc bot
-        #create computation job
+        # proc bot
+        # create computation job
         comp_job = subprocess.Popen(args=cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
-        #add the pid of the computational job to the resource file
+        # add the pid of the computational job to the resource file
         rc = Resource.create_from_file(unique_id, prcbot_pid)
-        rc.set_from_processbot( prcbot_pid, [ comp_job.pid ] ) 
+        rc.set_from_processbot(prcbot_pid, [comp_job.pid])
         rc.write()
 
-        #resource cleaner, should run in separate thread
+        # resource cleaner, should run in separate thread
         Resource.clean_up_iteration()
 
-        self.assertFalse( r.filepath().exists() )
+        self.assertFalse(r.filepath().exists())
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/src/wpsremote/resource_monitor.py b/src/wpsremote/resource_monitor.py
index b10c418..69f3d93 100644
--- a/src/wpsremote/resource_monitor.py
+++ b/src/wpsremote/resource_monitor.py
@@ -4,16 +4,14 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import threading
-import thread
-import time
 import psutil
 import logging
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
 logger = logging.getLogger("servicebot.resource_monitor")
 
 
@@ -21,7 +19,7 @@ class ResourceMonitor(threading.Thread):
 
     load_average_scan_minutes = 15
     cores = psutil.cpu_count()
-    cpu_perc  = []
+    cpu_perc = []
     vmem_perc = []
     lock = threading.Lock()
 
@@ -33,29 +31,29 @@ def __init__(self, load_average_scan_minutes):
         ResourceMonitor.vmem_perc.append(psutil.virtual_memory().percent)
         ResourceMonitor.vmem_perc.append(psutil.virtual_memory().percent)
 
-        ResourceMonitor.cpu_perc.append(psutil.cpu_percent(interval = 0, percpu= False))
-        ResourceMonitor.cpu_perc.append(psutil.cpu_percent(interval = 0, percpu= False))
+        ResourceMonitor.cpu_perc.append(psutil.cpu_percent(interval=0, percpu=False))
+        ResourceMonitor.cpu_perc.append(psutil.cpu_percent(interval=0, percpu=False))
 
         ResourceMonitor.lock.release()
 
     def proc_is_running(self, proc_defs):
         for proc in psutil.process_iter():
             try:
-                process = psutil.Process(proc.pid) # Get the process info using PID
+                process = psutil.Process(proc.pid)  # Get the process info using PID
                 if process.is_running():
-                    pid    = str(process.pid)
-                    ppid   = str(process.ppid)
-                    status = process.status()
+                    pid = str(process.pid)  # noqa
+                    ppid = str(process.ppid)  # noqa
+                    status = process.status()  # noqa
 
-                    cpu_percent = process.cpu_percent()
-                    mem_percent = process.memory_percent()
+                    cpu_percent = process.cpu_percent()  # noqa
+                    mem_percent = process.memory_percent()  # noqa
 
-                    rss = str(process.memory_info().rss)
-                    vms = str(process.memory_info().vms)
-                    username = process.username()
-                    name     = process.name() # Here is the process name
-                    path     = process.cwd()
-                    cmdline  = ' '.join(process.cmdline())
+                    rss = str(process.memory_info().rss)  # noqa
+                    vms = str(process.memory_info().vms)  # noqa
+                    username = process.username()  # noqa
+                    name = process.name()  # Here is the process name
+                    path = process.cwd()  # noqa
+                    cmdline = ' '.join(process.cmdline())  # noqa
 
                     print("Get the process info using (path, name, cmdline): [%s / %s / %s]" % (path, name, cmdline))
                     for _p in proc_defs:
@@ -64,9 +62,9 @@ def proc_is_running(self, proc_defs):
                         if (status.lower() != "sleeping") and \
                             ('name' in _p and _p['name'] in name) and \
                                 ('cwd' in _p and _p['cwd'] in path) and \
-                                    ('cmdline' in _p and _p['cmdline'] in cmdline):
+                                ('cmdline' in _p and _p['cmdline'] in cmdline):
                             return True
-            except:
+            except BaseException:
                 import traceback
                 tb = traceback.format_exc()
                 logger.debug(tb)
@@ -81,6 +79,7 @@ def run(self):
             ResourceMonitor.vmem_perc[0] = (ResourceMonitor.vmem_perc[1] + psutil.virtual_memory().percent) / 2.0
 
             ResourceMonitor.cpu_perc[1] = ResourceMonitor.cpu_perc[0]
-            ResourceMonitor.cpu_perc[0] = psutil.cpu_percent(interval = (ResourceMonitor.load_average_scan_minutes*60), percpu= False)
+            ResourceMonitor.cpu_perc[0] = psutil.cpu_percent(
+                interval=(ResourceMonitor.load_average_scan_minutes*60), percpu=False)
 
             ResourceMonitor.lock.release()
diff --git a/src/wpsremote/serviceTester.py b/src/wpsremote/serviceTester.py
index 73e1959..c98c984 100644
--- a/src/wpsremote/serviceTester.py
+++ b/src/wpsremote/serviceTester.py
@@ -4,34 +4,39 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import logging.config
+import logging
+import sleekxmpp
+import sys
+import os
+import inspect
+import pickle
+import urllib
+import time
+import hashlib
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import sys,os
-import logging, ConfigParser, thread, subprocess, inspect, pickle, json, socket, zipfile, shutil, urllib, re, time, hashlib, urllib, base64
-
 os.chdir(os.path.join(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
 sys.path.insert(0, os.getcwd())
 sys.path.append(os.path.abspath('lib'))
 
-import sleekxmpp
-import logging
-import logging.config
 
 class ServiceTester(sleekxmpp.ClientXMPP):
 
     def __init__(self, jid, password):
         sleekxmpp.ClientXMPP.__init__(self, jid, password)
-        self.jid=jid
-        self.register_plugin('xep_0004') # Data forms
-        self.register_plugin('xep_0030') # Service Discovery
-        self.register_plugin('xep_0045') # MUC
-        self.register_plugin('xep_0060') # MUC
-        self.register_plugin('xep_0077') # In-band Registration
-        self.register_plugin('xep_0078') # Non-SASL Authentication
-        self.register_plugin('xep_0199') # XMPP Ping
-        self.register_plugin('xep_0249') # Direct MUC invitation
+        self.jid = jid
+        self.register_plugin('xep_0004')  # Data forms
+        self.register_plugin('xep_0030')  # Service Discovery
+        self.register_plugin('xep_0045')  # MUC
+        self.register_plugin('xep_0060')  # MUC
+        self.register_plugin('xep_0077')  # In-band Registration
+        self.register_plugin('xep_0078')  # Non-SASL Authentication
+        self.register_plugin('xep_0199')  # XMPP Ping
+        self.register_plugin('xep_0249')  # Direct MUC invitation
         self.add_event_handler("session_start", self.start)
         self.add_event_handler("message", self.message)
 
@@ -40,14 +45,14 @@ def start(self, event):
         self.get_roster()
 
     def message(self, signal):
-      log=logging.getLogger("serviceTester")
-      if signal['type'] in ('normal', 'chat'):
-                line = signal['body'] 
-                log.info('Received XMPP bus signal: "%s"', line)
-                self.handleSignal(line, signal['from'])
-                 
+        log = logging.getLogger("serviceTester")
+        if signal['type'] in ('normal', 'chat'):
+            line = signal['body']
+            log.info('Received XMPP bus signal: "%s"', line)
+            self.handleSignal(line, signal['from'])
+
     def run(self):
-        if self.connect(("172.21.160.51",5223),use_tls=False, use_ssl=True):
+        if self.connect(("172.21.160.51", 5223), use_tls=False, use_ssl=True):
             self.channelJid = "default@conference.whale.nurc.nato.int"
             self.busResource = "admin@whale.nurc.nato.int"
             self.plugin['xep_0045'].joinMUC(self.channelJid, self.busResource, password="Crociera100!")
@@ -63,7 +68,7 @@ def gotOnline(self, presence):
         ''' If got online event fired:
                 - if self gotOnline: configureChat
                 - if service got online: invite
-        
+
             @param msg: the got online msg
         '''
         if 'master' in str(presence['muc']['nick']):
@@ -72,10 +77,10 @@ def gotOnline(self, presence):
 
     def sendInvitation(self, servicejid):
         ''' send invitation to a service to register with the orchestrator
-        
+
             @param jid: the jid which should be invited
         '''
-        log=logging.getLogger("serviceTester")
+        log = logging.getLogger("serviceTester")
         log.debug('Send Invitation to %s', servicejid)
         self.send_message(servicejid, mbody='topic=invite')
         pass
@@ -84,17 +89,17 @@ def handleSignal(self, signal, origin):
         ''' Handle an incoming signal either via IPC BUS or XMPP
             @param signal: the message body
         '''
-        
+
         signalArgs = None
         try:
             signalArgs = dict([tuple(each.strip().split('=')) for each in signal.split('&')])
-        except:
+        except BaseException:
             logging.error('Bus signal "%s" not supported (Error: %s)', signal, sys.exc_info()[0])
-        
-        # This is a list of supported bus signals that trigger an action  
+
+        # This is a list of supported bus signals that trigger an action
         if signalArgs is not None:
             # Handle topic
-            if signalArgs.has_key('topic'):
+            if 'topic' in signalArgs:
                 if signalArgs['topic'] == 'register':
                     logging.info('Registering remote service "%s"' % signalArgs['service'])
                     logging.debug('Received a request for "%s"', signalArgs['service'])
@@ -104,18 +109,16 @@ def handleSignal(self, signal, origin):
                     logging.debug('received progress msg with value %s', signalArgs['message'])
 
                 elif signalArgs['topic'] == 'log':
-                    logging.debug('Received log msg with level %s msg=%s', signalArgs['level'],signalArgs['message'] )
+                    logging.debug('Received log msg with level %s msg=%s', signalArgs['level'], signalArgs['message'])
 
                 elif signalArgs['topic'] == 'completed':
-                    msgbody='topic=finished' + '&id=' + self.pid
-                    logging.debug( msgbody )
+                    msgbody = 'topic=finished' + '&id=' + self.pid
+                    logging.debug(msgbody)
                     self.send_message(origin, mbody=msgbody)
                 elif signalArgs['topic'] == 'error':
-                    logging.debug( "**** error ****" )
-                    logging.debug( msgbody )
+                    logging.debug("**** error ****")
+                    logging.debug(msgbody)
 
-                        
-              
             else:
                 logging.warn('Bus signal "%s" provides no topic', signal)
 
@@ -124,93 +127,105 @@ def invokeService(self, service, origin):
         request = self.request_oaa_custom_riskmap()
 
         requestPickle = pickle.dumps(request)
-        msgPickledURLEnc=urllib.quote(requestPickle)
+        msgPickledURLEnc = urllib.quote(requestPickle)
 
-        self.pid = hashlib.md5(str(time.time())).hexdigest()[-5:] + '_' + hashlib.md5('%s%s' % (service, urllib.quote(msgPickledURLEnc))).hexdigest()
+        self.pid = hashlib.md5(str(time.time())).hexdigest(
+        )[-5:] + '_' + hashlib.md5('%s%s' % (service, urllib.quote(msgPickledURLEnc))).hexdigest()
 
         # Send Request to the Service
-        msgbody='topic=request&service=' + service + '&id=' + self.pid + '&message=' + msgPickledURLEnc + '&baseURL=localhost'
+        msgbody = 'topic=request&service=' + service + '&id=' + self.pid + \
+                  '&message=' + msgPickledURLEnc + '&baseURL=localhost'
         print msgbody
         self.send_message(origin, mbody=msgbody)
 
     def request_ok(self):
-        request = {u'asset': [u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 10.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 62.0, \n        "type": "Frigate", \n        "id": 1, \n        "Pd": 0.6, \n        "name": "Ship 1"\n    }\n}',
-            u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 10.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 60.0, \n        "type": "Frigate", \n        "id": 2, \n        "Pd": 0.6, \n        "name": "Ship 2"\n    }\n}',
-            u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 5.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 3, \n        "Pd": 0.6, \n        "name": "Ship 3"\n    }\n}',
-            u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 5.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 4, \n        "Pd": 0.6, \n        "name": "Ship 4"\n    }\n}'],
+        request = {
+            u'asset': [
+                u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 10.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 62.0, \n        "type": "Frigate", \n        "id": 1, \n        "Pd": 0.6, \n        "name": "Ship 1"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 10.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 60.0, \n        "type": "Frigate", \n        "id": 2, \n        "Pd": 0.6, \n        "name": "Ship 2"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 5.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 3, \n        "Pd": 0.6, \n        "name": "Ship 3"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 0.001, \n        "maxSpeed": 10, \n        "minSpeed": 2, \n        "maxHeading": 2.1, \n        "minHeading": -2.1, \n        "lat0": 5.0, \n        "cost": 1e-06, \n        "obsRange": 50000, \n        "heading0": 0, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 4, \n        "Pd": 0.6, \n        "name": "Ship 4"\n    }\n}'  # noqa
+            ],
             'numberOfEvaluations': 600,
             'referenceDate': '20140901',
             'timeHorizon': 259200,
-            'minlon' : 50.0,
-            'maxlon' : 70.0,
-            'minlat' : 0,
-            'maxlat' : 20.0
-            }
+            'minlon': 50.0,
+            'maxlon': 70.0,
+            'minlat': 0,
+            'maxlat': 20.0
+        }
+
         return request
 
     def request_error(self):
-        request = {u'asset': [
-            u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 62.0, \n        "type": "Frigate", \n        "id": 1, \n        "Pd": 1, \n        "name": "Ship 1"\n    }\n}',
-            u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 60.0, \n        "type": "Frigate", \n        "id": 2, \n        "Pd": 1, \n        "name": "Ship 2"\n    }\n}',
-            u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 3, \n        "Pd": 1, \n        "name": "Ship 3"\n    }\n}',
-            u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 4, \n        "Pd": 1, \n        "name": "Ship 4"\n    }\n}'],
+        request = {
+            u'asset': [
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 62.0, \n        "type": "Frigate", \n        "id": 1, \n        "Pd": 1, \n        "name": "Ship 1"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 60.0, \n        "type": "Frigate", \n        "id": 2, \n        "Pd": 1, \n        "name": "Ship 2"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 3, \n        "Pd": 1, \n        "name": "Ship 3"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 4, \n        "Pd": 1, \n        "name": "Ship 4"\n    }\n}'  # noqa
+            ],
             'numberOfEvaluations': 600,
             'referenceDate': '20140901',
             'timeHorizon': 259200,
-            'minlon' : 50.0,
-            'maxlon' : 70.0,
-            'minlat' : 0,
-            'maxlat' : 20.0
-            }
+            'minlon': 50.0,
+            'maxlon': 70.0,
+            'minlat': 0,
+            'maxlat': 20.0
+        }
+
         return request
 
     def request_riskmap(self):
         request = {
-            'referenceDate' : '20150115',
-            'minlon' : 50.0,
-            'maxlon' : 70.0,
-            'minlat' : 0,
-            'maxlat' : 20.0,
-            'baseWCSURL' : 'karapthos',
-            'layerName' : 'testlayer',
-            'outputFormat' : 'GeoTiff',
-            'requestCRS' : '3426',
-            'outputCRS' : '4326',
-            'resX' :  200,
-            'resY' :  200,
-            'workdir' : 'd:\\tmp2\\'
-            }
+            'referenceDate': '20150115',
+            'minlon': 50.0,
+            'maxlon': 70.0,
+            'minlat': 0,
+            'maxlat': 20.0,
+            'baseWCSURL': 'karapthos',
+            'layerName': 'testlayer',
+            'outputFormat': 'GeoTiff',
+            'requestCRS': '3426',
+            'outputCRS': '4326',
+            'resX': 200,
+            'resY': 200,
+            'workdir': 'd:\\tmp2\\'
+        }
+
+        return request
 
     def request_oaa_custom_riskmap(self):
         request = {
-            'referenceDate' : '20150115',
+            'referenceDate': '20150115',
             'numberOfEvaluations': 600,
             'timeHorizon': 259200,
             u'asset': [
-                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 62.0, \n        "type": "Frigate", \n        "id": 1, \n        "Pd": 1, \n        "name": "Ship 1"\n    }\n}',
-                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 60.0, \n        "type": "Frigate", \n        "id": 2, \n        "Pd": 1, \n        "name": "Ship 2"\n    }\n}',
-                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 3, \n        "Pd": 1, \n        "name": "Ship 3"\n    }\n}',
-                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 4, \n        "Pd": 1, \n        "name": "Ship 4"\n    }\n}'
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 62.0, \n        "type": "Frigate", \n        "id": 1, \n        "Pd": 1, \n        "name": "Ship 1"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 10.0, \n       "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 60.0, \n        "type": "Frigate", \n        "id": 2, \n        "Pd": 1, \n        "name": "Ship 2"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 3, \n        "Pd": 1, \n        "name": "Ship 3"\n    }\n}',  # noqa
+                u'{\n    "Asset": {\n        "Pfa": 1, \n        "maxSpeed": 1, \n        "minSpeed": 1, \n        "maxHeading": 1, \n        "minHeading": 1, \n        "lat0": 5.0, \n        "cost": 1, \n        "obsRange": 1, \n        "heading0": 1, \n        "lon0": 58.0, \n        "type": "Frigate", \n        "id": 4, \n        "Pd": 1, \n        "name": "Ship 4"\n    }\n}'  # noqa
             ],
-            'minlon' : 50.0,
-            'maxlon' : 70.0,
-            'minlat' : 0,
-            'maxlat' : 20.0,
-            'owsBaseURL' : 'http://karpathos-dev/geoserver/wcs',
-            'owsService' : 'WCS',
-            'owsVersion' : '1.0.0',
-            'requestCRS' : 'EPSG:4326',
-            'timeResolution' : 3,
-            'owsResourceIdentifier' : 'TDA:PAGM'
+            'minlon': 50.0,
+            'maxlon': 70.0,
+            'minlat': 0,
+            'maxlat': 20.0,
+            'owsBaseURL': 'http://karpathos-dev/geoserver/wcs',
+            'owsService': 'WCS',
+            'owsVersion': '1.0.0',
+            'requestCRS': 'EPSG:4326',
+            'timeResolution': 3,
+            'owsResourceIdentifier': 'TDA:PAGM'
         }
 
         return request
 
+
 if __name__ == '__main__':
     logging.config.fileConfig("logger_serviceTester.properties")
-    log=logging.getLogger("serviceTester")
+    log = logging.getLogger("serviceTester")
     log.debug("start tester")
-    
-    xmpp = ServiceTester("admin@whale.nurc.nato.int","Crociera100!")
-    
+
+    xmpp = ServiceTester("admin@whale.nurc.nato.int", "Crociera100!")
+
     xmpp.run()
diff --git a/src/wpsremote/servicebot.py b/src/wpsremote/servicebot.py
index de29a91..f2b0f44 100644
--- a/src/wpsremote/servicebot.py
+++ b/src/wpsremote/servicebot.py
@@ -4,13 +4,6 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
-import os
-import psutil
-
 import introspection
 import thread
 from collections import OrderedDict
@@ -19,7 +12,6 @@
 import datetime
 import logging
 import re
-import sys
 
 import busIndipendentMessages
 
@@ -29,55 +21,73 @@
 import resource_cleaner
 import resource_monitor
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
 
-class ServiceBot(object):
 
-    """This script is the remote WPS agent. One instance of this agent runs on each computational node connected to the WPS for each algorithm available. The script runs continuosly.
+class ServiceBot(object):
     """
+    This script is the remote WPS agent. One instance of this agent runs on each
+    computational node connected to the WPS for each algorithm available.
+    The script runs continuosly.
+    """
+
     def __init__(self, remote_config_filepath, service_config_filepath):
 
-        #read remote config file
+        # read remote config file
         self._remote_config_filepath = remote_config_filepath
         remote_config = configInstance.create(self._remote_config_filepath)
-        bus_class_name = remote_config.get("DEFAULT", "bus_class_name") #identify the class implementation of the cominication bus
-        self._resource_file_dir = remote_config.get_path("DEFAULT", "resource_file_dir") # directory used to store file for resource cleaner
+        # identify the class implementation of the cominication bus
+        bus_class_name = remote_config.get("DEFAULT", "bus_class_name")
+        # directory used to store file for resource cleaner
+        self._resource_file_dir = remote_config.get_path("DEFAULT", "resource_file_dir")
         if remote_config.has_option("DEFAULT", "wps_execution_shared_dir"):
-            self._wps_execution_shared_dir = remote_config.get_path("DEFAULT", "wps_execution_shared_dir") # directory used to store the process encoded outputs (usually on a shared fs)
+            # directory used to store the process encoded outputs (usually on a shared fs)
+            self._wps_execution_shared_dir = remote_config.get_path("DEFAULT", "wps_execution_shared_dir")
 
-            #ensure outdir exists
+            # ensure outdir exists
             if not self._wps_execution_shared_dir.exists():
                 self._wps_execution_shared_dir.mkdir()
         else:
             self._wps_execution_shared_dir = None
 
-        #read service config, with raw=true that is without config file's value interpolation. Interpolation values are prodice only for the process bot (request hanlder); for example the unique execution id value to craete the sand box directory
+        # read service config, with raw=true that is without config file's value
+        # interpolation. Interpolation values are prodice only for the process bot
+        # (request hanlder); for example the unique execution id value to craete
+        # the sand box directory
         self._service_config_file = service_config_filepath
-        serviceConfig = configInstance.create(service_config_filepath, case_sensitive=True, variables = {'wps_execution_shared_dir' : self._wps_execution_shared_dir}, raw=True)
-        self.service = serviceConfig.get("DEFAULT", "service") #WPS service name?
+        serviceConfig = configInstance.create(
+    service_config_filepath, case_sensitive=True, variables={
+        'wps_execution_shared_dir': self._wps_execution_shared_dir}, raw=True)
+        self.service = serviceConfig.get("DEFAULT", "service")  # WPS service name?
         self.namespace = serviceConfig.get("DEFAULT", "namespace")
-        self.description = serviceConfig.get("DEFAULT", "description") #WPS service description
-        self._active = serviceConfig.get("DEFAULT", "active").lower() == "true" #True
-        self._output_dir =  serviceConfig.get_path("DEFAULT", "output_dir")
-        self._max_running_time = datetime.timedelta( seconds = serviceConfig.getint("DEFAULT", "max_running_time_seconds") )
+        self.description = serviceConfig.get("DEFAULT", "description")  # WPS service description
+        self._active = serviceConfig.get("DEFAULT", "active").lower() == "true"  # True
+        self._output_dir = serviceConfig.get_path("DEFAULT", "output_dir")
+        self._max_running_time = datetime.timedelta(seconds=serviceConfig.getint("DEFAULT", "max_running_time_seconds"))
 
         try:
             import json
             self._process_blacklist = json.loads(serviceConfig.get("DEFAULT", "process_blacklist"))
-        except:
+        except BaseException:
             self._process_blacklist = []
 
         input_sections = OrderedDict()
         for input_section in [s for s in serviceConfig.sections() if 'input' in s.lower() or 'const' in s.lower()]:
-            #service bot doesn't have yet the execution unique id, thus the serviceConfig is read with raw=True to avoid config file variables interpolation
+            # service bot doesn't have yet the execution unique id, thus the
+            # serviceConfig is read with raw=True to avoid config file variables
+            # interpolation
             input_sections[input_section] = serviceConfig.items_without_defaults(input_section, raw=True)
-        self._input_parameters_defs = computation_job_inputs.ComputationJobInputs.create_from_config( input_sections )
+        self._input_parameters_defs = computation_job_inputs.ComputationJobInputs.create_from_config(input_sections)
 
-        output_sections=OrderedDict()
+        output_sections = OrderedDict()
         for output_section in [s for s in serviceConfig.sections() if 'output' in s.lower()]:
             output_sections[output_section] = serviceConfig.items_without_defaults(output_section, raw=True)
-        self._output_parameters_defs = output_parameters.OutputParameters.create_from_config( output_sections, self._wps_execution_shared_dir )
+        self._output_parameters_defs = output_parameters.OutputParameters.create_from_config(
+            output_sections, self._wps_execution_shared_dir)
 
-        #create the concrete bus object
+        # create the concrete bus object
         self.bus = introspection.get_class_three_arg(bus_class_name, remote_config, self.service, self.namespace)
 
         self.bus.RegisterMessageCallback(busIndipendentMessages.InviteMessage, self.handle_invite)
@@ -86,18 +96,20 @@ def __init__(self, remote_config_filepath, service_config_filepath):
         # -- Register here the callback to the "getloadavg" message
         self.bus.RegisterMessageCallback(busIndipendentMessages.GetLoadAverageMessage, self.handle_getloadavg)
 
-        #self._lock_running_process =  thread.allocate_lock() #critical section to access running_process from separate threads
-        self.running_process={}
+        # self._lock_running_process =  thread.allocate_lock() #critical section
+        # to access running_process from separate threads
+        self.running_process = {}
 
-        self._redirect_process_stdout_to_logger = True #send the process bot (aka request handler) stdout to service bot (remote wps agent) log file
+        # send the process bot (aka request handler) stdout to service bot (remote wps agent) log file
+        self._redirect_process_stdout_to_logger = True
         self._remote_wps_endpoint = None
 
         # Allocate and start a Resource Monitoring Thread
         try:
             load_average_scan_minutes = serviceConfig.getint("DEFAULT", "load_average_scan_minutes")
-        except:
+        except BaseException:
             load_average_scan_minutes = 15
-        self._resource_monitor = resource_monitor.ResourceMonitor( load_average_scan_minutes )
+        self._resource_monitor = resource_monitor.ResourceMonitor(load_average_scan_minutes)
         self._resource_monitor.start()
 
     def get_resource_file_dir(self):
@@ -127,8 +139,11 @@ def handle_invite(self, invite_message):
                 self.bus.xmpp.reconnect()
                 self.bus.xmpp.send_presence()
                 # self.bus.xmpp.get_roster()
-            except:
-                logger.info( "[XMPP Disconnected]: Service "+str(self.service)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
+            except BaseException:
+                logger.info("[XMPP Disconnected]: Service " +
+                            str(self.service) +
+                            " Could not send info message to GeoServer Endpoint " +
+                            str(self._remote_wps_endpoint))
         self.bus.SendMessage(
             busIndipendentMessages.RegisterMessage(invite_message.originator(),
                                                    self.service,
@@ -143,30 +158,36 @@ def handle_execute(self, execute_message):
         """Handler for WPS execute message."""
         logger = logging.getLogger("servicebot.handle_execute")
 
-        #save execute messsage to tmp file to enable the process bot to read the inputs
+        # save execute messsage to tmp file to enable the process bot to read the inputs
         tmp_file = tempfile.NamedTemporaryFile(prefix='wps_params_', suffix=".tmp", delete=False)
-        execute_message.serialize( tmp_file )
+        execute_message.serialize(tmp_file)
         param_filepath = tmp_file.name
         tmp_file.close()
-        logger.debug("save parameters file for executing process " + self.service+  " in " + param_filepath)
+        logger.debug("save parameters file for executing process " + self.service + " in " + param_filepath)
 
-        #create the Resource Cleaner file containing the process info. The "invoked_process.pid" will be set by the spawned process itself
+        # create the Resource Cleaner file containing the process info. The
+        # "invoked_process.pid" will be set by the spawned process itself
         try:
             r = resource_cleaner.Resource()
-            #create a resource...
+            # create a resource...
             r.set_from_servicebot(execute_message.UniqueId(), self._output_dir / execute_message.UniqueId())
-            #... and save to file
+            # ... and save to file
             logger.info("Start the resource cleaner!")
             r.write()
         except Exception as ex:
-            logger.exception("Resource Cleaner initialization error")
-
-        #invoke the process bot (aka request handler) asynchronously
-        cmd = 'python wpsagent.py -r ' + self._remote_config_filepath + ' -s ' + self._service_config_file + ' -p ' + param_filepath + ' process'
-        invoked_process = subprocess.Popen(args=cmd.split(), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-        logger.info("created process " + self.service +  " with PId " + str(invoked_process.pid) + " and cmd: " + cmd )
-
-        #use a parallel thread to wait the end of the request handler process and get the exit code of the just created asynchronous process computation
+            logger.exception("Resource Cleaner initialization error", ex)
+
+        # invoke the process bot (aka request handler) asynchronously
+        cmd = 'python wpsagent.py -r ' + self._remote_config_filepath + ' -s ' + \
+            self._service_config_file + ' -p ' + param_filepath + ' process'
+        invoked_process = subprocess.Popen(args=cmd.split(),
+                                           stdin=subprocess.PIPE,
+                                           stdout=subprocess.PIPE,
+                                           stderr=subprocess.STDOUT)
+        logger.info("created process " + self.service + " with PId " + str(invoked_process.pid) + " and cmd: " + cmd)
+
+        # use a parallel thread to wait the end of the request handler process and
+        # get the exit code of the just created asynchronous process computation
         thread.start_new_thread(self.output_parser_verbose, (invoked_process, param_filepath,))
 
         logger.info("end of execute message handler, going back in listening mode")
@@ -179,19 +200,19 @@ def handle_getloadavg(self, getloadavg_message):
 
         try:
             loadavg = self._resource_monitor.cpu_perc[0]
-            vmem    = self._resource_monitor.vmem_perc[0]
+            vmem = self._resource_monitor.vmem_perc[0]
 
             logger.info("Scanning Running Process. Declared Black List: %s" % self._process_blacklist)
-            if self._resource_monitor.proc_is_running(self._process_blacklist) == True:
+            if self._resource_monitor.proc_is_running(self._process_blacklist):
                 logger.info("A process listed in blacklist is running! Setting loadavg and vmem to (100.0, 100.0)")
                 loadavg = 100.0
-                vmem    = 100.0
+                vmem = 100.0
             else:
                 logger.info("No blacklisted process was found. Setting loadavg and vmem to (%s, %s)" % (loadavg, vmem))
 
             outputs = dict()
             outputs['loadavg'] = [loadavg, 'Average Load on CPUs during the last 15 minutes.']
-            outputs['vmem']    = [vmem, 'Percentage of Memory used by the server.']
+            outputs['vmem'] = [vmem, 'Percentage of Memory used by the server.']
 
             # Send the message back to the WPS
             if self.bus.state() != 'connected':
@@ -199,28 +220,22 @@ def handle_getloadavg(self, getloadavg_message):
                     self.bus.xmpp.reconnect()
                     self.bus.xmpp.send_presence()
                     # self.bus.xmpp.get_roster()
-                except:
-                    logger.info( "[XMPP Disconnected]: Service "+str(self.service)+" Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
+                except BaseException:
+                    logger.info("[XMPP Disconnected]: Service "+str(self.service) +
+                                " Could not send info message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
             self.bus.SendMessage(
                 busIndipendentMessages.LoadAverageMessage(
                     getloadavg_message.originator(),
                     outputs
-                    )
                 )
+            )
         except Exception as ex:
-            logger.exception("Load Average initialization error")
-
-    #def output_parser(self, invoked_process):
-    #    #silently wait the end of the computaion
-    #    logger = logging.getLogger("servicebot.output_parser")
-    #    return_code = invoked_process.wait()
-    #    logger.info("Process " + self.service +  " PId " + str(invoked_process.pid)  + " terminated with exit code " + str(return_code) )
-    #    if return_code != 0:
-    #        logger.critical("Process " + self.service +  " PId " + str(invoked_process.pid)  + " terminated with exit code " + str(return_code))
+            logger.exception("Load Average initialization error", ex)
 
     def output_parser_verbose(self, invoked_process, param_filepath):
         logger = logging.getLogger("servicebot.output_parser_verbose")
-        logger.info("wait for end of execution of created process " + self.service +  ", PId " + str(invoked_process.pid) )
+        logger.info("wait for end of execution of created process " +
+                    self.service + ", PId " + str(invoked_process.pid))
 
         gs_UID = None
         gs_JID = None
@@ -238,57 +253,68 @@ def output_parser_verbose(self, invoked_process, param_filepath):
                         gs_JID = gs_JID_search.group(1)
 
                         gs_MSG = gs_JID_search = re.search('<MSG>(.*)</MSG>', line, re.IGNORECASE).group(1)
-                    except:
+                    except BaseException:
                         pass
 
                 if self._redirect_process_stdout_to_logger:
                     line = line.strip()
                     logger.debug("[SERVICE] " + line)
             else:
-                logger.debug("created process " + self.service +  ", PId " + str(invoked_process.pid) + " stopped send data on stdout")
-                break #end of stream
+                logger.debug("created process " + self.service + ", PId " +
+                             str(invoked_process.pid) + " stopped send data on stdout")
+                break  # end of stream
 
-        #wait for process exit code
+        # wait for process exit code
         return_code = invoked_process.wait()
         if return_code != 0:
-            msg = "Process " + self.service +  " PId " + str(invoked_process.pid)  + " terminated with exit code " + str(return_code)
+            msg = "Process " + self.service + " PId " + \
+                str(invoked_process.pid) + " terminated with exit code " + str(return_code)
             logger.critical(msg)
 
             logger.debug("gs_UID[%s] / gs_JID[%s]" % (gs_UID, gs_JID))
             if gs_UID and gs_JID:
-                self.bus.SendMessage( busIndipendentMessages.ErrorMessage( gs_JID, msg + " Exception: " + str(gs_MSG), gs_UID ) )
+                self.bus.SendMessage(busIndipendentMessages.ErrorMessage(
+                    gs_JID, msg + " Exception: " + str(gs_MSG), gs_UID))
             elif self._remote_wps_endpoint:
-                self.bus.SendMessage( busIndipendentMessages.ErrorMessage( self._remote_wps_endpoint, msg ) )
+                self.bus.SendMessage(busIndipendentMessages.ErrorMessage(self._remote_wps_endpoint, msg))
             else:
                 exe_msg = None
                 try:
                     logger.debug("Trying to recover Originator from Process Params!")
-                    exe_msg = busIndipendentMessages.ExecuteMessage.deserialize( param_filepath )
+                    exe_msg = busIndipendentMessages.ExecuteMessage.deserialize(param_filepath)
                     if exe_msg.originator():
-                        self.bus.SendMessage( busIndipendentMessages.ErrorMessage( exe_msg.originator(), msg + " Exception: remote process exception. Please check outputs!", exe_msg.UniqueId() ) )
-                except:
+                        self.bus.SendMessage(busIndipendentMessages.
+                                             ErrorMessage(exe_msg.originator(),
+                                                          msg +
+                                                          " Exception: remote process exception. Please check outputs!",
+                                                          exe_msg.UniqueId()))
+                except BaseException:
                     pass
                 if not exe_msg:
-                    msg = "Process " + self.service +  " PId " + str(invoked_process.pid)  + " STALLED! Don't know who to send ERROR Message..."
+                    msg = "Process " + self.service + " PId " + \
+                        str(invoked_process.pid) + " STALLED! Don't know who to send ERROR Message..."
                     logger.error(msg)
         else:
-            msg = "Process " + self.service +  " PId " + str(invoked_process.pid)  + " terminated successfully!"
+            msg = "Process " + self.service + " PId " + str(invoked_process.pid) + " terminated successfully!"
             logger.debug(msg)
 
     def send_error_message(self, msg):
         logger = logging.getLogger("ServiceBot.send_error_message")
-        logger.error( msg )
+        logger.error(msg)
         if self.bus.state() != 'connected':
             try:
                 self.bus.xmpp.reconnect()
                 self.bus.xmpp.send_presence()
                 # self.bus.xmpp.get_roster()
-            except:
-                logger.info( "[XMPP Disconnected]: Service "+str(self.service)+" Could not send error message to GeoServer Endpoint "+str(self._remote_wps_endpoint))
+            except BaseException:
+                logger.info("[XMPP Disconnected]: Service " +
+                            str(self.service) +
+                            " Could not send error message to GeoServer Endpoint " +
+                            str(self._remote_wps_endpoint))
         if self._remote_wps_endpoint:
-            self.bus.SendMessage( busIndipendentMessages.ErrorMessage(  self._remote_wps_endpoint, msg ) )
+            self.bus.SendMessage(busIndipendentMessages.ErrorMessage(self._remote_wps_endpoint, msg))
         else:
-            msg = "Process " + str(self.service) +  " STALLED! Don't know who to send ERROR Message..."
+            msg = "Process " + str(self.service) + " STALLED! Don't know who to send ERROR Message..."
             logger.error(msg)
 
     def disconnect(self):
diff --git a/src/wpsremote/sftpUpload.py b/src/wpsremote/sftpUpload.py
index 3ace4d7..0f48df9 100644
--- a/src/wpsremote/sftpUpload.py
+++ b/src/wpsremote/sftpUpload.py
@@ -4,6 +4,15 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import paramiko
+import pickle
+import md5
+import os
+import string
+import logging      # if not std, http://www.red-dove.com/python_logging.html
+import path         # http://www.jorendorff.com/articles/python/path
+import upload
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
@@ -14,11 +23,6 @@
 Based on paramiko sftp client.
 """
 
-import paramiko, pickle, sys, md5, os, string
-import logging      # if not std, http://www.red-dove.com/python_logging.html
-import path         # http://www.jorendorff.com/articles/python/path
-import upload
-
 
 class EzFtp:
     """
@@ -27,6 +31,7 @@ class EzFtp:
     Lets you use full pathnames, with server-side
     directory management handled automatically.
     """
+
     def __init__(self, ftp):
         self.ftp = ftp
         self.serverDir = ''
@@ -58,12 +63,12 @@ def cd(self, dir, create=1):
                     try:
                         logging.info("ftpcd %s" % d)
                         self.ftp.exec_command('cd '+d+'; pwd')
-                    except:
+                    except BaseException:
                         if create:
                             logging.info("ftpmkdir %s" % d)
                             try:
                                 self.ftp.mkdir(d)
-                            except:
+                            except BaseException:
                                 pass
                             self.ftp.exec_command('cd '+d+'; pwd')
                         else:
@@ -79,7 +84,7 @@ def putasc(self, this, that):
         self.cd(thatDir)
         f = open(this, "r")
         logging.info("ftpstorasc %s" % that)
-        self.ftp.putfo(f,thatFile)
+        self.ftp.putfo(f, thatFile)
 
     def putbin(self, this, that):
         """
@@ -89,7 +94,7 @@ def putbin(self, this, that):
         self.cd(thatDir)
         f = open(this, "rb")
         logging.info("ftpstorbin %s" % that)
-        self.ftp.putfo(f,thatFile)
+        self.ftp.putfo(f, thatFile)
 
     def delete(self, that):
         """
@@ -100,7 +105,7 @@ def delete(self, that):
             logging.info("ftpdel %s" % that)
             try:
                 self.ftp.remove(thatFile)
-            except:
+            except BaseException:
                 pass
 
     def quit(self):
@@ -155,14 +160,14 @@ def setHost(self, host, username, password):
         """
         try:
             hoststr, portstr = host.split(':')
-        except:
+        except BaseException:
             hoststr = host
             portstr = None
         if portstr:
             transport = paramiko.Transport((hoststr, int(portstr)))
         else:
             transport = paramiko.Transport((hoststr, 22))
-        transport.connect(username = username, password = password)
+        transport.connect(username=username, password=password)
         self.ftp = paramiko.SFTPClient.from_transport(transport)
 
     def setMd5File(self, md5file):
@@ -270,4 +275,3 @@ def finish(self):
             outf = open(self.md5file, "w")
             pickle.dump(self.md5DictUp, outf)
             outf.close()
-
diff --git a/src/wpsremote/termination_handler.py b/src/wpsremote/termination_handler.py
index 8ecd9f0..022f5b2 100644
--- a/src/wpsremote/termination_handler.py
+++ b/src/wpsremote/termination_handler.py
@@ -4,19 +4,19 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import SocketServer
 import socket
 import threading
-import path 
+import path
 import os
-import thread
 import datetime
 
-class  TerminationHandler(object):
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
+class TerminationHandler(object):
     def __init__(self, handler):
         self._handler = handler
 
@@ -37,30 +37,34 @@ def __init__(self, handler):
     def _write_pid_file(self):
         pid = os.getpid()
         workdir = path.path("d:\\tmp\\wpsproc\\")
-        pidfile = workdir / path.path(str(pid) +  ".pid")
+        pidfile = workdir / path.path(str(pid) + ".pid")
 
         if pidfile.exists():
             pidfile.remove()
 
-        pidfile.write_lines( ['cmdline=', 'pid='+str(pid), 'start_time=' + str(datetime.datetime.now()), 'tcp_port=' + str(self.port) ] )
+        pidfile.write_lines(['cmdline=', 'pid='+str(pid), 'start_time=' +
+                             str(datetime.datetime.now()), 'tcp_port=' + str(self.port)])
 
 
 class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
-    
+
     def handle(self):
-        data = self.request.recv(1024)
+        data = self.request.recv(1024)  # noqa
 
-        #if (data=="kill"):
+        # if (data=="kill"):
         cur_thread = threading.current_thread()
-        response = "{}: {}".format( cur_thread.name, self._handle() )
+        response = "{}: {}".format(cur_thread.name, self._handle())
         self.request.sendall(response)
 
+
 class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
     pass
 
+
 def clean_up1(threadedTCPRequestHandler):
     return "clean_up1"
 
+
 def clean_up2(threadedTCPRequestHandler):
     return "clean_up2"
 
@@ -78,12 +82,13 @@ def client(ip, port, message):
 
 # #############################################################
 
+
 class WatchDog(object):
     """
         run as service every 15 minutes
 
         #iterate over pids of all process bots
-        for pid in path.path("d:\\tmp\\wpsproc\\").files(): #[1.pid, 2.pid,] 
+        for pid in path.path("d:\\tmp\\wpsproc\\").files(): #[1.pid, 2.pid,]
             read file:
                 cmdline=...
                 pid=...
@@ -95,26 +100,26 @@ class WatchDog(object):
                 open socket(port)
                 write "kill" to socket
 
-                
+
             elif pids is not running:
                 del "/var/proc/wpsproc/<pid>.pid
 
-           
+
     """
     pass
 
 # #############################################################
 
+
 if __name__ == '__main__':
     # Port 0 means to select an arbitrary unused port
 
-    th =TerminationHandler(clean_up1)
-
+    th = TerminationHandler(clean_up1)
 
     client(th.ip, th.port, "Hello World 1")
     client(th.ip, th.port, "Hello World 2")
     client(th.ip, th.port, "Hello World 3")
 
-    #server.shutdown()
+    # server.shutdown()
 
-    #th.set_handler(clean_up2)
\ No newline at end of file
+    # th.set_handler(clean_up2)
diff --git a/src/wpsremote/upload.py b/src/wpsremote/upload.py
index 1e6a074..204bdbf 100644
--- a/src/wpsremote/upload.py
+++ b/src/wpsremote/upload.py
@@ -8,9 +8,10 @@
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
+
 class Upload(object):
     def __init__(self, host, username, password, id):
-        self.callbacks={}
+        self.callbacks = {}
         self.id = id
         self.host = host
         self.username = username
diff --git a/src/wpsremote/wpsagent.py b/src/wpsremote/wpsagent.py
index fdd86c8..cbccc2d 100644
--- a/src/wpsremote/wpsagent.py
+++ b/src/wpsremote/wpsagent.py
@@ -4,14 +4,10 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import logging.config
 import logging
 import argparse
-import sys 
+import sys
 import thread
 import path
 import traceback
@@ -22,62 +18,74 @@
 import busIndipendentMessages
 import resource_cleaner
 
-#-p d:\users\cimino\appdata\local\temp\wps_params_wprbze.tmp process
-#-r .\\configs\\remote.config -s .\\configs\\RiskMaps\\service.config -p d:\\users\\cimino\\appdata\\local\\temp\\wps_params_q_245x.tmp process
-#-r .\configs\remote.config -s .\configs\RiskMaps\service.config service
-#-r .\configs\remote.config -s .\configs\OAAonDemand\service.config service
-#-r .\configs\remote.config -s .\configs\OAAonDemand\service.config -p d:\users\cimino\appdata\local\temp\wps_params_ullgiw.tmp process
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+# -p d:\users\cimino\appdata\local\temp\wps_params_wprbze.tmp process
+# -r .\\configs\\remote.config -s .\\configs\\RiskMaps\\service.config -p \
+#    d:\\users\\cimino\\appdata\\local\\temp\\wps_params_q_245x.tmp process
+# -r .\configs\remote.config -s .\configs\RiskMaps\service.config service
+# -r .\configs\remote.config -s .\configs\OAAonDemand\service.config service
+# -r .\configs\remote.config -s .\configs\OAAonDemand\service.config -p \
+#   d:\users\cimino\appdata\local\temp\wps_params_ullgiw.tmp process
+
 
 class WPSAgent(object):
     def __init__(self, args):
-        #remove sleek xmpp logging 
+        # remove sleek xmpp logging
         self.verbose = False
-        self.args=args
+        self.args = args
 
     def find_logger_property_file(self, find_logger_property_file_path):
-        if self.args.logconf == None:
+        if self.args.logconf is None:
             logger_properties_file = find_logger_property_file_path / "logger.properties"
         else:
             logger_properties_file = self.args.logconf
         return logger_properties_file
-    
+
     @staticmethod
-    def log_bootstrap_error( msg, stack_trace):
+    def log_bootstrap_error(msg, stack_trace):
         sys.stderr.write(msg + "\n")
         sys.stderr.write(stack_trace + "\n")
 
     @staticmethod
-    def set_resource_cleaner_parameters(pid_files_dir,process_time_threshold, workdir_time_threshold, sleep_time_seconds):
+    def set_resource_cleaner_parameters(
+    pid_files_dir,
+    process_time_threshold,
+    workdir_time_threshold,
+     sleep_time_seconds):
         resource_cleaner.Resource.pid_files_dir = pid_files_dir
         resource_cleaner.Resource.process_time_threshold = process_time_threshold
         resource_cleaner.Resource.workdir_time_threshold = workdir_time_threshold
         resource_cleaner.Resource.sleep_time_seconds = sleep_time_seconds
 
     @staticmethod
-    def create_logger( logger_config_file, workdir, verbose):
-        defaults={}
-        if workdir != None:
+    def create_logger(logger_config_file, workdir, verbose):
+        defaults = {}
+        if workdir is not None:
             defaults['workdir'] = workdir
-            #to avoid problems with escape sequence (\ab is apparently a valid hex number?!?!?), use always linux style path separator
+            # to avoid problems with escape sequence (\ab is apparently a valid hex
+            # number?!?!?), use always linux style path separator
             if '\\' in defaults['workdir']:
-                defaults['workdir']=defaults['workdir'].replace('\\', '/')
+                defaults['workdir'] = defaults['workdir'].replace('\\', '/')
 
-        logging.config.fileConfig(str(logger_config_file),  defaults=defaults)
+        logging.config.fileConfig(str(logger_config_file), defaults=defaults)
 
         logger = logging.getLogger("main.create_logger")
         if not verbose:
-            #drop logs from sleekxmlpp
+            # drop logs from sleekxmlpp
             for h in logger.root.handlers:
                 h.addFilter(SleekXMPPLoggerFilter())
 
         logger.debug("Logger initialized with file " + str(logger_config_file))
 
     def create_bot(self):
-        #template method
+        # template method
         pass
 
     def run(self):
-        #we now have a logger
+        # we now have a logger
         logger = logging.getLogger("WPSAgent.run")
         try:
             bot = self.create_bot()
@@ -86,73 +94,90 @@ def run(self):
         except Exception as e:
             msg = "Bot failure due to: " + str(e)
             logger.fatal(msg)
-            logger.fatal( traceback.format_exc() )
-            bot.send_error_message( msg )
+            logger.fatal(traceback.format_exc())
+            bot.send_error_message(msg)
             bot.disconnect()
-            logger.fatal( "Exit Bot process with code " + str(101) )
+            logger.fatal("Exit Bot process with code " + str(101))
             sys.exit(101)
 
+
 class WPSAgentProcess(WPSAgent):
-    """This script starts when the user call a new WPS execution. 
-        His task is to call the proper external executable/scripts according to the service.config file (option -s in command line) and send back to the WPS logging and progress 
-        information and error information if something unexpected happens.
-        All the output including the log file is generated in a sand box directory created with joint information from service.config and external process start-up information.
-        """
+    """
+    This script starts when the user call a new WPS execution.
+    His task is to call the proper external executable/scripts according to
+    the service.config file (option -s in command line) and send back to the
+    WPS logging and progress information and error information if something
+    unexpected happens. All the output including the log file is generated
+    in a sand box directory created with joint information from service.config
+    and external process start-up information.
+    """
+
     def __init__(self, args):
         super(WPSAgentProcess, self).__init__(args)
         try:
             config_dir_service = path.path(args.serviceconfig).dirname()
-            #deserilize pickled object with process startup info to get the unique_id to create the sand box work dir for the process execution
-            self.exe_msg = busIndipendentMessages.ExecuteMessage.deserialize( args.params )
-             
-            #read the service config file with interpolation=true (raw=False) to get the proper sand box work dir using the unique id as input parameter
-            #args.remoteconfig, args.serviceconfig
-            serviceConfig = configInstance.create(args.serviceconfig , case_sensitive=True, variables = {'unique_exe_id' : self.exe_msg.UniqueId()}, raw=False) 
+            # deserilize pickled object with process startup info to get the unique_id
+            # to create the sand box work dir for the process execution
+            self.exe_msg = busIndipendentMessages.ExecuteMessage.deserialize(args.params)
+
+            # read the service config file with interpolation=true (raw=False) to get
+            # the proper sand box work dir using the unique id as input parameter
+            # args.remoteconfig, args.serviceconfig
+            serviceConfig = configInstance.create(
+    args.serviceconfig, case_sensitive=True, variables={
+        'unique_exe_id': self.exe_msg.UniqueId()}, raw=False)
             work_dir = serviceConfig.get_path("DEFAULT", "workdir")
 
-            #ensure outdir exists
+            # ensure outdir exists
             if not work_dir.exists():
                 work_dir.mkdir()
 
-            #now i can create a logger with output log file in the sandbox dir
-            WPSAgent.create_logger( self.find_logger_property_file(config_dir_service), work_dir, self.verbose)
+            # now i can create a logger with output log file in the sandbox dir
+            WPSAgent.create_logger(self.find_logger_property_file(config_dir_service), work_dir, self.verbose)
 
         except Exception as e:
-            #here log is not available use log_bootstrap_error func to log somewhere else (e.g. operating system error log, tmp file, stdout)
+            # here log is not available use log_bootstrap_error func to log somewhere
+            # else (e.g. operating system error log, tmp file, stdout)
             msg = "Failure during bot bootstrap due to : " + str(e)
             WPSAgent.log_bootstrap_error(msg, traceback.format_exc())
             sys.exit(100)
-        
-        #start execution
+
+        # start execution
         self.run()
 
     def create_bot(self):
         try:
             logger = logging.getLogger("WPSAgentProcess.create_bot")
             logger.info("Create process bot")
-            bot =  processbot.ProcessBot( self.args.remoteconfig, self.args.serviceconfig,  self.exe_msg )
-            #create resource cleaner
-            self.set_resource_cleaner_parameters(bot.get_resource_file_dir(), bot.max_execution_time(), bot.max_execution_time(), bot.max_execution_time())
+            bot = processbot.ProcessBot(self.args.remoteconfig, self.args.serviceconfig, self.exe_msg)
+            # create resource cleaner
+            self.set_resource_cleaner_parameters(
+    bot.get_resource_file_dir(),
+    bot.max_execution_time(),
+    bot.max_execution_time(),
+     bot.max_execution_time())
             return bot
         except Exception as e:
             msg = "Failure during bot bootstrap due to : " + str(e)
             WPSAgent.log_bootstrap_error(msg, traceback.format_exc())
             sys.exit(100)
 
+
 class WPSAgentService(WPSAgent):
 
     def __init__(self, args):
         try:
             super(WPSAgentService, self).__init__(args)
             remote_config_dir = path.path(args.remoteconfig).dirname()
-            self.create_logger(self.find_logger_property_file( remote_config_dir ), None, self.verbose)
+            self.create_logger(self.find_logger_property_file(remote_config_dir), None, self.verbose)
         except Exception as e:
-            #here log is not available use log_bootstrap_error func to log somewhere else (e.g. operating system error log, tmp file, stdout)
+            # here log is not available use log_bootstrap_error func to log somewhere
+            # else (e.g. operating system error log, tmp file, stdout)
             msg = "Failure during bot bootstrap due to : " + str(e)
             WPSAgent.log_bootstrap_error(msg, traceback.format_exc())
             sys.exit(100)
 
-        #start execution
+        # start execution
         self.run()
 
     def create_bot(self):
@@ -161,32 +186,46 @@ def create_bot(self):
             logger.info("Create process bot")
             bot = servicebot.ServiceBot(self.args.remoteconfig, self.args.serviceconfig)
             logger.info("Create resource cleaner")
-            WPSAgent.set_resource_cleaner_parameters(bot.get_resource_file_dir(), bot.max_execution_time(), bot.max_execution_time(), bot.max_execution_time())
-            #start infinite loop for resource clenaer thread
-            thread.start_new_thread( resource_cleaner.Resource.clean_up_all,())
+            WPSAgent.set_resource_cleaner_parameters(
+    bot.get_resource_file_dir(),
+    bot.max_execution_time(),
+    bot.max_execution_time(),
+     bot.max_execution_time())
+            # start infinite loop for resource clenaer thread
+            thread.start_new_thread(resource_cleaner.Resource.clean_up_all, ())
             return bot
         except Exception as e:
             msg = "Failure during bot bootstrap due to : " + str(e)
             WPSAgent.log_bootstrap_error(msg, traceback.format_exc())
             sys.exit(100)
 
+
 class SleekXMPPLoggerFilter(logging.Filter):
 
     def filter(self, record):
-        return not 'sleekxmpp' in record.name 
+        return 'sleekxmpp' not in record.name
+
 
 if __name__ == '__main__':
-    
+
     parser = argparse.ArgumentParser()
-    parser.add_argument("-r", "--remoteconfig", nargs='?', default="remote.config", help="Config file containing connection information on the calling agent (e.g. XMPP server)")
-    parser.add_argument("-s", "--serviceconfig",nargs='?', default="service.config", help="Config file containing information concerning the local process to be invoked by WPS")
-    parser.add_argument("-l", "--logconf", nargs="?", default=None, help="Logger config file if not provided logger.conf in remoteconfig directory (runtype=service) or logger.conf in serviceconfig directory (runtype=process) will be used")
+    parser.add_argument("-r", "--remoteconfig", nargs='?', default="remote.config",
+                        help="Config file containing connection information on the calling agent (e.g. XMPP server)")
+    parser.add_argument("-s", "--serviceconfig", nargs='?', default="service.config",
+                        help="Config file containing information concerning the local process to be invoked by WPS")
+    parser.add_argument(
+    "-l",
+    "--logconf",
+    nargs="?",
+    default=None,
+     help="Logger config file if not provided logger.conf in remoteconfig directory (runtype=service) or logger.conf \
+         in serviceconfig directory (runtype=process) will be used")
     parser.add_argument("-p", "--params", nargs="?", help="JSON file containing input parameters")
     parser.add_argument("-e", "--executionid", nargs="?", help="Unique execution id")
-    parser.add_argument("runtype", help="Run type [service|process])") #, choices=['service', 'process'])
+    parser.add_argument("runtype", help="Run type [service|process])")  # , choices=['service', 'process'])
     cmdargs = parser.parse_args()
 
-    if cmdargs.runtype=='service':
+    if cmdargs.runtype == 'service':
         WPSAgentService(cmdargs)
-    else: #process
+    else:  # process
         WPSAgentProcess(cmdargs)
diff --git a/src/wpsremote/xmppBus.py b/src/wpsremote/xmppBus.py
index defd7ad..2a9bcd8 100644
--- a/src/wpsremote/xmppBus.py
+++ b/src/wpsremote/xmppBus.py
@@ -4,10 +4,6 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
 import socket
 import logging
 import traceback
@@ -20,17 +16,24 @@
 import sys
 import time
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
 
 class XMPPBus(bus.Bus):
     def __init__(self, config, service_name, service_name_namespace, id="master"):
         bus.Bus.__init__(self, id)
 
-        self.config=config
-        self.address=(config.get("DEFAULT", "address"), config.get("DEFAULT", "port")) # As address use mnemonic names
+        self.config = config
+        self.address = (
+    config.get(
+        "DEFAULT", "address"), config.get(
+            "DEFAULT", "port"))  # As address use mnemonic names
         self.domain = config.get("DEFAULT", "domain")
         self.MUC_name = config.get("DEFAULT", "mucService")
-        self.username=config.get("DEFAULT", "user")
-        self.password=config.get("DEFAULT", "password")
+        self.username = config.get("DEFAULT", "user")
+        self.password = config.get("DEFAULT", "password")
         self.nameSpacePassword = config.get("DEFAULT", "mucServicePassword")
 
         self._service_name = service_name
@@ -38,27 +41,26 @@ def __init__(self, config, service_name, service_name_namespace, id="master"):
         self._fully_qualified_service_name = self._service_name_namespace + "." + self._service_name
 
         self.xmpp = sleekxmpp.ClientXMPP(self._get_JId(), self.password)
-        self.xmpp.register_plugin('xep_0004') # Data forms
-        self.xmpp.register_plugin('xep_0030') # Service Discovery
-        self.xmpp.register_plugin('xep_0045') # MUC
-        self.xmpp.register_plugin('xep_0060') # MUC
-        self.xmpp.register_plugin('xep_0077') # In-band Registration
-        self.xmpp.register_plugin('xep_0078') # Non-SASL Authentication
-        self.xmpp.register_plugin('xep_0199') # XMPP Ping
-        self.xmpp.register_plugin('xep_0249') # Direct MUC invitation
+        self.xmpp.register_plugin('xep_0004')  # Data forms
+        self.xmpp.register_plugin('xep_0030')  # Service Discovery
+        self.xmpp.register_plugin('xep_0045')  # MUC
+        self.xmpp.register_plugin('xep_0060')  # MUC
+        self.xmpp.register_plugin('xep_0077')  # In-band Registration
+        self.xmpp.register_plugin('xep_0078')  # Non-SASL Authentication
+        self.xmpp.register_plugin('xep_0199')  # XMPP Ping
+        self.xmpp.register_plugin('xep_0249')  # Direct MUC invitation
         self.xmpp.add_event_handler('register', self._register)
         self.xmpp.add_event_handler('session_start', self._startService)
         self.xmpp.add_event_handler('message', self._handleXMPPSignal)
 
-
     def clone_for_process(self, id):
-        c=XMPPBus(self.config, self._service_name, self._service_name_namespace, id)
+        c = XMPPBus(self.config, self._service_name, self._service_name_namespace, id)
         return c
 
-
     def _get_JId(self):
         # default.Service@whale.nurc.nato.int/master@WW717962
-        # return ''.join([self._fully_qualified_service_name, '@', self.domain, '/', self.id, '@', socket.gethostname()])
+        # return ''.join([self._fully_qualified_service_name, '@', self.domain,
+        # '/', self.id, '@', socket.gethostname()])
         return ''.join([self.username, '@', self.domain, '/', self.id, '@', socket.gethostname()])
 
     def _get_MUC_JId(self):
@@ -67,7 +69,6 @@ def _get_MUC_JId(self):
     def _MUC_service_nickname(self):
         return '%s@%s' % (self._service_name, str(self.xmpp.boundjid).split('@', 1).pop())
 
-
     def CheckServerIdentity(self, serverId):
         pass
 
@@ -83,11 +84,11 @@ def Listen(self):
                     try:
                         self.xmpp.send_presence()
                         # self.xmpp.get_roster()
-                        self.xmpp.process(block = True)
+                        self.xmpp.process(block=True)
                         break
-                    except:
+                    except BaseException:
                         stack_trace = traceback.format_exc(sys.exc_info())
-                        logging.exception( "Service "+str(self._service_name)+" Exception: "+str(stack_trace))
+                        logging.exception("Service "+str(self._service_name)+" Exception: "+str(stack_trace))
                     finally:
                         self.xmpp.disconnect()
                 else:
@@ -95,14 +96,18 @@ def Listen(self):
                     time.sleep(2)
 
     def _startService(self, event):
-        # once the connection is established, immidiatelly join the MUC, no notification is sent to the calling class (serviceBot and processBot)
+        # once the connection is established, immidiatelly join the MUC, no
+        # notification is sent to the calling class (serviceBot and processBot)
         self.JoinMUC()
 
     def JoinMUC(self):
-        self.xmpp.plugin['xep_0045'].joinMUC(self._get_MUC_JId(), self._MUC_service_nickname(), password=self.nameSpacePassword)
+        self.xmpp.plugin['xep_0045'].joinMUC(
+    self._get_MUC_JId(),
+    self._MUC_service_nickname(),
+     password=self.nameSpacePassword)
 
     def _handleXMPPSignal(self, msg):
-        imsg=self.CreateIndipendentMessage(msg)
+        imsg = self.CreateIndipendentMessage(msg)
         if (imsg is not None):
             self.callbacks[type(imsg)](imsg)
 
@@ -113,7 +118,7 @@ def CreateIndipendentMessage(self, msg):
 
             logging.info('Received XMPP bus signal from %s: "%s"' % (origin, payload))
 
-            #todo: check for role=moderator
+            # todo: check for role=moderator
             role = 'visitor'
             roster = self.xmpp.plugin['xep_0045'].getRoster(self._get_MUC_JId())
             if origin.resource in roster:
@@ -126,9 +131,11 @@ def CreateIndipendentMessage(self, msg):
                 if ("topic=request" in payload):
                     logging.info("handle request message from WPS " + str(payload))
                     variables = dict([tuple(each.strip().split('=')) for each in payload.split('&')])
-                    requestParams=pickle.loads(urllib.unquote(variables['message'])) if variables['message'] is not None else None
-                    #print str(variables)
-                    return busIndipendentMessages.ExecuteMessage( msg['from'], variables['id'], variables['baseURL'], requestParams )
+                    requestParams = pickle.loads(
+    urllib.unquote(
+        variables['message'])) if variables['message'] is not None else None
+                    return busIndipendentMessages.ExecuteMessage(
+    msg['from'], variables['id'], variables['baseURL'], requestParams)
                 elif ("topic=invite" in payload):
                     logging.info("handle invite message from WPS " + str(payload))
                     return busIndipendentMessages.InviteMessage(payload, msg['from'])
@@ -145,7 +152,7 @@ def CreateIndipendentMessage(self, msg):
         return None
 
     def SendMessage(self, message):
-        m=self.Convert(message)
+        m = self.Convert(message)
         m.send()
 
     def Stop(self, Message):
@@ -155,31 +162,53 @@ def _register(self, iq):
         pass
 
     def Convert(self, busIndipendentMsg):
-        if (type(busIndipendentMsg) is busIndipendentMessages.RegisterMessage):
-            return xmppMessages.XMPPRegisterMessage(self, busIndipendentMsg.originator(), busIndipendentMsg.service, busIndipendentMsg.namespace, busIndipendentMsg.description, busIndipendentMsg.input_parameters(), busIndipendentMsg.output)
-
-        if (type(busIndipendentMsg) is busIndipendentMessages.ProgressMessage):
-            return xmppMessages.XMPPProgressMessage(  busIndipendentMsg.originator, self, busIndipendentMsg.progress )
-
-        if (type(busIndipendentMsg) is busIndipendentMessages.LogMessage):
-            return xmppMessages.XMPPLogMessage(busIndipendentMsg.originator, self, busIndipendentMsg.level, busIndipendentMsg.msg)
-
-        if (type(busIndipendentMsg) is busIndipendentMessages.CompletedMessage):
-            return xmppMessages.XMPPCompletedMessage(busIndipendentMsg.originator, self, busIndipendentMsg.base_url, busIndipendentMsg.outputs() )
-
-        if (type(busIndipendentMsg) is busIndipendentMessages.ErrorMessage):
-            return xmppMessages.XMPPErrorMessage(busIndipendentMsg.originator, self, busIndipendentMsg.msg, busIndipendentMsg.id)
-
-        if (type(busIndipendentMsg) is busIndipendentMessages.AbortMessage):
-            return xmppMessages.XMPPErrorMessage(busIndipendentMsg.originator, self, busIndipendentMsg.msg, busIndipendentMsg.id)
-
-        if (type(busIndipendentMsg) is busIndipendentMessages.LoadAverageMessage):
-            return xmppMessages.XMPPLoadAverageMessage(busIndipendentMsg.originator, self, busIndipendentMsg.outputs() )
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.RegisterMessage)):
+            return xmppMessages.XMPPRegisterMessage(
+    self,
+    busIndipendentMsg.originator(),
+    busIndipendentMsg.service,
+    busIndipendentMsg.namespace,
+    busIndipendentMsg.description,
+    busIndipendentMsg.input_parameters(),
+     busIndipendentMsg.output)
+
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.ProgressMessage)):
+            return xmppMessages.XMPPProgressMessage(busIndipendentMsg.originator, self, busIndipendentMsg.progress)
+
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.LogMessage)):
+            return xmppMessages.XMPPLogMessage(
+    busIndipendentMsg.originator,
+    self,
+    busIndipendentMsg.level,
+     busIndipendentMsg.msg)
+
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.CompletedMessage)):
+            return xmppMessages.XMPPCompletedMessage(
+    busIndipendentMsg.originator,
+    self,
+    busIndipendentMsg.base_url,
+     busIndipendentMsg.outputs())
+
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.ErrorMessage)):
+            return xmppMessages.XMPPErrorMessage(
+    busIndipendentMsg.originator,
+    self,
+    busIndipendentMsg.msg,
+     busIndipendentMsg.id)
+
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.AbortMessage)):
+            return xmppMessages.XMPPErrorMessage(
+    busIndipendentMsg.originator,
+    self,
+    busIndipendentMsg.msg,
+     busIndipendentMsg.id)
+
+        if (isinstance(busIndipendentMsg, busIndipendentMessages.LoadAverageMessage)):
+            return xmppMessages.XMPPLoadAverageMessage(busIndipendentMsg.originator, self, busIndipendentMsg.outputs())
 
         else:
             raise Exception("unknown message")
 
-
     def disconnect(self):
         self.xmpp.disconnect(wait=True)
 
diff --git a/src/wpsremote/xmppMessages.py b/src/wpsremote/xmppMessages.py
index 001eb0a..edf1221 100644
--- a/src/wpsremote/xmppMessages.py
+++ b/src/wpsremote/xmppMessages.py
@@ -4,88 +4,99 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+# from sleekxmpp.exceptions import IqError, IqTimeout
+# import sleekxmpp
+import os
+import sys
+import inspect
+import urllib
+import json
+import logging
+import traceback
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import os, sys, inspect, urllib, json
-import logging
-import traceback
-
 os.chdir(os.path.join(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
 sys.path.insert(0, os.getcwd())
 sys.path.append(os.path.abspath('lib'))
 
-import sleekxmpp
-from sleekxmpp.exceptions import IqError, IqTimeout
 
 class XMPPPresenceMessage(object):
 
     def __init__(self, xmppChannel):
-        self.xmppChannel=xmppChannel
+        self.xmppChannel = xmppChannel
 
     def send(self):
         self.xmppChannel.send_presence()
         self.xmppChannel.JoinmMUC()
 
+
 class XMPPRegisterMessage(object):
 
     def __init__(self, xmppChannel, originator, service, namespace, descritpion, par, output):
-        self.xmppChannel=xmppChannel
-        self.originator=originator
-        self.service=service
-        self.namespace=namespace
-        self.description=descritpion
-        self._input_parameter=par
-        self.output=output
+        self.xmppChannel = xmppChannel
+        self.originator = originator
+        self.service = service
+        self.namespace = namespace
+        self.description = descritpion
+        self._input_parameter = par
+        self.output = output
 
     def title(self):
-        return self.namespace + "." + self.service 
+        return self.namespace + "." + self.service
 
     def send(self):
         service = {}
         service['title'] = self.title()
         service['namespace'] = self.namespace
         service['description'] = self.description
-        #process_buffer & result_size kept for back compatibility with STBGIS protocol 
+        # process_buffer & result_size kept for back compatibility with STBGIS protocol
         service['process_buffer'] = 0
         service['result_size'] = 0
-        service['input']= self._input_parameter
-        service['output']= self.output
-        body = ''.join(['topic=register', '&service=', self.xmppChannel.get_fully_qualified_service_name(), '&message=', urllib.quote(json.dumps(service))])
+        service['input'] = self._input_parameter
+        service['output'] = self.output
+        body = ''.join(['topic=register',
+                        '&service=',
+                        self.xmppChannel.get_fully_qualified_service_name(),
+                        '&message=',
+                        urllib.quote(json.dumps(service))])
 
-        #self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
         self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
 
+
 class XMPPProgressMessage(object):
 
     def __init__(self, originator, xmppChannel, progress):
-        self.xmppChannel=xmppChannel
-        self.progress=progress
-        self.originator=originator
+        self.xmppChannel = xmppChannel
+        self.progress = progress
+        self.originator = originator
 
     def send(self):
-        body = ''.join(['topic=progress', '&id=', self.xmppChannel.id, '&message=', str( self.progress)])
+        body = ''.join(['topic=progress', '&id=', self.xmppChannel.id, '&message=', str(self.progress)])
         self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
 
+
 class XMPPLogMessage(object):
 
     def __init__(self, originator, xmppChannel, level, msg):
-        self.xmppChannel=xmppChannel
-        self.level=level
-        self.msg=msg
-        self.originator=originator
+        self.xmppChannel = xmppChannel
+        self.level = level
+        self.msg = msg
+        self.originator = originator
 
     def send(self):
-        body = ''.join(['topic=log', '&id=', self.xmppChannel.id, '&level=', self.level, "&message=", self.msg ])
+        body = ''.join(['topic=log', '&id=', self.xmppChannel.id, '&level=', self.level, "&message=", self.msg])
         self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
 
+
 class XMPPCompletedMessage(object):
 
     def __init__(self, originator, xmppChannel, base_url, outputs):
         self.xmppChannel = xmppChannel
         self.originator = originator
-        
+
         self._base_url = base_url
         self._outputs = outputs
 
@@ -94,35 +105,38 @@ def send(self):
             message = ""
             for out_param_name, out_param_values in self._outputs.items():
                 result = dict()
-                result[out_param_name+'_value']         = out_param_values[0] #value
-                result[out_param_name+'_description']   = out_param_values[1] #description
-                result[out_param_name+'_title']         = out_param_values[2] #title
-                result[out_param_name+'_type']          = out_param_values[3] #type
-                result[out_param_name+'_pub']           = out_param_values[4] #publish as layer
-                result[out_param_name+'_layer_name']    = out_param_values[5] #publish layer name
-                result[out_param_name+'_style']         = out_param_values[6] #publish default Style
-                result[out_param_name+'_workspace']     = out_param_values[7] #publish target Workspace
-                result[out_param_name+'_metadata']      = out_param_values[8] #publish target MetaData
+                result[out_param_name+'_value'] = out_param_values[0]  # value
+                result[out_param_name+'_description'] = out_param_values[1]  # description
+                result[out_param_name+'_title'] = out_param_values[2]  # title
+                result[out_param_name+'_type'] = out_param_values[3]  # type
+                result[out_param_name+'_pub'] = out_param_values[4]  # publish as layer
+                result[out_param_name+'_layer_name'] = out_param_values[5]  # publish layer name
+                result[out_param_name+'_style'] = out_param_values[6]  # publish default Style
+                result[out_param_name+'_workspace'] = out_param_values[7]  # publish target Workspace
+                result[out_param_name+'_metadata'] = out_param_values[8]  # publish target MetaData
                 result_json = json.dumps(result)
-                result_json_url_enc=urllib.quote(result_json)
+                result_json_url_enc = urllib.quote(result_json)
                 if len(message) > 0:
                     message = message + "&"
                 message = message + out_param_name + "=" + result_json_url_enc
 
-            body = ''.join(['topic=completed', '&id=', self.xmppChannel.id,"&baseURL=",self._base_url, "&message=completed","&",message])
+            body = ''.join(['topic=completed', '&id=', self.xmppChannel.id, "&baseURL=",
+                            self._base_url, "&message=completed", "&", message])
             self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
-        except Exception, err:
-            body = ''.join(['topic=error', '&id=', self.xmppChannel.id, "&message=", "Critical error while encoding outuput!"])
+        except Exception:
+            body = ''.join(['topic=error', '&id=', self.xmppChannel.id,
+                            "&message=", "Critical error while encoding outuput!"])
             self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
             logging.exception(str(traceback.format_exc()))
             raise
 
+
 class XMPPErrorMessage(object):
 
     def __init__(self, originator, xmppChannel, msg, id=None):
         self.originator = originator
         self.xmppChannel = xmppChannel
-        self.msg  = msg
+        self.msg = msg
         if id:
             self.id = id
         else:
@@ -131,11 +145,12 @@ def __init__(self, originator, xmppChannel, msg, id=None):
     def send(self):
 
         error_json = json.dumps(self.msg)
-        error_json_url_enc=urllib.quote(error_json)
+        error_json_url_enc = urllib.quote(error_json)
 
         body = ''.join(['topic=error', '&id=', self.id, "&message=", error_json_url_enc])
         self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
 
+
 class XMPPLoadAverageMessage(object):
 
     def __init__(self, originator, xmppChannel, outputs):
@@ -148,19 +163,18 @@ def send(self):
             message = ""
             for out_param_name, out_param_values in self._outputs.items():
                 result = dict()
-                #print str(out_param_values)
-                result[out_param_name+'_value']         = out_param_values[0] #value
-                result[out_param_name+'_description']   = out_param_values[1] #description
+                result[out_param_name+'_value'] = out_param_values[0]  # value
+                result[out_param_name+'_description'] = out_param_values[1]  # description
                 result_json = json.dumps(result)
-                result_json_url_enc=urllib.quote(result_json)
+                result_json_url_enc = urllib.quote(result_json)
                 if len(message) > 0:
                     message = message + "&"
                 message = message + "result_" + out_param_name + "=" + result_json_url_enc
 
-            body = ''.join(['topic=loadavg', '&id=', self.xmppChannel.id, "&message=loadavg","&",message])
+            body = ''.join(['topic=loadavg', '&id=', self.xmppChannel.id, "&message=loadavg", "&", message])
             self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
-        except Exception, err:
+        except Exception:
             print traceback.format_exc()
-            body = ''.join(['topic=log', '&id=', self.xmppChannel.id, '&level=warning', "&message=", "Critical error while encoding LoadAverageMessage outuputs!"])
+            body = ''.join(['topic=log', '&id=', self.xmppChannel.id, '&level=warning', "&message=",
+                            "Critical error while encoding LoadAverageMessage outuputs!"])
             self.xmppChannel.xmpp.send_message(mto=self.originator, mbody=body, mtype='chat')
-
diff --git a/src/wpsremote/xmpp_data/configs/myservice/code/test.py b/src/wpsremote/xmpp_data/configs/myservice/code/test.py
index 560c953..e597c18 100644
--- a/src/wpsremote/xmpp_data/configs/myservice/code/test.py
+++ b/src/wpsremote/xmpp_data/configs/myservice/code/test.py
@@ -8,10 +8,6 @@
 import logging.config
 import logging
 import argparse
-import sys 
-import thread
-import traceback
-import logging
 import sys
 import os
 import uuid
@@ -19,7 +15,7 @@
 import time
 
 # constants
-#id = os.urandom(10)
+# id = os.urandom(10)
 id = str(uuid.uuid4())
 gdalContour = r'/usr/bin/gdal_contour'
 dst = r'contour_'+id[:13]
@@ -27,34 +23,36 @@
 cmd = '-a elev'  # just for example!
 interval = '-i'
 
+
 class GDALTest(object):
     def __init__(self, args):
-        self.args=args
+        self.args = args
         self.create_logger("logger_test.properties")
         self.logger.info("ProgressInfo:0.0%")
 
-
     def run(self):
         trg = '%s/../../../output/%s/%s.shp' % (os.path.dirname(os.path.abspath(__file__)), self.args.execution_id, dst)
 
-        #fullCmd = ' '.join([gdalContour, cmd, self.youCanQuoteMe(src), self.youCanQuoteMe(dst), interval, self.args.interval])
+        # fullCmd = ' '.join([gdalContour, cmd, self.youCanQuoteMe(src), \
+        #     self.youCanQuoteMe(dst), interval, self.args.interval])
         fullCmd = ' '.join([gdalContour, cmd, src, trg, interval, self.args.interval])
         self.logger.debug("Running command > " + fullCmd)
 
-        self.logger.info("going to sleep again...");
+        self.logger.info("going to sleep again...")
         time.sleep(30)   # Delays for 30 seconds. You can also use a float value.
 
-        proc=subprocess.Popen(fullCmd.split(), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False)
+        proc = subprocess.Popen(fullCmd.split(), stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False)
         for line in proc.stdout:
             self.logger.info(line)
 
-        #call communicate to retrieve return code of subprocess
+        # call communicate to retrieve return code of subprocess
         proc.communicate()
         ret = proc.returncode
 
-        self.logger.info("...waking up and going to sleep again...");
+        self.logger.info("...waking up and going to sleep again...")
         time.sleep(30)   # Delays for 30 seconds. You can also use a float value.
-        
+
         if (ret == 0):
             # zipf = zipfile.ZipFile(self.args.workdir+'/contour.zip', 'w')
             # self.zipdir(self.args.workdir+'/', zipf)
@@ -62,11 +60,11 @@ def run(self):
             zipf = zipfile.ZipFile(output_dir+'/contour.zip', 'w')
             self.zipdir(output_dir+'/', zipf)
             zipf.close()
-            
+
             self.logger.info("ProgressInfo:100%")
         else:
             self.logger.critical("Error occurred during processing.")
-            
+
         return ret
 
     # see note below
@@ -75,19 +73,20 @@ def youCanQuoteMe(self, item):
 
     def zipdir(self, path, zip):
         for root, dirs, files in os.walk(path):
-            files = [ fi for fi in files if fi.startswith(dst) ]
+            files = [fi for fi in files if fi.startswith(dst)]
             for file in files:
                 zip.write(os.path.join(root, file))
 
     def create_logger(self, logger_config_file):
-        defaults={}
+        defaults = {}
 
-        logging.config.fileConfig(str(logger_config_file),  defaults=defaults)
+        logging.config.fileConfig(str(logger_config_file), defaults=defaults)
 
         self.logger = logging.getLogger("main.create_logger")
 
         self.logger.debug("Logger initialized with file " + str(logger_config_file))
 
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument("-i", "--interval", nargs='?', default="10", help="Elevation interval between contours.")
diff --git a/test/__init__.py b/test/__init__.py
index b598346..93b8b0a 100644
--- a/test/__init__.py
+++ b/test/__init__.py
@@ -3,4 +3,3 @@
 # (c) 2013 - 2014 German Aerospace Center (DLR)
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
-
diff --git a/test/test_computation_job_inputs.py b/test/test_computation_job_inputs.py
index a70affe..61f06a3 100644
--- a/test/test_computation_job_inputs.py
+++ b/test/test_computation_job_inputs.py
@@ -4,12 +4,6 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
-__author__ = "Alessio Fabiani"
-__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
-__license__ = "GPL"
-
-import wpsremote
-
 import unittest
 import json
 import ConfigParser
@@ -23,17 +17,21 @@
 from wpsremote import computational_job_input_action_update_json_file
 from wpsremote import mockutils
 
+__author__ = "Alessio Fabiani"
+__copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
+__license__ = "GPL"
+
+
 class TestComputationJobInputs(unittest.TestCase):
 
     def test_set_int_param(self):
         p1 = computation_job_param.ComputationJobParam("mypar", "int", "par title", "par descr")
         p1.set_value("1")
-        self.assertEquals( p1.get_value_string(), "1" )
+        self.assertEquals(p1.get_value_string(), "1")
 
-                   
     def test_set_int_param_wrong_value(self):
         p1 = computation_job_param.ComputationJobParam("mypar", "int", "par title", "par descr")
-        #self.assertRaises( TypeError, p1.set_value("zxc") )
+        # self.assertRaises( TypeError, p1.set_value("zxc") )
         try:
             p1.set_value("all your base are belong to us")
             self.fail()
@@ -42,105 +40,119 @@ def test_set_int_param_wrong_value(self):
 
     def test_set_multiple_int_param(self):
         p1 = computation_job_param.ComputationJobParam("mypar", "int", "par title", "par descr", max_occurencies=2)
-        p1.set_value(["1","2"])
-        self.assertEquals( p1.get_value_string(), ["1","2"] )
+        p1.set_value(["1", "2"])
+        self.assertEquals(p1.get_value_string(), ["1", "2"])
 
     def test_set_multiple_int_param_wrong_occurrencies(self):
         p1 = computation_job_param.ComputationJobParam("mypar", "int", "par title", "par descr", max_occurencies=1)
         try:
-            p1.set_value(["1","2"])
+            p1.set_value(["1", "2"])
             self.fail()
         except TypeError:
             self.assertTrue(True)
 
-
     def test_two_params(self):
         p1 = computation_job_param.ComputationJobParam("mypar1", "int", "par 1", "par descr 1")
         p2 = computation_job_param.ComputationJobParam("mypar2", "string", "par 2", "par descr 2")
         inputs = computation_job_inputs.ComputationJobInputs()
-        inputs.add_input( [p1, p2] )
-        inputs.set_values( { "mypar1" : "1", "mypar2" : "abc"} )
-        self.assertEquals( p1.get_value_string(), "1" )
-        self.assertEquals( p2.get_value_string(), "abc" )
-
+        inputs.add_input([p1, p2])
+        inputs.set_values({"mypar1": "1", "mypar2": "abc"})
+        self.assertEquals(p1.get_value_string(), "1")
+        self.assertEquals(p2.get_value_string(), "abc")
 
     def test_cmd_line_action(self):
         inputs = computation_job_inputs.ComputationJobInputs()
-        inputs.add_input(  computation_job_param.ComputationJobParam("mypar1", "int", "par 1", "par descr 1") )
+        inputs.add_input(computation_job_param.ComputationJobParam("mypar1", "int", "par 1", "par descr 1"))
 
         actions = computational_job_input_actions.ComputationalJobInputActions()
-        actions.add_actions( computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam("mypar1", "--name=value") )
+        actions.add_actions(
+    computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam(
+        "mypar1", "--name=value"))
 
-        inputs.set_values( { "mypar1" : "1" } )
-        actions.execute( inputs )
+        inputs.set_values({"mypar1": "1"})
+        actions.execute(inputs)
 
         self.assertEquals(actions.get_cmd_line(), "--mypar1=1")
 
-
     def test_cmd_line_action_2_values(self):
         p1 = computation_job_param.ComputationJobParam("mypar1", "int", "par 1", "par descr 1")
         p2 = computation_job_param.ComputationJobParam("mypar2", "string", "par 2", "par descr 2")
         inputs = computation_job_inputs.ComputationJobInputs()
-        inputs.add_input( [p1, p2] )
-        
-        actions = computational_job_input_actions.ComputationalJobInputActions()
-        actions.add_actions( computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam("mypar1", "--name=value") )
-        actions.add_actions( computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam("mypar2", "--name=value") )
+        inputs.add_input([p1, p2])
 
+        actions = computational_job_input_actions.ComputationalJobInputActions()
+        actions.add_actions(computational_job_input_action_cmd_param.
+                            ComputationalJobInputActionCmdParam("mypar1", "--name=value"))
+        actions.add_actions(computational_job_input_action_cmd_param.
+                            ComputationalJobInputActionCmdParam("mypar2", "--name=value"))
 
-        inputs.set_values( { "mypar1" : "1", "mypar2" : "abc"} )
-        actions.execute( inputs )
+        inputs.set_values({"mypar1": "1", "mypar2": "abc"})
+        actions.execute(inputs)
 
         self.assertEquals(actions.get_cmd_line(), "--mypar1=1 --mypar2=abc")
 
     def test_create_json_file_action(self):
         p1 = computation_job_param.ComputationJobParam("mypar1", "application/json", "par 1", "par descr 1")
         inputs = computation_job_inputs.ComputationJobInputs()
-        inputs.add_input( p1 )
+        inputs.add_input(p1)
 
         actions = computational_job_input_actions.ComputationalJobInputActions()
-        a1 = computational_job_input_action_create_json_file.ComputationalJobInputActionCreateJSONFile("mypar1", path.path("./json_out_${json_path_expr}.json"), "['Asset']['id']", path.path("./src/wpsremote/xmpp_data/test/asset_schema.json")) 
-        actions.add_actions( a1 )
-        
-        
-        inputs.set_values( { "mypar1" : TestComputationJobInputs.json_text1 } )
-        actions.execute( inputs )
+        a1 = computational_job_input_action_create_json_file. \
+            ComputationalJobInputActionCreateJSONFile("mypar1",
+                                                      path.path("./json_out_${json_path_expr}.json"),
+                                                      "['Asset']['id']",
+                                                      path.path("./src/wpsremote/xmpp_data/test/asset_schema.json"))
+        actions.add_actions(a1)
 
-        self.assertTrue( a1.exists() )
+        inputs.set_values({"mypar1": TestComputationJobInputs.json_text1})
+        actions.execute(inputs)
+
+        self.assertTrue(a1.exists())
 
     def test_create_2_json_file_action(self):
-        p1 = computation_job_param.ComputationJobParam("mypar1", "application/json", "par 1", "par descr 1",  max_occurencies=2)
+        p1 = computation_job_param.ComputationJobParam("mypar1",
+                                                       "application/json",
+                                                       "par 1",
+                                                       "par descr 1",
+                                                       max_occurencies=2)
         inputs = computation_job_inputs.ComputationJobInputs()
-        inputs.add_input( p1 )
+        inputs.add_input(p1)
 
         actions = computational_job_input_actions.ComputationalJobInputActions()
-        a1 = computational_job_input_action_create_json_file.ComputationalJobInputActionCreateJSONFile("mypar1", path.path("./json_out_${json_path_expr}.json"), "['Asset']['id']", path.path("./src/wpsremote/xmpp_data/test/asset_schema.json")) 
-        actions.add_actions( a1 )
-        
-        
-        inputs.set_values(  { "mypar1" : [TestComputationJobInputs.json_text1, TestComputationJobInputs.json_text2] } )
-        actions.execute( inputs )
-
-        self.assertTrue( a1.exists() )
-        
+        a1 = computational_job_input_action_create_json_file. \
+            ComputationalJobInputActionCreateJSONFile("mypar1",
+                                                      path.path("./json_out_${json_path_expr}.json"),
+                                                      "['Asset']['id']",
+                                                      path.path("./src/wpsremote/xmpp_data/test/asset_schema.json"))
+        actions.add_actions(a1)
+
+        inputs.set_values({"mypar1": [TestComputationJobInputs.json_text1, TestComputationJobInputs.json_text2]})
+        actions.execute(inputs)
+
+        self.assertTrue(a1.exists())
+
     def test_update_json_file_action_with_int(self):
         target_json_file = path.path("./json_out.json")
         if target_json_file.exists():
             target_json_file.remove()
         source_template_json_file = path.path(r"./src/wpsremote/xmpp_data/test/CMREOAA_MainConfigFile_template.json")
 
-        param1 = computation_job_param.ComputationJobParam("numberOfevaluations", "int", "par 1", "numberOfevaluations descr")
+        param1 = computation_job_param.ComputationJobParam("numberOfevaluations",
+                                                           "int",
+                                                           "par 1",
+                                                           "numberOfevaluations descr")
         inputs = computation_job_inputs.ComputationJobInputs()
-        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile("numberOfevaluations", target_json_file , "['Config']['nEvaluations']", source_template_json_file)
+        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile(
+            "numberOfevaluations", target_json_file, "['Config']['nEvaluations']", source_template_json_file)
 
-        inputs.add_input ( param1 )
-        inputs.set_values( { "numberOfevaluations" : "100" } )
-        action1.set_inputs( inputs )
+        inputs.add_input(param1)
+        inputs.set_values({"numberOfevaluations": "100"})
+        action1.set_inputs(inputs)
 
-        #check target_json_file
+        # check target_json_file
         json_text = target_json_file.text()
-        j=json.loads(json_text)
-        self.assertTrue( 100, j['Config']['nEvaluations'] )
+        j = json.loads(json_text)
+        self.assertTrue(100, j['Config']['nEvaluations'])
 
     def test_update_json_file_action_with_string(self):
         target_json_file = path.path("./json_out.json")
@@ -150,16 +162,17 @@ def test_update_json_file_action_with_string(self):
 
         param1 = computation_job_param.ComputationJobParam("path_file_name", "string", "par 1", "path_file_name descr")
         inputs = computation_job_inputs.ComputationJobInputs()
-        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile("path_file_name", target_json_file , "['Config']['pathFilename']", source_template_json_file)
+        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile(
+            "path_file_name", target_json_file, "['Config']['pathFilename']", source_template_json_file)
 
-        inputs.add_input ( param1 )
-        inputs.set_values( { "path_file_name" : "thisIsOK.txt" } )
-        action1.set_inputs( inputs )
+        inputs.add_input(param1)
+        inputs.set_values({"path_file_name": "thisIsOK.txt"})
+        action1.set_inputs(inputs)
 
-        #check target_json_file
+        # check target_json_file
         json_text = target_json_file.text()
-        j=json.loads(json_text)
-        self.assertTrue( "thisIsOK.txt", j['Config']['pathFilename'] )
+        j = json.loads(json_text)
+        self.assertTrue("thisIsOK.txt", j['Config']['pathFilename'])
 
     def test_read_param_from_ini(self):
         ini_text = '''[Input1]
@@ -170,17 +183,16 @@ class = param
         '''
         config = ConfigParser.ConfigParser()
         ini_file = mockutils.FileLikeObjectMock(ini_text)
-        config.readfp( ini_file )
+        config.readfp(ini_file)
         input_section = config.items('Input1')
-        inputs = computation_job_inputs.ComputationJobInputs.create_from_config({'Input1' : input_section })
+        inputs = computation_job_inputs.ComputationJobInputs.create_from_config({'Input1': input_section})
 
         actions = computational_job_input_action_cmd_param.ComputationalJobInputActionCmdParam("mypar1", "--name=value")
 
-        inputs.set_values( { "mypar1" : "1" } )
-        actions.set_inputs( inputs )
+        inputs.set_values({"mypar1": "1"})
+        actions.set_inputs(inputs)
 
         self.assertEquals(actions.get_cmd_line(), "--mypar1=1")
-        
 
     def test_read_action_from_ini(self):
         ini_text = '''[Action1]
@@ -190,23 +202,22 @@ class = cmdline
         '''
         config = ConfigParser.ConfigParser()
         ini_file = mockutils.FileLikeObjectMock(ini_text)
-        config.readfp( ini_file )
+        config.readfp(ini_file)
         input_section = config.items('Action1')
-        
+
         inputs = computation_job_inputs.ComputationJobInputs()
-        inputs.add_input (
+        inputs.add_input(
             computation_job_param.ComputationJobParam("mypar1", "int", "par 1", "par descr")
         )
 
-        actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config( { 'Action1' : input_section })
+        actions = computational_job_input_actions. \
+            ComputationalJobInputActions.create_from_config({'Action1': input_section})
 
-        inputs.set_values( { "mypar1" : "1" } )
-        actions.execute( inputs )
+        inputs.set_values({"mypar1": "1"})
+        actions.execute(inputs)
 
         self.assertEquals(actions.get_cmd_line(), "--mypar1=1")
 
-
-
     def test_2_cmdpar_from_ini(self):
 
         ini_text = '''[Input1]
@@ -233,16 +244,17 @@ class = cmdline
         config = ConfigParser.ConfigParser()
         import StringIO
 
-        sio = StringIO.StringIO( ini_text )
-        config.readfp( sio )
+        sio = StringIO.StringIO(ini_text)
+        config.readfp(sio)
 
-        inputs = computation_job_inputs.ComputationJobInputs.create_from_config({'Input1' : config.items('Input1'), 'Const1' : config.items('Const1') })
-        actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config( { 'Action1' : config.items('Action1'), 'Action2' : config.items('Action2') }) 
+        inputs = computation_job_inputs.ComputationJobInputs.create_from_config(
+            {'Input1': config.items('Input1'), 'Const1': config.items('Const1')})
+        actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config(
+            {'Action1': config.items('Action1'), 'Action2': config.items('Action2')})
 
+        inputs.set_values({'workingdir': '.'})
 
-        inputs.set_values( {'workingdir' : '.' } )
-
-        actions.execute( inputs )
+        actions.execute(inputs)
 
         self.assertEquals(actions.get_cmd_line(), '-w . oaaOnDemand')
 
@@ -274,16 +286,17 @@ class = cmdline
         config = ConfigParser.ConfigParser()
         import StringIO
 
-        sio = StringIO.StringIO( ini_text )
-        config.readfp( sio )
-
-        inputs = computation_job_inputs.ComputationJobInputs.create_from_config({'Input2' : config.items('Input2'), 'Input1' : config.items('Input1') })
-        actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config( { 'Action2' : config.items('Action2'), 'Action1' : config.items('Action1') }) 
+        sio = StringIO.StringIO(ini_text)
+        config.readfp(sio)
 
+        inputs = computation_job_inputs.ComputationJobInputs.create_from_config(
+            {'Input2': config.items('Input2'), 'Input1': config.items('Input1')})
+        actions = computational_job_input_actions.ComputationalJobInputActions.create_from_config(
+            {'Action2': config.items('Action2'), 'Action1': config.items('Action1')})
 
-        inputs.set_values( {'workingdir' : '.', 'coeff' : 2.4 } )
+        inputs.set_values({'workingdir': '.', 'coeff': 2.4})
 
-        actions.execute( inputs )
+        actions.execute(inputs)
 
         self.assertEquals(actions.get_cmd_line(), '-w . --k=2.4')
 
@@ -295,16 +308,17 @@ def test_update_json_list_in_file(self):
 
         param1 = computation_job_param.ComputationJobParam("maxlat", "float", "par title", "max latitude")
         inputs = computation_job_inputs.ComputationJobInputs()
-        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile("maxlat", target_json_file , "['Config']['latLim'][1]", source_template_json_file)
+        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile(
+            "maxlat", target_json_file, "['Config']['latLim'][1]", source_template_json_file)
 
-        inputs.add_input ( param1 )
-        inputs.set_values( { "maxlat" : "45.5" } )
-        action1.set_inputs( inputs )
+        inputs.add_input(param1)
+        inputs.set_values({"maxlat": "45.5"})
+        action1.set_inputs(inputs)
 
-        #check target_json_file
+        # check target_json_file
         json_text = target_json_file.text()
-        j=json.loads(json_text)
-        self.assertTrue( 45.5, j['Config']['latLim'][1] )
+        j = json.loads(json_text)
+        self.assertTrue(45.5, j['Config']['latLim'][1])
 
     def test_update_json_list_in_file_two_times(self):
         target_json_file = path.path("./json_out.json")
@@ -314,61 +328,62 @@ def test_update_json_list_in_file_two_times(self):
 
         param1 = computation_job_param.ComputationJobParam("minlat", "float", "par title", "min latitude")
         param2 = computation_job_param.ComputationJobParam("maxlat", "float", "par title", "max latitude")
-        
+
         inputs = computation_job_inputs.ComputationJobInputs()
-        
-        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile("minlat", target_json_file , "['Config']['latLim'][0]", source_template_json_file)
-        #action2 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile("maxlat", target_json_file , "['Config']['latLim'][1]", source_template_json_file)
 
-        inputs.add_input ( param1 )
-        inputs.add_input ( param2 )
+        action1 = computational_job_input_action_update_json_file.ComputationalJobInputActionUpdateJSONFile(
+            "minlat", target_json_file, "['Config']['latLim'][0]", source_template_json_file)
 
-        inputs.set_values( { "minlat" : "75.5", "maxlat" : "76.5" } )
-        action1.set_inputs( inputs )
+        inputs.add_input(param1)
+        inputs.add_input(param2)
 
-        #check target_json_file
-        json_text = target_json_file.text()
-        j=json.loads(json_text)
-        self.assertTrue( 75.5, j['Config']['latLim'][0] )
-        self.assertTrue( 76.5, j['Config']['latLim'][1] )
+        inputs.set_values({"minlat": "75.5", "maxlat": "76.5"})
+        action1.set_inputs(inputs)
 
+        # check target_json_file
+        json_text = target_json_file.text()
+        j = json.loads(json_text)
+        self.assertTrue(75.5, j['Config']['latLim'][0])
+        self.assertTrue(76.5, j['Config']['latLim'][1])
 
     json_text1 = '''{
         "Asset": {
-            "Pfa": 0.001, 
-            "maxSpeed": 10, 
-            "minSpeed": 2, 
-            "maxHeading": 2.1, 
-            "minHeading": -2.1, 
-            "lat0": 12.08, 
-            "cost": 1e-06, 
-            "obsRange": 50000, 
-            "heading0": 0, 
-            "lon0": 63.17, 
-            "type": "Frigate", 
-            "id": 1, 
-            "Pd": 0.6, 
+            "Pfa": 0.001,
+            "maxSpeed": 10,
+            "minSpeed": 2,
+            "maxHeading": 2.1,
+            "minHeading": -2.1,
+            "lat0": 12.08,
+            "cost": 1e-06,
+            "obsRange": 50000,
+            "heading0": 0,
+            "lon0": 63.17,
+            "type": "Frigate",
+            "id": 1,
+            "Pd": 0.6,
             "name": "Ship 1"
         }
     }'''
 
     json_text2 = '''{
         "Asset": {
-            "Pfa": 0.001, 
-            "maxSpeed": 10, 
-            "minSpeed": 2, 
-            "maxHeading": 2.1, 
-            "minHeading": -2.1, 
-            "lat0": 12.08, 
-            "cost": 1e-06, 
-            "obsRange": 50000, 
-            "heading0": 0, 
-            "lon0": 63.17, 
-            "type": "Frigate", 
-            "id": 2, 
-            "Pd": 0.6, 
+            "Pfa": 0.001,
+            "maxSpeed": 10,
+            "minSpeed": 2,
+            "maxHeading": 2.1,
+            "minHeading": -2.1,
+            "lat0": 12.08,
+            "cost": 1e-06,
+            "obsRange": 50000,
+            "heading0": 0,
+            "lon0": 63.17,
+            "type": "Frigate",
+            "id": 2,
+            "Pd": 0.6,
             "name": "Ship 2"
         }
     }'''
+
+
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/test/test_process_input_parameters.py b/test/test_process_input_parameters.py
index c59b4c0..490c5df 100644
--- a/test/test_process_input_parameters.py
+++ b/test/test_process_input_parameters.py
@@ -4,68 +4,67 @@
 # This code is licensed under the GPL 2.0 license, available at the root
 # application directory.
 
+import unittest
+
+from wpsremote import input_parameters
+
 __author__ = "Alessio Fabiani"
 __copyright__ = "Copyright 2016 Open Source Geospatial Foundation - all rights reserved"
 __license__ = "GPL"
 
-import unittest
-
-import urllib
-import pickle
-
-from wpsremote import path
-from wpsremote import input_parameters
-from wpsremote import command_line_parameter
 
 class TestProcessInputParameters(unittest.TestCase):
-    
+
     def test_parse_two_int_par(self):
-        paramsDef = [('argx', {"type": "int", "description": "descr of argx", "max": 2, "template" : "--name=value"}) ] 
-        paramValue = {'argx' : ["1","2"] }
+        paramsDef = [('argx', {"type": "int", "description": "descr of argx", "max": 2, "template": "--name=value"})]
+        paramValue = {'argx': ["1", "2"]}
 
         pip = input_parameters.InputParameters(paramsDef)
-        pip.parse( paramValue )
+        pip.parse(paramValue)
 
         self.assertEquals(pip.get_cmd_line(), "--argx=1 --argx=2 ")
 
     def test_parse_two_string_par(self):
-        paramsDef = [('argX', {"type": "string", "description": "descr of argx", "max": 2, "template" : "--name=value"}) ] 
-        paramValue = {'argX' : ["aaa","b"] }
+        paramsDef = [('argX', {"type": "string", "description": "descr of argx", "max": 2, "template": "--name=value"})]
+        paramValue = {'argX': ["aaa", "b"]}
 
         pip = input_parameters.InputParameters(paramsDef)
-        pip.parse( paramValue )
+        pip.parse(paramValue)
         res = pip.get_cmd_line()
 
         self.assertEquals(res, "--argX=aaa --argX=b ")
 
     def test_parse_wrog_type(self):
-        paramsDef = [('argx', {"type": "int", "description": "descr of argx", "max": 1, "template" : "--name=value"}) ] 
-        paramValue = {'argx' : '1bubu00' }
+        paramsDef = [('argx', {"type": "int", "description": "descr of argx", "max": 1, "template": "--name=value"})]
+        paramValue = {'argx': '1bubu00'}
 
         pip = input_parameters.InputParameters(paramsDef)
-        self.assertRaises( Exception, pip.parse, paramValue)
+        self.assertRaises(Exception, pip.parse, paramValue)
 
     def test_parse_float_par_with_alias(self):
-        paramsDef = [('argx', {"type": "float", "description": "descr of argx", "max": 1, "template" : "--name=value", "alias": "arg_alias"}) ] 
-        paramValue = {'argx' : '5.234' }
-
+        paramsDef = [('argx', {"type": "float", "description": "descr of argx",
+                               "max": 1, "template": "--name=value", "alias": "arg_alias"})]
+        paramValue = {'argx': '5.234'}
 
         pip = input_parameters.InputParameters(paramsDef)
-        pip.parse( paramValue )
+        pip.parse(paramValue)
         res = pip.get_cmd_line()
 
-        self.assertEquals(res, "--arg_alias=5.234 " )
-
+        self.assertEquals(res, "--arg_alias=5.234 ")
 
     def test_parse_const_cmdline_par(self):
-        paramsDef = [('argx', {"type": "string", "description": "descr of argx", "max": 1, "template" : "value", "value" : "this should be used", "class" : "wpsremote.command_line_parameter.CommandLineParameterConst" }) ] 
-        
-        pip = input_parameters.InputParameters(paramsDef)
-        #pip.parse( paramValue ) #parse ins not becessary because there is only one CommandLineParameterConst
-        self.assertEquals(pip.get_cmd_line().strip(), "this should be used" )
-    
+        paramsDef = [('argx',
+                      {"type": "string",
+                       "description": "descr of argx",
+                       "max": 1,
+                       "template": "value",
+                       "value": "this should be used",
+                       "class": "wpsremote.command_line_parameter.CommandLineParameterConst"})]
 
+        pip = input_parameters.InputParameters(paramsDef)
+        # pip.parse( paramValue ) #parse ins not becessary because there is only one CommandLineParameterConst
+        self.assertEquals(pip.get_cmd_line().strip(), "this should be used")
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/test_suite.sh b/test_suite.sh
new file mode 100644
index 0000000..a9122a0
--- /dev/null
+++ b/test_suite.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+echo "Running... test_computation_job_inputs"
+python test/test_computation_job_inputs.py
+
+echo "Running... test_process_input_parameters"
+python test/test_process_input_parameters.py
+