autopep8

6 files changed, 351 insertions, 337 deletions

diff --git a/lib/automata.py b/lib/automata.py
index 43f761c..eab58fb 100755
--- a/lib/automata.py
+++ b/lib/automata.py
@@ -708,7 +708,7 @@ class PTA:
                 min_state = state
         return min_state
 
-    def min_duration_until_energy_overflow(self, energy_granularity = 1e-12, max_energy_value = 2 ** 32 - 1):
+    def min_duration_until_energy_overflow(self, energy_granularity=1e-12, max_energy_value=2 ** 32 - 1):
         """
         Return minimum duration (in s) until energy counter overflow during online accounting.
 
@@ -726,7 +726,7 @@ class PTA:
         min_duration = max_energy_value * energy_granularity / max_power
         return min_duration
 
-    def max_duration_until_energy_overflow(self, energy_granularity = 1e-12, max_energy_value = 2 ** 32 - 1):
+    def max_duration_until_energy_overflow(self, energy_granularity=1e-12, max_energy_value=2 ** 32 - 1):
         """
         Return maximum duration (in s) until energy counter overflow during online accounting.
 
diff --git a/lib/utils.py b/lib/utils.py
index f040638..2e635a7 100644
--- a/lib/utils.py
+++ b/lib/utils.py
@@ -3,6 +3,7 @@ import re
 
 arg_support_enabled = True
 
+
 def vprint(verbose, string):
     """
     Print `string` if `verbose`.
@@ -12,9 +13,10 @@ def vprint(verbose, string):
     if verbose:
         print(string)
 
+
 def is_numeric(n):
     """Check if `n` is numeric (i.e., it can be converted to float)."""
-    if n == None:
+    if n is None:
         return False
     try:
         float(n)
@@ -22,19 +24,22 @@ def is_numeric(n):
     except ValueError:
         return False
 
+
 def is_power_of_two(n):
     """Check if `n` is a power of two (1, 2, 4, 8, 16, ...)."""
-    return n > 0 and (n & (n-1)) == 0
+    return n > 0 and (n & (n - 1)) == 0
+
 
 def float_or_nan(n):
     """Convert `n` to float (if numeric) or NaN."""
-    if n == None:
+    if n is None:
         return np.nan
     try:
         return float(n)
     except ValueError:
         return np.nan
 
+
 def soft_cast_int(n):
     """
     Convert `n` to int (if numeric) or return it as-is.
@@ -42,13 +47,14 @@ def soft_cast_int(n):
     If `n` is empty, returns None.
     If `n` is not numeric, it is left unchanged.
     """
-    if n == None or n == '':
+    if n is None or n == '':
         return None
     try:
         return int(n)
     except ValueError:
         return n
 
+
 def soft_cast_float(n):
     """
     Convert `n` to float (if numeric) or return it as-is.
@@ -56,7 +62,7 @@ def soft_cast_float(n):
     If `n` is empty, returns None.
     If `n` is not numeric, it is left unchanged.
     """
-    if n == None or n == '':
+    if n is None or n == '':
         return None
     try:
         return float(n)
@@ -72,6 +78,7 @@ def flatten(somelist):
     """
     return [item for sublist in somelist for item in sublist]
 
+
 def parse_conf_str(conf_str):
     """
     Parse a configuration string `k1=v1,k2=v2`... and return a dict `{'k1': v1, 'k2': v2}`...
@@ -84,6 +91,7 @@ def parse_conf_str(conf_str):
         conf_dict[key] = soft_cast_float(value)
     return conf_dict
 
+
 def remove_index_from_tuple(parameters, index):
     """
     Remove the element at `index` from tuple `parameters`.
@@ -92,7 +100,8 @@ def remove_index_from_tuple(parameters, index):
     :param index: index of element which is to be removed
     :returns: parameters tuple without the element at index
     """
-    return (*parameters[:index], *parameters[index+1:])
+    return (*parameters[:index], *parameters[index + 1:])
+
 
 def param_slice_eq(a, b, index):
     """
@@ -110,10 +119,11 @@ def param_slice_eq(a, b, index):
     ('foo', [1, 4]), ('foo', [2, 4]), 1 -> False
 
     """
-    if (*a[1][:index], *a[1][index+1:]) == (*b[1][:index], *b[1][index+1:]) and a[0] == b[0]:
+    if (*a[1][:index], *a[1][index + 1:]) == (*b[1][:index], *b[1][index + 1:]) and a[0] == b[0]:
         return True
     return False
 
+
 def match_parameter_values(input_param: dict, match_param: dict):
     """
     Check whether one of the paramaters in `input_param` has the same value in `match_param`.
@@ -129,6 +139,7 @@ def match_parameter_values(input_param: dict, match_param: dict):
             return False
     return True
 
+
 def by_name_to_by_param(by_name: dict):
     """
     Convert aggregation by name to aggregation by name and parameter values.
@@ -151,6 +162,7 @@ def by_name_to_by_param(by_name: dict):
             by_param[param_key]['param'].append(by_name[name]['param'][i])
     return by_param
 
+
 def filter_aggregate_by_param(aggregate, parameters, parameter_filter):
     """
     Remove entries which do not have certain parameter values from `aggregate`.
@@ -180,8 +192,9 @@ def filter_aggregate_by_param(aggregate, parameters, parameter_filter):
         for name in names_to_remove:
             aggregate.pop(name)
 
+
 class OptionalTimingAnalysis:
-    def __init__(self, enabled = True):
+    def __init__(self, enabled=True):
         self.enabled = enabled
         self.wrapped_lines = list()
         self.index = 1
diff --git a/test/test_codegen.py b/test/test_codegen.py
index e9b4067..bdde484 100755
--- a/test/test_codegen.py
+++ b/test/test_codegen.py
@@ -5,87 +5,88 @@ from codegen import get_simulated_accountingmethod
 import unittest
 
 example_json_1 = {
-    'parameters' : ['datarate', 'txbytes', 'txpower'],
-    'initial_param_values' : [None, None, None],
-    'state' : {
-        'IDLE' : {
-            'power' : {
-                'static' : 5,
+    'parameters': ['datarate', 'txbytes', 'txpower'],
+    'initial_param_values': [None, None, None],
+    'state': {
+        'IDLE': {
+            'power': {
+                'static': 5,
             }
         },
-        'TX' : {
-            'power' : {
-                'static' : 100,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * parameter(txpower)',
-                    'regression_args' : [ 100, 2 ]
+        'TX': {
+            'power': {
+                'static': 100,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * parameter(txpower)',
+                    'regression_args': [100, 2]
                 },
             }
         },
     },
-    'transitions' : [
+    'transitions': [
         {
-            'name' : 'init',
-            'origin' : ['UNINITIALIZED', 'IDLE'],
-            'destination' : 'IDLE',
-            'duration' : {
-                'static' : 50000,
+            'name': 'init',
+            'origin': ['UNINITIALIZED', 'IDLE'],
+            'destination': 'IDLE',
+            'duration': {
+                'static': 50000,
             },
-            'set_param' : {
-                'txpower' : 10
+            'set_param': {
+                'txpower': 10
             },
         },
         {
-            'name' : 'setTxPower',
-            'origin' : 'IDLE',
-            'destination' : 'IDLE',
-            'duration' : { 'static' : 120 },
-            'energy ' : { 'static' : 10000 },
-            'arg_to_param_map' : { 0: 'txpower'},
-            'argument_values' : [ [10, 20, 30] ],
+            'name': 'setTxPower',
+            'origin': 'IDLE',
+            'destination': 'IDLE',
+            'duration': {'static': 120},
+            'energy ': {'static': 10000},
+            'arg_to_param_map': {0: 'txpower'},
+            'argument_values': [[10, 20, 30]],
         },
         {
-            'name' : 'send',
-            'origin' : 'IDLE',
-            'destination' : 'TX',
-            'duration' : {
-                'static' : 10,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * function_arg(1)',
-                    'regression_args' : [48, 8],
+            'name': 'send',
+            'origin': 'IDLE',
+            'destination': 'TX',
+            'duration': {
+                'static': 10,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * function_arg(1)',
+                    'regression_args': [48, 8],
                 },
             },
-            'energy' : {
-                'static' : 3,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * function_arg(1)',
-                    'regression_args' : [3, 5],
+            'energy': {
+                'static': 3,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * function_arg(1)',
+                    'regression_args': [3, 5],
                 },
             },
-            'arg_to_param_map' : { 1: 'txbytes'},
-            'argument_values' : [ ['"foo"', '"hodor"'], [3, 5] ],
-            'argument_combination' : 'zip',
+            'arg_to_param_map': {1: 'txbytes'},
+            'argument_values': [['"foo"', '"hodor"'], [3, 5]],
+            'argument_combination': 'zip',
         },
         {
-            'name' : 'txComplete',
-            'origin' : 'TX',
-            'destination' : 'IDLE',
-            'is_interrupt' : 1,
-            'timeout' : {
-                'static' : 2000,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * parameter(txbytes)',
-                    'regression_args' : [ 500, 16 ],
+            'name': 'txComplete',
+            'origin': 'TX',
+            'destination': 'IDLE',
+            'is_interrupt': 1,
+            'timeout': {
+                'static': 2000,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * parameter(txbytes)',
+                    'regression_args': [500, 16],
                 },
             },
         }
     ],
 }
 
+
 class TestCG(unittest.TestCase):
     def test_statetransition_immediate(self):
         pta = PTA.from_json(example_json_1)
@@ -119,11 +120,11 @@ class TestCG(unittest.TestCase):
         cg.sleep(90)
         self.assertEqual(cg.get_energy(), 900)
 
-        pta.state['IDLE'].power = 9 # -> 90 uW
-        pta.transitions[1].energy = 1 # -> 100 pJ
+        pta.state['IDLE'].power = 9  # -> 90 uW
+        pta.transitions[1].energy = 1  # -> 100 pJ
         cg = get_simulated_accountingmethod('static_statetransition_immediate')(pta, 1000000, 'uint8_t', 'uint8_t', 'uint8_t', 'uint8_t', 1e-5, 1e-5, 1e-10)
         cg.current_state = pta.state['IDLE']
-        cg.sleep(10) # 10 us
+        cg.sleep(10)  # 10 us
         self.assertEqual(cg.get_energy(), 90 * 10)
         cg.pass_transition(pta.transitions[1])
         self.assertAlmostEqual(cg.get_energy(), 90 * 10 + 100, places=0)
diff --git a/test/test_pta.py b/test/test_pta.py
index ff67fb5..5158005 100755
--- a/test/test_pta.py
+++ b/test/test_pta.py
@@ -5,81 +5,81 @@ import unittest
 import yaml
 
 example_json_1 = {
-    'parameters' : ['datarate', 'txbytes', 'txpower'],
-    'initial_param_values' : [None, None, None],
-    'state' : {
-        'IDLE' : {
-            'power' : {
-                'static' : 5,
+    'parameters': ['datarate', 'txbytes', 'txpower'],
+    'initial_param_values': [None, None, None],
+    'state': {
+        'IDLE': {
+            'power': {
+                'static': 5,
             }
         },
-        'TX' : {
-            'power' : {
-                'static' : 10000,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * parameter(txpower)',
-                    'regression_args' : [ 10000, 2 ]
+        'TX': {
+            'power': {
+                'static': 10000,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * parameter(txpower)',
+                    'regression_args': [10000, 2]
                 },
             }
         },
     },
-    'transitions' : [
+    'transitions': [
         {
-            'name' : 'init',
-            'origin' : ['UNINITIALIZED', 'IDLE'],
-            'destination' : 'IDLE',
-            'duration' : {
-                'static' : 50000,
+            'name': 'init',
+            'origin': ['UNINITIALIZED', 'IDLE'],
+            'destination': 'IDLE',
+            'duration': {
+                'static': 50000,
             },
-            'set_param' : {
-                'txpower' : 10
+            'set_param': {
+                'txpower': 10
             },
         },
         {
-            'name' : 'setTxPower',
-            'origin' : 'IDLE',
-            'destination' : 'IDLE',
-            'duration' : { 'static' : 120 },
-            'energy ' : { 'static' : 10000 },
-            'arg_to_param_map' : { 0: 'txpower'},
-            'argument_values' : [ [10, 20, 30] ],
+            'name': 'setTxPower',
+            'origin': 'IDLE',
+            'destination': 'IDLE',
+            'duration': {'static': 120},
+            'energy ': {'static': 10000},
+            'arg_to_param_map': {0: 'txpower'},
+            'argument_values': [[10, 20, 30]],
         },
         {
-            'name' : 'send',
-            'origin' : 'IDLE',
-            'destination' : 'TX',
-            'duration' : {
-                'static' : 10,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * function_arg(1)',
-                    'regression_args' : [48, 8],
+            'name': 'send',
+            'origin': 'IDLE',
+            'destination': 'TX',
+            'duration': {
+                'static': 10,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * function_arg(1)',
+                    'regression_args': [48, 8],
                 },
             },
-            'energy' : {
-                'static' : 3,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * function_arg(1)',
-                    'regression_args' : [3, 5],
+            'energy': {
+                'static': 3,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * function_arg(1)',
+                    'regression_args': [3, 5],
                 },
             },
-            'arg_to_param_map' : { 1: 'txbytes'},
-            'argument_values' : [ ['"foo"', '"hodor"'], [3, 5] ],
-            'argument_combination' : 'zip',
+            'arg_to_param_map': {1: 'txbytes'},
+            'argument_values': [['"foo"', '"hodor"'], [3, 5]],
+            'argument_combination': 'zip',
         },
         {
-            'name' : 'txComplete',
-            'origin' : 'TX',
-            'destination' : 'IDLE',
-            'is_interrupt' : 1,
-            'timeout' : {
-                'static' : 2000,
-                'function' : {
-                    'raw' : 'regression_arg(0) + regression_arg(1)'
-                        ' * parameter(txbytes)',
-                    'regression_args' : [ 500, 16 ],
+            'name': 'txComplete',
+            'origin': 'TX',
+            'destination': 'IDLE',
+            'is_interrupt': 1,
+            'timeout': {
+                'static': 2000,
+                'function': {
+                    'raw': 'regression_arg(0) + regression_arg(1)'
+                    ' * parameter(txbytes)',
+                    'regression_args': [500, 16],
                 },
             },
         }
@@ -262,6 +262,7 @@ transition:
     argument_combination: zip
 """)
 
+
 def dfs_tran_to_name(runs: list, with_args: bool = False, with_param: bool = False) -> list:
     if with_param:
         return list(map(lambda run: list(map(lambda x: (x[0].name, x[1], x[2]), run)), runs))
@@ -269,6 +270,7 @@ def dfs_tran_to_name(runs: list, with_args: bool = False, with_param: bool = Fal
         return list(map(lambda run: list(map(lambda x: (x[0].name, x[1]), run)), runs))
     return list(map(lambda run: list(map(lambda x: (x[0].name), run)), runs))
 
+
 class TestPTA(unittest.TestCase):
     def test_dfs(self):
         pta = PTA(['IDLE', 'TX'])
@@ -287,9 +289,9 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(dfs_tran_to_name(pta.dfs(0), False), [['init']])
         self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1), False)), [['init', 'set1'], ['init', 'set2']])
         self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(2), False)), [['init', 'set1', 'set1'],
-            ['init', 'set1', 'set2'],
-            ['init', 'set2', 'set1'],
-            ['init', 'set2', 'set2']])
+                                                                       ['init', 'set1', 'set2'],
+                                                                       ['init', 'set2', 'set1'],
+                                                                       ['init', 'set2', 'set2']])
 
     def test_dfs_trace_filter(self):
         pta = PTA(['IDLE'])
@@ -297,12 +299,12 @@ class TestPTA(unittest.TestCase):
         pta.add_transition('IDLE', 'IDLE', 'set1')
         pta.add_transition('IDLE', 'IDLE', 'set2')
         self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(2, trace_filter=[['init', 'set1', 'set2'], ['init', 'set2', 'set1']]), False)),
-            [['init', 'set1', 'set2'], ['init', 'set2', 'set1']])
+                         [['init', 'set1', 'set2'], ['init', 'set2', 'set1']])
         self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(2, trace_filter=[['init', 'set1', '$'], ['init', 'set2', '$']]), False)),
-            [['init', 'set1'], ['init', 'set2']])
+                         [['init', 'set1'], ['init', 'set2']])
 
     def test_dfs_accepting(self):
-        pta = PTA(['IDLE', 'TX'], accepting_states = ['IDLE'])
+        pta = PTA(['IDLE', 'TX'], accepting_states=['IDLE'])
         pta.add_transition('UNINITIALIZED', 'IDLE', 'init')
         pta.add_transition('IDLE', 'TX', 'send')
         pta.add_transition('TX', 'IDLE', 'txComplete')
@@ -332,7 +334,7 @@ class TestPTA(unittest.TestCase):
         pta.add_transition('UNINITIALIZED', 'IDLE', 'init')
         pta.add_transition('IDLE', 'TX', 'send')
         pta.add_transition('TX', 'IDLE', 'txComplete')
-        traces = list(pta.dfs(2, sleep = 10))
+        traces = list(pta.dfs(2, sleep=10))
         self.assertEqual(len(traces), 1)
         trace = traces[0]
         self.assertEqual(len(trace), 6)
@@ -359,7 +361,7 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(pta.transitions[3].name, 'send')
         self.assertEqual(pta.transitions[4].name, 'txComplete')
 
-    #def test_to_json(self):
+    # def test_to_json(self):
     #    pta = PTA.from_json(example_json_1)
     #    json = pta.to_json()
     #    json['state'].pop('UNINITIALIZED')
@@ -369,152 +371,149 @@ class TestPTA(unittest.TestCase):
     def test_from_json_dfs_arg(self):
         pta = PTA.from_json(example_json_1)
         self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1), False)), [['init', 'init'], ['init', 'send'], ['init', 'setTxPower']])
-        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments = True), True)),
-            [
-                [('init', ()), ('init', ())],
-                [('init', ()), ('send', ('"foo"', 3))],
-                [('init', ()), ('send', ('"hodor"', 5))],
-                [('init', ()), ('setTxPower', (10,))],
-                [('init', ()), ('setTxPower', (20,))],
-                [('init', ()), ('setTxPower', (30,))],
-            ]
+        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments=True), True)),
+                         [
+            [('init', ()), ('init', ())],
+            [('init', ()), ('send', ('"foo"', 3))],
+            [('init', ()), ('send', ('"hodor"', 5))],
+            [('init', ()), ('setTxPower', (10,))],
+            [('init', ()), ('setTxPower', (20,))],
+            [('init', ()), ('setTxPower', (30,))],
+        ]
         )
 
     def test_from_json_dfs_param(self):
         pta = PTA.from_json(example_json_1)
         no_param = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': None,
         }
         param_tx3 = {
-            'datarate' : None,
-            'txbytes' : 3,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': 3,
+            'txpower': None,
         }
         param_tx5 = {
-            'datarate' : None,
-            'txbytes' : 5,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': 5,
+            'txpower': None,
         }
         param_txp10 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 10,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 10,
         }
         param_txp20 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 20,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 20,
         }
         param_txp30 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 30,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 30,
         }
-        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments = True, with_parameters = True), True, True)),
-            [
-                [('init', (), no_param), ('init', (), no_param)],
-                [('init', (), no_param), ('send', ('"foo"', 3), param_tx3)],
-                [('init', (), no_param), ('send', ('"hodor"', 5), param_tx5)],
-                [('init', (), no_param), ('setTxPower', (10,), param_txp10)],
-                [('init', (), no_param), ('setTxPower', (20,), param_txp20)],
-                [('init', (), no_param), ('setTxPower', (30,), param_txp30)],
-            ]
+        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments=True, with_parameters=True), True, True)),
+                         [
+            [('init', (), no_param), ('init', (), no_param)],
+            [('init', (), no_param), ('send', ('"foo"', 3), param_tx3)],
+            [('init', (), no_param), ('send', ('"hodor"', 5), param_tx5)],
+            [('init', (), no_param), ('setTxPower', (10,), param_txp10)],
+            [('init', (), no_param), ('setTxPower', (20,), param_txp20)],
+            [('init', (), no_param), ('setTxPower', (30,), param_txp30)],
+        ]
         )
 
     def test_from_json_function(self):
         pta = PTA.from_json(example_json_1)
-        self.assertEqual(pta.state['TX'].get_energy(1000, {'datarate' : 10, 'txbytes' : 6, 'txpower' : 10 }), 1000 * (10000 + 2 * 10))
-        self.assertEqual(pta.transitions[4].get_timeout({'datarate' : 10, 'txbytes' : 6, 'txpower' : 10 }), 500 + 16 * 6)
-
-    def test_from_yaml(self):
-        pta = PTA.from_yaml(example_yaml_1)
+        self.assertEqual(pta.state['TX'].get_energy(1000, {'datarate': 10, 'txbytes': 6, 'txpower': 10}), 1000 * (10000 + 2 * 10))
+        self.assertEqual(pta.transitions[4].get_timeout({'datarate': 10, 'txbytes': 6, 'txpower': 10}), 500 + 16 * 6)
 
     def test_from_yaml_dfs_param(self):
         pta = PTA.from_yaml(example_yaml_1)
         no_param = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': None,
         }
         param_tx3 = {
-            'datarate' : None,
-            'txbytes' : 3,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': 3,
+            'txpower': None,
         }
         param_tx5 = {
-            'datarate' : None,
-            'txbytes' : 5,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': 5,
+            'txpower': None,
         }
         param_txp10 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 10,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 10,
         }
         param_txp20 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 20,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 20,
         }
         param_txp30 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 30,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 30,
         }
-        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments = True, with_parameters = True), True, True)),
-            [
-                [('init', (), no_param), ('init', (), no_param)],
-                [('init', (), no_param), ('send', ('"foo"', 3), param_tx3)],
-                [('init', (), no_param), ('send', ('"hodor"', 5), param_tx5)],
-                [('init', (), no_param), ('setTxPower', (10,), param_txp10)],
-                [('init', (), no_param), ('setTxPower', (20,), param_txp20)],
-                [('init', (), no_param), ('setTxPower', (30,), param_txp30)],
-            ]
+        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments=True, with_parameters=True), True, True)),
+                         [
+            [('init', (), no_param), ('init', (), no_param)],
+            [('init', (), no_param), ('send', ('"foo"', 3), param_tx3)],
+            [('init', (), no_param), ('send', ('"hodor"', 5), param_tx5)],
+            [('init', (), no_param), ('setTxPower', (10,), param_txp10)],
+            [('init', (), no_param), ('setTxPower', (20,), param_txp20)],
+            [('init', (), no_param), ('setTxPower', (30,), param_txp30)],
+        ]
         )
 
     def test_normalization(self):
         pta = PTA.from_yaml(example_yaml_2)
         no_param = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': None,
         }
         param_tx3 = {
-            'datarate' : None,
-            'txbytes' : 3,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': 3,
+            'txpower': None,
         }
         param_tx6 = {
-            'datarate' : None,
-            'txbytes' : 6,
-            'txpower' : None,
+            'datarate': None,
+            'txbytes': 6,
+            'txpower': None,
         }
         param_txp10 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : -6,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': -6,
         }
         param_txp20 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 4,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 4,
         }
         param_txp30 = {
-            'datarate' : None,
-            'txbytes' : None,
-            'txpower' : 14,
+            'datarate': None,
+            'txbytes': None,
+            'txpower': 14,
         }
-        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments = True, with_parameters = True), True, True)),
-            [
-                [('init', (), no_param), ('init', (), no_param)],
-                [('init', (), no_param), ('send', ('FOO',), param_tx3)],
-                [('init', (), no_param), ('send', ('LONGER',), param_tx6)],
-                [('init', (), no_param), ('setTxPower', (10,), param_txp10)],
-                [('init', (), no_param), ('setTxPower', (20,), param_txp20)],
-                [('init', (), no_param), ('setTxPower', (30,), param_txp30)],
-            ]
+        self.assertEqual(sorted(dfs_tran_to_name(pta.dfs(1, with_arguments=True, with_parameters=True), True, True)),
+                         [
+            [('init', (), no_param), ('init', (), no_param)],
+            [('init', (), no_param), ('send', ('FOO',), param_tx3)],
+            [('init', (), no_param), ('send', ('LONGER',), param_tx6)],
+            [('init', (), no_param), ('setTxPower', (10,), param_txp10)],
+            [('init', (), no_param), ('setTxPower', (20,), param_txp20)],
+            [('init', (), no_param), ('setTxPower', (30,), param_txp30)],
+        ]
         )
 
     def test_shrink(self):
@@ -530,15 +529,15 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(pta.transitions[1].argument_values, [['Nrf24l01::RF24_PA_MIN', 'Nrf24l01::RF24_PA_MAX']])
         self.assertEqual(pta.transitions[2].argument_values, [[0, 15], [0, 15]])
         self.assertEqual(pta.transitions[5].argument_values, [['"foo"', '"foo"', '"foofoofoo"', '"foofoofoo"', '"123456789012345678901234567890"',
-        '"123456789012345678901234567890"'], [3, 3, 9, 9, 30, 30], [0, 1, 0, 1, 0, 1],  [1, 1, 1, 1, 1, 1]])
+                                                               '"123456789012345678901234567890"'], [3, 3, 9, 9, 30, 30], [0, 1, 0, 1, 0, 1], [1, 1, 1, 1, 1, 1]])
 
     def test_simulation(self):
         pta = PTA()
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', duration = 50000)
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10)
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True)
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', duration=50000)
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10)
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True)
         trace = [
             ['init'],
             [None, 10000000],
@@ -555,12 +554,12 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(parameters, {})
 
     def test_simulation_param_none(self):
-        pta = PTA(parameters = ['txpower', 'length'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000)
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10)
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True)
+        pta = PTA(parameters=['txpower', 'length'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000)
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10)
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True)
         trace = [
             ['init'],
         ]
@@ -571,19 +570,19 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : None,
-            'length' : None
+            'txpower': None,
+            'length': None
         })
 
     def test_simulation_param_update_function(self):
-        pta = PTA(parameters = ['txpower', 'length'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000)
-        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy = 10000, duration = 120,
-            param_update_function = lambda param, arg: {**param, 'txpower' : arg[0]})
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10)
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True)
+        pta = PTA(parameters=['txpower', 'length'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000)
+        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy=10000, duration=120,
+                           param_update_function=lambda param, arg: {**param, 'txpower': arg[0]})
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10)
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True)
         trace = [
             ['init'],
             ['setTxPower', 10]
@@ -595,19 +594,19 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : 10,
-            'length' : None
+            'txpower': 10,
+            'length': None
         })
 
     def test_simulation_arg_to_param_map(self):
-        pta = PTA(parameters = ['txpower', 'length'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000)
-        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy = 10000, duration = 120,
-            arg_to_param_map = {0: 'txpower'})
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10)
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True)
+        pta = PTA(parameters=['txpower', 'length'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000)
+        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy=10000, duration=120,
+                           arg_to_param_map={0: 'txpower'})
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10)
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True)
         trace = [
             ['init'],
             ['setTxPower', 10]
@@ -619,15 +618,15 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : 10,
-            'length' : None
+            'txpower': 10,
+            'length': None
         })
 
     def test_simulation_set_param(self):
-        pta = PTA(parameters = ['txpower', 'length'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000, set_param = {'txpower' : 10})
+        pta = PTA(parameters=['txpower', 'length'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000, set_param={'txpower': 10})
         trace = [
             ['init'],
         ]
@@ -638,21 +637,21 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : 10,
-            'length' : None
+            'txpower': 10,
+            'length': None
         })
 
     def test_simulation_arg_function(self):
-        pta = PTA(parameters = ['txpower', 'length'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000)
-        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy = 10000, duration = 120,
-            param_update_function = lambda param, arg: {**param, 'txpower' : arg[0]})
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10,
-            energy_function = lambda param, arg: 3 + 5 * arg[1],
-            duration_function = lambda param, arg: 48 + 8 * arg[1])
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True)
+        pta = PTA(parameters=['txpower', 'length'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000)
+        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy=10000, duration=120,
+                           param_update_function=lambda param, arg: {**param, 'txpower': arg[0]})
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10,
+                           energy_function=lambda param, arg: 3 + 5 * arg[1],
+                           duration_function=lambda param, arg: 48 + 8 * arg[1])
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True)
         trace = [
             ['init'],
             ['setTxPower', 10],
@@ -665,20 +664,20 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : 10,
-            'length' : None
+            'txpower': 10,
+            'length': None
         })
 
-        pta = PTA(parameters = ['txpower', 'length'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100)
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000)
-        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy = 10000, duration = 120,
-            param_update_function = lambda param, arg: {**param, 'txpower' : arg[0]})
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10,
-            energy_function = lambda param, arg: 3 + 5 * arg[1],
-            duration_function = lambda param, arg: 48 + 8 * arg[1])
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True)
+        pta = PTA(parameters=['txpower', 'length'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100)
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000)
+        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy=10000, duration=120,
+                           param_update_function=lambda param, arg: {**param, 'txpower': arg[0]})
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10,
+                           energy_function=lambda param, arg: 3 + 5 * arg[1],
+                           duration_function=lambda param, arg: 48 + 8 * arg[1])
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True)
         trace = [
             ['init'],
             ['setTxPower', 10],
@@ -691,24 +690,23 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : 10,
-            'length' : None
+            'txpower': 10,
+            'length': None
         })
 
-
     def test_simulation_param_function(self):
-        pta = PTA(parameters = ['length', 'txpower'])
-        pta.add_state('IDLE', power = 5)
-        pta.add_state('TX', power = 100,
-            power_function = lambda param, arg: 1000 + 2 * param[1])
-        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy = 500000, duration = 50000)
-        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy = 10000, duration = 120,
-            param_update_function = lambda param, arg: {**param, 'txpower' : arg[0]})
-        pta.add_transition('IDLE', 'TX', 'send', energy = 3, duration = 10,
-            energy_function = lambda param, arg: 3 + 5 * arg[1],
-            param_update_function = lambda param, arg: {**param, 'length' : arg[1]})
-        pta.add_transition('TX', 'IDLE', 'txComplete', timeout = 2000, is_interrupt = True,
-            timeout_function = lambda param, arg: 500 + 16 * param[0])
+        pta = PTA(parameters=['length', 'txpower'])
+        pta.add_state('IDLE', power=5)
+        pta.add_state('TX', power=100,
+                      power_function=lambda param, arg: 1000 + 2 * param[1])
+        pta.add_transition('UNINITIALIZED', 'IDLE', 'init', energy=500000, duration=50000)
+        pta.add_transition('IDLE', 'IDLE', 'setTxPower', energy=10000, duration=120,
+                           param_update_function=lambda param, arg: {**param, 'txpower': arg[0]})
+        pta.add_transition('IDLE', 'TX', 'send', energy=3, duration=10,
+                           energy_function=lambda param, arg: 3 + 5 * arg[1],
+                           param_update_function=lambda param, arg: {**param, 'length': arg[1]})
+        pta.add_transition('TX', 'IDLE', 'txComplete', timeout=2000, is_interrupt=True,
+                           timeout_function=lambda param, arg: 500 + 16 * param[0])
         trace = [
             ['init'],
             ['setTxPower', 10],
@@ -721,19 +719,18 @@ class TestPTA(unittest.TestCase):
         self.assertEqual(duration, expected_duration)
         self.assertEqual(state.name, 'IDLE')
         self.assertEqual(parameters, {
-            'txpower' : 10,
-            'length' : 3
+            'txpower': 10,
+            'length': 3
         })
 
     def test_get_X_expensive_state(self):
         pta = PTA.from_json(example_json_1)
         self.assertEqual(pta.get_least_expensive_state(), pta.state['IDLE'])
         self.assertEqual(pta.get_most_expensive_state(), pta.state['TX'])
-        self.assertAlmostEqual(pta.min_duration_until_energy_overflow(), (2**32-1) * 1e-12 / 10e-3, places=9)
-        self.assertAlmostEqual(pta.min_duration_until_energy_overflow(energy_granularity = 1e-9), (2**32-1) * 1e-9 / 10e-3, places=9)
-        self.assertAlmostEqual(pta.max_duration_until_energy_overflow(), (2**32-1) * 1e-12 / 5e-6, places=9)
-        self.assertAlmostEqual(pta.max_duration_until_energy_overflow(energy_granularity = 1e-9), (2**32-1) * 1e-9 / 5e-6, places=9)
-
+        self.assertAlmostEqual(pta.min_duration_until_energy_overflow(), (2**32 - 1) * 1e-12 / 10e-3, places=9)
+        self.assertAlmostEqual(pta.min_duration_until_energy_overflow(energy_granularity=1e-9), (2**32 - 1) * 1e-9 / 10e-3, places=9)
+        self.assertAlmostEqual(pta.max_duration_until_energy_overflow(), (2**32 - 1) * 1e-12 / 5e-6, places=9)
+        self.assertAlmostEqual(pta.max_duration_until_energy_overflow(energy_granularity=1e-9), (2**32 - 1) * 1e-9 / 5e-6, places=9)
 
 
 if __name__ == '__main__':
diff --git a/test/test_ptamodel.py b/test/test_ptamodel.py
index 36d2c11..6bd2f6a 100755
--- a/test/test_ptamodel.py
+++ b/test/test_ptamodel.py
@@ -5,12 +5,13 @@ import os
 import unittest
 import pytest
 
+
 class TestModels(unittest.TestCase):
     def test_model_singlefile_rf24(self):
         raw_data = RawData(['test-data/20170220_164723_RF24_int_A.tar'])
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = PTAModel(by_name, parameters, arg_count, verbose = False)
+        model = PTAModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.states(), 'POWERDOWN RX STANDBY1 TX'.split(' '))
         self.assertEqual(model.transitions(), 'begin epilogue powerDown powerUp setDataRate_num setPALevel_num startListening stopListening write_nb'.split(' '))
         static_model = model.get_static()
@@ -62,25 +63,24 @@ class TestModels(unittest.TestCase):
         param_model, param_info = model.get_fitted()
         self.assertEqual(param_info('POWERDOWN', 'power'), None)
         self.assertEqual(param_info('RX', 'power')['function']._model_str,
-            '0 + regression_arg(0) + regression_arg(1) * np.sqrt(parameter(datarate))')
+                         '0 + regression_arg(0) + regression_arg(1) * np.sqrt(parameter(datarate))')
         self.assertAlmostEqual(param_info('RX', 'power')['function']._regression_args[0], 48530.7, places=0)
         self.assertAlmostEqual(param_info('RX', 'power')['function']._regression_args[1], 117, places=0)
         self.assertEqual(param_info('STANDBY1', 'power'), None)
         self.assertEqual(param_info('TX', 'power')['function']._model_str,
-            '0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate)) + regression_arg(2) * parameter(txpower) + regression_arg(3) * 1/(parameter(datarate)) * parameter(txpower)')
+                         '0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate)) + regression_arg(2) * parameter(txpower) + regression_arg(3) * 1/(parameter(datarate)) * parameter(txpower)')
         self.assertEqual(param_info('epilogue', 'timeout')['function']._model_str,
-            '0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate))')
+                         '0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate))')
         self.assertEqual(param_info('stopListening', 'duration')['function']._model_str,
-            '0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate))')
+                         '0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate))')
 
         self.assertAlmostEqual(param_model('RX', 'power', param=[1, None, None]), 48647, places=-1)
 
-
     def test_model_singlefile_mmparam(self):
         raw_data = RawData(['test-data/20161221_123347_mmparam.tar'])
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = PTAModel(by_name, parameters, arg_count, verbose = False)
+        model = PTAModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.states(), 'OFF ON'.split(' '))
         self.assertEqual(model.transitions(), 'off setBrightness'.split(' '))
         static_model = model.get_static()
@@ -100,7 +100,7 @@ class TestModels(unittest.TestCase):
             param_lut_model('ON', 'power', param=['a'])
             param_lut_model('ON', 'power', param=[0])
         self.assertTrue(param_lut_model('ON', 'power', param=[0, 0]))
-        param_lut_model = model.get_param_lut(fallback = True)
+        param_lut_model = model.get_param_lut(fallback=True)
         self.assertAlmostEqual(param_lut_model('ON', 'power', param=[None, None]), 17866, places=0)
 
     def test_model_multifile_lm75x(self):
@@ -109,9 +109,9 @@ class TestModels(unittest.TestCase):
             'test-data/20170116_131306_LM75x.tar',
         ]
         raw_data = RawData(testfiles)
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = PTAModel(by_name, parameters, arg_count, verbose = False)
+        model = PTAModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.states(), 'ACTIVE POWEROFF'.split(' '))
         self.assertEqual(model.transitions(), 'getTemp setHyst setOS shutdown start'.split(' '))
         static_model = model.get_static()
@@ -139,9 +139,9 @@ class TestModels(unittest.TestCase):
             'test-data/20170116_151348_sharpLS013B4DN.tar',
         ]
         raw_data = RawData(testfiles)
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = PTAModel(by_name, parameters, arg_count, verbose = False)
+        model = PTAModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.states(), 'DISABLED ENABLED'.split(' '))
         self.assertEqual(model.transitions(), 'clear disable enable ioInit sendLine toggleVCOM'.split(' '))
         static_model = model.get_static()
@@ -172,9 +172,9 @@ class TestModels(unittest.TestCase):
             'test-data/20170116_142654_mmstatic.tar',
         ]
         raw_data = RawData(testfiles)
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = PTAModel(by_name, parameters, arg_count, verbose = False)
+        model = PTAModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.states(), 'B G OFF R'.split(' '))
         self.assertEqual(model.transitions(), 'blue green off red'.split(' '))
         static_model = model.get_static()
@@ -206,9 +206,9 @@ class TestModels(unittest.TestCase):
             'test-data/20170125_154019_cc1200.tar',
         ]
         raw_data = RawData(testfiles)
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = PTAModel(by_name, parameters, arg_count, verbose = False)
+        model = PTAModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.states(), 'IDLE RX SLEEP SLEEP_EWOR SYNTH_ON TX XOFF'.split(' '))
         self.assertEqual(model.transitions(), 'crystal_off eWOR idle init prepare_xmit receive send setSymbolRate setTxPower sleep txDone'.split(' '))
         static_model = model.get_static()
@@ -234,7 +234,7 @@ class TestModels(unittest.TestCase):
         param_model, param_info = model.get_fitted()
         self.assertEqual(param_info('IDLE', 'power'), None)
         self.assertEqual(param_info('RX', 'power')['function']._model_str,
-            '0 + regression_arg(0) + regression_arg(1) * np.log(parameter(symbolrate) + 1)')
+                         '0 + regression_arg(0) + regression_arg(1) * np.log(parameter(symbolrate) + 1)')
         self.assertEqual(param_info('SLEEP', 'power'), None)
         self.assertEqual(param_info('SLEEP_EWOR', 'power'), None)
         self.assertEqual(param_info('SYNTH_ON', 'power'), None)
@@ -243,5 +243,6 @@ class TestModels(unittest.TestCase):
         self.assertAlmostEqual(param_info('RX', 'power')['function']._regression_args[0], 84415, places=0)
         self.assertAlmostEqual(param_info('RX', 'power')['function']._regression_args[1], 206, places=0)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/test_timingharness.py b/test/test_timingharness.py
index bf5ecee..8d5ec20 100755
--- a/test/test_timingharness.py
+++ b/test/test_timingharness.py
@@ -4,12 +4,13 @@ from dfatool import AnalyticModel, TimingData, pta_trace_to_aggregate
 from parameters import prune_dependent_parameters
 import unittest
 
+
 class TestModels(unittest.TestCase):
     def test_model_singlefile_rf24(self):
         raw_data = TimingData(['test-data/20190815_111745_nRF24_no-rx.json'])
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = AnalyticModel(by_name, parameters, arg_count, verbose = False)
+        model = AnalyticModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.names, 'setPALevel setRetries setup write'.split(' '))
         static_model = model.get_static()
         self.assertAlmostEqual(static_model('setPALevel', 'duration'), 146, places=0)
@@ -33,10 +34,10 @@ class TestModels(unittest.TestCase):
 
     def test_dependent_parameter_pruning(self):
         raw_data = TimingData(['test-data/20190815_103347_nRF24_no-rx.json'])
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         prune_dependent_parameters(by_name, parameters)
-        model = AnalyticModel(by_name, parameters, arg_count, verbose = False)
+        model = AnalyticModel(by_name, parameters, arg_count, verbose=False)
         self.assertEqual(model.names, 'getObserveTx setPALevel setRetries setup write'.split(' '))
         static_model = model.get_static()
         self.assertAlmostEqual(static_model('getObserveTx', 'duration'), 75, places=0)
@@ -62,9 +63,9 @@ class TestModels(unittest.TestCase):
 
     def test_function_override(self):
         raw_data = TimingData(['test-data/20190815_122531_nRF24_no-rx.json'])
-        preprocessed_data = raw_data.get_preprocessed_data(verbose = False)
+        preprocessed_data = raw_data.get_preprocessed_data(verbose=False)
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
-        model = AnalyticModel(by_name, parameters, arg_count, verbose = False, function_override={('write', 'duration'): '(parameter(auto_ack!) * (regression_arg(0) + regression_arg(1) * parameter(max_retry_count) + regression_arg(2) * parameter(retry_delay) + regression_arg(3) * parameter(max_retry_count) * parameter(retry_delay))) + ((1 - parameter(auto_ack!)) * regression_arg(4))'})
+        model = AnalyticModel(by_name, parameters, arg_count, verbose=False, function_override={('write', 'duration'): '(parameter(auto_ack!) * (regression_arg(0) + regression_arg(1) * parameter(max_retry_count) + regression_arg(2) * parameter(retry_delay) + regression_arg(3) * parameter(max_retry_count) * parameter(retry_delay))) + ((1 - parameter(auto_ack!)) * regression_arg(4))'})
         self.assertEqual(model.names, 'setAutoAck setPALevel setRetries setup write'.split(' '))
         static_model = model.get_static()
         self.assertAlmostEqual(static_model('setAutoAck', 'duration'), 72, places=0)
@@ -89,5 +90,6 @@ class TestModels(unittest.TestCase):
         self.assertAlmostEqual(param_info('write', 'duration')['function']._regression_args[3], 1, places=0)
         self.assertAlmostEqual(param_info('write', 'duration')['function']._regression_args[4], 1086, places=0)
 
+
 if __name__ == '__main__':
     unittest.main()