--- a/sat_frontends/jp/cmd_debug.py	Wed Jun 27 07:51:29 2018 +0200
+++ b/sat_frontends/jp/cmd_debug.py	Wed Jun 27 20:14:46 2018 +0200
@@ -28,32 +28,35 @@
 
 
 class BridgeCommon(object):
-
     def evalArgs(self):
         if self.args.arg:
             try:
-                return eval(u'[{}]'.format(u",".join(self.args.arg)))
+                return eval(u"[{}]".format(u",".join(self.args.arg)))
             except SyntaxError as e:
-                self.disp(u"Can't evaluate arguments: {mess}\n{text}\n{offset}^".format(
-                    mess=e,
-                    text=e.text.decode('utf-8'),
-                    offset=u" "*(e.offset-1)
-                    ), error=True)
+                self.disp(
+                    u"Can't evaluate arguments: {mess}\n{text}\n{offset}^".format(
+                        mess=e, text=e.text.decode("utf-8"), offset=u" " * (e.offset - 1)
+                    ),
+                    error=True,
+                )
                 self.host.quit(C.EXIT_BAD_ARG)
         else:
             return []
 
 
 class Method(base.CommandBase, BridgeCommon):
-
     def __init__(self, host):
-        base.CommandBase.__init__(self, host, 'method', help=_(u'call a bridge method'))
+        base.CommandBase.__init__(self, host, "method", help=_(u"call a bridge method"))
         BridgeCommon.__init__(self)
-        self.need_loop=True
+        self.need_loop = True
 
     def add_parser_options(self):
-        self.parser.add_argument("method", type=str, help=_(u"name of the method to execute"))
-        self.parser.add_argument("arg", type=base.unicode_decoder, nargs="*", help=_(u"argument of the method"))
+        self.parser.add_argument(
+            "method", type=str, help=_(u"name of the method to execute")
+        )
+        self.parser.add_argument(
+            "arg", type=base.unicode_decoder, nargs="*", help=_(u"argument of the method")
+        )
 
     def method_cb(self, ret=None):
         if ret is not None:
@@ -61,14 +64,22 @@
         self.host.quit()
 
     def method_eb(self, failure):
-        self.disp(_(u"Error while executing {}: {}".format(self.args.method, failure)), error=True)
+        self.disp(
+            _(u"Error while executing {}: {}".format(self.args.method, failure)),
+            error=True,
+        )
         self.host.quit(C.EXIT_ERROR)
 
     def start(self):
         method = getattr(self.host.bridge, self.args.method)
         args = self.evalArgs()
         try:
-            method(*args, profile=self.profile, callback=self.method_cb, errback=self.method_eb)
+            method(
+                *args,
+                profile=self.profile,
+                callback=self.method_cb,
+                errback=self.method_eb
+            )
         except TypeError:
             # maybe the method doesn't need a profile ?
             try:
@@ -78,14 +89,19 @@
 
 
 class Signal(base.CommandBase, BridgeCommon):
-
     def __init__(self, host):
-        base.CommandBase.__init__(self, host, 'signal', help=_(u'send a fake signal from backend'))
+        base.CommandBase.__init__(
+            self, host, "signal", help=_(u"send a fake signal from backend")
+        )
         BridgeCommon.__init__(self)
 
     def add_parser_options(self):
-        self.parser.add_argument("signal", type=str, help=_(u"name of the signal to send"))
-        self.parser.add_argument("arg", type=base.unicode_decoder, nargs="*", help=_(u"argument of the signal"))
+        self.parser.add_argument(
+            "signal", type=str, help=_(u"name of the signal to send")
+        )
+        self.parser.add_argument(
+            "arg", type=base.unicode_decoder, nargs="*", help=_(u"argument of the signal")
+        )
 
     def start(self):
         args = self.evalArgs()
@@ -99,27 +115,36 @@
     subcommands = (Method, Signal)
 
     def __init__(self, host):
-        super(Bridge, self).__init__(host, 'bridge', use_profile=False, help=_('bridge s(t)imulation'))
+        super(Bridge, self).__init__(
+            host, "bridge", use_profile=False, help=_("bridge s(t)imulation")
+        )
 
 
 class Monitor(base.CommandBase):
-
     def __init__(self, host):
-        super(Monitor, self).__init__(host,
-                                      'monitor',
-                                      use_verbose=True,
-                                      use_profile=False,
-                                      use_output=C.OUTPUT_XML,
-                                      help=_('monitor XML stream'))
+        super(Monitor, self).__init__(
+            host,
+            "monitor",
+            use_verbose=True,
+            use_profile=False,
+            use_output=C.OUTPUT_XML,
+            help=_("monitor XML stream"),
+        )
         self.need_loop = True
 
     def add_parser_options(self):
-        self.parser.add_argument("-d", "--direction", choices=('in', 'out', 'both'), default='both', help=_(u"stream direction filter"))
+        self.parser.add_argument(
+            "-d",
+            "--direction",
+            choices=("in", "out", "both"),
+            default="both",
+            help=_(u"stream direction filter"),
+        )
 
     def printXML(self, direction, xml_data, profile):
-        if self.args.direction == 'in' and direction != 'IN':
+        if self.args.direction == "in" and direction != "IN":
             return
-        if self.args.direction == 'out' and direction != 'OUT':
+        if self.args.direction == "out" and direction != "OUT":
             return
         verbosity = self.host.verbosity
         if not xml_data.strip():
@@ -130,31 +155,41 @@
             whiteping = False
 
         if verbosity:
-            profile_disp = u' ({})'.format(profile) if verbosity>1 else u''
-            if direction == 'IN':
-                self.disp(A.color(A.BOLD, A.FG_YELLOW, '<<<===== IN ====', A.FG_WHITE, profile_disp))
+            profile_disp = u" ({})".format(profile) if verbosity > 1 else u""
+            if direction == "IN":
+                self.disp(
+                    A.color(
+                        A.BOLD, A.FG_YELLOW, "<<<===== IN ====", A.FG_WHITE, profile_disp
+                    )
+                )
             else:
-                self.disp(A.color(A.BOLD, A.FG_CYAN, '==== OUT ====>>>', A.FG_WHITE, profile_disp))
+                self.disp(
+                    A.color(
+                        A.BOLD, A.FG_CYAN, "==== OUT ====>>>", A.FG_WHITE, profile_disp
+                    )
+                )
         if whiteping:
-            self.disp('[WHITESPACE PING]')
+            self.disp("[WHITESPACE PING]")
         else:
             try:
                 self.output(xml_data)
             except Exception:
-                # initial stream is not valid XML,
+                #  initial stream is not valid XML,
                 # in this case we print directly to data
-                # FIXME: we should test directly lxml.etree.XMLSyntaxError
+                #  FIXME: we should test directly lxml.etree.XMLSyntaxError
                 #        but importing lxml directly here is not clean
                 #        should be wrapped in a custom Exception
                 self.disp(xml_data)
-                self.disp(u'')
+                self.disp(u"")
 
     def start(self):
-        self.host.bridge.register_signal('xmlLog', self.printXML, 'plugin')
+        self.host.bridge.register_signal("xmlLog", self.printXML, "plugin")
 
 
 class Debug(base.CommandBase):
     subcommands = (Bridge, Monitor)
 
     def __init__(self, host):
-        super(Debug, self).__init__(host, 'debug', use_profile=False, help=_('debugging tools'))
+        super(Debug, self).__init__(
+            host, "debug", use_profile=False, help=_("debugging tools")
+        )