From 82ac7f1348b42eb559e80689dba3605e6c5bc402 Mon Sep 17 00:00:00 2001
From: Thomas Mangin <thomas.mangin@exa.net.uk>
Date: Sun, 20 Oct 2024 21:46:35 +0100
Subject: [PATCH] format with ruff format

---
 src/exabgp/application/cli.py                 |   5 +-
 src/exabgp/application/decode.py              |   2 +-
 src/exabgp/application/healthcheck.py         | 202 +++++++++---------
 src/exabgp/application/netlink.py             |   2 +-
 src/exabgp/application/pipe.py                |   2 +-
 src/exabgp/application/server.py              |  11 +-
 src/exabgp/application/validate.py            |   1 -
 src/exabgp/application/version.py             |   1 +
 src/exabgp/bgp/message/keepalive.py           |   2 +-
 src/exabgp/bgp/message/nop.py                 |   2 +-
 src/exabgp/bgp/message/notification.py        | 110 +++++-----
 src/exabgp/bgp/message/open/__init__.py       |   4 +-
 .../bgp/message/open/capability/addpath.py    |   2 +-
 .../message/open/capability/capabilities.py   |  12 +-
 .../bgp/message/open/capability/graceful.py   |   4 +-
 .../bgp/message/open/capability/hostname.py   |   1 -
 src/exabgp/bgp/message/open/capability/mp.py  |   2 +-
 .../bgp/message/open/capability/nexthop.py    |   4 +-
 .../bgp/message/open/capability/refresh.py    |   2 +-
 .../bgp/message/open/capability/software.py   |   3 +-
 src/exabgp/bgp/message/refresh.py             |   2 +-
 src/exabgp/bgp/message/unknown.py             |   2 +-
 src/exabgp/bgp/message/update/__init__.py     |   2 +-
 .../bgp/message/update/attribute/aspath.py    |  30 +--
 .../bgp/message/update/attribute/attribute.py |  12 +-
 .../message/update/attribute/attributes.py    |   2 +-
 .../update/attribute/bgpls/link/igpmetric.py  |   2 +-
 .../update/attribute/bgpls/link/linkname.py   |   2 +-
 .../update/attribute/bgpls/link/opaque.py     |   2 +-
 .../update/attribute/bgpls/link/rterid.py     |   2 +-
 .../update/attribute/bgpls/link/sradj.py      |   2 +-
 .../update/attribute/bgpls/link/sradjlan.py   |   2 +-
 .../update/attribute/bgpls/link/srlg.py       |   2 +-
 .../update/attribute/bgpls/link/temetric.py   |   1 +
 .../update/attribute/bgpls/linkstate.py       |   8 +-
 .../update/attribute/bgpls/node/isisarea.py   |   4 +-
 .../update/attribute/bgpls/node/lterid.py     |   6 +-
 .../update/attribute/bgpls/node/nodename.py   |   6 +-
 .../update/attribute/bgpls/node/opaque.py     |   6 +-
 .../update/attribute/bgpls/node/sralgo.py     |   4 +-
 .../update/attribute/bgpls/node/srcap.py      |   4 +-
 .../attribute/bgpls/prefix/igpextags.py       |   2 +-
 .../update/attribute/bgpls/prefix/igptags.py  |   2 +-
 .../update/attribute/bgpls/prefix/opaque.py   |   2 +-
 .../update/attribute/bgpls/prefix/ospfaddr.py |   2 +-
 .../attribute/bgpls/prefix/prefixmetric.py    |   2 +-
 .../update/attribute/bgpls/prefix/srprefix.py |   2 +-
 .../update/attribute/bgpls/prefix/srrid.py    |   2 +-
 .../attribute/community/extended/bandwidth.py |   4 +-
 .../attribute/community/extended/chso.py      |   6 +-
 .../attribute/community/extended/community.py |   2 +-
 .../community/extended/encapsulation.py       |  22 +-
 .../community/extended/flowspec_scope.py      |   4 +-
 .../attribute/community/extended/l2info.py    |   4 +-
 .../community/extended/mac_mobility.py        |   4 +-
 .../attribute/community/extended/mup.py       |   2 +-
 .../attribute/community/extended/origin.py    |   6 +-
 .../update/attribute/community/extended/rt.py |   6 +-
 .../attribute/community/extended/rt_record.py |   2 +-
 .../attribute/community/extended/traffic.py   |  32 +--
 .../community/initial/communities.py          |   6 +-
 .../attribute/community/initial/community.py  |   4 +-
 .../attribute/community/large/community.py    |   4 +-
 .../bgp/message/update/attribute/mprnlri.py   |   4 +-
 .../bgp/message/update/attribute/mpurnlri.py  |   2 +-
 .../bgp/message/update/attribute/pmsi.py      |   6 +-
 .../message/update/attribute/sr/labelindex.py |   5 +-
 .../message/update/attribute/sr/prefixsid.py  |   8 +-
 .../bgp/message/update/attribute/sr/srgb.py   |   5 +-
 .../update/attribute/sr/srv6/generic.py       |   8 +-
 .../update/attribute/sr/srv6/l2service.py     |  11 +-
 .../update/attribute/sr/srv6/l3service.py     |  11 +-
 .../attribute/sr/srv6/sidinformation.py       |  31 +--
 .../update/attribute/sr/srv6/sidstructure.py  |  31 +--
 src/exabgp/bgp/message/update/eor.py          |   2 +-
 .../bgp/message/update/nlri/bgpls/link.py     |  10 +-
 .../bgp/message/update/nlri/bgpls/nlri.py     |   4 +-
 .../bgp/message/update/nlri/bgpls/node.py     |   6 +-
 .../bgp/message/update/nlri/bgpls/prefixv4.py |   6 +-
 .../bgp/message/update/nlri/bgpls/prefixv6.py |   6 +-
 .../message/update/nlri/bgpls/tlvs/ipreach.py |  10 +-
 .../message/update/nlri/bgpls/tlvs/node.py    |   2 +-
 src/exabgp/bgp/message/update/nlri/cidr.py    |   2 +-
 .../message/update/nlri/evpn/ethernetad.py    |   6 +-
 .../bgp/message/update/nlri/evpn/mac.py       |  18 +-
 .../bgp/message/update/nlri/evpn/multicast.py |   8 +-
 .../bgp/message/update/nlri/evpn/nlri.py      |   6 +-
 .../bgp/message/update/nlri/evpn/prefix.py    |  12 +-
 .../bgp/message/update/nlri/evpn/segment.py   |   8 +-
 src/exabgp/bgp/message/update/nlri/flow.py    |  20 +-
 src/exabgp/bgp/message/update/nlri/inet.py    |   8 +-
 src/exabgp/bgp/message/update/nlri/ipvpn.py   |   2 +-
 src/exabgp/bgp/message/update/nlri/label.py   |   4 +-
 src/exabgp/bgp/message/update/nlri/mup/dsd.py |   8 +-
 src/exabgp/bgp/message/update/nlri/mup/isd.py |   6 +-
 .../bgp/message/update/nlri/mup/nlri.py       |  13 +-
 .../bgp/message/update/nlri/mup/t1st.py       |  14 +-
 .../bgp/message/update/nlri/mup/t2st.py       |  14 +-
 .../bgp/message/update/nlri/mvpn/nlri.py      |   6 +-
 .../message/update/nlri/mvpn/sharedjoin.py    |  12 +-
 .../bgp/message/update/nlri/mvpn/sourcead.py  |  10 +-
 .../message/update/nlri/mvpn/sourcejoin.py    |  12 +-
 src/exabgp/bgp/message/update/nlri/nlri.py    |   2 +-
 .../bgp/message/update/nlri/qualifier/esi.py  |   6 +-
 .../bgp/message/update/nlri/qualifier/etag.py |   4 +-
 .../message/update/nlri/qualifier/labels.py   |   8 +-
 .../bgp/message/update/nlri/qualifier/mac.py  |   2 +-
 src/exabgp/bgp/message/update/nlri/rtc.py     |   8 +-
 src/exabgp/bgp/message/update/nlri/vpls.py    |   2 +-
 src/exabgp/bgp/neighbor.py                    |  36 ++--
 src/exabgp/cli/main.py                        |  10 +-
 src/exabgp/cli/test.py                        |   1 +
 src/exabgp/conf/yang/code.py                  |   4 +-
 src/exabgp/conf/yang/generate.py              |   2 +-
 src/exabgp/conf/yang/model.py                 |   2 +-
 src/exabgp/configuration/announce/mup.py      |  10 +-
 src/exabgp/configuration/announce/mvpn.py     |   2 +-
 src/exabgp/configuration/check.py             |  10 +-
 src/exabgp/configuration/configuration.py     |  40 ++--
 src/exabgp/configuration/flow/parser.py       |  11 +-
 src/exabgp/configuration/neighbor/__init__.py |   2 +-
 src/exabgp/configuration/neighbor/api.py      |   4 +-
 src/exabgp/configuration/neighbor/parser.py   |   1 +
 src/exabgp/configuration/static/mpls.py       | 100 ++++-----
 src/exabgp/configuration/static/parser.py     |   2 +-
 src/exabgp/data/check.py                      |   2 +-
 src/exabgp/debug/report.py                    |   6 +-
 src/exabgp/environment/environment.py         |   2 +-
 src/exabgp/logger/history.py                  |   2 +-
 src/exabgp/netlink/attributes.py              |   2 +-
 src/exabgp/netlink/firewall.py                |   4 +-
 src/exabgp/netlink/netlink.py                 |   6 +-
 src/exabgp/netlink/old.py                     |  12 +-
 src/exabgp/netlink/tc.py                      |   2 +-
 src/exabgp/protocol/family.py                 |   4 +-
 src/exabgp/protocol/ip/__init__.py            |   2 +-
 src/exabgp/reactor/api/command/announce.py    |  14 +-
 src/exabgp/reactor/api/command/rib.py         |  33 ++-
 src/exabgp/reactor/api/response/json.py       |  33 +--
 src/exabgp/reactor/api/transcoder.py          |  10 +-
 src/exabgp/reactor/daemon.py                  |  16 +-
 src/exabgp/reactor/loop.py                    |   8 +-
 src/exabgp/reactor/network/connection.py      |   4 +-
 src/exabgp/reactor/network/tcp.py             |   4 +-
 src/exabgp/reactor/peer.py                    |  18 +-
 src/exabgp/reactor/protocol.py                |   2 +-
 src/exabgp/rib/change.py                      |   2 +-
 src/exabgp/rib/outgoing.py                    |   1 +
 src/exabgp/util/dns.py                        |   4 +-
 src/exabgp/util/enumeration.py                |   2 +-
 src/exabgp/vendoring/gcdump.py                |  22 +-
 src/exabgp/vendoring/lsprofcalltree.py        |  34 +--
 src/exabgp/vendoring/objgraph.py              |  44 ++--
 src/exabgp/vendoring/profiler.py              |  40 ++--
 src/exabgp/version.py                         |  11 +-
 155 files changed, 803 insertions(+), 768 deletions(-)

diff --git a/src/exabgp/application/cli.py b/src/exabgp/application/cli.py
index 9131ce34d..5590196f9 100644
--- a/src/exabgp/application/cli.py
+++ b/src/exabgp/application/cli.py
@@ -3,7 +3,6 @@
 
 """exabgp command line interface"""
 
-
 import os
 import sys
 import time
@@ -126,7 +125,7 @@ def cmdline(cmdarg):
 
     pipes = named_pipe(ROOT, pipename)
     if len(pipes) != 1:
-        sys.stdout.write('could not find ExaBGP\'s named pipes (%s.in and %s.out) for the cli\n' % (pipename, pipename))
+        sys.stdout.write("could not find ExaBGP's named pipes (%s.in and %s.out) for the cli\n" % (pipename, pipename))
         sys.stdout.write('we scanned the following folders (the number is your PID):\n - ')
         sys.stdout.write('\n - '.join(pipes))
         sys.stdout.flush()
@@ -314,7 +313,7 @@ def cmdline(cmdarg):
                 break
             if string == Answer.text_error or string == Answer.json_error:
                 done = True
-                sys.stderr.write('ExaBGP returns an error (see ExaBGP\'s logs for more information)\n')
+                sys.stderr.write("ExaBGP returns an error (see ExaBGP's logs for more information)\n")
                 sys.stderr.write('use help for a list of available commands\n')
                 sys.stderr.flush()
                 break
diff --git a/src/exabgp/application/decode.py b/src/exabgp/application/decode.py
index da323c46d..ee43cd5e8 100644
--- a/src/exabgp/application/decode.py
+++ b/src/exabgp/application/decode.py
@@ -70,7 +70,7 @@ def cmdline(cmdarg):
         sys.stdout.write('  001E:02:0000:0007:900F:0003:0001:01\n')
         sys.stdout.write('  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF001E0200000007900F0003000101\n')
         sys.stdout.write('  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:001E:02:0000:0007:900F:0003:0001:01\n')
-        sys.stdout.write("  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 001E02 00000007900F0003000101\n")
+        sys.stdout.write('  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 001E02 00000007900F0003000101\n')
         sys.stdout.flush()
         sys.exit(1)
 
diff --git a/src/exabgp/application/healthcheck.py b/src/exabgp/application/healthcheck.py
index cba894fd4..7559b2a0e 100644
--- a/src/exabgp/application/healthcheck.py
+++ b/src/exabgp/application/healthcheck.py
@@ -55,12 +55,12 @@
 from ipaddress import ip_address
 
 
-logger = logging.getLogger("healthcheck")
+logger = logging.getLogger('healthcheck')
 
 
 def enum(*sequential):
     """Create a simple enumeration."""
-    return type(str("Enum"), (), dict(zip(sequential, sequential)))
+    return type(str('Enum'), (), dict(zip(sequential, sequential)))
 
 
 def setargs(parser):
@@ -135,9 +135,9 @@ def parse():
         # build an equivalent command line.
         args = sum(
             [
-                "--{0}".format(line.strip()).split("=", 1)
+                '--{0}'.format(line.strip()).split('=', 1)
                 for line in options.config.readlines()
-                if not line.strip().startswith("#") and line.strip()
+                if not line.strip().startswith('#') and line.strip()
             ],
             [],
         )
@@ -152,65 +152,65 @@ def setup_logging(debug, silent, name, syslog_facility, syslog):
 
     def syslog_address():
         """Return a sensible syslog address"""
-        if sys.platform == "darwin":
-            return "/var/run/syslog"
-        if sys.platform.startswith("freebsd"):
-            return "/var/run/log"
-        if sys.platform.startswith("netbsd"):
-            return "/var/run/log"
-        if sys.platform.startswith("linux"):
-            return "/dev/log"
-        raise EnvironmentError("Unable to guess syslog address for your " "platform, try to disable syslog")
+        if sys.platform == 'darwin':
+            return '/var/run/syslog'
+        if sys.platform.startswith('freebsd'):
+            return '/var/run/log'
+        if sys.platform.startswith('netbsd'):
+            return '/var/run/log'
+        if sys.platform.startswith('linux'):
+            return '/dev/log'
+        raise EnvironmentError('Unable to guess syslog address for your ' 'platform, try to disable syslog')
 
     logger.setLevel(debug and logging.DEBUG or logging.INFO)
     enable_syslog = syslog and not debug
     # To syslog
     if enable_syslog:
-        facility = getattr(logging.handlers.SysLogHandler, "LOG_{0}".format(syslog_facility.upper()))
+        facility = getattr(logging.handlers.SysLogHandler, 'LOG_{0}'.format(syslog_facility.upper()))
         sh = logging.handlers.SysLogHandler(address=str(syslog_address()), facility=facility)
         if name:
-            healthcheck_name = "healthcheck-{0}".format(name)
+            healthcheck_name = 'healthcheck-{0}'.format(name)
         else:
-            healthcheck_name = "healthcheck"
-        sh.setFormatter(logging.Formatter("{0}[{1}]: %(message)s".format(healthcheck_name, os.getpid())))
+            healthcheck_name = 'healthcheck'
+        sh.setFormatter(logging.Formatter('{0}[{1}]: %(message)s'.format(healthcheck_name, os.getpid())))
         logger.addHandler(sh)
     # To console
     if not silent:
         ch = logging.StreamHandler()
-        ch.setFormatter(logging.Formatter("%(levelname)s[%(name)s] %(message)s"))
+        ch.setFormatter(logging.Formatter('%(levelname)s[%(name)s] %(message)s'))
         logger.addHandler(ch)
 
 
 def loopback_ips(label, label_only, label_exact_match):
     """Retrieve loopback IP addresses"""
-    logger.debug("Retrieve loopback IP addresses")
+    logger.debug('Retrieve loopback IP addresses')
     addresses = []
 
-    if sys.platform.startswith("linux"):
+    if sys.platform.startswith('linux'):
         # Use "ip" (ifconfig is not able to see all addresses)
-        ipre = re.compile(r"^(?P<index>\d+):\s+(?P<name>\S+)\s+inet6?\s+" r"(?P<ip>[\da-f.:]+)/(?P<mask>\d+)\s+.*")
-        labelre = re.compile(r".*\s+lo:(?P<label>[^\\\s]+).*")
-        cmd = subprocess.Popen("/sbin/ip -o address show dev lo".split(), shell=False, stdout=subprocess.PIPE)
+        ipre = re.compile(r'^(?P<index>\d+):\s+(?P<name>\S+)\s+inet6?\s+' r'(?P<ip>[\da-f.:]+)/(?P<mask>\d+)\s+.*')
+        labelre = re.compile(r'.*\s+lo:(?P<label>[^\\\s]+).*')
+        cmd = subprocess.Popen('/sbin/ip -o address show dev lo'.split(), shell=False, stdout=subprocess.PIPE)
     else:
         # Try with ifconfig
         ipre = re.compile(
-            r"^inet6?\s+(alias\s+)?(?P<ip>[\da-f.:]+)\s+"
-            r"(?:netmask 0x(?P<netmask>[0-9a-f]+)|"
-            r"prefixlen (?P<mask>\d+)).*"
+            r'^inet6?\s+(alias\s+)?(?P<ip>[\da-f.:]+)\s+'
+            r'(?:netmask 0x(?P<netmask>[0-9a-f]+)|'
+            r'prefixlen (?P<mask>\d+)).*'
         )
-        cmd = subprocess.Popen("/sbin/ifconfig lo0".split(), shell=False, stdout=subprocess.PIPE)
-        labelre = re.compile(r"")
+        cmd = subprocess.Popen('/sbin/ifconfig lo0'.split(), shell=False, stdout=subprocess.PIPE)
+        labelre = re.compile(r'')
     for line in cmd.stdout:
-        line = line.decode("ascii", "ignore").strip()
+        line = line.decode('ascii', 'ignore').strip()
         mo = ipre.match(line)
         if not mo:
             continue
-        if mo.group("mask"):
-            mask = int(mo.group("mask"))
+        if mo.group('mask'):
+            mask = int(mo.group('mask'))
         else:
-            mask = bin(int(mo.group("netmask"), 16)).count("1")
+            mask = bin(int(mo.group('netmask'), 16)).count('1')
         try:
-            ip = ip_network("{0}/{1}".format(mo.group("ip"), mask))
+            ip = ip_network('{0}/{1}'.format(mo.group('ip'), mask))
         except ValueError:
             continue
         if not ip.is_loopback:
@@ -219,21 +219,21 @@ def loopback_ips(label, label_only, label_exact_match):
                 if not lmo:
                     continue
                 if label_exact_match:
-                    if lmo.groupdict().get("label", "") == label:
+                    if lmo.groupdict().get('label', '') == label:
                         addresses.append(ip)
-                elif lmo.groupdict().get("label", "").startswith(label):
+                elif lmo.groupdict().get('label', '').startswith(label):
                     addresses.append(ip)
             elif not label_only or label is None:
                 addresses.append(ip)
 
-    logger.debug("Loopback addresses: %s", addresses)
+    logger.debug('Loopback addresses: %s', addresses)
     return addresses
 
 
 def loopback():
-    lo = "lo0"
-    if sys.platform.startswith("linux"):
-        lo = "lo"
+    lo = 'lo0'
+    if sys.platform.startswith('linux'):
+        lo = 'lo'
     return lo
 
 
@@ -243,18 +243,18 @@ def setup_ips(ips, label, label_exact_match, sudo=False):
     existing = set(loopback_ips(label, False, label_exact_match))
     toadd = set([ip_network(ip) for net in ips for ip in net]) - existing
     for ip in toadd:
-        logger.debug("Setup loopback IP address %s", ip)
-        with open(os.devnull, "w") as fnull:
-            cmd = ["ip", "address", "add", str(ip), "dev", loopback()]
+        logger.debug('Setup loopback IP address %s', ip)
+        with open(os.devnull, 'w') as fnull:
+            cmd = ['ip', 'address', 'add', str(ip), 'dev', loopback()]
             if sudo:
-                cmd.insert(0, "sudo")
+                cmd.insert(0, 'sudo')
             if label:
-                cmd += ["label", "{0}:{1}".format(loopback(), label)]
+                cmd += ['label', '{0}:{1}'.format(loopback(), label)]
             try:
                 subprocess.check_call(cmd, stdout=fnull, stderr=fnull)
             except subprocess.CalledProcessError as e:
                 # the IP address is already setup, ignoring
-                if cmd[0] == "ip" and cmd[2] == "add" and e.returncode == 2:
+                if cmd[0] == 'ip' and cmd[2] == 'add' and e.returncode == 2:
                     continue
                 raise e
 
@@ -266,19 +266,19 @@ def remove_ips(ips, label, label_exact_match, sudo=False):
     # Get intersection of IPs (ips setup, and IPs configured by ExaBGP)
     toremove = set([ip_network(ip) for net in ips for ip in net]) & existing
     for ip in toremove:
-        logger.debug("Remove loopback IP address %s", ip)
-        with open(os.devnull, "w") as fnull:
-            cmd = ["ip", "address", "delete", str(ip), "dev", loopback()]
+        logger.debug('Remove loopback IP address %s', ip)
+        with open(os.devnull, 'w') as fnull:
+            cmd = ['ip', 'address', 'delete', str(ip), 'dev', loopback()]
             if sudo:
-                cmd.insert(0, "sudo")
+                cmd.insert(0, 'sudo')
             if label:
-                cmd += ["label", "{0}:{1}".format(loopback(), label)]
+                cmd += ['label', '{0}:{1}'.format(loopback(), label)]
             try:
                 subprocess.check_call(cmd, stdout=fnull, stderr=fnull)
             except subprocess.CalledProcessError:
                 logger.warn(
-                    "Unable to remove loopback IP address %s - is \
-                    healthcheck running as root?",
+                    'Unable to remove loopback IP address %s - is \
+                    healthcheck running as root?',
                     str(ip),
                 )
 
@@ -289,7 +289,7 @@ def drop_privileges(user, group):
         import grp
 
         gid = grp.getgrnam(group).gr_gid
-        logger.debug("Dropping privileges to group {0}/{1}".format(group, gid))
+        logger.debug('Dropping privileges to group {0}/{1}'.format(group, gid))
         try:
             os.setresgid(gid, gid, gid)
         except AttributeError:
@@ -298,7 +298,7 @@ def drop_privileges(user, group):
         import pwd
 
         uid = pwd.getpwnam(user).pw_uid
-        logger.debug("Dropping privileges to user {0}/{1}".format(user, uid))
+        logger.debug('Dropping privileges to user {0}/{1}'.format(user, uid))
         try:
             os.setresuid(uid, uid, uid)
         except AttributeError:
@@ -325,7 +325,7 @@ def alarm_handler(number, frame):  # pylint: disable=W0613
         """Handle SIGALRM signal."""
         raise Alarm()
 
-    logger.debug("Checking command %s", repr(cmd))
+    logger.debug('Checking command %s', repr(cmd))
     p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setpgrp)
     if timeout:
         signal.signal(signal.SIGALRM, alarm_handler)
@@ -336,14 +336,14 @@ def alarm_handler(number, frame):  # pylint: disable=W0613
         if timeout:
             signal.alarm(0)
         if p.returncode != 0:
-            logger.warn("Check command was unsuccessful: %s", p.returncode)
+            logger.warn('Check command was unsuccessful: %s', p.returncode)
             if stdout.strip():
-                logger.info("Output of check command: %s", stdout)
+                logger.info('Output of check command: %s', stdout)
             return False
-        logger.debug("Command was executed successfully %s %s", p.returncode, stdout)
+        logger.debug('Command was executed successfully %s %s', p.returncode, stdout)
         return True
     except Alarm:
-        logger.warn("Timeout (%s) while running check command %s", timeout, cmd)
+        logger.warn('Timeout (%s) while running check command %s', timeout, cmd)
         os.killpg(p.pid, signal.SIGKILL)
         return False
 
@@ -351,14 +351,14 @@ def alarm_handler(number, frame):  # pylint: disable=W0613
 def loop(options):
     """Main loop."""
     states = enum(
-        "INIT",  # Initial state
-        "DISABLED",  # Disabled state
-        "RISING",  # Checks are currently succeeding.
-        "FALLING",  # Checks are currently failing.
-        "UP",  # Service is considered as up.
-        "DOWN",  # Service is considered as down.
-        "EXIT",  # Exit state
-        "END",  # End state, exiting but without removing loopback and/or announced routes
+        'INIT',  # Initial state
+        'DISABLED',  # Disabled state
+        'RISING',  # Checks are currently succeeding.
+        'FALLING',  # Checks are currently failing.
+        'UP',  # Service is considered as up.
+        'DOWN',  # Service is considered as down.
+        'EXIT',  # Exit state
+        'END',  # End state, exiting but without removing loopback and/or announced routes
     )
 
     def exabgp(target):
@@ -369,72 +369,72 @@ def exabgp(target):
             return
         # if ips was deleted with dyn ip, re-setup them
         if target == states.UP and options.ip_dynamic:
-            logger.info("service up, restoring loopback ips")
+            logger.info('service up, restoring loopback ips')
             setup_ips(options.ips, options.label, options.label_exact_match, options.sudo)
 
-        logger.info("send announces for %s state to ExaBGP", target)
-        metric = vars(options).get("{0}_metric".format(str(target).lower()), 0)
-        as_path = vars(options).get("{0}_as_path".format(str(target).lower()), None)
+        logger.info('send announces for %s state to ExaBGP', target)
+        metric = vars(options).get('{0}_metric'.format(str(target).lower()), 0)
+        as_path = vars(options).get('{0}_as_path'.format(str(target).lower()), None)
         if as_path is None:
             as_path = options.as_path
         for ip in options.ips:
             if options.withdraw_on_down or target is states.EXIT:
-                command = "neighbor * announce" if target is states.UP else "neighbor * withdraw"
+                command = 'neighbor * announce' if target is states.UP else 'neighbor * withdraw'
             else:
-                command = "neighbor * announce"
-            announce = "route {0} next-hop {1}".format(str(ip), options.next_hop or "self")
+                command = 'neighbor * announce'
+            announce = 'route {0} next-hop {1}'.format(str(ip), options.next_hop or 'self')
 
-            if command == "neighbor * announce":
-                announce = "{0} med {1}".format(announce, metric)
+            if command == 'neighbor * announce':
+                announce = '{0} med {1}'.format(announce, metric)
                 if options.local_preference >= 0:
-                    announce = "{0} local-preference {1}".format(announce, options.local_preference)
+                    announce = '{0} local-preference {1}'.format(announce, options.local_preference)
                 if options.community or options.disabled_community:
                     community = options.community
                     if target in (states.DOWN, states.DISABLED):
                         if options.disabled_community:
                             community = options.disabled_community
                     if community:
-                        announce = "{0} community [ {1} ]".format(announce, community)
+                        announce = '{0} community [ {1} ]'.format(announce, community)
                 if options.extended_community:
-                    announce = "{0} extended-community [ {1} ]".format(announce, options.extended_community)
+                    announce = '{0} extended-community [ {1} ]'.format(announce, options.extended_community)
                 if options.large_community:
-                    announce = "{0} large-community [ {1} ]".format(announce, options.large_community)
+                    announce = '{0} large-community [ {1} ]'.format(announce, options.large_community)
                 if as_path:
-                    announce = "{0} as-path [ {1} ]".format(announce, options.as_path)
+                    announce = '{0} as-path [ {1} ]'.format(announce, options.as_path)
 
             # append path ID if required
             if options.path_id:
-                announce = "{0} path-information {1}".format(announce, options.path_id)
+                announce = '{0} path-information {1}'.format(announce, options.path_id)
 
             # allow filtering neighbors that the route should be advertised to
             if options.neighbors:
                 # routes are filtered to specific neighbors; format them and put into a list
-                neighbors = ["neighbor {0}".format(neighbor) for neighbor in options.neighbors]
+                neighbors = ['neighbor {0}'.format(neighbor) for neighbor in options.neighbors]
                 # comma seperate the neighbor list and prepend to announcement command
-                command = "{0} {1}".format(", ".join(neighbors), command)
+                command = '{0} {1}'.format(', '.join(neighbors), command)
 
             metric += options.increase
 
             # Send and flush command
-            logger.debug("exabgp: {0} {1}".format(command, announce))
-            print("{0} {1}".format(command, announce))
+            logger.debug('exabgp: {0} {1}'.format(command, announce))
+            print('{0} {1}'.format(command, announce))
             sys.stdout.flush()
 
             # Wait for confirmation from ExaBGP if expected
             if options.no_ack:
                 continue
             # if the program is not ran manually, do not read the input
-            if hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
+            if hasattr(sys.stdout, 'isatty') and sys.stdout.isatty():
                 continue
             sys.stdin.readline()
 
         # dynamic ip management. When the service fail, remove the loopback
         if target in (states.EXIT,) and (options.ip_dynamic or options.ip_setup):
-            logger.info("exiting, deleting loopback ips")
+            logger.info('exiting, deleting loopback ips')
             remove_ips(options.ips, options.label, options.label_exact_match, options.sudo)
         # dynamic ip management. When the service fail, remove the loopback
         if target in (states.DOWN, states.DISABLED) and options.ip_dynamic:
-            logger.info("service down, deleting loopback ips")
+            logger.info('service down, deleting loopback ips')
             remove_ips(options.ips, options.label, options.label_exact_match, options.sudo)
 
     def trigger(target):
@@ -446,15 +446,15 @@ def trigger(target):
             target = states.DOWN
 
         # Log and execute commands
-        logger.debug("Transition to %s", str(target))
+        logger.debug('Transition to %s', str(target))
         cmds = []
-        cmds.extend(vars(options).get("{0}_execute".format(str(target).lower()), []) or [])
-        cmds.extend(vars(options).get("execute", []) or [])
+        cmds.extend(vars(options).get('{0}_execute'.format(str(target).lower()), []) or [])
+        cmds.extend(vars(options).get('execute', []) or [])
         for cmd in cmds:
-            logger.debug("Transition to %s, execute `%s`", str(target), cmd)
+            logger.debug('Transition to %s, execute `%s`', str(target), cmd)
             env = os.environ.copy()
-            env.update({"STATE": str(target)})
-            with open(os.devnull, "w") as fnull:
+            env.update({'STATE': str(target)})
+            with open(os.devnull, 'w') as fnull:
                 subprocess.call(cmd, shell=True, stdout=fnull, stderr=fnull, env=env)
 
         return target
@@ -504,7 +504,7 @@ def one(checks, state):
                 state = trigger(states.RISING)
                 checks = 1
         else:
-            raise ValueError("Unhandled state: {0}".format(str(state)))
+            raise ValueError('Unhandled state: {0}'.format(str(state)))
 
         # Send announces. We announce them on a regular basis (unless --debounce flag is set),
         # in case we lose connection with a peer and the adj-rib-out is disabled.
@@ -531,7 +531,7 @@ def sigterm_handler(signum, frame):  # pylint: disable=W0612,W0613
             if state in (states.FALLING, states.RISING):
                 time.sleep(options.fast)
             elif options.interval == 0:
-                logger.info("interval set to zero, exiting after the announcement")
+                logger.info('interval set to zero, exiting after the announcement')
                 exabgp(states.END)
                 break
             else:
@@ -551,13 +551,13 @@ def main():
     options = parse()
     setup_logging(options.debug, options.silent, options.name, options.syslog_facility, not options.no_syslog)
     if options.pid:
-        options.pid.write("{0}\n".format(os.getpid()))
+        options.pid.write('{0}\n'.format(os.getpid()))
         options.pid.close()
     try:
         # Setup IP to use
         options.ips = options.ips or loopback_ips(options.label, False, options.label_exact_match)
         if not options.ips:
-            logger.error("No IP found")
+            logger.error('No IP found')
             sys.exit(1)
         if options.ip_setup:
             setup_ips(options.ips, options.label, options.label_exact_match, options.sudo)
@@ -573,9 +573,9 @@ def main():
         # Main loop
         loop(options)
     except Exception as e:  # pylint: disable=W0703
-        logger.exception("Uncaught exception: %s", e)
+        logger.exception('Uncaught exception: %s', e)
         sys.exit(1)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/src/exabgp/application/netlink.py b/src/exabgp/application/netlink.py
index 2ee46019a..e0138f6c7 100755
--- a/src/exabgp/application/netlink.py
+++ b/src/exabgp/application/netlink.py
@@ -37,7 +37,7 @@ def addresses():
         hwaddr = '<no addr>'
         if Address.Type.Attribute.IFLA_ADDRESS in ifi.attributes:
             hwaddr = ':'.join(x.encode('hex') for x in ifi.attributes[Address.Type.Attribute.IFLA_ADDRESS])
-        print("%d: %s %s" % (ifi.index, ifi.attributes[Address.Type.Attribute.IFLA_IFNAME][:-1], hwaddr))
+        print('%d: %s %s' % (ifi.index, ifi.attributes[Address.Type.Attribute.IFLA_IFNAME][:-1], hwaddr))
 
         for ifa in addrs.get(ifi.index, {}):
             address = ifa.attributes.get(Attributes.Type.IFA_ADDRESS)
diff --git a/src/exabgp/application/pipe.py b/src/exabgp/application/pipe.py
index 22c35c21d..7fcbeb1b9 100644
--- a/src/exabgp/application/pipe.py
+++ b/src/exabgp/application/pipe.py
@@ -292,7 +292,7 @@ def main(location=''):
     if not location:
         location = os.environ.get('exabgp_cli_pipe', '')
     if not location:
-        sys.stderr.write("usage %s %s\n" % (sys.executable, ' '.join(sys.argv)))
+        sys.stderr.write('usage %s %s\n' % (sys.executable, ' '.join(sys.argv)))
         sys.stderr.write("run with 'env exabgp_cli_pipe=<location>' if you are trying to mess with ExaBGP's internals")
         sys.stderr.flush()
         sys.exit(1)
diff --git a/src/exabgp/application/server.py b/src/exabgp/application/server.py
index 1f8bf665b..6e275460c 100755
--- a/src/exabgp/application/server.py
+++ b/src/exabgp/application/server.py
@@ -2,7 +2,6 @@
 
 """exabgp server"""
 
-
 import os
 import sys
 import time
@@ -212,7 +211,7 @@ def run(comment, configurations, pid=0):
         __exit(env.debug.memory, exit_code)
 
     if pid:
-        profile_name = "%s-pid-%d" % (env.profile.file, pid)
+        profile_name = '%s-pid-%d' % (env.profile.file, pid)
     else:
         profile_name = env.profile.file
 
@@ -243,14 +242,14 @@ def run(comment, configurations, pid=0):
                     kprofile.output(write)
             except IOError:
                 notice = 'could not save profiling in formation at: ' + destination
-                log.debug("-" * len(notice), 'reactor')
+                log.debug('-' * len(notice), 'reactor')
                 log.debug(notice, 'reactor')
-                log.debug("-" * len(notice), 'reactor')
+                log.debug('-' * len(notice), 'reactor')
             __exit(env.debug.memory, exit_code)
     else:
-        log.debug("-" * len(notice), 'reactor')
+        log.debug('-' * len(notice), 'reactor')
         log.debug(notice, 'reactor')
-        log.debug("-" * len(notice), 'reactor')
+        log.debug('-' * len(notice), 'reactor')
         Reactor(configuration).run()
         __exit(env.debug.memory, 1)
 
diff --git a/src/exabgp/application/validate.py b/src/exabgp/application/validate.py
index 99249796b..43f74ef3b 100644
--- a/src/exabgp/application/validate.py
+++ b/src/exabgp/application/validate.py
@@ -2,7 +2,6 @@
 
 """exabgp configuration validation"""
 
-
 import sys
 import argparse
 
diff --git a/src/exabgp/application/version.py b/src/exabgp/application/version.py
index 3ed946804..89923f63f 100644
--- a/src/exabgp/application/version.py
+++ b/src/exabgp/application/version.py
@@ -8,6 +8,7 @@
 
 from exabgp.version import version, get_root
 
+
 def setargs(sub):
     # fmt:off
     pass
diff --git a/src/exabgp/bgp/message/keepalive.py b/src/exabgp/bgp/message/keepalive.py
index 9dc935617..f016e92bb 100644
--- a/src/exabgp/bgp/message/keepalive.py
+++ b/src/exabgp/bgp/message/keepalive.py
@@ -25,7 +25,7 @@ def message(self, negotiated=None):
         return self._message(b'')
 
     def __str__(self):
-        return "KEEPALIVE"
+        return 'KEEPALIVE'
 
     @classmethod
     def unpack_message(cls, data, direction, negotiated):  # pylint: disable=W0613
diff --git a/src/exabgp/bgp/message/nop.py b/src/exabgp/bgp/message/nop.py
index 12dfa80d2..581c307ff 100644
--- a/src/exabgp/bgp/message/nop.py
+++ b/src/exabgp/bgp/message/nop.py
@@ -21,7 +21,7 @@ def message(self, negotiated=None):
         raise RuntimeError('NOP messages can not be sent on the wire')
 
     def __str__(self):
-        return "NOP"
+        return 'NOP'
 
     @classmethod
     def unpack_message(cls, data, direction, negotiated):  # pylint: disable=W0613
diff --git a/src/exabgp/bgp/message/notification.py b/src/exabgp/bgp/message/notification.py
index eafcef979..c2ad9e5af 100644
--- a/src/exabgp/bgp/message/notification.py
+++ b/src/exabgp/bgp/message/notification.py
@@ -32,63 +32,63 @@ class Notification(Message):
     TYPE = bytes([Message.CODE.NOTIFICATION])
 
     _str_code = {
-        1: "Message header error",
-        2: "OPEN message error",
-        3: "UPDATE message error",
-        4: "Hold timer expired",
-        5: "State machine error",
-        6: "Cease",
+        1: 'Message header error',
+        2: 'OPEN message error',
+        3: 'UPDATE message error',
+        4: 'Hold timer expired',
+        5: 'State machine error',
+        6: 'Cease',
     }
 
     _str_subcode = {
-        (1, 0): "Unspecific",
-        (1, 1): "Connection Not Synchronized",
-        (1, 2): "Bad Message Length",
-        (1, 3): "Bad Message Type",
-        (2, 0): "Unspecific",
-        (2, 1): "Unsupported Version Number",
-        (2, 2): "Bad Peer AS",
-        (2, 3): "Bad BGP Identifier",
-        (2, 4): "Unsupported Optional Parameter",
-        (2, 5): "Authentication Notification (Deprecated)",
-        (2, 6): "Unacceptable Hold Time",
+        (1, 0): 'Unspecific',
+        (1, 1): 'Connection Not Synchronized',
+        (1, 2): 'Bad Message Length',
+        (1, 3): 'Bad Message Type',
+        (2, 0): 'Unspecific',
+        (2, 1): 'Unsupported Version Number',
+        (2, 2): 'Bad Peer AS',
+        (2, 3): 'Bad BGP Identifier',
+        (2, 4): 'Unsupported Optional Parameter',
+        (2, 5): 'Authentication Notification (Deprecated)',
+        (2, 6): 'Unacceptable Hold Time',
         # RFC 5492 - https://tools.ietf.org/html/rfc5492
-        (2, 7): "Unsupported Capability",
+        (2, 7): 'Unsupported Capability',
         # draft-ietf-idr-bgp-multisession-06
-        (2, 8): "Grouping Conflict",
-        (2, 9): "Grouping Required",
-        (2, 10): "Capability Value Mismatch",
-        (3, 0): "Unspecific",
-        (3, 1): "Malformed Attribute List",
-        (3, 2): "Unrecognized Well-known Attribute",
-        (3, 3): "Missing Well-known Attribute",
-        (3, 4): "Attribute Flags Error",
-        (3, 5): "Attribute Length Error",
-        (3, 6): "Invalid ORIGIN Attribute",
-        (3, 7): "AS Routing Loop",
-        (3, 8): "Invalid NEXT_HOP Attribute",
-        (3, 9): "Optional Attribute Error",
-        (3, 10): "Invalid Network Field",
-        (3, 11): "Malformed AS_PATH",
-        (4, 0): "Unspecific",
-        (5, 0): "Unspecific",
+        (2, 8): 'Grouping Conflict',
+        (2, 9): 'Grouping Required',
+        (2, 10): 'Capability Value Mismatch',
+        (3, 0): 'Unspecific',
+        (3, 1): 'Malformed Attribute List',
+        (3, 2): 'Unrecognized Well-known Attribute',
+        (3, 3): 'Missing Well-known Attribute',
+        (3, 4): 'Attribute Flags Error',
+        (3, 5): 'Attribute Length Error',
+        (3, 6): 'Invalid ORIGIN Attribute',
+        (3, 7): 'AS Routing Loop',
+        (3, 8): 'Invalid NEXT_HOP Attribute',
+        (3, 9): 'Optional Attribute Error',
+        (3, 10): 'Invalid Network Field',
+        (3, 11): 'Malformed AS_PATH',
+        (4, 0): 'Unspecific',
+        (5, 0): 'Unspecific',
         # RFC 6608 - https://tools.ietf.org/html/rfc6608
-        (5, 1): "Receive Unexpected Message in OpenSent State",
-        (5, 2): "Receive Unexpected Message in OpenConfirm State",
-        (5, 3): "Receive Unexpected Message in Established State",
-        (6, 0): "Unspecific",
+        (5, 1): 'Receive Unexpected Message in OpenSent State',
+        (5, 2): 'Receive Unexpected Message in OpenConfirm State',
+        (5, 3): 'Receive Unexpected Message in Established State',
+        (6, 0): 'Unspecific',
         # RFC 4486 - https://tools.ietf.org/html/rfc4486
-        (6, 1): "Maximum Number of Prefixes Reached",
-        (6, 2): "Administrative Shutdown",  # augmented with draft-ietf-idr-shutdown
-        (6, 3): "Peer De-configured",
-        (6, 4): "Administrative Reset",
-        (6, 5): "Connection Rejected",
-        (6, 6): "Other Configuration Change",
-        (6, 7): "Connection Collision Resolution",
-        (6, 8): "Out of Resources",
+        (6, 1): 'Maximum Number of Prefixes Reached',
+        (6, 2): 'Administrative Shutdown',  # augmented with draft-ietf-idr-shutdown
+        (6, 3): 'Peer De-configured',
+        (6, 4): 'Administrative Reset',
+        (6, 5): 'Connection Rejected',
+        (6, 6): 'Other Configuration Change',
+        (6, 7): 'Connection Collision Resolution',
+        (6, 8): 'Out of Resources',
         # draft-keyur-bgp-enhanced-route-refresh-00
-        (7, 1): "Invalid Message Length",
-        (7, 2): "Malformed Message Subtype",
+        (7, 1): 'Invalid Message Length',
+        (7, 2): 'Malformed Message Subtype',
     }
 
     def __init__(self, code, subcode, data=b'', parse_data=True):
@@ -114,19 +114,19 @@ def __init__(self, code, subcode, data=b'', parse_data=True):
         data = data[1:]
 
         if shutdown_length == 0:
-            self.data = b"empty Shutdown Communication."
+            self.data = b'empty Shutdown Communication.'
             # move offset past length field
             return
 
         if len(data) < shutdown_length:
-            self.data = b"invalid Shutdown Communication (buffer underrun) length : %i [%s]" % (
+            self.data = b'invalid Shutdown Communication (buffer underrun) length : %i [%s]' % (
                 shutdown_length,
                 hexstring(data),
             )
             return
 
         if shutdown_length > 128:
-            self.data = b"invalid Shutdown Communication (too large) length : %i [%s]" % (
+            self.data = b'invalid Shutdown Communication (too large) length : %i [%s]' % (
                 shutdown_length,
                 hexstring(data),
             )
@@ -137,7 +137,7 @@ def __init__(self, code, subcode, data=b'', parse_data=True):
                 '\r', ' '
             ).replace('\n', ' ')
         except UnicodeDecodeError:
-            self.data = b"invalid Shutdown Communication (invalid UTF-8) length : %i [%s]" % (
+            self.data = b'invalid Shutdown Communication (invalid UTF-8) length : %i [%s]' % (
                 shutdown_length,
                 hexstring(data),
             )
@@ -145,10 +145,10 @@ def __init__(self, code, subcode, data=b'', parse_data=True):
 
         trailer = data[shutdown_length:]
         if trailer:
-            self.data += b", trailing data: " + hexstring(trailer)
+            self.data += b', trailing data: ' + hexstring(trailer)
 
     def __str__(self):
-        return "%s / %s%s" % (
+        return '%s / %s%s' % (
             self._str_code.get(self.code, 'unknown error'),
             self._str_subcode.get((self.code, self.subcode), 'unknow reason'),
             ' / %s' % self.data.decode('ascii') if self.data else '',
diff --git a/src/exabgp/bgp/message/open/__init__.py b/src/exabgp/bgp/message/open/__init__.py
index b08a8e288..94b142fa3 100644
--- a/src/exabgp/bgp/message/open/__init__.py
+++ b/src/exabgp/bgp/message/open/__init__.py
@@ -72,7 +72,7 @@ def message(self, negotiated=None):
         )
 
     def __str__(self):
-        return "OPEN version=%d asn=%d hold_time=%s router_id=%s capabilities=[%s]" % (
+        return 'OPEN version=%d asn=%d hold_time=%s router_id=%s capabilities=[%s]' % (
             self.version,
             self.asn.trans(),
             self.hold_time,
@@ -90,5 +90,5 @@ def unpack_message(cls, data, direction=None, negotiated=None):
         asn = unpack('!H', data[1:3])[0]
         hold_time = unpack('!H', data[3:5])[0]
         numeric = unpack('!L', data[5:9])[0]
-        router_id = "%d.%d.%d.%d" % (numeric >> 24, (numeric >> 16) & 0xFF, (numeric >> 8) & 0xFF, numeric & 0xFF)
+        router_id = '%d.%d.%d.%d' % (numeric >> 24, (numeric >> 16) & 0xFF, (numeric >> 8) & 0xFF, numeric & 0xFF)
         return cls(Version(version), ASN(asn), HoldTime(hold_time), RouterID(router_id), Capabilities.unpack(data[9:]))
diff --git a/src/exabgp/bgp/message/open/capability/addpath.py b/src/exabgp/bgp/message/open/capability/addpath.py
index d61bdeb94..b91731b49 100644
--- a/src/exabgp/bgp/message/open/capability/addpath.py
+++ b/src/exabgp/bgp/message/open/capability/addpath.py
@@ -39,7 +39,7 @@ def __str__(self):
             'AddPath('
             + ','.join(
                 [
-                    "%s %s %s" % (self.string[self[aafi]], xafi, xsafi)
+                    '%s %s %s' % (self.string[self[aafi]], xafi, xsafi)
                     for (aafi, xafi, xsafi) in [((afi, safi), str(afi), str(safi)) for (afi, safi) in self]
                 ]
             )
diff --git a/src/exabgp/bgp/message/open/capability/capabilities.py b/src/exabgp/bgp/message/open/capability/capabilities.py
index a42430114..1e9f1ca53 100644
--- a/src/exabgp/bgp/message/open/capability/capabilities.py
+++ b/src/exabgp/bgp/message/open/capability/capabilities.py
@@ -38,9 +38,9 @@ class Parameter(int):
 
     def __str__(self):
         if self == 0x01:
-            return "AUTHENTIFICATION INFORMATION"
+            return 'AUTHENTIFICATION INFORMATION'
         if self == 0x02:
-            return "OPTIONAL"
+            return 'OPTIONAL'
         return 'UNKNOWN'
 
 
@@ -204,13 +204,13 @@ def pack(self):
     def unpack(data):
         def _extended_type_length(name, data):
             if len(data) < 3:
-                raise Notify(2, 0, "Bad length for OPEN (extended) %s (<3) %s" % (name, Capability.hex(data)))
+                raise Notify(2, 0, 'Bad length for OPEN (extended) %s (<3) %s' % (name, Capability.hex(data)))
             # Optional parameters length
             ld = unpack('!H', data[1:3])[0]
             boundary = ld + 3
             if len(data) < boundary:
                 raise Notify(
-                    2, 0, "Bad length for OPEN (extended) %s (buffer underrun) %s" % (name, Capability.hex(data))
+                    2, 0, 'Bad length for OPEN (extended) %s (buffer underrun) %s' % (name, Capability.hex(data))
                 )
             key = data[0]
             value = data[3:boundary]
@@ -219,11 +219,11 @@ def _extended_type_length(name, data):
 
         def _key_values(name, data):
             if len(data) < 2:
-                raise Notify(2, 0, "Bad length for OPEN %s (<2) %s" % (name, Capability.hex(data)))
+                raise Notify(2, 0, 'Bad length for OPEN %s (<2) %s' % (name, Capability.hex(data)))
             ld = data[1]
             boundary = ld + 2
             if len(data) < boundary:
-                raise Notify(2, 0, "Bad length for OPEN %s (buffer underrun) %s" % (name, Capability.hex(data)))
+                raise Notify(2, 0, 'Bad length for OPEN %s (buffer underrun) %s' % (name, Capability.hex(data)))
             key = data[0]
             value = data[2:boundary]
             rest = data[boundary:]
diff --git a/src/exabgp/bgp/message/open/capability/graceful.py b/src/exabgp/bgp/message/open/capability/graceful.py
index 17c2090c0..ce787fb3d 100644
--- a/src/exabgp/bgp/message/open/capability/graceful.py
+++ b/src/exabgp/bgp/message/open/capability/graceful.py
@@ -44,8 +44,8 @@ def extract(self):
 
     def __str__(self):
         families = [(str(afi), str(safi), hex(self[(afi, safi)])) for (afi, safi) in self.keys()]
-        sfamilies = ' '.join(["%s/%s=%s" % (afi, safi, family) for (afi, safi, family) in families])
-        return "Graceful Restart Flags %s Time %d %s" % (hex(self.restart_flag), self.restart_time, sfamilies)
+        sfamilies = ' '.join(['%s/%s=%s' % (afi, safi, family) for (afi, safi, family) in families])
+        return 'Graceful Restart Flags %s Time %d %s' % (hex(self.restart_flag), self.restart_time, sfamilies)
 
     def json(self):
         d = {
diff --git a/src/exabgp/bgp/message/open/capability/hostname.py b/src/exabgp/bgp/message/open/capability/hostname.py
index afa6b2d84..1442f5943 100644
--- a/src/exabgp/bgp/message/open/capability/hostname.py
+++ b/src/exabgp/bgp/message/open/capability/hostname.py
@@ -9,7 +9,6 @@
 
 # https://datatracker.ietf.org/doc/html/draft-walton-bgp-hostname-capability-02
 
-
 from exabgp.bgp.message.open.capability.capability import Capability
 from exabgp.util.dns import host, domain
 
diff --git a/src/exabgp/bgp/message/open/capability/mp.py b/src/exabgp/bgp/message/open/capability/mp.py
index 6ff9cc22b..a47a16c77 100644
--- a/src/exabgp/bgp/message/open/capability/mp.py
+++ b/src/exabgp/bgp/message/open/capability/mp.py
@@ -21,7 +21,7 @@ class MultiProtocol(Capability, list):
     ID = Capability.CODE.MULTIPROTOCOL
 
     def __str__(self):
-        return 'Multiprotocol(' + ','.join(["%s %s" % (str(afi), str(safi)) for (afi, safi) in self]) + ')'
+        return 'Multiprotocol(' + ','.join(['%s %s' % (str(afi), str(safi)) for (afi, safi) in self]) + ')'
 
     def json(self):
         return '{ "name": "multiprotocol", "families": [%s ] }' % ','.join(
diff --git a/src/exabgp/bgp/message/open/capability/nexthop.py b/src/exabgp/bgp/message/open/capability/nexthop.py
index a91a0fe17..7bd763553 100644
--- a/src/exabgp/bgp/message/open/capability/nexthop.py
+++ b/src/exabgp/bgp/message/open/capability/nexthop.py
@@ -31,7 +31,7 @@ def add_nexthop(self, afi, safi, nhafi):
 
     def __str__(self):
         return (
-            'NextHop(' + ','.join(["%s %s %s" % (str(afi), str(safi), str(nhafi)) for (afi, safi, nhafi) in self]) + ')'
+            'NextHop(' + ','.join(['%s %s %s' % (str(afi), str(safi), str(nhafi)) for (afi, safi, nhafi) in self]) + ')'
         )
 
     def json(self):
@@ -42,7 +42,7 @@ def json(self):
     def extract(self):
         rs = b''
         for afi, safi, nhafi in self:
-            rs += afi.pack() + pack("!B", 0) + safi.pack() + nhafi.pack()
+            rs += afi.pack() + pack('!B', 0) + safi.pack() + nhafi.pack()
         return [
             rs,
         ]
diff --git a/src/exabgp/bgp/message/open/capability/refresh.py b/src/exabgp/bgp/message/open/capability/refresh.py
index 51d5cbf87..604dfe986 100644
--- a/src/exabgp/bgp/message/open/capability/refresh.py
+++ b/src/exabgp/bgp/message/open/capability/refresh.py
@@ -28,7 +28,7 @@ def json(refresh):
             return 'enhanced'
         return 'unknown'
 
-    def __str__ (self):
+    def __str__(self):
         if self == REFRESH.ABSENT:
             return 'absent'
         if self == REFRESH.NORMAL:
diff --git a/src/exabgp/bgp/message/open/capability/software.py b/src/exabgp/bgp/message/open/capability/software.py
index 0f46b76fe..3adb20f6b 100644
--- a/src/exabgp/bgp/message/open/capability/software.py
+++ b/src/exabgp/bgp/message/open/capability/software.py
@@ -8,7 +8,6 @@
 
 # https://datatracker.ietf.org/doc/html/draft-abraitis-bgp-version-capability
 
-
 from exabgp.bgp.message.open.capability.capability import Capability
 from exabgp.version import version
 
@@ -19,7 +18,7 @@ class Software(Capability):
     SOFTWARE_VERSION_MAX_LEN = 64
 
     def __init__(self):
-        software_version = f"ExaBGP/{version}"
+        software_version = f'ExaBGP/{version}'
         if len(software_version) > self.SOFTWARE_VERSION_MAX_LEN:
             software_version = software_version[: self.SOFTWARE_VERSION_MAX_LEN - 3] + '...'
         self.software_version = software_version
diff --git a/src/exabgp/bgp/message/refresh.py b/src/exabgp/bgp/message/refresh.py
index 28e66ae26..7e3b8d456 100644
--- a/src/exabgp/bgp/message/refresh.py
+++ b/src/exabgp/bgp/message/refresh.py
@@ -52,7 +52,7 @@ def messages(self, negotiated, include_withdraw):
         yield self.message(negotiated)
 
     def __str__(self):
-        return "REFRESH"
+        return 'REFRESH'
 
     def extensive(self):
         return 'route refresh %s/%d/%s' % (self.afi, self.reserved, self.safi)
diff --git a/src/exabgp/bgp/message/unknown.py b/src/exabgp/bgp/message/unknown.py
index 6d82bf760..a86717121 100644
--- a/src/exabgp/bgp/message/unknown.py
+++ b/src/exabgp/bgp/message/unknown.py
@@ -25,7 +25,7 @@ def message(self, negotiated=None):
         return self._message(self.data)
 
     def __str__(self):
-        return "UNKNOWN"
+        return 'UNKNOWN'
 
     @classmethod
     def unpack_message(cls, data):  # pylint: disable=W0613
diff --git a/src/exabgp/bgp/message/update/__init__.py b/src/exabgp/bgp/message/update/__init__.py
index 50078f41a..2ab78e244 100644
--- a/src/exabgp/bgp/message/update/__init__.py
+++ b/src/exabgp/bgp/message/update/__init__.py
@@ -137,7 +137,7 @@ def messages(self, negotiated, include_withdraw=True):
                 mp_nlris.setdefault(nlri.family().afi_safi(), {}).setdefault(nlri.action, []).append(nlri)
                 continue
 
-            raise ValueError("unexpected nlri definition (%s)" % nlri)
+            raise ValueError('unexpected nlri definition (%s)' % nlri)
 
         if not nlris and not mp_nlris:
             return
diff --git a/src/exabgp/bgp/message/update/attribute/aspath.py b/src/exabgp/bgp/message/update/attribute/aspath.py
index d7c229073..304ca77cb 100644
--- a/src/exabgp/bgp/message/update/attribute/aspath.py
+++ b/src/exabgp/bgp/message/update/attribute/aspath.py
@@ -24,30 +24,30 @@
 
 class SET(list):
     ID = 0x01
-    NAME = "as-set"
-    HEAD = "["
-    TAIL = "]"
+    NAME = 'as-set'
+    HEAD = '['
+    TAIL = ']'
 
 
 class SEQUENCE(list):
     ID = 0x02
-    NAME = "as-sequence"
-    HEAD = "("
-    TAIL = ")"
+    NAME = 'as-sequence'
+    HEAD = '('
+    TAIL = ')'
 
 
 class CONFED_SEQUENCE(list):
     ID = 0x03
-    NAME = "as-sequence"
-    HEAD = "{("
-    TAIL = ")}"
+    NAME = 'as-sequence'
+    HEAD = '{('
+    TAIL = ')}'
 
 
 class CONFED_SET(list):
     ID = 0x04
-    NAME = "as-sequence"
-    HEAD = "{["
-    TAIL = "]}"
+    NAME = 'as-sequence'
+    HEAD = '{['
+    TAIL = ']}'
 
     # def __getslice__(self, i, j):
     #     return CONFED_SET(list.__getslice__(self, i, j))
@@ -93,7 +93,7 @@ def __ne__(self, other):
     def _segment(cls, seg_type, values, asn4):
         length = len(values)
         if length == 0:
-            return b""
+            return b''
         if length > 255:
             return cls._segment(seg_type, values[:255], asn4) + cls._segment(seg_type, values[255:], asn4)
         return bytes([seg_type, length]) + b''.join(v.pack(asn4) for v in values)
@@ -144,9 +144,9 @@ def __repr__(self):
     def string(self):
         parts = []
         for content in self.aspath:
-            part = "%s %s %s" % (content.HEAD, " ".join((str(_) for _ in content)), content.TAIL)
+            part = '%s %s %s' % (content.HEAD, ' '.join((str(_) for _ in content)), content.TAIL)
             parts.append(part)
-        return " ".join(parts)
+        return ' '.join(parts)
 
     def json(self):
         jason = {}
diff --git a/src/exabgp/bgp/message/update/attribute/attribute.py b/src/exabgp/bgp/message/update/attribute/attribute.py
index 3b0a19831..8cfa2aa43 100644
--- a/src/exabgp/bgp/message/update/attribute/attribute.py
+++ b/src/exabgp/bgp/message/update/attribute/attribute.py
@@ -178,20 +178,20 @@ def __str__(self):
             r = []
             v = int(self)
             if v & 0x10:
-                r.append("EXTENDED_LENGTH")
+                r.append('EXTENDED_LENGTH')
                 v -= 0x10
             if v & 0x20:
-                r.append("PARTIAL")
+                r.append('PARTIAL')
                 v -= 0x20
             if v & 0x40:
-                r.append("TRANSITIVE")
+                r.append('TRANSITIVE')
                 v -= 0x40
             if v & 0x80:
-                r.append("OPTIONAL")
+                r.append('OPTIONAL')
                 v -= 0x80
             if v:
-                r.append("UNKNOWN %s" % hex(v))
-            return " ".join(r)
+                r.append('UNKNOWN %s' % hex(v))
+            return ' '.join(r)
 
         def matches(self, value):
             return self | 0x10 == value | 0x10
diff --git a/src/exabgp/bgp/message/update/attribute/attributes.py b/src/exabgp/bgp/message/update/attribute/attributes.py
index 6323bf7f5..8e9880305 100644
--- a/src/exabgp/bgp/message/update/attribute/attributes.py
+++ b/src/exabgp/bgp/message/update/attribute/attributes.py
@@ -436,7 +436,7 @@ def merge_attributes(self):
 
         # this key is unique as index length is a two header, plus a number of ASN of size 2 or 4
         # so adding the: make the length odd and unique
-        key = "%s:%s" % (as2path.index, as4path.index)
+        key = '%s:%s' % (as2path.index, as4path.index)
 
         # found a cache copy
         cached = Attribute.cache.get(Attribute.CODE.AS_PATH, {}).get(key, None)
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/igpmetric.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/igpmetric.py
index 8bc78fa12..c40aa5c4d 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/igpmetric.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/igpmetric.py
@@ -49,4 +49,4 @@ def unpack(cls, data):
             # ISIS wide metrics
             return cls(unpack('!L', bytes([0]) + data)[0])
 
-        raise Notify(3, 5, "Incorrect IGP Metric Size")
+        raise Notify(3, 5, 'Incorrect IGP Metric Size')
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/linkname.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/linkname.py
index 7c1ecea18..9af536cd6 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/linkname.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/linkname.py
@@ -31,5 +31,5 @@ class LinkName(BaseLS):
     @classmethod
     def unpack(cls, data):
         if len(data) > 255:
-            raise Notify(3, 5, "Link Name TLV length too large")
+            raise Notify(3, 5, 'Link Name TLV length too large')
         return cls(data)
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/opaque.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/opaque.py
index 865c391d4..d22731751 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/opaque.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/opaque.py
@@ -32,4 +32,4 @@ class LinkOpaque(object):
     @classmethod
     def unpack(cls, data):
         length = len(data)
-        return cls(unpack("!%ds" % length, data)[0])
+        return cls(unpack('!%ds' % length, data)[0])
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/rterid.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/rterid.py
index b887a2365..c071e7cfb 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/rterid.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/rterid.py
@@ -29,5 +29,5 @@ class RemoteTeRid(BaseLS):
     def unpack(cls, data):
         length = len(data)
         if length not in (4, 16):
-            raise Notify(3, 5, "Invalid remote-te size")
+            raise Notify(3, 5, 'Invalid remote-te size')
         return cls(IP.unpack(data))
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/sradj.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/sradj.py
index 0d25800c2..e3b9c3529 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/sradj.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/sradj.py
@@ -38,7 +38,7 @@ def __init__(self, flags, sids, weight, undecoded=[]):
         self.undecoded = undecoded
 
     def __repr__(self):
-        return "adj_flags: %s, sids: %s, undecoded_sid %s" % (self.flags, self.sids, self.undecoded)
+        return 'adj_flags: %s, sids: %s, undecoded_sid %s' % (self.flags, self.sids, self.undecoded)
 
     @classmethod
     def unpack(cls, data):
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/sradjlan.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/sradjlan.py
index bbadf4844..0ef9ce7c2 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/sradjlan.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/sradjlan.py
@@ -47,7 +47,7 @@ def __init__(self, sradjlans):
         self.sr_adj_lan_sids = []
 
     def __repr__(self):
-        return "sr-adj-lan-sids: {}".format(self.sr_adj_lan_sids)
+        return 'sr-adj-lan-sids: {}'.format(self.sr_adj_lan_sids)
 
     @classmethod
     def unpack(cls, data):
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/srlg.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/srlg.py
index 4b29df346..b9cb71a09 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/srlg.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/srlg.py
@@ -38,5 +38,5 @@ class Srlg(BaseLS):
     @classmethod
     def unpack(cls, data):
         if len(data) % 4:
-            raise Notify(3, 5, "Unable to decode SRLG")
+            raise Notify(3, 5, 'Unable to decode SRLG')
         return cls([unpack('!L', _)[0] for _ in split(data, 4)])
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/link/temetric.py b/src/exabgp/bgp/message/update/attribute/bgpls/link/temetric.py
index d595e962b..fe3f7360b 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/link/temetric.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/link/temetric.py
@@ -5,6 +5,7 @@
 Created by Evelio Vila on 2016-12-01.
 Copyright (c) 2014-2017 Exa Networks. All rights reserved.
 """
+
 from struct import unpack
 
 from exabgp.bgp.message.update.attribute.bgpls.linkstate import LinkState
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/linkstate.py b/src/exabgp/bgp/message/update/attribute/bgpls/linkstate.py
index c96807eb1..650199400 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/linkstate.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/linkstate.py
@@ -115,7 +115,7 @@ def json(self, compact=None):
             return '"{}": "{}"'.format(self.JSON, self.content.decode('utf-8'))
 
     def __repr__(self):
-        return "%s: %s" % (self.REPR, self.content)
+        return '%s: %s' % (self.REPR, self.content)
 
     @classmethod
     def check_length(cls, data, length):
@@ -145,7 +145,7 @@ def __init__(self, content):
         )
 
     def __repr__(self):
-        return "Attribute with code [ %s ] not implemented" % (self.TLV)
+        return 'Attribute with code [ %s ] not implemented' % (self.TLV)
 
     def json(self):
         merged = ', '.join(['"{}"'.format(hexstring(_)) for _ in self.content])
@@ -161,7 +161,7 @@ def __init__(self, flags):
         self.flags = flags
 
     def __repr__(self):
-        return "%s: %s" % (self.REPR, self.flags)
+        return '%s: %s' % (self.REPR, self.flags)
 
     def json(self, compact=None):
         return '"{}": {}'.format(self.JSON, json.dumps(self.flags))
@@ -186,7 +186,7 @@ def unpack_flags(cls, data):
             )
             flags.update(dict((k, int(v)) for k, v in zip(cls.FLAGS, bits)))
         else:
-            raise Notify(3, 5, "Invalid SR flags mask")
+            raise Notify(3, 5, 'Invalid SR flags mask')
         return flags
 
     @classmethod
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/node/isisarea.py b/src/exabgp/bgp/message/update/attribute/bgpls/node/isisarea.py
index 16c0b6ccd..c409bf67a 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/node/isisarea.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/node/isisarea.py
@@ -22,8 +22,8 @@
 @LinkState.register()
 class IsisArea(BaseLS):
     TLV = 1027
-    REPR = "ISIS area id"
-    JSON = "area-id"
+    REPR = 'ISIS area id'
+    JSON = 'area-id'
 
     def __init__(self, areaid):
         BaseLS.__init__(self, areaid)
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/node/lterid.py b/src/exabgp/bgp/message/update/attribute/bgpls/node/lterid.py
index e070338d8..5f79c143b 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/node/lterid.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/node/lterid.py
@@ -25,8 +25,8 @@
 @LinkState.register(lsid=1029)
 class LocalTeRid(BaseLS):
     MERGE = True
-    REPR = "Local TE Router IDs"
-    JSON = "local-te-router-ids"
+    REPR = 'Local TE Router IDs'
+    JSON = 'local-te-router-ids'
 
     def __init__(self, terids):
         BaseLS.__init__(self, terids)
@@ -36,7 +36,7 @@ def unpack(cls, data):
         length = len(data)
 
         if length not in (4, 16):
-            raise Notify(3, 5, "Invalid remote-te size")
+            raise Notify(3, 5, 'Invalid remote-te size')
 
         return cls([str(IP.unpack(data))])
 
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/node/nodename.py b/src/exabgp/bgp/message/update/attribute/bgpls/node/nodename.py
index 6f3d158ae..678ec7046 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/node/nodename.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/node/nodename.py
@@ -28,8 +28,8 @@
 class NodeName(BaseLS):
     TLV = 1026
     MERGE = False
-    REPR = "Node Name"
-    JSON = "node-name"
+    REPR = 'Node Name'
+    JSON = 'node-name'
 
     def __init__(self, nodename):
         BaseLS.__init__(self, nodename)
@@ -37,7 +37,7 @@ def __init__(self, nodename):
     @classmethod
     def unpack(cls, data):
         if len(data) > 255:
-            raise Notify(3, 5, "Node Name TLV length too large")
+            raise Notify(3, 5, 'Node Name TLV length too large')
 
         return cls(data.decode('ascii'))
 
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/node/opaque.py b/src/exabgp/bgp/message/update/attribute/bgpls/node/opaque.py
index 819236369..7fd1abea4 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/node/opaque.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/node/opaque.py
@@ -29,15 +29,15 @@
 @LinkState.register()
 class NodeOpaque(BaseLS):
     TLV = 1025
-    REPR = "Node Opaque attribute"
-    JSON = "opaque"
+    REPR = 'Node Opaque attribute'
+    JSON = 'opaque'
 
     def __init__(self, opaque):
         BaseLS.__init__(self, opaque)
 
     @classmethod
     def unpack(cls, data):
-        return cls(unpack("!%ds" % len(data), data)[0])
+        return cls(unpack('!%ds' % len(data), data)[0])
 
     def json(self, compact=None):
         return '"{}": {}'.format(self.JSON, json.dumps(self.content))
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/node/sralgo.py b/src/exabgp/bgp/message/update/attribute/bgpls/node/sralgo.py
index 357337569..486dc117c 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/node/sralgo.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/node/sralgo.py
@@ -27,8 +27,8 @@
 @LinkState.register()
 class SrAlgorithm(BaseLS):
     TLV = 1035
-    REPR = "SrAlgorithms"
-    JSON = "sr-algorithms"
+    REPR = 'SrAlgorithms'
+    JSON = 'sr-algorithms'
 
     def __init__(self, sr_algos):
         BaseLS.__init__(self, sr_algos)
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/node/srcap.py b/src/exabgp/bgp/message/update/attribute/bgpls/node/srcap.py
index b9180e7dd..6ae008d79 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/node/srcap.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/node/srcap.py
@@ -51,7 +51,7 @@ def __init__(self, flags, sids):
         self.sids = sids
 
     def __repr__(self):
-        return "%s: %s, sids: %s" % (self.REPR, self.flags, self.sids)
+        return '%s: %s, sids: %s' % (self.REPR, self.flags, self.sids)
 
     @classmethod
     def unpack(cls, data):
@@ -71,7 +71,7 @@ def unpack(cls, data):
             # represents a 32 bit SID.
             sub_type, length = unpack('!HH', data[3:7])
             if sub_type != 1161:
-                raise Notify(3, 5, "Invalid sub-TLV type: {}".format(sub_type))
+                raise Notify(3, 5, 'Invalid sub-TLV type: {}'.format(sub_type))
             if length == 3:
                 sids.append([range_size, unpack('!I', bytes([0]) + data[7 : length + 7])[0] & 0xFFFFF])
             elif length == 4:
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igpextags.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igpextags.py
index 5b26dc42f..3fac72cfb 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igpextags.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igpextags.py
@@ -33,4 +33,4 @@ class IgpExTags(BaseLS):
     @classmethod
     def unpack(cls, data):
         cls.check(data)
-        return cls([unpack("!Q", _)[0] for _ in split(data, 8)])
+        return cls([unpack('!Q', _)[0] for _ in split(data, 8)])
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igptags.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igptags.py
index e95604cbc..63ce0d858 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igptags.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/igptags.py
@@ -36,4 +36,4 @@ class IgpTags(BaseLS):
     @classmethod
     def unpack(cls, data):
         cls.check(data)
-        return cls([unpack("!L", _)[0] for _ in split(data, 4)])
+        return cls([unpack('!L', _)[0] for _ in split(data, 4)])
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/opaque.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/opaque.py
index e601038a8..13be1338a 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/opaque.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/opaque.py
@@ -30,4 +30,4 @@ class PrefixOpaque(BaseLS):
 
     @classmethod
     def unpack(cls, data):
-        return cls(unpack("!%ds" % len(data), data)[0])
+        return cls(unpack('!%ds' % len(data), data)[0])
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/ospfaddr.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/ospfaddr.py
index dd05f29db..dcce73524 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/ospfaddr.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/ospfaddr.py
@@ -32,5 +32,5 @@ class OspfForwardingAddress(BaseLS):
     def unpack(cls, data):
         length = len(data)
         if length not in (4, 16):
-            raise Notify(3, 5, "Error parsing OSPF Forwarding Address. Wrong size")
+            raise Notify(3, 5, 'Error parsing OSPF Forwarding Address. Wrong size')
         return cls(IP.unpack(data))
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/prefixmetric.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/prefixmetric.py
index 4f6a557ef..8b307cd43 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/prefixmetric.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/prefixmetric.py
@@ -32,4 +32,4 @@ class PrefixMetric(BaseLS):
     @classmethod
     def unpack(cls, data):
         cls.check(data)
-        return cls(int(unpack("!L", data)[0]))
+        return cls(int(unpack('!L', data)[0]))
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srprefix.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srprefix.py
index 1dc8d1de7..dc7eef250 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srprefix.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srprefix.py
@@ -40,7 +40,7 @@ def __init__(self, flags, sids, sr_algo, undecoded=[]):
         self.undecoded = undecoded
 
     def __repr__(self):
-        return "prefix_flags: %s, sids: %s, undecoded_sid: %s" % (self.flags, self.sids, self.undecoded)
+        return 'prefix_flags: %s, sids: %s, undecoded_sid: %s' % (self.flags, self.sids, self.undecoded)
 
     @classmethod
     def unpack(cls, data):
diff --git a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srrid.py b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srrid.py
index da4567d23..c1f974550 100644
--- a/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srrid.py
+++ b/src/exabgp/bgp/message/update/attribute/bgpls/prefix/srrid.py
@@ -33,5 +33,5 @@ class SrSourceRouterID(BaseLS):
     def unpack(cls, data):
         length = len(data)
         if length not in (4, 16):
-            raise Notify(3, 5, "Error parsing SR Source Router ID. Wrong size")
+            raise Notify(3, 5, 'Error parsing SR Source Router ID. Wrong size')
         return cls(IP.unpack(data))
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/bandwidth.py b/src/exabgp/bgp/message/update/attribute/community/extended/bandwidth.py
index 157c0395f..01791c2e7 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/bandwidth.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/bandwidth.py
@@ -24,10 +24,10 @@ class Bandwidth(ExtendedCommunity):
     def __init__(self, asn, speed, community=None):
         self.asn = asn
         self.speed = speed
-        ExtendedCommunity.__init__(self, community if community is not None else pack("!Hf", asn, speed))
+        ExtendedCommunity.__init__(self, community if community is not None else pack('!Hf', asn, speed))
 
     def __repr__(self):
-        return "bandwith:%d:%0.f" % (self.asn, self.speed)
+        return 'bandwith:%d:%0.f' % (self.asn, self.speed)
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/chso.py b/src/exabgp/bgp/message/update/attribute/community/extended/chso.py
index 229f64163..3e81c73b2 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/chso.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/chso.py
@@ -17,18 +17,18 @@
 class ConsistentHashSortOrder(ExtendedCommunity):
     COMMUNITY_TYPE = 0x03
     COMMUNITY_SUBTYPE = 0x14
-    DESCRIPTION = "consistentHashSortOrder"
+    DESCRIPTION = 'consistentHashSortOrder'
 
     def __init__(self, order, reserved=0, community=None):
         self.order = order
         self.reserved = reserved
 
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sIH", self._subtype(), order, reserved)
+            self, community if community is not None else pack('!2sIH', self._subtype(), order, reserved)
         )
 
     def __repr__(self):
-        return "%s:%d" % (self.DESCRIPTION, self.order)
+        return '%s:%d' % (self.DESCRIPTION, self.order)
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/community.py b/src/exabgp/bgp/message/update/attribute/community/extended/community.py
index 0905185ad..0f49338cd 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/community.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/community.py
@@ -92,7 +92,7 @@ def __repr__(self):
         for byte in self.community:
             h <<= 8
             h += byte
-        return "0x%016X" % h
+        return '0x%016X' % h
 
     def __hash__(self):
         return hash(self.community)
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/encapsulation.py b/src/exabgp/bgp/message/update/attribute/community/extended/encapsulation.py
index d10e24fa8..877ab7f06 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/encapsulation.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/encapsulation.py
@@ -35,25 +35,25 @@ class Type:
         MPLS_UDP = 0x0D
 
     _string = {
-        Type.DEFAULT: "Default",
-        Type.L2TPv3: "L2TPv3",
-        Type.GRE: "GRE",
-        Type.IPIP: "IP-in-IP",
-        Type.VXLAN: "VXLAN",
-        Type.NVGRE: "NVGRE",
-        Type.MPLS: "MPLS",
-        Type.VXLAN_GPE: "VXLAN-GPE",
-        Type.MPLS_UDP: "MPLS-in-UDP",
+        Type.DEFAULT: 'Default',
+        Type.L2TPv3: 'L2TPv3',
+        Type.GRE: 'GRE',
+        Type.IPIP: 'IP-in-IP',
+        Type.VXLAN: 'VXLAN',
+        Type.NVGRE: 'NVGRE',
+        Type.MPLS: 'MPLS',
+        Type.VXLAN_GPE: 'VXLAN-GPE',
+        Type.MPLS_UDP: 'MPLS-in-UDP',
     }
 
     def __init__(self, tunnel_type, community=None):
         self.tunnel_type = tunnel_type
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sLH", self._subtype(), 0, self.tunnel_type)
+            self, community if community is not None else pack('!2sLH', self._subtype(), 0, self.tunnel_type)
         )
 
     def __repr__(self):
-        return "encap:%s" % Encapsulation._string.get(self.tunnel_type, "encap:UNKNOWN-%d" % self.tunnel_type)
+        return 'encap:%s' % Encapsulation._string.get(self.tunnel_type, 'encap:UNKNOWN-%d' % self.tunnel_type)
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/flowspec_scope.py b/src/exabgp/bgp/message/update/attribute/community/extended/flowspec_scope.py
index 5139b0cec..95877e23f 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/flowspec_scope.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/flowspec_scope.py
@@ -34,12 +34,12 @@ def __init__(self, trans, asn, target, direction, community=None):
         self.transitive = trans
         new_target = (direction << 14) + target
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sLH", self._subtype(self.transitive), asn, new_target)
+            self, community if community is not None else pack('!2sLH', self._subtype(self.transitive), asn, new_target)
         )
 
     def __repr__(self):
         str_direction = self.names.get(self.direction, str(self.direction))
-        return "interface-set:%s:%s:%s" % (str_direction, str(self.asn), str(self.target))
+        return 'interface-set:%s:%s:%s' % (str_direction, str(self.asn), str(self.target))
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/l2info.py b/src/exabgp/bgp/message/update/attribute/community/extended/l2info.py
index 9f8e7f70a..d7add8ad8 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/l2info.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/l2info.py
@@ -30,11 +30,11 @@ def __init__(self, encaps, control, mtu, reserved, community=None):
         # reserved is called preference in draft-ietf-l2vpn-vpls-multihoming-07
         ExtendedCommunity.__init__(
             self,
-            community if community is not None else pack("!2sBBHH", self._subtype(), encaps, control, mtu, reserved),
+            community if community is not None else pack('!2sBBHH', self._subtype(), encaps, control, mtu, reserved),
         )
 
     def __repr__(self):
-        return "l2info:%s:%s:%s:%s" % (self.encaps, self.control, self.mtu, self.reserved)
+        return 'l2info:%s:%s:%s:%s' % (self.encaps, self.control, self.mtu, self.reserved)
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/mac_mobility.py b/src/exabgp/bgp/message/update/attribute/community/extended/mac_mobility.py
index 5151b44bd..b55b0288f 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/mac_mobility.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/mac_mobility.py
@@ -32,9 +32,9 @@ def __hash__(self):
         return hash((self.sticky, self.sequence))
 
     def __repr__(self):
-        s = "%s:%d" % (self.DESCRIPTION, self.sequence)
+        s = '%s:%d' % (self.DESCRIPTION, self.sequence)
         if self.sticky:
-            s += ":sticky"
+            s += ':sticky'
         return s
 
     @staticmethod
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/mup.py b/src/exabgp/bgp/message/update/attribute/community/extended/mup.py
index 67a842dfd..65fa39d56 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/mup.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/mup.py
@@ -49,7 +49,7 @@ def __hash__(self):
         return hash((self.sgid2, self.sgid4))
 
     def __repr__(self):
-        return "%s:%d:%d" % ("mup", self.sgid2, self.sgid4)
+        return '%s:%d:%d' % ('mup', self.sgid2, self.sgid4)
 
     @classmethod
     def unpack(cls, data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/origin.py b/src/exabgp/bgp/message/update/attribute/community/extended/origin.py
index 180b4ee3e..1327b8ceb 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/origin.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/origin.py
@@ -51,7 +51,7 @@ def __init__(self, asn, ip, transitive, community=None):
         Origin.__init__(self, community if community else pack('!2sH4s', self._subtype(), asn, IPv4.pton(ip)))
 
     def __repr__(self):
-        return "origin:%s:%s" % (self.asn, self.ip)
+        return 'origin:%s:%s' % (self.asn, self.ip)
 
     @staticmethod
     def unpack(data):
@@ -74,7 +74,7 @@ def __init__(self, asn, ip, transitive, community=None):
         Origin.__init__(self, community if community else pack('!2s4sH', self._subtype(), IPv4.pton(ip), asn))
 
     def __repr__(self):
-        return "origin:%s:%s" % (self.ip, self.asn)
+        return 'origin:%s:%s' % (self.ip, self.asn)
 
     @staticmethod
     def unpack(data):
@@ -97,7 +97,7 @@ def __init__(self, asn, number, transitive, community=None):
         Origin.__init__(self, community if community else pack('!2sLH', self._subtype(), asn, number))
 
     def __repr__(self):
-        return "origin:%s:%s" % (self.asn, self.number)
+        return 'origin:%s:%s' % (self.asn, self.number)
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/rt.py b/src/exabgp/bgp/message/update/attribute/community/extended/rt.py
index 77a44fe86..d92c053ef 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/rt.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/rt.py
@@ -59,7 +59,7 @@ def __hash__(self):
         return hash((self.asn, self.number))
 
     def __repr__(self):
-        return "%s:%d:%d" % (self.DESCRIPTION, self.asn, self.number)
+        return '%s:%d:%d' % (self.DESCRIPTION, self.asn, self.number)
 
     @classmethod
     def unpack(cls, data):
@@ -89,7 +89,7 @@ def __hash__(self):
         return hash((self.ip, self.number))
 
     def __repr__(self):
-        return "%s:%s:%d" % (self.DESCRIPTION, self.ip, self.number)
+        return '%s:%s:%d' % (self.DESCRIPTION, self.ip, self.number)
 
     @classmethod
     def unpack(cls, data):
@@ -117,7 +117,7 @@ def __hash__(self):
         return hash((self.asn, self.number))
 
     def __repr__(self):
-        return "%s:%d:%d" % (self.DESCRIPTION, self.asn, self.number)
+        return '%s:%d:%d' % (self.DESCRIPTION, self.asn, self.number)
 
     @classmethod
     def unpack(cls, data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/rt_record.py b/src/exabgp/bgp/message/update/attribute/community/extended/rt_record.py
index e07a9f49a..0a1f888f9 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/rt_record.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/rt_record.py
@@ -15,7 +15,7 @@
 
 class RTRecord(rt.RouteTarget):
     COMMUNITY_SUBTYPE = 0x13
-    DESCRIPTION = "rtrecord"
+    DESCRIPTION = 'rtrecord'
 
     @classmethod
     def from_rt(cls, route_target):
diff --git a/src/exabgp/bgp/message/update/attribute/community/extended/traffic.py b/src/exabgp/bgp/message/update/attribute/community/extended/traffic.py
index d9ae35aa1..8bb91190d 100644
--- a/src/exabgp/bgp/message/update/attribute/community/extended/traffic.py
+++ b/src/exabgp/bgp/message/update/attribute/community/extended/traffic.py
@@ -33,11 +33,11 @@ def __init__(self, asn, rate, community=None):
         self.asn = asn
         self.rate = rate
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sHf", self._subtype(), asn, rate)
+            self, community if community is not None else pack('!2sHf', self._subtype(), asn, rate)
         )
 
     def __repr__(self):
-        return "rate-limit:%d" % self.rate
+        return 'rate-limit:%d' % self.rate
 
     @staticmethod
     def unpack(data):
@@ -101,11 +101,11 @@ def __init__(self, asn, target, community=None):
         self.asn = asn
         self.target = target
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sHL", self._subtype(), asn, target)
+            self, community if community is not None else pack('!2sHL', self._subtype(), asn, target)
         )
 
     def __repr__(self):
-        return "redirect:%s:%s" % (self.asn, self.target)
+        return 'redirect:%s:%s' % (self.asn, self.target)
 
     @staticmethod
     def unpack(data):
@@ -122,11 +122,11 @@ def __init__(self, asn, target, community=None):
         self.asn = asn
         self.target = target
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sLH", self._subtype(), asn, target)
+            self, community if community is not None else pack('!2sLH', self._subtype(), asn, target)
         )
 
     def __str__(self):
-        return "redirect:%s:%s" % (self.asn, self.target)
+        return 'redirect:%s:%s' % (self.asn, self.target)
 
     @staticmethod
     def unpack(data):
@@ -146,11 +146,11 @@ class TrafficMark(ExtendedCommunity):
     def __init__(self, dscp, community=None):
         self.dscp = dscp
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sLBB", self._subtype(), 0, 0, dscp)
+            self, community if community is not None else pack('!2sLBB', self._subtype(), 0, 0, dscp)
         )
 
     def __repr__(self):
-        return "mark %d" % self.dscp
+        return 'mark %d' % self.dscp
 
     @staticmethod
     def unpack(data):
@@ -172,11 +172,11 @@ def __init__(self, ip, copy, community=None):
         self.ip = ip
         self.copy = copy
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2s4sH", self._subtype(), ip.pack(), 1 if copy else 0)
+            self, community if community is not None else pack('!2s4sH', self._subtype(), ip.pack(), 1 if copy else 0)
         )
 
     def __repr__(self):
-        return "copy-to-nexthop-ietf %s (with copy)" % self.ip if self.copy else "redirect-to-nexthop-ietf %s" % self.ip
+        return 'copy-to-nexthop-ietf %s (with copy)' % self.ip if self.copy else 'redirect-to-nexthop-ietf %s' % self.ip
 
     @staticmethod
     def unpack(data):
@@ -198,11 +198,11 @@ def __init__(self, ip, copy, community=None):
         self.ip = ip
         self.copy = copy
         ExtendedCommunityIPv6.__init__(
-            self, community if community is not None else pack("!2s16sH", self._subtype(), ip.pack(), 1 if copy else 0)
+            self, community if community is not None else pack('!2s16sH', self._subtype(), ip.pack(), 1 if copy else 0)
         )
 
     def __repr__(self):
-        return "copy-to-nexthop-ietf %s (with copy)" % self.ip if self.copy else "redirect-to-nexthop-ietf %s" % self.ip
+        return 'copy-to-nexthop-ietf %s (with copy)' % self.ip if self.copy else 'redirect-to-nexthop-ietf %s' % self.ip
 
     @staticmethod
     def unpack(data):
@@ -224,11 +224,11 @@ class TrafficNextHopSimpson(ExtendedCommunity):
     def __init__(self, copy, community=None):
         self.copy = copy
         ExtendedCommunity.__init__(
-            self, community if community is not None else pack("!2sLH", self._subtype(), 0, 1 if copy else 0)
+            self, community if community is not None else pack('!2sLH', self._subtype(), 0, 1 if copy else 0)
         )
 
     def __repr__(self):
-        return "copy-to-nexthop" if self.copy else "redirect-to-nexthop"
+        return 'copy-to-nexthop' if self.copy else 'redirect-to-nexthop'
 
     @staticmethod
     def unpack(data):
@@ -253,12 +253,12 @@ def __init__(self, ip, asn, community=None):
             (
                 community
                 if community is not None
-                else pack("!BB16sH", 0x00, 0x02, socket.inet_pton(socket.AF_INET6, ip), asn)
+                else pack('!BB16sH', 0x00, 0x02, socket.inet_pton(socket.AF_INET6, ip), asn)
             ),
         )
 
     def __str__(self):
-        return "redirect %s:%d" % (self.ip, self.asn)
+        return 'redirect %s:%d' % (self.ip, self.asn)
 
     @staticmethod
     def unpack(data):
diff --git a/src/exabgp/bgp/message/update/attribute/community/initial/communities.py b/src/exabgp/bgp/message/update/attribute/community/initial/communities.py
index a109f33d1..bff5698c1 100644
--- a/src/exabgp/bgp/message/update/attribute/community/initial/communities.py
+++ b/src/exabgp/bgp/message/update/attribute/community/initial/communities.py
@@ -44,13 +44,13 @@ def __iter__(self):
     def __repr__(self):
         lc = len(self.communities)
         if lc > 1:
-            return "[ %s ]" % " ".join(repr(community) for community in sorted(self.communities))
+            return '[ %s ]' % ' '.join(repr(community) for community in sorted(self.communities))
         if lc == 1:
             return repr(self.communities[0])
-        return ""
+        return ''
 
     def json(self):
-        return "[ %s ]" % ", ".join(community.json() for community in self.communities)
+        return '[ %s ]' % ', '.join(community.json() for community in self.communities)
 
     @staticmethod
     def unpack(data, direction, negotiated):
diff --git a/src/exabgp/bgp/message/update/attribute/community/initial/community.py b/src/exabgp/bgp/message/update/attribute/community/initial/community.py
index 94330aef6..8dfd64c1b 100644
--- a/src/exabgp/bgp/message/update/attribute/community/initial/community.py
+++ b/src/exabgp/bgp/message/update/attribute/community/initial/community.py
@@ -40,7 +40,7 @@ def __init__(self, community):
         elif community == self.BLACKHOLE:
             self._str = 'blackhole'
         else:
-            self._str = "%d:%d" % unpack('!HH', self.community)
+            self._str = '%d:%d' % unpack('!HH', self.community)
 
     def __eq__(self, other):
         return self.community == other.community
@@ -61,7 +61,7 @@ def __ge__(self, other):
         return self.community >= other.community
 
     def json(self):
-        return "[ %d, %d ]" % unpack('!HH', self.community)
+        return '[ %d, %d ]' % unpack('!HH', self.community)
 
     def pack(self, negotiated=None):
         return self.community
diff --git a/src/exabgp/bgp/message/update/attribute/community/large/community.py b/src/exabgp/bgp/message/update/attribute/community/large/community.py
index 8ef7bb7fc..57c24b285 100644
--- a/src/exabgp/bgp/message/update/attribute/community/large/community.py
+++ b/src/exabgp/bgp/message/update/attribute/community/large/community.py
@@ -21,7 +21,7 @@ class LargeCommunity(Attribute):
 
     def __init__(self, large_community):
         self.large_community = large_community
-        self._str = "%d:%d:%d" % unpack('!LLL', self.large_community)
+        self._str = '%d:%d:%d' % unpack('!LLL', self.large_community)
 
     def __eq__(self, other):
         return self.large_community == other.large_community
@@ -42,7 +42,7 @@ def __ge__(self, other):
         return self.large_community >= other.large_community
 
     def json(self):
-        return "[ %d, %d , %d ]" % unpack('!LLL', self.large_community)
+        return '[ %d, %d , %d ]' % unpack('!LLL', self.large_community)
 
     def pack(self, negotiated=None):
         return self.large_community
diff --git a/src/exabgp/bgp/message/update/attribute/mprnlri.py b/src/exabgp/bgp/message/update/attribute/mprnlri.py
index 62afc6a03..e3a304ef7 100644
--- a/src/exabgp/bgp/message/update/attribute/mprnlri.py
+++ b/src/exabgp/bgp/message/update/attribute/mprnlri.py
@@ -106,7 +106,7 @@ def __len__(self):
         # return len(self.pack(False))
 
     def __repr__(self):
-        return "MP_REACH_NLRI for %s %s with %d NLRI(s)" % (self.afi, self.safi, len(self.nlris))
+        return 'MP_REACH_NLRI for %s %s with %d NLRI(s)' % (self.afi, self.safi, len(self.nlris))
 
     @classmethod
     def unpack(cls, data, direction, negotiated):
@@ -195,7 +195,7 @@ def unpack(cls, data, direction, negotiated):
                     nlris.append(nlri)
 
             if left == data:
-                raise RuntimeError("sub-calls should consume data")
+                raise RuntimeError('sub-calls should consume data')
 
             data = left
         return cls(afi, safi, nlris)
diff --git a/src/exabgp/bgp/message/update/attribute/mpurnlri.py b/src/exabgp/bgp/message/update/attribute/mpurnlri.py
index 61f246f05..8ca97887a 100644
--- a/src/exabgp/bgp/message/update/attribute/mpurnlri.py
+++ b/src/exabgp/bgp/message/update/attribute/mpurnlri.py
@@ -73,7 +73,7 @@ def __len__(self):
         raise RuntimeError('we can not give you the size of an MPURNLRI - was it with our witout addpath ?')
 
     def __repr__(self):
-        return "MP_UNREACH_NLRI for %s %s with %d NLRI(s)" % (self.afi, self.safi, len(self.nlris))
+        return 'MP_UNREACH_NLRI for %s %s with %d NLRI(s)' % (self.afi, self.safi, len(self.nlris))
 
     @classmethod
     def unpack(cls, data, direction, negotiated):
diff --git a/src/exabgp/bgp/message/update/attribute/pmsi.py b/src/exabgp/bgp/message/update/attribute/pmsi.py
index 563604e85..f51b0143b 100644
--- a/src/exabgp/bgp/message/update/attribute/pmsi.py
+++ b/src/exabgp/bgp/message/update/attribute/pmsi.py
@@ -86,14 +86,14 @@ def __len__(self):
         return len(self.tunnel) + 5  # label:1, tunnel type: 1, MPLS label:3
 
     def prettytunnel(self):
-        return "0x" + ''.join('%02X' % _ for _ in self.tunnel) if self.tunnel else ''
+        return '0x' + ''.join('%02X' % _ for _ in self.tunnel) if self.tunnel else ''
 
     def __repr__(self):
         if self.raw_label:
-            label_repr = "%d(%d)" % (self.label, self.raw_label)
+            label_repr = '%d(%d)' % (self.label, self.raw_label)
         else:
             label_repr = str(self.label) if self.label else '0'
-        return "pmsi:%s:%s:%s:%s" % (
+        return 'pmsi:%s:%s:%s:%s' % (
             self.name(self.TUNNEL_TYPE).replace(' ', '').lower(),
             str(self.flags),
             label_repr,
diff --git a/src/exabgp/bgp/message/update/attribute/sr/labelindex.py b/src/exabgp/bgp/message/update/attribute/sr/labelindex.py
index d724323c8..da103e082 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/labelindex.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/labelindex.py
@@ -5,6 +5,7 @@
 Created by Evelio Vila 2017-02-16
 Copyright (c) 2009-2017 Exa Networks. All rights reserved.
 """
+
 from struct import pack, unpack
 
 from exabgp.bgp.message.notification import Notify
@@ -32,7 +33,7 @@ def __init__(self, labelindex, packed=None):
         self.packed = self.pack()
 
     def __repr__(self):
-        return "%s" % (self.labelindex)
+        return '%s' % (self.labelindex)
 
     def pack(self):
         reserved, flags = 0, 0
@@ -48,7 +49,7 @@ def pack(self):
     def unpack(cls, data, length):
         labelindex = -1
         if cls.LENGTH != length:
-            raise Notify(3, 5, "Invalid TLV size. Should be 7 but {0} received".format(length))
+            raise Notify(3, 5, 'Invalid TLV size. Should be 7 but {0} received'.format(length))
         # Shift reserved bits
         data = data[1:]
         # Shift Flags
diff --git a/src/exabgp/bgp/message/update/attribute/sr/prefixsid.py b/src/exabgp/bgp/message/update/attribute/sr/prefixsid.py
index be1e05a7e..2a9a566c2 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/prefixsid.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/prefixsid.py
@@ -70,12 +70,12 @@ def __str__(self):
         if label_index is not None:
             srgb = next((i for i in self.sr_attrs if i.TLV == 3), None)
             if srgb is not None:
-                return "[ {}, {} ]".format(str(label_index), str(srgb))
+                return '[ {}, {} ]'.format(str(label_index), str(srgb))
             else:
-                return "[ {} ]".format(str(label_index))
+                return '[ {} ]'.format(str(label_index))
 
         # if not, we try to decode path attribute for SRv6
-        return "[ " + ", ".join([str(attr) for attr in self.sr_attrs]) + " ]"
+        return '[ ' + ', '.join([str(attr) for attr in self.sr_attrs]) + ' ]'
 
     def pack(self, negotiated=None):
         return self._packed
@@ -89,7 +89,7 @@ def __init__(self, code, rep):
         self.code = code
 
     def __repr__(self):
-        return "Attribute with code [ %s ] not implemented" % (self.code)
+        return 'Attribute with code [ %s ] not implemented' % (self.code)
 
     @classmethod
     def unpack(cls, scode, data):
diff --git a/src/exabgp/bgp/message/update/attribute/sr/srgb.py b/src/exabgp/bgp/message/update/attribute/sr/srgb.py
index 7fd215aeb..d886d42eb 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/srgb.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/srgb.py
@@ -5,6 +5,7 @@
 Created by Evelio Vila 2017-02-16
 Copyright (c) 2009-2017 Exa Networks. All rights reserved.
 """
+
 import json
 from struct import pack
 from struct import unpack
@@ -47,13 +48,13 @@ def __init__(self, srgbs, packed=None):
     def __repr__(self):
         items = []
         for base, srange in self.srgbs:
-            items.append("( {},{} )".format(base, srange))
+            items.append('( {},{} )'.format(base, srange))
         return '[ {} ]'.format(', '.join(items))
 
     def pack(self):
         payload = pack('!H', 0)  # flags
         for b, r in self.srgbs:
-            payload = payload + pack("!L", b)[1:] + pack("!L", r)[1:]
+            payload = payload + pack('!L', b)[1:] + pack('!L', r)[1:]
         return pack('!B', self.TLV) + pack('!H', len(payload)) + payload
 
     @classmethod
diff --git a/src/exabgp/bgp/message/update/attribute/sr/srv6/generic.py b/src/exabgp/bgp/message/update/attribute/sr/srv6/generic.py
index 4fa9d718b..d7043ea64 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/srv6/generic.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/srv6/generic.py
@@ -13,11 +13,11 @@ def __init__(self, code, packed):
         self.packed = packed
 
     def __repr__(self):
-        return "SRv6 Service Sub-TLV type %d not implemented" % self.code
+        return 'SRv6 Service Sub-TLV type %d not implemented' % self.code
 
     def json(self, compact=None):
         # TODO:
-        return ""
+        return ''
 
     def pack(self):
         return self.packed
@@ -29,11 +29,11 @@ def __init__(self, code, packed):
         self.packed = packed
 
     def __repr__(self):
-        return "SRv6 Service Data Sub-Sub-TLV type %d not implemented" % self.code
+        return 'SRv6 Service Data Sub-Sub-TLV type %d not implemented' % self.code
 
     def json(self, compact=None):
         # TODO:
-        return ""
+        return ''
 
     def pack(self):
         return self.packed
diff --git a/src/exabgp/bgp/message/update/attribute/sr/srv6/l2service.py b/src/exabgp/bgp/message/update/attribute/sr/srv6/l2service.py
index e4535ab27..9733d2d4f 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/srv6/l2service.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/srv6/l2service.py
@@ -5,6 +5,7 @@
 Created by Ryoga Saito 2022-02-24
 Copyright (c) 2022 Ryoga Saito. All rights reserved.
 """
+
 from struct import pack, unpack
 
 from exabgp.bgp.message.update.attribute.sr.prefixsid import PrefixSid
@@ -52,7 +53,7 @@ def unpack(cls, data, length):
         data = data[1:]
         while data:
             code = data[0]
-            length = unpack("!H", data[1:3])[0]
+            length = unpack('!H', data[1:3])[0]
             if code in cls.registered_subtlvs:
                 subtlv = cls.registered_subtlvs[code].unpack(data[3 : length + 3], length)
             else:
@@ -63,15 +64,15 @@ def unpack(cls, data, length):
         return cls(subtlvs=subtlvs)
 
     def pack(self):
-        subtlvs_packed = b"".join([_.pack() for _ in self.subtlvs])
+        subtlvs_packed = b''.join([_.pack() for _ in self.subtlvs])
         length = len(subtlvs_packed) + 1
         reserved = 0
 
-        return pack("!B", self.TLV) + pack("!H", length) + pack("!B", reserved) + subtlvs_packed
+        return pack('!B', self.TLV) + pack('!H', length) + pack('!B', reserved) + subtlvs_packed
 
     def __str__(self):
-        return "l2-service [ " + ", ".join([str(subtlv) for subtlv in self.subtlvs]) + " ]"
+        return 'l2-service [ ' + ', '.join([str(subtlv) for subtlv in self.subtlvs]) + ' ]'
 
     def json(self, compact=None):
-        content = "[ " + ", ".join(subtlv.json() for subtlv in self.subtlvs) + " ]"
+        content = '[ ' + ', '.join(subtlv.json() for subtlv in self.subtlvs) + ' ]'
         return '"l2-service": %s' % content
diff --git a/src/exabgp/bgp/message/update/attribute/sr/srv6/l3service.py b/src/exabgp/bgp/message/update/attribute/sr/srv6/l3service.py
index 5ae1dede6..63dd36f2f 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/srv6/l3service.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/srv6/l3service.py
@@ -5,6 +5,7 @@
 Created by Ryoga Saito 2022-02-24
 Copyright (c) 2022 Ryoga Saito. All rights reserved.
 """
+
 from struct import pack, unpack
 
 from exabgp.bgp.message.update.attribute.sr.prefixsid import PrefixSid
@@ -52,7 +53,7 @@ def unpack(cls, data, length):
         data = data[1:]
         while data:
             code = data[0]
-            length = unpack("!H", data[1:3])[0]
+            length = unpack('!H', data[1:3])[0]
             if code in cls.registered_subtlvs:
                 subtlv = cls.registered_subtlvs[code].unpack(data[3 : length + 3], length)
             else:
@@ -63,15 +64,15 @@ def unpack(cls, data, length):
         return cls(subtlvs=subtlvs)
 
     def pack(self):
-        subtlvs_packed = b"".join([_.pack() for _ in self.subtlvs])
+        subtlvs_packed = b''.join([_.pack() for _ in self.subtlvs])
         length = len(subtlvs_packed) + 1
         reserved = 0
 
-        return pack("!B", self.TLV) + pack("!H", length) + pack("!B", reserved) + subtlvs_packed
+        return pack('!B', self.TLV) + pack('!H', length) + pack('!B', reserved) + subtlvs_packed
 
     def __str__(self):
-        return "l3-service [ " + ", ".join([str(subtlv) for subtlv in self.subtlvs]) + " ]"
+        return 'l3-service [ ' + ', '.join([str(subtlv) for subtlv in self.subtlvs]) + ' ]'
 
     def json(self, compact=None):
-        content = "[ " + ", ".join(subtlv.json() for subtlv in self.subtlvs) + " ]"
+        content = '[ ' + ', '.join(subtlv.json() for subtlv in self.subtlvs) + ' ]'
         return '"l3-service": %s' % content
diff --git a/src/exabgp/bgp/message/update/attribute/sr/srv6/sidinformation.py b/src/exabgp/bgp/message/update/attribute/sr/srv6/sidinformation.py
index dc558c72c..ed86a23b5 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/srv6/sidinformation.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/srv6/sidinformation.py
@@ -5,6 +5,7 @@
 Created by Ryoga Saito 2022-02-24
 Copyright (c) 2022 Ryoga Saito. All rights reserved.
 """
+
 from struct import pack, unpack
 
 from exabgp.protocol.ip import IPv6
@@ -59,13 +60,13 @@ def register_subsubtlv(klass):
     @classmethod
     def unpack(cls, data, length):
         sid = IPv6.unpack(data[1:17])
-        behavior = unpack("!H", data[18:20])[0]
+        behavior = unpack('!H', data[18:20])[0]
         subsubtlvs = []
 
         data = data[21:]
         while data:
             code = data[0]
-            length = unpack("!H", data[1:3])[0]
+            length = unpack('!H', data[1:3])[0]
             if code in cls.registered_subsubtlvs:
                 subsubtlv = cls.registered_subsubtlvs[code].unpack(data[3 : length + 3], length)
             else:
@@ -76,32 +77,32 @@ def unpack(cls, data, length):
         return cls(sid=sid, behavior=behavior, subsubtlvs=subsubtlvs)
 
     def pack(self):
-        subsubtlvs_packed = b"".join([_.pack() for _ in self.subsubtlvs])
+        subsubtlvs_packed = b''.join([_.pack() for _ in self.subsubtlvs])
         length = len(subsubtlvs_packed) + 21
         reserved, flags = 0, 0
 
         return (
-            pack("!B", self.TLV)
-            + pack("!H", length)
-            + pack("!B", reserved)
+            pack('!B', self.TLV)
+            + pack('!H', length)
+            + pack('!B', reserved)
             + self.sid.pack()
-            + pack("!B", flags)
-            + pack("!H", self.behavior)
-            + pack("!B", reserved)
+            + pack('!B', flags)
+            + pack('!H', self.behavior)
+            + pack('!B', reserved)
             + subsubtlvs_packed
         )
 
     def __str__(self):
-        s = "sid-information [ sid:%s flags:0 endpoint_behavior:0x%x " % (str(self.sid), self.behavior)
+        s = 'sid-information [ sid:%s flags:0 endpoint_behavior:0x%x ' % (str(self.sid), self.behavior)
         if len(self.subsubtlvs) != 0:
-            s += " [ " + ", ".join([str(subsubtlv) for subsubtlv in self.subsubtlvs]) + " ]"
-        s + " ]"
+            s += ' [ ' + ', '.join([str(subsubtlv) for subsubtlv in self.subsubtlvs]) + ' ]'
+        s + ' ]'
         return s
 
     def json(self, compact=None):
         s = '{ "sid": "%s", "flags": 0, "endpoint_behavior": %d'
-        content = ", ".join(subsubtlv.json() for subsubtlv in self.subsubtlvs)
+        content = ', '.join(subsubtlv.json() for subsubtlv in self.subsubtlvs)
         if content:
-            s += ", %s" % content
-        s += " }"
+            s += ', %s' % content
+        s += ' }'
         return s
diff --git a/src/exabgp/bgp/message/update/attribute/sr/srv6/sidstructure.py b/src/exabgp/bgp/message/update/attribute/sr/srv6/sidstructure.py
index 11658f605..578f05fbe 100644
--- a/src/exabgp/bgp/message/update/attribute/sr/srv6/sidstructure.py
+++ b/src/exabgp/bgp/message/update/attribute/sr/srv6/sidstructure.py
@@ -5,6 +5,7 @@
 Created by Ryoga Saito 2022-02-24
 Copyright (c) 2022 Ryoga Saito. All rights reserved.
 """
+
 import json
 from struct import pack
 
@@ -64,18 +65,18 @@ def unpack(cls, data, length):
 
     def pack(self):
         return (
-            pack("!B", self.TLV)
-            + pack("!H", 6)
-            + pack("!B", self.loc_block_len)
-            + pack("!B", self.loc_node_len)
-            + pack("!B", self.func_len)
-            + pack("!B", self.arg_len)
-            + pack("!B", self.tpose_len)
-            + pack("!B", self.tpose_offset)
+            pack('!B', self.TLV)
+            + pack('!H', 6)
+            + pack('!B', self.loc_block_len)
+            + pack('!B', self.loc_node_len)
+            + pack('!B', self.func_len)
+            + pack('!B', self.arg_len)
+            + pack('!B', self.tpose_len)
+            + pack('!B', self.tpose_offset)
         )
 
     def __str__(self):
-        return "sid-structure [%d,%d,%d,%d,%d,%d]" % (
+        return 'sid-structure [%d,%d,%d,%d,%d,%d]' % (
             self.loc_block_len,
             self.loc_node_len,
             self.func_len,
@@ -86,12 +87,12 @@ def __str__(self):
 
     def json(self, compact=None):
         pairs = {
-            "locator-block-length": self.loc_block_len,
-            "locator-node-length": self.loc_node_len,
-            "function-length": self.func_len,
-            "argument-length": self.arg_len,
-            "transposition-length": self.tpose_len,
-            "transposition-offset": self.tpose_offset,
+            'locator-block-length': self.loc_block_len,
+            'locator-node-length': self.loc_node_len,
+            'function-length': self.func_len,
+            'argument-length': self.arg_len,
+            'transposition-length': self.tpose_len,
+            'transposition-offset': self.tpose_offset,
         }
 
         return '"structure": %s' % json.dumps(pairs)
diff --git a/src/exabgp/bgp/message/update/eor.py b/src/exabgp/bgp/message/update/eor.py
index 2f5969efa..379fb7ddd 100644
--- a/src/exabgp/bgp/message/update/eor.py
+++ b/src/exabgp/bgp/message/update/eor.py
@@ -22,7 +22,7 @@ class EOR(Message):
     TYPE = bytes([Message.CODE.UPDATE])
 
     class NLRI(_NLRI):
-        PREFIX = b'\x00\x00\x00\x07\x90\x0F\x00\x03'
+        PREFIX = b'\x00\x00\x00\x07\x90\x0f\x00\x03'
         MP_LENGTH = len(PREFIX) + 1 + 2  # len(AFI) and len(SAFI)
         EOR = True
 
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/link.py b/src/exabgp/bgp/message/update/nlri/bgpls/link.py
index d6fefed37..918332f39 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/link.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/link.py
@@ -56,8 +56,8 @@
 @BGPLS.register
 class LINK(BGPLS):
     CODE = 2
-    NAME = "bgpls-link"
-    SHORT_NAME = "Link"
+    NAME = 'bgpls-link'
+    SHORT_NAME = 'Link'
 
     def __init__(
         self,
@@ -117,7 +117,7 @@ def unpack_nlri(cls, data, rd):
                     node, left = NodeDescriptor.unpack(value, proto_id)
                     local_node.append(node)
                     if left == value:
-                        raise RuntimeError("sub-calls should consume data")
+                        raise RuntimeError('sub-calls should consume data')
                     value = left
                 continue
 
@@ -128,7 +128,7 @@ def unpack_nlri(cls, data, rd):
                     node, left = NodeDescriptor.unpack(value, proto_id)
                     remote_node.append(node)
                     if left == value:
-                        raise RuntimeError("sub-calls should consume data")
+                        raise RuntimeError('sub-calls should consume data')
                     value = left
                 continue
 
@@ -215,6 +215,6 @@ def json(self, compact=None):
         # # content is ending without a , here in purpose
 
         if self.route_d:
-            content += ", { %s }" % self.route_d.json()
+            content += ', { %s }' % self.route_d.json()
 
         return '{ %s }' % content
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/nlri.py b/src/exabgp/bgp/message/update/nlri/bgpls/nlri.py
index 88954c506..e936372fd 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/nlri.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/nlri.py
@@ -96,10 +96,10 @@ def __len__(self):
         return len(self._packed) + 2
 
     def __hash__(self):
-        return hash("%s:%s:%s:%s" % (self.afi, self.safi, self.CODE, self._packed))
+        return hash('%s:%s:%s:%s' % (self.afi, self.safi, self.CODE, self._packed))
 
     def __str__(self):
-        return "bgp-ls:%s:%s" % (
+        return 'bgp-ls:%s:%s' % (
             self.registered_bgpls.get(self.CODE, self).SHORT_NAME.lower(),
             '0x' + ''.join('%02x' % _ for _ in self._packed),
         )
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/node.py b/src/exabgp/bgp/message/update/nlri/bgpls/node.py
index 60f55cfe6..a92c471f2 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/node.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/node.py
@@ -35,8 +35,8 @@
 @BGPLS.register
 class NODE(BGPLS):
     CODE = 1
-    NAME = "bgpls-node"
-    SHORT_NAME = "Node"
+    NAME = 'bgpls-node'
+    SHORT_NAME = 'Node'
 
     def __init__(self, domain, proto_id, node_ids, packed=None, nexthop=None, action=None, route_d=None, addpath=None):
         BGPLS.__init__(self, action, addpath)
@@ -83,7 +83,7 @@ def unpack_nlri(cls, data, rd):
             node_id, left = NodeDescriptor.unpack(values, proto_id)
             node_ids.append(node_id)
             if left == values:
-                raise RuntimeError("sub-calls should consume data")
+                raise RuntimeError('sub-calls should consume data')
             values = left
 
         return cls(domain=domain, proto_id=proto_id, node_ids=node_ids, route_d=rd, packed=data)
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/prefixv4.py b/src/exabgp/bgp/message/update/nlri/bgpls/prefixv4.py
index fa6ed4fe8..cc08d51d6 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/prefixv4.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/prefixv4.py
@@ -36,8 +36,8 @@
 @BGPLS.register
 class PREFIXv4(BGPLS):
     CODE = 3
-    NAME = "bgpls-prefix-v4"
-    SHORT_NAME = "PREFIX_V4"
+    NAME = 'bgpls-prefix-v4'
+    SHORT_NAME = 'PREFIX_V4'
 
     def __init__(
         self,
@@ -85,7 +85,7 @@ def unpack_nlri(cls, data, rd):
                     node, left = NodeDescriptor.unpack(value, proto_id)
                     local_node.append(node)
                     if left == value:
-                        raise RuntimeError("sub-calls should consume data")
+                        raise RuntimeError('sub-calls should consume data')
                     value = left
                 continue
 
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/prefixv6.py b/src/exabgp/bgp/message/update/nlri/bgpls/prefixv6.py
index bd7187a9e..16f42d613 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/prefixv6.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/prefixv6.py
@@ -36,8 +36,8 @@
 @BGPLS.register
 class PREFIXv6(BGPLS):
     CODE = 4
-    NAME = "bgpls-prefix-v6"
-    SHORT_NAME = "PREFIX_V6"
+    NAME = 'bgpls-prefix-v6'
+    SHORT_NAME = 'PREFIX_V6'
 
     def __init__(
         self,
@@ -85,7 +85,7 @@ def unpack_nlri(cls, data, rd):
                     node, left = NodeDescriptor.unpack(value, proto_id)
                     local_node.append(node)
                     if left == value:
-                        raise RuntimeError("sub-calls should consume data")
+                        raise RuntimeError('sub-calls should consume data')
                     value = left
                 continue
 
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/ipreach.py b/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/ipreach.py
index e4e1b9637..161989d69 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/ipreach.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/ipreach.py
@@ -60,19 +60,19 @@ def unpack(cls, data, code):
                 # So we add an empty octet.
                 data += bytearray.fromhex('00')
                 octet += 1
-            prefix_list = unpack("!%dH" % (octet / 2), data[1 : octet + 1])
+            prefix_list = unpack('!%dH' % (octet / 2), data[1 : octet + 1])
             prefix_list = [str(format(x, 'x')) for x in prefix_list]
             # fill out to a complete 128-bit address
-            prefix_list = prefix_list + ["0"] * (8 - len(prefix_list))
-            prefix = u":".join(prefix_list)
+            prefix_list = prefix_list + ['0'] * (8 - len(prefix_list))
+            prefix = ':'.join(prefix_list)
             prefix = ip_address(prefix).compressed
         else:
             # IPv4
-            prefix_list = unpack("!%dB" % octet, data[1 : octet + 1])
+            prefix_list = unpack('!%dB' % octet, data[1 : octet + 1])
             prefix_list = [str(x) for x in prefix_list]
             # fill the rest of the octets with 0 to construct
             # a 4 octet IP prefix
-            prefix_list = prefix_list + ["0"] * (4 - len(prefix_list))
+            prefix_list = prefix_list + ['0'] * (4 - len(prefix_list))
             prefix = '.'.join(prefix_list)
 
         return cls(prefix=prefix, plength=plength)
diff --git a/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/node.py b/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/node.py
index 2fc448235..094db71ce 100644
--- a/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/node.py
+++ b/src/exabgp/bgp/message/update/nlri/bgpls/tlvs/node.py
@@ -101,7 +101,7 @@ def unpack(cls, data, igp):
                 return cls(node_id, node_type, psn, dr_id, packed), remaining
 
         raise Exception(
-            "unknown node descriptor sub-tlv ({}, {})".format(
+            'unknown node descriptor sub-tlv ({}, {})'.format(
                 f'node-type: {node_type}',
                 f'igp: {igp}',
             )
diff --git a/src/exabgp/bgp/message/update/nlri/cidr.py b/src/exabgp/bgp/message/update/nlri/cidr.py
index 2063e7fbd..ec0bd642e 100644
--- a/src/exabgp/bgp/message/update/nlri/cidr.py
+++ b/src/exabgp/bgp/message/update/nlri/cidr.py
@@ -62,7 +62,7 @@ def __repr__(self):
         return self.prefix()
 
     def prefix(self):
-        return "%s/%s" % (self.top(), self.mask)
+        return '%s/%s' % (self.top(), self.mask)
 
     def index(self):
         return str(self.mask) + str(self._packed[: CIDR.size(self.mask)])
diff --git a/src/exabgp/bgp/message/update/nlri/evpn/ethernetad.py b/src/exabgp/bgp/message/update/nlri/evpn/ethernetad.py
index 1d1182b8f..e62024ab8 100644
--- a/src/exabgp/bgp/message/update/nlri/evpn/ethernetad.py
+++ b/src/exabgp/bgp/message/update/nlri/evpn/ethernetad.py
@@ -29,8 +29,8 @@
 @EVPN.register
 class EthernetAD(EVPN):
     CODE = 1
-    NAME = "Ethernet Auto-Discovery"
-    SHORT_NAME = "EthernetAD"
+    NAME = 'Ethernet Auto-Discovery'
+    SHORT_NAME = 'EthernetAD'
 
     def __init__(self, rd, esi, etag, label, packed=None, nexthop=None, action=None, addpath=None):
         EVPN.__init__(self, action, addpath)
@@ -54,7 +54,7 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s:%s:%s" % (self._prefix(), self.rd._str(), self.esi, self.etag, self.label)
+        return '%s:%s:%s:%s:%s' % (self._prefix(), self.rd._str(), self.esi, self.etag, self.label)
 
     def __hash__(self):
         # esi and label MUST *NOT* be part of the hash
diff --git a/src/exabgp/bgp/message/update/nlri/evpn/mac.py b/src/exabgp/bgp/message/update/nlri/evpn/mac.py
index 2501a1cca..3ae612c6c 100644
--- a/src/exabgp/bgp/message/update/nlri/evpn/mac.py
+++ b/src/exabgp/bgp/message/update/nlri/evpn/mac.py
@@ -41,8 +41,8 @@
 @EVPN.register
 class MAC(EVPN):
     CODE = 2
-    NAME = "MAC/IP advertisement"
-    SHORT_NAME = "MACAdv"
+    NAME = 'MAC/IP advertisement'
+    SHORT_NAME = 'MACAdv'
 
     def __init__(self, rd, esi, etag, mac, maclen, label, ip, packed=None, nexthop=None, action=None, addpath=None):
         EVPN.__init__(self, action, addpath)
@@ -75,14 +75,14 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s:%s:%s%s:%s:%s" % (
+        return '%s:%s:%s:%s:%s%s:%s:%s' % (
             self._prefix(),
             self.rd._str(),
             self.esi,
             self.etag,
             self.mac,
-            "" if len(self.mac) == 48 else "/%d" % self.maclen,
-            self.ip if self.ip else "",
+            '' if len(self.mac) == 48 else '/%d' % self.maclen,
+            self.ip if self.ip else '',
             self.label,
         )
 
@@ -132,14 +132,14 @@ def unpack(cls, data):
         if datalen in [33, 36]:  # No IP information (1 or 2 labels)
             iplenUnpack = 0
             if iplen != 0:
-                raise Notify(3, 5, "IP length is given as %d, but current MAC route has no IP information" % iplen)
+                raise Notify(3, 5, 'IP length is given as %d, but current MAC route has no IP information' % iplen)
         elif datalen in [37, 40]:  # Using IPv4 addresses (1 or 2 labels)
             iplenUnpack = 4
             if iplen > 32 or iplen < 0:
                 raise Notify(
                     3,
                     5,
-                    "IP field length is given as %d, but current MAC route is IPv4 and valus is out of range" % iplen,
+                    'IP field length is given as %d, but current MAC route is IPv4 and valus is out of range' % iplen,
                 )
         elif datalen in [49, 52]:  # Using IPv6 addresses (1 or 2 labels)
             iplenUnpack = 16
@@ -147,11 +147,11 @@ def unpack(cls, data):
                 raise Notify(
                     3,
                     5,
-                    "IP field length is given as %d, but current MAC route is IPv6 and valus is out of range" % iplen,
+                    'IP field length is given as %d, but current MAC route is IPv6 and valus is out of range' % iplen,
                 )
         else:
             raise Notify(
-                3, 5, "Data field length is given as %d, but does not match one of the expected lengths" % datalen
+                3, 5, 'Data field length is given as %d, but does not match one of the expected lengths' % datalen
             )
 
         payload = data[end + 1 : end + 1 + iplenUnpack]
diff --git a/src/exabgp/bgp/message/update/nlri/evpn/multicast.py b/src/exabgp/bgp/message/update/nlri/evpn/multicast.py
index 9e9a674e2..75d9875a1 100644
--- a/src/exabgp/bgp/message/update/nlri/evpn/multicast.py
+++ b/src/exabgp/bgp/message/update/nlri/evpn/multicast.py
@@ -29,8 +29,8 @@
 @EVPN.register
 class Multicast(EVPN):
     CODE = 3
-    NAME = "Inclusive Multicast Ethernet Tag"
-    SHORT_NAME = "Multicast"
+    NAME = 'Inclusive Multicast Ethernet Tag'
+    SHORT_NAME = 'Multicast'
 
     def __init__(self, rd, etag, ip, packed=None, nexthop=None, action=None, addpath=None):
         EVPN.__init__(self, action, addpath)
@@ -44,7 +44,7 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s:%s" % (
+        return '%s:%s:%s:%s' % (
             self._prefix(),
             self.rd._str(),
             self.etag,
@@ -71,7 +71,7 @@ def unpack(cls, data):
         etag = EthernetTag.unpack(data[8:12])
         iplen = data[12]
         if iplen not in (4 * 8, 16 * 8):
-            raise Exception("IP len is %d, but EVPN route currently support only IPv4" % iplen)
+            raise Exception('IP len is %d, but EVPN route currently support only IPv4' % iplen)
         ip = IP.unpack(data[13 : 13 + iplen // 8])
         return cls(rd, etag, ip, data)
 
diff --git a/src/exabgp/bgp/message/update/nlri/evpn/nlri.py b/src/exabgp/bgp/message/update/nlri/evpn/nlri.py
index 79972801c..3800acd5d 100644
--- a/src/exabgp/bgp/message/update/nlri/evpn/nlri.py
+++ b/src/exabgp/bgp/message/update/nlri/evpn/nlri.py
@@ -42,7 +42,7 @@ def __init__(self, action=Action.UNSET, addpath=None):
         self._packed = b''
 
     def __hash__(self):
-        return hash("%s:%s:%s:%s" % (self.afi, self.safi, self.CODE, self._packed))
+        return hash('%s:%s:%s:%s' % (self.afi, self.safi, self.CODE, self._packed))
 
     def __len__(self):
         return len(self._packed) + 2
@@ -51,7 +51,7 @@ def __eq__(self, other):
         return NLRI.__eq__(self, other) and self.CODE == other.CODE
 
     def __str__(self):
-        return "evpn:%s:%s" % (
+        return 'evpn:%s:%s' % (
             self.registered_evpn.get(self.CODE, self).SHORT_NAME.lower(),
             '0x' + ''.join('%02x' % _ for _ in self._packed),
         )
@@ -65,7 +65,7 @@ def feedback(self, action):
         return ''
 
     def _prefix(self):
-        return "evpn:%s:" % (self.registered_evpn.get(self.CODE, self).SHORT_NAME.lower())
+        return 'evpn:%s:' % (self.registered_evpn.get(self.CODE, self).SHORT_NAME.lower())
 
     def pack_nlri(self, negotiated=None):
         # XXX: addpath not supported yet
diff --git a/src/exabgp/bgp/message/update/nlri/evpn/prefix.py b/src/exabgp/bgp/message/update/nlri/evpn/prefix.py
index ebe5c0a98..a6d96449d 100644
--- a/src/exabgp/bgp/message/update/nlri/evpn/prefix.py
+++ b/src/exabgp/bgp/message/update/nlri/evpn/prefix.py
@@ -51,8 +51,8 @@
 @EVPN.register
 class Prefix(EVPN):
     CODE = 5
-    NAME = "IP Prefix Advertisement"
-    SHORT_NAME = "PrfxAdv"
+    NAME = 'IP Prefix Advertisement'
+    SHORT_NAME = 'PrfxAdv'
 
     def __init__(self, rd, esi, etag, label, ip, iplen, gwip, packed=None, nexthop=None, action=None, addpath=None):
         """
@@ -92,20 +92,20 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s:%s:%s%s:%s:%s" % (
+        return '%s:%s:%s:%s:%s%s:%s:%s' % (
             self._prefix(),
             self.rd._str(),
             self.esi,
             self.etag,
             self.ip,
-            "/%d" % self.iplen,
+            '/%d' % self.iplen,
             self.gwip,
             self.label,
         )
 
     def __hash__(self):
         # esi, and label, gwip must *not* be part of the hash
-        return hash("%s:%s:%s:%s" % (self.rd, self.etag, self.ip, self.iplen))
+        return hash('%s:%s:%s:%s' % (self.rd, self.etag, self.ip, self.iplen))
 
     def _pack(self, packed=None):
         if self._packed:
@@ -159,7 +159,7 @@ def unpack(cls, exdata):
             raise Notify(
                 3,
                 5,
-                "Data field length is given as %d, but EVPN route currently support only IPv4 or IPv6(34 or 58)"
+                'Data field length is given as %d, but EVPN route currently support only IPv4 or IPv6(34 or 58)'
                 % datalen,
             )
 
diff --git a/src/exabgp/bgp/message/update/nlri/evpn/segment.py b/src/exabgp/bgp/message/update/nlri/evpn/segment.py
index e7eb231c3..3eaeaa10c 100644
--- a/src/exabgp/bgp/message/update/nlri/evpn/segment.py
+++ b/src/exabgp/bgp/message/update/nlri/evpn/segment.py
@@ -33,8 +33,8 @@
 @EVPN.register
 class EthernetSegment(EVPN):
     CODE = 4
-    NAME = "Ethernet Segment"
-    SHORT_NAME = "Segment"
+    NAME = 'Ethernet Segment'
+    SHORT_NAME = 'Segment'
 
     def __init__(self, rd, esi, ip, packed=None, nexthop=None, action=None, addpath=None):
         EVPN.__init__(self, action, addpath)
@@ -57,7 +57,7 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s:%s" % (self._prefix(), self.rd._str(), self.esi, self.ip if self.ip else "")
+        return '%s:%s:%s:%s' % (self._prefix(), self.rd._str(), self.esi, self.ip if self.ip else '')
 
     def __hash__(self):
         # esi and label MUST *NOT* be part of the hash
@@ -91,7 +91,7 @@ def unpack(cls, data):
             raise Notify(
                 3,
                 5,
-                "IP length field is given as %d in current Segment, expecting 32 (IPv4) or 128 (IPv6) bits" % iplen,
+                'IP length field is given as %d in current Segment, expecting 32 (IPv4) or 128 (IPv6) bits' % iplen,
             )
 
         ip = IP.unpack(data[19 : 19 + (iplen // 8)])
diff --git a/src/exabgp/bgp/message/update/nlri/flow.py b/src/exabgp/bgp/message/update/nlri/flow.py
index ff1fc3f0e..f0ac4fd55 100644
--- a/src/exabgp/bgp/message/update/nlri/flow.py
+++ b/src/exabgp/bgp/message/update/nlri/flow.py
@@ -168,10 +168,10 @@ def pack(self):
         return bytes([self.ID, self.cidr.mask, self.offset]) + self.cidr.pack_ip()  # pylint: disable=E1101
 
     def short(self):
-        return "%s/%s" % (self.cidr, self.offset)
+        return '%s/%s' % (self.cidr, self.offset)
 
     def __str__(self):
-        return "%s/%s" % (self.cidr, self.offset)
+        return '%s/%s' % (self.cidr, self.offset)
 
     @classmethod
     def make(cls, bgp):
@@ -262,7 +262,7 @@ def short(self):
             return self._string[op]
         # ugly hack as dynamic languages are what they are and use used __str__ in the past
         value = self.value.short() if hasattr(self.value, 'short') else str(self.value)
-        return "%s%s" % (self._string.get(op, "%02X" % op), value)
+        return '%s%s' % (self._string.get(op, '%02X' % op), value)
 
     def __str__(self):
         return self.short()
@@ -286,7 +286,7 @@ class BinaryString(object):
 
     def short(self):
         op = self.operations & (CommonOperator.EOL ^ 0xFF)
-        return "%s%s" % (self._string.get(op, "%02X" % op), self.value)
+        return '%s%s' % (self._string.get(op, '%02X' % op), self.value)
 
     def __str__(self):
         return self.short()
@@ -315,7 +315,7 @@ def _inner(value):
 
 
 def PacketLength(data):
-    _str_bad_length = "cloudflare already found that invalid max-packet length for for you .."
+    _str_bad_length = 'cloudflare already found that invalid max-packet length for for you ..'
     number = int(data)
     if number > 0xFFFF:
         raise ValueError(_str_bad_length)
@@ -323,7 +323,7 @@ def PacketLength(data):
 
 
 def PortValue(data):
-    _str_bad_port = "you tried to set an invalid port number .."
+    _str_bad_port = 'you tried to set an invalid port number ..'
     try:
         number = Port.named(data)
     except ValueError:
@@ -332,7 +332,7 @@ def PortValue(data):
 
 
 def DSCPValue(data):
-    _str_bad_dscp = "you tried to filter a flow using an invalid dscp for a component .."
+    _str_bad_dscp = 'you tried to filter a flow using an invalid dscp for a component ..'
     number = int(data)
     if number < 0 or number > 0x3F:  # 0b00111111
         raise ValueError(_str_bad_dscp)
@@ -340,7 +340,7 @@ def DSCPValue(data):
 
 
 def ClassValue(data):
-    _str_bad_class = "you tried to filter a flow using an invalid traffic class for a component .."
+    _str_bad_class = 'you tried to filter a flow using an invalid traffic class for a component ..'
     number = int(data)
     if number < 0 or number > 0xFFFF:
         raise ValueError(_str_bad_class)
@@ -348,7 +348,7 @@ def ClassValue(data):
 
 
 def LabelValue(data):
-    _str_bad_label = "you tried to filter a flow using an invalid traffic label for a component .."
+    _str_bad_label = 'you tried to filter a flow using an invalid traffic label for a component ..'
     number = int(data)
     if number < 0 or number > 0xFFFFF:  # 20 bits 5 bytes
         raise ValueError(_str_bad_label)
@@ -591,7 +591,7 @@ def pack_nlri(self, negotiated=None):
         raise Notify(
             3,
             0,
-            "my administrator attempted to announce a Flow Spec rule larger than encoding allows, protecting the innocent the only way I can",
+            'my administrator attempted to announce a Flow Spec rule larger than encoding allows, protecting the innocent the only way I can',
         )
 
     def _rules(self):
diff --git a/src/exabgp/bgp/message/update/nlri/inet.py b/src/exabgp/bgp/message/update/nlri/inet.py
index 6abda6459..c3bf8829a 100644
--- a/src/exabgp/bgp/message/update/nlri/inet.py
+++ b/src/exabgp/bgp/message/update/nlri/inet.py
@@ -57,10 +57,10 @@ def index(self):
         return Family.index(self) + addpath + self.cidr.pack_nlri()
 
     def prefix(self):
-        return "%s%s" % (self.cidr.prefix(), str(self.path_info))
+        return '%s%s' % (self.cidr.prefix(), str(self.path_info))
 
     def extensive(self):
-        return "%s%s" % (self.prefix(), '' if self.nexthop is NoNextHop else ' next-hop %s' % self.nexthop)
+        return '%s%s' % (self.prefix(), '' if self.nexthop is NoNextHop else ' next-hop %s' % self.nexthop)
 
     def _internal(self, announced=True):
         return [self.path_info.json()]
@@ -68,7 +68,7 @@ def _internal(self, announced=True):
     # The announced feature is not used by ExaBGP, is it by BAGPIPE ?
 
     def json(self, announced=True, compact=False):
-        internal = ", ".join([_ for _ in self._internal(announced) if _])
+        internal = ', '.join([_ for _ in self._internal(announced) if _])
         if internal:
             return '{ "nlri": "%s", %s }' % (self.cidr.prefix(), internal)
         if compact:
@@ -94,7 +94,7 @@ def unpack_nlri(cls, afi, safi, bgp, action, addpath):
 
         if addpath:
             if len(bgp) <= 4:
-                raise ValueError("Trying to extract path-information but we do not have enough data")
+                raise ValueError('Trying to extract path-information but we do not have enough data')
             nlri.path_info = PathInfo(bgp[:4])
             bgp = bgp[4:]
 
diff --git a/src/exabgp/bgp/message/update/nlri/ipvpn.py b/src/exabgp/bgp/message/update/nlri/ipvpn.py
index 62e9dbb74..ed5763e6d 100644
--- a/src/exabgp/bgp/message/update/nlri/ipvpn.py
+++ b/src/exabgp/bgp/message/update/nlri/ipvpn.py
@@ -50,7 +50,7 @@ def new(cls, afi, safi, packed, mask, labels, rd, nexthop=None, action=Action.UN
         return instance
 
     def extensive(self):
-        return "%s%s" % (Label.extensive(self), str(self.rd))
+        return '%s%s' % (Label.extensive(self), str(self.rd))
 
     def __str__(self):
         return self.extensive()
diff --git a/src/exabgp/bgp/message/update/nlri/label.py b/src/exabgp/bgp/message/update/nlri/label.py
index 02b5c36a4..963d3bb0e 100644
--- a/src/exabgp/bgp/message/update/nlri/label.py
+++ b/src/exabgp/bgp/message/update/nlri/label.py
@@ -35,7 +35,7 @@ def feedback(self, action):
         return ''
 
     def extensive(self):
-        return "%s%s" % (self.prefix(), '' if self.nexthop is NoNextHop else ' next-hop %s' % self.nexthop)
+        return '%s%s' % (self.prefix(), '' if self.nexthop is NoNextHop else ' next-hop %s' % self.nexthop)
 
     def __str__(self):
         return self.extensive()
@@ -53,7 +53,7 @@ def __hash__(self):
         return hash(self.pack())
 
     def prefix(self):
-        return "%s%s" % (INET.prefix(self), self.labels)
+        return '%s%s' % (INET.prefix(self), self.labels)
 
     def pack(self, negotiated=None):
         addpath = self.path_info.pack() if negotiated and negotiated.addpath.send(self.afi, self.safi) else b''
diff --git a/src/exabgp/bgp/message/update/nlri/mup/dsd.py b/src/exabgp/bgp/message/update/nlri/mup/dsd.py
index 6cae5ffe6..2d97e23b9 100644
--- a/src/exabgp/bgp/message/update/nlri/mup/dsd.py
+++ b/src/exabgp/bgp/message/update/nlri/mup/dsd.py
@@ -24,8 +24,8 @@
 class DirectSegmentDiscoveryRoute(MUP):
     ARCHTYPE = 1
     CODE = 2
-    NAME = "DirectSegmentDiscoveryRoute"
-    SHORT_NAME = "DSD"
+    NAME = 'DirectSegmentDiscoveryRoute'
+    SHORT_NAME = 'DSD'
 
     def __init__(self, rd, ip, afi, packed=None):
         MUP.__init__(self, afi)
@@ -43,7 +43,7 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s" % (
+        return '%s:%s:%s' % (
             self._prefix(),
             self.rd._str(),
             self.ip,
@@ -74,7 +74,7 @@ def unpack(cls, data, afi):
         rd = RouteDistinguisher.unpack(data[:8])
         size = data_len - 8
         if size not in [4, 16]:
-            raise Notify(3, 5, "Invalid IP size, expect 4 or 16 octets. accuracy size %d" % size)
+            raise Notify(3, 5, 'Invalid IP size, expect 4 or 16 octets. accuracy size %d' % size)
         ip = IP.unpack(data[8 : 8 + size])
 
         return cls(rd, ip, afi)
diff --git a/src/exabgp/bgp/message/update/nlri/mup/isd.py b/src/exabgp/bgp/message/update/nlri/mup/isd.py
index 7b1924c0e..3ff8299ce 100644
--- a/src/exabgp/bgp/message/update/nlri/mup/isd.py
+++ b/src/exabgp/bgp/message/update/nlri/mup/isd.py
@@ -27,8 +27,8 @@
 class InterworkSegmentDiscoveryRoute(MUP):
     ARCHTYPE = 1
     CODE = 1
-    NAME = "InterworkSegmentDiscoveryRoute"
-    SHORT_NAME = "ISD"
+    NAME = 'InterworkSegmentDiscoveryRoute'
+    SHORT_NAME = 'ISD'
 
     def __init__(self, rd, prefix_ip_len, prefix_ip, afi, packed=None):
         MUP.__init__(self, afi)
@@ -52,7 +52,7 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s%s" % (self._prefix(), self.rd._str(), self.prefix_ip, "/%d" % self.prefix_ip_len)
+        return '%s:%s:%s%s' % (self._prefix(), self.rd._str(), self.prefix_ip, '/%d' % self.prefix_ip_len)
 
     def __hash__(self):
         return hash((self.rd, self.prefix_ip_len, self.prefix_ip))
diff --git a/src/exabgp/bgp/message/update/nlri/mup/nlri.py b/src/exabgp/bgp/message/update/nlri/mup/nlri.py
index 0f1327b18..a88c6fe49 100644
--- a/src/exabgp/bgp/message/update/nlri/mup/nlri.py
+++ b/src/exabgp/bgp/message/update/nlri/mup/nlri.py
@@ -5,6 +5,7 @@
 Created by Takeru Hayasaka on 2023-01-21.
 Copyright (c) 2023 BBSakura Networks Inc. All rights reserved.
 """
+
 from struct import pack
 from exabgp.protocol.family import AFI
 from exabgp.protocol.family import SAFI
@@ -40,7 +41,7 @@ def __init__(self, afi, action=Action.ANNOUNCE):
         self._packed = b''
 
     def __hash__(self):
-        return hash("%s:%s:%s:%s:%s" % (self.afi, self.safi, self.ARCHTYPE, self.CODE, self._packed))
+        return hash('%s:%s:%s:%s:%s' % (self.afi, self.safi, self.ARCHTYPE, self.CODE, self._packed))
 
     def __len__(self):
         return len(self._packed) + 2
@@ -49,7 +50,7 @@ def __eq__(self, other):
         return NLRI.__eq__(self, other) and self.CODE == other.CODE
 
     def __str__(self):
-        return "mup:%s:%s" % (
+        return 'mup:%s:%s' % (
             self.registered.get(self.CODE, self).SHORT_NAME.lower(),
             '0x' + ''.join('%02x' % _ for _ in self._packed),
         )
@@ -61,14 +62,14 @@ def feedback(self, action):
         return ''
 
     def _prefix(self):
-        return "mup:%s:" % (self.registered.get(self.CODE, self).SHORT_NAME.lower())
+        return 'mup:%s:' % (self.registered.get(self.CODE, self).SHORT_NAME.lower())
 
     def pack_nlri(self, negotiated=None):
         return pack('!BHB', self.ARCHTYPE, self.CODE, len(self._packed)) + self._packed
 
     @classmethod
     def register(cls, klass):
-        key = "%s:%s" % (klass.ARCHTYPE, klass.CODE)
+        key = '%s:%s' % (klass.ARCHTYPE, klass.CODE)
         if key in cls.registered:
             raise RuntimeError('only one Mup registration allowed')
         cls.registered[key] = klass
@@ -77,12 +78,12 @@ def register(cls, klass):
     @classmethod
     def unpack_nlri(cls, afi, safi, bgp, action, addpath):
         arch = bgp[0]
-        code = int.from_bytes(bgp[1:3], "big")
+        code = int.from_bytes(bgp[1:3], 'big')
         length = bgp[3]
 
         # arch and code byte size is 4 byte
         end = length + 4
-        key = "%s:%s" % (arch, code)
+        key = '%s:%s' % (arch, code)
         if key in cls.registered:
             klass = cls.registered[key].unpack(bgp[4:end], afi)
         else:
diff --git a/src/exabgp/bgp/message/update/nlri/mup/t1st.py b/src/exabgp/bgp/message/update/nlri/mup/t1st.py
index 79f3d776f..e94145a1b 100644
--- a/src/exabgp/bgp/message/update/nlri/mup/t1st.py
+++ b/src/exabgp/bgp/message/update/nlri/mup/t1st.py
@@ -44,8 +44,8 @@
 class Type1SessionTransformedRoute(MUP):
     ARCHTYPE = 1
     CODE = 3
-    NAME = "Type1SessionTransformedRoute"
-    SHORT_NAME = "T1ST"
+    NAME = 'Type1SessionTransformedRoute'
+    SHORT_NAME = 'T1ST'
 
     def __init__(
         self,
@@ -93,19 +93,19 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        s = "%s:%s:%s%s:%s:%s:%s%s" % (
+        s = '%s:%s:%s%s:%s:%s:%s%s' % (
             self._prefix(),
             self.rd._str(),
             self.prefix_ip,
-            "/%d" % self.prefix_ip_len,
+            '/%d' % self.prefix_ip_len,
             self.teid,
             self.qfi,
             self.endpoint_ip,
-            "/%d" % self.prefix_ip_len,
+            '/%d' % self.prefix_ip_len,
         )
 
         if self.source_ip_len != 0 and self.source_ip != b'':
-            s += ":%s/%d" % (self.source_ip, self.source_ip_len)
+            s += ':%s/%d' % (self.source_ip, self.source_ip_len)
 
         return s
 
@@ -182,7 +182,7 @@ def unpack(cls, data, afi):
         size = ip_offset
         prefix_ip = IP.unpack(ip)
         size += 9
-        teid = int.from_bytes(data[size : size + 4], "big")
+        teid = int.from_bytes(data[size : size + 4], 'big')
         size += 4
         qfi = data[size]
         size += 1
diff --git a/src/exabgp/bgp/message/update/nlri/mup/t2st.py b/src/exabgp/bgp/message/update/nlri/mup/t2st.py
index 4c8014ef0..a131ad7aa 100644
--- a/src/exabgp/bgp/message/update/nlri/mup/t2st.py
+++ b/src/exabgp/bgp/message/update/nlri/mup/t2st.py
@@ -35,8 +35,8 @@
 class Type2SessionTransformedRoute(MUP):
     ARCHTYPE = 1
     CODE = 4
-    NAME = "Type2SessionTransformedRoute"
-    SHORT_NAME = "T2ST"
+    NAME = 'Type2SessionTransformedRoute'
+    SHORT_NAME = 'T2ST'
 
     def __init__(self, rd, endpoint_len, endpoint_ip, teid, afi, packed=None):
         MUP.__init__(self, afi)
@@ -62,7 +62,7 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
-        return "%s:%s:%s:%s:%s:" % (
+        return '%s:%s:%s:%s:%s:' % (
             self._prefix(),
             self.rd._str(),
             self.endpoint_len,
@@ -100,7 +100,7 @@ def _pack(self, packed=None):
         teid_size = self.endpoint_len - endpoint_size
 
         if teid_size < 0 or teid_size > 32:
-            raise Exception("teid is too large %d (range 0~32)" % teid_size)
+            raise Exception('teid is too large %d (range 0~32)' % teid_size)
 
         teid_packed = pack('!I', self.teid)
 
@@ -129,11 +129,11 @@ def unpack(cls, data, afi):
         if endpoint_len > afi_bit_size:
             teid_len = endpoint_len - afi_bit_size
             if afi == AFI.ipv4 and teid_len > 32:
-                raise Exception("endpoint length is too large %d (max 64 for Ipv4)" % endpoint_len)
+                raise Exception('endpoint length is too large %d (max 64 for Ipv4)' % endpoint_len)
             if afi == AFI.ipv6 and teid_len > 32:
-                raise Exception("endpoint length is too large %d (max 160 for Ipv6)" % endpoint_len)
+                raise Exception('endpoint length is too large %d (max 160 for Ipv6)' % endpoint_len)
 
-            teid = int.from_bytes(data[end:], "big")
+            teid = int.from_bytes(data[end:], 'big')
 
         return cls(rd, endpoint_len, endpoint_ip, teid, afi)
 
diff --git a/src/exabgp/bgp/message/update/nlri/mvpn/nlri.py b/src/exabgp/bgp/message/update/nlri/mvpn/nlri.py
index f5c277402..78dd664ad 100644
--- a/src/exabgp/bgp/message/update/nlri/mvpn/nlri.py
+++ b/src/exabgp/bgp/message/update/nlri/mvpn/nlri.py
@@ -35,7 +35,7 @@ def __init__(self, afi, action=Action.UNSET, addpath=None):
         self._packed = b''
 
     def __hash__(self):
-        return hash("%s:%s:%s:%s" % (self.afi, self.safi, self.CODE, self._packed))
+        return hash('%s:%s:%s:%s' % (self.afi, self.safi, self.CODE, self._packed))
 
     def __len__(self):
         return len(self._packed) + 2
@@ -44,7 +44,7 @@ def __eq__(self, other):
         return NLRI.__eq__(self, other) and self.CODE == other.CODE
 
     def __str__(self):
-        return "mvpn:%s:%s" % (
+        return 'mvpn:%s:%s' % (
             self.registered_mvpn.get(self.CODE, self).SHORT_NAME.lower(),
             '0x' + ''.join('%02x' % _ for _ in self._packed),
         )
@@ -58,7 +58,7 @@ def feedback(self, action):
         return ''
 
     def _prefix(self):
-        return "mvpn:%s:" % (self.registered_mvpn.get(self.CODE, self).SHORT_NAME.lower())
+        return 'mvpn:%s:' % (self.registered_mvpn.get(self.CODE, self).SHORT_NAME.lower())
 
     def pack_nlri(self, negotiated=None):
         # XXX: addpath not supported yet
diff --git a/src/exabgp/bgp/message/update/nlri/mvpn/sharedjoin.py b/src/exabgp/bgp/message/update/nlri/mvpn/sharedjoin.py
index ba3367367..6e5a6b9fe 100644
--- a/src/exabgp/bgp/message/update/nlri/mvpn/sharedjoin.py
+++ b/src/exabgp/bgp/message/update/nlri/mvpn/sharedjoin.py
@@ -22,8 +22,8 @@
 @MVPN.register
 class SharedJoin(MVPN):
     CODE = 6
-    NAME = "C-Multicast Shared Tree Join route"
-    SHORT_NAME = "Shared-Join"
+    NAME = 'C-Multicast Shared Tree Join route'
+    SHORT_NAME = 'Shared-Join'
 
     def __init__(self, rd, afi, source, group, source_as, packed=None, action=None, addpath=None):
         MVPN.__init__(self, afi=afi, action=action, addpath=addpath)
@@ -72,11 +72,11 @@ def _pack(self, packed=None):
     def unpack(cls, data, afi):
         datalen = len(data)
         if datalen not in (22, 46):  # IPv4 or IPv6
-            raise Notify(3, 5, f"Invalid C-Multicast Route length ({datalen} bytes).")
+            raise Notify(3, 5, f'Invalid C-Multicast Route length ({datalen} bytes).')
         cursor = 0
         rd = RouteDistinguisher.unpack(data[cursor:8])
         cursor += 8
-        source_as = int.from_bytes(data[cursor : cursor + 4], "big")
+        source_as = int.from_bytes(data[cursor : cursor + 4], 'big')
         cursor += 4
         sourceiplen = int(data[cursor] / 8)
         cursor += 1
@@ -84,7 +84,7 @@ def unpack(cls, data, afi):
             raise Notify(
                 3,
                 5,
-                f"Invalid C-Multicast Route length ({sourceiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).",
+                f'Invalid C-Multicast Route length ({sourceiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).',
             )
         sourceip = IP.unpack(data[cursor : cursor + sourceiplen])
         cursor += sourceiplen
@@ -94,7 +94,7 @@ def unpack(cls, data, afi):
             raise Notify(
                 3,
                 5,
-                f"Invalid C-Multicast Route length ({groupiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).",
+                f'Invalid C-Multicast Route length ({groupiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).',
             )
         groupip = IP.unpack(data[cursor : cursor + groupiplen])
         return cls(afi=afi, rd=rd, source=sourceip, group=groupip, source_as=source_as, packed=data)
diff --git a/src/exabgp/bgp/message/update/nlri/mvpn/sourcead.py b/src/exabgp/bgp/message/update/nlri/mvpn/sourcead.py
index 301b21e59..20a9fdb30 100644
--- a/src/exabgp/bgp/message/update/nlri/mvpn/sourcead.py
+++ b/src/exabgp/bgp/message/update/nlri/mvpn/sourcead.py
@@ -19,8 +19,8 @@
 @MVPN.register
 class SourceAD(MVPN):
     CODE = 5
-    NAME = "Source Active A-D Route"
-    SHORT_NAME = "SourceAD"
+    NAME = 'Source Active A-D Route'
+    SHORT_NAME = 'SourceAD'
 
     def __init__(self, rd, afi, source, group, packed=None, action=None, addpath=None):
         MVPN.__init__(self, afi=afi, action=action, addpath=addpath)
@@ -67,7 +67,7 @@ def _pack(self, packed=None):
     def unpack(cls, data, afi):
         datalen = len(data)
         if datalen not in (18, 42):  # IPv4 or IPv6
-            raise Notify(3, 5, f"Unsupported Source Active A-D route length ({datalen} bytes).")
+            raise Notify(3, 5, f'Unsupported Source Active A-D route length ({datalen} bytes).')
         cursor = 0
         rd = RouteDistinguisher.unpack(data[cursor:8])
         cursor += 8
@@ -77,7 +77,7 @@ def unpack(cls, data, afi):
             raise Notify(
                 3,
                 5,
-                f"Unsupported Source Active A-D Route Multicast Source IP length ({sourceiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).",
+                f'Unsupported Source Active A-D Route Multicast Source IP length ({sourceiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).',
             )
         sourceip = IP.unpack(data[cursor : cursor + sourceiplen])
         cursor += sourceiplen
@@ -87,7 +87,7 @@ def unpack(cls, data, afi):
             raise Notify(
                 3,
                 5,
-                f"Unsupported Source Active A-D Route Multicast Group IP length ({groupiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).",
+                f'Unsupported Source Active A-D Route Multicast Group IP length ({groupiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).',
             )
         groupip = IP.unpack(data[cursor : cursor + groupiplen])
 
diff --git a/src/exabgp/bgp/message/update/nlri/mvpn/sourcejoin.py b/src/exabgp/bgp/message/update/nlri/mvpn/sourcejoin.py
index 394adb7f1..1bd0da4f7 100644
--- a/src/exabgp/bgp/message/update/nlri/mvpn/sourcejoin.py
+++ b/src/exabgp/bgp/message/update/nlri/mvpn/sourcejoin.py
@@ -22,8 +22,8 @@
 @MVPN.register
 class SourceJoin(MVPN):
     CODE = 7
-    NAME = "C-Multicast Source Tree Join route"
-    SHORT_NAME = "Source-Join"
+    NAME = 'C-Multicast Source Tree Join route'
+    SHORT_NAME = 'Source-Join'
 
     def __init__(self, rd, afi, source, group, source_as, packed=None, action=None, addpath=None):
         MVPN.__init__(self, afi=afi, action=action, addpath=addpath)
@@ -72,11 +72,11 @@ def _pack(self, packed=None):
     def unpack(cls, data, afi):
         datalen = len(data)
         if datalen not in (22, 46):  # IPv4 or IPv6
-            raise Notify(3, 5, f"Invalid C-Multicast Route length ({datalen} bytes).")
+            raise Notify(3, 5, f'Invalid C-Multicast Route length ({datalen} bytes).')
         cursor = 0
         rd = RouteDistinguisher.unpack(data[cursor:8])
         cursor += 8
-        source_as = int.from_bytes(data[cursor : cursor + 4], "big")
+        source_as = int.from_bytes(data[cursor : cursor + 4], 'big')
         cursor += 4
         sourceiplen = int(data[cursor] / 8)
         cursor += 1
@@ -84,7 +84,7 @@ def unpack(cls, data, afi):
             raise Notify(
                 3,
                 5,
-                f"Invalid C-Multicast Route length ({sourceiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).",
+                f'Invalid C-Multicast Route length ({sourceiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).',
             )
         sourceip = IP.unpack(data[cursor : cursor + sourceiplen])
         cursor += sourceiplen
@@ -94,7 +94,7 @@ def unpack(cls, data, afi):
             raise Notify(
                 3,
                 5,
-                f"Invalid C-Multicast Route length ({groupiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).",
+                f'Invalid C-Multicast Route length ({groupiplen*8} bits). Expected 32 bits (IPv4) or 128 bits (IPv6).',
             )
         groupip = IP.unpack(data[cursor : cursor + groupiplen])
         return cls(afi=afi, rd=rd, source=sourceip, group=groupip, source_as=source_as, packed=data)
diff --git a/src/exabgp/bgp/message/update/nlri/nlri.py b/src/exabgp/bgp/message/update/nlri/nlri.py
index 6ce8a7b44..d3b2907df 100644
--- a/src/exabgp/bgp/message/update/nlri/nlri.py
+++ b/src/exabgp/bgp/message/update/nlri/nlri.py
@@ -28,7 +28,7 @@ def __init__(self, afi, safi, action=Action.UNSET):
         self.action = action
 
     def __hash__(self):
-        return hash("%s:%s:%s" % (self.afi, self.safi, self.pack_nlri()))
+        return hash('%s:%s:%s' % (self.afi, self.safi, self.pack_nlri()))
 
     def __eq__(self, other):
         return self.index() == other.index()
diff --git a/src/exabgp/bgp/message/update/nlri/qualifier/esi.py b/src/exabgp/bgp/message/update/nlri/qualifier/esi.py
index 7a683cf1f..7e0ad7c0e 100644
--- a/src/exabgp/bgp/message/update/nlri/qualifier/esi.py
+++ b/src/exabgp/bgp/message/update/nlri/qualifier/esi.py
@@ -20,7 +20,7 @@ class ESI(object):
     def __init__(self, esi=None):
         self.esi = self.DEFAULT if esi is None else esi
         if len(self.esi) != 10:
-            raise Exception("incorrect ESI, len %d instead of 10" % len(esi))
+            raise Exception('incorrect ESI, len %d instead of 10' % len(esi))
 
     def __eq__(self, other):
         return self.esi == other.esi
@@ -42,8 +42,8 @@ def __ge__(self, other):
 
     def __str__(self):
         if self.esi == self.DEFAULT:
-            return "-"
-        return ":".join('%02x' % _ for _ in self.esi)
+            return '-'
+        return ':'.join('%02x' % _ for _ in self.esi)
 
     def __repr__(self):
         return self.__str__()
diff --git a/src/exabgp/bgp/message/update/nlri/qualifier/etag.py b/src/exabgp/bgp/message/update/nlri/qualifier/etag.py
index 60ba66482..d3affd596 100644
--- a/src/exabgp/bgp/message/update/nlri/qualifier/etag.py
+++ b/src/exabgp/bgp/message/update/nlri/qualifier/etag.py
@@ -46,7 +46,7 @@ def __repr__(self):
         return repr(self.tag)
 
     def pack(self):
-        return pack("!L", self.tag)
+        return pack('!L', self.tag)
 
     def __len__(self):
         return 4
@@ -56,7 +56,7 @@ def __hash__(self):
 
     @classmethod
     def unpack(cls, data):
-        return cls(unpack("!L", data[:4])[0])
+        return cls(unpack('!L', data[:4])[0])
 
     def json(self, compact=None):
         return '"ethernet-tag": %s' % self.tag
diff --git a/src/exabgp/bgp/message/update/nlri/qualifier/labels.py b/src/exabgp/bgp/message/update/nlri/qualifier/labels.py
index 1dcb2bb9d..94ed2feb2 100644
--- a/src/exabgp/bgp/message/update/nlri/qualifier/labels.py
+++ b/src/exabgp/bgp/message/update/nlri/qualifier/labels.py
@@ -72,7 +72,7 @@ def __len__(self):
     def json(self):
         if len(self.labels) >= 1:
             return '"label": [ %s ]' % ', '.join(
-                ["[%d%s]" % (label, opt_raw_label(raw, ', %d')) for (label, raw) in zip(self.labels, self.raw_labels)]
+                ['[%d%s]' % (label, opt_raw_label(raw, ', %d')) for (label, raw) in zip(self.labels, self.raw_labels)]
             )
         else:
             return ''
@@ -80,7 +80,7 @@ def json(self):
     def __str__(self):
         if len(self.labels) > 1:
             return ' label [ %s ]' % ' '.join(
-                ["%d%s" % (label, opt_raw_label(raw)) for (label, raw) in zip(self.labels, self.raw_labels)]
+                ['%d%s' % (label, opt_raw_label(raw)) for (label, raw) in zip(self.labels, self.raw_labels)]
             )
         elif len(self.labels) == 1:
             return ' label %d%s' % (self.labels[0], opt_raw_label(self.raw_labels[0]))
@@ -89,7 +89,9 @@ def __str__(self):
 
     def __repr__(self):
         if len(self.labels) > 1:
-            return '[ %s ]' % ','.join(["%d%s" % (label, opt_raw_label(raw)) for (label, raw) in zip(self.labels, self.raw_labels)])
+            return '[ %s ]' % ','.join(
+                ['%d%s' % (label, opt_raw_label(raw)) for (label, raw) in zip(self.labels, self.raw_labels)]
+            )
         elif len(self.labels) == 1:
             return '%d%s' % (self.labels[0], opt_raw_label(self.raw_labels[0]))
         else:
diff --git a/src/exabgp/bgp/message/update/nlri/qualifier/mac.py b/src/exabgp/bgp/message/update/nlri/qualifier/mac.py
index 032c47783..89d81ddea 100644
--- a/src/exabgp/bgp/message/update/nlri/qualifier/mac.py
+++ b/src/exabgp/bgp/message/update/nlri/qualifier/mac.py
@@ -16,7 +16,7 @@
 class MAC(object):
     def __init__(self, mac=None, packed=None):
         self.mac = mac
-        self._packed = packed if packed else b''.join(bytes([int(_, 16)]) for _ in mac.split(":"))
+        self._packed = packed if packed else b''.join(bytes([int(_, 16)]) for _ in mac.split(':'))
 
     def __eq__(self, other):
         return self.mac == other.mac
diff --git a/src/exabgp/bgp/message/update/nlri/rtc.py b/src/exabgp/bgp/message/update/nlri/rtc.py
index f8dc3a189..66aa8dc8e 100644
--- a/src/exabgp/bgp/message/update/nlri/rtc.py
+++ b/src/exabgp/bgp/message/update/nlri/rtc.py
@@ -53,7 +53,7 @@ def __len__(self):
         return (4 + len(self.rt)) * 8 if self.rt else 1
 
     def __str__(self):
-        return "rtc %s:%s" % (self.origin, self.rt) if self.rt else "rtc wildcard"
+        return 'rtc %s:%s' % (self.origin, self.rt) if self.rt else 'rtc wildcard'
 
     def __repr__(self):
         return str(self)
@@ -68,8 +68,8 @@ def pack_nlri(self, negotiated=None):
         # because in an RTC route these flags never appear.
         if self.rt:
             packedRT = self.rt.pack()
-            return pack("!BLB", len(self), self.origin, RTC.resetFlags(packedRT[0])) + packedRT[1:]
-        return pack("!B", 0)
+            return pack('!BLB', len(self), self.origin, RTC.resetFlags(packedRT[0])) + packedRT[1:]
+        return pack('!B', 0)
 
     @classmethod
     def unpack_nlri(cls, afi, safi, bgp, action, addpath):
@@ -79,7 +79,7 @@ def unpack_nlri(cls, afi, safi, bgp, action, addpath):
             return cls(afi, safi, action, ASN(0), None), bgp[1:]
 
         if length < 8 * 4:
-            raise Exception("incorrect RT length: %d (should be >=32,<=96)" % length)
+            raise Exception('incorrect RT length: %d (should be >=32,<=96)' % length)
 
         # We are reseting the flags on the RouteTarget extended
         # community, because they do not make sense for an RTC route
diff --git a/src/exabgp/bgp/message/update/nlri/vpls.py b/src/exabgp/bgp/message/update/nlri/vpls.py
index bf5f285ad..2b2daff57 100644
--- a/src/exabgp/bgp/message/update/nlri/vpls.py
+++ b/src/exabgp/bgp/message/update/nlri/vpls.py
@@ -85,7 +85,7 @@ def json(self, compact=None):
         return '{ %s }' % (content)
 
     def extensive(self):
-        return "vpls%s endpoint %s base %s offset %s size %s %s" % (
+        return 'vpls%s endpoint %s base %s offset %s size %s %s' % (
             self.rd,
             self.endpoint,
             self.base,
diff --git a/src/exabgp/bgp/neighbor.py b/src/exabgp/bgp/neighbor.py
index d513a30b0..0547272dc 100644
--- a/src/exabgp/bgp/neighbor.py
+++ b/src/exabgp/bgp/neighbor.py
@@ -179,10 +179,10 @@ def clear_rib(self):
 
     def name(self):
         if self['capability']['multi-session']:
-            session = '/'.join("%s-%s" % (afi.name(), safi.name()) for (afi, safi) in self.families())
+            session = '/'.join('%s-%s' % (afi.name(), safi.name()) for (afi, safi) in self.families())
         else:
             session = 'in-open'
-        return "neighbor %s local-ip %s local-as %s peer-as %s router-id %s family-allowed %s" % (
+        return 'neighbor %s local-ip %s local-as %s peer-as %s router-id %s family-allowed %s' % (
             self['peer-address'],
             self['local-address'] if self['peer-address'] is not None else 'auto',
             self['local-as'] if self['local-as'] is not None else 'auto',
@@ -335,12 +335,12 @@ def _pr(value):
 
 def _addpath(send, receive):
     if send and receive:
-        return "send/receive"
+        return 'send/receive'
     if send:
-        return "send"
+        return 'send'
     if receive:
-        return "receive"
-    return "disabled"
+        return 'receive'
+    return 'disabled'
 
 
 class NeighborTemplate(object):
@@ -366,9 +366,7 @@ class NeighborTemplate(object):
 
     Message Statistic                Sent        Received
 %(messages)s
-""".replace(
-        '\t', '  '
-    )
+""".replace('\t', '  ')
 
     summary_header = 'Peer            AS        up/down state       |     #sent     #recvd'
     summary_template = '%-15s %-7s %9s %-12s %10d %10d'
@@ -523,18 +521,28 @@ def configuration(cls, neighbor, with_changes=True):
                 '\tadj-rib-out %s;\n' % ('true' if neighbor['adj-rib-out'] else 'false'),
                 '\tmd5-password "%s";\n' % neighbor['md5-password'] if neighbor['md5-password'] else '',
                 '\tmd5-base64 %s;\n'
-                % ('true' if neighbor['md5-base64'] is True else 'false' if neighbor['md5-base64'] is False else 'auto'),
+                % (
+                    'true' if neighbor['md5-base64'] is True else 'false' if neighbor['md5-base64'] is False else 'auto'
+                ),
                 '\tmd5-ip "%s";\n' % neighbor['md5-ip'] if not neighbor.auto_discovery else '',
                 '\toutgoing-ttl %s;\n' % neighbor['outgoing-ttl'] if neighbor['outgoing-ttl'] else '',
                 '\tincoming-ttl %s;\n' % neighbor['incoming-ttl'] if neighbor['incoming-ttl'] else '',
                 '\t\tasn4 %s;\n' % ('enable' if neighbor['capability']['asn4'] else 'disable'),
                 '\t\troute-refresh %s;\n' % ('enable' if neighbor['capability']['route-refresh'] else 'disable'),
                 '\t\tgraceful-restart %s;\n'
-                % (neighbor['capability']['graceful-restart'] if neighbor['capability']['graceful-restart'] else 'disable'),
+                % (
+                    neighbor['capability']['graceful-restart']
+                    if neighbor['capability']['graceful-restart']
+                    else 'disable'
+                ),
                 '\t\tsoftware-version %s;\n' % ('enable' if neighbor['capability']['software-version'] else 'disable'),
                 '\t\tnexthop %s;\n' % ('enable' if neighbor['capability']['nexthop'] else 'disable'),
                 '\t\tadd-path %s;\n'
-                % (AddPath.string[neighbor['capability']['add-path']] if neighbor['capability']['add-path'] else 'disable'),
+                % (
+                    AddPath.string[neighbor['capability']['add-path']]
+                    if neighbor['capability']['add-path']
+                    else 'disable'
+                ),
                 '\t\tmulti-session %s;\n' % ('enable' if neighbor['capability']['multi-session'] else 'disable'),
                 '\t\toperational %s;\n' % ('enable' if neighbor['capability']['operational'] else 'disable'),
                 '\t\taigp %s;\n' % ('enable' if neighbor['capability']['aigp'] else 'disable'),
@@ -550,7 +558,6 @@ def configuration(cls, neighbor, with_changes=True):
         # '\t\tsend {\n%s\t\t}\n' % send if send else '',
         return returned.replace('\t', '  ')
 
-
     @classmethod
     def as_dict(cls, answer):
         up = answer['duration']
@@ -638,7 +645,7 @@ def formated_dict(cls, answer):
 
     @classmethod
     def to_json(cls, answer):
-       return json.dumps(cls.formated_dict(answer)) 
+        return json.dumps(cls.formated_dict(answer))
 
     @classmethod
     def extensive(cls, answer):
@@ -654,4 +661,3 @@ def summary(cls, answer):
             answer['messages']['update'][0],
             answer['messages']['update'][1],
         )
-
diff --git a/src/exabgp/cli/main.py b/src/exabgp/cli/main.py
index 4cc5d66a6..4da51fe52 100755
--- a/src/exabgp/cli/main.py
+++ b/src/exabgp/cli/main.py
@@ -29,7 +29,7 @@
 from exabgp.conf import Config
 
 corrections = {
-    "neighbour": "neighbor",
+    'neighbour': 'neighbor',
 }
 
 
@@ -40,10 +40,10 @@
 
 def main():
     parser = argparse.ArgumentParser(description='configure ExaBGP')
-    parser.add_argument('--load', type=str, help="configuration file to load")
-    parser.add_argument('--commit', action='store_true', help="commit the configuration on load")
-    parser.add_argument('--show', action='store_true', help="show loaded configuration")
-    parser.add_argument('--no-cli', action='store_true', help="do not start the cli")
+    parser.add_argument('--load', type=str, help='configuration file to load')
+    parser.add_argument('--commit', action='store_true', help='commit the configuration on load')
+    parser.add_argument('--show', action='store_true', help='show loaded configuration')
+    parser.add_argument('--no-cli', action='store_true', help='do not start the cli')
     arg = parser.parse_args()
 
     # if True:
diff --git a/src/exabgp/cli/test.py b/src/exabgp/cli/test.py
index 12208e81a..b86e81cb8 100755
--- a/src/exabgp/cli/test.py
+++ b/src/exabgp/cli/test.py
@@ -4,6 +4,7 @@
 from vyos.cli.completer import VyOSCompleter
 from vyos.cli.validator import VyOSValidator
 from vyos.cli.validator import ValidationError
+
 # from vyos.cli.command import dispatch
 from vyos.cli import msg
 
diff --git a/src/exabgp/conf/yang/code.py b/src/exabgp/conf/yang/code.py
index 1a78520c0..b20eaad52 100644
--- a/src/exabgp/conf/yang/code.py
+++ b/src/exabgp/conf/yang/code.py
@@ -13,8 +13,8 @@
 # is used to generate code from the AST created
 
 from ast import Module, Import, FunctionDef, arguments, arg, alias
-from ast import Load, Call, Return, Name, Attribute, Constant #, Param
-from ast import If, Compare, Gt, Lt, And #, Add, GtE, LtE, Or
+from ast import Load, Call, Return, Name, Attribute, Constant  # , Param
+from ast import If, Compare, Gt, Lt, And  # , Add, GtE, LtE, Or
 from ast import BoolOp, UnaryOp, Not, USub
 
 # import astunparse
diff --git a/src/exabgp/conf/yang/generate.py b/src/exabgp/conf/yang/generate.py
index 87b74026f..ce1c4c007 100755
--- a/src/exabgp/conf/yang/generate.py
+++ b/src/exabgp/conf/yang/generate.py
@@ -74,5 +74,5 @@ def main():
     gen.save()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/src/exabgp/conf/yang/model.py b/src/exabgp/conf/yang/model.py
index f7667f747..ff46711f2 100644
--- a/src/exabgp/conf/yang/model.py
+++ b/src/exabgp/conf/yang/model.py
@@ -79,7 +79,7 @@ def fetch(self, module):
             if not site:
                 raise RuntimeError('unimplemented namespace case')
 
-            url = f"{site}/{yang}"
+            url = f'{site}/{yang}'
         else:
             raise RuntimeError('unimplemented yang-library case')
 
diff --git a/src/exabgp/configuration/announce/mup.py b/src/exabgp/configuration/announce/mup.py
index 2f9c75d71..49b9cbe6a 100644
--- a/src/exabgp/configuration/announce/mup.py
+++ b/src/exabgp/configuration/announce/mup.py
@@ -76,16 +76,16 @@ def check(self):
 
 def mup(tokeniser, afi, safi):
     muptype = tokeniser()
-    if "mup-isd" == muptype:
+    if 'mup-isd' == muptype:
         mup_nlri = srv6_mup_isd(tokeniser, afi)
-    elif "mup-dsd" == muptype:
+    elif 'mup-dsd' == muptype:
         mup_nlri = srv6_mup_dsd(tokeniser, afi)
-    elif "mup-t1st" == muptype:
+    elif 'mup-t1st' == muptype:
         mup_nlri = srv6_mup_t1st(tokeniser, afi)
-    elif "mup-t2st" == muptype:
+    elif 'mup-t2st' == muptype:
         mup_nlri = srv6_mup_t2st(tokeniser, afi)
     else:
-        raise ValueError("mup: unknown mup type: %s" % muptype)
+        raise ValueError('mup: unknown mup type: %s' % muptype)
 
     change = Change(mup_nlri, Attributes())
     while True:
diff --git a/src/exabgp/configuration/announce/mvpn.py b/src/exabgp/configuration/announce/mvpn.py
index 9393b5772..8351a6522 100644
--- a/src/exabgp/configuration/announce/mvpn.py
+++ b/src/exabgp/configuration/announce/mvpn.py
@@ -71,7 +71,7 @@ def mvpn_route(tokeniser, afi):
     elif route_type == 'shared-join':
         mvpn_nlri = mvpn_sharedjoin(tokeniser, afi, action)
     else:
-        raise ValueError("mup: unknown/unsupported mvpn route type: %s" % route_type)
+        raise ValueError('mup: unknown/unsupported mvpn route type: %s' % route_type)
 
     change = Change(mvpn_nlri, Attributes())
 
diff --git a/src/exabgp/configuration/check.py b/src/exabgp/configuration/check.py
index b4dd13619..f0f32dced 100644
--- a/src/exabgp/configuration/check.py
+++ b/src/exabgp/configuration/check.py
@@ -109,7 +109,7 @@ def check_generation(neighbors):
             try:
                 log.debug('')  # new line
 
-                pack1s = pack1[19:] if pack1.startswith(b'\xFF' * 16) else pack1
+                pack1s = pack1[19:] if pack1.startswith(b'\xff' * 16) else pack1
                 update = Update.unpack_message(pack1s, Direction.IN, negotiated)
 
                 change2 = Change(update.nlris[0], update.attributes)
@@ -205,7 +205,7 @@ def check_message(neighbor, message):
     if kind == 3:
         return check_notification(raw)
 
-    print("unknown type %d", kind)
+    print('unknown type %d', kind)
     return False
 
 
@@ -228,7 +228,7 @@ def display_message(neighbor, message):
     if kind == 2:
         return display_update(neighbor, raw)
 
-    print("unknown type %d", kind)
+    print('unknown type %d', kind)
     return False
 
 
@@ -301,8 +301,8 @@ def check_open(neighbor, raw):
         print(o)
     except Exception:
         print()
-        print("we could not decode this open message")
-        print("here is the traceback to help to figure out why")
+        print('we could not decode this open message')
+        print('here is the traceback to help to figure out why')
         print()
         raise
 
diff --git a/src/exabgp/configuration/configuration.py b/src/exabgp/configuration/configuration.py
index 6c6a23dab..3cae524c0 100644
--- a/src/exabgp/configuration/configuration.py
+++ b/src/exabgp/configuration/configuration.py
@@ -434,10 +434,10 @@ def _reload(self):
             self._rollback_reload()
 
             return self.error.set(
-                "\n"
-                "syntax error in section %s\n"
-                "line %d: %s\n"
-                "\n%s" % (self.scope.location(), self.tokeniser.number, ' '.join(self.tokeniser.line), str(self.error))
+                '\n'
+                'syntax error in section %s\n'
+                'line %d: %s\n'
+                '\n%s' % (self.scope.location(), self.tokeniser.number, ' '.join(self.tokeniser.line), str(self.error))
             )
 
         self._commit_reload()
@@ -451,8 +451,8 @@ def _reload(self):
 
     def validate(self):
         for neighbor in self.neighbors.values():
-            has_procs = "processes" in neighbor.api and neighbor.api["processes"]
-            has_match = "processes-match" in neighbor.api and neighbor.api["processes-match"]
+            has_procs = 'processes' in neighbor.api and neighbor.api['processes']
+            has_match = 'processes-match' in neighbor.api and neighbor.api['processes-match']
             if has_procs and has_match:
                 return self.error.set(
                     "\n\nprocesses and processes-match are mutually exclusive, verify neighbor '%s' configuration.\n\n"
@@ -462,13 +462,13 @@ def validate(self):
             for notification in neighbor.api:
                 errors = []
                 for api in neighbor.api[notification]:
-                    if notification == "processes":
+                    if notification == 'processes':
                         if not self.processes[api].get('run', False):
                             return self.error.set(
                                 "\n\nan api called '%s' is used by neighbor '%s' but not defined\n\n"
                                 % (api, neighbor['peer-address']),
                             )
-                    elif notification == "processes-match":
+                    elif notification == 'processes-match':
                         if not any(v.get('run', False) for k, v in self.processes.items() if re.match(api, k)):
                             errors.append(
                                 "\n\nAny process match regex '%s' for neighbor '%s'.\n\n"
@@ -479,7 +479,7 @@ def validate(self):
                 # if any of rule had a match
                 if len(errors) > 0 and len(errors) == len(neighbor.api[notification]):
                     return self.error.set(
-                        " ".join(errors),
+                        ' '.join(errors),
                     )
 
     def _link(self):
@@ -487,9 +487,9 @@ def _link(self):
             api = neighbor.api
             processes = []
             if api.get('processes', []):
-                processes = api["processes"]
+                processes = api['processes']
             elif api.get('processes-match', []):
-                processes = [k for k in self.processes.keys() for pm in api["processes-match"] if re.match(pm, k)]
+                processes = [k for k in self.processes.keys() for pm in api['processes-match'] if re.match(pm, k)]
 
             for process in processes:
                 self.processes.setdefault(process, {})['neighbor-changes'] = api['neighbor-changes']
@@ -498,11 +498,11 @@ def _link(self):
                 self.processes.setdefault(process, {})['signal'] = api['signal']
                 for way in ('send', 'receive'):
                     for name in ('parsed', 'packets', 'consolidate'):
-                        key = "%s-%s" % (way, name)
+                        key = '%s-%s' % (way, name)
                         if api[key]:
                             self.processes[process].setdefault(key, []).append(neighbor['router-id'])
                     for name in ('open', 'update', 'notification', 'keepalive', 'refresh', 'operational'):
-                        key = "%s-%s" % (way, name)
+                        key = '%s-%s' % (way, name)
                         if api[key]:
                             self.processes[process].setdefault(key, []).append(neighbor['router-id'])
 
@@ -515,10 +515,10 @@ def partial(self, section, text, action='announce'):
         if self.parseSection(section) is not True:
             self._rollback_reload()
             log.debug(
-                "\n"
-                "syntax error in api command %s\n"
-                "line %d: %s\n"
-                "\n%s" % (self.scope.location(), self.tokeniser.number, ' '.join(self.tokeniser.line), str(self.error)),
+                '\n'
+                'syntax error in api command %s\n'
+                'line %d: %s\n'
+                '\n%s' % (self.scope.location(), self.tokeniser.number, ' '.join(self.tokeniser.line), str(self.error)),
                 'configuration',
             )
             return False
@@ -526,7 +526,7 @@ def partial(self, section, text, action='announce'):
 
     def _enter(self, name):
         location = self.tokeniser.iterate()
-        log.debug("> %-16s | %s" % (location, self.tokeniser.params()), 'configuration')
+        log.debug('> %-16s | %s' % (location, self.tokeniser.params()), 'configuration')
 
         if location not in self._structure[name]['sections']:
             return self.error.set('section %s is invalid in %s, %s' % (location, name, self.scope.location()))
@@ -553,12 +553,12 @@ def _enter(self, name):
             return self.error.set('closing too many parenthesis')
         self.scope.to_context()
 
-        log.debug("< %-16s | %s" % (left, self.tokeniser.params()), 'configuration')
+        log.debug('< %-16s | %s' % (left, self.tokeniser.params()), 'configuration')
         return True
 
     def _run(self, name):
         command = self.tokeniser.iterate()
-        log.debug(". %-16s | %s" % (command, self.tokeniser.params()), 'configuration')
+        log.debug('. %-16s | %s' % (command, self.tokeniser.params()), 'configuration')
 
         if not self.run(name, command):
             return False
diff --git a/src/exabgp/configuration/flow/parser.py b/src/exabgp/configuration/flow/parser.py
index 041dc310f..953f1297d 100644
--- a/src/exabgp/configuration/flow/parser.py
+++ b/src/exabgp/configuration/flow/parser.py
@@ -91,6 +91,7 @@ def destination(tokeniser):
         ip, netmask, offset = data.split('/')
         yield Flow6Destination(IP.pton(ip), int(netmask), int(offset))
 
+
 # Expressions
 
 
@@ -165,11 +166,11 @@ def _generic_condition(tokeniser, klass):
             yield klass(AND | operator, klass.converter(value))
             if data:
                 if data[0] != '&':
-                    raise ValueError("Unknown binary operator %s" % data[0])
+                    raise ValueError('Unknown binary operator %s' % data[0])
                 AND = BinaryOperator.AND
                 data = data[1:]
                 if not data:
-                    raise ValueError("Can not finish an expresion on an &")
+                    raise ValueError('Can not finish an expresion on an &')
             else:
                 AND = BinaryOperator.NOP
                 data = tokeniser()
@@ -180,7 +181,7 @@ def _generic_condition(tokeniser, klass):
             yield klass(operator | AND, klass.converter(value))
             if data:
                 if data[0] != '&':
-                    raise ValueError("Unknown binary operator %s" % data[0])
+                    raise ValueError('Unknown binary operator %s' % data[0])
                 AND = BinaryOperator.AND
                 data = data[1:]
 
@@ -273,10 +274,10 @@ def rate_limit(tokeniser):
     # README: We are setting the ASN as zero as that what Juniper (and Arbor) did when we created a local flow route
     speed = int(tokeniser())
     if speed < 9600 and speed != 0:
-        log.warning("rate-limiting flow under 9600 bytes per seconds may not work", 'configuration')
+        log.warning('rate-limiting flow under 9600 bytes per seconds may not work', 'configuration')
     if speed > 1000000000000:
         speed = 1000000000000
-        log.warning("rate-limiting changed for 1 000 000 000 000 bytes from %s" % speed, 'configuration')
+        log.warning('rate-limiting changed for 1 000 000 000 000 bytes from %s' % speed, 'configuration')
     return ExtendedCommunities().add(TrafficRate(ASN(0), speed))
 
 
diff --git a/src/exabgp/configuration/neighbor/__init__.py b/src/exabgp/configuration/neighbor/__init__.py
index 1329111b9..4cd7d5660 100644
--- a/src/exabgp/configuration/neighbor/__init__.py
+++ b/src/exabgp/configuration/neighbor/__init__.py
@@ -304,7 +304,7 @@ def post(self):
             try:
                 md5 = base64.b64decode(neighbor['md5-password']) if neighbor['md5-base64'] else neighbor['md5-password']
             except TypeError as e:
-                return self.error.set(f"Invalid base64 encoding of MD5 password ({e})")
+                return self.error.set(f'Invalid base64 encoding of MD5 password ({e})')
             else:
                 if len(md5) > 80:
                     return self.error.set('MD5 password must be no larger than 80 characters')
diff --git a/src/exabgp/configuration/neighbor/api.py b/src/exabgp/configuration/neighbor/api.py
index 02e512d11..410ef2ed0 100644
--- a/src/exabgp/configuration/neighbor/api.py
+++ b/src/exabgp/configuration/neighbor/api.py
@@ -181,7 +181,7 @@ def flatten(cls, apis):
                     'refresh',
                     'operational',
                 ):
-                    built.setdefault("%s-%s" % (direction, action), []).extend(procs if data.get(action, False) else [])
+                    built.setdefault('%s-%s' % (direction, action), []).extend(procs if data.get(action, False) else [])
 
         return built
 
@@ -198,4 +198,4 @@ def flatten(cls, apis):
         'refresh',
         'operational',
     ):
-        ParseAPI.DEFAULT_API["%s-%s" % (way, name)] = []
+        ParseAPI.DEFAULT_API['%s-%s' % (way, name)] = []
diff --git a/src/exabgp/configuration/neighbor/parser.py b/src/exabgp/configuration/neighbor/parser.py
index 2dd4a03e0..c9213c21b 100644
--- a/src/exabgp/configuration/neighbor/parser.py
+++ b/src/exabgp/configuration/neighbor/parser.py
@@ -6,6 +6,7 @@
 Copyright (c) 2009-2017 Exa Networks. All rights reserved.
 License: 3-clause BSD. (See the COPYRIGHT file)
 """
+
 import re
 import socket
 from string import ascii_letters
diff --git a/src/exabgp/configuration/static/mpls.py b/src/exabgp/configuration/static/mpls.py
index 124ebfedf..e38ddfb3e 100644
--- a/src/exabgp/configuration/static/mpls.py
+++ b/src/exabgp/configuration/static/mpls.py
@@ -135,11 +135,11 @@ def prefix_sid(tokeniser):  # noqa: C901
 # ( [l2-service|l3-service] <SID:ipv6-addr> <Endpoint Behavior:int> [<LBL:int>, <LNL:int>, <FL:int>, <AL:int>, <Tpose-len:int>, <Tpose-offset:int>] )
 def prefix_sid_srv6(tokeniser):
     value = tokeniser()
-    if value != "(":
+    if value != '(':
         raise Exception("expect '(', but received '%s'" % value)
 
     service_type = tokeniser()
-    if service_type not in ["l3-service", "l2-service"]:
+    if service_type not in ['l3-service', 'l2-service']:
         raise Exception("expect 'l3-service' or 'l2-service', but received '%s'" % value)
 
     sid = IPv6.unpack(IPv6.pton(tokeniser()))
@@ -147,23 +147,23 @@ def prefix_sid_srv6(tokeniser):
     subtlvs = []
     subsubtlvs = []
     value = tokeniser()
-    if value != ")":
-        base = 10 if not value.startswith("0x") else 16
+    if value != ')':
+        base = 10 if not value.startswith('0x') else 16
         behavior = int(value, base)
         value = tokeniser()
-        if value == "[":
+        if value == '[':
             values = []
             for i in range(6):
                 if i != 0:
                     value = tokeniser()
-                    if value != ",":
+                    if value != ',':
                         raise Exception("expect ',', but received '%s'" % value)
                 value = tokeniser()
-                base = 10 if not value.startswith("0x") else 16
+                base = 10 if not value.startswith('0x') else 16
                 values.append(int(value, base))
 
             value = tokeniser()
-            if value != "]":
+            if value != ']':
                 raise Exception("expect ']', but received '%s'" % value)
 
             value = tokeniser()
@@ -187,17 +187,17 @@ def prefix_sid_srv6(tokeniser):
         )
     )
 
-    if value != ")":
+    if value != ')':
         raise Exception("expect ')', but received '%s'" % value)
 
-    if service_type == "l3-service":
+    if service_type == 'l3-service':
         return PrefixSid([Srv6L3Service(subtlvs=subtlvs)])
-    elif service_type == "l2-service":
+    elif service_type == 'l2-service':
         return PrefixSid([Srv6L2Service(subtlvs=subtlvs)])
 
 
 def parse_ip_prefix(tokeninser):
-    addrstr, length = tokeninser.split("/")
+    addrstr, length = tokeninser.split('/')
     if length is None:
         raise Exception("unexpect prefix format '%s'" % tokeninser)
 
@@ -218,22 +218,22 @@ def parse_ip_prefix(tokeninser):
 # shared-join rp <ip> group <ip> rd <rd> source-as <source-as>
 def mvpn_sharedjoin(tokeniser, afi, action):
     if afi == AFI.ipv4:
-        tokeniser.consume("rp")
+        tokeniser.consume('rp')
         sourceip = IPv4.unpack(IPv4.pton(tokeniser()))
-        tokeniser.consume("group")
+        tokeniser.consume('group')
         groupip = IPv4.unpack(IPv4.pton(tokeniser()))
     elif afi == AFI.ipv6:
-        tokeniser.consume("rp")
+        tokeniser.consume('rp')
         sourceip = IPv6.unpack(IPv6.pton(tokeniser()))
-        tokeniser.consume("group")
+        tokeniser.consume('group')
         groupip = IPv6.unpack(IPv6.pton(tokeniser()))
     else:
-        raise Exception("unexpect afi: %s" % afi)
+        raise Exception('unexpect afi: %s' % afi)
 
-    tokeniser.consume("rd")
+    tokeniser.consume('rd')
     rd = route_distinguisher(tokeniser)
 
-    tokeniser.consume("source-as")
+    tokeniser.consume('source-as')
     value = tokeniser()
     if not value.isdigit():
         raise Exception("expect source-as to be a integer in the range 0-4294967295, but received '%s'" % value)
@@ -247,22 +247,22 @@ def mvpn_sharedjoin(tokeniser, afi, action):
 # source-join source <ip> group <ip> rd <rd> source-as <source-as>
 def mvpn_sourcejoin(tokeniser, afi, action):
     if afi == AFI.ipv4:
-        tokeniser.consume("source")
+        tokeniser.consume('source')
         sourceip = IPv4.unpack(IPv4.pton(tokeniser()))
-        tokeniser.consume("group")
+        tokeniser.consume('group')
         groupip = IPv4.unpack(IPv4.pton(tokeniser()))
     elif afi == AFI.ipv6:
-        tokeniser.consume("source")
+        tokeniser.consume('source')
         sourceip = IPv6.unpack(IPv6.pton(tokeniser()))
-        tokeniser.consume("group")
+        tokeniser.consume('group')
         groupip = IPv6.unpack(IPv6.pton(tokeniser()))
     else:
-        raise Exception("unexpect afi: %s" % afi)
+        raise Exception('unexpect afi: %s' % afi)
 
-    tokeniser.consume("rd")
+    tokeniser.consume('rd')
     rd = route_distinguisher(tokeniser)
 
-    tokeniser.consume("source-as")
+    tokeniser.consume('source-as')
     value = tokeniser()
     if not value.isdigit():
         raise Exception("expect source-as to be a integer in the range 0-4294967295, but received '%s'" % value)
@@ -276,19 +276,19 @@ def mvpn_sourcejoin(tokeniser, afi, action):
 #'source-ad source <ip address> group <ip address> rd <rd>'
 def mvpn_sourcead(tokeniser, afi, action):
     if afi == AFI.ipv4:
-        tokeniser.consume("source")
+        tokeniser.consume('source')
         sourceip = IPv4.unpack(IPv4.pton(tokeniser()))
-        tokeniser.consume("group")
+        tokeniser.consume('group')
         groupip = IPv4.unpack(IPv4.pton(tokeniser()))
     elif afi == AFI.ipv6:
-        tokeniser.consume("source")
+        tokeniser.consume('source')
         sourceip = IPv6.unpack(IPv6.pton(tokeniser()))
-        tokeniser.consume("group")
+        tokeniser.consume('group')
         groupip = IPv6.unpack(IPv6.pton(tokeniser()))
     else:
-        raise Exception("unexpect afi: %s" % afi)
+        raise Exception('unexpect afi: %s' % afi)
 
-    tokeniser.consume("rd")
+    tokeniser.consume('rd')
     rd = route_distinguisher(tokeniser)
 
     return SourceAD(rd=rd, afi=afi, source=sourceip, group=groupip, action=action)
@@ -299,7 +299,7 @@ def srv6_mup_isd(tokeniser, afi):
     prefix_ip, prefix_len = parse_ip_prefix(tokeniser())
 
     value = tokeniser()
-    if value != "rd":
+    if value != 'rd':
         raise Exception("expect rd, but received '%s'" % value)
     rd = route_distinguisher(tokeniser)
 
@@ -318,10 +318,10 @@ def srv6_mup_dsd(tokeniser, afi):
     elif afi == AFI.ipv6:
         ip = IPv6.unpack(IPv6.pton(tokeniser()))
     else:
-        raise Exception("unexpect afi: %s" % afi)
+        raise Exception('unexpect afi: %s' % afi)
 
     value = tokeniser()
-    if value != "rd":
+    if value != 'rd':
         raise Exception("expect rd, but received '%s'" % value)
     rd = route_distinguisher(tokeniser)
 
@@ -336,33 +336,33 @@ def srv6_mup_dsd(tokeniser, afi):
 def srv6_mup_t1st(tokeniser, afi):
     prefix_ip, prefix_ip_len = parse_ip_prefix(tokeniser())
 
-    tokeniser.consume("rd")
+    tokeniser.consume('rd')
     rd = route_distinguisher(tokeniser)
 
-    tokeniser.consume("teid")
+    tokeniser.consume('teid')
     value = tokeniser()
     if not value.isdigit():
         raise Exception("expect teid to be a number, but received '%s'" % value)
     teid = int(value)
 
-    tokeniser.consume("qfi")
+    tokeniser.consume('qfi')
     value = tokeniser()
     if not value.isdigit():
         raise Exception("expect qfi to be a number, but received '%s'" % value)
     qfi = int(value)
 
-    tokeniser.consume("endpoint")
+    tokeniser.consume('endpoint')
     if afi == AFI.ipv4:
         endpoint_ip = IPv4.unpack(IPv4.pton(tokeniser()))
     elif afi == AFI.ipv6:
         endpoint_ip = IPv6.unpack(IPv6.pton(tokeniser()))
     else:
-        raise Exception("unexpect afi: %s" % afi)
+        raise Exception('unexpect afi: %s' % afi)
 
     source_ip_len = 0
-    source_ip = b""
+    source_ip = b''
 
-    if tokeniser.consume_if_match("source"):
+    if tokeniser.consume_if_match('source'):
         if afi == AFI.ipv4:
             source_ip = IPv4.unpack(IPv4.pton(tokeniser()))
             source_ip_len = 32
@@ -370,7 +370,7 @@ def srv6_mup_t1st(tokeniser, afi):
             source_ip = IPv6.unpack(IPv6.pton(tokeniser()))
             source_ip_len = 128
         else:
-            raise Exception("unexpect afi: %s" % afi)
+            raise Exception('unexpect afi: %s' % afi)
 
     return Type1SessionTransformedRoute(
         rd=rd,
@@ -393,30 +393,30 @@ def srv6_mup_t2st(tokeniser, afi):
     elif afi == AFI.ipv6:
         endpoint_ip = IPv6.unpack(IPv6.pton(tokeniser()))
     else:
-        raise Exception("unexpect afi: %s" % afi)
+        raise Exception('unexpect afi: %s' % afi)
 
     value = tokeniser()
-    if "rd" != value:
+    if 'rd' != value:
         raise Exception("expect rd, but received '%s'" % value)
 
     rd = route_distinguisher(tokeniser)
 
     value = tokeniser()
-    if value != "teid":
+    if value != 'teid':
         raise Exception("expect teid, but received '%s'" % value)
 
-    teids = tokeniser().split("/")
+    teids = tokeniser().split('/')
     if len(teids) != 2:
-        raise Exception("unexpect teid format, this expect format <teid>/<length, expect 0 ~ 32")
+        raise Exception('unexpect teid format, this expect format <teid>/<length, expect 0 ~ 32')
 
     teid = int(teids[0])
     teid_len = int(teids[1])
 
     if not (0 <= teid_len <= 32):
-        raise Exception("unexpect teid format, this expect format <teid>/<length, expect 0 ~ 32>")
+        raise Exception('unexpect teid format, this expect format <teid>/<length, expect 0 ~ 32>')
 
     if teid >= pow(2, teid_len):
-        raise Exception(f"unexpect teid format, we can not store {teid} using {teid_len} bits")
+        raise Exception(f'unexpect teid format, we can not store {teid} using {teid_len} bits')
 
     return Type2SessionTransformedRoute(
         rd=rd,
diff --git a/src/exabgp/configuration/static/parser.py b/src/exabgp/configuration/static/parser.py
index 0a4da8ffd..a239a2805 100644
--- a/src/exabgp/configuration/static/parser.py
+++ b/src/exabgp/configuration/static/parser.py
@@ -89,7 +89,7 @@ def next_hop(tokeniser, afi=None):
     else:
         ip = IP.create(value)
         if ip.afi == AFI.ipv4 and afi == AFI.ipv6:
-            ip = IP.create("::ffff:%s" % ip)
+            ip = IP.create('::ffff:%s' % ip)
         return ip, NextHop(ip.top())
 
 
diff --git a/src/exabgp/data/check.py b/src/exabgp/data/check.py
index 9819e6fa0..59dbffb41 100644
--- a/src/exabgp/data/check.py
+++ b/src/exabgp/data/check.py
@@ -38,7 +38,7 @@ def integer(data):
 
 
 def string(data):
-    return type(data) == type(u'') or type(data) == type('')  # noqa
+    return type(data) == type('') or type(data) == type('')  # noqa
 
 
 def array(data):
diff --git a/src/exabgp/debug/report.py b/src/exabgp/debug/report.py
index 5a0d2ed65..96df42075 100644
--- a/src/exabgp/debug/report.py
+++ b/src/exabgp/debug/report.py
@@ -36,12 +36,12 @@ def format_exception(exception):
 def format_panic(dtype, value, trace):
     result = _PANIC + _INFO
 
-    result += "-- Traceback\n\n"
+    result += '-- Traceback\n\n'
     result += ''.join(traceback.format_exception(dtype, value, trace))
 
-    result += "\n\n-- Logging History\n\n"
+    result += '\n\n-- Logging History\n\n'
     result += history()
-    result += "\n\n\n"
+    result += '\n\n\n'
 
     result += _FOOTER
 
diff --git a/src/exabgp/environment/environment.py b/src/exabgp/environment/environment.py
index 94780adc8..3ba4730ed 100644
--- a/src/exabgp/environment/environment.py
+++ b/src/exabgp/environment/environment.py
@@ -86,7 +86,7 @@ def iter_env(cls, diff=False):
                 if cls.definition[section][k]['write'] == parsing.quote:
                     yield "%s.%s.%s='%s'" % (base.APPLICATION, section, k, v)
                     continue
-                yield "%s.%s.%s=%s" % (
+                yield '%s.%s.%s=%s' % (
                     base.APPLICATION,
                     section,
                     k,
diff --git a/src/exabgp/logger/history.py b/src/exabgp/logger/history.py
index 107da5763..d81a10f3e 100644
--- a/src/exabgp/logger/history.py
+++ b/src/exabgp/logger/history.py
@@ -7,7 +7,7 @@
 
 
 def history():
-    return "\n".join(formater(*_) for _ in _history)
+    return '\n'.join(formater(*_) for _ in _history)
 
 
 def record(message, source, level, timestamp):
diff --git a/src/exabgp/netlink/attributes.py b/src/exabgp/netlink/attributes.py
index caf01f826..076b6bada 100644
--- a/src/exabgp/netlink/attributes.py
+++ b/src/exabgp/netlink/attributes.py
@@ -41,7 +41,7 @@ def decode(cls, data):
                 atype,
             ) = unpack(cls.Header.PACK, data[: cls.Header.LEN])
             if len(data) < length:
-                raise AttributesError("Buffer underrun %d < %d" % (len(data), length))
+                raise AttributesError('Buffer underrun %d < %d' % (len(data), length))
             payload = data[cls.Header.LEN : length]
             yield atype, payload
             data = data[int((length + 3) / 4) * 4 :]
diff --git a/src/exabgp/netlink/firewall.py b/src/exabgp/netlink/firewall.py
index 04ecc4284..3ac075d52 100644
--- a/src/exabgp/netlink/firewall.py
+++ b/src/exabgp/netlink/firewall.py
@@ -52,10 +52,10 @@
 
 class Firewall(Message):
     class Header(object):
-        PACK = "BxxxI"
+        PACK = 'BxxxI'
         LEN = calcsize(PACK)
 
     class Packet(object):
         class Header(object):
-            PACK = "IIIIIIIHHHHII"
+            PACK = 'IIIIIIIHHHHII'
             LEN = calcsize(PACK)
diff --git a/src/exabgp/netlink/netlink.py b/src/exabgp/netlink/netlink.py
index 2a78c67f8..2c52ab221 100644
--- a/src/exabgp/netlink/netlink.py
+++ b/src/exabgp/netlink/netlink.py
@@ -109,7 +109,7 @@ def decode(cls, data):
         while data:
             length, format_type, control_flags, sequence, pid = unpack(cls.Header.PACK, data[: cls.Header.LEN])
             if len(data) < length:
-                raise NetLinkError("Buffer underrun")
+                raise NetLinkError('Buffer underrun')
             yield cls.format(format_type, control_flags, sequence, pid, data[cls.Header.LEN : length])
             data = data[length:]
 
@@ -134,9 +134,9 @@ def send(cls, format_type, control_flags, family=socket.AF_UNSPEC, attributes=No
                 if response_sequence != sequence:
                     if cls._IGNORE_SEQ_FAULTS:
                         continue
-                    raise NetLinkError("netlink sequence mismatch")
+                    raise NetLinkError('netlink sequence mismatch')
                 elif response_pid != pid:
-                    raise NetLinkError("netlink pid mismatch")
+                    raise NetLinkError('netlink pid mismatch')
                 # elif response_flags != control_flags:
                 # 	raise NetLinkError("netlink flags mismatch")
                 elif response_type in cls.errors:
diff --git a/src/exabgp/netlink/old.py b/src/exabgp/netlink/old.py
index 45bec185f..d106d667e 100755
--- a/src/exabgp/netlink/old.py
+++ b/src/exabgp/netlink/old.py
@@ -128,7 +128,7 @@ def decode(cls, data):
         while data:
             length, ntype, flags, seq, pid = unpack(cls.Header.PACK, data[: cls.Header.LEN])
             if len(data) < length:
-                raise NetLinkError("Buffer underrun")
+                raise NetLinkError('Buffer underrun')
             yield cls.format(ntype, flags, seq, pid, data[cls.Header.LEN : length])
             data = data[length:]
 
@@ -146,7 +146,7 @@ def send(cls, dtype, hflags, family=socket.AF_UNSPEC):
                 if seq != sequence:
                     if cls._IGNORE_SEQ_FAULTS:
                         continue
-                    raise NetLinkError("netlink seq mismatch")
+                    raise NetLinkError('netlink seq mismatch')
                 if mtype == NetLinkRoute.Command.NLMSG_DONE:
                     raise StopIteration()
                 elif dtype in cls.errors:
@@ -186,7 +186,7 @@ def decode(cls, data):
                 atype,
             ) = unpack(cls.Header.PACK, data[: cls.Header.LEN])
             if len(data) < length:
-                raise AttributesError("Buffer underrun %d < %d" % (len(data), length))
+                raise AttributesError('Buffer underrun %d < %d' % (len(data), length))
             payload = data[cls.Header.LEN : length]
             yield atype, payload
             data = data[int((length + 3) / 4) * 4 :]
@@ -590,7 +590,7 @@ def delRoute(self):
 
 class TC(_Message):
     class Header(object):
-        PACK = "BxxxiIII"
+        PACK = 'BxxxiIII'
         LEN = calcsize(PACK)
 
     class Command(object):
@@ -650,10 +650,10 @@ class Attribute(object):
 
 class Firewall(_Message):
     class Header(object):
-        PACK = "BxxxI"
+        PACK = 'BxxxI'
         LEN = calcsize(PACK)
 
     class Packet(object):
         class Header(object):
-            PACK = "IIIIIIIHHHHII"
+            PACK = 'IIIIIIIHHHHII'
             LEN = calcsize(PACK)
diff --git a/src/exabgp/netlink/tc.py b/src/exabgp/netlink/tc.py
index 580919fae..7f69f02a7 100644
--- a/src/exabgp/netlink/tc.py
+++ b/src/exabgp/netlink/tc.py
@@ -29,7 +29,7 @@
 
 class TC(Message):
     class Header(object):
-        PACK = "BxxxiIII"
+        PACK = 'BxxxiIII'
         LEN = calcsize(PACK)
 
     class Command(object):
diff --git a/src/exabgp/protocol/family.py b/src/exabgp/protocol/family.py
index 7433e46d1..cd6207b1d 100644
--- a/src/exabgp/protocol/family.py
+++ b/src/exabgp/protocol/family.py
@@ -84,7 +84,7 @@ class AFI(Resource):
     inet_names = dict([(inst, name.replace('ipv', 'inet')) for (name, inst) in codes.items()])
 
     def name(self):
-        return self.inet_names.get(self, "unknown afi")
+        return self.inet_names.get(self, 'unknown afi')
 
     @staticmethod
     def unpack(data):
@@ -337,4 +337,4 @@ def index(self):
         return b'%02x%02x' % (self.afi, self.safi)
 
     def __repr__(self):
-        return "%s %s" % (str(self.afi), str(self.safi))
+        return '%s %s' % (str(self.afi), str(self.safi))
diff --git a/src/exabgp/protocol/ip/__init__.py b/src/exabgp/protocol/ip/__init__.py
index 598d317ec..ac1afe68c 100644
--- a/src/exabgp/protocol/ip/__init__.py
+++ b/src/exabgp/protocol/ip/__init__.py
@@ -61,7 +61,7 @@ class IP(object):
     # deprecate the string API in favor of top()
 
     def __init__(self):
-        raise RuntimeError("You should use IP.create() to use IP")
+        raise RuntimeError('You should use IP.create() to use IP')
 
     def init(self, string, packed=None):
         # XXX: the str should not be needed
diff --git a/src/exabgp/reactor/api/command/announce.py b/src/exabgp/reactor/api/command/announce.py
index 696798eee..0f94c3915 100644
--- a/src/exabgp/reactor/api/command/announce.py
+++ b/src/exabgp/reactor/api/command/announce.py
@@ -21,9 +21,11 @@
 def register_announce():
     pass
 
+
 # @Command.register('debug')
 # the command debug is hardcoded in the process code
 
+
 @Command.register('announce route')
 def announce_route(self, reactor, service, line, use_json):
     def callback():
@@ -395,14 +397,14 @@ def announce_eor(self, reactor, service, line, use_json):
     def callback(self, command, peers):
         family = self.api_eor(command)
         if not family:
-            self.log_failure("Command could not parse eor : %s" % command)
+            self.log_failure('Command could not parse eor : %s' % command)
             reactor.processes.answer_error(service)
             yield True
             return
 
         reactor.configuration.inject_eor(peers, family)
         self.log_message(
-            "Sent to %s : %s"
+            'Sent to %s : %s'
             % (', '.join(peers if peers else []) if peers is not None else 'all peers', family.extensive())
         )
         yield False
@@ -433,7 +435,7 @@ def announce_refresh(self, reactor, service, line, use_json):
     def callback(self, command, peers):
         refreshes = self.api_refresh(command)
         if not refreshes:
-            self.log_failure("Command could not parse route-refresh command : %s" % command)
+            self.log_failure('Command could not parse route-refresh command : %s' % command)
             reactor.processes.answer_error(service)
             yield True
             return
@@ -441,7 +443,7 @@ def callback(self, command, peers):
         reactor.configuration.inject_refresh(peers, refreshes)
         for refresh in refreshes:
             self.log_message(
-                "Sent to %s : %s"
+                'Sent to %s : %s'
                 % (', '.join(peers if peers else []) if peers is not None else 'all peers', refresh.extensive())
             )
 
@@ -472,14 +474,14 @@ def announce_operational(self, reactor, service, line, use_json):
     def callback(self, command, peers):
         operational = self.api_operational(command)
         if not operational:
-            self.log_failure("Command could not parse operational command : %s" % command)
+            self.log_failure('Command could not parse operational command : %s' % command)
             reactor.processes.answer_error(service)
             yield True
             return
 
         reactor.configuration.inject_operational(peers, operational)
         self.log_message(
-            "operational message sent to %s : %s"
+            'operational message sent to %s : %s'
             % (', '.join(peers if peers else []) if peers is not None else 'all peers', operational.extensive())
         )
         yield False
diff --git a/src/exabgp/reactor/api/command/rib.py b/src/exabgp/reactor/api/command/rib.py
index cec5b1e89..7bf8178e3 100644
--- a/src/exabgp/reactor/api/command/rib.py
+++ b/src/exabgp/reactor/api/command/rib.py
@@ -56,15 +56,16 @@ def to_json(key, changes):
                 # log something about this drop?
                 continue
 
-            routes.append({
-                "prefix": str(change.nlri.cidr.prefix()),
-                "family": str(change.nlri.family()).strip("()").replace(",", "")
-            })
+            routes.append(
+                {
+                    'prefix': str(change.nlri.cidr.prefix()),
+                    'family': str(change.nlri.family()).strip('()').replace(',', ''),
+                }
+            )
 
             for line in json.dumps(jason).split('\n'):
                 reactor.processes.write(service, line)
 
-
     def callback():
         lines_per_yield = getenv().api.chunk
         if last in ('routes', 'extensive', 'static', 'flow', 'l2vpn'):
@@ -85,8 +86,22 @@ def callback():
     return callback
 
 
-@Command.register('show adj-rib out', False, ['extensive',], True)
-@Command.register('show adj-rib in', False, ['extensive',], True)
+@Command.register(
+    'show adj-rib out',
+    False,
+    [
+        'extensive',
+    ],
+    True,
+)
+@Command.register(
+    'show adj-rib in',
+    False,
+    [
+        'extensive',
+    ],
+    True,
+)
 def show_adj_rib(self, reactor, service, line, use_json):
     words = line.split()
     extensive = line.endswith(' extensive')
@@ -134,7 +149,7 @@ def show_adj_rib(self, reactor, service, line, use_json):
 def flush_adj_rib_out(self, reactor, service, line, use_json):
     def callback(self, peers):
         self.log_message(
-            "flushing adjb-rib out for %s" % ', '.join(peers if peers else []) if peers is not None else 'all peers'
+            'flushing adjb-rib out for %s' % ', '.join(peers if peers else []) if peers is not None else 'all peers'
         )
         for peer_name in peers:
             reactor.neighbor_rib_resend(peer_name)
@@ -165,7 +180,7 @@ def callback(self, peers):
 def clear_adj_rib(self, reactor, service, line, use_json):
     def callback(self, peers, direction):
         self.log_message(
-            "clearing adjb-rib-%s for %s"
+            'clearing adjb-rib-%s for %s'
             % (direction, ', '.join(peers if peers else []) if peers is not None else 'all peers')
         )
         for peer_name in peers:
diff --git a/src/exabgp/reactor/api/response/json.py b/src/exabgp/reactor/api/response/json.py
index df11476e0..70c2f875a 100755
--- a/src/exabgp/reactor/api/response/json.py
+++ b/src/exabgp/reactor/api/response/json.py
@@ -65,24 +65,25 @@ def _header(self, content, header, body, neighbor, message_type=None):
         body = '"body": "%s", ' % hexstring(body) if body else ''
         mtype = '"type": "%s", ' % message_type if message_type else 'default'
 
-        return (
-            '{ '
-            '"exabgp": "%s", '
-            '"time": %s, '
-            '%s%s%s%s%s%s%s%s '
-            '}' % (self.version, self.time(time.time()), peer, pid, ppid, counter, mtype, header, body, content)
+        return '{ ' '"exabgp": "%s", ' '"time": %s, ' '%s%s%s%s%s%s%s%s ' '}' % (
+            self.version,
+            self.time(time.time()),
+            peer,
+            pid,
+            ppid,
+            counter,
+            mtype,
+            header,
+            body,
+            content,
         )
 
-    __neighbor = '''\
+    __neighbor = """\
 "neighbor": {
     "address": { "local": "%s", "peer": "%s" },
     "asn": { "local": %s, "peer": %s }
     %s%s%s%s
-}'''.replace(
-        '\t', ''
-    ).replace(
-        '\n', ' '
-    )
+}""".replace('\t', '').replace('\n', ' ')
 
     def _neighbor(self, neighbor, direction, content):
         return self.__neighbor % (
@@ -97,16 +98,16 @@ def _neighbor(self, neighbor, direction, content):
         )
 
     def _kv(self, extra):
-        return ", ".join('"%s": %s' % (k, self._string(v)) for (k, v) in extra.items())
+        return ', '.join('"%s": %s' % (k, self._string(v)) for (k, v) in extra.items())
 
     def _json_kv(self, extra):
-        return ", ".join('"%s": %s' % (k, v.json()) for (k, v) in extra.items())
+        return ', '.join('"%s": %s' % (k, v.json()) for (k, v) in extra.items())
 
     def _json_list(self, extra):
-        return ", ".join('%s' % (v.json()) for v in extra.items())
+        return ', '.join('%s' % (v.json()) for v in extra.items())
 
     def _minimalkv(self, extra):
-        return ", ".join('"%s": %s' % (k, self._string(v)) for (k, v) in extra.items() if v)
+        return ', '.join('"%s": %s' % (k, self._string(v)) for (k, v) in extra.items() if v)
 
     def up(self, neighbor):
         return self._header(
diff --git a/src/exabgp/reactor/api/transcoder.py b/src/exabgp/reactor/api/transcoder.py
index cc3b67ccf..2cafad85c 100644
--- a/src/exabgp/reactor/api/transcoder.py
+++ b/src/exabgp/reactor/api/transcoder.py
@@ -122,19 +122,19 @@ def _from_json(self, direction, json_string):
             data = data[1:]
 
             if shutdown_length == 0:
-                message.data = "empty Shutdown Communication."
+                message.data = 'empty Shutdown Communication.'
                 # move offset past length field
                 return self.encoder.notification(neighbor, direction, message, None, header, body)
 
             if len(data) < shutdown_length:
-                message.data = "invalid Shutdown Communication (buffer underrun) length : %i [%s]" % (
+                message.data = 'invalid Shutdown Communication (buffer underrun) length : %i [%s]' % (
                     shutdown_length,
                     hexstring(data),
                 )
                 return self.encoder.notification(neighbor, direction, message, None, header, body)
 
             if shutdown_length > 128:
-                message.data = "invalid Shutdown Communication (too large) length : %i [%s]" % (
+                message.data = 'invalid Shutdown Communication (too large) length : %i [%s]' % (
                     shutdown_length,
                     hexstring(data),
                 )
@@ -145,7 +145,7 @@ def _from_json(self, direction, json_string):
                     '\r', ' '
                 ).replace('\n', ' ')
             except UnicodeDecodeError:
-                message.data = "invalid Shutdown Communication (invalid UTF-8) length : %i [%s]" % (
+                message.data = 'invalid Shutdown Communication (invalid UTF-8) length : %i [%s]' % (
                     shutdown_length,
                     hexstring(data),
                 )
@@ -153,7 +153,7 @@ def _from_json(self, direction, json_string):
 
             trailer = data[shutdown_length:]
             if trailer:
-                message.data += ", trailing data: " + hexstring(trailer)
+                message.data += ', trailing data: ' + hexstring(trailer)
 
             return self.encoder.notification(neighbor, direction, message, None, header, body)
 
diff --git a/src/exabgp/reactor/daemon.py b/src/exabgp/reactor/daemon.py
index 139575375..9688811f1 100644
--- a/src/exabgp/reactor/daemon.py
+++ b/src/exabgp/reactor/daemon.py
@@ -65,25 +65,25 @@ def savepid(self):
             try:
                 pid = open(self.pid, 'r').readline().strip()
                 if self.check_pid(int(pid)):
-                    log.debug("PIDfile already exists and program still running %s" % self.pid, 'daemon')
+                    log.debug('PIDfile already exists and program still running %s' % self.pid, 'daemon')
                     return False
                 else:
                     # If pid is not running, reopen file without O_EXCL
                     fd = os.open(self.pid, flags ^ os.O_EXCL, mode)
             except (OSError, IOError, ValueError):
-                log.debug("issue accessing PID file %s (most likely permission or ownership)" % self.pid, 'daemon')
+                log.debug('issue accessing PID file %s (most likely permission or ownership)' % self.pid, 'daemon')
                 return False
 
         try:
             f = os.fdopen(fd, 'w')
-            line = "%d\n" % ownid
+            line = '%d\n' % ownid
             f.write(line)
             f.close()
             self._saved_pid = True
         except IOError:
-            log.warning("Can not create PIDfile %s" % self.pid, 'daemon')
+            log.warning('Can not create PIDfile %s' % self.pid, 'daemon')
             return False
-        log.warning("Created PIDfile %s with value %d" % (self.pid, ownid), 'daemon')
+        log.warning('Created PIDfile %s with value %d' % (self.pid, ownid), 'daemon')
         return True
 
     def removepid(self):
@@ -95,9 +95,9 @@ def removepid(self):
             if exc.errno == errno.ENOENT:
                 pass
             else:
-                log.error("Can not remove PIDfile %s" % self.pid, 'daemon')
+                log.error('Can not remove PIDfile %s' % self.pid, 'daemon')
                 return
-        log.debug("Removed PIDfile %s" % self.pid, 'daemon')
+        log.debug('Removed PIDfile %s' % self.pid, 'daemon')
 
     def drop_privileges(self):
         """return true if we are left with insecure privileges"""
@@ -200,7 +200,7 @@ def silence():
                 os.close(fd)
             except OSError:
                 pass
-        os.open("/dev/null", os.O_RDWR)
+        os.open('/dev/null', os.O_RDWR)
         os.dup2(0, 1)
         os.dup2(0, 2)
 
diff --git a/src/exabgp/reactor/loop.py b/src/exabgp/reactor/loop.py
index fef54c8d7..db1271b63 100644
--- a/src/exabgp/reactor/loop.py
+++ b/src/exabgp/reactor/loop.py
@@ -176,21 +176,21 @@ def neighbor_name(self, peer_name):
         peer = self._peers.get(peer_name, None)
         if not peer:
             log.critical('could not find referenced peer', 'reactor')
-            return ""
+            return ''
         return peer.neighbor.name()
 
     def neighbor_ip(self, peer_name):
         peer = self._peers.get(peer_name, None)
         if not peer:
             log.critical('could not find referenced peer', 'reactor')
-            return ""
+            return ''
         return str(peer.neighbor['peer-address'])
 
     def neighbor_cli_data(self, peer_name):
         peer = self._peers.get(peer_name, None)
         if not peer:
             log.critical('could not find referenced peer', 'reactor')
-            return ""
+            return ''
         return peer.cli_data()
 
     def neighor_rib(self, peer_name, rib_name, advertised=False):
@@ -303,7 +303,7 @@ def run(self):
             self.processes.start(self.configuration.processes)
 
         if not self.daemon.drop_privileges():
-            log.critical('could not drop privileges to \'%s\' refusing to run as root' % self.daemon.user, 'reactor')
+            log.critical("could not drop privileges to '%s' refusing to run as root" % self.daemon.user, 'reactor')
             log.critical('set the environmemnt value exabgp.daemon.user to change the unprivileged user', 'reactor')
             return self.Exit.privileges
 
diff --git a/src/exabgp/reactor/network/connection.py b/src/exabgp/reactor/network/connection.py
index 109c6c595..49e396df8 100644
--- a/src/exabgp/reactor/network/connection.py
+++ b/src/exabgp/reactor/network/connection.py
@@ -64,10 +64,10 @@ def __del__(self):
         self.close()
 
     def name(self):
-        return "%s-%d %s-%s" % (self.direction, self.id, self.local, self.peer)
+        return '%s-%d %s-%s' % (self.direction, self.id, self.local, self.peer)
 
     def session(self):
-        return "%s-%d" % (self.direction, self.id)
+        return '%s-%d' % (self.direction, self.id)
 
     def fd(self):
         if self.io:
diff --git a/src/exabgp/reactor/network/tcp.py b/src/exabgp/reactor/network/tcp.py
index 565a73d29..2ee30f9a6 100644
--- a/src/exabgp/reactor/network/tcp.py
+++ b/src/exabgp/reactor/network/tcp.py
@@ -50,7 +50,7 @@ def create(afi, interface=None):
                 if not hasattr(socket, 'SO_BINDTODEVICE'):
                     socket.SO_BINDTODEVICE = 25
 
-                io.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, str(interface + '\0').encode("utf-8"))
+                io.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, str(interface + '\0').encode('utf-8'))
             except socket.error:
                 raise NotConnected(f'Could not bind to device {interface}')
     except socket.error:
@@ -141,7 +141,7 @@ def MD5(io, ip, port, md5, md5_base64):
                     try:
                         md5_bytes = base64.b64decode(md5)
                     except TypeError:
-                        raise MD5Error("Failed to decode base 64 encoded PSK")
+                        raise MD5Error('Failed to decode base 64 encoded PSK')
                 elif md5_base64 is None and not re.match('.*[^a-f0-9].*', md5):  # auto
                     options = [md5 + '==', md5 + '=', md5]
                     for md5 in options:
diff --git a/src/exabgp/reactor/peer.py b/src/exabgp/reactor/peer.py
index 093c6302b..6093adfcd 100644
--- a/src/exabgp/reactor/peer.py
+++ b/src/exabgp/reactor/peer.py
@@ -117,9 +117,9 @@ def _close(self, message='', error=''):
         }
         if self.proto:
             try:
-                message = u"peer reset, message [{0}] error[{1}]".format(message, error)
+                message = 'peer reset, message [{0}] error[{1}]'.format(message, error)
             except UnicodeDecodeError as msg_err:
-                message = u"peer reset, message [{0}] error[{1}]".format(message, msg_err)
+                message = 'peer reset, message [{0}] error[{1}]'.format(message, msg_err)
             self.proto.close(message)
         self._delay.increase()
 
@@ -149,7 +149,7 @@ def _stop(self, message):
     # logging
 
     def me(self, message):
-        return "peer %s ASN %-7s %s" % (self.neighbor['peer-address'], self.neighbor['peer-as'], message)
+        return 'peer %s ASN %-7s %s' % (self.neighbor['peer-address'], self.neighbor['peer-as'], message)
 
     # control
 
@@ -167,11 +167,11 @@ def stop(self):
         self.neighbor.rib.uncache()
 
     def remove(self):
-        self._stop("removed")
+        self._stop('removed')
         self.stop()
 
     def shutdown(self):
-        self._stop("shutting down")
+        self._stop('shutting down')
         self.stop()
 
     def resend(self, enhanced, family=None):
@@ -201,7 +201,7 @@ def socket(self):
         return -1
 
     def handle_connection(self, connection):
-        log.debug("state machine for the peer is %s" % self.fsm.name(), self.id())
+        log.debug('state machine for the peer is %s' % self.fsm.name(), self.id())
 
         # if the other side fails, we go back to idle
         if self.fsm == FSM.ESTABLISHED:
@@ -251,12 +251,12 @@ def established(self):
 
     def negotiated_families(self):
         if self.proto:
-            families = ["%s/%s" % (x[0], x[1]) for x in self.proto.negotiated.families]
+            families = ['%s/%s' % (x[0], x[1]) for x in self.proto.negotiated.families]
         else:
-            families = ["%s/%s" % (x[0], x[1]) for x in self.neighbor.families()]
+            families = ['%s/%s' % (x[0], x[1]) for x in self.neighbor.families()]
 
         if len(families) > 1:
-            return "[ %s ]" % " ".join(families)
+            return '[ %s ]' % ' '.join(families)
         elif len(families) == 1:
             return families[0]
 
diff --git a/src/exabgp/reactor/protocol.py b/src/exabgp/reactor/protocol.py
index 3f4755fe1..3dd959152 100644
--- a/src/exabgp/reactor/protocol.py
+++ b/src/exabgp/reactor/protocol.py
@@ -80,7 +80,7 @@ def fd(self):
     # XXX: we use self.peer.neighbor['peer-address'] when we could use self.neighbor['peer-address']
 
     def me(self, message):
-        return "%s/%s %s" % (self.peer.neighbor['peer-address'], self.peer.neighbor['peer-as'], message)
+        return '%s/%s %s' % (self.peer.neighbor['peer-address'], self.peer.neighbor['peer-as'], message)
 
     def accept(self, incoming):
         self.connection = incoming
diff --git a/src/exabgp/rib/change.py b/src/exabgp/rib/change.py
index 0cb314337..d54979f11 100644
--- a/src/exabgp/rib/change.py
+++ b/src/exabgp/rib/change.py
@@ -46,7 +46,7 @@ def __ge__(self, other):
 
     def extensive(self):
         # If you change this you must change as well extensive in Update
-        return "%s%s" % (str(self.nlri), str(self.attributes))
+        return '%s%s' % (str(self.nlri), str(self.attributes))
 
     def __repr__(self):
         return self.extensive()
diff --git a/src/exabgp/rib/outgoing.py b/src/exabgp/rib/outgoing.py
index 6b3da4edb..51ebd19f7 100644
--- a/src/exabgp/rib/outgoing.py
+++ b/src/exabgp/rib/outgoing.py
@@ -6,6 +6,7 @@
 Copyright (c) 2009-2017 Exa Networks. All rights reserved.
 License: 3-clause BSD. (See the COPYRIGHT file)
 """
+
 from copy import deepcopy
 from exabgp.logger import log
 
diff --git a/src/exabgp/util/dns.py b/src/exabgp/util/dns.py
index 5b7d67df9..3b892f604 100644
--- a/src/exabgp/util/dns.py
+++ b/src/exabgp/util/dns.py
@@ -15,11 +15,11 @@
 __host_name = ''
 __domain_name = ''
 
-__warning = '''
+__warning = """
 Your OS is very slow when returning the host FQDN
 Most likely you do not have valid forward/reverse DNS setup
 Adding your hostname to the /etc/hosts file should fix the issue
-'''
+"""
 
 
 def host():
diff --git a/src/exabgp/util/enumeration.py b/src/exabgp/util/enumeration.py
index d43a7c884..31645d926 100644
--- a/src/exabgp/util/enumeration.py
+++ b/src/exabgp/util/enumeration.py
@@ -25,4 +25,4 @@ def __init__(self, *names):
 
 # Taken from Vincent Bernat
 def Enum(*sequential):
-    return type(str("Enum"), (), dict(zip(sequential, sequential)))
+    return type(str('Enum'), (), dict(zip(sequential, sequential)))
diff --git a/src/exabgp/vendoring/gcdump.py b/src/exabgp/vendoring/gcdump.py
index e6638ada1..7d9356701 100644
--- a/src/exabgp/vendoring/gcdump.py
+++ b/src/exabgp/vendoring/gcdump.py
@@ -5,29 +5,29 @@
 
 def dump():
     # force collection
-    print("\nCollecting GARBAGE:")
+    print('\nCollecting GARBAGE:')
     gc.collect()
     # prove they have been collected
-    print("\nCollecting GARBAGE:")
+    print('\nCollecting GARBAGE:')
     gc.collect()
 
-    print("\nGARBAGE OBJECTS:")
+    print('\nGARBAGE OBJECTS:')
     for x in gc.garbage:
         s = str(x)
         if len(s) > 80:
-            s = "%s..." % s[:80]
+            s = '%s...' % s[:80]
 
-        print("::", s)
-        print("		type:", type(x))
-        print("   referrers:", len(gc.get_referrers(x)))
+        print('::', s)
+        print('		type:', type(x))
+        print('   referrers:', len(gc.get_referrers(x)))
         try:
-            print("	is class:", inspect.isclass(type(x)))
-            print("	  module:", inspect.getmodule(x))
+            print('	is class:', inspect.isclass(type(x)))
+            print('	  module:', inspect.getmodule(x))
 
             lines, line_num = inspect.getsourcelines(type(x))
-            print("	line num:", line_num)
+            print('	line num:', line_num)
             for line in lines:
-                print("		line:", line.rstrip("\n"))
+                print('		line:', line.rstrip('\n'))
         except Exception:
             pass
 
diff --git a/src/exabgp/vendoring/lsprofcalltree.py b/src/exabgp/vendoring/lsprofcalltree.py
index 0a8fbfcb8..aab772e28 100644
--- a/src/exabgp/vendoring/lsprofcalltree.py
+++ b/src/exabgp/vendoring/lsprofcalltree.py
@@ -15,7 +15,7 @@
 try:
     import cProfile
 except ImportError:
-    raise SystemExit("This script requires cProfile from Python 2.5")
+    raise SystemExit('This script requires cProfile from Python 2.5')
 
 
 def label(code):
@@ -32,7 +32,7 @@ def __init__(self, profiler):
 
     def output(self, out_file):
         self.out_file = out_file
-        print(u'events: Ticks', file=out_file)
+        print('events: Ticks', file=out_file)
         self._print_summary()
         for entry in self.data:
             self._entry(entry)
@@ -42,7 +42,7 @@ def _print_summary(self):
         for entry in self.data:
             totaltime = int(entry.totaltime * 1000)
             max_cost = max(max_cost, totaltime)
-        print(u'summary: %d' % (max_cost,), file=self.out_file)
+        print('summary: %d' % (max_cost,), file=self.out_file)
 
     def _entry(self, entry):
         out_file = self.out_file
@@ -50,16 +50,16 @@ def _entry(self, entry):
         code = entry.code
         # print(u'ob=%s' % (code.co_filename,), file=out_file)
         if isinstance(code, str):
-            print(u'fi=~', file=out_file)
+            print('fi=~', file=out_file)
         else:
-            print(u'fi=%s' % (code.co_filename,), file=out_file)
-        print(u'fn=%s' % (label(code),), file=out_file)
+            print('fi=%s' % (code.co_filename,), file=out_file)
+        print('fn=%s' % (label(code),), file=out_file)
 
         inlinetime = int(entry.inlinetime * 1000)
         if isinstance(code, str):
-            print(u'0 ', inlinetime, file=out_file)
+            print('0 ', inlinetime, file=out_file)
         else:
-            print(u'%d %d' % (code.co_firstlineno, inlinetime), file=out_file)
+            print('%d %d' % (code.co_firstlineno, inlinetime), file=out_file)
 
         # recursive calls are counted in entry.calls
         if entry.calls:
@@ -74,29 +74,29 @@ def _entry(self, entry):
 
         for subentry in calls:
             self._subentry(lineno, subentry)
-        print(u'', file=out_file)
+        print('', file=out_file)
 
     def _subentry(self, lineno, subentry):
         out_file = self.out_file
         code = subentry.code
         # print(u'cob=%s' % (code.co_filename,), file=out_file)
-        print(u'cfn=%s' % (label(code),), file=out_file)
+        print('cfn=%s' % (label(code),), file=out_file)
         if isinstance(code, str):
-            print(u'cfi=~', file=out_file)
-            print(u'calls=%d 0' % (subentry.callcount,), file=out_file)
+            print('cfi=~', file=out_file)
+            print('calls=%d 0' % (subentry.callcount,), file=out_file)
         else:
-            print(u'cfi=%s' % (code.co_filename,), file=out_file)
-            print(u'calls=%d %d' % (subentry.callcount, code.co_firstlineno), file=out_file)
+            print('cfi=%s' % (code.co_filename,), file=out_file)
+            print('calls=%d %d' % (subentry.callcount, code.co_firstlineno), file=out_file)
 
         totaltime = int(subentry.totaltime * 1000)
-        print(u'%d %d' % (lineno, totaltime), file=out_file)
+        print('%d %d' % (lineno, totaltime), file=out_file)
 
 
 def main(args):
-    usage = "%s [-o output_file_path] scriptfile [arg] ..."
+    usage = '%s [-o output_file_path] scriptfile [arg] ...'
     parser = optparse.OptionParser(usage=usage % sys.argv[0])
     parser.allow_interspersed_args = False
-    parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None)
+    parser.add_option('-o', '--outfile', dest='outfile', help='Save stats to <outfile>', default=None)
 
     if not sys.argv[1:]:
         parser.print_usage()
diff --git a/src/exabgp/vendoring/objgraph.py b/src/exabgp/vendoring/objgraph.py
index 4b8ab34e7..6d079c0ee 100644
--- a/src/exabgp/vendoring/objgraph.py
+++ b/src/exabgp/vendoring/objgraph.py
@@ -26,7 +26,6 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
-
 import codecs
 import gc
 import re
@@ -46,11 +45,11 @@
     InstanceType = None
 
 
-__author__ = "Marius Gedminas (marius@gedmin.as)"
-__copyright__ = "Copyright (c) 2008-2015 Marius Gedminas and contributors"
-__license__ = "MIT"
-__version__ = "2.0.1"
-__date__ = "2015-07-28"
+__author__ = 'Marius Gedminas (marius@gedmin.as)'
+__copyright__ = 'Copyright (c) 2008-2015 Marius Gedminas and contributors'
+__license__ = 'MIT'
+__version__ = '2.0.1'
+__date__ = '2015-07-28'
 
 
 try:
@@ -554,8 +553,7 @@ def show_chain(*chains, **kw):
     You can specify if you want that chain traced backwards or forwards
     by passing a ``backrefs`` keyword argument, e.g.
 
-        >>> show_chain(find_ref_chain(obj, is_proper_module),
-        ...            backrefs=False)
+        >>> show_chain(find_ref_chain(obj, is_proper_module), backrefs=False)
 
     Ideally this shouldn't matter, but for some objects
     :func:`gc.get_referrers` and :func:`gc.get_referents` are not perfectly
@@ -673,7 +671,7 @@ def _show_graph(
         dot_filename = filename
     else:
         fd, dot_filename = tempfile.mkstemp(prefix='objgraph-', suffix='.dot', text=True)
-        f = os.fdopen(fd, "w")
+        f = os.fdopen(fd, 'w')
         if getattr(f, 'encoding', None):
             # Python 3 will wrap the file in the user's preferred encoding
             # Re-wrap it for utf-8
@@ -759,24 +757,24 @@ def _show_graph(
         if skipped > 0:
             h, s, v = _gradient((0, 1, 1), (0, 1, 0.3), tdepth + 1, max_depth)
             if swap_source_target:
-                label = "%d more references" % skipped
-                edge = "%s->too_many_%s" % (_obj_node_id(target), _obj_node_id(target))
+                label = '%d more references' % skipped
+                edge = '%s->too_many_%s' % (_obj_node_id(target), _obj_node_id(target))
             else:
-                label = "%d more backreferences" % skipped
-                edge = "too_many_%s->%s" % (_obj_node_id(target), _obj_node_id(target))
+                label = '%d more backreferences' % skipped
+                edge = 'too_many_%s->%s' % (_obj_node_id(target), _obj_node_id(target))
             f.write('  %s[color=red,style=dotted,len=0.25,weight=10];\n' % edge)
             f.write(
                 '  too_many_%s[label="%s",shape=box,height=0.25,'
                 'color=red,fillcolor="%g,%g,%g",fontsize=6];\n' % (_obj_node_id(target), label, h, s, v)
             )
             f.write('  too_many_%s[fontcolor=white];\n' % (_obj_node_id(target)))
-    f.write("}\n")
+    f.write('}\n')
     if output:
         return
     # The file should only be closed if this function was in charge of opening
     # the file.
     f.close()
-    print("Graph written to %s (%d nodes)" % (dot_filename, nodes))
+    print('Graph written to %s (%d nodes)' % (dot_filename, nodes))
     _present_graph(dot_filename, filename)
 
 
@@ -794,11 +792,11 @@ def _present_graph(dot_filename, filename=None):
         # nothing to do, the user asked for a .dot file and got it
         return
     if not filename and _program_in_path('xdot'):
-        print("Spawning graph viewer (xdot)")
+        print('Spawning graph viewer (xdot)')
         subprocess.Popen(['xdot', dot_filename], close_fds=True)
     elif _program_in_path('dot'):
         if not filename:
-            print("Graph viewer (xdot) not found, generating a png instead")
+            print('Graph viewer (xdot) not found, generating a png instead')
             filename = dot_filename[:-4] + '.png'
         stem, ext = os.path.splitext(filename)
         cmd = ['dot', '-T' + ext[1:], '-o' + filename, dot_filename]
@@ -808,12 +806,12 @@ def _present_graph(dot_filename, filename=None):
             # XXX: shouldn't this go to stderr or a log?
             print('dot failed (exit code %d) while executing "%s"' % (dot.returncode, ' '.join(cmd)))
         else:
-            print("Image generated as %s" % filename)
+            print('Image generated as %s' % filename)
     else:
         if not filename:
-            print("Graph viewer (xdot) and image renderer (dot) not found," " not doing anything else")
+            print('Graph viewer (xdot) and image renderer (dot) not found,' ' not doing anything else')
         else:
-            print("Image renderer (dot) not found, not doing anything else")
+            print('Image renderer (dot) not found, not doing anything else')
 
 
 def _obj_node_id(obj):
@@ -839,7 +837,7 @@ def _obj_label(obj, extra_info=None, refcounts=False, shortnames=True):
 
 
 def _quote(s):
-    return s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n").replace("\0", "\\\\0")
+    return s.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\0', '\\\\0')
 
 
 def _get_obj_type(obj):
@@ -940,7 +938,7 @@ def _edge_label(source, target, shortnames=True):
                         tn = _short_typename(k)
                     else:
                         tn = _long_typename(k)
-                    return ' [label="%s"]' % _quote(tn + "\n" + _safe_repr(k))
+                    return ' [label="%s"]' % _quote(tn + '\n' + _safe_repr(k))
     return ''
 
 
@@ -949,7 +947,7 @@ def _edge_label(source, target, shortnames=True):
 
 def _program_in_path(program):
     # XXX: Consider using distutils.spawn.find_executable or shutil.which
-    path = os.environ.get("PATH", os.defpath).split(os.pathsep)
+    path = os.environ.get('PATH', os.defpath).split(os.pathsep)
     path = [os.path.join(dir, program) for dir in path]
     path = [True for file in path if os.path.isfile(file) or os.path.isfile(file + '.exe')]
     return bool(path)
diff --git a/src/exabgp/vendoring/profiler.py b/src/exabgp/vendoring/profiler.py
index 85ce79e3c..94453c0ed 100644
--- a/src/exabgp/vendoring/profiler.py
+++ b/src/exabgp/vendoring/profiler.py
@@ -5,7 +5,7 @@
 
 __version__ = '0.26'
 
-_CMD_USAGE = "python -m memory_profiler script_file.py"
+_CMD_USAGE = 'python -m memory_profiler script_file.py'
 
 import time  # noqa: E402
 import sys  # noqa: E402
@@ -36,7 +36,7 @@ def _get_memory(pid):
         return mem
 
 except ImportError:
-    warnings.warn("psutil module not found. memory_profiler will be slow")
+    warnings.warn('psutil module not found. memory_profiler will be slow')
 
     if os.name == 'posix':
 
@@ -214,7 +214,7 @@ def add_function(self, func):
             # func_code does not exist in Python3
             code = func.__code__
         except AttributeError:
-            warnings.warn("Could not extract a code object for the object %r" % (func,))
+            warnings.warn('Could not extract a code object for the object %r' % (func,))
             return
         if code not in self.code_map:
             self.code_map[code] = {}
@@ -331,15 +331,15 @@ def show_results(prof, stream=None, precision=3):
             # .. measurements are empty ..
             continue
         filename = code.co_filename
-        if filename.endswith((".pyc", ".pyo")):
+        if filename.endswith(('.pyc', '.pyo')):
             filename = filename[:-1]
         stream.write('Filename: ' + filename + '\n\n')
         if not os.path.exists(filename):
             stream.write('ERROR: Could not find file ' + filename + '\n')
-            if filename.startswith("ipython-input") or filename.startswith("<ipython-input"):
+            if filename.startswith('ipython-input') or filename.startswith('<ipython-input'):
                 print(
-                    "NOTE: %mprun can only be used on functions defined in "
-                    "physical files, and not in the IPython environment."
+                    'NOTE: %mprun can only be used on functions defined in '
+                    'physical files, and not in the IPython environment.'
                 )
             continue
         all_lines = linecache.getlines(filename)
@@ -433,7 +433,7 @@ def magic_mprun(self, parameter_s=''):
 
     # Escape quote markers.
     opts_def = Struct(T=[''], f=[])
-    parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'")
+    parameter_s = parameter_s.replace('"', r'\"').replace("'", r'\'')
     opts, arg_str = self.parse_options(parameter_s, 'rf:T:', list_all=True)
     opts.merge(opts_def)
     global_ns = self.shell.user_global_ns
@@ -470,9 +470,9 @@ def magic_mprun(self, parameter_s=''):
             profile.runctx(arg_str, global_ns, local_ns)
             message = ''
         except SystemExit:
-            message = "*** SystemExit exception caught in code being profiled."
+            message = '*** SystemExit exception caught in code being profiled.'
         except KeyboardInterrupt:
-            message = "*** KeyboardInterrupt exception caught in code being " "profiled."
+            message = '*** KeyboardInterrupt exception caught in code being ' 'profiled.'
     finally:
         if had_profile:
             builtins.__dict__['profile'] = old_profile
@@ -584,20 +584,20 @@ def wrapper(*args, **kwargs):
     parser = OptionParser(usage=_CMD_USAGE, version=__version__)
     parser.disable_interspersed_args()
     parser.add_option(
-        "--pdb-mmem",
-        dest="max_mem",
-        metavar="MAXMEM",
-        type="float",
-        action="store",
-        help="step into the debugger when memory exceeds MAXMEM",
+        '--pdb-mmem',
+        dest='max_mem',
+        metavar='MAXMEM',
+        type='float',
+        action='store',
+        help='step into the debugger when memory exceeds MAXMEM',
     )
     parser.add_option(
         '--precision',
-        dest="precision",
-        type="int",
-        action="store",
+        dest='precision',
+        type='int',
+        action='store',
         default=3,
-        help="precision of memory output in number of significant digits",
+        help='precision of memory output in number of significant digits',
     )
 
     if not sys.argv[1:]:
diff --git a/src/exabgp/version.py b/src/exabgp/version.py
index 275e4337e..abc565bb0 100644
--- a/src/exabgp/version.py
+++ b/src/exabgp/version.py
@@ -2,14 +2,17 @@
 import sys
 from datetime import datetime
 
+
 def get_zipapp():
     return os.path.abspath(os.path.sep.join(__file__.split(os.path.sep)[:-2]))
 
+
 def get_root():
     if os.path.isfile(get_zipapp()):
         return get_zipapp()
     return os.path.abspath(os.path.sep.join(__file__.split(os.path.sep)[:-1]))
 
+
 try:
     file = os.path.abspath(__file__)
     modification_time = modification_time = os.path.getmtime(file)
@@ -19,10 +22,10 @@ def get_root():
 
 date = datetime.fromtimestamp(modification_time)
 
-commit = "unset"
-release = "5.0.0-%s+uncontrolled" % date.strftime('%Y%m%d')
-json = "5.0.0"
-text = "5.0.0"
+commit = 'unset'
+release = '5.0.0-%s+uncontrolled' % date.strftime('%Y%m%d')
+json = '5.0.0'
+text = '5.0.0'
 version = os.environ.get('exabgp_version', release)
 
 # Do not change the first line as it is parsed by scripts