diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..99482b1
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,5 @@
+FROM kennethreitz/pipenv
+
+COPY . /app
+
+CMD python3 mainCLI.py
diff --git a/README.md b/README.md
index 49b0466..002d778 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,9 @@ SPECtate is a configuration tool that interfaces with the benchmarking software
 
 These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See usage for notes on how to use the project on a live system.
 
+There's a pre-packaged binary for quick, out-of-the box setup without **any dependencies**! 
+Check out the [releases](https://github.com/PDXCapstoneF/SPECtate/releases) for binaries for the main CLI application.
+
 ### Prerequisites
 
 * UNIX (Linux, Mac OSX), or Windows
@@ -45,6 +48,21 @@ pipenv install
 ```
 
 
+#### Docker
+
+This project has a Docker file. You can build an image 
+yourself and run SPECtate with it:
+
+```shell
+# build the image
+docker build -t SPECtate:latest .
+# run SPECtate
+docker run SPECtate:latest --help
+# would display the help text like you ran it yourself
+# with python mainCLI.py --help
+```
+
+
 ## Example CLI Usage
 
 * Run an example configuration:
diff --git a/dialogue.py b/dialogue.py
index b10b1d6..809bdf4 100644
--- a/dialogue.py
+++ b/dialogue.py
@@ -19,14 +19,15 @@
 TEMPLATE_DEFAULT = 'prop_options'
 
 TYPE_CHECK_FUNC = {
-    'string' : lambda x : str(x),
-    'int' : lambda x : int(x),
-    'integer' : lambda x : int(x),
-    'float' : lambda x : float(x),
-    'bool' : lambda x : x not in set(['false', 'False']),
-    'boolean' : lambda x : x not in set(['false', 'False']),
+    'string': lambda x: str(x),
+    'int': lambda x: int(x),
+    'integer': lambda x: int(x),
+    'float': lambda x: float(x),
+    'bool': lambda x: x not in set(['false', 'False']),
+    'boolean': lambda x: x not in set(['false', 'False']),
 }
 
+
 def write_json(filename, python_dict):
     """ 
     Serialize python_dict (dictionary) to filename (text file).
@@ -45,35 +46,43 @@ def read_json(filename):
     with open(filename) as f:
         return json.load(f)
 
+
 def print_dict(d):
     for key, value in sorted(d.items(), key=lambda x: x[0]):
         print("{}: {}".format(key, value))
 
+
 # Level-one layer of dialogue.
 # All functions take run_dict, template_dict as arguments so that they can be
 # called homogenously from a dictionary in `dialogue`.
 
+
 def tag_in_runlist(tag, run_list):
     """
     Returns True if a Run with tag `tag` is in the list.
     """
-    return any(map(lambda run : run[TAG_ARG] == tag, run_list))
+    return any(map(lambda run: run[TAG_ARG] == tag, run_list))
+
 
 def find(f, seq):
     """
     Return first item in sequence where f(item) == True.
     """
     for item in seq:
-        if f(item): 
+        if f(item):
             return item
+
+
 def find_run_tag(tag, run_list):
-    return find(lambda run : run[TAG_ARG] == tag, run_list)
+    return find(lambda run: run[TAG_ARG] == tag, run_list)
+
 
 # Level-one layer of dialogue. All functions take run_dict, template_dict as
 # arguments so that they can be called homogeneously from a dictionary in
 # `dialogue`. All functions must, in turn, *return* a tuple (run_dict,
 # template_dict) as arguments.
 
+
 def print_all_runs(run_list, template_dict):
     """
     Prints all runs in the RunList. Note that it gets the argument order from
@@ -87,11 +96,12 @@ def print_all_runs(run_list, template_dict):
         print()
     return (run_list, template_dict)
 
+
 def create_run(run_list, template_dict):
     new_run = {}
     # Inputting run type.
-    print('Input the template type. Current options: {}'.format(
-            ' '.join(sorted(template_dict.keys()))))
+    print('Input the template type. Current options: {}'.format(' '.join(
+        sorted(template_dict.keys()))))
     template_type = input('-> ')
     if template_type not in template_dict.keys():
         user_input = input('{} is not currently an option. Add it? '\
@@ -121,12 +131,12 @@ def create_run(run_list, template_dict):
                     return (run_list, template_dict)
                 elif user_input in HELP_CONSTS:
                     print('Annotation:\n{}\nType:\n{}\n'.format(
-                          template_dict[template_type]['annotations'][arg],
-                          template_dict[template_type]['types'][arg]))
-                else: 
+                        template_dict[template_type]['annotations'][arg],
+                        template_dict[template_type]['types'][arg]))
+                else:
                     try:
-                        type_func = TYPE_CHECK_FUNC[
-                          template_dict[template_type][TEMPLATE_TYPES][arg]]
+                        type_func = TYPE_CHECK_FUNC[template_dict[template_type]
+                                                    [TEMPLATE_TYPES][arg]]
                         user_input = type_func(user_input)
                         new_run[RUNLIST_ARGS][arg] = user_input
                         break
@@ -142,9 +152,10 @@ def create_run(run_list, template_dict):
         else:
             if input('Discard new run {}? '.format(new_tag)) in YES_CONSTS:
                 return run_list, template_dict
-    
+
     return run_list, template_dict
 
+
 def create_template(run_list, template_dict):
     new_template = {}
     new_template[TEMPLATE_ARGS] = []
@@ -183,9 +194,8 @@ def create_template(run_list, template_dict):
                               'Blank input skips this step. ')
         if new_arg_trans in EXIT_CONSTS:
             break
-        
-        print('Current argument:\n',
-              'Arg: {}\n'.format(new_arg),
+
+        print('Current argument:\n', 'Arg: {}\n'.format(new_arg),
               'Type: {}\n'.format(new_arg_type),
               'Annotation: {}\n'.format(new_arg_annotation),
               'Translation: {}'.format(new_arg_trans))
@@ -196,7 +206,7 @@ def create_template(run_list, template_dict):
             new_template[TEMPLATE_TYPES][new_arg] = new_arg_type
             if new_arg_trans:
                 new_template[TEMPLATE_TRANS][new_arg] = new_arg_trans
-    
+
     # Default props.
     while True:
         default_property = input('Input a default property. Blank or \'exit\' '\
@@ -220,14 +230,13 @@ def create_template(run_list, template_dict):
 
     return run_list, template_dict
 
+
 def delete_run(run_list, template_dict):
     print('Input the tag of the Run that you want to delete. Available tags')
-    print('are {}'.format(
-                   ' '.join(run[TAG_ARG] for run in run_list)))
+    print('are {}'.format(' '.join(run[TAG_ARG] for run in run_list)))
     delete_tag = input('-> ')
 
-    new_run_list = [run for run in run_list 
-                    if run[TAG_ARG] != delete_tag]
+    new_run_list = [run for run in run_list if run[TAG_ARG] != delete_tag]
     if len(run_list) == len(new_run_list):
         print('Tag {} does not exist.'.format(delete_tag))
     else:
@@ -239,15 +248,15 @@ def delete_run(run_list, template_dict):
             print('Deletion of tag {} cancelled.'.format(delete_tag))
     return run_list, template_dict
 
+
 def copy_run(run_list, template_dict):
     print('Input the tag of the Run that you want to copy. Available tags')
-    print('are {}'.format(
-                   ' '.join(run[TAG_ARG] for run in run_list)))
+    print('are {}'.format(' '.join(run[TAG_ARG] for run in run_list)))
     old_run_tag = input('-> ')
 
     if old_run_tag in EXIT_CONSTS:
         return run_list, template_dict
-    
+
     old_run = find_run_tag(old_run_tag, run_list)
     if not old_run:
         print('Tag {} not found.'.format(old_run_tag))
@@ -266,7 +275,7 @@ def copy_run(run_list, template_dict):
         else:
             new_run[TAG_ARG] = new_run_tag
             break
-    
+
     if input('Add run {} to RunList? '.format(new_run_tag)) in YES_CONSTS:
         print('Added run {} to RunList.'.format(new_run_tag))
         run_list.append(new_run)
@@ -274,6 +283,7 @@ def copy_run(run_list, template_dict):
         print('Run {} not copied.'.format(old_run_tag))
     return run_list, template_dict
 
+
 def edit_run(run_list, template_dict):
     edit_tag = input('Input the tag of the Run you want to edit. ')
 
@@ -315,7 +325,7 @@ def edit_run(run_list, template_dict):
             except:
                 print('Invalid input.')
 
-    
+
     if input('Are you sure you want to change run {}? '\
              .format(old_run[TAG_ARG])) in YES_CONSTS:
         # Find the index of old_run and create a new list with new_run in its
@@ -323,13 +333,14 @@ def edit_run(run_list, template_dict):
         for index, run in enumerate(run_list):
             if run == old_run:
                 print('Run {} changed.'.format(old_run[TAG_ARG]))
-                return (run_list[:index] + [new_run] + run_list[index+1:], 
+                return (run_list[:index] + [new_run] + run_list[index + 1:],
                         template_dict)
         print('Something terribly wrong has happened. Cancelled.')
     else:
         print('Edit of Run {} cancelled.'.format(old_run[TAG_ARG]))
     return run_list, template_dict
 
+
 def delete_template(run_list, template_dict):
     delete_tag = input('Enter the tag of the template you want to delete. ')
     if delete_tag not in template_dict.keys():
@@ -343,6 +354,7 @@ def delete_template(run_list, template_dict):
         print('Deletion of Template {} cancelled.'.format(delete_tag))
     return run_list, template_dict
 
+
 def save_tate(run_list, template_dict):
     filename = input('Input a filename to save the TateConfig to. ')
     if not filename or filename in EXIT_CONSTS:
@@ -351,12 +363,16 @@ def save_tate(run_list, template_dict):
     if input('Are you sure you want to save to {}? '.format(filename))\
         in YES_CONSTS:
         try:
-            write_json(filename, {RUN_LIST : run_list, TEMPLATE_DATA : template_dict})
+            write_json(filename, {
+                RUN_LIST: run_list,
+                TEMPLATE_DATA: template_dict
+            })
             print('Saved TateConfig to {}'.format(filename))
         except:
             print('Unable to save to {}.'.format(filename))
     return run_list, template_dict
 
+
 def load_tate(run_list, template_dict):
     filename = input('Input a filename to load the TateConfig from. ')
     if not filename or filename in EXIT_CONSTS:
@@ -372,6 +388,7 @@ def load_tate(run_list, template_dict):
             print('Unable to load filename {}'.format(filename))
     return run_list, template_dict
 
+
 def reorder_run(run_list, template_dict):
     print('Select an index to reorder.')
     for index, run in enumerate(run_list):
@@ -399,9 +416,8 @@ def reorder_run(run_list, template_dict):
     except:
         print('Invalid index.')
         return run_list, template_dict
-    
+
     print('Reorder canceled.')
-    
 
 
 def error(run_dict, template_dict):
@@ -423,29 +439,29 @@ def dialogue():
         json_filename = default_json
 
     function_dict = {
-        'print all' : print_all_runs,
-        'create run' : create_run,
-        'create template' : create_template,
-        'delete run' : delete_run,
-        'delete template' : delete_template,
-        'copy run' : copy_run,
-        'edit run' : edit_run,
-        'save tate' : save_tate,
-        'load tate' : load_tate,
-        'reorder run' : reorder_run,
+        'print all': print_all_runs,
+        'create run': create_run,
+        'create template': create_template,
+        'delete run': delete_run,
+        'delete template': delete_template,
+        'copy run': copy_run,
+        'edit run': edit_run,
+        'save tate': save_tate,
+        'load tate': load_tate,
+        'reorder run': reorder_run,
     }
 
     option_description_dict = {
-        'print all' : 'Print all runs',
-        'create run' : 'Create a run',
-        'create template' : 'Create a template',
-        'delete run' : 'Delete a run',
-        'delete template' : 'Delete a template',
-        'copy run' : 'Copy a run',
-        'edit run' : 'Edit a run',
-        'save tate' : 'Save TateConfig',
-        'load tate' : 'Load TateConfig',
-        'reorder run' : 'Reorder a run',
+        'print all': 'Print all runs',
+        'create run': 'Create a run',
+        'create template': 'Create a template',
+        'delete run': 'Delete a run',
+        'delete template': 'Delete a template',
+        'copy run': 'Copy a run',
+        'edit run': 'Edit a run',
+        'save tate': 'Save TateConfig',
+        'load tate': 'Load TateConfig',
+        'reorder run': 'Reorder a run',
     }
 
     try:
@@ -472,7 +488,6 @@ def dialogue():
         if user_input.lower() in HELP_CONSTS:
             continue
         elif user_input.lower() not in EXIT_CONSTS:
-            run_list, template_dict = function_dict.get(user_input, error)(run_list, template_dict)
+            run_list, template_dict = function_dict.get(user_input, error)(
+                run_list, template_dict)
     print('Exiting.')
-
-
diff --git a/docs/gifs/CLI-Run.gif b/docs/gifs/CLI-Run.gif
new file mode 100644
index 0000000..25a4d85
Binary files /dev/null and b/docs/gifs/CLI-Run.gif differ
diff --git a/docs/gifs/CLI-copy, rename, delete.gif b/docs/gifs/CLI-copy, rename, delete.gif
new file mode 100644
index 0000000..41b5063
Binary files /dev/null and b/docs/gifs/CLI-copy, rename, delete.gif differ
diff --git a/docs/gifs/CLI-create run from template.gif b/docs/gifs/CLI-create run from template.gif
new file mode 100644
index 0000000..ff2a812
Binary files /dev/null and b/docs/gifs/CLI-create run from template.gif differ
diff --git a/docs/gifs/CLI-create template.gif b/docs/gifs/CLI-create template.gif
new file mode 100644
index 0000000..4b99d8a
Binary files /dev/null and b/docs/gifs/CLI-create template.gif differ
diff --git a/docs/gifs/CLI-load config.gif b/docs/gifs/CLI-load config.gif
new file mode 100644
index 0000000..2839a01
Binary files /dev/null and b/docs/gifs/CLI-load config.gif differ
diff --git a/docs/gifs/GUI-Run (All).gif b/docs/gifs/GUI-Run (All).gif
new file mode 100644
index 0000000..1f3dd5b
Binary files /dev/null and b/docs/gifs/GUI-Run (All).gif differ
diff --git a/docs/gifs/GUI-Run (Single).gif b/docs/gifs/GUI-Run (Single).gif
new file mode 100644
index 0000000..a0fb92c
Binary files /dev/null and b/docs/gifs/GUI-Run (Single).gif differ
diff --git a/docs/gifs/GUI-copy, rename, delete.gif b/docs/gifs/GUI-copy, rename, delete.gif
new file mode 100644
index 0000000..70a47d6
Binary files /dev/null and b/docs/gifs/GUI-copy, rename, delete.gif differ
diff --git a/docs/gifs/GUI-create run from template.gif b/docs/gifs/GUI-create run from template.gif
new file mode 100644
index 0000000..0f26459
Binary files /dev/null and b/docs/gifs/GUI-create run from template.gif differ
diff --git a/docs/gifs/GUI-create template.gif b/docs/gifs/GUI-create template.gif
new file mode 100644
index 0000000..be73ad8
Binary files /dev/null and b/docs/gifs/GUI-create template.gif differ
diff --git a/docs/gifs/GUI-load JAR.gif b/docs/gifs/GUI-load JAR.gif
new file mode 100644
index 0000000..15be18b
Binary files /dev/null and b/docs/gifs/GUI-load JAR.gif differ
diff --git a/docs/gifs/GUI-load config.gif b/docs/gifs/GUI-load config.gif
new file mode 100644
index 0000000..842e02f
Binary files /dev/null and b/docs/gifs/GUI-load config.gif differ
diff --git a/docs/index.md b/docs/index.md
deleted file mode 120000
index 32d46ee..0000000
--- a/docs/index.md
+++ /dev/null
@@ -1 +0,0 @@
-../README.md
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..002d778
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,113 @@
+| Service        | Master           | Development  |
+| ------------- |:-------------:| ------------------:|
+| CI Status      | [![Build Status](https://travis-ci.org/PDXCapstoneF/SPECtate.svg?branch=master)](https://travis-ci.org/PDXCapstoneF/SPECtate)    | [![Build Status](https://travis-ci.org/PDXCapstoneF/SPECtate.svg?branch=dev)](https://travis-ci.org/PDXCapstoneF/SPECtate) |
+| Documentation Status | [![Documentation Status](https://readthedocs.org/projects/spectate/badge/?version=latest)](https://spectate.readthedocs.io/en/latest/?badge=latest) | [![Documentation Status](https://readthedocs.org/projects/spectate/badge/?version=dev)](https://spectate.readthedocs.io/en/latest/?badge=dev) |
+
+# SPECtate
+
+SPECtate is a configuration tool that interfaces with the benchmarking software [SPECjbb®2015](https://www.spec.org/jbb2015/). SPECtate is designed to to be a more user-friendly alternative for configuring and invoking the SPECjbb®2015 benchmarking software, providing: 
+
+**Interfaces:**
+* a graphical-user-interface (GUI) 
+* a command-line-interface (CLI)
+
+**Configuration:**
+* processes human-readable configuration files (HJSON, JSON, YAML)
+
+**Invocation:**
+* a python-equivalent of SPECjbb®2015's `run.sh` file
+
+
+## Getting Started
+
+These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See usage for notes on how to use the project on a live system.
+
+There's a pre-packaged binary for quick, out-of-the box setup without **any dependencies**! 
+Check out the [releases](https://github.com/PDXCapstoneF/SPECtate/releases) for binaries for the main CLI application.
+
+### Prerequisites
+
+* UNIX (Linux, Mac OSX), or Windows
+* [python](https://www.python.org/downloads/) >= 3.6
+* [SPECjbb®2015](https://www.spec.org/order.html)
+
+
+### Setup
+
+```shell
+git clone https://github.com/PDXCapstoneF/SPECtate.git
+cd SPECtate/
+python -m unittest discover -s .
+```
+
+This project uses `pipenv` to manage dependencies. To start:
+
+```
+pipenv shell
+pipenv install
+```
+
+
+#### Docker
+
+This project has a Docker file. You can build an image 
+yourself and run SPECtate with it:
+
+```shell
+# build the image
+docker build -t SPECtate:latest .
+# run SPECtate
+docker run SPECtate:latest --help
+# would display the help text like you ran it yourself
+# with python mainCLI.py --help
+```
+
+
+## Example CLI Usage
+
+* Run an example configuration:
+```
+python mainCLI.py run example_config.json
+```
+
+* See what an example configuration might do:
+```
+python mainCLI.py run --dry-run example_config.json
+```
+
+* Generate configurations:
+```
+# generate you own configuration via the cli in dialogue:
+python mainCLI.py dialogue
+# or through the ncurses equivalent cli:
+python speccurses.py
+```
+
+
+## Documentation
+
+* SPECtate documentation can be found in [`docs/`](docs/) page and in the Python scripts themselves. Documentation of SPECtate can be generated by using Python's standard library [pydoc](https://docs.python.org/2/library/pydoc.html).
+
+Example:
+
+```
+cd SPECtate/
+pydoc -w dialogue; open dialogue.html
+```
+
+The `-w` flag in the above command will "Write out the HTML documentation for a module to a file in the current directory."
+
+## Testing
+
+* Unittests 
+
+* [Travis-CI](https://travis-ci.org/PDXCapstoneF/SPECtate) for Continuous integration testing during development
+
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/PDXCapstoneF/SPECtate/blob/dev/README.md) file for details.
+
+## Contact
+
+* [Andrew Waugh](mailto:ZonrZero@gmail.com) (Product Owner)
diff --git a/example_config.json b/example_config.json
index 2ba7294..ffffb7b 100644
--- a/example_config.json
+++ b/example_config.json
@@ -1,144 +1,145 @@
 {
-	"TemplateData": {
-		"HBIR": {
-			"args": [
-				"Kit Version",
-				"JDK",
-				"RTSTART",
-				"JVM Options",
-				"NUMA Nodes",
-				"Data Collection",
-				"T1",
-				"T2",
-				"T3"
-			],
-			"annotations" : {
-			  "Kit Version" : "Version of SpecJBB",
-			  "JDK" : "Version of the JVM that will run SpecJBB",
-			  "RTSTART" : "What percentage of total output will we start at",
-			  "JVM Options" : "What additional arguments, if any, will be passed to the JVM",
-			  "NUMA Nodes" : "How many NUMA nodes will SpecJBB use",
-			  "Data Collection" : "What data collection process will monitor while running SpecJBB",
-			  "T1" : "How many threads does Tier 1 have access to",
-			  "T2" : "How many threads does Tier 2 have access to",
-			  "T3" : "How many threads does Tier 3 have access to"
-			},
-			"prop_options": {
-				"specjbb.controller.type": "HBIR",
-				"specjbb.time.server": false,
-				"specjbb.comm.connect.client.pool.size": 192,
-				"specjbb.comm.connect.selector.runner.count": 4,
-				"specjbb.comm.connect.timeouts.connect": 650000,
-				"specjbb.comm.connect.timeouts.read": 650000,
-				"specjbb.comm.connect.timeouts.write": 650000,
-				"specjbb.comm.connect.worker.pool.max": 320,
-				"specjbb.mapreducer.pool.size": 27
-			},
-			"types": {
-				"Kit Version": "string",
-				"JDK": "string",
-				"RTSTART": "integer",
-				"JVM Options": "string",
-				"NUMA Nodes": "integer",
-				"Data Collection": "string",
-				"T1": "integer",
-				"T2": "integer",
-				"T3": "integer"
-			},
-			"translations": {
-				"RTSTART": "specjbb.controller.rtcurve.start",
-				"T1": "specjbb.forkjoin.workers.Tier1",
-				"T2": "specjbb.forkjoin.workers.Tier2",
-				"T3": "specjbb.forkjoin.workers.Tier3",
-				"NUMA Nodes": "specjbb.group.count"
-			}
-		},
-		"HBIR_RT": {
-			"args": [
-				"Kit Version",
-				"JDK",
-				"RTSTART",
-				"JVM Options",
-				"NUMA Nodes",
-				"Data Collection",
-				"T1",
-				"T2",
-				"T3"
-			],
-			"annotations" : {
-			  "Kit Version" : "Version of SpecJBB",
-			  "JDK" : "Version of the JVM that will run SpecJBB",
-			  "RTSTART" : "What percentage of total output will we start at",
-			  "JVM Options" : "What additional arguments, if any, will be passed to the JVM",
-			  "NUMA Nodes" : "How many NUMA nodes will SpecJBB use",
-			  "Data Collection" : "What data collection process will monitor while running SpecJBB",
-			  "T1" : "How many threads does Tier 1 have access to",
-			  "T2" : "How many threads does Tier 2 have access to",
-			  "T3" : "How many threads does Tier 3 have access to"
-			},
-			"prop_options": {
-				"specjbb.controller.type": "HBIR_RT",
-				"specjbb.time.server": false,
-				"specjbb.comm.connect.client.pool.size": 192,
-				"specjbb.comm.connect.selector.runner.count": 4,
-				"specjbb.comm.connect.timeouts.connect": 650000,
-				"specjbb.comm.connect.timeouts.read": 650000,
-				"specjbb.comm.connect.timeouts.write": 650000,
-				"specjbb.comm.connect.worker.pool.max": 320,
-				"specjbb.customerDriver.threads": 64,
-				"specjbb.customerDriver.threads.saturate": 144,
-				"specjbb.customerDriver.threads.probe": 96,
-				"specjbb.mapreducer.pool.size": 27
-			},
-			"types": {
-				"Kit Version": "string",
-				"JDK": "string",
-				"RTSTART": "integer",
-				"JVM Options": "string",
-				"NUMA Nodes": "integer",
-				"Data Collection": "string",
-				"T1": "integer",
-				"T2": "integer",
-				"T3": "integer"
-			},
-			"translations": {
-				"RTSTART": "specjbb.controller.rtcurve.start",
-				"T1": "specjbb.forkjoin.workers.Tier1",
-				"T2": "specjbb.forkjoin.workers.Tier2",
-				"T3": "specjbb.forkjoin.workers.Tier3",
-				"NUMA Nodes": "specjbb.group.count"
-			}
-		}
-	},
-	"RunList": [{
-			"template_type": "HBIR",
-			"tag": "TAG",
-			"args": {
-				"Kit Version": "15",
-				"JDK": 7,
-				"RTSTART": "4",
-				"JVM Options": "options -x -y",
-				"NUMA Nodes": "2",
-				"Data Collection": "TRUE",
-				"T1": 1,
-				"T2": 2,
-				"T3": 3
-			}
-		},
-		{
-			"template_type": "HBIR_RT",
-		        "tag" : "specjbb",
-			"args": {
-				  "Kit Version": "RC3",
-				  "RTSTART" : 30,
-				  "JDK": "jdk.8-u121",
-				  "JVM Options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
-				  "NUMA Nodes": 4,
-				  "Data Collection": "NONE",
-				  "T1" : 154,
-				  "T2" :  45,
-				  "T3" :  23
-			}
-		}
-	]
+  "TemplateData": {
+    "HBIR": {
+      "args": [
+        "Kit Version",
+        "JDK",
+        "RTSTART",
+        "JVM Options",
+        "NUMA Nodes",
+        "Data Collection",
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "annotations": {
+        "Kit Version": "Version of SpecJBB",
+        "JDK": "Version of the JVM that will run SpecJBB",
+        "RTSTART": "What percentage of total output will we start at",
+        "JVM Options": "What additional arguments, if any, will be passed to the JVM",
+        "NUMA Nodes": "How many NUMA nodes will SpecJBB use",
+        "Data Collection": "What data collection process will monitor while running SpecJBB",
+        "T1": "How many threads does Tier 1 have access to",
+        "T2": "How many threads does Tier 2 have access to",
+        "T3": "How many threads does Tier 3 have access to"
+      },
+      "prop_options": {
+        "specjbb.controller.type": "HBIR",
+        "specjbb.time.server": false,
+        "specjbb.comm.connect.client.pool.size": 192,
+        "specjbb.comm.connect.selector.runner.count": 4,
+        "specjbb.comm.connect.timeouts.connect": 650000,
+        "specjbb.comm.connect.timeouts.read": 650000,
+        "specjbb.comm.connect.timeouts.write": 650000,
+        "specjbb.comm.connect.worker.pool.max": 320,
+        "specjbb.mapreducer.pool.size": 27
+      },
+      "types": {
+        "Kit Version": "string",
+        "JDK": "string",
+        "RTSTART": "integer",
+        "JVM Options": "string",
+        "NUMA Nodes": "integer",
+        "Data Collection": "string",
+        "T1": "integer",
+        "T2": "integer",
+        "T3": "integer"
+      },
+      "translations": {
+        "RTSTART": "specjbb.controller.rtcurve.start",
+        "T1": "specjbb.forkjoin.workers.Tier1",
+        "T2": "specjbb.forkjoin.workers.Tier2",
+        "T3": "specjbb.forkjoin.workers.Tier3",
+        "NUMA Nodes": "specjbb.group.count"
+      }
+    },
+    "HBIR_RT": {
+      "args": [
+        "Kit Version",
+        "JDK",
+        "RTSTART",
+        "JVM Options",
+        "NUMA Nodes",
+        "Data Collection",
+        "T1",
+        "T2",
+        "T3"
+      ],
+      "annotations": {
+        "Kit Version": "Version of SpecJBB",
+        "JDK": "Version of the JVM that will run SpecJBB",
+        "RTSTART": "What percentage of total output will we start at",
+        "JVM Options": "What additional arguments, if any, will be passed to the JVM",
+        "NUMA Nodes": "How many NUMA nodes will SpecJBB use",
+        "Data Collection": "What data collection process will monitor while running SpecJBB",
+        "T1": "How many threads does Tier 1 have access to",
+        "T2": "How many threads does Tier 2 have access to",
+        "T3": "How many threads does Tier 3 have access to"
+      },
+      "prop_options": {
+        "specjbb.controller.type": "HBIR_RT",
+        "specjbb.time.server": false,
+        "specjbb.comm.connect.client.pool.size": 192,
+        "specjbb.comm.connect.selector.runner.count": 4,
+        "specjbb.comm.connect.timeouts.connect": 650000,
+        "specjbb.comm.connect.timeouts.read": 650000,
+        "specjbb.comm.connect.timeouts.write": 650000,
+        "specjbb.comm.connect.worker.pool.max": 320,
+        "specjbb.customerDriver.threads": 64,
+        "specjbb.customerDriver.threads.saturate": 144,
+        "specjbb.customerDriver.threads.probe": 96,
+        "specjbb.mapreducer.pool.size": 27
+      },
+      "types": {
+        "Kit Version": "string",
+        "JDK": "string",
+        "RTSTART": "integer",
+        "JVM Options": "string",
+        "NUMA Nodes": "integer",
+        "Data Collection": "string",
+        "T1": "integer",
+        "T2": "integer",
+        "T3": "integer"
+      },
+      "translations": {
+        "RTSTART": "specjbb.controller.rtcurve.start",
+        "T1": "specjbb.forkjoin.workers.Tier1",
+        "T2": "specjbb.forkjoin.workers.Tier2",
+        "T3": "specjbb.forkjoin.workers.Tier3",
+        "NUMA Nodes": "specjbb.group.count"
+      }
+    }
+  },
+  "RunList": [
+    {
+      "template_type": "HBIR",
+      "tag": "TAG",
+      "args": {
+        "Kit Version": "15",
+        "JDK": 7,
+        "RTSTART": "4",
+        "JVM Options": "options -x -y",
+        "NUMA Nodes": "2",
+        "Data Collection": "TRUE",
+        "T1": 1,
+        "T2": 2,
+        "T3": 3
+      }
+    },
+    {
+      "template_type": "HBIR_RT",
+      "tag": "specjbb",
+      "args": {
+        "Kit Version": "RC3",
+        "RTSTART": 30,
+        "JDK": "jdk.8-u121",
+        "JVM Options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
+        "NUMA Nodes": 4,
+        "Data Collection": "NONE",
+        "T1": 154,
+        "T2": 45,
+        "T3": 23
+      }
+    }
+  ]
 }
diff --git a/examples/example_basic_config.json b/examples/example_basic_config.json
index 7aa18f2..35fef6a 100644
--- a/examples/example_basic_config.json
+++ b/examples/example_basic_config.json
@@ -1,20 +1,19 @@
 {
-	"TemplateData": {
-		"MyTemplate": {
-			"args": [
-				"Host",
-				"Port"
-			]
-
-		}
-	},
-	"RunList": [
-		{
-			"template_type": "MyTemplate",
-			"args": {
-				"Host": "localhost",
-				"Port": 24000
-			}
-		}
-	]
+  "TemplateData": {
+    "MyTemplate": {
+      "args": [
+        "Host",
+        "Port"
+      ]
+    }
+  },
+  "RunList": [
+    {
+      "template_type": "MyTemplate",
+      "args": {
+        "Host": "localhost",
+        "Port": 24000
+      }
+    }
+  ]
 }
diff --git a/examples/example_config.json b/examples/example_config.json
index 76a56b6..802492e 100644
--- a/examples/example_config.json
+++ b/examples/example_config.json
@@ -1,53 +1,48 @@
 {
-	"TemplateData": {
-		"HBIR": {
-			"args": [
-				"arg1",
-				"arg2"
-			]
-
-		},
-		"HBIR BUT BETTER": {
-			"args": [
-				"arg1",
-				"arg2",
-				"arg3"
-			]
-
-		},
-		"LOADLEVELS BUT NOT": {
-			"args": [
-				"foo",
-				"bar",
-				"baz"
-			]
-
-
-		}
-	},
-	"RunList": [
-		{
-			"template_type": "HBIR BUT BETTER",
-			"args": {
-				"arg1": "value 1",
-				"arg2": "value 1",
-				"arg3": "value 1"
-			}
-		},
-		{
-			"template_type": "HBIR",
-			"args": {
-				"arg1": 4,
-				"arg2": false
-			}
-
-		},
-		{
-			"template_type": "HBIR",
-			"args": {
-				"arg1": 4,
-				"arg2": false
-			}
-		}
-	]
+  "TemplateData": {
+    "HBIR": {
+      "args": [
+        "arg1",
+        "arg2"
+      ]
+    },
+    "HBIR BUT BETTER": {
+      "args": [
+        "arg1",
+        "arg2",
+        "arg3"
+      ]
+    },
+    "LOADLEVELS BUT NOT": {
+      "args": [
+        "foo",
+        "bar",
+        "baz"
+      ]
+    }
+  },
+  "RunList": [
+    {
+      "template_type": "HBIR BUT BETTER",
+      "args": {
+        "arg1": "value 1",
+        "arg2": "value 1",
+        "arg3": "value 1"
+      }
+    },
+    {
+      "template_type": "HBIR",
+      "args": {
+        "arg1": 4,
+        "arg2": false
+      }
+    },
+    {
+      "template_type": "HBIR",
+      "args": {
+        "arg1": 4,
+        "arg2": false
+      }
+    }
+  ]
 }
diff --git a/examples/example_curses_basic.json b/examples/example_curses_basic.json
index 3dcd389..77089de 100644
--- a/examples/example_curses_basic.json
+++ b/examples/example_curses_basic.json
@@ -1,47 +1,47 @@
 {
-    "_type": "spec_config",
-    "runs": [
-        {
-            "tag": "tag-name",
-            "skip_report": false,
-            "jdk": "/usr/bin/java",
-            "report_level": 0,
-            "data_collection": "NONE",
-            "ignore_kit_validation": false,
-            "numa_nodes": 1,
-            "num_runs": 1,
-            "jvm_options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
-            "props": {
-                "modified": [
-                    {
-                        "prop": "specjbb.comm.connect.timeouts.connect",
-                        "value": "600001"
-                    }
-                ]
-            },
-            "verbose": false,
-            "run_type": "composite"
-        },
-        {
-            "tag": "tag-name12",
-            "skip_report": false,
-            "jdk": "/usr/bin/java",
-            "report_level": 0,
-            "data_collection": "NONE",
-            "ignore_kit_validation": false,
-            "numa_nodes": 1,
-            "num_runs": 1,
-            "jvm_options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
-            "props": {
-                "modified": [
-                    {
-                        "prop": "specjbb.comm.connect.timeouts.connect",
-                        "value": "600001"
-                    }
-                ]
-            },
-            "verbose": false,
-            "run_type": "composite"
-        }
-    ]
-}
\ No newline at end of file
+  "_type": "spec_config",
+  "runs": [
+    {
+      "tag": "tag-name",
+      "skip_report": false,
+      "jdk": "/usr/bin/java",
+      "report_level": 0,
+      "data_collection": "NONE",
+      "ignore_kit_validation": false,
+      "numa_nodes": 1,
+      "num_runs": 1,
+      "jvm_options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
+      "props": {
+        "modified": [
+          {
+            "prop": "specjbb.comm.connect.timeouts.connect",
+            "value": "600001"
+          }
+        ]
+      },
+      "verbose": false,
+      "run_type": "composite"
+    },
+    {
+      "tag": "tag-name12",
+      "skip_report": false,
+      "jdk": "/usr/bin/java",
+      "report_level": 0,
+      "data_collection": "NONE",
+      "ignore_kit_validation": false,
+      "numa_nodes": 1,
+      "num_runs": 1,
+      "jvm_options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
+      "props": {
+        "modified": [
+          {
+            "prop": "specjbb.comm.connect.timeouts.connect",
+            "value": "600001"
+          }
+        ]
+      },
+      "verbose": false,
+      "run_type": "composite"
+    }
+  ]
+}
diff --git a/examples/example_curses_template.json b/examples/example_curses_template.json
index d789015..c078b16 100644
--- a/examples/example_curses_template.json
+++ b/examples/example_curses_template.json
@@ -1,64 +1,64 @@
 {
-    "TemplateData": {
-        "CURSES": {
-            "annotations": {
-                "JVM Options": "A string of arguments to be passed to the JVM",
-                "Run Type": "The run type must be 'composite', 'distributed_ctrl_txl', 'distributed_sut', or 'multi'",
-                "Ignore Kit Validation": "Whether or not SPECjbb will perform kit validation prior to running",
-                "Numa Nodes": "The number of numa nodes to use when running multiple TXINJECTOR's or BACKEND's",
-                "Tag": "The name of this run",
-                "JDK": "The full path location of a java executable to be invoked",
-                "Data Collection": "Currently unsupported",
-                "Number of Runs": "The number of times this run will execute sequentially",
-                "Verbose": "Whether or not SPECjbb will produce verbose output during a run",
-                "Skip Report": "Whether or not SPECjbb will skip producing a report after completion"
-            },
-            "args": [
-                "JDK",
-                "JVM Options",
-                "Run Type",
-                "Tag",
-                "Numa Nodes",
-                "Verbose",
-                "Report Level",
-                "Skip Report",
-                "Ignore Kit Validation",
-                "Number of Runs",
-                "Data Collection"
-            ],
-            "types": {
-                "JVM Options": "string",
-                "Run Type": "string",
-                "Ignore Kit Validation": "boolean",
-                "Numa Nodes": "integer",
-                "Tag": "string",
-                "JDK": "string",
-                "Data Collection": "string",
-                "Number of Runs": "integer",
-                "Verbose": "boolean",
-                "Skip Report": "boolean"
-            }
-        }
-    },
-    "RunList": [
-        {
-            "template_type": "CURSES",
-            "args": {
-                "JVM Options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
-                "Run Type": "composite",
-                "Ignore Kit Validation": false,
-                "Report Level": 0,
-                "Tag": "tag-name",
-                "Number of Runs": 1,
-                "Skip Report": false,
-                "Numa Nodes": 1,
-                "JDK": "/usr/bin/java",
-                "Data Collection": "NONE",
-                "Verbose": false
-            },
-            "props_extra": {
-                "specjbb.comm.connect.worker.pool.min": "12323"
-            }
-        }
-    ]
+  "TemplateData": {
+    "CURSES": {
+      "annotations": {
+        "JVM Options": "A string of arguments to be passed to the JVM",
+        "Run Type": "The run type must be 'composite', 'distributed_ctrl_txl', 'distributed_sut', or 'multi'",
+        "Ignore Kit Validation": "Whether or not SPECjbb will perform kit validation prior to running",
+        "Numa Nodes": "The number of numa nodes to use when running multiple TXINJECTOR's or BACKEND's",
+        "Tag": "The name of this run",
+        "JDK": "The full path location of a java executable to be invoked",
+        "Data Collection": "Currently unsupported",
+        "Number of Runs": "The number of times this run will execute sequentially",
+        "Verbose": "Whether or not SPECjbb will produce verbose output during a run",
+        "Skip Report": "Whether or not SPECjbb will skip producing a report after completion"
+      },
+      "args": [
+        "JDK",
+        "JVM Options",
+        "Run Type",
+        "Tag",
+        "Numa Nodes",
+        "Verbose",
+        "Report Level",
+        "Skip Report",
+        "Ignore Kit Validation",
+        "Number of Runs",
+        "Data Collection"
+      ],
+      "types": {
+        "JVM Options": "string",
+        "Run Type": "string",
+        "Ignore Kit Validation": "boolean",
+        "Numa Nodes": "integer",
+        "Tag": "string",
+        "JDK": "string",
+        "Data Collection": "string",
+        "Number of Runs": "integer",
+        "Verbose": "boolean",
+        "Skip Report": "boolean"
+      }
+    }
+  },
+  "RunList": [
+    {
+      "template_type": "CURSES",
+      "args": {
+        "JVM Options": "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48",
+        "Run Type": "composite",
+        "Ignore Kit Validation": false,
+        "Report Level": 0,
+        "Tag": "tag-name",
+        "Number of Runs": 1,
+        "Skip Report": false,
+        "Numa Nodes": 1,
+        "JDK": "/usr/bin/java",
+        "Data Collection": "NONE",
+        "Verbose": false
+      },
+      "props_extra": {
+        "specjbb.comm.connect.worker.pool.min": "12323"
+      }
+    }
+  ]
 }
diff --git a/mainCLI.py b/mainCLI.py
index e5b47fa..c81db72 100644
--- a/mainCLI.py
+++ b/mainCLI.py
@@ -34,6 +34,7 @@
 
 log = logging.getLogger(__name__)
 
+
 def to_list(s):
     if s["run_type"].lower() in ["hbir", "hbir_rt"]:
         return [
@@ -113,12 +114,19 @@ def do_run(arguments):
 
         s.run(arguments['--dry-run'])
 
+
 def do_script(arguments):
-    call(["perl", "scripts/{}.pl".format(arguments["<script>"])] + arguments["ARG"])
+    call(["perl", "scripts/{}.pl".format(arguments["<script>"])] +
+         arguments["ARG"])
+
 
 def do_scripts(arguments):
     log.info("These are the scripts available to run using 'script':")
-    log.info([script for script in os.listdir(join(dirname(__file__), "scripts")) if script.endswith("pl")])
+    log.info([
+        script for script in os.listdir(join(dirname(__file__), "scripts"))
+        if script.endswith("pl")
+    ])
+
 
 def do_compliant(arguments):
     with open(arguments['<config>'], 'r') as f:
diff --git a/objects.py b/objects.py
index 1b439ae..8f6e919 100644
--- a/objects.py
+++ b/objects.py
@@ -43,11 +43,13 @@ def run(self, outhandle, errhandle):
             jar_path = os.getcwd()
         jar_file = os.path.join(jar_path, "specjbb2015.jar")
         if not os.path.exists(jar_file):
-            errhandle('Failed to locate "specjbb2015.jar" in "{}"'.format(jar_path))
+            errhandle(
+                'Failed to locate "specjbb2015.jar" in "{}"'.format(jar_path))
             return 2
-        result_dir = "{}/results_{}-runs_{}".format(jar_path, len(self.runs),
-                                                    datetime.datetime.fromtimestamp(time.time()).strftime(
-                                                        '+%y-%m-%d_%H%M%S'))
+        result_dir = "{}/results_{}-runs_{}".format(
+            jar_path, len(self.runs),
+            datetime.datetime.fromtimestamp(
+                time.time()).strftime('+%y-%m-%d_%H%M%S'))
         os.makedirs(result_dir)
         for r in self.runs:
             result = r._run(jar_file, result_dir, outhandle, errhandle)
@@ -60,7 +62,6 @@ def set_spec_dir(self, path):
         for r in self.runs:
             r.spec_dir = path
 
-
     def _rollup(self, path: str, outhandle):
         """
         :param path: Path to a directory containing directories of results
@@ -81,8 +82,12 @@ def _rollup(self, path: str, outhandle):
         outhandle(os.linesep)
         outhandle("Starting analysis on {}...".format(path))
         outhandle(os.linesep)
-        p = Popen(shlex.split("{} {} {}".format(perlbin, rollscript, path)), cwd=path, stdout=PIPE, stderr=STDOUT,
-                  universal_newlines=True)
+        p = Popen(
+            shlex.split("{} {} {}".format(perlbin, rollscript, path)),
+            cwd=path,
+            stdout=PIPE,
+            stderr=STDOUT,
+            universal_newlines=True)
         outstream = stream(p.stdout)
         while p.poll() is None:
             o = outstream.readline()
@@ -91,7 +96,8 @@ def _rollup(self, path: str, outhandle):
         p.wait()
         resname, resext = os.path.splitext(os.path.basename(path))
         resname += ".csv"
-        result = os.path.join(os.path.abspath(os.path.join(path, os.pardir)), resname)
+        result = os.path.join(
+            os.path.abspath(os.path.join(path, os.pardir)), resname)
         return result
 
     def _tojson(self):
@@ -106,45 +112,50 @@ def _tojson(self):
 
     def _totateconfig(self):
         return {
-            "TemplateData": {"CURSES": {
-                "args": [
-                    "JDK",
-                    "JVM Options",
-                    "Run Type",
-                    "Tag",
-                    "Numa Nodes",
-                    "Verbose",
-                    "Report Level",
-                    "Skip Report",
-                    "Ignore Kit Validation",
-                    "Number of Runs",
-                    "Data Collection"
-                ],
-                "annotations": {
-                    "JDK": "The full path location of a java executable to be invoked",
-                    "JVM Options": "A string of arguments to be passed to the JVM",
-                    "Run Type": "The run type must be 'composite', 'distributed_ctrl_txl', 'distributed_sut', or 'multi'",
-                    "Tag": "The name of this run",
-                    "Numa Nodes": "The number of numa nodes to use when running multiple TXINJECTOR's or BACKEND's",
-                    "Verbose": "Whether or not SPECjbb will produce verbose output during a run",
-                    "Skip Report": "Whether or not SPECjbb will skip producing a report after completion",
-                    "Ignore Kit Validation": "Whether or not SPECjbb will perform kit validation prior to running",
-                    "Number of Runs": "The number of times this run will execute sequentially",
-                    "Data Collection": "Currently unsupported"
-                },
-                "types": {
-                    "JDK": "string",
-                    "JVM Options": "string",
-                    "Run Type": "string",
-                    "Tag": "string",
-                    "Numa Nodes": "integer",
-                    "Verbose": "boolean",
-                    "Skip Report": "boolean",
-                    "Ignore Kit Validation": "boolean",
-                    "Number of Runs": "integer",
-                    "Data Collection": "string"
+            "TemplateData": {
+                "CURSES": {
+                    "args": [
+                        "JDK", "JVM Options", "Run Type", "Tag", "Numa Nodes",
+                        "Verbose", "Report Level", "Skip Report",
+                        "Ignore Kit Validation", "Number of Runs",
+                        "Data Collection"
+                    ],
+                    "annotations": {
+                        "JDK":
+                        "The full path location of a java executable to be invoked",
+                        "JVM Options":
+                        "A string of arguments to be passed to the JVM",
+                        "Run Type":
+                        "The run type must be 'composite', 'distributed_ctrl_txl', 'distributed_sut', or 'multi'",
+                        "Tag":
+                        "The name of this run",
+                        "Numa Nodes":
+                        "The number of numa nodes to use when running multiple TXINJECTOR's or BACKEND's",
+                        "Verbose":
+                        "Whether or not SPECjbb will produce verbose output during a run",
+                        "Skip Report":
+                        "Whether or not SPECjbb will skip producing a report after completion",
+                        "Ignore Kit Validation":
+                        "Whether or not SPECjbb will perform kit validation prior to running",
+                        "Number of Runs":
+                        "The number of times this run will execute sequentially",
+                        "Data Collection":
+                        "Currently unsupported"
+                    },
+                    "types": {
+                        "JDK": "string",
+                        "JVM Options": "string",
+                        "Run Type": "string",
+                        "Tag": "string",
+                        "Numa Nodes": "integer",
+                        "Verbose": "boolean",
+                        "Skip Report": "boolean",
+                        "Ignore Kit Validation": "boolean",
+                        "Number of Runs": "integer",
+                        "Data Collection": "string"
+                    }
                 }
-            }},
+            },
             "RunList": list(map(lambda x: x._totateconfig(), self.runs))
         }
 
@@ -155,14 +166,17 @@ def save(self, path: str):
 
 
 class spec_encoder(json.JSONEncoder):
+
     def default(self, obj):
-        if isinstance(obj, spec_config) or isinstance(obj, spec_run) or isinstance(obj, props) or isinstance(obj,
-                                                                                                             propitem):
+        if isinstance(obj, spec_config) or isinstance(
+                obj, spec_run) or isinstance(obj, props) or isinstance(
+                    obj, propitem):
             return obj._tojson()
         return super(spec_encoder, self).default(obj)
 
 
 class spec_decoder(json.JSONDecoder):
+
     def __init__(self, *args, **kwargs):
         json.JSONDecoder.__init__(
             self, object_hook=self.object_hook, *args, **kwargs)
@@ -190,7 +204,8 @@ def decode_tate(self, obj, templates):
                 raise AssertionError("Run in RunList has no template type")
             temp = templates.get(template_type, '')
             if temp == '':
-                raise AssertionError("Template '{}' does not exist in TemplateData".format(temp))
+                raise AssertionError(
+                    "Template '{}' does not exist in TemplateData".format(temp))
             translations = temp.get('translations', {})
             for k, v in run.items():
                 if k in known_args:
@@ -229,7 +244,9 @@ def __init__(self, fromjson=None):
             self.spec_dir = ""
         else:
             self.jdk = fromjson.get('jdk', "/usr/bin/java")
-            self.jvm_options = fromjson.get('jvm_options', "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48")
+            self.jvm_options = fromjson.get(
+                'jvm_options',
+                "-Xms29g -Xmx29g -Xmn27g -XX:ParallelGCThreads=48")
             self.data_collection = fromjson.get('data_collection', "NONE")
             self.num_runs = fromjson.get('num_runs', 1)
             self.tag = fromjson.get('tag', "tag-name")
@@ -239,7 +256,8 @@ def __init__(self, fromjson=None):
             self.numa_nodes = fromjson.get('numa_nodes', 1)
             self.report_level = fromjson.get('report_level', 0)
             self.skip_report = fromjson.get('skip_report', False)
-            self.ignore_kit_validation = fromjson.get('ignore_kit_validation', False)
+            self.ignore_kit_validation = fromjson.get('ignore_kit_validation',
+                                                      False)
             self.spec_dir = fromjson.get('spec_dir', "")
 
     def set_runtype(self, arg: str):
@@ -343,7 +361,11 @@ def _defHandle(msg):
     # handle = Any function that takes a single string argument.
     # It can be used to intercept any output
     # If set to None, then output will only be logged
-    def _run(self, jar_file="", result_path="", handle_out=_defHandle, handle_err=_defHandle):
+    def _run(self,
+             jar_file="",
+             result_path="",
+             handle_out=_defHandle,
+             handle_err=_defHandle):
         """
         Runs with the current settings.  Auto detects runtype, writes the config file, and executes all required processes
         :param path: The path to a directory containing 'specjbb2015.jar'
@@ -359,7 +381,8 @@ def _run(self, jar_file="", result_path="", handle_out=_defHandle, handle_err=_d
             return 3
         fname, fext = os.path.splitext(jar_file)
         if not os.path.exists(jar_file) or fext != '.jar':
-            handle_err('Failed to locate "specjbb2015.jar" in "{}"'.format(jar_file))
+            handle_err(
+                'Failed to locate "specjbb2015.jar" in "{}"'.format(jar_file))
             return 2
 
         if result_path == "" or not os.path.exists(result_path):
@@ -374,16 +397,18 @@ def _run(self, jar_file="", result_path="", handle_out=_defHandle, handle_err=_d
         spec_run._running = True
         signal.signal(signal.SIGINT, spec_run._signal_handler)
 
-        ret = switch[self.run_type](jar_file, result_path, handle_out, handle_err)
+        ret = switch[self.run_type](jar_file, result_path, handle_out,
+                                    handle_err)
 
         signal.signal(signal.SIGINT, orig_sig)
         spec_run._running = False
         return ret
 
-    def _run_composite(self, jar: str, result_parent: str, handle_out, handle_err):
+    def _run_composite(self, jar: str, result_parent: str, handle_out,
+                       handle_err):
         """Called internally only by this.run()"""
-        cmd = '{} {} -jar {} -m COMPOSITE {}'.format(
-            self.jdk, self.jvm_options, jar, self._spec_opts())
+        cmd = '{} {} -jar {} -m COMPOSITE {}'.format(self.jdk, self.jvm_options,
+                                                     jar, self._spec_opts())
 
         for x in range(int(self.num_runs)):
             result_dir = self._prerun(result_parent)
@@ -396,7 +421,12 @@ def _run_composite(self, jar: str, result_parent: str, handle_out, handle_err):
             data = self._start_data_collection(result_dir, handle_out)
             errout = open(os.path.join(result_dir, 'composite.out'), 'w')
             stdout = open(os.path.join(result_dir, 'composite.log'), 'w')
-            p = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+            p = Popen(
+                shlex.split(cmd),
+                cwd=result_dir,
+                stdout=PIPE,
+                stderr=PIPE,
+                universal_newlines=True)
             spec_run._running = True
             errstream = stream(p.stderr)
             outstream = stream(p.stdout)
@@ -427,7 +457,8 @@ def _run_composite(self, jar: str, result_parent: str, handle_out, handle_err):
                 return -1
         return 0
 
-    def _run_distributed_ctrl_txl(self, jar: str, result_parent: str, handle_out, handle_err):
+    def _run_distributed_ctrl_txl(self, jar: str, result_parent: str,
+                                  handle_out, handle_err):
         """Called internally only by this.run()"""
         ctrl_ip = self.properties.root['specjbb.controller.host'].value
         pingcmd = 'ping -c 1 {}'.format(ctrl_ip)
@@ -439,7 +470,9 @@ def _run_distributed_ctrl_txl(self, jar: str, result_parent: str, handle_out, ha
         exitcode = ping.wait()
         FNULL.close()
         if exitcode != 0:
-            handle_err('ERROR: Failed to ping Controller host (specjbb.controller.host): {}'.format(ctrl_ip))
+            handle_err(
+                'ERROR: Failed to ping Controller host (specjbb.controller.host): {}'.
+                format(ctrl_ip))
 
             return 4
         handle_out(os.linesep)
@@ -449,23 +482,43 @@ def _run_distributed_ctrl_txl(self, jar: str, result_parent: str, handle_out, ha
         opts = self._spec_opts()
         tx_opts = self._tx_opts()
         result_dir = self._prerun(result_parent)
-        cmd = '{} {} -jar {} -m DISTCONTROLLER {}'.format(self.jdk, self.jvm_options, jar, opts)
+        cmd = '{} {} -jar {} -m DISTCONTROLLER {}'.format(
+            self.jdk, self.jvm_options, jar, opts)
         tx_procs = []
         cont_std = open(os.path.join(result_dir, 'controller.log'), 'w')
         cont_err = open(os.path.join(result_dir, 'controller.out'), 'w')
-        controller = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        controller = Popen(
+            shlex.split(cmd),
+            cwd=result_dir,
+            stdout=PIPE,
+            stderr=PIPE,
+            universal_newlines=True)
         data = self._start_data_collection(result_dir, handle_out)
         for g in range(int(self.properties.root['specjbb.group.count'].value)):
-            for j in range(int(self.properties.root['specjbb.txi.pergroup.count'].value)):
-                ti_name = "{}Group{}.TxInjector.txiJVM{}".format(result_dir, g, j)
-                cmd = '{} {} -jar {} -m TXINJECTOR -G={}'.format(self.jdk, self.jvm_options, jar,
-                                                                 tx_opts, g)
-                p = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=PIPE, universal_newlines=True)
-                tx_procs.append([p,
-                                 open(os.path.join(result_dir, '{}.log'.format(ti_name)), 'w'),
-                                 open(os.path.join(result_dir, '{}.out'.format(ti_name)), 'w'),
-                                 stream(p.stderr),
-                                 stream(p.stdout)])
+            for j in range(
+                    int(self.properties.root['specjbb.txi.pergroup.count']
+                        .value)):
+                ti_name = "{}Group{}.TxInjector.txiJVM{}".format(
+                    result_dir, g, j)
+                cmd = '{} {} -jar {} -m TXINJECTOR -G={}'.format(
+                    self.jdk, self.jvm_options, jar, tx_opts, g)
+                p = Popen(
+                    shlex.split(cmd),
+                    cwd=result_dir,
+                    stdout=PIPE,
+                    stderr=PIPE,
+                    universal_newlines=True)
+                tx_procs.append([
+                    p,
+                    open(
+                        os.path.join(result_dir, '{}.log'.format(ti_name)),
+                        'w'),
+                    open(
+                        os.path.join(result_dir, '{}.out'.format(ti_name)),
+                        'w'),
+                    stream(p.stderr),
+                    stream(p.stdout)
+                ])
         spec_run._running = True
         errstream = stream(controller.stderr)
         outstream = stream(controller.stdout)
@@ -509,7 +562,8 @@ def _run_distributed_ctrl_txl(self, jar: str, result_parent: str, handle_out, ha
             return -1
         return 0
 
-    def _distributed_sut(self, jar: str, result_parent: str, handle_out, handle_err):
+    def _distributed_sut(self, jar: str, result_parent: str, handle_out,
+                         handle_err):
         """Called internally only by this.run()"""
         ctrl_ip = self.properties.root['specjbb.controller.host'].value
         pingcmd = 'ping -c 1 {}'.format(ctrl_ip)
@@ -521,7 +575,9 @@ def _distributed_sut(self, jar: str, result_parent: str, handle_out, handle_err)
         exitcode = ping.wait()
         FNULL.close()
         if exitcode != 0:
-            handle_err('ERROR: Failed to ping Controller host (specjbb.controller.host): {}'.format(ctrl_ip))
+            handle_err(
+                'ERROR: Failed to ping Controller host (specjbb.controller.host): {}'.
+                format(ctrl_ip))
             return 4
         handle_out(os.linesep)
         handle_out("Starting backends, press Ctrl + C to terminate.")
@@ -532,12 +588,19 @@ def _distributed_sut(self, jar: str, result_parent: str, handle_out, handle_err)
         data = self._start_data_collection(result_dir, handle_out)
         for g in range(int(self.properties.root['specjbb.group.count'].value)):
             be_name = 'beJVM Group{}.Backend.beJVM.log'.format(g)
-            cmd = '{} {} -jar {} -m BACKEND {} -G={} -J=beJVM'.format(self.jdk, self.jvm_options, jar,
-                                                                      opts, g)
-            p = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=STDOUT, universal_newlines=True)
-            procs.append([p,
-                          open(os.path.join(result_dir, be_name), 'w'),
-                          stream(p.stdout)])
+            cmd = '{} {} -jar {} -m BACKEND {} -G={} -J=beJVM'.format(
+                self.jdk, self.jvm_options, jar, opts, g)
+            p = Popen(
+                shlex.split(cmd),
+                cwd=result_dir,
+                stdout=PIPE,
+                stderr=STDOUT,
+                universal_newlines=True)
+            procs.append([
+                p,
+                open(os.path.join(result_dir, be_name), 'w'),
+                stream(p.stdout)
+            ])
 
         spec_run._running = True
         while spec_run._running:
@@ -566,54 +629,80 @@ def _run_multi(self, jar: str, result_parent: str, handle_out, handle_err):
         for x in range(int(self.num_runs)):
             handle_out(os.linesep)
             result_dir = self._prerun(result_parent)
-            handle_out("Starting run {} of {} in {}...".format(x +
-                                                               1, self.num_runs, result_dir))
+            handle_out("Starting run {} of {} in {}...".format(
+                x + 1, self.num_runs, result_dir))
             handle_out(os.linesep)
             handle_out(os.linesep)
 
             cont_std = open(os.path.join(result_dir, 'controller.log'), 'w')
             cont_err = open(os.path.join(result_dir, 'controller.out'), 'w')
-            cmd = '{} {} -jar {} -m MULTICONTROLLER {}'.format(self.jdk, self.jvm_options, jar, opts)
-            controller = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+            cmd = '{} {} -jar {} -m MULTICONTROLLER {}'.format(
+                self.jdk, self.jvm_options, jar, opts)
+            controller = Popen(
+                shlex.split(cmd),
+                cwd=result_dir,
+                stdout=PIPE,
+                stderr=PIPE,
+                universal_newlines=True)
             tx_procs = []
             be_procs = []
             data = self._start_data_collection(result_dir, handle_out)
-            for g in range(int(self.properties.root['specjbb.group.count'].value)):
+            for g in range(
+                    int(self.properties.root['specjbb.group.count'].value)):
                 numa = numa_cmd.format((g - 1) % 4)
-                for j in range(self.properties.root['specjbb.txi.pergroup.count'].value):
+                for j in range(self.properties.root[
+                        'specjbb.txi.pergroup.count'].value):
                     ti_name = "Group{}.TxInjector.txiJVM{}".format(g, j)
                     if has_numa:
-                        cmd = '{} {} {} -jar {} -m TXINJECTOR -G={} -J=txiJVM{} {}'.format(numa, self.jdk,
-                                                                                           self.jvm_options,
-                                                                                           jar, g, j,
-                                                                                           tx_opts)
+                        cmd = '{} {} {} -jar {} -m TXINJECTOR -G={} -J=txiJVM{} {}'.format(
+                            numa, self.jdk, self.jvm_options, jar, g, j,
+                            tx_opts)
                     else:
-                        cmd = '{} {} -jar {} -m TXINJECTOR -G={} -J=txiJVM{} {}'.format(self.jdk, self.jvm_options,
-                                                                                        jar, g, j, tx_opts)
+                        cmd = '{} {} -jar {} -m TXINJECTOR -G={} -J=txiJVM{} {}'.format(
+                            self.jdk, self.jvm_options, jar, g, j, tx_opts)
                     handle_out('Using command: "{}"'.format(cmd))
-                    p = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=PIPE, universal_newlines=True)
-                    tx_procs.append([p,
-                                     open(os.path.join(result_dir, '{}.log'.format(ti_name)), 'w'),
-                                     open(os.path.join(result_dir, '{}.out'.format(ti_name)), 'w'),
-                                     stream(p.stderr),
-                                     stream(p.stdout)])
+                    p = Popen(
+                        shlex.split(cmd),
+                        cwd=result_dir,
+                        stdout=PIPE,
+                        stderr=PIPE,
+                        universal_newlines=True)
+                    tx_procs.append([
+                        p,
+                        open(
+                            os.path.join(result_dir, '{}.log'.format(ti_name)),
+                            'w'),
+                        open(
+                            os.path.join(result_dir, '{}.out'.format(ti_name)),
+                            'w'),
+                        stream(p.stderr),
+                        stream(p.stdout)
+                    ])
                 be_name = "Group{}.Backend.beJVM".format(g)
                 if has_numa:
-                    cmd = '{} {} {} -jar {} -m BACKEND {} -G={} -J=beJVM'.format(numa, self.jdk,
-                                                                                 self.jvm_options,
-                                                                                 jar, tx_opts,
-                                                                                 g)
+                    cmd = '{} {} {} -jar {} -m BACKEND {} -G={} -J=beJVM'.format(
+                        numa, self.jdk, self.jvm_options, jar, tx_opts, g)
                 else:
-                    cmd = '{} {} -jar {} -m BACKEND {} -G={} -J=beJVM'.format(self.jdk, self.jvm_options,
-                                                                              jar, tx_opts,
-                                                                              g)
+                    cmd = '{} {} -jar {} -m BACKEND {} -G={} -J=beJVM'.format(
+                        self.jdk, self.jvm_options, jar, tx_opts, g)
                 handle_out('Using command: "{}"'.format(cmd))
-                p = Popen(shlex.split(cmd), cwd=result_dir, stdout=PIPE, stderr=PIPE, universal_newlines=True)
-                be_procs.append([p,
-                                 open(os.path.join(result_dir, '{}.log'.format(be_name)), 'w'),
-                                 open(os.path.join(result_dir, '{}.out'.format(be_name)), 'w'),
-                                 stream(p.stderr),
-                                 stream(p.stdout)])
+                p = Popen(
+                    shlex.split(cmd),
+                    cwd=result_dir,
+                    stdout=PIPE,
+                    stderr=PIPE,
+                    universal_newlines=True)
+                be_procs.append([
+                    p,
+                    open(
+                        os.path.join(result_dir, '{}.log'.format(be_name)),
+                        'w'),
+                    open(
+                        os.path.join(result_dir, '{}.out'.format(be_name)),
+                        'w'),
+                    stream(p.stderr),
+                    stream(p.stdout)
+                ])
 
             spec_run._running = True
             errstream = stream(controller.stderr)
@@ -686,19 +775,25 @@ def _prerun(self, path: str):
         :param path: Path to results folder
         :return:
         """
-        result_dir = "{}/{}-{}".format(path, datetime.datetime.fromtimestamp(time.time()).strftime('+%y-%m-%d_%H%M%S'),
-                                       self.tag)
+        result_dir = "{}/{}-{}".format(
+            path,
+            datetime.datetime.fromtimestamp(
+                time.time()).strftime('+%y-%m-%d_%H%M%S'), self.tag)
         os.makedirs(result_dir)
         if not os.path.exists("{}/config".format(result_dir)):
             os.makedirs("{}/config".format(result_dir))
-        self.properties.writeconfig("{}/config/specjbb2015.props".format(result_dir))
+        self.properties.writeconfig(
+            "{}/config/specjbb2015.props".format(result_dir))
         templates = os.path.abspath(os.path.join(__file__, os.pardir))
         templateC = os.path.join(templates, "scripts", "template-C.raw")
         templateD = os.path.join(templates, "scripts", "template-D.raw")
         templateM = os.path.join(templates, "scripts", "template-M.raw")
-        shutil.copyfile(templateC, os.path.join(result_dir, "config", "tempalte-C.raw"))
-        shutil.copyfile(templateD, os.path.join(result_dir, "config", "tempalte-D.raw"))
-        shutil.copyfile(templateM, os.path.join(result_dir, "config", "tempalte-M.raw"))
+        shutil.copyfile(templateC,
+                        os.path.join(result_dir, "config", "tempalte-C.raw"))
+        shutil.copyfile(templateD,
+                        os.path.join(result_dir, "config", "tempalte-D.raw"))
+        shutil.copyfile(templateM,
+                        os.path.join(result_dir, "config", "tempalte-M.raw"))
         return result_dir
 
     def _start_data_collection(self, results_dir: str, handle):
@@ -707,13 +802,25 @@ def _start_data_collection(self, results_dir: str, handle):
         for c in cmds:
             if c != 'NONE' and c != '':
                 shcmd = shlex.split(c)
-                if os.path.exists(shcmd[0]) or any(os.access(os.path.join(path, shcmd[0]), os.X_OK) for path in os.environ["PATH"].split(os.pathsep)):
+                if os.path.exists(shcmd[0]) or any(
+                        os.access(os.path.join(path, shcmd[0]), os.X_OK)
+                        for path in os.environ["PATH"].split(os.pathsep)):
                     handle("Starting data collection ''{}".format(c))
-                    stdout = open(os.path.join(results_dir, "{}.log".format(shcmd[0])), 'w')
-                    procs.append(Popen(shcmd, cwd=results_dir, stdout=stdout, stderr=STDOUT, close_fds=True,
-                                       universal_newlines=True))
+                    stdout = open(
+                        os.path.join(results_dir, "{}.log".format(shcmd[0])),
+                        'w')
+                    procs.append(
+                        Popen(
+                            shcmd,
+                            cwd=results_dir,
+                            stdout=stdout,
+                            stderr=STDOUT,
+                            close_fds=True,
+                            universal_newlines=True))
                 else:
-                    handle("Failed to start data collection: '{}', command does not exit".format(c))
+                    handle(
+                        "Failed to start data collection: '{}', command does not exit".
+                        format(c))
         return procs
 
     def _tx_opts(self):
@@ -751,7 +858,15 @@ def _signal_handler(signum, frame):
 
 
 class propitem:
-    def __init__(self, prop, def_value, desc, input_validator, value_validator, valid_opts=None, help_text=""):
+
+    def __init__(self,
+                 prop,
+                 def_value,
+                 desc,
+                 input_validator,
+                 value_validator,
+                 valid_opts=None,
+                 help_text=""):
         self.prop = prop
         self.def_value = def_value
         self.desc = desc
@@ -783,197 +898,320 @@ def _totateconfig(self):
 
     def _tojson(self):
         """Called internally only.  Returns dictionary of json values"""
-        return {
-            "prop": self.prop,
-            "value": self.value
-        }
+        return {"prop": self.prop, "value": self.value}
 
 
 known_args = [
-    'JDK',
-    'JVM Options',
-    'Run Type',
-    'Tag',
-    'Numa Nodes',
-    'Verbose',
-    'Skip Report',
-    'Ignore Kit Validation',
-    'Number of Runs',
-    'Data Collection'
+    'JDK', 'JVM Options', 'Run Type', 'Tag', 'Numa Nodes', 'Verbose',
+    'Skip Report', 'Ignore Kit Validation', 'Number of Runs', 'Data Collection'
 ]
 
-run_types = [
-    'composite',
-    'distributed_ctrl_txl',
-    'distributed_sut',
-    'multi'
-]
+run_types = ['composite', 'distributed_ctrl_txl', 'distributed_sut', 'multi']
 
-loglevels = [
-    'SEVERE',
-    'WARNING',
-    'INFO',
-    'CONFIG',
-    'FINE',
-    'FINER',
-    'FINEST'
-]
+loglevels = ['SEVERE', 'WARNING', 'INFO', 'CONFIG', 'FINE', 'FINER', 'FINEST']
 
 con_types = [
-    'HBIR_RT',
-    'HBIR',
-    'PRESET',
-    'FIXED_RT',
-    'FIXED_RT_LOADLEVELS',
+    'HBIR_RT', 'HBIR', 'PRESET', 'FIXED_RT', 'FIXED_RT_LOADLEVELS',
     'FIXED_LOADLEVELS'
 ]
 
 must_be_positive = "Value must be greater than 0"
 
 
-def number_validator(x): return int(x) <= ord('9') and int(x) >= ord('0')
+def number_validator(x):
+    return int(x) <= ord('9') and int(x) >= ord('0')
 
 
-def float_validator(x): return (
-    x <= ord('9') and x >= ord('0')) or x == ord('.')
+def float_validator(x):
+    return (x <= ord('9') and x >= ord('0')) or x == ord('.')
 
 
-def default_validator(x): return True
+def default_validator(x):
+    return True
 
 
 defaults = [
-    propitem('specjbb.controller.type', 'HBIR_RT', 'Controls phases being controlled by Controller.', default_validator,
-             lambda x: x in con_types, con_types),
-    propitem('specjbb.comm.connect.client.pool.size', 256,
-             'Network connection pool size, i.e. number of sockets for I/O communication for each Agent.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.comm.connect.worker.pool.min', 1,
-             'Minimum number of worker threads in the network connection pool.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.comm.connect.worker.pool.max', 256,
-             'Maximum number of worker threads in the network connection pool.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.comm.connect.selector.runner.count', 0,
-             'Number of acceptor threads for handling new connections and scheduling existing ones.',
-             number_validator, lambda x: int(x) >= 0,
-             help_text="Value must an integer. Special '0' value  will force to using the default connectivity provider setting"),
-    propitem('specjbb.comm.connect.timeouts.connect', 60000, 'Timeout (in milliseconds) for I/O connection operation.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.comm.connect.timeouts.read', 60000, 'Timeout (in milliseconds) for I/O read operation.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.comm.connect.timeouts.write', 60000, 'Timeout (in milliseconds) for I/O write operation.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.controller.host', "localhost",
-             'IP address / host name of the machine where Controller program will be launched.',
-             default_validator, default_validator, help_text=must_be_positive),
-    propitem('specjbb.controller.port', 24000, 'The network port to which Controller listener will bind.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.controller.handshake.period', 5000,
-             'Time period (in milliseconds) for logging status of the initial Controller <-> Agent handshaking.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.controller.handshake.timeout', 600000,
-             'Timeout (in milliseconds) for initial Controller <-> Agent handshaking.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.controller.maxir.maxFailedPoints', 3,
-             ' Number of points to try after max-jOPS was found to ensure there are no more passes and max-jOPS value is correct.',
-             number_validator, lambda x: int(x) >= 0, help_text="Value must be greater than or equal to 0"),
-
-    propitem('specjbb.controller.preset.ir', 1000, 'Sets IR for preset for controller type ',
-             number_validator, lambda x: x >= 0, help_text="Value must be greater than or equal to 0"),
-    propitem('specjbb.controller.preset.duration', 600000,
-             'Sets duration in milliseconds for preset for controller type ',
-             number_validator, lambda x: int(x) > 0, help_text="Value must be greater than or equal to 0"),
-
-    propitem('specjbb.controller.rtcurve.duration.min', 60000,
-             'Sets duration of steady period of RT step level in milliseconds',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.controller.rtcurve.duration.max', 90000,
-             'Sets duration of steady period of RT step level in milliseconds',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.controller.rtcurve.start', 0, 'Sets the RT start percent',
-             number_validator, lambda x: int(x) >= 0 and int(x) <= 100, help_text="Value must be between 0 and 100"),
-    propitem('specjbb.controller.rtcurve.step', 0.01, 'Sets the RT step level to a percent',
-             float_validator, lambda x: float(x) > 0 and float(x) <= 1,
-             help_text="Value must be a decimal greater than 0 and less than or equal to 1"),
-    propitem('specjbb.controller.rtcurve.warmup.step', 0.1,
-             'Injection rate for warming up before response-time curve building defined as the percent of the high-bound.',
-             float_validator, lambda x: float(x) > 0 and float(x) <= 1,
-             help_text="Value must be a decimal greater than 0 and less than or equal to 1"),
-
-    propitem('specjbb.controller.settle.time.min', 3000,
-             'Sets duration of settle period of RT step level in milliseconds', number_validator, lambda x: int(
-                 x) > 0,
-             help_text=must_be_positive),
-    propitem('specjbb.controller.settle.time.max', 30000,
-             'Sets duration of settle period of RT step level in milliseconds', number_validator, lambda x: int(
-                 x) > 0,
-             help_text=must_be_positive),
+    propitem('specjbb.controller.type', 'HBIR_RT',
+             'Controls phases being controlled by Controller.',
+             default_validator, lambda x: x in con_types, con_types),
+    propitem(
+        'specjbb.comm.connect.client.pool.size',
+        256,
+        'Network connection pool size, i.e. number of sockets for I/O communication for each Agent.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.comm.connect.worker.pool.min',
+        1,
+        'Minimum number of worker threads in the network connection pool.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.comm.connect.worker.pool.max',
+        256,
+        'Maximum number of worker threads in the network connection pool.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.comm.connect.selector.runner.count',
+        0,
+        'Number of acceptor threads for handling new connections and scheduling existing ones.',
+        number_validator,
+        lambda x: int(x) >= 0,
+        help_text=
+        "Value must an integer. Special '0' value  will force to using the default connectivity provider setting"
+    ),
+    propitem(
+        'specjbb.comm.connect.timeouts.connect',
+        60000,
+        'Timeout (in milliseconds) for I/O connection operation.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.comm.connect.timeouts.read',
+        60000,
+        'Timeout (in milliseconds) for I/O read operation.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.comm.connect.timeouts.write',
+        60000,
+        'Timeout (in milliseconds) for I/O write operation.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.host',
+        "localhost",
+        'IP address / host name of the machine where Controller program will be launched.',
+        default_validator,
+        default_validator,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.port',
+        24000,
+        'The network port to which Controller listener will bind.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.handshake.period',
+        5000,
+        'Time period (in milliseconds) for logging status of the initial Controller <-> Agent handshaking.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.handshake.timeout',
+        600000,
+        'Timeout (in milliseconds) for initial Controller <-> Agent handshaking.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.maxir.maxFailedPoints',
+        3,
+        ' Number of points to try after max-jOPS was found to ensure there are no more passes and max-jOPS value is correct.',
+        number_validator,
+        lambda x: int(x) >= 0,
+        help_text="Value must be greater than or equal to 0"),
+    propitem(
+        'specjbb.controller.preset.ir',
+        1000,
+        'Sets IR for preset for controller type ',
+        number_validator,
+        lambda x: x >= 0,
+        help_text="Value must be greater than or equal to 0"),
+    propitem(
+        'specjbb.controller.preset.duration',
+        600000,
+        'Sets duration in milliseconds for preset for controller type ',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text="Value must be greater than or equal to 0"),
+    propitem(
+        'specjbb.controller.rtcurve.duration.min',
+        60000,
+        'Sets duration of steady period of RT step level in milliseconds',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.rtcurve.duration.max',
+        90000,
+        'Sets duration of steady period of RT step level in milliseconds',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.rtcurve.start',
+        0,
+        'Sets the RT start percent',
+        number_validator,
+        lambda x: int(x) >= 0 and int(x) <= 100,
+        help_text="Value must be between 0 and 100"),
+    propitem(
+        'specjbb.controller.rtcurve.step',
+        0.01,
+        'Sets the RT step level to a percent',
+        float_validator,
+        lambda x: float(x) > 0 and float(x) <= 1,
+        help_text=
+        "Value must be a decimal greater than 0 and less than or equal to 1"),
+    propitem(
+        'specjbb.controller.rtcurve.warmup.step',
+        0.1,
+        'Injection rate for warming up before response-time curve building defined as the percent of the high-bound.',
+        float_validator,
+        lambda x: float(x) > 0 and float(x) <= 1,
+        help_text=
+        "Value must be a decimal greater than 0 and less than or equal to 1"),
+    propitem(
+        'specjbb.controller.settle.time.min',
+        3000,
+        'Sets duration of settle period of RT step level in milliseconds',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.controller.settle.time.max',
+        30000,
+        'Sets duration of settle period of RT step level in milliseconds',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
 
     # propitem('specjbb.customerDriver.threads', 64, 'Maximum number of threads in ThreadPoolExecutor for all three probe/saturate/service requests on the TxInjector side.', lambda x: isinstance(x, int) and x >= 64,help_text=must_be_positive)
-    propitem('specjbb.customerDriver.threads.saturate', 64,
-             'Maximum number of threads in ThreadPoolExecutor for saturate requests on the TxInjector side.',
-             number_validator, lambda x: int(x) >= 64, help_text="Value must be greater than or equal to 64"),
-    propitem('specjbb.customerDriver.threads.probe', 64,
-             'Maximum number of threads in ThreadPoolExecutor for probe requests on the TxInjector side.',
-             number_validator,
-             lambda x: int(x) >= 64, help_text="Value must be greater than or equal to 64"),
-    propitem('specjbb.customerDriver.threads.service', 64,
-             'Maximum number of threads in ThreadPoolExecutor for service requests on the TxInjector side.',
-             number_validator,
-             lambda x: int(x) >= 64, help_text="Value must be greater than or equal to 64"),
+    propitem(
+        'specjbb.customerDriver.threads.saturate',
+        64,
+        'Maximum number of threads in ThreadPoolExecutor for saturate requests on the TxInjector side.',
+        number_validator,
+        lambda x: int(x) >= 64,
+        help_text="Value must be greater than or equal to 64"),
+    propitem(
+        'specjbb.customerDriver.threads.probe',
+        64,
+        'Maximum number of threads in ThreadPoolExecutor for probe requests on the TxInjector side.',
+        number_validator,
+        lambda x: int(x) >= 64,
+        help_text="Value must be greater than or equal to 64"),
+    propitem(
+        'specjbb.customerDriver.threads.service',
+        64,
+        'Maximum number of threads in ThreadPoolExecutor for service requests on the TxInjector side.',
+        number_validator,
+        lambda x: int(x) >= 64,
+        help_text="Value must be greater than or equal to 64"),
     # propitem('specjbb.forkjoin.workers', multiprocessing.cpu_count() * 2, 'Maximum number of worker threads in ForkJoinPool in each tier on the Backend side.', lambda x:isinstance(x, int),help_text=must_be_positive)
-    propitem('specjbb.forkjoin.workers.Tier1', multiprocessing.cpu_count() * 2,
-             'Maximum number of worker threads in ForkJoinPool in tier 1 on the Backend side.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.forkjoin.workers.Tier2', multiprocessing.cpu_count() * 2,
-             'Maximum number of worker threads in ForkJoinPool in tier 2 on the Backend side.', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.forkjoin.workers.Tier3', multiprocessing.cpu_count() * 2,
-             'Maximum number of worker threads in ForkJoinPool in tier 3 on the Backend side.', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.group.count', 1, 'Number of Groups for the run, where Group is TxInjector(s) mapped to Backend.',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.heartbeat.period', 10000,
-             'How often (in milliseconds) Controller sends heartbeat message to an Agent checking it is alive',
-             number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.heartbeat.threshold', 100000,
-             'How much time (in milliseconds) await for heartbeat response from an Agent.', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.time.server', False, 'Enables Controller communication with Time Server.', default_validator,
-             lambda x: x is bool, [False, True]),
-    propitem('specjbb.txi.pergroup.count', 1, 'Number of TxInjectors per Backend in one Group.', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.run.datafile.dir', '.', 'Directory for storing binary log file of the run.', default_validator,
-             default_validator, help_text="Enter a directory"),
-    propitem('specjbb.mapreducer.pool.size', 2,
-             'Controller ForkJoinPool size supporting parallel work of TxInjector/Backend agents.', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.input.number_customers', 100000, 'Total number of customers', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.input.number_products', 100000, ' Number of products in each Supermarket', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-
-    propitem('specjbb.logLevel', 'INFO', 'Log level output',
-             default_validator, lambda x: x in loglevels, loglevels),
-
-    propitem('specjbb.time.check.interval', 10000,
-             'Time interval (in milliseconds) for periodic time check from Time Server', number_validator,
-             lambda x: int(x) > 0, help_text=must_be_positive),
-    propitem('specjbb.time.offset.max', 600000,
-             'Maximum time offset (in milliseconds) between Controller and Time Server on the benchmark start',
-             number_validator, lambda x: int(x) > 0, help_text=must_be_positive)
+    propitem(
+        'specjbb.forkjoin.workers.Tier1',
+        multiprocessing.cpu_count() * 2,
+        'Maximum number of worker threads in ForkJoinPool in tier 1 on the Backend side.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.forkjoin.workers.Tier2',
+        multiprocessing.cpu_count() * 2,
+        'Maximum number of worker threads in ForkJoinPool in tier 2 on the Backend side.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.forkjoin.workers.Tier3',
+        multiprocessing.cpu_count() * 2,
+        'Maximum number of worker threads in ForkJoinPool in tier 3 on the Backend side.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.group.count',
+        1,
+        'Number of Groups for the run, where Group is TxInjector(s) mapped to Backend.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.heartbeat.period',
+        10000,
+        'How often (in milliseconds) Controller sends heartbeat message to an Agent checking it is alive',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.heartbeat.threshold',
+        100000,
+        'How much time (in milliseconds) await for heartbeat response from an Agent.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem('specjbb.time.server', False,
+             'Enables Controller communication with Time Server.',
+             default_validator, lambda x: x is bool, [False, True]),
+    propitem(
+        'specjbb.txi.pergroup.count',
+        1,
+        'Number of TxInjectors per Backend in one Group.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.run.datafile.dir',
+        '.',
+        'Directory for storing binary log file of the run.',
+        default_validator,
+        default_validator,
+        help_text="Enter a directory"),
+    propitem(
+        'specjbb.mapreducer.pool.size',
+        2,
+        'Controller ForkJoinPool size supporting parallel work of TxInjector/Backend agents.',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.input.number_customers',
+        100000,
+        'Total number of customers',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.input.number_products',
+        100000,
+        ' Number of products in each Supermarket',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem('specjbb.logLevel', 'INFO', 'Log level output', default_validator,
+             lambda x: x in loglevels, loglevels),
+    propitem(
+        'specjbb.time.check.interval',
+        10000,
+        'Time interval (in milliseconds) for periodic time check from Time Server',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive),
+    propitem(
+        'specjbb.time.offset.max',
+        600000,
+        'Maximum time offset (in milliseconds) between Controller and Time Server on the benchmark start',
+        number_validator,
+        lambda x: int(x) > 0,
+        help_text=must_be_positive)
 ]
 
+
 def type_convert(obj):
     if obj == 'True' or obj == 'true' or obj == 'T' or obj == 't': return True
-    if obj == 'False' or obj == 'false' or obj == 'F' or obj == 'f':return False
+    if obj == 'False' or obj == 'false' or obj == 'F' or obj == 'f':
+        return False
     try:
 
         return int(obj)
@@ -986,6 +1224,7 @@ def type_convert(obj):
 
 
 class props:
+
     def __init__(self, fromjson=None):
         self.root = {a.prop: copy.deepcopy(a) for a in defaults}
         if not fromjson is None:
@@ -1011,7 +1250,10 @@ def get_all(self):
 
     def get_modified(self):
         """Returns a list of modified 'propitem's"""
-        return [x for x in list(self.root.values()) if isinstance(x, propitem) and x.value != x.def_value]
+        return [
+            x for x in list(self.root.values())
+            if isinstance(x, propitem) and x.value != x.def_value
+        ]
 
     def writeconfig(self, path: str):
         """Called internally only before running any 'spec_run'"""
diff --git a/speccurses.py b/speccurses.py
index 758a0d5..a6bd223 100644
--- a/speccurses.py
+++ b/speccurses.py
@@ -37,15 +37,17 @@ def display_run(stdscr, runinfo, y=STARTY + 2):
     :param y: The current y value
     :return: The new y value, as well as the max length of any property in the current run
     """
-    mem = [attr for attr in dir(runinfo) if not callable(getattr(runinfo, attr)) and not attr.startswith("_")]
+    mem = [
+        attr for attr in dir(runinfo)
+        if not callable(getattr(runinfo, attr)) and not attr.startswith("_")
+    ]
     valueoffset = len(max(mem, key=len)) + 2
     for name in mem:
         if name == 'properties':
             stdscr.addstr(y, xoffset, name)
         else:
             stdscr.addstr(y, xoffset, "{}:".format(name))
-            stdscr.addstr(y, xoffset + valueoffset,
-                          str(getattr(runinfo, name)))
+            stdscr.addstr(y, xoffset + valueoffset, str(getattr(runinfo, name)))
         y += 1
     return y, valueoffset
 
@@ -72,12 +74,14 @@ def select_from(stdscr, x, y, value, slist, redraw):
         curses_safe_addstr(stdscr, 0, 0, str(value))
         curses_safe_addstr(stdscr, 1, 0, str(type(value)))
         curses_safe_addstr(stdscr, 2, 0, ','.join(map(str, slist)))
-        curses_safe_addstr(stdscr, 3, 0, ','.join(list(map(str, map(type, slist)))))
+        curses_safe_addstr(stdscr, 3, 0, ','.join(
+            list(map(str, map(type, slist)))))
         stdscr.getch()
         stdscr.clear()
         stdscr.refresh()
 
-    draw_status_bar(stdscr, "Press 'q' to exit and 'UP' or 'DOWN' to select a value")
+    draw_status_bar(stdscr,
+                    "Press 'q' to exit and 'UP' or 'DOWN' to select a value")
     while k != KEY_ENTER and k != ord('q'):
         pad.clear()
         value = str(slist[idx])
@@ -99,7 +103,9 @@ def select_from(stdscr, x, y, value, slist, redraw):
             stdscr.erase()
             height, width = stdscr.getmaxyx()
             redraw(stdscr)
-            draw_status_bar(stdscr, "Press 'q' to exit and 'UP' or 'DOWN' to select a value")
+            draw_status_bar(
+                stdscr,
+                "Press 'q' to exit and 'UP' or 'DOWN' to select a value")
     return slist[idx]
 
 
@@ -114,6 +120,7 @@ def input_text(stdscr, x, y, value, validator, redraw):
     :param validator: A validator to ensure only proper keys are entered.
     :return: A validated value
     """
+
     def _resize(screen):
         screen.erase()
         stdscr.refresh()
@@ -123,6 +130,7 @@ def _resize(screen):
         p = curses.newpad(1, x)
         stdscr.refresh()
         return w, x, p
+
     k = 0
     value = list(str(value))
     idx = len(value)
@@ -181,8 +189,8 @@ def _resize(screen):
             #   o X
             #               I
             # I - ((W - o) - (W - X))
-            pad.refresh(0, idx - ((width - 1 - x) -
-                                  (width - 1 - cursorx)), y, x, y, width - 1)
+            pad.refresh(0, idx - ((width - 1 - x) - (width - 1 - cursorx)), y,
+                        x, y, width - 1)
         else:
             pad.refresh(0, 0, y, x, y, width - 1)
         k = stdscr.getch()
@@ -211,6 +219,7 @@ def draw_save_config(stdscr):
 
 
 def draw_edit_props(stdscr, p):
+
     def _resize(std):
         h, w = stdscr.getmaxyx()
         sy = draw_title(std)
@@ -233,21 +242,25 @@ def _resize(std):
             if cury < height - 5:
                 cury += 1
             else:
-                pad.refresh(index - (cury - starty), 0, starty,
-                            xoffset, height - 5, width - xoffset - 1)
+                pad.refresh(index - (cury - starty), 0, starty, xoffset,
+                            height - 5, width - xoffset - 1)
         elif k == curses.KEY_UP and index > 0:
             index -= 1
             if cury > starty:
                 cury -= 1
             else:
-                pad.refresh(index - (cury - starty), 0, starty,
-                            xoffset, height - 5, width - xoffset - 1)
+                pad.refresh(index - (cury - starty), 0, starty, xoffset,
+                            height - 5, width - xoffset - 1)
         elif k == KEY_ENTER:
             if p[index].valid_opts:
-                value = select_from(stdscr, xoffset + startx, cury, p[index].value, p[index].valid_opts, _resize)
+                value = select_from(stdscr, xoffset + startx, cury,
+                                    p[index].value, p[index].valid_opts,
+                                    _resize)
                 p[index].value = value
             else:
-                value = input_text(stdscr, xoffset + startx, cury, p[index].value, p[index].input_validator, _resize)
+                value = input_text(stdscr, xoffset + startx, cury,
+                                   p[index].value, p[index].input_validator,
+                                   _resize)
                 if not p[index].value_validator(value):
                     draw_show_message(stdscr, p[index].help_text)
                 else:
@@ -264,6 +277,7 @@ def _resize(std):
 
 # Calls display_run, and allows user to select and edit any of the run options
 def draw_edit_run(stdscr, runinfo):
+
     def _resize(std):
         ey, ex = display_run(std, runinfo, draw_title(std))
         draw_status_bar(std, "Press 'q' to exit or 'ENTER' to edit a value")
@@ -272,7 +286,10 @@ def _resize(std):
     k = 0
     y = STARTY + 2
     cury = y
-    array = [attr for attr in dir(runinfo) if not callable(getattr(runinfo, attr)) and not attr.startswith("_")]
+    array = [
+        attr for attr in dir(runinfo)
+        if not callable(getattr(runinfo, attr)) and not attr.startswith("_")
+    ]
     endy, startx = _resize(stdscr)
 
     while k != ord('q'):  # 27 == 'ESC'
@@ -283,37 +300,44 @@ def _resize(std):
         elif k == KEY_ENTER:
             name = array[cury - y]
             if name == 'verbose' or name == 'skip_report' or name == 'ignore_kit_validation':
-                value = select_from(stdscr, xoffset + startx, cury, getattr(runinfo, name), [True, False], _resize)
+                value = select_from(stdscr, xoffset + startx, cury,
+                                    getattr(runinfo, name), [True, False],
+                                    _resize)
                 setattr(runinfo, name, value)
             elif name == 'report_level':
-                value = select_from(stdscr, xoffset + startx, cury, getattr(runinfo, name), [0, 1, 2], _resize)
+                value = select_from(stdscr, xoffset + startx, cury,
+                                    getattr(runinfo, name), [0, 1, 2], _resize)
                 setattr(runinfo, name, value)
             elif name == 'run_type':
-                value = select_from(stdscr, xoffset + startx, cury, getattr(runinfo, name), run_types, _resize)
+                value = select_from(stdscr, xoffset + startx, cury,
+                                    getattr(runinfo, name), run_types, _resize)
                 setattr(runinfo, name, value)
             elif name == 'properties':
                 draw_edit_props(stdscr, runinfo.properties.get_all())
             elif name == 'jdk':
-                value = input_text(stdscr, xoffset + startx, cury, getattr(runinfo, name),
-                                   lambda x: True,_resize)  # start editing at end of value
+                value = input_text(stdscr, xoffset + startx, cury,
+                                   getattr(runinfo, name), lambda x: True,
+                                   _resize)  # start editing at end of value
                 if not os.path.exists(value):
                     draw_show_message(stdscr, "Warning: jdk path not found")
                 setattr(runinfo, name, value)
             elif name == 'num_runs' or name == 'numa_nodes':
-                value = input_text(stdscr, xoffset + startx, cury, getattr(runinfo, name),
-                                   objects.number_validator,_resize)  # start editing at end of value
+                value = input_text(stdscr, xoffset + startx, cury,
+                                   getattr(runinfo,
+                                           name), objects.number_validator,
+                                   _resize)  # start editing at end of value
                 setattr(runinfo, name, value)
             else:
-                value = input_text(stdscr, xoffset + startx, cury, getattr(runinfo, name),
-                                   lambda x: True,_resize)  # start editing at end of value
-                if(name == 'spec_dir'):
+                value = input_text(stdscr, xoffset + startx, cury,
+                                   getattr(runinfo, name), lambda x: True,
+                                   _resize)  # start editing at end of value
+                if (name == 'spec_dir'):
                     cur_config.set_spec_dir(value)
                 else:
                     setattr(runinfo, name, value)
         elif k == curses.KEY_RESIZE:
             stdscr.erase()
 
-
         stdscr.clear()
         stdscr.refresh()
         endy, startx = _resize(stdscr)
@@ -322,7 +346,9 @@ def _resize(std):
         k = stdscr.getch()
     return runinfo
 
-def draw_generic_get_input(stdscr, message, validator = lambda x:True):
+
+def draw_generic_get_input(stdscr, message, validator=lambda x: True):
+
     def _resize(std):
         y = draw_title(std)
         s = curses_safe_addstr(std, y, xoffset, message)
@@ -335,9 +361,6 @@ def _resize(std):
     return input_text(stdscr, sy, x, "", validator, _resize)
 
 
-
-
-
 def edit_config(stdscr):
     if cur_config is None:
         draw_get_config_path(stdscr)
@@ -350,9 +373,15 @@ def _draw():
         stdscr.clear()
         stdscr.refresh()
         sy = draw_title(stdscr)
-        curses_safe_addstr(stdscr, sy + len(cur_config.runs), xoffset, "{}. Add new run:".format(len(cur_config.runs) + 1))
-        draw_status_bar(stdscr, "Press 'ENTER' to edit a run | Press 'RIGHT' to adjust run position | Press q to quit")
-        draw_notice_bar(stdscr, "Press 'C' to change config type: {}".format(cur_config.type))
+        curses_safe_addstr(stdscr, sy + len(cur_config.runs), xoffset,
+                           "{}. Add new run:".format(len(cur_config.runs) + 1))
+        draw_status_bar(
+            stdscr,
+            "Press 'ENTER' to edit a run | Press 'RIGHT' to adjust run position | Press q to quit"
+        )
+        draw_notice_bar(
+            stdscr,
+            "Press 'C' to change config type: {}".format(cur_config.type))
         if position:
             stdscr.move(cury, xoffset + 2)
         else:
@@ -373,22 +402,31 @@ def _draw():
         if k == curses.KEY_DOWN:
             if (not position and cury < endy) or (position and cury < endy - 1):
                 if position:
-                    cur_config.runs[index + 1], cur_config.runs[index] = cur_config.runs[index], cur_config.runs[index + 1]
+                    cur_config.runs[index + 1], cur_config.runs[
+                        index] = cur_config.runs[index], cur_config.runs[index +
+                                                                         1]
                 cury += 1
                 index += 1
-            elif (not position and index < len(cur_config.runs) - 1) or (position and index < len(cur_config.runs) - 1):
+            elif (not position and index < len(cur_config.runs) - 1) or (
+                    position and index < len(cur_config.runs) - 1):
                 if position:
-                    cur_config.runs[index + 1], cur_config.runs[index] = cur_config.runs[index], cur_config.runs[index + 1]
+                    cur_config.runs[index + 1], cur_config.runs[
+                        index] = cur_config.runs[index], cur_config.runs[index +
+                                                                         1]
                 index += 1
         elif k == curses.KEY_UP:
             if cury > starty:
                 if position:
-                    cur_config.runs[index - 1], cur_config.runs[index] = cur_config.runs[index], cur_config.runs[index - 1]
+                    cur_config.runs[index - 1], cur_config.runs[
+                        index] = cur_config.runs[index], cur_config.runs[index -
+                                                                         1]
                 cury -= 1
                 index -= 1
             elif index > 0:
                 if position:
-                    cur_config.runs[index - 1], cur_config.runs[index] = cur_config.runs[index], cur_config.runs[index - 1]
+                    cur_config.runs[index - 1], cur_config.runs[
+                        index] = cur_config.runs[index], cur_config.runs[index -
+                                                                         1]
                 index -= 1
         elif k == curses.KEY_LEFT:
             position = False
@@ -396,7 +434,9 @@ def _draw():
             position = True
         elif k == curses.KEY_DC and index < len(cur_config.runs):
             position = False
-            draw_status_bar(stdscr, "Remove run {} from this config? (y/N)".format(cur_config.runs[index].tag))
+            draw_status_bar(
+                stdscr, "Remove run {} from this config? (y/N)".format(
+                    cur_config.runs[index].tag))
             resp = stdscr.getch()
             if resp == ord('y') or resp == ord('Y'):
                 del cur_config.runs[index]
@@ -414,7 +454,8 @@ def _draw():
                         newrun.spec_dir = r.spec_dir
                         break
                 cur_config.runs.append(newrun)
-            cur_config.runs[index] = draw_edit_run(stdscr, cur_config.runs[index])
+            cur_config.runs[index] = draw_edit_run(stdscr,
+                                                   cur_config.runs[index])
         elif k == ord('c') or k == ord('C'):
             cur_config.switch_type()
         elif k == curses.KEY_RESIZE:
@@ -429,7 +470,7 @@ def _draw():
 
 def draw_title(stdscr):
     height, width = stdscr.getmaxyx()
-    title = "SPECtate - curses"[:width - 1]
+    title = "SPECtate - curses" [:width - 1]
     start_x_title = int((width // 2) - (len(title) // 2) - len(title) % 2)
 
     # Turning on attributes for title
@@ -437,7 +478,7 @@ def draw_title(stdscr):
     stdscr.attron(curses.A_BOLD)
 
     stdscr.attron(curses.color_pair(1))
-    curses_safe_addstr(stdscr,STARTY, start_x_title, "SPECtate - curses")
+    curses_safe_addstr(stdscr, STARTY, start_x_title, "SPECtate - curses")
     stdscr.attroff(curses.color_pair(1))
     # Turning off attributes for title
     stdscr.attroff(curses.color_pair(2))
@@ -450,8 +491,9 @@ def draw_notice_bar(stdscr, noticebarstr):
     stdscr.attron(curses.color_pair(3))
     if len(noticebarstr) > width:
         noticebarstr = noticebarstr[:width - 1]
-    start_x = int((width // 2) - (len(noticebarstr) // 2) - len(noticebarstr) % 2)
-    curses_safe_addstr(stdscr,height - 3, start_x, noticebarstr)
+    start_x = int((width // 2) - (len(noticebarstr) // 2) -
+                  len(noticebarstr) % 2)
+    curses_safe_addstr(stdscr, height - 3, start_x, noticebarstr)
     stdscr.attroff(curses.color_pair(3))
 
 
@@ -460,8 +502,9 @@ def draw_status_bar(stdscr, statusbarstr):
     stdscr.attron(curses.color_pair(3))
     if len(statusbarstr) > width:
         statusbarstr = statusbarstr[:width - 1]
-    curses_safe_addstr(stdscr,height - 1, 0, statusbarstr)
-    curses_safe_addstr(stdscr,height - 1, len(statusbarstr), " " * (width - len(statusbarstr) - 1))
+    curses_safe_addstr(stdscr, height - 1, 0, statusbarstr)
+    curses_safe_addstr(stdscr, height - 1, len(statusbarstr),
+                       " " * (width - len(statusbarstr) - 1))
     stdscr.attroff(curses.color_pair(3))
 
 
@@ -490,15 +533,17 @@ def draw_get_config_path(stdscr):
     cur_path = ""
     stdscr.clear()
     stdscr.refresh()
+
     def _resize(std):
         sy = draw_title(std)
         draw_status_bar(std, "Please enter the path of a config")
 
-        curses_safe_addstr(std,sy, xoffset, "Config file path:")
+        curses_safe_addstr(std, sy, xoffset, "Config file path:")
         return sy
 
     y = _resize(stdscr)
-    path = input_text(stdscr, xoffset + len("Config file path:") + 1, y, "", lambda x: True, _resize)
+    path = input_text(stdscr, xoffset + len("Config file path:") + 1, y, "",
+                      lambda x: True, _resize)
     if not os.path.exists(path) and not path.endswith('.json'):
         path += '.json'
     if os.path.isfile(path):
@@ -514,6 +559,7 @@ def draw_get_path(stdscr):
     :param stdscr:
     :return: A string path
     """
+
     def _resize(std):
         sy = draw_title(std)
         draw_status_bar(stdscr, "Please enter the path of SPECjbb")
@@ -524,7 +570,8 @@ def _resize(std):
     stdscr.clear()
     stdscr.refresh()
     y = _resize(stdscr)
-    return input_text(stdscr, xoffset + len("Config file path:") + 1, y, "", lambda x: True, _resize)
+    return input_text(stdscr, xoffset + len("Config file path:") + 1, y, "",
+                      lambda x: True, _resize)
 
 
 def run_config(stdscr):
@@ -538,6 +585,7 @@ def run_config(stdscr):
         return True
     index = 0
     context = runcontext(stdscr, xoffset, draw_title)
+
     def _handle(msg):
         msg = _remove_control_chars(msg)
         if msg.isspace():
@@ -550,7 +598,8 @@ def _handle(msg):
         pad.addstr(c, 0, msg)  # c == new bottom
         pad.refresh(0, 0, maxy - c, xoffset, maxy, width - xoffset - 1)
         if c < logmax - 1:
-            pad.refresh(c + 1, 0, cury, xoffset, (maxy - c), width - xoffset - 1)
+            pad.refresh(c + 1, 0, cury, xoffset, (maxy - c),
+                        width - xoffset - 1)
         # if(index < maxy - cury):
         #   pad.refresh(0, 0, cury, xoffset, cury + c, width - xoffset - 1)
         #  if(c < logmax - 1):
@@ -594,13 +643,17 @@ def _handle(msg):
         cur_config.set_spec_dir(draw_get_path(stdscr))
         result = cur_config.run(_handle, lambda x: x)
         if result == 2:
-            draw_status_bar(stdscr, "Invalid SPECjbb path. Press any key to continue")
+            draw_status_bar(stdscr,
+                            "Invalid SPECjbb path. Press any key to continue")
             return stdscr.getch()
 
     if result == -1:
-        draw_status_bar(stdscr, "An error occured running the benchmark. Press any key to continue")
+        draw_status_bar(
+            stdscr,
+            "An error occured running the benchmark. Press any key to continue")
         return stdscr.getch()
-    draw_status_bar(stdscr, "All runs have been completed - Press any key to continue")
+    draw_status_bar(stdscr,
+                    "All runs have been completed - Press any key to continue")
     return stdscr.getch()
 
 
@@ -612,14 +665,17 @@ def create_config(stdscr):
     """
     global cur_path
     global cur_config
+
     def _resize(std):
         sy = draw_title(std)
         curses_safe_addstr(std, sy, xoffset, "Enter config name:")
         return sy
+
     stdscr.clear()
     stdscr.refresh()
     y = _resize(stdscr)
-    path = input_text(stdscr, xoffset + len("Enter config name:") + 1, y, "", lambda x: True, _resize).strip()
+    path = input_text(stdscr, xoffset + len("Enter config name:") + 1, y, "",
+                      lambda x: True, _resize).strip()
     if path.isspace() or path == "":
 
         draw_show_message(stdscr, "Config name cannot be blank")
@@ -628,13 +684,18 @@ def _resize(std):
         stdscr.clear()
         stdscr.refresh()
         y = draw_title(stdscr)
-        curses_safe_addstr(stdscr, y, xoffset, "Warning: file {} already exists, overwrite? (y/N)".format(path))
+        curses_safe_addstr(
+            stdscr, y, xoffset,
+            "Warning: file {} already exists, overwrite? (y/N)".format(path))
 
         k = stdscr.getch()
         while k == curses.KEY_RESIZE:
             stdscr.erase()
             y = draw_title(stdscr)
-            curses_safe_addstr(stdscr, y, xoffset, "Warning: file {} already exists, overwrite? (y/N)".format(path))
+            curses_safe_addstr(
+                stdscr, y, xoffset,
+                "Warning: file {} already exists, overwrite? (y/N)".format(
+                    path))
             k = stdscr.getch()
         if k != ord('Y') and k != ord('y'):
             return True
@@ -685,17 +746,20 @@ def pad_runs(stdscr, runlist):
 
 
 def draw_view_props(stdscr, p):
+
     def _draw():
         h, w = stdscr.getmaxyx()
         stdscr.clear()
         stdscr.refresh()
         sy = draw_title(stdscr)
         if show_all:
-            draw_status_bar(stdscr, "Press 'q' to exit | Press 'a' to hide defaults")
+            draw_status_bar(stdscr,
+                            "Press 'q' to exit | Press 'a' to hide defaults")
         else:
-            draw_status_bar(stdscr, "Press 'q' to exit | Press 'a' to show all properties")
+            draw_status_bar(
+                stdscr, "Press 'q' to exit | Press 'a' to show all properties")
         if len(visprops) > 0:
-            curses_safe_addstr(stdscr,h - 3, 0, visprops[index].desc)
+            curses_safe_addstr(stdscr, h - 3, 0, visprops[index].desc)
         pad.refresh(index - (cury - sy), 0, sy, xoffset, h - 5, w - xoffset - 1)
         stdscr.move(cury, xoffset)
         stdscr.refresh()
@@ -707,8 +771,7 @@ def _draw():
     k = 0
     visprops = p.get_modified()
     pad, startx = pad_props(stdscr, visprops)
-    height, width, starty =_draw()
-
+    height, width, starty = _draw()
 
     if len(visprops) == 0:
         pad.addstr(0, 0, "No properties to display")
@@ -720,14 +783,15 @@ def _draw():
             if cury < height - 5:
                 cury += 1
             else:
-                pad.refresh(index - (cury - starty), 0, starty,
-                            xoffset, height - 5, width - xoffset - 1)
+                pad.refresh(index - (cury - starty), 0, starty, xoffset,
+                            height - 5, width - xoffset - 1)
         elif k == curses.KEY_UP and index > 0:
             index -= 1
             if cury > starty:
                 cury -= 1
             else:
-                pad.refresh(index - (cury - starty), 0, starty, xoffset, height - 5, width - xoffset - 1)
+                pad.refresh(index - (cury - starty), 0, starty, xoffset,
+                            height - 5, width - xoffset - 1)
         elif k == ord('a') or k == ord('A'):
             show_all = not show_all
             if show_all:
@@ -753,12 +817,13 @@ def _draw():
 
 
 def draw_view_run(stdscr, runinfo):
+
     def _draw():
         stdscr.clear()
         stdscr.refresh()
         ey, ex = display_run(stdscr, runinfo, draw_title(stdscr))
-        draw_status_bar(
-            stdscr, "Press 'q' to exit or 'ENTER' to view run properties")
+        draw_status_bar(stdscr,
+                        "Press 'q' to exit or 'ENTER' to view run properties")
 
         return ey, ex
 
@@ -817,6 +882,7 @@ def _draw(stdr, py, pd, idx):
         k = stdscr.getch()
     return True
 
+
 def draw_load_config(stdscr):
     global cur_config
     if os.path.exists(cur_path):
@@ -827,6 +893,7 @@ def draw_load_config(stdscr):
             draw_show_message(stdscr, "Invalid config file format")
     return True
 
+
 def load_config(path: str):
     """
     Loads a config file as a spec_config object
@@ -839,18 +906,14 @@ def load_config(path: str):
     except:
         return None
 
-opts = [
-        run_config,
-        create_config,
-        edit_config,
-        view_runs
-    ]
+
+opts = [run_config, create_config, edit_config, view_runs]
 menunames = [
-"1. Run a config",
-    "2. Create a config",
-"3. Edit a config",
-"4. View a config"
+    "1. Run a config", "2. Create a config", "3. Edit a config",
+    "4. View a config"
 ]
+
+
 def draw_menu(stdscr):
     global cur_config
     k = 0
@@ -862,14 +925,13 @@ def _resize(std):
         # Declaration of strings
 
         for s in menunames:
-            if(len(s) + xoffset >= width):
+            if (len(s) + xoffset >= width):
                 s = s[:width - xoffset - 1]
             std.addstr(dy, xoffset, s)
             dy += 1
 
         return sy, dy - 1
 
-
     while k != ord('q'):
         cur_config = None
         # Initialization
@@ -880,13 +942,11 @@ def _resize(std):
         elif k == curses.KEY_RESIZE:
             stdscr.erase()
 
-
         stdscr.clear()
         stdscr.refresh()
 
         starty, y = _resize(stdscr)
 
-
         if k == curses.KEY_DOWN and cursor_y < y:
             cursor_y += 1
         elif k == curses.KEY_UP and cursor_y > starty:
@@ -904,7 +964,8 @@ def _resize(std):
         k = stdscr.getch()
     return True
 
-def resize_wrapper(stdscr, child = None, redraw = None):
+
+def resize_wrapper(stdscr, child=None, redraw=None):
     if child is None:
         child = draw_menu
     noerror = None
@@ -921,7 +982,8 @@ def resize_wrapper(stdscr, child = None, redraw = None):
             traceback.format_exc()
             i = 0
             for line in TracebackException(
-                    type(exc_type), exc_obj, exc_tb, limit=None).format(chain=True):
+                    type(exc_type), exc_obj, exc_tb,
+                    limit=None).format(chain=True):
                 curses_safe_addstr(stdscr, i, 0, str(line))
                 i += 1
             curses_safe_addstr(stdscr, 2, 0, str(e))
@@ -935,6 +997,7 @@ def resize_wrapper(stdscr, child = None, redraw = None):
         if not redraw is None:
             redraw(stdscr)
 
+
 def curses_init(stdscr):
     # Start colors in curses
     curses.start_color()
@@ -943,6 +1006,7 @@ def curses_init(stdscr):
     curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_WHITE)
     resize_wrapper(stdscr, draw_menu)
 
+
 def curses_safe_addstr(stdscr, y, x, str):
     height, width = stdscr.getmaxyx()
     if width < x or height < y:
@@ -952,9 +1016,9 @@ def curses_safe_addstr(stdscr, y, x, str):
     stdscr.addstr(y, x, str)
     return str
 
-def main():
-        curses.wrapper(curses_init)
 
+def main():
+    curses.wrapper(curses_init)
 
 
 if __name__ == "__main__":
diff --git a/src/__init__.py b/src/__init__.py
index 87107b2..c6a4deb 100644
--- a/src/__init__.py
+++ b/src/__init__.py
@@ -1,5 +1,8 @@
 from os.path import dirname, basename, isfile
 import glob
-modules = glob.glob(dirname(__file__)+"/*.py")
-__all__ = [basename(f)[:-3] for f in modules if isfile(f)
-           and not f.endswith('__init__.py')]
+modules = glob.glob(dirname(__file__) + "/*.py")
+__all__ = [
+    basename(f)[:-3]
+    for f in modules
+    if isfile(f) and not f.endswith('__init__.py')
+]
diff --git a/src/benchmark_run.py b/src/benchmark_run.py
index 8eccfe1..870e720 100644
--- a/src/benchmark_run.py
+++ b/src/benchmark_run.py
@@ -41,6 +41,7 @@ def do(task):
     task.run()
     log.debug("finished task {}".format(task))
 
+
 def do_dry(task):
     """
     Prints some additional logging information without
@@ -48,6 +49,7 @@ def do_dry(task):
     """
     log.info("DRY: {}".format(task))
 
+
 class JvmRunOptions(dict):
     """
     A helper class for SpecJBBRun, to provide defaults and a way
@@ -83,13 +85,11 @@ def __init__(self, val=None):
 
             self.update(val)
         elif val is None:
-            self.update({
-                "path": "java",
-                "options": []
-            })
+            self.update({"path": "java", "options": []})
         else:
             raise Exception(
-                "unrecognized type given to JvmRunOptions: {}".format(type(val)))
+                "unrecognized type given to JvmRunOptions: {}".format(
+                    type(val)))
 
 
 """
@@ -119,10 +119,12 @@ def __init__(self, component_type, rest=None):
             component_type = component_type.lower()
             if component_type not in SpecJBBComponentTypes:
                 raise Exception(
-                    "invalid component type '{}' given to SpecJBBComponentOptions".format(component_type))
+                    "invalid component type '{}' given to SpecJBBComponentOptions".
+                    format(component_type))
         else:
             raise Exception(
-                "Unrecognized type given to SpecJBBComponentOptions: {}".format(type(component_type)))
+                "Unrecognized type given to SpecJBBComponentOptions: {}".format(
+                    type(component_type)))
 
         if isinstance(rest, dict):
             if "count" not in rest:
@@ -151,7 +153,8 @@ def __init__(self, component_type, rest=None):
             })
         else:
             raise Exception(
-                "Unrecognized 'rest' given to SpecJBBComponentOptions: {}".format(rest))
+                "Unrecognized 'rest' given to SpecJBBComponentOptions: {}".
+                format(rest))
         if "-p" in self["options"]:
             raise Exception("SpecJBBComponentOptions recieved external props file")
         if "-m" in self["options"]:
@@ -235,16 +238,14 @@ def _generate_tasks(self):
         if self.controller["type"] == "composite":
             return
 
-        self.log.info(
-            "generating {} groups, each with {} transaction injectors"
-                .format(self.backends["count"], self.injectors["count"]))
+        self.log.info("generating {} groups, each with {} transaction injectors"
+                      .format(self.backends["count"], self.injectors["count"]))
 
         for _ in range(self.backends["count"]):
             group_id = uuid4().hex
             backend_jvm_id = uuid4().hex
             self.log.debug("constructing group {}".format(group_id))
-            yield TaskRunner(*self.backend_run_args(),
-                             '-G={}'.format(group_id),
+            yield TaskRunner(*self.backend_run_args(), '-G={}'.format(group_id),
                              '-J={}'.format(backend_jvm_id))
 
             self.log.debug(
@@ -253,7 +254,8 @@ def _generate_tasks(self):
             for _ in range(self.injectors["count"]):
                 ti_jvm_id = uuid4().hex
                 self.log.debug(
-                    "preparing injector in group {} with jvmid={}".format(group_id, ti_jvm_id))
+                    "preparing injector in group {} with jvmid={}".format(
+                        group_id, ti_jvm_id))
                 yield TaskRunner(*self.injector_run_args(),
                                  '-G={}'.format(group_id),
                                  '-J={}'.format(ti_jvm_id))
@@ -275,7 +277,8 @@ def run(self, dry_run=False):
         else:
             try:
                 self.log.debug(
-                    "attempting to create results directory {}".format(results_directory))
+                    "attempting to create results directory {}".format(
+                        results_directory))
                 os.mkdir(results_directory)
             except os.FileExistsError:
                 self.log.error(
@@ -285,8 +288,8 @@ def run(self, dry_run=False):
 
             try:
                 for number_of_times in range(self.times):
-                    self.log.debug(
-                            "beginning run {}/{}".format(number_of_times, self.times))
+                    self.log.debug("beginning run {}/{}".format(
+                        number_of_times, self.times))
                     self._run(dry_run)
             except Exception as e:
                 self.log.error(
@@ -311,7 +314,8 @@ def _run(self, dry_run=False):
             if not self.props:
                 self.log.info("DRY: (none provided)")
             for name, value in self.props.items():
-                self.log.info("DRY: name: {}, value({}): {}".format(name, type(value), value))
+                self.log.info("DRY: name: {}, value({}): {}".format(
+                    name, type(value), value))
         else:
             with open(self.props_file, 'w+') as props_file:
                 c = configparser.ConfigParser()
@@ -410,11 +414,11 @@ def contains_forbidden_flag(l):
             except Exception:
                 continue
 
-            specjbb_options = options[jar_index+2:-1]
+            specjbb_options = options[jar_index + 2:-1]
 
             if contains_forbidden_flag(specjbb_options):
-                self.log.error("component arguments would have been NON-COMPLIANT")
+                self.log.error(
+                    "component arguments would have been NON-COMPLIANT")
                 return False
 
         return True
-
diff --git a/src/compliant.py b/src/compliant.py
index c391a4c..ac5b927 100644
--- a/src/compliant.py
+++ b/src/compliant.py
@@ -5,6 +5,7 @@
 from schema import Schema, And, Or, Optional
 from src.validate import is_stringy
 
+
 def compliant(props=None):
     """
     Returns a boolean representing whether or not a run is compliant.
@@ -18,9 +19,14 @@ def compliant(props=None):
     except Exception:
         return False
 
+
 CompliantRunSchema = Schema({
-    Optional("specjbb.group.count"): And(int, lambda group_count: group_count >= 1),
-    Optional("specjbb.txi.pergroup.count"): And(int, lambda injector_count: injector_count >= 1),
-    Optional("specjbb.mapreducer.pool.size"): And(int, lambda pool_size: pool_size >= 2),
-    Optional(is_stringy): object,
-    })
+    Optional("specjbb.group.count"):
+    And(int, lambda group_count: group_count >= 1),
+    Optional("specjbb.txi.pergroup.count"):
+    And(int, lambda injector_count: injector_count >= 1),
+    Optional("specjbb.mapreducer.pool.size"):
+    And(int, lambda pool_size: pool_size >= 2),
+    Optional(is_stringy):
+    object,
+})
diff --git a/src/run_generator.py b/src/run_generator.py
index ff870b1..1ec80d2 100644
--- a/src/run_generator.py
+++ b/src/run_generator.py
@@ -44,8 +44,10 @@ def __init__(self, TemplateData=None, RunList=None):
             props = template.get("prop_options", dict()).copy()
             # populate arguments
             if "translations" in template:
-                props.update(
-                    {translation: run["args"][arg] for arg, translation in template["translations"].items()})
+                props.update({
+                    translation: run["args"][arg]
+                    for arg, translation in template["translations"].items()
+                })
             if "props_extra" in run:
                 props.update(run["props_extra"])
 
@@ -54,8 +56,8 @@ def __init__(self, TemplateData=None, RunList=None):
                 injectors = template["prop_options"].get(
                     "specjbb.txi.pergroups.count", 1)
                 # and let's peek for backend count (specjbb.group.count)
-                backends = template["prop_options"].get(
-                    "specjbb.group.count", 1)
+                backends = template["prop_options"].get("specjbb.group.count",
+                                                        1)
             else:
                 injectors = 1
                 backends = 1
@@ -64,13 +66,22 @@ def __init__(self, TemplateData=None, RunList=None):
                 'controller': {
                     "type": template["run_type"],
                 },
-                'backends': backends,
-                'injectors': injectors,
-                'cwd': template["cwd"] if "cwd" in template else os.getcwd(),
-                'java': template["java"],
-                'jar': template["jar"],
-                'tag': run["tag"] if "tag" in run else random_run_id(),
-                'times': run["times"],
-                'props': props,
-                'props_file': template.get("props_file", 'specjbb2015.props'),
+                'backends':
+                backends,
+                'injectors':
+                injectors,
+                'cwd':
+                template["cwd"] if "cwd" in template else os.getcwd(),
+                'java':
+                template["java"],
+                'jar':
+                template["jar"],
+                'tag':
+                run["tag"] if "tag" in run else random_run_id(),
+                'times':
+                run["times"],
+                'props':
+                props,
+                'props_file':
+                template.get("props_file", 'specjbb2015.props'),
             })
diff --git a/src/runcontext.py b/src/runcontext.py
index 297039a..3466550 100644
--- a/src/runcontext.py
+++ b/src/runcontext.py
@@ -2,6 +2,7 @@
 
 
 class runcontext:
+
     def __init__(self, stdscr, xoffset, draw):
         height, width = stdscr.getmaxyx()
         self.stdscr = stdscr
@@ -29,10 +30,11 @@ def _resize(self, stdscr):
             self._refresh(self.index % self.logmax)
 
     def _refresh(self, c):
-        self.pad.refresh(0, 0, self.maxy - c, self.xoffset, self.maxy, self.width - self.xoffset - 1)
+        self.pad.refresh(0, 0, self.maxy - c, self.xoffset, self.maxy,
+                         self.width - self.xoffset - 1)
         if c < self.logmax - 1:
-            self.pad.refresh(c + 1, 0, self.starty, self.xoffset, (self.maxy - c), self.width - self.xoffset - 1)
-
+            self.pad.refresh(c + 1, 0, self.starty, self.xoffset,
+                             (self.maxy - c), self.width - self.xoffset - 1)
 
     def handle_out(self, msg):
         while True:
@@ -51,9 +53,8 @@ def handle_out(self, msg):
             self.stdscr.erase()
             self._resize(self.stdscr)
 
-
     @staticmethod
     def _remove_control_chars(s):
         if isinstance(s, str):
             return ''.join([i if ord(i) < 128 else '' for i in s])
-        return runcontext._remove_control_chars(s.decode())
\ No newline at end of file
+        return runcontext._remove_control_chars(s.decode())
diff --git a/src/stream.py b/src/stream.py
index b86b918..cb5706f 100644
--- a/src/stream.py
+++ b/src/stream.py
@@ -3,6 +3,7 @@
 
 
 class stream:
+
     def __init__(self, s):
         """
         s: the stream to read from.
@@ -12,8 +13,8 @@ def __init__(self, s):
         self._queue = Queue()
         self._active = True
 
-
-        self._t = Thread(target = self._read, args = (self._stream, self, self._queue))
+        self._t = Thread(
+            target=self._read, args=(self._stream, self, self._queue))
         self._t.daemon = True
         self._t.start()
 
@@ -39,5 +40,5 @@ def readline(self):
         return ''
 
     def close(self):
-        if(self._active):
-            self._active = False
\ No newline at end of file
+        if (self._active):
+            self._active = False
diff --git a/src/task_runner.py b/src/task_runner.py
index 11633e3..e5ccc41 100644
--- a/src/task_runner.py
+++ b/src/task_runner.py
@@ -16,8 +16,8 @@ def __init__(self, path, *options, **popen_kw):
 
         for opt in options:
             if not isinstance(opt, str):
-                raise Exception(
-                    "Option key was '{}':{}, not str".format(opt, type(opt)))
+                raise Exception("Option key was '{}':{}, not str".format(
+                    opt, type(opt)))
 
         self.options = options
         self.kw = popen_kw
@@ -25,7 +25,8 @@ def __init__(self, path, *options, **popen_kw):
         self.proc = None
 
     def __str__(self):
-        return "TaskRunner(path={}, options={}, kw={})".format(self.path, self.options, self.kw)
+        return "TaskRunner(path={}, options={}, kw={})".format(
+            self.path, self.options, self.kw)
 
     def argument_list(self):
         return [self.path] + self.options
diff --git a/src/validate.py b/src/validate.py
index adc548a..69c248f 100644
--- a/src/validate.py
+++ b/src/validate.py
@@ -8,6 +8,7 @@
 def is_stringy(v):
     return type(v) is text_type
 
+
 def random_run_id():
     """
     Returns a value that will be a default, non-repeated
@@ -59,12 +60,17 @@ def validate(unvalidated):
     d = SpectateConfig.validate(unvalidated)
 
     # each run needs a unique run id
-    custom_run_ids = list(map(lambda run: run["tag"], 
-        filter(lambda run: "tag" in run, d["RunList"])))
+    custom_run_ids = list(
+        map(lambda run: run["tag"],
+            filter(lambda run: "tag" in run, d["RunList"])))
 
     if custom_run_ids and len(set(custom_run_ids)) != len(custom_run_ids):
-        duplicates = [_id for _id in custom_run_ids if custom_run_ids.count(_id) > 1 ]
-        raise Exception("Duplicate custom run IDs provided to different configured runs: {}".format(duplicates))
+        duplicates = [
+            _id for _id in custom_run_ids if custom_run_ids.count(_id) > 1
+        ]
+        raise Exception(
+            "Duplicate custom run IDs provided to different configured runs: {}".
+            format(duplicates))
 
     # generate IDs for each unspecified run
     for run in list(filter(lambda run: "tag" not in run, d["RunList"])):
@@ -78,13 +84,17 @@ def validate(unvalidated):
         # they need to appear in the template
         for arg in run["args"]:
             if arg not in t["args"]:
-                raise Exception("Argument '{}' was not in the template {}'s arguments: {}".format(arg, run["template_type"], t["args"]))
+                raise Exception(
+                    "Argument '{}' was not in the template {}'s arguments: {}".
+                    format(arg, run["template_type"], t["args"]))
 
         # and if the arg isn't in the run,
         # it needs to have a default
         for arg in t["args"]:
             if arg not in run["args"] and arg not in t["prop_options"]:
-                raise Exception("Argument '{}' did not have a default from template {}".format(arg, run["template_type"]))
+                raise Exception(
+                    "Argument '{}' did not have a default from template {}".
+                    format(arg, run["template_type"]))
 
     # for each template,
     for name, template in d["TemplateData"].items():
@@ -93,12 +103,16 @@ def validate(unvalidated):
         if "translations" in template:
             for translation in template["translations"]:
                 if translation not in template["args"]:
-                    raise Exception("Translation '{}' for template '{}' doesn't have an associated argument".format(translation, name))
+                    raise Exception(
+                        "Translation '{}' for template '{}' doesn't have an associated argument".
+                        format(translation, name))
         # all of the annotations need to refer to
         # arguments specified by the user
         if "annotations" in template:
             for annotation in template["annotations"]:
                 if annotation not in template["args"]:
-                    raise Exception("Annotation '{}' for template '{}' doesn't have an associated argument".format(annotation, name))
+                    raise Exception(
+                        "Annotation '{}' for template '{}' doesn't have an associated argument".
+                        format(annotation, name))
 
     return d
diff --git a/tests/fixtures/sample_config.json b/tests/fixtures/sample_config.json
index eb998d8..eb28d71 100644
--- a/tests/fixtures/sample_config.json
+++ b/tests/fixtures/sample_config.json
@@ -1,4 +1,4 @@
 {
-	"TemplateData": {},
-	"RunList": []
+  "TemplateData": {},
+  "RunList": []
 }
diff --git a/tests/fixtures/sample_config_invalid.json b/tests/fixtures/sample_config_invalid.json
index 0ca9848..eb3dd10 100644
--- a/tests/fixtures/sample_config_invalid.json
+++ b/tests/fixtures/sample_config_invalid.json
@@ -1,4 +1,6 @@
 {
-	"templates": [],
-	"runs": [{}]
+  "templates": [],
+  "runs": [
+    {}
+  ]
 }
diff --git a/tests/test_benchmark_run.py b/tests/test_benchmark_run.py
index 6c87656..a3a4b9b 100644
--- a/tests/test_benchmark_run.py
+++ b/tests/test_benchmark_run.py
@@ -9,6 +9,7 @@
 
 from src.benchmark_run import SpecJBBRun, InvalidRunConfigurationException, JvmRunOptions, SpecJBBComponentOptions, SpecJBBComponentTypes, do
 
+
 @contextmanager
 def temporary_directory():
     pwd = os.getcwd()
@@ -17,6 +18,7 @@ def temporary_directory():
         yield
         os.chdir(pwd)
 
+
 class TestBenchmarkRun(unittest.TestCase):
     valid_props = [
         {  # multijvm run with counts for each
@@ -39,7 +41,6 @@ class TestBenchmarkRun(unittest.TestCase):
         },
     ]
 
-
     invalid_props = [
         {
             "injectors": 4,
@@ -63,18 +64,21 @@ def test_invalid_props_dont_work(self):
                 SpecJBBRun(**invalid)
 
     def test_valid_give_run_options(self):
-        t = SpecJBBRun(**{
-            "backends": 2,
-            "injectors": 4,
-            "controller": {
-                "type": "multi",
-                "options": ["arg1", "arg2"],
-            },
-            "java": "java",
-            "jar": "env/Main.jar",
-        })
+        t = SpecJBBRun(
+            **{
+                "backends": 2,
+                "injectors": 4,
+                "controller": {
+                    "type": "multi",
+                    "options": ["arg1", "arg2"],
+                },
+                "java": "java",
+                "jar": "env/Main.jar",
+            })
 
-        for f in [t.controller_run_args, t.backend_run_args, t.injector_run_args]:
+        for f in [
+                t.controller_run_args, t.backend_run_args, t.injector_run_args
+        ]:
             self.assertTrue(any("env/Main.jar" in arg for arg in f()))
             self.assertTrue("java" in f())
             self.assertEqual("java", f()[0])
@@ -129,7 +133,6 @@ def test_run_with_custom_java(self):
             with testpath.assert_calls("echo"):
                 r.run()
 
-
     def test_run_multijvm(self):
         with temporary_directory():
             r = SpecJBBRun(**{  # multijvm run with arguments
@@ -144,11 +147,18 @@ def test_run_multijvm(self):
             with testpath.MockCommand("java") as mock_java:
                 r.run()
 
-                component_invocations = list(filter(lambda line: "-m" in line, mock_java.get_calls()))
+                component_invocations = list(
+                    filter(lambda line: "-m" in line, mock_java.get_calls()))
 
-                self.assertTrue(filter(lambda line: "CONTROLLER" in line, component_invocations))
-                self.assertTrue(filter(lambda line: "BACKEND" in line, component_invocations))
-                self.assertTrue(filter(lambda line: "TXINJECTOR" in line, component_invocations))
+                self.assertTrue(
+                    filter(lambda line: "CONTROLLER" in line,
+                           component_invocations))
+                self.assertTrue(
+                    filter(lambda line: "BACKEND" in line,
+                           component_invocations))
+                self.assertTrue(
+                    filter(lambda line: "TXINJECTOR" in line,
+                           component_invocations))
 
     def test_compliant_runs_need_kit_validation(self):
         ignore_kit_arguments = [{
@@ -192,7 +202,6 @@ def test_compliant_runs_need_kit_validation(self):
                 },
             ]
 
-
         for invalid_props in ignore_kit_arguments:
             r = SpecJBBRun(**invalid_props)
             self.assertFalse(r.compliant())
@@ -202,7 +211,9 @@ def test_valid_props_compliant(self):
             r = SpecJBBRun(**valid)
             self.assertTrue(r.compliant())
 
+
 class TestJvmRunOptions(unittest.TestCase):
+
     def test_given_none_will_fill_defaults(self):
         self.assertTrue(JvmRunOptions())
 
@@ -242,23 +253,19 @@ def test_with_dict_missing_options(self):
         self.assertEqual(j["options"], [])
 
     def test_validates_dictionaries(self):
-        invalid_missing_path = {
-            "options": []
-        }
+        invalid_missing_path = {"options": []}
 
         with self.assertRaises(Exception):
             j = JvmRunOptions(invalid_missing_path)
 
-        invalid_types = {
-            "path": 2,
-            "options": {}
-        }
+        invalid_types = {"path": 2, "options": {}}
 
         with self.assertRaises(Exception):
             j = JvmRunOptions(invalid_types)
 
 
 class TestSpecJBBComponentOptions(unittest.TestCase):
+
     def test_given_invalid_type(self):
         with self.assertRaises(Exception):
             SpecJBBComponentOptions("foo")
@@ -275,7 +282,8 @@ def test_given_none(self):
     def test_given_int(self):
         count = 5
         component_options = list(
-            map(lambda c: SpecJBBComponentOptions(c, count), SpecJBBComponentTypes))
+            map(lambda c: SpecJBBComponentOptions(c, count),
+                SpecJBBComponentTypes))
 
         for co in component_options:
             self.assertEqual(co["count"], count)
@@ -286,10 +294,11 @@ def test_given_dict(self):
         options = ["a", "b"]
         jvm_opts = ["c", "d"]
 
-        component_options = list(map(lambda c: SpecJBBComponentOptions(c, {
-            "options": options,
-            "jvm_opts": jvm_opts,
-        }), SpecJBBComponentTypes))
+        component_options = list(
+            map(
+                lambda c: SpecJBBComponentOptions(c, {
+                    "options": options,
+                    "jvm_opts": jvm_opts,}), SpecJBBComponentTypes))
 
         for co in component_options:
             self.assertEqual(co["count"], 1)
@@ -317,8 +326,11 @@ def construct_all_types(c):
 
 
 class TestDo(unittest.TestCase):
+
     def test_do_calls_run_method_on_objects(self):
+
         class example:
+
             def __init__(self):
                 self.called = False
 
diff --git a/tests/test_compliant.py b/tests/test_compliant.py
index bea8dc4..36eb842 100644
--- a/tests/test_compliant.py
+++ b/tests/test_compliant.py
@@ -1,7 +1,9 @@
 import unittest
 from src import compliant
 
+
 class TestComplianceProps(unittest.TestCase):
+
     def test_defaults_are_compliant(self):
         self.assertTrue(compliant.compliant())
         self.assertTrue(compliant.compliant({}))
@@ -9,14 +11,16 @@ def test_defaults_are_compliant(self):
     def test_group_count_must_be_compliant(self):
         self.assertFalse(compliant.compliant({
             "specjbb.group.count": -1,
-            }))
+        }))
 
     def test_transaction_injector_count_must_be_compliant(self):
-        self.assertFalse(compliant.compliant({
-            "specjbb.txi.pergroup.count": -1,
+        self.assertFalse(
+            compliant.compliant({
+                "specjbb.txi.pergroup.count": -1,
             }))
 
     def test_mapreducer_must_be_compliant(self):
-        self.assertFalse(compliant.compliant({
-            "specjbb.mapreducer.pool.size": 1,
+        self.assertFalse(
+            compliant.compliant({
+                "specjbb.mapreducer.pool.size": 1,
             }))
diff --git a/tests/test_validate.py b/tests/test_validate.py
index 2385911..bdf9455 100644
--- a/tests/test_validate.py
+++ b/tests/test_validate.py
@@ -6,11 +6,11 @@
 
 class TestSpectateConfigValidator(TestCase):
     examples = [
-            'example_config.json',
-            'examples/example_curses_template.json',
-            'examples/example_basic_config.json',
-            'examples/example_config.json',
-            ]
+        'example_config.json',
+        'examples/example_curses_template.json',
+        'examples/example_basic_config.json',
+        'examples/example_config.json',
+    ]
 
     def test_example_config_does_validate(self):
         for example in self.examples:
@@ -114,33 +114,32 @@ def test_RunList_with_extra_annotations_fail_to_validate(self):
             })
 
     sample_hbir_template = {
-                "args": [
-                    "Tag", "Kit Version", "JDK", "RTSTART",
-                    "JVM Options", "NUMA Nodes", "Data Collection",
-                    "T1", "T2", "T3"
-                ],
-                "prop_options": {
-                    "specjbb.controller.type": "HBIR",
-                    "specjbb.time.server": False,
-                    "specjbb.comm.connect.client.pool.size": 192,
-                    "specjbb.comm.connect.selector.runner.count": 4,
-                    "specjbb.comm.connect.timeouts.connect": 650000,
-                    "specjbb.comm.connect.timeouts.read": 650000,
-                    "specjbb.comm.connect.timeouts.write": 650000,
-                    "specjbb.comm.connect.worker.pool.max": 320,
-                    "specjbb.customerDriver.threads": 64,
-                    "specjbb.customerDriver.threads.saturate": 144,
-                    "specjbb.customerDriver.threads.probe": 96,
-                    "specjbb.mapreducer.pool.size": 27
-                },
-                "translations": {
-                    "RTSTART": "specjbb.controller.rtcurve.start",
-                    "T1": "specjbb.forkjoin.workers.Tier1",
-                    "T2": "specjbb.forkjoin.workers.Tier2",
-                    "T3": "specjbb.forkjoin.workers.Tier3",
-                    "NUMA Nodes": "specjbb.group.count"
-                }
-            }
+        "args": [
+            "Tag", "Kit Version", "JDK", "RTSTART", "JVM Options", "NUMA Nodes",
+            "Data Collection", "T1", "T2", "T3"
+        ],
+        "prop_options": {
+            "specjbb.controller.type": "HBIR",
+            "specjbb.time.server": False,
+            "specjbb.comm.connect.client.pool.size": 192,
+            "specjbb.comm.connect.selector.runner.count": 4,
+            "specjbb.comm.connect.timeouts.connect": 650000,
+            "specjbb.comm.connect.timeouts.read": 650000,
+            "specjbb.comm.connect.timeouts.write": 650000,
+            "specjbb.comm.connect.worker.pool.max": 320,
+            "specjbb.customerDriver.threads": 64,
+            "specjbb.customerDriver.threads.saturate": 144,
+            "specjbb.customerDriver.threads.probe": 96,
+            "specjbb.mapreducer.pool.size": 27
+        },
+        "translations": {
+            "RTSTART": "specjbb.controller.rtcurve.start",
+            "T1": "specjbb.forkjoin.workers.Tier1",
+            "T2": "specjbb.forkjoin.workers.Tier2",
+            "T3": "specjbb.forkjoin.workers.Tier3",
+            "NUMA Nodes": "specjbb.group.count"
+        }
+    }
 
     sample_args = {
         "Tag": "sample Tag",
@@ -155,24 +154,23 @@ def test_RunList_with_extra_annotations_fail_to_validate(self):
         "T3": 3,
     }
 
-
     def test_RunList_with_times_validates(self):
         v = validate({
-                "TemplateData": {
-                    "HBIR": self.sample_hbir_template,
+            "TemplateData": {
+                "HBIR": self.sample_hbir_template,
+            },
+            "RunList": [
+                {
+                    "template_type": "HBIR",
+                    "args": self.sample_args,
                 },
-                "RunList": [
-                    {
-                        "template_type": "HBIR",
-                        "args": self.sample_args,
-                    },
-                    {
-                        "template_type": "HBIR",
-                        "args": self.sample_args,
-                        "times": 2,
-                    },
-                ]
-            })
+                {
+                    "template_type": "HBIR",
+                    "args": self.sample_args,
+                    "times": 2,
+                },
+            ]
+        })
 
         for run in v["RunList"]:
             self.assertEqual(self.sample_args, run["args"])
@@ -184,14 +182,12 @@ def test_runs_have_default_tags(self):
         v = validate({
             "TemplateData": {
                 "HBIR": self.sample_hbir_template,
-                },
-            "RunList": [
-                {
-                    "template_type": "HBIR",
-                    "args": self.sample_args,
-                    }
-                ]
-            })
+            },
+            "RunList": [{
+                "template_type": "HBIR",
+                "args": self.sample_args,
+            }]
+        })
 
         self.assertTrue(v["RunList"][0]["tag"])
 
@@ -201,15 +197,13 @@ def test_runs_have_custom_tags(self):
         v = validate({
             "TemplateData": {
                 "HBIR": self.sample_hbir_template,
-                },
-            "RunList": [
-                {
-                    "template_type": "HBIR",
-                    "args": self.sample_args,
-                    "tag": custom_tag,
-                    }
-                ]
-            })
+            },
+            "RunList": [{
+                "template_type": "HBIR",
+                "args": self.sample_args,
+                "tag": custom_tag,
+            }]
+        })
 
         self.assertEqual(v["RunList"][0]["tag"], custom_tag)
 
@@ -220,18 +214,14 @@ def test_runs_have_distinct_ids(self):
             self.assertFalse({
                 "TemplateData": {
                     "HBIR": self.sample_hbir_template,
-                    },
-                "RunList": [
-                    {
-                        "template_type": "HBIR",
-                        "args": self.sample_args,
-                        "tag": custom_tag,
-                        },
-                    {
-                        "template_type": "HBIR",
-                        "args": self.sample_args,
-                        "tag": custom_tag,
-                        }
-                    ]
-                })
-
+                },
+                "RunList": [{
+                    "template_type": "HBIR",
+                    "args": self.sample_args,
+                    "tag": custom_tag,
+                }, {
+                    "template_type": "HBIR",
+                    "args": self.sample_args,
+                    "tag": custom_tag,
+                }]
+            })