autopep8 / flake8

1 files changed, 64 insertions, 49 deletions

diff --git a/lib/plotter.py b/lib/plotter.py
index 30b5b82..b9d5c3e 100755
--- a/lib/plotter.py
+++ b/lib/plotter.py
@@ -4,69 +4,79 @@ import itertools
 import numpy as np
 import matplotlib.pyplot as plt
 import re
-from matplotlib.patches import Polygon
-from utils import flatten
+
 
 def is_state(aggregate, name):
     """Return true if name is a state and not UNINITIALIZED."""
     return aggregate[name]['isa'] == 'state' and name != 'UNINITIALIZED'
 
+
 def plot_states(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if is_state(aggregate, key)]
     data = [aggregate[key]['means'] for key in keys]
     mdata = [int(model['state'][key]['power']['static']) for key in keys]
-    boxplot(keys, data, 'Zustand', 'µW', modeldata = mdata)
+    boxplot(keys, data, 'Zustand', 'µW', modeldata=mdata)
+
 
 def plot_transitions(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if aggregate[key]['isa'] == 'transition']
     data = [aggregate[key]['rel_energies'] for key in keys]
     mdata = [int(model['transition'][key]['rel_energy']['static']) for key in keys]
-    boxplot(keys, data, 'Transition', 'pJ (rel)', modeldata = mdata)
+    boxplot(keys, data, 'Transition', 'pJ (rel)', modeldata=mdata)
     data = [aggregate[key]['energies'] for key in keys]
     mdata = [int(model['transition'][key]['energy']['static']) for key in keys]
-    boxplot(keys, data, 'Transition', 'pJ', modeldata = mdata)
+    boxplot(keys, data, 'Transition', 'pJ', modeldata=mdata)
+
 
 def plot_states_duration(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if is_state(aggregate, key)]
     data = [aggregate[key]['durations'] for key in keys]
     boxplot(keys, data, 'Zustand', 'µs')
 
+
 def plot_transitions_duration(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if aggregate[key]['isa'] == 'transition']
     data = [aggregate[key]['durations'] for key in keys]
     boxplot(keys, data, 'Transition', 'µs')
 
+
 def plot_transitions_timeout(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if aggregate[key]['isa'] == 'transition']
     data = [aggregate[key]['timeouts'] for key in keys]
     boxplot(keys, data, 'Timeout', 'µs')
 
+
 def plot_states_clips(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if is_state(aggregate, key)]
     data = [np.array([100]) * aggregate[key]['clip_rate'] for key in keys]
     boxplot(keys, data, 'Zustand', '% Clipping')
 
+
 def plot_transitions_clips(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if aggregate[key]['isa'] == 'transition']
     data = [np.array([100]) * aggregate[key]['clip_rate'] for key in keys]
     boxplot(keys, data, 'Transition', '% Clipping')
 
+
 def plot_substate_thresholds(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if is_state(aggregate, key)]
     data = [aggregate[key]['sub_thresholds'] for key in keys]
     boxplot(keys, data, 'Zustand', 'substate threshold (mW/dmW)')
 
+
 def plot_histogram(data):
     n, bins, patches = plt.hist(data, 1000, normed=1, facecolor='green', alpha=0.75)
     plt.show()
 
+
 def plot_states_param(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if aggregate[key]['isa'] == 'state' and key[0] != 'UNINITIALIZED']
     data = [aggregate[key]['means'] for key in keys]
     mdata = [int(model['state'][key[0]]['power']['static']) for key in keys]
-    boxplot(keys, data, 'Transition', 'µW', modeldata = mdata)
+    boxplot(keys, data, 'Transition', 'µW', modeldata=mdata)
 
-def plot_attribute(aggregate, attribute, attribute_unit = '', key_filter = lambda x: True, **kwargs):
+
+def plot_attribute(aggregate, attribute, attribute_unit='', key_filter=lambda x: True, **kwargs):
     """
     Boxplot measurements of a single attribute according to the partitioning provided by aggregate.
 
@@ -82,23 +92,26 @@ def plot_attribute(aggregate, attribute, attribute_unit = '', key_filter = lambd
     data = [aggregate[key][attribute] for key in keys]
     boxplot(keys, data, attribute, attribute_unit, **kwargs)
 
+
 def plot_substate_thresholds_p(model, aggregate):
     keys = [key for key in sorted(aggregate.keys()) if aggregate[key]['isa'] == 'state' and key[0] != 'UNINITIALIZED']
     data = [aggregate[key]['sub_thresholds'] for key in keys]
     boxplot(keys, data, 'Zustand', '% Clipping')
 
+
 def plot_y(Y, **kwargs):
     plot_xy(np.arange(len(Y)), Y, **kwargs)
 
-def plot_xy(X, Y, xlabel = None, ylabel = None, title = None, output = None):
-    fig, ax1 = plt.subplots(figsize=(10,6))
-    if title != None:
+
+def plot_xy(X, Y, xlabel=None, ylabel=None, title=None, output=None):
+    fig, ax1 = plt.subplots(figsize=(10, 6))
+    if title is not None:
         fig.canvas.set_window_title(title)
-    if xlabel != None:
+    if xlabel is not None:
         ax1.set_xlabel(xlabel)
-    if ylabel != None:
+    if ylabel is not None:
         ax1.set_ylabel(ylabel)
-    plt.subplots_adjust(left = 0.1, bottom = 0.1, right = 0.99, top = 0.99)
+    plt.subplots_adjust(left=0.1, bottom=0.1, right=0.99, top=0.99)
     plt.plot(X, Y, "bo", markersize=2)
     if output:
         plt.savefig(output)
@@ -109,18 +122,20 @@ def plot_xy(X, Y, xlabel = None, ylabel = None, title = None, output = None):
     else:
         plt.show()
 
+
 def _param_slice_eq(a, b, index):
-    return (*a[1][:index], *a[1][index+1:]) == (*b[1][:index], *b[1][index+1:]) and a[0] == b[0]
+    return (*a[1][:index], *a[1][index + 1:]) == (*b[1][:index], *b[1][index + 1:]) and a[0] == b[0]
+
 
-def plot_param(model, state_or_trans, attribute, param_idx, xlabel = None, ylabel = None, title = None, extra_function = None, output = None):
-    fig, ax1 = plt.subplots(figsize=(10,6))
-    if title != None:
+def plot_param(model, state_or_trans, attribute, param_idx, xlabel=None, ylabel=None, title=None, extra_function=None, output=None):
+    fig, ax1 = plt.subplots(figsize=(10, 6))
+    if title is not None:
         fig.canvas.set_window_title(title)
-    if xlabel != None:
+    if xlabel is not None:
         ax1.set_xlabel(xlabel)
-    if ylabel != None:
+    if ylabel is not None:
         ax1.set_ylabel(ylabel)
-    plt.subplots_adjust(left = 0.1, bottom = 0.1, right = 0.99, top = 0.99)
+    plt.subplots_adjust(left=0.1, bottom=0.1, right=0.99, top=0.99)
 
     param_name = model.param_name(param_idx)
 
@@ -137,8 +152,8 @@ def plot_param(model, state_or_trans, attribute, param_idx, xlabel = None, ylabe
 
     for k, v in model.by_param.items():
         if k[0] == state_or_trans:
-            other_param_key = (*k[1][:param_idx], *k[1][param_idx+1:])
-            if not other_param_key in by_other_param:
+            other_param_key = (*k[1][:param_idx], *k[1][param_idx + 1:])
+            if other_param_key not in by_other_param:
                 by_other_param[other_param_key] = {'X': [], 'Y': []}
             by_other_param[other_param_key]['X'].extend([float(k[1][param_idx])] * len(v[attribute]))
             by_other_param[other_param_key]['Y'].extend(v[attribute])
@@ -153,7 +168,7 @@ def plot_param(model, state_or_trans, attribute, param_idx, xlabel = None, ylabe
     YY2_legend = []
 
     cm = plt.get_cmap('brg', len(by_other_param))
-    for i, k in sorted(enumerate(by_other_param), key = lambda x: x[1]):
+    for i, k in sorted(enumerate(by_other_param), key=lambda x: x[1]):
         v = by_other_param[k]
         v['X'] = np.array(v['X'])
         v['Y'] = np.array(v['Y'])
@@ -169,17 +184,17 @@ def plot_param(model, state_or_trans, attribute, param_idx, xlabel = None, ylabe
             for i in range(len(v['X'])):
                 print('{} {}'.format(v['X'][i], v['Y'][i]), file=f)
 
-        #x_range = int((v['X'].max() - v['X'].min()) * 10)
-        #xsp = np.linspace(v['X'].min(), v['X'].max(), x_range)
+        # x_range = int((v['X'].max() - v['X'].min()) * 10)
+        # xsp = np.linspace(v['X'].min(), v['X'].max(), x_range)
         if param_model:
             ysp = []
             for x in xsp:
                 xarg = [*k[:param_idx], x, *k[param_idx:]]
-                ysp.append(param_model(state_or_trans, attribute, param = xarg))
+                ysp.append(param_model(state_or_trans, attribute, param=xarg))
             plt.plot(xsp, ysp, "r-", color=cm(i), linewidth=0.5)
             YY.append(ysp)
             YY_legend.append(legend_sanitizer.sub('_', 'regr_{}'.format(k)))
-        if extra_function != None:
+        if extra_function is not None:
             ysp = []
             with np.errstate(divide='ignore', invalid='ignore'):
                 for x in xsp:
@@ -202,7 +217,7 @@ def plot_param(model, state_or_trans, attribute, param_idx, xlabel = None, ylabe
 
 
 def plot_param_fit(function, name, fitfunc, funp, parameters, datatype, index, X, Y, xaxis=None, yaxis=None):
-    fig, ax1 = plt.subplots(figsize=(10,6))
+    fig, ax1 = plt.subplots(figsize=(10, 6))
     fig.canvas.set_window_title("fit %s" % (function))
     plt.subplots_adjust(left=0.14, right=0.99, top=0.99, bottom=0.14)
 
@@ -214,16 +229,16 @@ def plot_param_fit(function, name, fitfunc, funp, parameters, datatype, index, X
         xsp = np.linspace(X[index].min(), X[index].max(), 100)
         x_range = 100
 
-    if xaxis != None:
+    if xaxis is not None:
         ax1.set_xlabel(xaxis)
     else:
         ax1.set_xlabel(parameters[index])
-    if yaxis != None:
+    if yaxis is not None:
         ax1.set_ylabel(yaxis)
     else:
         ax1.set_ylabel('%s %s' % (name, datatype))
 
-    otherparams = list(set(itertools.product(*X[:index], *X[index+1:])))
+    otherparams = list(set(itertools.product(*X[:index], *X[index + 1:])))
     cm = plt.get_cmap('brg', len(otherparams))
     for i in range(len(otherparams)):
         elem = otherparams[i]
@@ -234,7 +249,7 @@ def plot_param_fit(function, name, fitfunc, funp, parameters, datatype, index, X
             if k < index:
                 tt &= X[k] == elem[k]
             elif k > index:
-                tt &= X[k] == elem[k-1]
+                tt &= X[k] == elem[k - 1]
 
         plt.plot(X[index][tt], Y[tt], "rx", color=color)
 
@@ -245,8 +260,8 @@ def plot_param_fit(function, name, fitfunc, funp, parameters, datatype, index, X
     plt.show()
 
 
-def boxplot(ticks, measurements, xlabel = '', ylabel = '', modeldata = None, output = None):
-    fig, ax1 = plt.subplots(figsize=(10,6))
+def boxplot(ticks, measurements, xlabel='', ylabel='', modeldata=None, output=None):
+    fig, ax1 = plt.subplots(figsize=(10, 6))
     fig.canvas.set_window_title('DriverEval')
     plt.subplots_adjust(left=0.1, right=0.95, top=0.95, bottom=0.1)
 
@@ -256,10 +271,10 @@ def boxplot(ticks, measurements, xlabel = '', ylabel = '', modeldata = None, out
     plt.setp(bp['fliers'], color='red', marker='+')
 
     ax1.yaxis.grid(True, linestyle='-', which='major', color='lightgrey',
-                alpha=0.5)
+                   alpha=0.5)
 
     ax1.set_axisbelow(True)
-    #ax1.set_title('DriverEval')
+    # ax1.set_title('DriverEval')
     ax1.set_xlabel(xlabel)
     ax1.set_ylabel(ylabel)
 
@@ -268,7 +283,7 @@ def boxplot(ticks, measurements, xlabel = '', ylabel = '', modeldata = None, out
     xtickNames = plt.setp(ax1, xticklabels=ticks)
     plt.setp(xtickNames, rotation=0, fontsize=10)
 
-    boxColors = ['darkkhaki', 'royalblue']
+    # boxColors = ['darkkhaki', 'royalblue']
     medians = list(range(numBoxes))
     for i in range(numBoxes):
         box = bp['boxes'][i]
@@ -277,11 +292,11 @@ def boxplot(ticks, measurements, xlabel = '', ylabel = '', modeldata = None, out
         for j in range(5):
             boxX.append(box.get_xdata()[j])
             boxY.append(box.get_ydata()[j])
-        boxCoords = list(zip(boxX, boxY))
+        # boxCoords = list(zip(boxX, boxY))
         # Alternate between Dark Khaki and Royal Blue
-        k = i % 2
-        boxPolygon = Polygon(boxCoords, facecolor=boxColors[k])
-        #ax1.add_patch(boxPolygon)
+        # k = i % 2
+        # boxPolygon = Polygon(boxCoords, facecolor=boxColors[k])
+        # ax1.add_patch(boxPolygon)
         # Now draw the median lines back over what we just filled in
         med = bp['medians'][i]
         medianX = []
@@ -294,22 +309,22 @@ def boxplot(ticks, measurements, xlabel = '', ylabel = '', modeldata = None, out
         # Finally, overplot the sample averages, with horizontal alignment
         # in the center of each box
         plt.plot([np.average(med.get_xdata())], [np.average(measurements[i])],
-                color='w', marker='*', markeredgecolor='k')
+                 color='w', marker='*', markeredgecolor='k')
         if modeldata:
             plt.plot([np.average(med.get_xdata())], [modeldata[i]],
-                color='w', marker='o', markeredgecolor='k')
+                     color='w', marker='o', markeredgecolor='k')
 
     pos = np.arange(numBoxes) + 1
     upperLabels = [str(np.round(s, 2)) for s in medians]
-    weights = ['bold', 'semibold']
+    # weights = ['bold', 'semibold']
     for tick, label in zip(range(numBoxes), ax1.get_xticklabels()):
-        k = tick % 2
+        # k = tick % 2
         y0, y1 = ax1.get_ylim()
-        textpos = y0 + (y1 - y0)*0.97
-        ypos = ax1.get_ylim()[0]
+        textpos = y0 + (y1 - y0) * 0.97
+        # ypos = ax1.get_ylim()[0]
         ax1.text(pos[tick], textpos, upperLabels[tick],
-                horizontalalignment='center', size='small',
-                color='royalblue')
+                 horizontalalignment='center', size='small',
+                 color='royalblue')
 
     if output:
         plt.savefig(output)