diff --git a/.travis.yml b/.travis.yml
index 7030496..9e7dd94 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -18,6 +18,7 @@ install:
   - "pip install flake8"
   - "pip install defusedxml"
   - "pip install pytest"
+  - "pip install pytest-cov"
   # - "pip install boto" # disabled: since boto not supporting py3
   # - "pip install pymongo sqlalchemy MySQL-python" # disabled MySQL-python (not py3 compatible)
   # - "pip install pymongo sqlalchemy pymysql"
@@ -26,7 +27,7 @@ install:
 before_script:
   - "flake8 . --exclude test,docs,examples"
   # - mysql -e 'create database poulet;'
-script: pytest --ignore=libnmap/test/test_backend_plugin_factory.py .
+script: pytest --cov=libnmap/ --ignore=libnmap/test/test_backend_plugin_factory.py .
 after_success:
   coveralls
 deploy:
diff --git a/docs/conf.py b/docs/conf.py
index 712cc25..07e9dc8 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -11,7 +11,8 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys, os
+import os
+import sys
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -184,7 +185,13 @@
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-    ("index", "libnmap.tex", u"libnmap Documentation", u"Ronald Bister", "manual")
+    (
+        "index",
+        "libnmap.tex",
+        u"libnmap Documentation",
+        u"Ronald Bister",
+        "manual",
+    )
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -212,7 +219,9 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [("index", "libnmap", u"libnmap Documentation", [u"Ronald Bister"], 1)]
+man_pages = [
+    ("index", "libnmap", u"libnmap Documentation", [u"Ronald Bister"], 1)
+]
 
 # If true, show URL addresses after external links.
 # man_show_urls = False
diff --git a/examples/elastikibana.py b/examples/elastikibana.py
index f91cadc..3be6487 100644
--- a/examples/elastikibana.py
+++ b/examples/elastikibana.py
@@ -1,10 +1,12 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from libnmap.parser import NmapParser
-from elasticsearch import Elasticsearch
 from datetime import datetime
+
 import pygeoip
+from elasticsearch import Elasticsearch
+
+from libnmap.parser import NmapParser
 
 
 def store_report(nmap_report, database, index):
diff --git a/examples/es_plugin.py b/examples/es_plugin.py
index 4bf2cbe..6474399 100644
--- a/examples/es_plugin.py
+++ b/examples/es_plugin.py
@@ -1,10 +1,11 @@
 #!/usr/bin/env python
 
+import json
+from datetime import datetime
+
 from libnmap.parser import NmapParser
-from libnmap.reportjson import ReportDecoder
 from libnmap.plugins.es import NmapElasticsearchPlugin
-from datetime import datetime
-import json
+from libnmap.reportjson import ReportDecoder
 
 nmap_report = NmapParser.parse_fromfile("libnmap/test/files/1_hosts.xml")
 mindex = datetime.fromtimestamp(nmap_report.started).strftime("%Y-%m-%d")
diff --git a/examples/json_serialize.py b/examples/json_serialize.py
index 4e70b16..b7d5148 100644
--- a/examples/json_serialize.py
+++ b/examples/json_serialize.py
@@ -1,9 +1,10 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import json
+
 from libnmap.parser import NmapParser
 from libnmap.reportjson import ReportDecoder, ReportEncoder
-import json
 
 nmap_report_obj = NmapParser.parse_fromfile("libnmap/test/files/1_hosts.xml")
 
diff --git a/examples/proc_async.py b/examples/proc_async.py
index 868f808..01c167c 100644
--- a/examples/proc_async.py
+++ b/examples/proc_async.py
@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from libnmap.process import NmapProcess
 from time import sleep
 
+from libnmap.process import NmapProcess
 
 nmap_proc = NmapProcess(targets="scanme.nmap.org", options="-sT")
 nmap_proc.run_background()
diff --git a/examples/proc_nmap_like.py b/examples/proc_nmap_like.py
index bd85cfd..bed93fe 100644
--- a/examples/proc_nmap_like.py
+++ b/examples/proc_nmap_like.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from libnmap.process import NmapProcess
 from libnmap.parser import NmapParser, NmapParserException
+from libnmap.process import NmapProcess
 
 
 # start a new nmap scan on localhost with some specific options
diff --git a/libnmap/diff.py b/libnmap/diff.py
index d2e8e34..432aa2f 100644
--- a/libnmap/diff.py
+++ b/libnmap/diff.py
@@ -3,11 +3,11 @@
 
 class DictDiffer(object):
     """
-        Calculate the difference between two dictionaries as:
-        (1) items added
-        (2) items removed
-        (3) keys same in both but changed values
-        (4) keys same in both and unchanged values
+    Calculate the difference between two dictionaries as:
+    (1) items added
+    (2) items removed
+    (3) keys same in both but changed values
+    (4) keys same in both and unchanged values
     """
 
     def __init__(self, current_dict, past_dict):
@@ -40,35 +40,35 @@ def unchanged(self):
 
 class NmapDiff(DictDiffer):
     """
-        NmapDiff compares two objects of same type to enable the user to check:
-
-        - what has changed
-        - what has been added
-        - what has been removed
-        - what was kept unchanged
-
-        NmapDiff inherit from DictDiffer which makes the actual comparaison.
-        The different methods from DictDiffer used by NmapDiff are the
-        following:
-
-        - NmapDiff.changed()
-        - NmapDiff.added()
-        - NmapDiff.removed()
-        - NmapDiff.unchanged()
-
-        Each of the returns a python set() of key which have changed in the
-        compared objects. To check the different keys that could be returned,
-        refer to the get_dict() method of the objects you which to
-        compare (i.e: libnmap.objects.NmapHost, NmapService,...).
+    NmapDiff compares two objects of same type to enable the user to check:
+
+    - what has changed
+    - what has been added
+    - what has been removed
+    - what was kept unchanged
+
+    NmapDiff inherit from DictDiffer which makes the actual comparaison.
+    The different methods from DictDiffer used by NmapDiff are the
+    following:
+
+    - NmapDiff.changed()
+    - NmapDiff.added()
+    - NmapDiff.removed()
+    - NmapDiff.unchanged()
+
+    Each of the returns a python set() of key which have changed in the
+    compared objects. To check the different keys that could be returned,
+    refer to the get_dict() method of the objects you which to
+    compare (i.e: libnmap.objects.NmapHost, NmapService,...).
     """
 
     def __init__(self, nmap_obj1, nmap_obj2):
         """
-            Constructor of NmapDiff:
+        Constructor of NmapDiff:
 
-            - Checks if the two objects are of the same class
-            - Checks if the objects are "comparable" via a call to id() (dirty)
-            - Inherits from DictDiffer and
+        - Checks if the two objects are of the same class
+        - Checks if the objects are "comparable" via a call to id() (dirty)
+        - Inherits from DictDiffer and
         """
         if (
             nmap_obj1.__class__ != nmap_obj2.__class__
diff --git a/libnmap/objects/__init__.py b/libnmap/objects/__init__.py
index b7f24e4..ddf3699 100644
--- a/libnmap/objects/__init__.py
+++ b/libnmap/objects/__init__.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
-from libnmap.objects.report import NmapReport
 from libnmap.objects.host import NmapHost
+from libnmap.objects.report import NmapReport
 from libnmap.objects.service import NmapService
 
 __all__ = ["NmapReport", "NmapHost", "NmapService"]
diff --git a/libnmap/objects/cpe.py b/libnmap/objects/cpe.py
index 8b6e497..9476444 100644
--- a/libnmap/objects/cpe.py
+++ b/libnmap/objects/cpe.py
@@ -3,11 +3,11 @@
 
 class CPE(object):
     """
-        CPE class offers an API for basic CPE objects.
-        These objects could be found in NmapService or in <os> tag
-        within NmapHost.
+    CPE class offers an API for basic CPE objects.
+    These objects could be found in NmapService or in <os> tag
+    within NmapHost.
 
-        :todo: interpret CPE string and provide appropriate API
+    :todo: interpret CPE string and provide appropriate API
     """
 
     def __init__(self, cpestring):
@@ -29,14 +29,14 @@ def __init__(self, cpestring):
     @property
     def cpestring(self):
         """
-            Accessor for the full CPE string.
+        Accessor for the full CPE string.
         """
         return self._cpestring
 
     @property
     def cpedict(self):
         """
-            Accessor for _cpedict
+        Accessor for _cpedict
         """
         return self._cpedict
 
@@ -45,60 +45,60 @@ def __repr__(self):
 
     def get_part(self):
         """
-            Returns the cpe part (/o, /h, /a)
+        Returns the cpe part (/o, /h, /a)
         """
         return self._cpedict["part"]
 
     def get_vendor(self):
         """
-            Returns the vendor name
+        Returns the vendor name
         """
         return self._cpedict["vendor"]
 
     def get_product(self):
         """
-            Returns the product name
+        Returns the product name
         """
         return self._cpedict["product"]
 
     def get_version(self):
         """
-            Returns the version of the cpe
+        Returns the version of the cpe
         """
         return self._cpedict["version"]
 
     def get_update(self):
         """
-            Returns the update version
+        Returns the update version
         """
         return self._cpedict["update"]
 
     def get_edition(self):
         """
-            Returns the cpe edition
+        Returns the cpe edition
         """
         return self._cpedict["edition"]
 
     def get_language(self):
         """
-            Returns the cpe language
+        Returns the cpe language
         """
         return self._cpedict["language"]
 
     def is_application(self):
         """
-            Returns True if cpe describes an application
+        Returns True if cpe describes an application
         """
         return self.get_part() == "/a"
 
     def is_hardware(self):
         """
-            Returns True if cpe describes a hardware
+        Returns True if cpe describes a hardware
         """
         return self.get_part() == "/h"
 
     def is_operating_system(self):
         """
-            Returns True if cpe describes an operating system
+        Returns True if cpe describes an operating system
         """
         return self.get_part() == "/o"
diff --git a/libnmap/objects/host.py b/libnmap/objects/host.py
index 980682f..a8e1ba6 100644
--- a/libnmap/objects/host.py
+++ b/libnmap/objects/host.py
@@ -6,7 +6,7 @@
 
 class NmapHost(object):
     """
-        NmapHost is a class representing a host object of NmapReport
+    NmapHost is a class representing a host object of NmapReport
     """
 
     def __init__(
@@ -20,17 +20,17 @@ def __init__(
         extras=None,
     ):
         """
-            NmapHost constructor
-            :param starttime: unix timestamp of when the scan against
-            that host started
-            :type starttime: string
-            :param endtime: unix timestamp of when the scan against
-            that host ended
-            :type endtime: string
-            :param address: dict ie :{'addr': '127.0.0.1', 'addrtype': 'ipv4'}
-            :param status: dict ie:{'reason': 'localhost-response',
-                                    'state': 'up'}
-            :return: NmapHost:
+        NmapHost constructor
+        :param starttime: unix timestamp of when the scan against
+        that host started
+        :type starttime: string
+        :param endtime: unix timestamp of when the scan against
+        that host ended
+        :type endtime: string
+        :param address: dict ie :{'addr': '127.0.0.1', 'addrtype': 'ipv4'}
+        :param status: dict ie:{'reason': 'localhost-response',
+                                'state': 'up'}
+        :return: NmapHost:
         """
         self._starttime = starttime
         self._endtime = endtime
@@ -65,13 +65,13 @@ def __init__(
 
     def __eq__(self, other):
         """
-            Compare eq NmapHost based on :
+        Compare eq NmapHost based on :
 
-                - hostnames
-                - address
-                - if an associated services has changed
+            - hostnames
+            - address
+            - if an associated services has changed
 
-            :return: boolean
+        :return: boolean
         """
         rval = False
         if self.__class__ == other.__class__ and self.id == other.id:
@@ -80,13 +80,13 @@ def __eq__(self, other):
 
     def __ne__(self, other):
         """
-            Compare ne NmapHost based on:
+        Compare ne NmapHost based on:
 
-                - hostnames
-                - address
-                - if an associated services has changed
+            - hostnames
+            - address
+            - if an associated services has changed
 
-            :return: boolean
+        :return: boolean
         """
         rval = True
         if self.__class__ == other.__class__ and self.id == other.id:
@@ -95,8 +95,8 @@ def __ne__(self, other):
 
     def __repr__(self):
         """
-            String representing the object
-            :return: string
+        String representing the object
+        :return: string
         """
         return "{0}: [{1} ({2}) - {3}]".format(
             self.__class__.__name__,
@@ -107,8 +107,8 @@ def __repr__(self):
 
     def __hash__(self):
         """
-            Hash is needed to be able to use our object in sets
-            :return: hash
+        Hash is needed to be able to use our object in sets
+        :return: hash
         """
         return (
             hash(self.status)
@@ -119,46 +119,46 @@ def __hash__(self):
 
     def changed(self, other):
         """
-            return the number of attribute who have changed
-            :param other: NmapHost object to compare
-            :return int
+        return the number of attribute who have changed
+        :param other: NmapHost object to compare
+        :return int
         """
         return len(self.diff(other).changed())
 
     @property
     def starttime(self):
         """
-            Accessor for the unix timestamp of when the scan was started
+        Accessor for the unix timestamp of when the scan was started
 
-            :return: string
+        :return: string
         """
         return self._starttime
 
     @property
     def endtime(self):
         """
-            Accessor for the unix timestamp of when the scan ended
+        Accessor for the unix timestamp of when the scan ended
 
-            :return: string
+        :return: string
         """
         return self._endtime
 
     @property
     def address(self):
         """
-            Accessor for the IP address of the scanned host
+        Accessor for the IP address of the scanned host
 
-            :return: IP address as a string
+        :return: IP address as a string
         """
         return self._main_address
 
     @address.setter
     def address(self, addrdict):
         """
-            Setter for the address dictionnary.
+        Setter for the address dictionnary.
 
-            :param addrdict: valid dict is {'addr': '1.1.1.1',
-                                            'addrtype': 'ipv4'}
+        :param addrdict: valid dict is {'addr': '1.1.1.1',
+                                        'addrtype': 'ipv4'}
         """
         if addrdict["addrtype"] == "ipv4":
             self._ipv4_addr = addrdict["addr"]
@@ -175,65 +175,65 @@ def address(self, addrdict):
     @property
     def ipv4(self):
         """
-            Accessor for the IPv4 address of the scanned host
+        Accessor for the IPv4 address of the scanned host
 
-            :return: IPv4 address as a string
+        :return: IPv4 address as a string
         """
         return self._ipv4_addr or ""
 
     @property
     def mac(self):
         """
-            Accessor for the MAC address of the scanned host
+        Accessor for the MAC address of the scanned host
 
-            :return: MAC address as a string
+        :return: MAC address as a string
         """
         return self._mac_addr or ""
 
     @property
     def vendor(self):
         """
-            Accessor for the vendor attribute of the scanned host
+        Accessor for the vendor attribute of the scanned host
 
-            :return: string (vendor) of empty string if no vendor defined
+        :return: string (vendor) of empty string if no vendor defined
         """
         return self._vendor or ""
 
     @property
     def ipv6(self):
         """
-            Accessor for the IPv6 address of the scanned host
+        Accessor for the IPv6 address of the scanned host
 
-            :return: IPv6 address as a string
+        :return: IPv6 address as a string
         """
         return self._ipv6_addr or ""
 
     @property
     def status(self):
         """
-            Accessor for the host's status (up, down, unknown...)
+        Accessor for the host's status (up, down, unknown...)
 
-            :return: string
+        :return: string
         """
         return self._status["state"]
 
     @status.setter
     def status(self, statusdict):
         """
-            Setter for the status dictionnary.
+        Setter for the status dictionnary.
 
-            :param statusdict: valid dict is {"state": "open",
-                                              "reason": "syn-ack",
-                                              "reason_ttl": "0"}
-                                'state' is the only mandatory key.
+        :param statusdict: valid dict is {"state": "open",
+                                          "reason": "syn-ack",
+                                          "reason_ttl": "0"}
+                            'state' is the only mandatory key.
         """
         self._status = statusdict
 
     def is_up(self):
         """
-            method to determine if host is up or not
+        method to determine if host is up or not
 
-            :return: bool
+        :return: bool
         """
         rval = False
         if self.status == "up":
@@ -243,36 +243,36 @@ def is_up(self):
     @property
     def hostnames(self):
         """
-            Accessor returning the list of hostnames (array of strings).
+        Accessor returning the list of hostnames (array of strings).
 
-            :return: array of string
+        :return: array of string
         """
         return self._hostnames
 
     @property
     def services(self):
         """
-            Accessor for the array of scanned services for that host.
+        Accessor for the array of scanned services for that host.
 
-            An array of NmapService objects is returned.
+        An array of NmapService objects is returned.
 
-            :return: array of NmapService
+        :return: array of NmapService
         """
         return self._services
 
     def get_ports(self):
         """
-            Retrieve a list of the port used by each service of the NmapHost
+        Retrieve a list of the port used by each service of the NmapHost
 
-            :return: list: of tuples (port,'proto') ie:[(22,'tcp'),(25, 'tcp')]
+        :return: list: of tuples (port,'proto') ie:[(22,'tcp'),(25, 'tcp')]
         """
         return [(p.port, p.protocol) for p in self._services]
 
     def get_open_ports(self):
         """
-            Same as get_ports() but only for open ports
+        Same as get_ports() but only for open ports
 
-            :return: list: of tuples (port,'proto') ie:[(22,'tcp'),(25, 'tcp')]
+        :return: list: of tuples (port,'proto') ie:[(22,'tcp'),(25, 'tcp')]
         """
         return [
             (p.port, p.protocol) for p in self._services if p.state == "open"
@@ -280,10 +280,10 @@ def get_open_ports(self):
 
     def get_service(self, portno, protocol="tcp"):
         """
-            :param portno: int the portnumber
-            :param protocol='tcp': string ('tcp','udp')
+        :param portno: int the portnumber
+        :param protocol='tcp': string ('tcp','udp')
 
-            :return: NmapService or None
+        :return: NmapService or None
         """
         plist = [
             p
@@ -296,9 +296,9 @@ def get_service(self, portno, protocol="tcp"):
 
     def get_service_byid(self, service_id):
         """
-            Returns a NmapService by providing its id.
+        Returns a NmapService by providing its id.
 
-            The id of a nmap service is a python tupl made of (protocol, port)
+        The id of a nmap service is a python tupl made of (protocol, port)
         """
         rval = None
         for _tmpservice in self._services:
@@ -308,10 +308,10 @@ def get_service_byid(self, service_id):
 
     def os_class_probabilities(self):
         """
-            Returns an array of possible OS class detected during
-            the OS fingerprinting.
+        Returns an array of possible OS class detected during
+        the OS fingerprinting.
 
-            :return: Array of NmapOSClass objects
+        :return: Array of NmapOSClass objects
         """
         rval = []
         if self.os is not None:
@@ -320,10 +320,10 @@ def os_class_probabilities(self):
 
     def os_match_probabilities(self):
         """
-            Returns an array of possible OS match detected during
-            the OS fingerprinting
+        Returns an array of possible OS match detected during
+        the OS fingerprinting
 
-            :return: array of NmapOSMatches objects
+        :return: array of NmapOSMatches objects
         """
         rval = []
         if self.os is not None:
@@ -333,18 +333,18 @@ def os_match_probabilities(self):
     @property
     def os_fingerprinted(self):
         """
-            Specify if the host has OS fingerprint data available
+        Specify if the host has OS fingerprint data available
 
-            :return: Boolean
+        :return: Boolean
         """
         return self._osfingerprinted
 
     @property
     def os_fingerprint(self):
         """
-            Returns the fingerprint of the scanned system.
+        Returns the fingerprint of the scanned system.
 
-            :return: string
+        :return: string
         """
         rval = ""
         if self.os is not None:
@@ -353,11 +353,11 @@ def os_fingerprint(self):
 
     def os_ports_used(self):
         """
-            Returns an array of the ports used for OS fingerprinting
+        Returns an array of the ports used for OS fingerprinting
 
-            :return: array of ports used: [{'portid': '22',
-                                            'proto': 'tcp',
-                                            'state': 'open'},]
+        :return: array of ports used: [{'portid': '22',
+                                        'proto': 'tcp',
+                                        'state': 'open'},]
         """
         rval = []
         try:
@@ -369,10 +369,10 @@ def os_ports_used(self):
     @property
     def tcpsequence(self):
         """
-            Returns the difficulty to determine remotely predict
-            the tcp sequencing.
+        Returns the difficulty to determine remotely predict
+        the tcp sequencing.
 
-            return: string
+        return: string
         """
         rval = ""
         try:
@@ -384,9 +384,9 @@ def tcpsequence(self):
     @property
     def ipsequence(self):
         """
-            Return the class of ip sequence of the remote hosts.
+        Return the class of ip sequence of the remote hosts.
 
-            :return: string
+        :return: string
         """
         rval = ""
         try:
@@ -398,9 +398,9 @@ def ipsequence(self):
     @property
     def uptime(self):
         """
-            uptime of the remote host (if nmap was able to determine it)
+        uptime of the remote host (if nmap was able to determine it)
 
-            :return: string (in seconds)
+        :return: string (in seconds)
         """
         rval = 0
         try:
@@ -412,9 +412,9 @@ def uptime(self):
     @property
     def lastboot(self):
         """
-            Since when the host was booted.
+        Since when the host was booted.
 
-            :return: string
+        :return: string
         """
         rval = ""
         try:
@@ -426,9 +426,9 @@ def lastboot(self):
     @property
     def distance(self):
         """
-            Number of hops to host
+        Number of hops to host
 
-            :return: int
+        :return: int
         """
         rval = 0
         try:
@@ -440,9 +440,9 @@ def distance(self):
     @property
     def scripts_results(self):
         """
-            Scripts results specific to the scanned host
+        Scripts results specific to the scanned host
 
-            :return: array of <script> dictionary
+        :return: array of <script> dictionary
         """
         rval = {}
         try:
@@ -454,19 +454,19 @@ def scripts_results(self):
     @property
     def id(self):
         """
-            id of the host. Used for diff()ing NmapObjects
+        id of the host. Used for diff()ing NmapObjects
 
-            :return: string
+        :return: string
         """
         return self.address
 
     @property
     def extraports_state(self):
         """
-            dictionnary containing state and amount of extra ports scanned
-            for which a common state, usually, closed was discovered.
+        dictionnary containing state and amount of extra ports scanned
+        for which a common state, usually, closed was discovered.
 
-            :return: dict with keys 'state' and 'count' or None
+        :return: dict with keys 'state' and 'count' or None
         """
         _xtrports = self._extras.get("extraports", None)
 
@@ -478,10 +478,10 @@ def extraports_state(self):
     @property
     def extraports_reasons(self):
         """
-            dictionnary containing reasons why extra ports scanned
-            for which a common state, usually, closed was discovered.
+        dictionnary containing reasons why extra ports scanned
+        for which a common state, usually, closed was discovered.
 
-            :return: array of dict containing keys 'state' and 'count' or None
+        :return: array of dict containing keys 'state' and 'count' or None
         """
         r = self._extras.get("extraports", {})
 
@@ -492,11 +492,11 @@ def extraports_reasons(self):
 
     def get_dict(self):
         """
-            Return a dict representation of the object.
+        Return a dict representation of the object.
 
-            This is needed by NmapDiff to allow comparaison
+        This is needed by NmapDiff to allow comparaison
 
-            :return dict
+        :return dict
         """
         d = dict(
             [
@@ -516,16 +516,16 @@ def get_dict(self):
 
     def diff(self, other):
         """
-            Calls NmapDiff to check the difference between self and
-            another NmapHost object.
+        Calls NmapDiff to check the difference between self and
+        another NmapHost object.
 
-            Will return a NmapDiff object.
+        Will return a NmapDiff object.
 
-            This objects return python set() of keys describing the elements
-            which have changed, were added, removed or kept unchanged.
+        This objects return python set() of keys describing the elements
+        which have changed, were added, removed or kept unchanged.
 
-            :param other: NmapHost to diff with
+        :param other: NmapHost to diff with
 
-            :return: NmapDiff object
+        :return: NmapDiff object
         """
         return NmapDiff(self, other)
diff --git a/libnmap/objects/os.py b/libnmap/objects/os.py
index 5c64d86..912c32e 100644
--- a/libnmap/objects/os.py
+++ b/libnmap/objects/os.py
@@ -1,14 +1,15 @@
 # -*- coding: utf-8 -*-
 
 import warnings
+
 from libnmap.objects.cpe import CPE
 
 
 class OSFPPortUsed(object):
     """
-        Port used class: this enables the user of NmapOSFingerprint class
-        to have a common and clear interface to access portused data which
-        were collected and used during os fingerprint scan
+    Port used class: this enables the user of NmapOSFingerprint class
+    to have a common and clear interface to access portused data which
+    were collected and used during os fingerprint scan
     """
 
     def __init__(self, port_used_dict):
@@ -22,43 +23,43 @@ def __init__(self, port_used_dict):
     @property
     def state(self):
         """
-            Accessor for the portused state (closed, open,...)
+        Accessor for the portused state (closed, open,...)
         """
         return self._state
 
     @property
     def proto(self):
         """
-            Accessor for the portused protocol (tcp, udp,...)
+        Accessor for the portused protocol (tcp, udp,...)
         """
         return self._proto
 
     @property
     def portid(self):
         """
-            Accessor for the referenced port number used
+        Accessor for the referenced port number used
         """
         return self._portid
 
 
 class NmapOSMatch(object):
     """
-        NmapOSMatch is an internal class used for offering results
-        from an nmap os fingerprint. This common interfaces makes
-        a compatibility between old nmap xml (<1.04) and new nmap
-        xml versions (used in nmapv6 for instance).
-
-        In previous xml version, osclass tags from nmap fingerprints
-        were not directly mapped to a osmatch. In new xml version,
-        osclass could be embedded in osmatch tag.
-
-        The approach to solve this is to create a common class
-        which will, for older xml version, match based on the accuracy
-        osclass to an osmatch. If no match, an osmatch will be made up
-        from a concat of os class attributes: vendor and osfamily.
-        Unmatched osclass will have a line attribute of -1.
-
-        More info, see issue #26 or http://seclists.org/nmap-dev/2012/q2/252
+    NmapOSMatch is an internal class used for offering results
+    from an nmap os fingerprint. This common interfaces makes
+    a compatibility between old nmap xml (<1.04) and new nmap
+    xml versions (used in nmapv6 for instance).
+
+    In previous xml version, osclass tags from nmap fingerprints
+    were not directly mapped to a osmatch. In new xml version,
+    osclass could be embedded in osmatch tag.
+
+    The approach to solve this is to create a common class
+    which will, for older xml version, match based on the accuracy
+    osclass to an osmatch. If no match, an osmatch will be made up
+    from a concat of os class attributes: vendor and osfamily.
+    Unmatched osclass will have a line attribute of -1.
+
+    More info, see issue #26 or http://seclists.org/nmap-dev/2012/q2/252
     """
 
     def __init__(self, osmatch_dict):
@@ -90,54 +91,54 @@ def __init__(self, osmatch_dict):
     def add_osclass(self, osclass_obj):
 
         """
-            Add a NmapOSClass object to the OSMatch object. This method is
-            useful to implement compatibility with older versions of NMAP
-            by providing a common interface to access os fingerprint data.
+        Add a NmapOSClass object to the OSMatch object. This method is
+        useful to implement compatibility with older versions of NMAP
+        by providing a common interface to access os fingerprint data.
         """
         self._osclasses.append(osclass_obj)
 
     @property
     def osclasses(self):
         """
-            Accessor for all NmapOSClass objects matching with this OS Match
+        Accessor for all NmapOSClass objects matching with this OS Match
         """
         return self._osclasses
 
     @property
     def name(self):
         """
-            Accessor for name attribute (e.g.: Linux 2.4.26 (Slackware 10.0.0))
+        Accessor for name attribute (e.g.: Linux 2.4.26 (Slackware 10.0.0))
         """
         return self._name
 
     @property
     def line(self):
         """
-            Accessor for line attribute as integer. value equals -1 if this
-            osmatch holds orphans NmapOSClass objects. This could happen with
-            older version of nmap xml engine (<1.04 (e.g: nmapv6)).
+        Accessor for line attribute as integer. value equals -1 if this
+        osmatch holds orphans NmapOSClass objects. This could happen with
+        older version of nmap xml engine (<1.04 (e.g: nmapv6)).
 
-            :return: int
+        :return: int
         """
         return int(self._line)
 
     @property
     def accuracy(self):
         """
-            Accessor for accuracy
+        Accessor for accuracy
 
-            :return: int
+        :return: int
         """
         return int(self._accuracy)
 
     def get_cpe(self):
         """
-            This method return a list of cpe stings and not CPE objects as
-            the NmapOSClass.cpelist property. This method is a helper to
-            simplify data management.
+        This method return a list of cpe stings and not CPE objects as
+        the NmapOSClass.cpelist property. This method is a helper to
+        simplify data management.
 
-            For more advanced handling of CPE data, use NmapOSClass.cpelist
-            and use the methods from CPE class
+        For more advanced handling of CPE data, use NmapOSClass.cpelist
+        and use the methods from CPE class
         """
         _cpelist = []
         for osc in self.osclasses:
@@ -154,13 +155,13 @@ def __repr__(self):
 
 class NmapOSClass(object):
     """
-        NmapOSClass offers an unified API to access data from analysed
-        osclass tag. As implemented in libnmap and newer version of nmap,
-        osclass objects will always be embedded in a NmapOSMatch.
-        Unmatched NmapOSClass will be stored in "dummy" NmapOSMatch objects
-        which will have the particularity of have a line attribute of -1.
-        On top of this, NmapOSClass will have optional CPE objects
-        embedded.
+    NmapOSClass offers an unified API to access data from analysed
+    osclass tag. As implemented in libnmap and newer version of nmap,
+    osclass objects will always be embedded in a NmapOSMatch.
+    Unmatched NmapOSClass will be stored in "dummy" NmapOSMatch objects
+    which will have the particularity of have a line attribute of -1.
+    On top of this, NmapOSClass will have optional CPE objects
+    embedded.
     """
 
     def __init__(self, osclass_dict):
@@ -191,65 +192,65 @@ def __init__(self, osclass_dict):
     @property
     def cpelist(self):
         """
-            Returns a list of CPE Objects matching with this os class
+        Returns a list of CPE Objects matching with this os class
 
-            :return: list of CPE objects
-            :rtype: Array
+        :return: list of CPE objects
+        :rtype: Array
         """
         return self._cpelist
 
     @property
     def vendor(self):
         """
-            Accessor for vendor information (Microsoft, Linux,...)
+        Accessor for vendor information (Microsoft, Linux,...)
 
-            :return: string
+        :return: string
         """
         return self._vendor
 
     @property
     def osfamily(self):
         """
-            Accessor for OS family information (Windows, Linux,...)
+        Accessor for OS family information (Windows, Linux,...)
 
-            :return: string
+        :return: string
         """
         return self._osfamily
 
     @property
     def accuracy(self):
         """
-            Accessor for OS class detection accuracy (int)
+        Accessor for OS class detection accuracy (int)
 
-            :return: int
+        :return: int
         """
         return int(self._accuracy)
 
     @property
     def osgen(self):
         """
-            Accessor for OS class generation (7, 8, 2.4.X,...).
+        Accessor for OS class generation (7, 8, 2.4.X,...).
 
-            :return: string
+        :return: string
         """
         return self._osgen
 
     @property
     def type(self):
         """
-            Accessor for OS class type (general purpose,...)
+        Accessor for OS class type (general purpose,...)
 
-            :return: string
+        :return: string
         """
         return self._type
 
     @property
     def description(self):
         """
-            Accessor helper which returns a concataned string of
-            the valuable attributes from NmapOSClass object
+        Accessor helper which returns a concataned string of
+        the valuable attributes from NmapOSClass object
 
-            :return: string
+        :return: string
         """
         rval = "{0}: {1}, {2}".format(self.type, self.vendor, self.osfamily)
         if len(self.osgen):
@@ -267,9 +268,9 @@ def __repr__(self):
 
 class NmapOSFingerprint(object):
     """
-        NmapOSFingerprint is a easier API for using os fingerprinting.
-        Data for OS fingerprint (<os> tag) is instanciated from
-        a NmapOSFingerprint which is accessible in NmapHost via NmapHost.os
+    NmapOSFingerprint is a easier API for using os fingerprinting.
+    Data for OS fingerprint (<os> tag) is instanciated from
+    a NmapOSFingerprint which is accessible in NmapHost via NmapHost.os
     """
 
     def __init__(self, osfp_data):
@@ -300,16 +301,16 @@ def __init__(self, osfp_data):
 
     def get_osmatch(self, osclass_obj):
         """
-            This function enables NmapOSFingerprint to determine if an
-            NmapOSClass object could be attached to an existing NmapOSMatch
-            object in order to respect the common interface for
-            the nmap xml version < 1.04 and >= 1.04
+        This function enables NmapOSFingerprint to determine if an
+        NmapOSClass object could be attached to an existing NmapOSMatch
+        object in order to respect the common interface for
+        the nmap xml version < 1.04 and >= 1.04
 
-            This method will return an NmapOSMatch object matching with
-            the NmapOSClass provided in parameter
-            (match is performed based on accuracy)
+        This method will return an NmapOSMatch object matching with
+        the NmapOSClass provided in parameter
+        (match is performed based on accuracy)
 
-            :return: NmapOSMatch object
+        :return: NmapOSMatch object
         """
         rval = None
         for _osmatch in self.__osmatches:
@@ -320,9 +321,9 @@ def get_osmatch(self, osclass_obj):
 
     def _add_dummy_osmatch(self, osclass_obj):
         """
-            This functions creates a dummy NmapOSMatch object in order to
-            encapsulate an NmapOSClass object which was not matched with an
-            existing NmapOSMatch object
+        This functions creates a dummy NmapOSMatch object in order to
+        encapsulate an NmapOSClass object which was not matched with an
+        existing NmapOSMatch object
         """
         _dname = "{0}:{1}:{2}".format(
             osclass_obj.type, osclass_obj.vendor, osclass_obj.osfamily
@@ -368,9 +369,9 @@ def fingerprints(self):
     @property
     def ports_used(self):
         """
-            Return an array of OSFPPortUsed object with the ports used to
-            perform the os fingerprint. This dict might contain another dict
-            embedded containing the ports_reason values.
+        Return an array of OSFPPortUsed object with the ports used to
+        perform the os fingerprint. This dict might contain another dict
+        embedded containing the ports_reason values.
         """
         return self.__ports_used
 
diff --git a/libnmap/objects/report.py b/libnmap/objects/report.py
index 0fbc05c..cd9a556 100644
--- a/libnmap/objects/report.py
+++ b/libnmap/objects/report.py
@@ -4,28 +4,28 @@
 
 class NmapReport(object):
     """
-        NmapReport is the usual interface for the end user to
-        read scans output.
+    NmapReport is the usual interface for the end user to
+    read scans output.
 
-        A NmapReport as the following structure:
+    A NmapReport as the following structure:
 
-        - Scan headers data
-        - A list of scanned hosts (NmapReport.hosts)
-        - Scan footer data
+    - Scan headers data
+    - A list of scanned hosts (NmapReport.hosts)
+    - Scan footer data
 
-        It is to note that each NmapHost comprised in NmapReport.hosts array
-        contains also a list of scanned services (NmapService object).
+    It is to note that each NmapHost comprised in NmapReport.hosts array
+    contains also a list of scanned services (NmapService object).
 
-        This means that if NmapParser.parse*() is the input interface for the
-        end user of the lib. NmapReport is certainly the output interface for
-        the end user of the lib.
+    This means that if NmapParser.parse*() is the input interface for the
+    end user of the lib. NmapReport is certainly the output interface for
+    the end user of the lib.
     """
 
     def __init__(self, raw_data=None):
         """
-            Constructor for NmapReport object.
+        Constructor for NmapReport object.
 
-            This is usually called by the NmapParser module.
+        This is usually called by the NmapParser module.
         """
         self._nmaprun = {}
         self._scaninfo = {}
@@ -36,16 +36,16 @@ def __init__(self, raw_data=None):
 
     def save(self, backend):
         """
-            This method gets a NmapBackendPlugin representing the backend.
+        This method gets a NmapBackendPlugin representing the backend.
 
-            :param backend: libnmap.plugins.PluginBackend object.
+        :param backend: libnmap.plugins.PluginBackend object.
 
-            Object created by BackendPluginFactory and enabling nmap reports
-            to be saved/stored in any type of backend implemented in plugins.
+        Object created by BackendPluginFactory and enabling nmap reports
+        to be saved/stored in any type of backend implemented in plugins.
 
-            The primary key of the stored object is returned.
+        The primary key of the stored object is returned.
 
-            :return: str
+        :return: str
         """
         if backend is not None:
             _id = backend.insert(self)
@@ -55,13 +55,13 @@ def save(self, backend):
 
     def diff(self, other):
         """
-            Calls NmapDiff to check the difference between self and
-            another NmapReport object.
+        Calls NmapDiff to check the difference between self and
+        another NmapReport object.
 
-            Will return a NmapDiff object.
+        Will return a NmapDiff object.
 
-            :return: NmapDiff object
-            :todo: remove is_consistent approach, diff() should be generic.
+        :return: NmapDiff object
+        :todo: remove is_consistent approach, diff() should be generic.
         """
         if self.is_consistent() and other.is_consistent():
             _rdiff = NmapDiff(self, other)
@@ -72,9 +72,9 @@ def diff(self, other):
     @property
     def started(self):
         """
-            Accessor returning a unix timestamp of when the scan was started.
+        Accessor returning a unix timestamp of when the scan was started.
 
-            :return: integer
+        :return: integer
         """
         rval = -1
         try:
@@ -87,10 +87,10 @@ def started(self):
     @property
     def startedstr(self):
         """
-            Accessor returning a human readable string of when the
-            scan was started
+        Accessor returning a human readable string of when the
+        scan was started
 
-            :return: string
+        :return: string
         """
         rval = ""
         try:
@@ -102,49 +102,49 @@ def startedstr(self):
     @property
     def commandline(self):
         """
-            Accessor returning the full nmap command line fired.
+        Accessor returning the full nmap command line fired.
 
-            :return: string
+        :return: string
         """
         return self._nmaprun["args"]
 
     @property
     def version(self):
         """
-            Accessor returning the version of the
-            nmap binary used to perform the scan.
+        Accessor returning the version of the
+        nmap binary used to perform the scan.
 
-            :return: string
+        :return: string
         """
         return self._nmaprun["version"]
 
     @property
     def xmlversion(self):
         """
-            Accessor returning the XML output
-            version of the nmap report.
+        Accessor returning the XML output
+        version of the nmap report.
 
-            :return: string
+        :return: string
         """
         return self._nmaprun["xmloutputversion"]
 
     @property
     def scan_type(self):
         """
-            Accessor returning a string which identifies what type of scan
-            was launched (syn, ack, tcp,...).
+        Accessor returning a string which identifies what type of scan
+        was launched (syn, ack, tcp,...).
 
-            :return: string
+        :return: string
         """
         return self._scaninfo.get("type")
 
     @property
     def numservices(self):
         """
-            Accessor returning the number of services the
-            scan attempted to enumerate.
+        Accessor returning the number of services the
+        scan attempted to enumerate.
 
-            :return: integer
+        :return: integer
         """
         rval = -1
         try:
@@ -157,23 +157,23 @@ def numservices(self):
     @property
     def hosts(self):
         """
-            Accessor returning an array of scanned hosts.
+        Accessor returning an array of scanned hosts.
 
-            Scanned hosts are NmapHost objects.
+        Scanned hosts are NmapHost objects.
 
-            :return: array of NmapHost
+        :return: array of NmapHost
         """
         return self._hosts
 
     def get_host_byid(self, host_id):
         """
-           Gets a NmapHost object directly from the host array
-           by looking it up by id.
+        Gets a NmapHost object directly from the host array
+        by looking it up by id.
 
-           :param ip_addr: ip address of the host to lookup
-           :type ip_addr: string
+        :param ip_addr: ip address of the host to lookup
+        :type ip_addr: string
 
-           :return: NmapHost
+        :return: NmapHost
         """
         rval = None
         for _rhost in self._hosts:
@@ -184,9 +184,9 @@ def get_host_byid(self, host_id):
     @property
     def endtime(self):
         """
-            Accessor returning a unix timestamp of when the scan ended.
+        Accessor returning a unix timestamp of when the scan ended.
 
-            :return: integer
+        :return: integer
         """
         rval = -1
         try:
@@ -198,10 +198,10 @@ def endtime(self):
     @property
     def endtimestr(self):
         """
-            Accessor returning a human readable time string
-            of when the scan ended.
+        Accessor returning a human readable time string
+        of when the scan ended.
 
-            :return: string
+        :return: string
         """
         rval = ""
         try:
@@ -213,10 +213,10 @@ def endtimestr(self):
     @property
     def summary(self):
         """
-            Accessor returning a string describing and
-            summarizing the scan.
+        Accessor returning a string describing and
+        summarizing the scan.
 
-            :return: string
+        :return: string
         """
         rval = ""
         try:
@@ -239,9 +239,9 @@ def summary(self):
     @property
     def elapsed(self):
         """
-            Accessor returning the number of seconds the scan took
+        Accessor returning the number of seconds the scan took
 
-            :return: float (0 >= or -1)
+        :return: float (0 >= or -1)
         """
         rval = -1
         try:
@@ -254,10 +254,10 @@ def elapsed(self):
     @property
     def hosts_up(self):
         """
-            Accessor returning the numer of host detected
-            as 'up' during the scan.
+        Accessor returning the numer of host detected
+        as 'up' during the scan.
 
-            :return: integer (0 >= or -1)
+        :return: integer (0 >= or -1)
         """
         rval = -1
         try:
@@ -270,10 +270,10 @@ def hosts_up(self):
     @property
     def hosts_down(self):
         """
-            Accessor returning the numer of host detected
-            as 'down' during the scan.
+        Accessor returning the numer of host detected
+        as 'down' during the scan.
 
-            :return: integer (0 >= or -1)
+        :return: integer (0 >= or -1)
         """
         rval = -1
         try:
@@ -286,9 +286,9 @@ def hosts_down(self):
     @property
     def hosts_total(self):
         """
-            Accessor returning the number of hosts scanned in total.
+        Accessor returning the number of hosts scanned in total.
 
-            :return: integer (0 >= or -1)
+        :return: integer (0 >= or -1)
         """
         rval = -1
         try:
@@ -300,10 +300,10 @@ def hosts_total(self):
 
     def get_raw_data(self):
         """
-            Returns a dict representing the NmapReport object.
+        Returns a dict representing the NmapReport object.
 
-            :return: dict
-            :todo: deprecate. get rid of this ugliness.
+        :return: dict
+        :todo: deprecate. get rid of this ugliness.
         """
         raw_data = {
             "_nmaprun": self._nmaprun,
@@ -321,11 +321,11 @@ def __set_raw_data(self, raw_data):
 
     def is_consistent(self):
         """
-            Checks if the report is consistent and can be diffed().
+        Checks if the report is consistent and can be diffed().
 
-            This needs to be rewritten and removed: diff() should be generic.
+        This needs to be rewritten and removed: diff() should be generic.
 
-            :return: boolean
+        :return: boolean
         """
         rval = True
         rdata = self.get_raw_data()
@@ -338,10 +338,10 @@ def is_consistent(self):
 
     def get_dict(self):
         """
-            Return a python dict representation of the NmapReport object.
-            This is used to diff() NmapReport objects via NmapDiff.
+        Return a python dict representation of the NmapReport object.
+        This is used to diff() NmapReport objects via NmapDiff.
 
-            :return: dict
+        :return: dict
         """
         rdict = dict(
             [
@@ -368,18 +368,18 @@ def get_dict(self):
     @property
     def id(self):
         """
-            Dummy id() defined for reports.
+        Dummy id() defined for reports.
         """
         return hash(1)
 
     def __eq__(self, other):
         """
-            Compare eq NmapReport based on :
+        Compare eq NmapReport based on :
 
-                - create a diff obj and check the result
-                report are equal if added&changed&removed are empty
+            - create a diff obj and check the result
+            report are equal if added&changed&removed are empty
 
-            :return: boolean
+        :return: boolean
         """
         rval = False
         if self.__class__ == other.__class__ and self.id == other.id:
@@ -393,12 +393,12 @@ def __eq__(self, other):
 
     def __ne__(self, other):
         """
-            Compare ne NmapReport based on:
+        Compare ne NmapReport based on:
 
-                - create a diff obj and check the result
-                report are ne if added|changed|removed are not empty
+            - create a diff obj and check the result
+            report are ne if added|changed|removed are not empty
 
-            :return: boolean
+        :return: boolean
         """
         rval = True
         if self.__class__ == other.__class__ and self.id == other.id:
diff --git a/libnmap/objects/service.py b/libnmap/objects/service.py
index 70fc5d0..10b9b64 100644
--- a/libnmap/objects/service.py
+++ b/libnmap/objects/service.py
@@ -5,11 +5,11 @@
 
 class NmapService(object):
     """
-        NmapService represents a nmap scanned service. Its id() is comprised
-        of the protocol and the port.
+    NmapService represents a nmap scanned service. Its id() is comprised
+    of the protocol and the port.
 
-        Depending on the scanning options, some additional details might be
-        available or not. Like banner or extra datas from NSE (nmap scripts).
+    Depending on the scanning options, some additional details might be
+    available or not. Like banner or extra datas from NSE (nmap scripts).
     """
 
     def __init__(
@@ -22,18 +22,18 @@ def __init__(
         service_extras=None,
     ):
         """
-            Constructor
+        Constructor
 
-            :param portid: port number
-            :type portid: string
-            :param protocol: protocol of port scanned (tcp, udp)
-            :type protocol: string
-            :param state: python dict describing the service status
-            :type state: python dict
-            :param service: python dict describing the service name and banner
-            :type service: python dict
-            :param service_extras: additional info about the tested service
-            like scripts' data
+        :param portid: port number
+        :type portid: string
+        :param protocol: protocol of port scanned (tcp, udp)
+        :type protocol: string
+        :param state: python dict describing the service status
+        :type state: python dict
+        :param service: python dict describing the service name and banner
+        :type service: python dict
+        :param service_extras: additional info about the tested service
+        like scripts' data
         """
         try:
             self._portid = int(portid or -1)
@@ -80,12 +80,12 @@ def __init__(
 
     def __eq__(self, other):
         """
-            Compares two NmapService objects to see if they are the same or
-            if one of them changed.
+        Compares two NmapService objects to see if they are the same or
+        if one of them changed.
 
-            :param other: NmapService
+        :param other: NmapService
 
-            :return: boolean
+        :return: boolean
         """
         rval = False
         if self.__class__ == other.__class__ and self.id == other.id:
@@ -94,12 +94,12 @@ def __eq__(self, other):
 
     def __ne__(self, other):
         """
-            Compares two NmapService objects to see if they are different
-            if one of them changed.
+        Compares two NmapService objects to see if they are different
+        if one of them changed.
 
-            :param other: NmapService
+        :param other: NmapService
 
-            :return: boolean
+        :return: boolean
         """
         rval = True
         if self.__class__ == other.__class__ and self.id == other.id:
@@ -128,108 +128,108 @@ def __hash__(self):
 
     def changed(self, other):
         """
-            Checks if a NmapService is different from another.
+        Checks if a NmapService is different from another.
 
-            :param other: NmapService
+        :param other: NmapService
 
-            :return: boolean
+        :return: boolean
         """
         return len(self.diff(other).changed())
 
     @property
     def port(self):
         """
-            Accessor for port.
+        Accessor for port.
 
-            :return: integer or -1
+        :return: integer or -1
         """
         return self._portid
 
     @property
     def protocol(self):
         """
-            Accessor for protocol
+        Accessor for protocol
 
-            :return: string
+        :return: string
         """
         return self._protocol
 
     @property
     def state(self):
         """
-            Accessor for service's state (open, filtered, closed,...)
+        Accessor for service's state (open, filtered, closed,...)
 
-            :return: string
+        :return: string
         """
         return self._state["state"] if "state" in self._state else None
 
     @property
     def reason(self):
         """
-            Accessor for service's state reason (syn-ack, filtered,...)
+        Accessor for service's state reason (syn-ack, filtered,...)
 
-            :return: string or empty if not applicable
+        :return: string or empty if not applicable
         """
         return self._reason
 
     @property
     def reason_ip(self):
         """
-            Accessor for service's state reason ip
+        Accessor for service's state reason ip
 
-            :return: string or empty if not applicable
+        :return: string or empty if not applicable
         """
         return self._reason_ip
 
     @property
     def reason_ttl(self):
         """
-            Accessor for service's state reason ttl
+        Accessor for service's state reason ttl
 
-            :return: string or empty if not applicable
+        :return: string or empty if not applicable
         """
         return self._reason_ttl
 
     @property
     def service(self):
         """
-            Accessor for service name.
+        Accessor for service name.
 
-            :return: string or empty
+        :return: string or empty
         """
         return self._service["name"] if "name" in self._service else ""
 
     @property
     def service_dict(self):
         """
-            Accessor for service dictionary.
+        Accessor for service dictionary.
 
-            :return: dict or None
+        :return: dict or None
         """
         return self._service
 
     def open(self):
         """
-            Tells if the port was open or not
+        Tells if the port was open or not
 
-            :return: boolean
+        :return: boolean
         """
         return "state" in self._state and self._state["state"] == "open"
 
     @property
     def owner(self):
         """
-            Accessor for service owner if available
+        Accessor for service owner if available
         """
         return self._owner
 
     @property
     def banner(self):
         """
-            Accessor for the service's banner. Only available
-            if the nmap option -sV or similar was used.
+        Accessor for the service's banner. Only available
+        if the nmap option -sV or similar was used.
 
-            :return: string
+        :return: string
         """
         notrelevant = [
             "name",
@@ -254,19 +254,19 @@ def banner(self):
     @property
     def cpelist(self):
         """
-            Accessor for list of CPE for this particular service
+        Accessor for list of CPE for this particular service
         """
         return self._cpelist
 
     @property
     def scripts_results(self):
         """
-            Gives a python list of the nse scripts results.
+        Gives a python list of the nse scripts results.
 
-            The dict key is the name (id) of the nse script and
-            the value is the output of the script.
+        The dict key is the name (id) of the nse script and
+        the value is the output of the script.
 
-            :return: dict
+        :return: dict
         """
         scripts_dict = None
         try:
@@ -278,42 +278,42 @@ def scripts_results(self):
     @property
     def servicefp(self):
         """
-            Accessor for the service's fingerprint
-            if the nmap option -sV or -A is used
+        Accessor for the service's fingerprint
+        if the nmap option -sV or -A is used
 
-            :return: string if available
+        :return: string if available
         """
         return self._servicefp
 
     @property
     def tunnel(self):
         """
-            Accessor for the service's tunnel type
-            if applicable and available from scan
-            results
+        Accessor for the service's tunnel type
+        if applicable and available from scan
+        results
 
-            :return: string if available
+        :return: string if available
         """
         return self._tunnel
 
     @property
     def id(self):
         """
-            Accessor for the id() of the NmapService.
+        Accessor for the id() of the NmapService.
 
-            This is used for diff()ing NmapService object via NmapDiff.
+        This is used for diff()ing NmapService object via NmapDiff.
 
-            :return: tuple
+        :return: tuple
         """
         return "{0}.{1}".format(self.protocol, self.port)
 
     def get_dict(self):
         """
-            Return a python dict representation of the NmapService object.
+        Return a python dict representation of the NmapService object.
 
-            This is used to diff() NmapService objects via NmapDiff.
+        This is used to diff() NmapService objects via NmapDiff.
 
-            :return: dict
+        :return: dict
         """
         return {
             "id": str(self.id),
@@ -327,14 +327,14 @@ def get_dict(self):
 
     def diff(self, other):
         """
-            Calls NmapDiff to check the difference between self and
-            another NmapService object.
+        Calls NmapDiff to check the difference between self and
+        another NmapService object.
 
-            Will return a NmapDiff object.
+        Will return a NmapDiff object.
 
-            This objects return python set() of keys describing the elements
-            which have changed, were added, removed or kept unchanged.
+        This objects return python set() of keys describing the elements
+        which have changed, were added, removed or kept unchanged.
 
-            :return: NmapDiff object
+        :return: NmapDiff object
         """
         return NmapDiff(self, other)
diff --git a/libnmap/parser.py b/libnmap/parser.py
index 928a62b..8da7e09 100644
--- a/libnmap/parser.py
+++ b/libnmap/parser.py
@@ -8,8 +8,10 @@
         import xml.etree.cElementTree as ET
     except ImportError:
         import xml.etree.ElementTree as ET
+
 from xml.etree.ElementTree import iselement as et_iselement
-from libnmap.objects import NmapHost, NmapService, NmapReport
+
+from libnmap.objects import NmapHost, NmapReport, NmapService
 
 
 class NmapParser(object):
@@ -119,13 +121,13 @@ def _parse_xml(cls, nmap_data=None, incomplete=False):
     @classmethod
     def _parse_xml_report(cls, root=None):
         """
-            This method parses out a full nmap scan report from its XML root
-            node: <nmaprun>.
+        This method parses out a full nmap scan report from its XML root
+        node: <nmaprun>.
 
-            :param root: Element from xml.ElementTree (top of XML the document)
-            :type root: Element
+        :param root: Element from xml.ElementTree (top of XML the document)
+        :type root: Element
 
-            :return: NmapReport object
+        :return: NmapReport object
         """
 
         nmap_scan = {
@@ -265,13 +267,13 @@ def parse_fromdict(cls, rdict):
     @classmethod
     def __parse_scaninfo(cls, scaninfo_data):
         """
-            Private method parsing a portion of a nmap scan result.
-            Receives a <scaninfo> XML tag.
+        Private method parsing a portion of a nmap scan result.
+        Receives a <scaninfo> XML tag.
 
-            :param scaninfo_data: <scaninfo> XML tag from a nmap scan
-            :type scaninfo_data: xml.ElementTree.Element or a string
+        :param scaninfo_data: <scaninfo> XML tag from a nmap scan
+        :type scaninfo_data: xml.ElementTree.Element or a string
 
-            :return: python dict representing the XML scaninfo tag
+        :return: python dict representing the XML scaninfo tag
         """
 
         xelement = cls.__format_element(scaninfo_data)
@@ -280,14 +282,14 @@ def __parse_scaninfo(cls, scaninfo_data):
     @classmethod
     def _parse_xml_host(cls, scanhost_data):
         """
-            Protected method parsing a portion of a nmap scan result.
-            Receives a <host> XML tag representing a scanned host with
-            its services.
+        Protected method parsing a portion of a nmap scan result.
+        Receives a <host> XML tag representing a scanned host with
+        its services.
 
-            :param scaninfo_data: <host> XML tag from a nmap scan
-            :type scaninfo_data: xml.ElementTree.Element or a string
+        :param scaninfo_data: <host> XML tag from a nmap scan
+        :type scaninfo_data: xml.ElementTree.Element or a string
 
-            :return: NmapHost object
+        :return: NmapHost object
         """
 
         xelement = cls.__format_element(scanhost_data)
@@ -345,12 +347,12 @@ def _parse_xml_host(cls, scanhost_data):
     @classmethod
     def __parse_hostnames(cls, scanhostnames_data):
         """
-            Private method parsing the hostnames list within a <host> XML tag.
+        Private method parsing the hostnames list within a <host> XML tag.
 
-            :param scanhostnames_data: <hostnames> XML tag from a nmap scan
-            :type scanhostnames_data: xml.ElementTree.Element or a string
+        :param scanhostnames_data: <hostnames> XML tag from a nmap scan
+        :type scanhostnames_data: xml.ElementTree.Element or a string
 
-            :return: list of hostnames
+        :return: list of hostnames
         """
 
         xelement = cls.__format_element(scanhostnames_data)
@@ -363,16 +365,16 @@ def __parse_hostnames(cls, scanhostnames_data):
     @classmethod
     def _parse_xml_ports(cls, scanports_data):
         """
-            Protected method parsing the list of scanned services from
-            a targeted host. This protected method cannot be called directly
-            with a string. A <ports/> tag can be directly passed to parse()
-            and the below method will be called and return a list of nmap
-            scanned services.
+        Protected method parsing the list of scanned services from
+        a targeted host. This protected method cannot be called directly
+        with a string. A <ports/> tag can be directly passed to parse()
+        and the below method will be called and return a list of nmap
+        scanned services.
 
-            :param scanports_data: <ports> XML tag from a nmap scan
-            :type scanports_data: xml.ElementTree.Element or a string
+        :param scanports_data: <ports> XML tag from a nmap scan
+        :type scanports_data: xml.ElementTree.Element or a string
 
-            :return: list of NmapService
+        :return: list of NmapService
         """
 
         xelement = cls.__format_element(scanports_data)
@@ -393,16 +395,16 @@ def _parse_xml_ports(cls, scanports_data):
     @classmethod
     def _parse_xml_port(cls, scanport_data):
         """
-            Protected method parsing a scanned service from a targeted host.
-            This protected method cannot be called directly.
-            A <port/> tag can be directly passed to parse() and the below
-            method will be called and return a NmapService object
-            representing the state of the service.
+        Protected method parsing a scanned service from a targeted host.
+        This protected method cannot be called directly.
+        A <port/> tag can be directly passed to parse() and the below
+        method will be called and return a NmapService object
+        representing the state of the service.
 
-            :param scanport_data: <port> XML tag from a nmap scan
-            :type scanport_data: xml.ElementTree.Element or a string
+        :param scanport_data: <port> XML tag from a nmap scan
+        :type scanport_data: xml.ElementTree.Element or a string
 
-            :return: NmapService
+        :return: NmapService
         """
 
         xelement = cls.__format_element(scanport_data)
@@ -443,7 +445,7 @@ def _parse_xml_port(cls, scanport_data):
     @classmethod
     def __parse_service(cls, xserv):
         """
-            Parse <service> tag to manage CPE object
+        Parse <service> tag to manage CPE object
         """
         _service = cls.__format_attributes(xserv)
         _cpelist = []
@@ -457,14 +459,14 @@ def __parse_service(cls, xserv):
     @classmethod
     def __parse_extraports(cls, extraports_data):
         """
-            Private method parsing the data from extra scanned ports.
-            X extraports were in state "closed" server returned "conn-refused"
-            tag: <extraports>
+        Private method parsing the data from extra scanned ports.
+        X extraports were in state "closed" server returned "conn-refused"
+        tag: <extraports>
 
-            :param extraports_data: XML data for extraports
-            :type extraports_data: xml.ElementTree.Element or a string
+        :param extraports_data: XML data for extraports
+        :type extraports_data: xml.ElementTree.Element or a string
 
-            :return: python dict with following keys: state, count, reason
+        :return: python dict with following keys: state, count, reason
         """
         rdict = {"state": "", "count": "", "reasons": []}
         xelement = cls.__format_element(extraports_data)
@@ -483,12 +485,12 @@ def __parse_extraports(cls, extraports_data):
     @classmethod
     def __parse_script_table(cls, script_table):
         """
-           Private method parsing a table from NSE scripts output
+        Private method parsing a table from NSE scripts output
 
-           :param sccript_table: poertion of XML containing the table
-           :type script_table: xml.ElementTree.Element
+        :param sccript_table: poertion of XML containing the table
+        :type script_table: xml.ElementTree.Element
 
-           :return: python dict of table structure
+        :return: python dict of table structure
         """
         tdict = {}
         for telem in script_table:
@@ -515,13 +517,13 @@ def __parse_script_table(cls, script_table):
     @classmethod
     def __parse_script(cls, script_data):
         """
-            Private method parsing the data from NSE scripts output
+        Private method parsing the data from NSE scripts output
 
-            :param script_data: portion of XML describing the results of the
-            script data
-            :type script_data: xml.ElementTree.Element or a string
+        :param script_data: portion of XML describing the results of the
+        script data
+        :type script_data: xml.ElementTree.Element or a string
 
-            :return: python dict holding scripts output
+        :return: python dict holding scripts output
         """
         _script_dict = cls.__format_attributes(script_data)
 
@@ -545,15 +547,15 @@ def __parse_script(cls, script_data):
     @classmethod
     def __parse_host_scripts(cls, scripts_data):
         """
-            Private method parsing the data from scripts affecting
-            the target host.
-            Contents of <hostscript> is returned as a list of dict.
+        Private method parsing the data from scripts affecting
+        the target host.
+        Contents of <hostscript> is returned as a list of dict.
 
-            :param scripts_data: portion of XML describing the results of the
-            scripts data
-            :type scripts_data: xml.ElementTree.Element or a string
+        :param scripts_data: portion of XML describing the results of the
+        scripts data
+        :type scripts_data: xml.ElementTree.Element or a string
 
-            :return: python list holding scripts output in a dict
+        :return: python list holding scripts output in a dict
         """
         _host_scripts = []
         for xscript in scripts_data:
@@ -565,14 +567,14 @@ def __parse_host_scripts(cls, scripts_data):
     @classmethod
     def __parse_os_fingerprint(cls, os_data):
         """
-            Private method parsing the data from an OS fingerprint (-O).
-            Contents of <os> is returned as a dict.
+        Private method parsing the data from an OS fingerprint (-O).
+        Contents of <os> is returned as a dict.
 
-            :param os_data: portion of XML describing the results of the
-            os fingerprinting attempt
-            :type os_data: xml.ElementTree.Element or a string
+        :param os_data: portion of XML describing the results of the
+        os fingerprinting attempt
+        :type os_data: xml.ElementTree.Element or a string
 
-            :return: python dict representing the XML os tag
+        :return: python dict representing the XML os tag
         """
         rdict = {}
         xelement = cls.__format_element(os_data)
@@ -607,14 +609,14 @@ def __parse_os_fingerprint(cls, os_data):
     @classmethod
     def __parse_osmatch(cls, osmatch_data):
         """
-            This methods parses osmatch data and returns a dict. Depending
-            on the nmap xml version, osmatch could contain an osclass
-            dict.
+        This methods parses osmatch data and returns a dict. Depending
+        on the nmap xml version, osmatch could contain an osclass
+        dict.
 
-            :param osmatch_data: <osmatch> XML tag from a nmap scan
-            :type osmatch_data: xml.ElementTree.Element or a string
+        :param osmatch_data: <osmatch> XML tag from a nmap scan
+        :type osmatch_data: xml.ElementTree.Element or a string
 
-            :return: python dict representing the XML osmatch tag
+        :return: python dict representing the XML osmatch tag
         """
         rdict = {}
         xelement = cls.__format_element(osmatch_data)
@@ -632,14 +634,14 @@ def __parse_osmatch(cls, osmatch_data):
     @classmethod
     def __parse_osclass(cls, osclass_data):
         """
-            This methods parses osclass data and returns a dict. Depending
-            on the nmap xml version, osclass could contain a cpe
-            dict.
+        This methods parses osclass data and returns a dict. Depending
+        on the nmap xml version, osclass could contain a cpe
+        dict.
 
-            :param osclass_data: <osclass> XML tag from a nmap scan
-            :type osclass_data: xml.ElementTree.Element or a string
+        :param osclass_data: <osclass> XML tag from a nmap scan
+        :type osclass_data: xml.ElementTree.Element or a string
 
-            :return: python dict representing the XML osclass tag
+        :return: python dict representing the XML osclass tag
         """
         rdict = {}
         xelement = cls.__format_element(osclass_data)
@@ -657,13 +659,13 @@ def __parse_osclass(cls, osclass_data):
     @classmethod
     def __parse_runstats(cls, scanrunstats_data):
         """
-            Private method parsing a portion of a nmap scan result.
-            Receives a <runstats> XML tag.
+        Private method parsing a portion of a nmap scan result.
+        Receives a <runstats> XML tag.
 
-            :param scanrunstats_data: <runstats> XML tag from a nmap scan
-            :type scanrunstats_data: xml.ElementTree.Element or a string
+        :param scanrunstats_data: <runstats> XML tag from a nmap scan
+        :type scanrunstats_data: xml.ElementTree.Element or a string
 
-            :return: python dict representing the XML runstats tag
+        :return: python dict representing the XML runstats tag
         """
 
         xelement = cls.__format_element(scanrunstats_data)
@@ -681,15 +683,15 @@ def __parse_runstats(cls, scanrunstats_data):
     @staticmethod
     def __format_element(elt_data):
         """
-            Private method which ensures that a XML portion to be parsed is
-            of type xml.etree.ElementTree.Element.
-            If elt_data is a string, then it is converted to an
-            XML Element type.
+        Private method which ensures that a XML portion to be parsed is
+        of type xml.etree.ElementTree.Element.
+        If elt_data is a string, then it is converted to an
+        XML Element type.
 
-            :param elt_data: XML Element to be parsed or string
-            to be converted to a XML Element
+        :param elt_data: XML Element to be parsed or string
+        to be converted to a XML Element
 
-            :return: Element
+        :return: Element
         """
         if isinstance(elt_data, str):
             try:
@@ -712,14 +714,14 @@ def __format_element(elt_data):
     @staticmethod
     def __format_attributes(elt_data):
         """
-            Private method which converts a single XML tag to a python dict.
-            It also checks that the elt_data given as argument is of type
-            xml.etree.ElementTree.Element
+        Private method which converts a single XML tag to a python dict.
+        It also checks that the elt_data given as argument is of type
+        xml.etree.ElementTree.Element
 
-            :param elt_data: XML Element to be parsed or string
-            to be converted to a XML Element
+        :param elt_data: XML Element to be parsed or string
+        to be converted to a XML Element
 
-            :return: Element
+        :return: Element
         """
 
         rval = {}
diff --git a/libnmap/plugins/backendplugin.py b/libnmap/plugins/backendplugin.py
index e14a23e..cfbf393 100644
--- a/libnmap/plugins/backendplugin.py
+++ b/libnmap/plugins/backendplugin.py
@@ -3,8 +3,8 @@
 
 class NmapBackendPlugin(object):
     """
-        Abstract class showing to the minimal implementation for a plugin
-        All subclass MUST at least implement the following methods
+    Abstract class showing to the minimal implementation for a plugin
+    All subclass MUST at least implement the following methods
     """
 
     def __init__(self):
@@ -13,32 +13,32 @@ def __init__(self):
 
     def insert(self, NmapReport):
         """
-            insert NmapReport in the backend
-            :param NmapReport:
-            :return: str the ident of the object in the backend for
-            future usage
-            or None
+        insert NmapReport in the backend
+        :param NmapReport:
+        :return: str the ident of the object in the backend for
+        future usage
+        or None
         """
         raise NotImplementedError
 
     def delete(self, id):
         """
-            delete NmapReport if the backend
-            :param id: str
+        delete NmapReport if the backend
+        :param id: str
         """
         raise NotImplementedError
 
     def get(self, id):
         """
-            retreive a NmapReport from the backend
-            :param id: str
-            :return: NmapReport
+        retreive a NmapReport from the backend
+        :param id: str
+        :return: NmapReport
         """
         raise NotImplementedError
 
     def getall(self, filter):
         """
-            :return: collection of tuple (id,NmapReport)
-            :param filter: Nice to have implement a filter capability
+        :return: collection of tuple (id,NmapReport)
+        :param filter: Nice to have implement a filter capability
         """
         raise NotImplementedError
diff --git a/libnmap/plugins/backendpluginFactory.py b/libnmap/plugins/backendpluginFactory.py
index 83494b3..3b06bfd 100644
--- a/libnmap/plugins/backendpluginFactory.py
+++ b/libnmap/plugins/backendpluginFactory.py
@@ -1,23 +1,23 @@
 #!/usr/bin/env python
-import sys
 import inspect
+import sys
 
 
 class BackendPluginFactory(object):
     """
-        This is a backend plugin factory a backend instance MUST be
-        created via the static method create()
-        ie : mybackend = BackendPluginFactory.create()
+    This is a backend plugin factory a backend instance MUST be
+    created via the static method create()
+    ie : mybackend = BackendPluginFactory.create()
     """
 
     @classmethod
     def create(cls, plugin_name="mongodb", **kwargs):
         """Import the needed lib and return an object NmapBackendPlugin
-           representing the backend of your desire.
-           NmapBackendPlugin is an abstract class, to know what argument
-           need to be given, review the code of the subclass you need
-           :param plugin_name: str : name of the py file without .py
-           :return: NmapBackend (abstract class on top of all plugin)
+        representing the backend of your desire.
+        NmapBackendPlugin is an abstract class, to know what argument
+        need to be given, review the code of the subclass you need
+        :param plugin_name: str : name of the py file without .py
+        :return: NmapBackend (abstract class on top of all plugin)
         """
         backendplugin = None
         plugin_path = "libnmap.plugins.{0}".format(plugin_name)
diff --git a/libnmap/plugins/es.py b/libnmap/plugins/es.py
index 311fb75..688a3d2 100644
--- a/libnmap/plugins/es.py
+++ b/libnmap/plugins/es.py
@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
 
 import json
-from libnmap.reportjson import ReportEncoder
-from libnmap.plugins.backendplugin import NmapBackendPlugin
-from elasticsearch import Elasticsearch
 from datetime import datetime
 
+from elasticsearch import Elasticsearch
+
+from libnmap.plugins.backendplugin import NmapBackendPlugin
+from libnmap.reportjson import ReportEncoder
+
 
 class NmapElasticsearchPlugin(NmapBackendPlugin):
     """
@@ -22,11 +24,11 @@ def __init__(self, index=None):
 
     def insert(self, report, doc_type=None):
         """
-            insert NmapReport in the backend
-            :param NmapReport:
-            :return: str the ident of the object in the backend for
-            future usage
-            or None
+        insert NmapReport in the backend
+        :param NmapReport:
+        :return: str the ident of the object in the backend for
+        future usage
+        or None
         """
         if doc_type is None:
             doc_type = "NmapReport"
@@ -39,16 +41,16 @@ def insert(self, report, doc_type=None):
 
     def delete(self, id):
         """
-            delete NmapReport if the backend
-            :param id: str
+        delete NmapReport if the backend
+        :param id: str
         """
         raise NotImplementedError
 
     def get(self, id):
         """
-            retreive a NmapReport from the backend
-            :param id: str
-            :return: NmapReport
+        retreive a NmapReport from the backend
+        :param id: str
+        :return: NmapReport
         """
         res = self._esapi.get(index=self.index, doc_type="NmapReport", id=id)
         rc = res["_source"]
@@ -56,8 +58,8 @@ def get(self, id):
 
     def getall(self, filter=None):
         """
-            :return: collection of tuple (id,NmapReport)
-            :param filter: Nice to have implement a filter capability
+        :return: collection of tuple (id,NmapReport)
+        :param filter: Nice to have implement a filter capability
         """
         rsearch = self._esapi.search(
             index=self.index, body={"query": {"match_all": {}}}
diff --git a/libnmap/plugins/mongodb.py b/libnmap/plugins/mongodb.py
index 6609760..1e707f3 100644
--- a/libnmap/plugins/mongodb.py
+++ b/libnmap/plugins/mongodb.py
@@ -1,21 +1,22 @@
 #!/usr/bin/env python
 import json
-from pymongo import MongoClient
+
 from bson.objectid import ObjectId
+from pymongo import MongoClient
 
-from libnmap.reportjson import ReportEncoder
 from libnmap.parser import NmapParser
 from libnmap.plugins.backendplugin import NmapBackendPlugin
+from libnmap.reportjson import ReportEncoder
 
 
 class NmapMongodbPlugin(NmapBackendPlugin):
     """
-        This class handle the persistence of NmapRepport object in mongodb
-        Implementation is made using pymongo
-        Object of this class must be create via the
-        BackendPluginFactory.create(**url) where url is a named dict like
-        {'plugin_name': "mongodb"} this dict may reeive all the param
-        MongoClient() support
+    This class handle the persistence of NmapRepport object in mongodb
+    Implementation is made using pymongo
+    Object of this class must be create via the
+    BackendPluginFactory.create(**url) where url is a named dict like
+    {'plugin_name': "mongodb"} this dict may reeive all the param
+    MongoClient() support
     """
 
     def __init__(self, dbname=None, store=None, **kwargs):
@@ -29,9 +30,9 @@ def __init__(self, dbname=None, store=None, **kwargs):
 
     def insert(self, report):
         """
-            create a json object from an NmapReport instance
-            :param NmapReport: obj to insert
-            :return: str id
+        create a json object from an NmapReport instance
+        :param NmapReport: obj to insert
+        :return: str id
         """
         j = json.dumps(report, cls=ReportEncoder)
         try:
@@ -42,9 +43,9 @@ def insert(self, report):
         return str(oid)
 
     def get(self, str_report_id=None):
-        """ select a NmapReport by Id
-            :param str: id
-            :return: NmapReport object
+        """select a NmapReport by Id
+        :param str: id
+        :return: NmapReport object
         """
         rid = str_report_id
         nmapreport = None
@@ -64,7 +65,7 @@ def get(self, str_report_id=None):
 
     def getall(self, dict_filter=None):
         """return a list of tuple (id,NmapReport) saved in the backend
-           TODO : add a filter capability
+        TODO : add a filter capability
         """
         nmapreportlist = []
         resultset = self.collection.find()
@@ -77,9 +78,9 @@ def getall(self, dict_filter=None):
 
     def delete(self, report_id=None):
         """
-            delete an obj from the backend
-            :param str: id
-            :return: dict document with result or None
+        delete an obj from the backend
+        :param str: id
+        :return: dict document with result or None
         """
         if report_id is not None and isinstance(report_id, str):
             return self.collection.remove({"_id": ObjectId(report_id)})
diff --git a/libnmap/plugins/s3.py b/libnmap/plugins/s3.py
index a090e2f..4074e08 100644
--- a/libnmap/plugins/s3.py
+++ b/libnmap/plugins/s3.py
@@ -12,47 +12,49 @@
 .. moduleauthor:: Mike Boutillier
 """
 import json
-from bson.objectid import ObjectId
-from boto.s3.connection import S3Connection, OrdinaryCallingFormat
-from boto.s3.key import Key
-from boto.s3.bucketlistresultset import bucket_lister
+
 from boto.exception import S3ResponseError
-from libnmap.reportjson import ReportEncoder
+from boto.s3.bucketlistresultset import bucket_lister
+from boto.s3.connection import OrdinaryCallingFormat, S3Connection
+from boto.s3.key import Key
+from bson.objectid import ObjectId
+
 from libnmap.parser import NmapParser
 from libnmap.plugins.backendplugin import NmapBackendPlugin
+from libnmap.reportjson import ReportEncoder
 
 
 class NmapS3Plugin(NmapBackendPlugin):
     """
-        This plugin save the reports on S3 and compatible.
+    This plugin save the reports on S3 and compatible.
     """
 
     def __init__(self, **kwargs):
         """
-            - create the conn object
-            - create the bucket (if it doesn't exist)
-                - if not given, awsaccessKey_nmapreport
-            - may raise exception (ie in case of conflict bucket name)
-            - sample :
-            To connect to walrus:
-            from libnmap.plugins.backendpluginFactory import
-                            BackendPluginFactory
-            walrusBackend =
-              BackendPluginFactory.create(
-                    plugin_name='s3',
-                    host="walrus.ecc.eucalyptus.com",
-                    path="/services/Walrus",port=8773,
-                    is_secure=False,
-                    aws_access_key_id='UU72FLVJCAYRATLXI70YH',
-                    aws_secret_access_key=
-                               'wFg7gP5YFHjVlxakw1g1uCC8UR2xVW5ax9ErZCut')
-           To connect to S3:
-           mybackend_S3 =
-             BackendPluginFactory.create(
-                plugin_name='s3',
-                is_secure=True,
-                aws_access_key_id='MYACCESSKEY',
-                aws_secret_access_key='MYSECRET')
+         - create the conn object
+         - create the bucket (if it doesn't exist)
+             - if not given, awsaccessKey_nmapreport
+         - may raise exception (ie in case of conflict bucket name)
+         - sample :
+         To connect to walrus:
+         from libnmap.plugins.backendpluginFactory import
+                         BackendPluginFactory
+         walrusBackend =
+           BackendPluginFactory.create(
+                 plugin_name='s3',
+                 host="walrus.ecc.eucalyptus.com",
+                 path="/services/Walrus",port=8773,
+                 is_secure=False,
+                 aws_access_key_id='UU72FLVJCAYRATLXI70YH',
+                 aws_secret_access_key=
+                            'wFg7gP5YFHjVlxakw1g1uCC8UR2xVW5ax9ErZCut')
+        To connect to S3:
+        mybackend_S3 =
+          BackendPluginFactory.create(
+             plugin_name='s3',
+             is_secure=True,
+             aws_access_key_id='MYACCESSKEY',
+             aws_secret_access_key='MYSECRET')
         """
         NmapBackendPlugin.__init__(self)
         try:
@@ -74,13 +76,13 @@ def __init__(self, **kwargs):
 
     def insert(self, report):
         """
-            create a json string from an NmapReport instance
-            and push it to S3 bucket.
+        create a json string from an NmapReport instance
+        and push it to S3 bucket.
 
-            :param NmapReport: obj to insert
-            :rtype: string
-            :return: str id
-            :todo: Add tagging option
+        :param NmapReport: obj to insert
+        :rtype: string
+        :return: str id
+        :todo: Add tagging option
         """
         try:
             oid = ObjectId()
@@ -95,11 +97,11 @@ def insert(self, report):
 
     def get(self, str_report_id=None):
         """
-            select a NmapReport by Id.
+        select a NmapReport by Id.
 
-            :param str: id
-            :rtype: NmapReport
-            :return: NmapReport object
+        :param str: id
+        :rtype: NmapReport
+        :return: NmapReport object
         """
         nmapreport = None
         if str_report_id is not None and isinstance(str_report_id, str):
@@ -114,9 +116,9 @@ def get(self, str_report_id=None):
 
     def getall(self, dict_filter=None):
         """
-            :rtype: List of tuple
-            :return: list of key/report
-            :todo: add a filter capability
+        :rtype: List of tuple
+        :return: list of key/report
+        :todo: add a filter capability
         """
         nmapreportlist = []
         for key in bucket_lister(self.bucket):
@@ -128,10 +130,10 @@ def getall(self, dict_filter=None):
 
     def delete(self, report_id=None):
         """
-            delete an obj from the backend
+        delete an obj from the backend
 
-            :param str: id
-            :return: dict document with result or None
+        :param str: id
+        :return: dict document with result or None
         """
         rcode = None
         if report_id is not None and isinstance(report_id, str):
diff --git a/libnmap/plugins/sql.py b/libnmap/plugins/sql.py
index b754306..dc0ede4 100644
--- a/libnmap/plugins/sql.py
+++ b/libnmap/plugins/sql.py
@@ -1,54 +1,54 @@
 #!/usr/bin/env python
+import json
+from datetime import datetime
+
 from sqlalchemy import create_engine
-from sqlalchemy.schema import Column
-from sqlalchemy.types import Integer, DateTime, LargeBinary
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
+from sqlalchemy.schema import Column
+from sqlalchemy.types import DateTime, Integer, LargeBinary
 
 from libnmap.plugins.backendplugin import NmapBackendPlugin
-from libnmap.reportjson import ReportEncoder, ReportDecoder
-
-import json
-from datetime import datetime
+from libnmap.reportjson import ReportDecoder, ReportEncoder
 
 Base = declarative_base()
 
 
 class NmapSqlPlugin(NmapBackendPlugin):
     """
-        This class handle the persistence of NmapRepport object in SQL backend
-        Implementation is made using sqlalchemy(0.8.1)
-        usage :
-
-        #get a nmapReport object
-        from libnmap.parser import NmapParser
-        from libnmap.reportjson import ReportDecoder, ReportEncoder
-        import json
-        nmap_report_obj = NmapParser.parse_fromfile(
-               '/home/vagrant/python-nmap-lib/libnmap/test/files/1_hosts.xml')
-
-         #get a backend with in memory sqlite
-         from libnmap.plugins.backendpluginFactory import BackendPluginFactory
-         mybackend_mem = BackendPluginFactory.create(plugin_name='sql',
-                                                     url='sqlite://',
-                                                     echo=True)
-
-         mybackend_mysql = BackendPluginFactory.create(plugin_name='sql',
-                            url='mysql+mysqldb://scott:tiger@localhost/foo',
-                            echo=True)
-         mybackend = BackendPluginFactory.create(plugin_name='sql',
-                                        url='sqlite:////tmp/reportdb.sql',
-                                        echo=True)
-         #lets save!!
-         nmap_report_obj.save(mybackend)
-         mybackend.getall()
-         mybackend.get(1)
+    This class handle the persistence of NmapRepport object in SQL backend
+    Implementation is made using sqlalchemy(0.8.1)
+    usage :
+
+    #get a nmapReport object
+    from libnmap.parser import NmapParser
+    from libnmap.reportjson import ReportDecoder, ReportEncoder
+    import json
+    nmap_report_obj = NmapParser.parse_fromfile(
+           '/home/vagrant/python-nmap-lib/libnmap/test/files/1_hosts.xml')
+
+     #get a backend with in memory sqlite
+     from libnmap.plugins.backendpluginFactory import BackendPluginFactory
+     mybackend_mem = BackendPluginFactory.create(plugin_name='sql',
+                                                 url='sqlite://',
+                                                 echo=True)
+
+     mybackend_mysql = BackendPluginFactory.create(plugin_name='sql',
+                        url='mysql+mysqldb://scott:tiger@localhost/foo',
+                        echo=True)
+     mybackend = BackendPluginFactory.create(plugin_name='sql',
+                                    url='sqlite:////tmp/reportdb.sql',
+                                    echo=True)
+     #lets save!!
+     nmap_report_obj.save(mybackend)
+     mybackend.getall()
+     mybackend.get(1)
     """
 
     class Reports(Base):
         """
-            Embeded class for ORM map NmapReport to a
-            simple three column table
+        Embeded class for ORM map NmapReport to a
+        simple three column table
         """
 
         __tablename__ = "reports"
@@ -69,22 +69,22 @@ def decode(self):
 
     def __init__(self, **kwargs):
         """
-            constructor receive a **kwargs as the **kwargs in the sqlalchemy
-            create_engine() method (see sqlalchemy docs)
-            You must add to this **kwargs an 'url' key with the url to your
-            database
-            This constructor will :
-            - create all the necessary obj to discuss with the DB
-            - create all the mapping(ORM)
-
-            todo : suport the : sqlalchemy.engine_from_config
-
-            :param **kwargs:
-            :raises: ValueError if no url is given,
-                    all exception sqlalchemy can throw
-            ie sqlite in memory url='sqlite://' echo=True
-            ie sqlite file on hd url='sqlite:////tmp/reportdb.sql' echo=True
-            ie mysql url='mysql+mysqldb://scott:tiger@localhost/foo'
+        constructor receive a **kwargs as the **kwargs in the sqlalchemy
+        create_engine() method (see sqlalchemy docs)
+        You must add to this **kwargs an 'url' key with the url to your
+        database
+        This constructor will :
+        - create all the necessary obj to discuss with the DB
+        - create all the mapping(ORM)
+
+        todo : suport the : sqlalchemy.engine_from_config
+
+        :param **kwargs:
+        :raises: ValueError if no url is given,
+                all exception sqlalchemy can throw
+        ie sqlite in memory url='sqlite://' echo=True
+        ie sqlite file on hd url='sqlite:////tmp/reportdb.sql' echo=True
+        ie mysql url='mysql+mysqldb://scott:tiger@localhost/foo'
         """
         NmapBackendPlugin.__init__(self)
         self.engine = None
@@ -121,11 +121,11 @@ def insert(self, nmap_report):
 
     def get(self, report_id=None):
         """
-            retreive a NmapReport from the backend
+        retreive a NmapReport from the backend
 
-            :param id: str
+        :param id: str
 
-            :returns: NmapReport
+        :returns: NmapReport
         """
         if report_id is None:
             raise ValueError
@@ -137,9 +137,9 @@ def get(self, report_id=None):
 
     def getall(self):
         """
-            :param filter: Nice to have implement a filter capability
+        :param filter: Nice to have implement a filter capability
 
-            :returns: collection of tuple (id,NmapReport)
+        :returns: collection of tuple (id,NmapReport)
         """
         sess = self.Session()
         nmapreportList = []
@@ -152,11 +152,11 @@ def getall(self):
 
     def delete(self, report_id=None):
         """
-            Remove a report from the backend
+        Remove a report from the backend
 
-            :param id: str
+        :param id: str
 
-            :returns: The number of rows deleted
+        :returns: The number of rows deleted
         """
         if report_id is None:
             raise ValueError
diff --git a/libnmap/process.py b/libnmap/process.py
index 83a5892..67107ae 100644
--- a/libnmap/process.py
+++ b/libnmap/process.py
@@ -2,12 +2,12 @@
 # -*- coding: utf-8 -*-
 
 import os
+import platform
 import shlex
 import subprocess
+import warnings
 from threading import Thread
 from xml.dom import pulldom
-import warnings
-import platform
 
 try:
     import pwd
diff --git a/libnmap/reportjson.py b/libnmap/reportjson.py
index 057d727..07925be 100644
--- a/libnmap/reportjson.py
+++ b/libnmap/reportjson.py
@@ -2,9 +2,15 @@
 # -*- coding: utf-8 -*-
 
 import json
-from libnmap.objects import NmapHost, NmapService, NmapReport
-from libnmap.objects.os import NmapOSFingerprint, NmapOSMatch, NmapOSClass
-from libnmap.objects.os import CPE, OSFPPortUsed
+
+from libnmap.objects import NmapHost, NmapReport, NmapService
+from libnmap.objects.os import (
+    CPE,
+    NmapOSClass,
+    NmapOSFingerprint,
+    NmapOSMatch,
+    OSFPPortUsed,
+)
 from libnmap.parser import NmapParser
 
 
diff --git a/libnmap/test/process-stressbox/check_fqp_nmap.py b/libnmap/test/process-stressbox/check_fqp_nmap.py
index 163c520..6308c2d 100644
--- a/libnmap/test/process-stressbox/check_fqp_nmap.py
+++ b/libnmap/test/process-stressbox/check_fqp_nmap.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-from libnmap.process import NmapProcess
 from libnmap.parser import NmapParser, NmapParserException
+from libnmap.process import NmapProcess
 
 
 # start a new nmap scan on localhost with some specific options
diff --git a/libnmap/test/process-stressbox/multi_nmap_process_background.py b/libnmap/test/process-stressbox/multi_nmap_process_background.py
index 5fea3d2..bff25c9 100644
--- a/libnmap/test/process-stressbox/multi_nmap_process_background.py
+++ b/libnmap/test/process-stressbox/multi_nmap_process_background.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 
-from libnmap.process import NmapProcess
 from time import sleep
 
+from libnmap.process import NmapProcess
+
 
 def make_nmproc_obj(targets, options):
     return NmapProcess(targets=targets, options=options)
diff --git a/libnmap/test/process-stressbox/proc_async.py b/libnmap/test/process-stressbox/proc_async.py
index 1f7a53d..3aa4a37 100644
--- a/libnmap/test/process-stressbox/proc_async.py
+++ b/libnmap/test/process-stressbox/proc_async.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 
-from libnmap.process import NmapProcess
 from time import sleep
 
+from libnmap.process import NmapProcess
 
 nmap_proc = NmapProcess(targets="scanme.nmap.org", options="-sT")
 nmap_proc.run_background()
diff --git a/libnmap/test/process-stressbox/proc_nmap_like.py b/libnmap/test/process-stressbox/proc_nmap_like.py
index 1b428c1..cf5eaae 100644
--- a/libnmap/test/process-stressbox/proc_nmap_like.py
+++ b/libnmap/test/process-stressbox/proc_nmap_like.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-from libnmap.process import NmapProcess
 from libnmap.parser import NmapParser, NmapParserException
+from libnmap.process import NmapProcess
 
 
 # start a new nmap scan on localhost with some specific options
diff --git a/libnmap/test/process-stressbox/stop_scan.py b/libnmap/test/process-stressbox/stop_scan.py
index 93906fd..ec9bec8 100644
--- a/libnmap/test/process-stressbox/stop_scan.py
+++ b/libnmap/test/process-stressbox/stop_scan.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 
-from libnmap.process import NmapProcess
 from time import sleep
 
+from libnmap.process import NmapProcess
 
 nmap_proc = NmapProcess(targets="scanme.nmap.org", options="-sV")
 nmap_proc.run_background()
diff --git a/libnmap/test/process-stressbox/stressback.py b/libnmap/test/process-stressbox/stressback.py
index 0a059fc..6f1a05a 100644
--- a/libnmap/test/process-stressbox/stressback.py
+++ b/libnmap/test/process-stressbox/stressback.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 
-from libnmap.process import NmapProcess
 from time import sleep
 
+from libnmap.process import NmapProcess
+
 
 def make_nmproc_obj(targets, options):
     return NmapProcess(targets=targets, options=options)
diff --git a/libnmap/test/process-stressbox/stresstest.py b/libnmap/test/process-stressbox/stresstest.py
index 812ca0c..34ca5a8 100644
--- a/libnmap/test/process-stressbox/stresstest.py
+++ b/libnmap/test/process-stressbox/stresstest.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-from libnmap.process import NmapProcess
 from libnmap.parser import NmapParser, NmapParserException
+from libnmap.process import NmapProcess
 
 nm = NmapProcess("127.0.0.1", "-sP")
 rc = nm.run()
diff --git a/libnmap/test/test_backend_plugin_factory.py b/libnmap/test/test_backend_plugin_factory.py
index f5733ca..9440e94 100644
--- a/libnmap/test/test_backend_plugin_factory.py
+++ b/libnmap/test/test_backend_plugin_factory.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import unittest
 import os
+import unittest
+
 from libnmap.parser import NmapParser
 from libnmap.plugins.backendplugin import NmapBackendPlugin
 from libnmap.plugins.backendpluginFactory import BackendPluginFactory
@@ -80,8 +81,8 @@ def setUp(self):
         ]
 
     def test_backend_factory(self):
-        """ test_factory BackendPluginFactory.create(**url)
-            Invoke factory and test that the object is of the right classes
+        """test_factory BackendPluginFactory.create(**url)
+        Invoke factory and test that the object is of the right classes
         """
         for url in self.urls:
             backend = BackendPluginFactory.create(**url)
@@ -90,8 +91,8 @@ def test_backend_factory(self):
             self.assertEqual(backend.__class__.__name__, className, True)
 
     def test_backend_insert(self):
-        """ test_insert
-            best way to insert is to call save() of nmapreport :P
+        """test_insert
+        best way to insert is to call save() of nmapreport :P
         """
         for nrp in self.reportList:
             for url in self.urls:
@@ -103,10 +104,10 @@ def test_backend_insert(self):
                 self.assertNotEqual(returncode, None)
 
     def test_backend_get(self):
-        """ test_backend_get
-            inset all report and save the returned id in a list
-            then get each id and create a new list of report
-            compare each report (assume eq)
+        """test_backend_get
+        inset all report and save the returned id in a list
+        then get each id and create a new list of report
+        compare each report (assume eq)
         """
         id_list = []
         result_list = []
@@ -125,9 +126,9 @@ def test_backend_getall(self):
         pass
 
     def test_backend_delete(self):
-        """ test_backend_delete
-            inset all report and save the returned id in a list
-            for each id remove the item and test if not present
+        """test_backend_delete
+        inset all report and save the returned id in a list
+        for each id remove the item and test if not present
         """
         id_list = []
         result_list = []
diff --git a/libnmap/test/test_cpe.py b/libnmap/test/test_cpe.py
index 4497a5c..d51d866 100644
--- a/libnmap/test/test_cpe.py
+++ b/libnmap/test/test_cpe.py
@@ -1,9 +1,10 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from libnmap.objects.os import CPE
 import unittest
 
+from libnmap.objects.os import CPE
+
 
 class TestNmapFP(unittest.TestCase):
     def setUp(self):
diff --git a/libnmap/test/test_defusedxml.py b/libnmap/test/test_defusedxml.py
index db2bf26..5215726 100644
--- a/libnmap/test/test_defusedxml.py
+++ b/libnmap/test/test_defusedxml.py
@@ -1,10 +1,12 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from libnmap.parser import NmapParser, NmapParserException
-import unittest
 import os
 import sys
+import unittest
+
+from libnmap.parser import NmapParser, NmapParserException
+
 
 class TestDefusedXML(unittest.TestCase):
     def setUp(self):
@@ -37,7 +39,7 @@ def setUp(self):
             self.fdir, "defused_et_local_includer.xml"
         )
 
-    def test_billion_laugh(self):       
+    def test_billion_laugh(self):
         self._assertRaisesRegex(
             NmapParserException,
             ".*EntitiesForbidden",
diff --git a/libnmap/test/test_fp.py b/libnmap/test/test_fp.py
index d3deb2a..cb599fc 100644
--- a/libnmap/test/test_fp.py
+++ b/libnmap/test/test_fp.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import unittest
 import os
+import unittest
+
 from libnmap.parser import NmapParser
 
 
diff --git a/libnmap/test/test_host.py b/libnmap/test/test_host.py
index df361d1..67830ff 100644
--- a/libnmap/test/test_host.py
+++ b/libnmap/test/test_host.py
@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import unittest
+
 from libnmap.parser import NmapParser
 
 host1 = """
diff --git a/libnmap/test/test_new_parser.py b/libnmap/test/test_new_parser.py
index 2a094ab..4549e2b 100644
--- a/libnmap/test/test_new_parser.py
+++ b/libnmap/test/test_new_parser.py
@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import unittest
+
 from libnmap.parser import NmapParser, NmapParserException
 
 baddatalist = [
diff --git a/libnmap/test/test_parser.py b/libnmap/test/test_parser.py
index e1eae50..b7f2537 100644
--- a/libnmap/test/test_parser.py
+++ b/libnmap/test/test_parser.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import unittest
 import os
+import unittest
+
 from libnmap.parser import NmapParser, NmapParserException
 
 
diff --git a/libnmap/test/test_report.py b/libnmap/test/test_report.py
index d9f2858..b777a5d 100644
--- a/libnmap/test/test_report.py
+++ b/libnmap/test/test_report.py
@@ -1,12 +1,13 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import unittest
 import os
+import unittest
+
+from libnmap.diff import NmapDiffException
 
 # sys.path.append("".join([os.path.dirname(__file__), "/../"]))
 from libnmap.parser import NmapParser
-from libnmap.diff import NmapDiffException
 
 
 class TestNmapParser(unittest.TestCase):
diff --git a/libnmap/test/test_report_diff.py b/libnmap/test/test_report_diff.py
index 69430cc..6b38230 100644
--- a/libnmap/test/test_report_diff.py
+++ b/libnmap/test/test_report_diff.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import unittest
 import os
+import unittest
+
 from libnmap.parser import NmapParser
 
 
diff --git a/libnmap/test/test_service.py b/libnmap/test/test_service.py
index bab5ef3..0e4c29d 100644
--- a/libnmap/test/test_service.py
+++ b/libnmap/test/test_service.py
@@ -2,8 +2,9 @@
 # -*- coding: utf-8 -*-
 
 import unittest
-from libnmap.parser import NmapParser
+
 from libnmap.diff import NmapDiffException
+from libnmap.parser import NmapParser
 
 service1 = """
 <port protocol="tcp" portid="22">
diff --git a/setup.py b/setup.py
index a0d3824..d86f6e4 100644
--- a/setup.py
+++ b/setup.py
@@ -12,7 +12,7 @@
     packages=["libnmap", "libnmap.plugins", "libnmap.objects"],
     url="http://pypi.python.org/pypi/python-libnmap/",
     extras_require={
-        'defusedxml': ['defusedxml>=0.6.0'],
+        "defusedxml": ["defusedxml>=0.6.0"],
     },
     license="Apache 2.0",
     description=(
diff --git a/tox.ini b/tox.ini
index 283b18e..1852194 100644
--- a/tox.ini
+++ b/tox.ini
@@ -3,8 +3,8 @@ envlist = py27, py32, py38, flake8, pycodestyle, formatting, defusedxml
 
 [testenv]
 deps=pytest
-     defusedxml
-commands=pytest --ignore=libnmap/test/test_backend_plugin_factory.py --ignore=libnmap/test/test_defusedxml.py 
+     pytest-cov
+commands=pytest --cov=libnmap/ --ignore=libnmap/test/test_backend_plugin_factory.py --ignore=libnmap/test/test_defusedxml.py 
 
 [testenv:defusedxml]
 deps=pytest