tests: replace pycodestyle with black

Drop pycodestyle for code style checking in favor of black. Black is
much faster, stable PEP8 compliant code style checker offering also
automatic formatting. It aims to be very stable and produce smallest
diffs. It's used by many small and big projects.

Running checkstyle with black takes a few seconds with a terse output.
Thus, test-checkstyle-diff is no longer necessary.

Expand scope of checkstyle to all python files in the repo, replacing
test-checkstyle with checkstyle-python.

Also, fixstyle-python is now available for automatic style formatting.

Note: python virtualenv has been consolidated in test/Makefile,
test/requirements*.txt which will eventually be moved to a central
location.  This is required to simply the automated generation of
docker executor images in the CI.

Type: improvement
Change-Id: I022a326603485f58585e879ac0f697fceefbc9c8
Signed-off-by: Klement Sekera <klement.sekera@gmail.com>
Signed-off-by: Dave Wallace <dwallacelf@gmail.com>

3 files changed, 378 insertions, 283 deletions

diff --git a/src/scripts/fts.py b/src/scripts/fts.py
index f2b877fb2c7..e8ff477c788 100755
--- a/src/scripts/fts.py
+++ b/src/scripts/fts.py
@@ -21,25 +21,28 @@ schema = {
         "name": {"type": "string"},
         "description": {"type": "string"},
         "maintainer": {"$ref": "#/definitions/maintainers"},
-        "state": {"type": "string",
-                  "enum": ["production", "experimental", "development"]},
+        "state": {
+            "type": "string",
+            "enum": ["production", "experimental", "development"],
+        },
         "features": {"$ref": "#/definitions/features"},
         "missing": {"$ref": "#/definitions/features"},
-        "properties": {"type": "array",
-                       "items": {"type": "string",
-                                 "enum": ["API", "CLI", "STATS",
-                                          "MULTITHREAD"]},
-                       },
+        "properties": {
+            "type": "array",
+            "items": {"type": "string", "enum": ["API", "CLI", "STATS", "MULTITHREAD"]},
+        },
     },
     "additionalProperties": False,
     "definitions": {
         "maintainers": {
-            "anyof": [{
-                "type": "array",
-                "items": {"type": "string"},
-                "minItems": 1,
-            },
-                {"type": "string"}],
+            "anyof": [
+                {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "minItems": 1,
+                },
+                {"type": "string"},
+            ],
         },
         "featureobject": {
             "type": "object",
@@ -49,9 +52,12 @@ schema = {
         },
         "features": {
             "type": "array",
-            "items": {"anyOf": [{"$ref": "#/definitions/featureobject"},
-                                {"type": "string"},
-                                ]},
+            "items": {
+                "anyOf": [
+                    {"$ref": "#/definitions/featureobject"},
+                    {"type": "string"},
+                ]
+            },
             "minItems": 1,
         },
     },
@@ -59,14 +65,15 @@ schema = {
 
 DEFAULT_REPO_LINK = "https://github.com/FDio/vpp/blob/master/"
 
+
 def filelist_from_git_status():
     filelist = []
-    git_status = 'git status --porcelain */FEATURE*.yaml'
+    git_status = "git status --porcelain */FEATURE*.yaml"
     rv = run(git_status.split(), stdout=PIPE, stderr=PIPE)
     if rv.returncode != 0:
         sys.exit(rv.returncode)
 
-    for l in rv.stdout.decode('ascii').split('\n'):
+    for l in rv.stdout.decode("ascii").split("\n"):
         if len(l):
             filelist.append(l.split()[1])
     return filelist
@@ -74,24 +81,26 @@ def filelist_from_git_status():
 
 def filelist_from_git_ls():
     filelist = []
-    git_ls = 'git ls-files :(top)*/FEATURE*.yaml'
+    git_ls = "git ls-files :(top)*/FEATURE*.yaml"
     rv = run(git_ls.split(), stdout=PIPE, stderr=PIPE)
     if rv.returncode != 0:
         sys.exit(rv.returncode)
 
-    for l in rv.stdout.decode('ascii').split('\n'):
+    for l in rv.stdout.decode("ascii").split("\n"):
         if len(l):
             filelist.append(l)
     return filelist
 
+
 def version_from_git():
-    git_describe = 'git describe'
+    git_describe = "git describe"
     rv = run(git_describe.split(), stdout=PIPE, stderr=PIPE)
     if rv.returncode != 0:
         sys.exit(rv.returncode)
-    return rv.stdout.decode('ascii').split('\n')[0]
+    return rv.stdout.decode("ascii").split("\n")[0]
+
 
-class MarkDown():
+class MarkDown:
     _dispatch = {}
 
     def __init__(self, stream):
@@ -101,102 +110,115 @@ class MarkDown():
     def print_maintainer(self, o):
         write = self.stream.write
         if type(o) is list:
-            write('Maintainers: ' +
-                  ', '.join('{m}'.format(m=m) for m in
-                            o) + '  \n')
+            write("Maintainers: " + ", ".join("{m}".format(m=m) for m in o) + "  \n")
         else:
-            write('Maintainer: {o}  \n'.format(o=o))
+            write("Maintainer: {o}  \n".format(o=o))
 
-    _dispatch['maintainer'] = print_maintainer
+    _dispatch["maintainer"] = print_maintainer
 
     def print_features(self, o, indent=0):
         write = self.stream.write
         for f in o:
-            indentstr = ' ' * indent
+            indentstr = " " * indent
             if type(f) is dict:
                 for k, v in f.items():
-                    write('{indentstr}- {k}\n'.format(indentstr=indentstr, k=k))
+                    write("{indentstr}- {k}\n".format(indentstr=indentstr, k=k))
                     self.print_features(v, indent + 2)
             else:
-                write('{indentstr}- {f}\n'.format(indentstr=indentstr, f=f))
-        write('\n')
-    _dispatch['features'] = print_features
+                write("{indentstr}- {f}\n".format(indentstr=indentstr, f=f))
+        write("\n")
+
+    _dispatch["features"] = print_features
 
     def print_markdown_header(self, o):
         write = self.stream.write
-        write('## {o}\n'.format(o=o))
-    _dispatch['markdown_header'] = print_markdown_header
+        write("## {o}\n".format(o=o))
+
+    _dispatch["markdown_header"] = print_markdown_header
 
     def print_name(self, o):
         write = self.stream.write
-        write('### {o}\n'.format(o=o))
+        write("### {o}\n".format(o=o))
         self.toc.append(o)
-    _dispatch['name'] = print_name
+
+    _dispatch["name"] = print_name
 
     def print_description(self, o):
         write = self.stream.write
-        write('\n{o}\n\n'.format(o=o))
-    _dispatch['description'] = print_description
+        write("\n{o}\n\n".format(o=o))
+
+    _dispatch["description"] = print_description
 
     def print_state(self, o):
         write = self.stream.write
-        write('Feature maturity level: {o}  \n'.format(o=o))
-    _dispatch['state'] = print_state
+        write("Feature maturity level: {o}  \n".format(o=o))
+
+    _dispatch["state"] = print_state
 
     def print_properties(self, o):
         write = self.stream.write
-        write('Supports: {s}  \n'.format(s=" ".join(o)))
-    _dispatch['properties'] = print_properties
+        write("Supports: {s}  \n".format(s=" ".join(o)))
+
+    _dispatch["properties"] = print_properties
 
     def print_missing(self, o):
         write = self.stream.write
-        write('\nNot yet implemented:  \n')
+        write("\nNot yet implemented:  \n")
         self.print_features(o)
-    _dispatch['missing'] = print_missing
+
+    _dispatch["missing"] = print_missing
 
     def print_code(self, o):
         write = self.stream.write
-        write('Source Code: [{o}]({o}) \n'.format(o=o))
-    _dispatch['code'] = print_code
+        write("Source Code: [{o}]({o}) \n".format(o=o))
+
+    _dispatch["code"] = print_code
 
     def print(self, t, o):
         write = self.stream.write
         if t in self._dispatch:
-            self._dispatch[t](self, o,)
+            self._dispatch[t](
+                self,
+                o,
+            )
         else:
-            write('NOT IMPLEMENTED: {t}\n')
+            write("NOT IMPLEMENTED: {t}\n")
+
 
 def output_toc(toc, stream):
     write = stream.write
-    write('# VPP Supported Features\n')
+    write("# VPP Supported Features\n")
 
     for t in toc:
-        ref = t.lower().replace(' ', '-')
-        write('[{t}](#{ref})  \n'.format(t=t, ref=ref))
+        ref = t.lower().replace(" ", "-")
+        write("[{t}](#{ref})  \n".format(t=t, ref=ref))
+
 
 def featuresort(k):
-    return k[1]['name']
+    return k[1]["name"]
+
 
 def featurelistsort(k):
     orderedfields = {
-        'name': 0,
-        'maintainer': 1,
-        'description': 2,
-        'features': 3,
-        'state': 4,
-        'properties': 5,
-        'missing': 6,
-        'code': 7,
+        "name": 0,
+        "maintainer": 1,
+        "description": 2,
+        "features": 3,
+        "state": 4,
+        "properties": 5,
+        "missing": 6,
+        "code": 7,
     }
     return orderedfields[k[0]]
 
+
 def output_markdown(features, fields, notfields, repository_url):
     stream = StringIO()
     m = MarkDown(stream)
-    m.print('markdown_header', 'Feature Details:')
+    m.print("markdown_header", "Feature Details:")
     for path, featuredef in sorted(features.items(), key=featuresort):
         codeurl = urllib.parse.urljoin(repository_url, os.path.dirname(path))
-        featuredef['code'] = codeurl
+        featuredef["code"] = codeurl
         for k, v in sorted(featuredef.items(), key=featurelistsort):
             if notfields:
                 if k not in notfields:
@@ -211,24 +233,45 @@ def output_markdown(features, fields, notfields, repository_url):
     output_toc(m.toc, tocstream)
     return tocstream, stream
 
+
 def main():
-    parser = argparse.ArgumentParser(description='VPP Feature List.')
-    parser.add_argument('--validate', dest='validate', action='store_true',
-                        help='validate the FEATURE.yaml file')
-    parser.add_argument("--repolink", metavar="repolink", default=DEFAULT_REPO_LINK,
-                help="Link to public repository [%s]" %
-                     DEFAULT_REPO_LINK)
-    parser.add_argument('--git-status', dest='git_status', action='store_true',
-                        help='Get filelist from git status')
-    parser.add_argument('--all', dest='all', action='store_true',
-                        help='Validate all files in repository')
-    parser.add_argument('--markdown', dest='markdown', action='store_true',
-                        help='Output feature table in markdown')
-    parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
-                        default=sys.stdin)
+    parser = argparse.ArgumentParser(description="VPP Feature List.")
+    parser.add_argument(
+        "--validate",
+        dest="validate",
+        action="store_true",
+        help="validate the FEATURE.yaml file",
+    )
+    parser.add_argument(
+        "--repolink",
+        metavar="repolink",
+        default=DEFAULT_REPO_LINK,
+        help="Link to public repository [%s]" % DEFAULT_REPO_LINK,
+    )
+    parser.add_argument(
+        "--git-status",
+        dest="git_status",
+        action="store_true",
+        help="Get filelist from git status",
+    )
+    parser.add_argument(
+        "--all",
+        dest="all",
+        action="store_true",
+        help="Validate all files in repository",
+    )
+    parser.add_argument(
+        "--markdown",
+        dest="markdown",
+        action="store_true",
+        help="Output feature table in markdown",
+    )
+    parser.add_argument(
+        "infile", nargs="?", type=argparse.FileType("r"), default=sys.stdin
+    )
     group = parser.add_mutually_exclusive_group()
-    group.add_argument('--include', help='List of fields to include')
-    group.add_argument('--exclude', help='List of fields to exclude')
+    group.add_argument("--include", help="List of fields to include")
+    group.add_argument("--exclude", help="List of fields to exclude")
     args = parser.parse_args()
     features = {}
 
@@ -240,11 +283,11 @@ def main():
         filelist = args.infile
 
     if args.include:
-        fields = args.include.split(',')
+        fields = args.include.split(",")
     else:
         fields = []
     if args.exclude:
-        notfields = args.exclude.split(',')
+        notfields = args.exclude.split(",")
     else:
         notfields = []
 
@@ -252,13 +295,15 @@ def main():
         featurefile = featurefile.rstrip()
 
         # Load configuration file
-        with open(featurefile, encoding='utf-8') as f:
+        with open(featurefile, encoding="utf-8") as f:
             cfg = yaml.load(f, Loader=yaml.SafeLoader)
         try:
             validate(instance=cfg, schema=schema)
         except exceptions.ValidationError:
-            print('File does not validate: {featurefile}' \
-                  .format(featurefile=featurefile), file=sys.stderr)
+            print(
+                "File does not validate: {featurefile}".format(featurefile=featurefile),
+                file=sys.stderr,
+            )
             raise
         features[featurefile] = cfg
 
@@ -270,5 +315,5 @@ def main():
         stream.close()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/scripts/host-stack/cc_plots.py b/src/scripts/host-stack/cc_plots.py
index 20f5bd6a3f1..f0296af7223 100755
--- a/src/scripts/host-stack/cc_plots.py
+++ b/src/scripts/host-stack/cc_plots.py
@@ -6,214 +6,242 @@ import argparse
 import matplotlib.pyplot as plt
 from matplotlib.lines import Line2D
 
-class Point():
+
+class Point:
     "CC event"
+
     def __init__(self, x, y):
         self.x = x
         self.y = y
 
+
 def listx(points):
-  return list(map(lambda pt: pt.x, points))
+    return list(map(lambda pt: pt.x, points))
+
 
 def listy(points):
-  return list(map(lambda pt: pt.y, points))
+    return list(map(lambda pt: pt.y, points))
+
 
 def plot_data(d):
 
-  plt.figure(1)
-
-  cwndx = listx(d["cwnd"])
-  cwndy = listy(d["cwnd"])
-  congx = listx(d["congestion"])
-  congy = listy(d["congestion"])
-  rcvrdx = listx(d["recovered"])
-  rcvrdy = listy(d["recovered"])
-  rxttx = listx(d["rxtTimeout"])
-  rxtty = listy(d["rxtTimeout"])
-
-  # cwnd/ssthresh/cc events
-  plt.subplot(311)
-  plt.title("cwnd/ssthresh")
-  pcwnd = plt.plot(cwndx, cwndy, 'r')
-  psst = plt.plot(cwndx, d["ssthresh"], 'y-')
-  pcong = plt.plot(congx, congy,'yo')
-  precov = plt.plot(rcvrdx, rcvrdy,'co')
-  prxtt = plt.plot(rxttx, rxtty,'mo')
-
-  marker1 = Line2D(range(1), range(1), color="r")
-  marker2 = Line2D(range(1), range(1), color="y")
-  marker3 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="y")
-  marker4 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="c")
-  marker5 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="m")
-  plt.legend((marker1, marker2, marker3, marker4, marker5),
-             ('cwnd', 'ssthresh', 'congestion', 'recovered', 'rxt-timeout'),
-             loc=4)
-  axes = plt.gca()
-  axes.set_ylim([-20e4, max(cwndy) + 20e4])
-
-  # snd variables
-  plt.subplot(312)
-  plt.title("cc variables")
-  plt.plot(cwndx, d["space"], 'g-', markersize=1)
-  plt.plot(cwndx, d["flight"], 'b-', markersize=1)
-  plt.plot(cwndx, d["sacked"], 'm:', markersize=1)
-  plt.plot(cwndx, d["lost"], 'y:', markersize=1)
-  plt.plot(cwndx, d["cc-space"], 'k:', markersize=1)
-  plt.plot(cwndx, cwndy, 'ro', markersize=2)
-
-  plt.plot(congx, congy, 'y^', markersize=10, markerfacecolor="y")
-  plt.plot(rcvrdx, rcvrdy, 'c^', markersize=10, markerfacecolor="c")
-  plt.plot(rxttx, rxtty, 'm^', markersize=10, markerfacecolor="m")
-
-  #plt.plot(cwndx, d["snd_wnd"], 'ko', markersize=1)
-  plt.legend(("snd-space", "flight", "sacked", "lost", "cc-space", "cwnd",
-              "congestion", "recovered", "rxt-timeout"),
-             loc=1)
-
-  # rto/srrt/rttvar
-  plt.subplot(313)
-  plt.title("rtt")
-  plt.plot(cwndx, d["srtt"], 'g-')
-  plt.plot(cwndx, [x/1000 for x in d["mrtt-us"]], 'r-')
-  plt.plot(cwndx, d["rttvar"], 'b-')
-  plt.legend(["srtt", "mrtt-us", "rttvar"])
-  axes = plt.gca()
-  #plt.plot(cwndx, rto, 'r-')
-  #axes.set_ylim([0, int(max(rto[2:len(rto)])) + 50])
-
-  # show
-  plt.show()
-
-def find_pattern(file_path,session_idx):
+    plt.figure(1)
+
+    cwndx = listx(d["cwnd"])
+    cwndy = listy(d["cwnd"])
+    congx = listx(d["congestion"])
+    congy = listy(d["congestion"])
+    rcvrdx = listx(d["recovered"])
+    rcvrdy = listy(d["recovered"])
+    rxttx = listx(d["rxtTimeout"])
+    rxtty = listy(d["rxtTimeout"])
+
+    # cwnd/ssthresh/cc events
+    plt.subplot(311)
+    plt.title("cwnd/ssthresh")
+    pcwnd = plt.plot(cwndx, cwndy, "r")
+    psst = plt.plot(cwndx, d["ssthresh"], "y-")
+    pcong = plt.plot(congx, congy, "yo")
+    precov = plt.plot(rcvrdx, rcvrdy, "co")
+    prxtt = plt.plot(rxttx, rxtty, "mo")
+
+    marker1 = Line2D(range(1), range(1), color="r")
+    marker2 = Line2D(range(1), range(1), color="y")
+    marker3 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="y")
+    marker4 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="c")
+    marker5 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="m")
+    plt.legend(
+        (marker1, marker2, marker3, marker4, marker5),
+        ("cwnd", "ssthresh", "congestion", "recovered", "rxt-timeout"),
+        loc=4,
+    )
+    axes = plt.gca()
+    axes.set_ylim([-20e4, max(cwndy) + 20e4])
+
+    # snd variables
+    plt.subplot(312)
+    plt.title("cc variables")
+    plt.plot(cwndx, d["space"], "g-", markersize=1)
+    plt.plot(cwndx, d["flight"], "b-", markersize=1)
+    plt.plot(cwndx, d["sacked"], "m:", markersize=1)
+    plt.plot(cwndx, d["lost"], "y:", markersize=1)
+    plt.plot(cwndx, d["cc-space"], "k:", markersize=1)
+    plt.plot(cwndx, cwndy, "ro", markersize=2)
+
+    plt.plot(congx, congy, "y^", markersize=10, markerfacecolor="y")
+    plt.plot(rcvrdx, rcvrdy, "c^", markersize=10, markerfacecolor="c")
+    plt.plot(rxttx, rxtty, "m^", markersize=10, markerfacecolor="m")
+
+    # plt.plot(cwndx, d["snd_wnd"], 'ko', markersize=1)
+    plt.legend(
+        (
+            "snd-space",
+            "flight",
+            "sacked",
+            "lost",
+            "cc-space",
+            "cwnd",
+            "congestion",
+            "recovered",
+            "rxt-timeout",
+        ),
+        loc=1,
+    )
+
+    # rto/srrt/rttvar
+    plt.subplot(313)
+    plt.title("rtt")
+    plt.plot(cwndx, d["srtt"], "g-")
+    plt.plot(cwndx, [x / 1000 for x in d["mrtt-us"]], "r-")
+    plt.plot(cwndx, d["rttvar"], "b-")
+    plt.legend(["srtt", "mrtt-us", "rttvar"])
+    axes = plt.gca()
+    # plt.plot(cwndx, rto, 'r-')
+    # axes.set_ylim([0, int(max(rto[2:len(rto)])) + 50])
+
+    # show
+    plt.show()
+
+
+def find_pattern(file_path, session_idx):
     is_active_open = 1
     listener_pattern = "l\[\d\]"
-    if (is_active_open):
-      initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s+open:\s"
+    if is_active_open:
+        initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s+open:\s"
     else:
-      initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s"
+        initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s"
     idx = 0
-    f = open(file_path, 'r')
+    f = open(file_path, "r")
     for line in f:
-      # skip listener lines (server)
-      if (re.search(listener_pattern, line) != None):
-        continue
-      match = re.search(initial_pattern, line)
-      if (match == None):
-        continue
-      if (idx < session_idx):
-        idx += 1
-        continue
-      filter_pattern = str(match.group(1)) + "\s+(.+)"
-      print ("pattern is %s" % filter_pattern)
-      f.close()
-      return filter_pattern
-    raise Exception ("Could not find initial pattern")
+        # skip listener lines (server)
+        if re.search(listener_pattern, line) != None:
+            continue
+        match = re.search(initial_pattern, line)
+        if match == None:
+            continue
+        if idx < session_idx:
+            idx += 1
+            continue
+        filter_pattern = str(match.group(1)) + "\s+(.+)"
+        print("pattern is %s" % filter_pattern)
+        f.close()
+        return filter_pattern
+    raise Exception("Could not find initial pattern")
+
 
 def compute_time(min, sec, msec):
-  return int(min)*60 + int(sec) + int(msec)/1000.0
+    return int(min) * 60 + int(sec) + int(msec) / 1000.0
+
 
 def run(file_path, session_idx):
     filter_sessions = 1
     filter_pattern = ""
 
     patterns = {
-      "time"      : "^\d+:(\d+):(\d+):(\d+):\d+",
-      "listener"  : "l\[\d\]",
-      "cc"        : "cwnd (\d+) flight (\d+) space (\d+) ssthresh (\d+) snd_wnd (\d+)",
-      "cc-snd"    : "cc_space (\d+) sacked (\d+) lost (\d+)",
-      "rtt"       : "rto (\d+) srtt (\d+) mrtt-us (\d+) rttvar (\d+)",
-      "rxtt"      : "rxt-timeout",
-      "congestion": "congestion",
-      "recovered" : "recovered",
+        "time": "^\d+:(\d+):(\d+):(\d+):\d+",
+        "listener": "l\[\d\]",
+        "cc": "cwnd (\d+) flight (\d+) space (\d+) ssthresh (\d+) snd_wnd (\d+)",
+        "cc-snd": "cc_space (\d+) sacked (\d+) lost (\d+)",
+        "rtt": "rto (\d+) srtt (\d+) mrtt-us (\d+) rttvar (\d+)",
+        "rxtt": "rxt-timeout",
+        "congestion": "congestion",
+        "recovered": "recovered",
     }
     d = {
-      "cwnd"        : [],
-      "space"       : [],
-      "flight"      : [],
-      "ssthresh"    : [],
-      "snd_wnd"     : [],
-      "cc-space"    : [],
-      "lost"        : [],
-      "sacked"      : [],
-      "rto"         : [],
-      "srtt"        : [],
-      "mrtt-us"     : [],
-      "rttvar"      : [],
-      "rxtTimeout"  : [],
-      "congestion"  : [],
-      "recovered"   : [],
+        "cwnd": [],
+        "space": [],
+        "flight": [],
+        "ssthresh": [],
+        "snd_wnd": [],
+        "cc-space": [],
+        "lost": [],
+        "sacked": [],
+        "rto": [],
+        "srtt": [],
+        "mrtt-us": [],
+        "rttvar": [],
+        "rxtTimeout": [],
+        "congestion": [],
+        "recovered": [],
     }
 
-    if (filter_sessions):
+    if filter_sessions:
         filter_pattern = find_pattern(file_path, session_idx)
-    f = open(file_path, 'r')
+    f = open(file_path, "r")
 
     stats_index = 0
     start_time = 0
 
     for line in f:
         # skip listener lines (server)
-        if (re.search(patterns["listener"], line) != None):
+        if re.search(patterns["listener"], line) != None:
             continue
         # filter sessions
-        if (filter_sessions):
+        if filter_sessions:
             match = re.search(filter_pattern, line)
-            if (match == None):
+            if match == None:
                 continue
 
         original_line = line
         line = match.group(1)
-        match = re.search (patterns["time"], original_line)
-        if (match == None):
-          print "something went wrong! no time!"
-          continue
-        time = compute_time (match.group(1), match.group(2), match.group(3))
-        if (start_time == 0):
-          start_time = time
+        match = re.search(patterns["time"], original_line)
+        if match == None:
+            print("something went wrong! no time!")
+            continue
+        time = compute_time(match.group(1), match.group(2), match.group(3))
+        if start_time == 0:
+            start_time = time
 
         time = time - start_time
         match = re.search(patterns["cc"], line)
-        if (match != None):
-          d["cwnd"].append(Point(time, int(match.group(1))))
-          d["flight"].append(int(match.group(2)))
-          d["space"].append(int(match.group(3)))
-          d["ssthresh"].append(int(match.group(4)))
-          d["snd_wnd"].append(int(match.group(5)))
-          stats_index += 1
-          continue
+        if match != None:
+            d["cwnd"].append(Point(time, int(match.group(1))))
+            d["flight"].append(int(match.group(2)))
+            d["space"].append(int(match.group(3)))
+            d["ssthresh"].append(int(match.group(4)))
+            d["snd_wnd"].append(int(match.group(5)))
+            stats_index += 1
+            continue
         match = re.search(patterns["cc-snd"], line)
-        if (match != None):
-          d["cc-space"].append(int(match.group(1)))
-          d["sacked"].append(int(match.group(2)))
-          d["lost"].append(int(match.group(3)))
+        if match != None:
+            d["cc-space"].append(int(match.group(1)))
+            d["sacked"].append(int(match.group(2)))
+            d["lost"].append(int(match.group(3)))
         match = re.search(patterns["rtt"], line)
-        if (match != None):
-           d["rto"].append(int(match.group(1)))
-           d["srtt"].append(int(match.group(2)))
-           d["mrtt-us"].append(int(match.group(3)))
-           d["rttvar"].append(int(match.group(4)))
-        if (stats_index == 0):
-           continue
+        if match != None:
+            d["rto"].append(int(match.group(1)))
+            d["srtt"].append(int(match.group(2)))
+            d["mrtt-us"].append(int(match.group(3)))
+            d["rttvar"].append(int(match.group(4)))
+        if stats_index == 0:
+            continue
         match = re.search(patterns["rxtt"], line)
-        if (match != None):
-          d["rxtTimeout"].append(Point(time, d["cwnd"][stats_index - 1].y + 1e4))
-          continue
+        if match != None:
+            d["rxtTimeout"].append(Point(time, d["cwnd"][stats_index - 1].y + 1e4))
+            continue
         match = re.search(patterns["congestion"], line)
-        if (match != None):
-          d["congestion"].append(Point(time, d["cwnd"][stats_index - 1].y - 1e4))
-          continue
+        if match != None:
+            d["congestion"].append(Point(time, d["cwnd"][stats_index - 1].y - 1e4))
+            continue
         match = re.search(patterns["recovered"], line)
-        if (match != None):
-          d["recovered"].append(Point(time, d["cwnd"][stats_index - 1].y))
-          continue
+        if match != None:
+            d["recovered"].append(Point(time, d["cwnd"][stats_index - 1].y))
+            continue
 
     plot_data(d)
 
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Plot tcp cc logs")
-    parser.add_argument('-f', action='store', dest='file', required=True,
-                        help="elog file in txt format")
-    parser.add_argument('-s', action='store', dest='session_index', default=0,
-                        help="session index for which to plot cc logs" )
+    parser.add_argument(
+        "-f", action="store", dest="file", required=True, help="elog file in txt format"
+    )
+    parser.add_argument(
+        "-s",
+        action="store",
+        dest="session_index",
+        default=0,
+        help="session index for which to plot cc logs",
+    )
     results = parser.parse_args()
     run(results.file, int(results.session_index))
diff --git a/src/scripts/vnet/uri/dummy_app.py b/src/scripts/vnet/uri/dummy_app.py
index d96a378a193..7fab2d766ad 100755
--- a/src/scripts/vnet/uri/dummy_app.py
+++ b/src/scripts/vnet/uri/dummy_app.py
@@ -5,34 +5,41 @@ import sys
 import time
 import argparse
 
-# action can be reflect or drop 
+# action can be reflect or drop
 action = "drop"
 test = 0
 
-def test_data (data, n_rcvd):
-    n_read = len (data);
+
+def test_data(data, n_rcvd):
+    n_read = len(data)
     for i in range(n_read):
-        expected = (n_rcvd + i) & 0xff
-        byte_got = ord (data[i])
-        if (byte_got != expected):
-            print("Difference at byte {}. Expected {} got {}"
-                  .format(n_rcvd + i, expected, byte_got))
+        expected = (n_rcvd + i) & 0xFF
+        byte_got = ord(data[i])
+        if byte_got != expected:
+            print(
+                "Difference at byte {}. Expected {} got {}".format(
+                    n_rcvd + i, expected, byte_got
+                )
+            )
     return n_read
 
-def handle_connection (connection, client_address):
+
+def handle_connection(connection, client_address):
     print("Received connection from {}".format(repr(client_address)))
     n_rcvd = 0
     try:
         while True:
             data = connection.recv(4096)
             if not data:
-                break;
-            if (test == 1):
-                n_rcvd += test_data (data, n_rcvd)
-            if (action != "drop"):
+                break
+            if test == 1:
+                n_rcvd += test_data(data, n_rcvd)
+            if action != "drop":
                 connection.sendall(data)
     finally:
         connection.close()
+
+
 def run_tcp_server(ip, port):
     print("Starting TCP server {}:{}".format(repr(ip), repr(port)))
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -42,7 +49,9 @@ def run_tcp_server(ip, port):
     sock.listen(1)
     while True:
         connection, client_address = sock.accept()
-        handle_connection (connection, client_address)
+        handle_connection(connection, client_address)
+
+
 def run_udp_server(ip, port):
     print("Starting UDP server {}:{}".format(repr(ip), repr(port)))
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -51,22 +60,25 @@ def run_udp_server(ip, port):
     sock.bind(server_address)
     while True:
         data, addr = sock.recvfrom(4096)
-        if (action != "drop"):
-            #snd_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            sock.sendto (data, addr)
+        if action != "drop":
+            # snd_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            sock.sendto(data, addr)
+
 
 def run_server(ip, port, proto):
-    if (proto == "tcp"):
+    if proto == "tcp":
         run_tcp_server(ip, port)
-    elif (proto == "udp"):
+    elif proto == "udp":
         run_udp_server(ip, port)
 
+
 def prepare_data(power):
     buf = []
-    for i in range (0, pow(2, power)):
-        buf.append(i & 0xff)
+    for i in range(0, pow(2, power)):
+        buf.append(i & 0xFF)
     return bytearray(buf)
 
+
 def run_tcp_client(ip, port):
     print("Starting TCP client {}:{}".format(repr(ip), repr(port)))
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -75,28 +87,33 @@ def run_tcp_client(ip, port):
 
     data = prepare_data(16)
     n_rcvd = 0
-    n_sent = len (data)
+    n_sent = len(data)
     try:
         sock.sendall(data)
 
         timeout = time.time() + 2
         while n_rcvd < n_sent and time.time() < timeout:
             tmp = sock.recv(1500)
-            tmp = bytearray (tmp)
+            tmp = bytearray(tmp)
             n_read = len(tmp)
             for i in range(n_read):
-                if (data[n_rcvd + i] != tmp[i]):
-                    print("Difference at byte {}. Sent {} got {}"
-                          .format(n_rcvd + i, data[n_rcvd + i], tmp[i]))
+                if data[n_rcvd + i] != tmp[i]:
+                    print(
+                        "Difference at byte {}. Sent {} got {}".format(
+                            n_rcvd + i, data[n_rcvd + i], tmp[i]
+                        )
+                    )
             n_rcvd += n_read
 
-        if (n_rcvd < n_sent or n_rcvd > n_sent):
+        if n_rcvd < n_sent or n_rcvd > n_sent:
             print("Sent {} and got back {}".format(n_sent, n_rcvd))
         else:
-            print("Got back what we've sent!!");
+            print("Got back what we've sent!!")
 
     finally:
         sock.close()
+
+
 def run_udp_client(ip, port):
     print("Starting UDP client {}:{}".format(repr(ip), repr(port)))
     n_packets = 100
@@ -104,38 +121,43 @@ def run_udp_client(ip, port):
     server_address = (ip, int(port))
     data = prepare_data(10)
     try:
-        for i in range (0, n_packets):
+        for i in range(0, n_packets):
             sock.sendto(data, server_address)
     finally:
         sock.close()
+
+
 def run_client(ip, port, proto):
-    if (proto == "tcp"):
+    if proto == "tcp":
         run_tcp_client(ip, port)
-    elif (proto == "udp"):
+    elif proto == "udp":
         run_udp_client(ip, port)
+
+
 def run(mode, ip, port, proto):
-    if (mode == "server"):
-        run_server (ip, port, proto)
-    elif (mode == "client"):
-        run_client (ip, port, proto)
+    if mode == "server":
+        run_server(ip, port, proto)
+    elif mode == "client":
+        run_client(ip, port, proto)
     else:
         raise Exception("Unknown mode. Only client and server supported")
 
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument('-m', action='store', dest='mode')
-    parser.add_argument('-i', action='store', dest='ip')
-    parser.add_argument('-p', action='store', dest='port')
-    parser.add_argument('-proto', action='store', dest='proto')
-    parser.add_argument('-a', action='store', dest='action')
-    parser.add_argument('-t', action='store', dest='test')
+    parser.add_argument("-m", action="store", dest="mode")
+    parser.add_argument("-i", action="store", dest="ip")
+    parser.add_argument("-p", action="store", dest="port")
+    parser.add_argument("-proto", action="store", dest="proto")
+    parser.add_argument("-a", action="store", dest="action")
+    parser.add_argument("-t", action="store", dest="test")
     results = parser.parse_args()
     action = results.action
     test = results.test
     run(results.mode, results.ip, results.port, results.proto)
-    #if (len(sys.argv)) < 4:
+    # if (len(sys.argv)) < 4:
     #    raise Exception("Usage: ./dummy_app <mode> <ip> <port> [<action> <test>]")
-    #if (len(sys.argv) == 6):
+    # if (len(sys.argv) == 6):
     #    action = sys.argv[4]
     #    test = int(sys.argv[5])
-    #run (sys.argv[1], sys.argv[2], int(sys.argv[3]))
+    # run (sys.argv[1], sys.argv[2], int(sys.argv[3]))