diff --git a/api-daemon/pvcapid/benchmark.py b/api-daemon/pvcapid/benchmark.py
index 4e0bb8a1..5d8859a8 100755
--- a/api-daemon/pvcapid/benchmark.py
+++ b/api-daemon/pvcapid/benchmark.py
@@ -105,7 +105,7 @@ def list_benchmarks(job=None):
     if data:
         return data, 200
     else:
-        return { 'message': 'No benchmark found.' }, 404
+        return {'message': 'No benchmark found.' }, 404
 
 def run_benchmark(self, pool):
     # Runtime imports
@@ -456,4 +456,4 @@ def run_benchmark(self, pool):
 
     close_database(db_conn, db_cur)
     pvc_common.stopZKConnection(zk_conn)
-    return { 'status': "Storage benchmark '{}' completed successfully.", 'current': 3, 'total': 3 }
+    return {'status': "Storage benchmark '{}' completed successfully.", 'current': 3, 'total': 3 }
diff --git a/api-daemon/pvcapid/flaskapi.py b/api-daemon/pvcapid/flaskapi.py
index 5afe482b..31406830 100755
--- a/api-daemon/pvcapid/flaskapi.py
+++ b/api-daemon/pvcapid/flaskapi.py
@@ -182,9 +182,9 @@ def Authenticator(function):
             if any(token for token in config['auth_tokens'] if flask.request.headers.get('X-Api-Key') == token.get('token')):
                 return function(*args, **kwargs)
             else:
-                return { "message": "X-Api-Key Authentication failed." }, 401
+                return {"message": "X-Api-Key Authentication failed." }, 401
         # All authentications failed
-        return { "message": "X-Api-Key Authentication required." }, 401
+        return {"message": "X-Api-Key Authentication required." }, 401
     return authenticate
 
 
@@ -224,7 +224,7 @@ class API_Root(Resource):
                   description: A text message
                   example: "PVC API version 1.0"
         """
-        return { "message": "PVC API version {}".format(API_VERSION) }
+        return {"message": "PVC API version {}".format(API_VERSION) }
 api.add_resource(API_Root, '/')
 
 # /doc - NOTE: Until flask_swagger is packaged for Debian this must be disabled
@@ -282,9 +282,9 @@ class API_Login(Resource):
 
         if any(token for token in config['auth_tokens'] if flask.request.values['token'] in token['token']):
             flask.session['token'] = flask.request.form['token']
-            return { "message": "Authentication successful" }, 200
+            return {"message": "Authentication successful" }, 200
         else:
-            { "message": "Authentication failed" }, 401
+            {"message": "Authentication failed" }, 401
 api.add_resource(API_Login, '/login')
 
 # /logout
@@ -308,7 +308,7 @@ class API_Logout(Resource):
             return flask.redirect(Api.url_for(api, API_Root))
 
         flask.session.pop('token', None)
-        return { "message": "Deauthentication successful" }, 200
+        return {"message": "Deauthentication successful" }, 200
 api.add_resource(API_Logout, '/logout')
 
 # /initialize
@@ -335,9 +335,9 @@ class API_Initialize(Resource):
             description: Bad request
         """
         if api_helper.initialize_cluster():
-            return { "message": "Successfully initialized a new PVC cluster" }, 200
+            return {"message": "Successfully initialized a new PVC cluster" }, 200
         else:
-            return { "message": "PVC cluster already initialized" }, 400
+            return {"message": "PVC cluster already initialized" }, 400
 api.add_resource(API_Initialize, '/initialize')
 
 # /status
@@ -420,7 +420,7 @@ class API_Status(Resource):
         return api_helper.cluster_status()
 
     @RequestParser([
-        { 'name': 'state', 'choices': ('true', 'false'), 'required': True, 'helpmsg': "A valid state must be specified." }
+        {'name': 'state', 'choices': ('true', 'false'), 'required': True, 'helpmsg': "A valid state must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -459,10 +459,10 @@ api.add_resource(API_Status, '/status')
 # /node
 class API_Node_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'daemon_state' },
-        { 'name': 'coordinator_state' },
-        { 'name': 'domain_state' }
+        {'name': 'limit' },
+        {'name': 'daemon_state' },
+        {'name': 'coordinator_state' },
+        {'name': 'domain_state' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -659,7 +659,7 @@ class API_Node_CoordinatorState(Resource):
         return api_helper.node_coordinator_state(node)
 
     @RequestParser([
-        { 'name': 'state', 'choices': ('primary', 'secondary'), 'helptext': "A valid state must be specified", 'required': True }
+        {'name': 'state', 'choices': ('primary', 'secondary'), 'helptext': "A valid state must be specified", 'required': True }
     ])
     @Authenticator
     def post(self, node, reqargs):
@@ -727,8 +727,8 @@ class API_Node_DomainState(Resource):
         return api_helper.node_domain_state(node)
 
     @RequestParser([
-        { 'name': 'state', 'choices': ('ready', 'flush'), 'helptext': "A valid state must be specified", 'required': True },
-        { 'name': 'wait' }
+        {'name': 'state', 'choices': ('ready', 'flush'), 'helptext': "A valid state must be specified", 'required': True },
+        {'name': 'wait' }
     ])
     @Authenticator
     def post(self, node, reqargs):
@@ -777,9 +777,9 @@ api.add_resource(API_Node_DomainState, '/node/<node>/domain-state')
 # /vm
 class API_VM_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'node' },
-        { 'name': 'state' },
+        {'name': 'limit' },
+        {'name': 'node' },
+        {'name': 'state' },
     ])
     @Authenticator
     def get(self, reqargs):
@@ -1026,12 +1026,12 @@ class API_VM_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'node' },
-        { 'name': 'selector', 'choices': ('mem', 'vcpus', 'load', 'vms'), 'helptext': "A valid selector must be specified" },
-        { 'name': 'autostart' },
-        { 'name': 'migration_method', 'choices': ('live', 'shutdown', 'none'), 'helptext': "A valid migration_method must be specified" },
-        { 'name': 'xml', 'required': True, 'helptext': "A Libvirt XML document must be specified" },
+        {'name': 'limit' },
+        {'name': 'node' },
+        {'name': 'selector', 'choices': ('mem', 'vcpus', 'load', 'vms'), 'helptext': "A valid selector must be specified" },
+        {'name': 'autostart' },
+        {'name': 'migration_method', 'choices': ('live', 'shutdown', 'none'), 'helptext': "A valid migration_method must be specified" },
+        {'name': 'xml', 'required': True, 'helptext': "A Libvirt XML document must be specified" },
     ])
     @Authenticator
     def post(self, reqargs):
@@ -1127,12 +1127,12 @@ class API_VM_Element(Resource):
         return api_helper.vm_list(None, None, vm, is_fuzzy=False)
 
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'node' },
-        { 'name': 'selector', 'choices': ('mem', 'vcpus', 'load', 'vms'), 'helptext': "A valid selector must be specified" },
-        { 'name': 'autostart' },
-        { 'name': 'migration_method', 'choices': ('live', 'shutdown', 'none'), 'helptext': "A valid migration_method must be specified" },
-        { 'name': 'xml', 'required': True, 'helptext': "A Libvirt XML document must be specified" },
+        {'name': 'limit' },
+        {'name': 'node' },
+        {'name': 'selector', 'choices': ('mem', 'vcpus', 'load', 'vms'), 'helptext': "A valid selector must be specified" },
+        {'name': 'autostart' },
+        {'name': 'migration_method', 'choices': ('live', 'shutdown', 'none'), 'helptext': "A valid migration_method must be specified" },
+        {'name': 'xml', 'required': True, 'helptext': "A Libvirt XML document must be specified" },
     ])
     @Authenticator
     def post(self, vm, reqargs):
@@ -1207,8 +1207,8 @@ class API_VM_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'restart' },
-        { 'name': 'xml', 'required': True, 'helptext': "A Libvirt XML document must be specified" },
+        {'name': 'restart' },
+        {'name': 'xml', 'required': True, 'helptext': "A Libvirt XML document must be specified" },
     ])
     @Authenticator
     def put(self, vm, reqargs):
@@ -1246,7 +1246,7 @@ class API_VM_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'delete_disks' },
+        {'name': 'delete_disks' },
     ])
     @Authenticator
     def delete(self, vm, reqargs):
@@ -1326,11 +1326,11 @@ class API_VM_Metadata(Resource):
         return api_helper.get_vm_meta(vm)
 
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'selector', 'choices': ('mem', 'vcpus', 'load', 'vms'), 'helptext': "A valid selector must be specified" },
-        { 'name': 'autostart' },
-        { 'name': 'profile' },
-        { 'name': 'migration_method', 'choices': ('live', 'shutdown', 'none'), 'helptext': "A valid migration_method must be specified" },
+        {'name': 'limit' },
+        {'name': 'selector', 'choices': ('mem', 'vcpus', 'load', 'vms'), 'helptext': "A valid selector must be specified" },
+        {'name': 'autostart' },
+        {'name': 'profile' },
+        {'name': 'migration_method', 'choices': ('live', 'shutdown', 'none'), 'helptext': "A valid migration_method must be specified" },
     ])
     @Authenticator
     def post(self, vm, reqargs):
@@ -1428,8 +1428,8 @@ class API_VM_State(Resource):
         return api_helper.vm_state(vm)
 
     @RequestParser([
-        { 'name': 'state', 'choices': ('start', 'shutdown', 'stop', 'restart', 'disable'), 'helptext': "A valid state must be specified", 'required': True },
-        { 'name': 'wait' }
+        {'name': 'state', 'choices': ('start', 'shutdown', 'stop', 'restart', 'disable'), 'helptext': "A valid state must be specified", 'required': True },
+        {'name': 'wait' }
     ])
     @Authenticator
     def post(self, vm, reqargs):
@@ -1516,11 +1516,11 @@ class API_VM_Node(Resource):
         return api_helper.vm_node(vm)
 
     @RequestParser([
-        { 'name': 'action', 'choices': ('migrate', 'unmigrate', 'move'), 'helptext': "A valid action must be specified", 'required': True },
-        { 'name': 'node' },
-        { 'name': 'force' },
-        { 'name': 'wait' },
-        { 'name': 'force_live' }
+        {'name': 'action', 'choices': ('migrate', 'unmigrate', 'move'), 'helptext': "A valid action must be specified", 'required': True },
+        {'name': 'node' },
+        {'name': 'force' },
+        {'name': 'wait' },
+        {'name': 'force_live' }
     ])
     @Authenticator
     def post(self, vm, reqargs):
@@ -1609,7 +1609,7 @@ api.add_resource(API_VM_Locks, '/vm/<vm>/locks')
 # /vm/<vm</console
 class API_VM_Console(Resource):
     @RequestParser([
-        { 'name': 'lines' }
+        {'name': 'lines' }
     ])
     @Authenticator
     def get(self, vm, reqargs):
@@ -1657,7 +1657,7 @@ api.add_resource(API_VM_Console, '/vm/<vm>/console')
 # /network
 class API_Network_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -1740,18 +1740,18 @@ class API_Network_Root(Resource):
         return api_helper.net_list(reqargs.get('limit', None))
 
     @RequestParser([
-        { 'name': 'vni', 'required': True },
-        { 'name': 'description', 'required': True },
-        { 'name': 'nettype', 'choices': ('managed', 'bridged'), 'helptext': 'A valid nettype must be specified', 'required': True },
-        { 'name': 'domain' },
-        { 'name': 'name_servers' },
-        { 'name': 'ip4_network' },
-        { 'name': 'ip4_gateway' },
-        { 'name': 'ip6_network' },
-        { 'name': 'ip6_gateway' },
-        { 'name': 'dhcp4' },
-        { 'name': 'dhcp4_start' },
-        { 'name': 'dhcp4_end' }
+        {'name': 'vni', 'required': True },
+        {'name': 'description', 'required': True },
+        {'name': 'nettype', 'choices': ('managed', 'bridged'), 'helptext': 'A valid nettype must be specified', 'required': True },
+        {'name': 'domain' },
+        {'name': 'name_servers' },
+        {'name': 'ip4_network' },
+        {'name': 'ip4_gateway' },
+        {'name': 'ip6_network' },
+        {'name': 'ip6_gateway' },
+        {'name': 'dhcp4' },
+        {'name': 'dhcp4_start' },
+        {'name': 'dhcp4_end' }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -1870,17 +1870,17 @@ class API_Network_Element(Resource):
         return api_helper.net_list(vni, is_fuzzy=False)
 
     @RequestParser([
-        { 'name': 'description', 'required': True },
-        { 'name': 'nettype', 'choices': ('managed', 'bridged'), 'helptext': 'A valid nettype must be specified', 'required': True },
-        { 'name': 'domain' },
-        { 'name': 'name_servers' },
-        { 'name': 'ip4_network' },
-        { 'name': 'ip4_gateway' },
-        { 'name': 'ip6_network' },
-        { 'name': 'ip6_gateway' },
-        { 'name': 'dhcp4' },
-        { 'name': 'dhcp4_start' },
-        { 'name': 'dhcp4_end' }
+        {'name': 'description', 'required': True },
+        {'name': 'nettype', 'choices': ('managed', 'bridged'), 'helptext': 'A valid nettype must be specified', 'required': True },
+        {'name': 'domain' },
+        {'name': 'name_servers' },
+        {'name': 'ip4_network' },
+        {'name': 'ip4_gateway' },
+        {'name': 'ip6_network' },
+        {'name': 'ip6_gateway' },
+        {'name': 'dhcp4' },
+        {'name': 'dhcp4_start' },
+        {'name': 'dhcp4_end' }
     ])
     @Authenticator
     def post(self, vni, reqargs):
@@ -1971,16 +1971,16 @@ class API_Network_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'description' },
-        { 'name': 'domain' },
-        { 'name': 'name_servers' },
-        { 'name': 'ip4_network' },
-        { 'name': 'ip4_gateway' },
-        { 'name': 'ip6_network' },
-        { 'name': 'ip6_gateway' },
-        { 'name': 'dhcp4' },
-        { 'name': 'dhcp4_start' },
-        { 'name': 'dhcp4_end' }
+        {'name': 'description' },
+        {'name': 'domain' },
+        {'name': 'name_servers' },
+        {'name': 'ip4_network' },
+        {'name': 'ip4_gateway' },
+        {'name': 'ip6_network' },
+        {'name': 'ip6_gateway' },
+        {'name': 'dhcp4' },
+        {'name': 'dhcp4_start' },
+        {'name': 'dhcp4_end' }
     ])
     @Authenticator
     def put(self, vni, reqargs):
@@ -2096,8 +2096,8 @@ api.add_resource(API_Network_Element, '/network/<vni>')
 # /network/<vni>/lease
 class API_Network_Lease_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'static' }
+        {'name': 'limit' },
+        {'name': 'static' }
     ])
     @Authenticator
     def get(self, vni, reqargs):
@@ -2160,9 +2160,9 @@ class API_Network_Lease_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'macaddress', 'required': True },
-        { 'name': 'ipaddress', 'required': True },
-        { 'name': 'hostname' }
+        {'name': 'macaddress', 'required': True },
+        {'name': 'ipaddress', 'required': True },
+        {'name': 'hostname' }
     ])
     @Authenticator
     def post(self, vni, reqargs):
@@ -2263,8 +2263,8 @@ class API_Network_Lease_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'ipaddress', 'required': True },
-        { 'name': 'hostname' }
+        {'name': 'ipaddress', 'required': True },
+        {'name': 'hostname' }
     ])
     @Authenticator
     def post(self, vni, mac):
@@ -2341,8 +2341,8 @@ api.add_resource(API_Network_Lease_Element, '/network/<vni>/lease/<mac>')
 # /network/<vni>/acl
 class API_Network_ACL_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'direction', 'choices': ('in', 'out'), 'helpmsg': "A valid direction must be specified." }
+        {'name': 'limit' },
+        {'name': 'direction', 'choices': ('in', 'out'), 'helpmsg': "A valid direction must be specified." }
     ])
     @Authenticator
     def get(self, vni, reqargs):
@@ -2404,10 +2404,10 @@ class API_Network_ACL_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'description', 'required': True, 'helpmsg': "A whitespace-free description must be specified." },
-        { 'name': 'rule', 'required': True, 'helpmsg': "A rule must be specified." },
-        { 'name': 'direction', 'choices': ('in', 'out'), 'helpmsg': "A valid direction must be specified." },
-        { 'name': 'order' }
+        {'name': 'description', 'required': True, 'helpmsg': "A whitespace-free description must be specified." },
+        {'name': 'rule', 'required': True, 'helpmsg': "A rule must be specified." },
+        {'name': 'direction', 'choices': ('in', 'out'), 'helpmsg': "A valid direction must be specified." },
+        {'name': 'order' }
     ])
     @Authenticator
     def post(self, vni, reqargs):
@@ -2493,9 +2493,9 @@ class API_Network_ACL_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'rule', 'required': True, 'helpmsg': "A rule must be specified." },
-        { 'name': 'direction', 'choices': ('in', 'out'), 'helpmsg': "A valid direction must be specified." },
-        { 'name': 'order' }
+        {'name': 'rule', 'required': True, 'helpmsg': "A rule must be specified." },
+        {'name': 'direction', 'choices': ('in', 'out'), 'helpmsg': "A valid direction must be specified." },
+        {'name': 'order' }
     ])
     @Authenticator
     def post(self, vni, description, reqargs):
@@ -2649,7 +2649,7 @@ api.add_resource(API_Storage_Ceph_Utilization, '/storage/ceph/utilization')
 # /storage/ceph/benchmark
 class API_Storage_Ceph_Benchmark(Resource):
     @RequestParser([
-        { 'name': 'job' }
+        {'name': 'job' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -2771,7 +2771,7 @@ class API_Storage_Ceph_Benchmark(Resource):
         return api_benchmark.list_benchmarks(reqargs.get('job', None))
 
     @RequestParser([
-        { 'name': 'pool', 'required': True, 'helpmsg': "A valid pool must be specified." },
+        {'name': 'pool', 'required': True, 'helpmsg': "A valid pool must be specified." },
     ])
     @Authenticator
     def post(self, reqargs):
@@ -2796,19 +2796,19 @@ class API_Storage_Ceph_Benchmark(Resource):
         # Verify that the pool is valid
         _list, code = api_helper.ceph_pool_list(reqargs.get('pool', None), is_fuzzy=False)
         if code != 200:
-            return { 'message': 'Pool "{}" is not valid.'.format(reqargs.get('pool')) }, 400
+            return {'message': 'Pool "{}" is not valid.'.format(reqargs.get('pool')) }, 400
 
         task = run_benchmark.delay(
             reqargs.get('pool', None)
         )
-        return { "task_id": task.id }, 202, { 'Location': Api.url_for(api, API_Storage_Ceph_Benchmark, task_id=task.id) }
+        return {"task_id": task.id }, 202, {'Location': Api.url_for(api, API_Storage_Ceph_Benchmark, task_id=task.id) }
 api.add_resource(API_Storage_Ceph_Benchmark, '/storage/ceph/benchmark')
 
 # /storage/ceph/option
 class API_Storage_Ceph_Option(Resource):
     @RequestParser([
-        { 'name': 'option', 'required': True, 'helpmsg': "A valid option must be specified." },
-        { 'name': 'action', 'required': True, 'choices': ('set', 'unset'), 'helpmsg': "A valid action must be specified." },
+        {'name': 'option', 'required': True, 'helpmsg': "A valid option must be specified." },
+        {'name': 'action', 'required': True, 'choices': ('set', 'unset'), 'helpmsg': "A valid action must be specified." },
     ])
     @Authenticator
     def post(self, reqargs):
@@ -2853,7 +2853,7 @@ api.add_resource(API_Storage_Ceph_Option, '/storage/ceph/option')
 # /storage/ceph/osd
 class API_Storage_Ceph_OSD_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' },
+        {'name': 'limit' },
     ])
     @Authenticator
     def get(self, reqargs):
@@ -2946,9 +2946,9 @@ class API_Storage_Ceph_OSD_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'node', 'required': True, 'helpmsg': "A valid node must be specified." },
-        { 'name': 'device', 'required': True, 'helpmsg': "A valid device must be specified." },
-        { 'name': 'weight', 'required': True, 'helpmsg': "An OSD weight must be specified." },
+        {'name': 'node', 'required': True, 'helpmsg': "A valid node must be specified." },
+        {'name': 'device', 'required': True, 'helpmsg': "A valid device must be specified." },
+        {'name': 'weight', 'required': True, 'helpmsg': "An OSD weight must be specified." },
     ])
     @Authenticator
     def post(self, reqargs):
@@ -3013,7 +3013,7 @@ class API_Storage_Ceph_OSD_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'yes-i-really-mean-it', 'required': True, 'helpmsg': "Please confirm that 'yes-i-really-mean-it'." }
+        {'name': 'yes-i-really-mean-it', 'required': True, 'helpmsg': "Please confirm that 'yes-i-really-mean-it'." }
     ])
     @Authenticator
     def delete(self, osdid, reqargs):
@@ -3076,7 +3076,7 @@ class API_Storage_Ceph_OSD_State(Resource):
         )
 
     @RequestParser([
-        { 'name': 'state', 'choices': ('in', 'out'), 'required': True, 'helpmsg': "A valid state must be specified." },
+        {'name': 'state', 'choices': ('in', 'out'), 'required': True, 'helpmsg': "A valid state must be specified." },
     ])
     @Authenticator
     def post(self, osdid, reqargs):
@@ -3112,7 +3112,7 @@ api.add_resource(API_Storage_Ceph_OSD_State, '/storage/ceph/osd/<osdid>/state')
 # /storage/ceph/pool
 class API_Storage_Ceph_Pool_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -3193,9 +3193,9 @@ class API_Storage_Ceph_Pool_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'pool', 'required': True, 'helpmsg': "A pool name must be specified." },
-        { 'name': 'pgs', 'required': True, 'helpmsg': "A placement group count must be specified." },
-        { 'name': 'replcfg', 'required': True, 'helpmsg': "A valid replication configuration must be specified." }
+        {'name': 'pool', 'required': True, 'helpmsg': "A pool name must be specified." },
+        {'name': 'pgs', 'required': True, 'helpmsg': "A placement group count must be specified." },
+        {'name': 'replcfg', 'required': True, 'helpmsg': "A valid replication configuration must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -3265,8 +3265,8 @@ class API_Storage_Ceph_Pool_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'pgs', 'required': True, 'helpmsg': "A placement group count must be specified." },
-        { 'name': 'replcfg', 'required': True, 'helpmsg': "A valid replication configuration must be specified." }
+        {'name': 'pgs', 'required': True, 'helpmsg': "A placement group count must be specified." },
+        {'name': 'replcfg', 'required': True, 'helpmsg': "A valid replication configuration must be specified." }
     ])
     @Authenticator
     def post(self, pool):
@@ -3310,7 +3310,7 @@ class API_Storage_Ceph_Pool_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'yes-i-really-mean-it', 'required': True, 'helpmsg': "Please confirm that 'yes-i-really-mean-it'." }
+        {'name': 'yes-i-really-mean-it', 'required': True, 'helpmsg': "Please confirm that 'yes-i-really-mean-it'." }
     ])
     @Authenticator
     def delete(self, pool, reqargs):
@@ -3351,8 +3351,8 @@ api.add_resource(API_Storage_Ceph_Pool_Element, '/storage/ceph/pool/<pool>')
 # /storage/ceph/volume
 class API_Storage_Ceph_Volume_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' },
-        { 'name': 'pool' }
+        {'name': 'limit' },
+        {'name': 'pool' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -3451,9 +3451,9 @@ class API_Storage_Ceph_Volume_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'volume', 'required': True, 'helpmsg': "A volume name must be specified." },
-        { 'name': 'pool', 'required': True, 'helpmsg': "A valid pool name must be specified." },
-        { 'name': 'size', 'required': True, 'helpmsg': "A volume size in bytes (or with k/M/G/T suffix) must be specified." }
+        {'name': 'volume', 'required': True, 'helpmsg': "A volume name must be specified." },
+        {'name': 'pool', 'required': True, 'helpmsg': "A valid pool name must be specified." },
+        {'name': 'size', 'required': True, 'helpmsg': "A volume size in bytes (or with k/M/G/T suffix) must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -3524,7 +3524,7 @@ class API_Storage_Ceph_Volume_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'size', 'required': True, 'helpmsg': "A volume size in bytes (or with k/M/G/T suffix) must be specified." }
+        {'name': 'size', 'required': True, 'helpmsg': "A volume size in bytes (or with k/M/G/T suffix) must be specified." }
     ])
     @Authenticator
     def post(self, pool, volume, reqargs):
@@ -3563,8 +3563,8 @@ class API_Storage_Ceph_Volume_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'new_size' },
-        { 'name': 'new_name' }
+        {'name': 'new_size' },
+        {'name': 'new_name' }
     ])
     @Authenticator
     def put(self, pool, volume, reqargs):
@@ -3602,7 +3602,7 @@ class API_Storage_Ceph_Volume_Element(Resource):
               id: Message
         """
         if reqargs.get('new_size', None) and reqargs.get('new_name', None):
-            return { "message": "Can only perform one modification at once" }, 400
+            return {"message": "Can only perform one modification at once" }, 400
 
         if reqargs.get('new_size', None):
             return api_helper.ceph_volume_resize(
@@ -3616,7 +3616,7 @@ class API_Storage_Ceph_Volume_Element(Resource):
                 volume,
                 reqargs.get('new_name')
             )
-        return { "message": "At least one modification must be specified" }, 400
+        return {"message": "At least one modification must be specified" }, 400
 
     @Authenticator
     def delete(self, pool, volume):
@@ -3647,7 +3647,7 @@ api.add_resource(API_Storage_Ceph_Volume_Element, '/storage/ceph/volume/<pool>/<
 # /storage/ceph/volume/<pool>/<volume>/clone
 class API_Storage_Ceph_Volume_Element_Clone(Resource):
     @RequestParser([
-        { 'name': 'new_volume', 'required': True, 'helpmsg': "A new volume name must be specified." }
+        {'name': 'new_volume', 'required': True, 'helpmsg': "A new volume name must be specified." }
     ])
     @Authenticator
     def post(self, pool, volume, reqargs):
@@ -3689,7 +3689,7 @@ api.add_resource(API_Storage_Ceph_Volume_Element_Clone, '/storage/ceph/volume/<p
 # /storage/ceph/volume/<pool>/<volume>/upload
 class API_Storage_Ceph_Volume_Element_Upload(Resource):
     @RequestParser([
-        { 'name': 'image_format', 'required': True, 'helpmsg': "A source image format must be specified." }
+        {'name': 'image_format', 'required': True, 'helpmsg': "A source image format must be specified." }
     ])
     @Authenticator
     def post(self, pool, volume, reqargs):
@@ -3740,9 +3740,9 @@ api.add_resource(API_Storage_Ceph_Volume_Element_Upload, '/storage/ceph/volume/<
 # /storage/ceph/snapshot
 class API_Storage_Ceph_Snapshot_Root(Resource):
     @RequestParser([
-        { 'name': 'pool' },
-        { 'name': 'volume' },
-        { 'name': 'limit' },
+        {'name': 'pool' },
+        {'name': 'volume' },
+        {'name': 'limit' },
     ])
     @Authenticator
     def get(self, reqargs):
@@ -3796,9 +3796,9 @@ class API_Storage_Ceph_Snapshot_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'snapshot', 'required': True, 'helpmsg': "A snapshot name must be specified." },
-        { 'name': 'volume', 'required': True, 'helpmsg': "A volume name must be specified." },
-        { 'name': 'pool', 'required': True, 'helpmsg': "A pool name must be specified." }
+        {'name': 'snapshot', 'required': True, 'helpmsg': "A snapshot name must be specified." },
+        {'name': 'volume', 'required': True, 'helpmsg': "A volume name must be specified." },
+        {'name': 'pool', 'required': True, 'helpmsg': "A pool name must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -3916,7 +3916,7 @@ class API_Storage_Ceph_Snapshot_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'new_name', 'required': True, 'helpmsg': "A new name must be specified." }
+        {'name': 'new_name', 'required': True, 'helpmsg': "A new name must be specified." }
     ])
     @Authenticator
     def put(self, pool, volume, snapshot, reqargs):
@@ -4000,7 +4000,7 @@ api.add_resource(API_Provisioner_Root, '/provisioner')
 # /provisioner/template
 class API_Provisioner_Template_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -4046,7 +4046,7 @@ api.add_resource(API_Provisioner_Template_Root, '/provisioner/template')
 # /provisioner/template/system
 class API_Provisioner_Template_System_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -4112,16 +4112,16 @@ class API_Provisioner_Template_System_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A name must be specified." },
-        { 'name': 'vcpus', 'required': True, 'helpmsg': "A vcpus value must be specified." },
-        { 'name': 'vram', 'required': True, 'helpmsg': "A vram value in MB must be specified." },
-        { 'name': 'serial', 'required': True, 'helpmsg': "A serial value must be specified." },
-        { 'name': 'vnc', 'required': True, 'helpmsg': "A vnc value must be specified." },
-        { 'name': 'vnc_bind' },
-        { 'name': 'node_limit' },
-        { 'name': 'node_selector' },
-        { 'name': 'node_autostart' },
-        { 'name': 'migration_method' }
+        {'name': 'name', 'required': True, 'helpmsg': "A name must be specified." },
+        {'name': 'vcpus', 'required': True, 'helpmsg': "A vcpus value must be specified." },
+        {'name': 'vram', 'required': True, 'helpmsg': "A vram value in MB must be specified." },
+        {'name': 'serial', 'required': True, 'helpmsg': "A serial value must be specified." },
+        {'name': 'vnc', 'required': True, 'helpmsg': "A vnc value must be specified." },
+        {'name': 'vnc_bind' },
+        {'name': 'node_limit' },
+        {'name': 'node_selector' },
+        {'name': 'node_autostart' },
+        {'name': 'migration_method' }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -4197,11 +4197,11 @@ class API_Provisioner_Template_System_Root(Resource):
         try:
             vcpus = int(reqargs.get('vcpus'))
         except Exception:
-            return { "message": "A vcpus value must be an integer" }, 400
+            return {"message": "A vcpus value must be an integer" }, 400
         try:
             vram = int(reqargs.get('vram'))
         except Exception:
-            return { "message": "A vram value must be an integer" }, 400
+            return {"message": "A vram value must be an integer" }, 400
         # Cast boolean arguments
         if bool(strtobool(reqargs.get('serial', 'false'))):
             serial = True
@@ -4258,15 +4258,15 @@ class API_Provisioner_Template_System_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'vcpus', 'required': True, 'helpmsg': "A vcpus value must be specified." },
-        { 'name': 'vram', 'required': True, 'helpmsg': "A vram value in MB must be specified." },
-        { 'name': 'serial', 'required': True, 'helpmsg': "A serial value must be specified." },
-        { 'name': 'vnc', 'required': True, 'helpmsg': "A vnc value must be specified." },
-        { 'name': 'vnc_bind' },
-        { 'name': 'node_limit' },
-        { 'name': 'node_selector' },
-        { 'name': 'node_autostart' },
-        { 'name': 'migration_method' }
+        {'name': 'vcpus', 'required': True, 'helpmsg': "A vcpus value must be specified." },
+        {'name': 'vram', 'required': True, 'helpmsg': "A vram value in MB must be specified." },
+        {'name': 'serial', 'required': True, 'helpmsg': "A serial value must be specified." },
+        {'name': 'vnc', 'required': True, 'helpmsg': "A vnc value must be specified." },
+        {'name': 'vnc_bind' },
+        {'name': 'node_limit' },
+        {'name': 'node_selector' },
+        {'name': 'node_autostart' },
+        {'name': 'migration_method' }
     ])
     @Authenticator
     def post(self, template, reqargs):
@@ -4337,11 +4337,11 @@ class API_Provisioner_Template_System_Element(Resource):
         try:
             vcpus = int(reqargs.get('vcpus'))
         except Exception:
-            return { "message": "A vcpus value must be an integer" }, 400
+            return {"message": "A vcpus value must be an integer" }, 400
         try:
             vram = int(reqargs.get('vram'))
         except Exception:
-            return { "message": "A vram value must be an integer" }, 400
+            return {"message": "A vram value must be an integer" }, 400
         # Cast boolean arguments
         if bool(strtobool(reqargs.get('serial', False))):
             serial = True
@@ -4372,15 +4372,15 @@ class API_Provisioner_Template_System_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'vcpus' },
-        { 'name': 'vram' },
-        { 'name': 'serial' },
-        { 'name': 'vnc' },
-        { 'name': 'vnc_bind' },
-        { 'name': 'node_limit' },
-        { 'name': 'node_selector' },
-        { 'name': 'node_autostart' },
-        { 'name': 'migration_method' }
+        {'name': 'vcpus' },
+        {'name': 'vram' },
+        {'name': 'serial' },
+        {'name': 'vnc' },
+        {'name': 'vnc_bind' },
+        {'name': 'node_limit' },
+        {'name': 'node_selector' },
+        {'name': 'node_autostart' },
+        {'name': 'migration_method' }
     ])
     @Authenticator
     def put(self, template, reqargs):
@@ -4478,7 +4478,7 @@ api.add_resource(API_Provisioner_Template_System_Element, '/provisioner/template
 # /provisioner/template/network
 class API_Provisioner_Template_Network_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -4537,8 +4537,8 @@ class API_Provisioner_Template_Network_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A template name must be specified." },
-        { 'name': 'mac_template' }
+        {'name': 'name', 'required': True, 'helpmsg': "A template name must be specified." },
+        {'name': 'mac_template' }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -4602,7 +4602,7 @@ class API_Provisioner_Template_Network_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'mac_template' }
+        {'name': 'mac_template' }
     ])
     @Authenticator
     def post(self, template, reqargs):
@@ -4687,10 +4687,10 @@ class API_Provisioner_Template_Network_Net_Root(Resource):
         if templates:
             return templates['networks']
         else:
-            return { 'message': 'Template not found.' }, 404
+            return {'message': 'Template not found.' }, 404
 
     @RequestParser([
-        { 'name': 'vni', 'required': True, 'helpmsg': "A valid VNI must be specified." }
+        {'name': 'vni', 'required': True, 'helpmsg': "A valid VNI must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -4804,7 +4804,7 @@ api.add_resource(API_Provisioner_Template_Network_Net_Element, '/provisioner/tem
 # /provisioner/template/storage
 class API_Provisioner_Template_Storage_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -4877,7 +4877,7 @@ class API_Provisioner_Template_Storage_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A template name must be specified." }
+        {'name': 'name', 'required': True, 'helpmsg': "A template name must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -4984,7 +4984,7 @@ api.add_resource(API_Provisioner_Template_Storage_Element, '/provisioner/templat
 # /provisioner/template/storage/<template>/disk
 class API_Provisioner_Template_Storage_Disk_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, template, reqargs):
@@ -5013,16 +5013,16 @@ class API_Provisioner_Template_Storage_Disk_Root(Resource):
         if templates:
             return templates['disks']
         else:
-            return { 'message': 'Template not found.' }, 404
+            return {'message': 'Template not found.' }, 404
 
     @RequestParser([
-        { 'name': 'disk_id', 'required': True, 'helpmsg': "A disk identifier in sdX or vdX format must be specified." },
-        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
-        { 'name': 'source_volume' },
-        { 'name': 'disk_size' },
-        { 'name': 'filesystem' },
-        { 'name': 'filesystem_arg', 'action': 'append' },
-        { 'name': 'mountpoint' }
+        {'name': 'disk_id', 'required': True, 'helpmsg': "A disk identifier in sdX or vdX format must be specified." },
+        {'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
+        {'name': 'source_volume' },
+        {'name': 'disk_size' },
+        {'name': 'filesystem' },
+        {'name': 'filesystem_arg', 'action': 'append' },
+        {'name': 'mountpoint' }
     ])
     @Authenticator
     def post(self, template, reqargs):
@@ -5121,12 +5121,12 @@ class API_Provisioner_Template_Storage_Disk_Element(Resource):
         abort(404)
 
     @RequestParser([
-        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
-        { 'name': 'source_volume' },
-        { 'name': 'disk_size' },
-        { 'name': 'filesystem' },
-        { 'name': 'filesystem_arg', 'action': 'append' },
-        { 'name': 'mountpoint' }
+        {'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
+        {'name': 'source_volume' },
+        {'name': 'disk_size' },
+        {'name': 'filesystem' },
+        {'name': 'filesystem_arg', 'action': 'append' },
+        {'name': 'mountpoint' }
     ])
     @Authenticator
     def post(self, template, disk_id, reqargs):
@@ -5218,7 +5218,7 @@ api.add_resource(API_Provisioner_Template_Storage_Disk_Element, '/provisioner/te
 # /provisioner/userdata
 class API_Provisioner_Userdata_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -5260,8 +5260,8 @@ class API_Provisioner_Userdata_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A name must be specified." },
-        { 'name': 'data', 'required': True, 'helpmsg': "A userdata document must be specified." }
+        {'name': 'name', 'required': True, 'helpmsg': "A name must be specified." },
+        {'name': 'data', 'required': True, 'helpmsg': "A userdata document must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -5325,7 +5325,7 @@ class API_Provisioner_Userdata_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'data', 'required': True, 'helpmsg': "A userdata document must be specified." }
+        {'name': 'data', 'required': True, 'helpmsg': "A userdata document must be specified." }
     ])
     @Authenticator
     def post(self, userdata, reqargs):
@@ -5358,7 +5358,7 @@ class API_Provisioner_Userdata_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'data', 'required': True, 'helpmsg': "A userdata document must be specified." }
+        {'name': 'data', 'required': True, 'helpmsg': "A userdata document must be specified." }
     ])
     @Authenticator
     def put(self, userdata, reqargs):
@@ -5417,7 +5417,7 @@ api.add_resource(API_Provisioner_Userdata_Element, '/provisioner/userdata/<userd
 # /provisioner/script
 class API_Provisioner_Script_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -5459,8 +5459,8 @@ class API_Provisioner_Script_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A script name must be specified." },
-        { 'name': 'data', 'required': True, 'helpmsg': "A script document must be specified." }
+        {'name': 'name', 'required': True, 'helpmsg': "A script name must be specified." },
+        {'name': 'data', 'required': True, 'helpmsg': "A script document must be specified." }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -5524,7 +5524,7 @@ class API_Provisioner_Script_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'data', 'required': True, 'helpmsg': "A script document must be specified." }
+        {'name': 'data', 'required': True, 'helpmsg': "A script document must be specified." }
     ])
     @Authenticator
     def post(self, script):
@@ -5557,7 +5557,7 @@ class API_Provisioner_Script_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'data', 'required': True, 'helpmsg': "A script document must be specified." }
+        {'name': 'data', 'required': True, 'helpmsg': "A script document must be specified." }
     ])
     @Authenticator
     def put(self, script, reqargs):
@@ -5616,7 +5616,7 @@ api.add_resource(API_Provisioner_Script_Element, '/provisioner/script/<script>')
 # /provisioner/profile
 class API_Provisioner_OVA_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -5676,9 +5676,9 @@ class API_Provisioner_OVA_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
-        { 'name': 'name', 'required': True, 'helpmsg': "A VM name must be specified." },
-        { 'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified." },
+        {'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
+        {'name': 'name', 'required': True, 'helpmsg': "A VM name must be specified." },
+        {'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified." },
     ])
     @Authenticator
     def post(self, reqargs):
@@ -5750,8 +5750,8 @@ class API_Provisioner_OVA_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
-        { 'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified." },
+        {'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified." },
+        {'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified." },
     ])
     @Authenticator
     def post(self, ova, reqargs):
@@ -5818,7 +5818,7 @@ api.add_resource(API_Provisioner_OVA_Element, '/provisioner/ova/<ova>')
 # /provisioner/profile
 class API_Provisioner_Profile_Root(Resource):
     @RequestParser([
-        { 'name': 'limit' }
+        {'name': 'limit' }
     ])
     @Authenticator
     def get(self, reqargs):
@@ -5877,15 +5877,15 @@ class API_Provisioner_Profile_Root(Resource):
         )
 
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A profile name must be specified." },
-        { 'name': 'profile_type', 'required': True, 'helpmsg': "A profile type must be specified." },
-        { 'name': 'system_template' },
-        { 'name': 'network_template' },
-        { 'name': 'storage_template' },
-        { 'name': 'userdata' },
-        { 'name': 'script' },
-        { 'name': 'ova' },
-        { 'name': 'arg', 'action': 'append' }
+        {'name': 'name', 'required': True, 'helpmsg': "A profile name must be specified." },
+        {'name': 'profile_type', 'required': True, 'helpmsg': "A profile type must be specified." },
+        {'name': 'system_template' },
+        {'name': 'network_template' },
+        {'name': 'storage_template' },
+        {'name': 'userdata' },
+        {'name': 'script' },
+        {'name': 'ova' },
+        {'name': 'arg', 'action': 'append' }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -5993,14 +5993,14 @@ class API_Provisioner_Profile_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'profile_type', 'required': True, 'helpmsg': "A profile type must be specified." },
-        { 'name': 'system_template' },
-        { 'name': 'network_template' },
-        { 'name': 'storage_template' },
-        { 'name': 'userdata' },
-        { 'name': 'script' },
-        { 'name': 'ova' },
-        { 'name': 'arg', 'action': 'append' }
+        {'name': 'profile_type', 'required': True, 'helpmsg': "A profile type must be specified." },
+        {'name': 'system_template' },
+        {'name': 'network_template' },
+        {'name': 'storage_template' },
+        {'name': 'userdata' },
+        {'name': 'script' },
+        {'name': 'ova' },
+        {'name': 'arg', 'action': 'append' }
     ])
     @Authenticator
     def post(self, profile, reqargs):
@@ -6077,12 +6077,12 @@ class API_Provisioner_Profile_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'system_template' },
-        { 'name': 'network_template' },
-        { 'name': 'storage_template' },
-        { 'name': 'userdata' },
-        { 'name': 'script' },
-        { 'name': 'arg', 'action': 'append' }
+        {'name': 'system_template' },
+        {'name': 'network_template' },
+        {'name': 'storage_template' },
+        {'name': 'userdata' },
+        {'name': 'script' },
+        {'name': 'arg', 'action': 'append' }
     ])
     @Authenticator
     def put(self, profile, reqargs):
@@ -6172,11 +6172,11 @@ api.add_resource(API_Provisioner_Profile_Element, '/provisioner/profile/<profile
 # /provisioner/create
 class API_Provisioner_Create_Root(Resource):
     @RequestParser([
-        { 'name': 'name', 'required': True, 'helpmsg': "A VM name must be specified." },
-        { 'name': 'profile', 'required': True, 'helpmsg': "A profile name must be specified." },
-        { 'name': 'define_vm' },
-        { 'name': 'start_vm' },
-        { 'name': 'arg', 'action': 'append' }
+        {'name': 'name', 'required': True, 'helpmsg': "A VM name must be specified." },
+        {'name': 'profile', 'required': True, 'helpmsg': "A profile name must be specified." },
+        {'name': 'define_vm' },
+        {'name': 'start_vm' },
+        {'name': 'arg', 'action': 'append' }
     ])
     @Authenticator
     def post(self, reqargs):
@@ -6229,7 +6229,7 @@ class API_Provisioner_Create_Root(Resource):
         # Verify that the profile is valid
         _list, code = api_provisioner.list_profile(reqargs.get('profile', None), is_fuzzy=False)
         if code != 200:
-            return { 'message': 'Profile "{}" is not valid.'.format(reqargs.get('profile')) }, 400
+            return {'message': 'Profile "{}" is not valid.'.format(reqargs.get('profile')) }, 400
 
         if bool(strtobool(reqargs.get('define_vm', 'true'))):
             define_vm = True
@@ -6248,7 +6248,7 @@ class API_Provisioner_Create_Root(Resource):
             start_vm=start_vm,
             script_run_args=reqargs.get('arg', []),
         )
-        return { "task_id": task.id }, 202, { 'Location': Api.url_for(api, API_Provisioner_Status_Element, task_id=task.id) }
+        return {"task_id": task.id }, 202, {'Location': Api.url_for(api, API_Provisioner_Status_Element, task_id=task.id) }
 api.add_resource(API_Provisioner_Create_Root, '/provisioner/create')
 
 # /provisioner/status
diff --git a/api-daemon/pvcapid/helper.py b/api-daemon/pvcapid/helper.py
index e47e29af..2897daf7 100755
--- a/api-daemon/pvcapid/helper.py
+++ b/api-daemon/pvcapid/helper.py
@@ -439,7 +439,7 @@ def vm_define(xml, node, limit, selector, autostart, migration_method):
         xml_data = etree.fromstring(xml)
         new_cfg = etree.tostring(xml_data, pretty_print=True).decode('utf8')
     except Exception as e:
-        return { 'message': 'XML is malformed or incorrect: {}'.format(e) }, 400
+        return {'message': 'XML is malformed or incorrect: {}'.format(e) }, 400
 
     zk_conn = pvc_common.startZKConnection(config['coordinators'])
     retflag, retdata = pvc_vm.define_vm(zk_conn, new_cfg, node, limit, selector, autostart, migration_method, profile=None)
@@ -522,7 +522,7 @@ def vm_modify(name, restart, xml):
         xml_data = etree.fromstring(xml)
         new_cfg = etree.tostring(xml_data, pretty_print=True).decode('utf8')
     except Exception as e:
-        return { 'message': 'XML is malformed or incorrect: {}'.format(e) }, 400
+        return {'message': 'XML is malformed or incorrect: {}'.format(e) }, 400
     zk_conn = pvc_common.startZKConnection(config['coordinators'])
     retflag, retdata = pvc_vm.modify_vm(zk_conn, name, restart, new_cfg)
     pvc_common.stopZKConnection(zk_conn)
@@ -1047,7 +1047,7 @@ def ceph_osd_state(osd):
     in_state = retdata[0]['stats']['in']
     up_state = retdata[0]['stats']['up']
 
-    return { "id": osd, "in": in_state, "up": up_state }, retcode
+    return {"id": osd, "in": in_state, "up": up_state }, retcode
 
 def ceph_osd_add(node, device, weight):
     """
diff --git a/api-daemon/pvcapid/ova.py b/api-daemon/pvcapid/ova.py
index 6ad02bf6..3da28b26 100755
--- a/api-daemon/pvcapid/ova.py
+++ b/api-daemon/pvcapid/ova.py
@@ -103,12 +103,12 @@ def list_ova(limit, is_fuzzy=True):
     if ova_data:
         return ova_data, 200
     else:
-        return { 'message': 'No OVAs found.' }, 404
+        return {'message': 'No OVAs found.' }, 404
 
 def delete_ova(name):
     ova_data, retcode = list_ova(name, is_fuzzy=False)
     if retcode != 200:
-        retmsg = { 'message': 'The OVA "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The OVA "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -146,10 +146,10 @@ def delete_ova(name):
         args = (ova_id,)
         cur.execute(query, args)
 
-        retmsg = { "message": 'Removed OVA image "{}".'.format(name) }
+        retmsg = {"message": 'Removed OVA image "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to remove OVA "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to remove OVA "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
diff --git a/api-daemon/pvcapid/provisioner.py b/api-daemon/pvcapid/provisioner.py
index 1a0d222b..a92beadc 100755
--- a/api-daemon/pvcapid/provisioner.py
+++ b/api-daemon/pvcapid/provisioner.py
@@ -149,7 +149,7 @@ def list_template_system(limit, is_fuzzy=True):
     if data:
         return data, 200
     else:
-        return { 'message': 'No system templates found.' }, 404
+        return {'message': 'No system templates found.' }, 404
 
 def list_template_network(limit, is_fuzzy=True):
     """
@@ -159,7 +159,7 @@ def list_template_network(limit, is_fuzzy=True):
     if data:
         return data, 200
     else:
-        return { 'message': 'No network templates found.' }, 404
+        return {'message': 'No network templates found.' }, 404
 
 def list_template_network_vnis(name):
     """
@@ -170,7 +170,7 @@ def list_template_network_vnis(name):
     if networks:
         return networks, 200
     else:
-        return { 'message': 'No network template networks found.' }, 404
+        return {'message': 'No network template networks found.' }, 404
 
 def list_template_storage(limit, is_fuzzy=True):
     """
@@ -180,7 +180,7 @@ def list_template_storage(limit, is_fuzzy=True):
     if data:
         return data, 200
     else:
-        return { 'message': 'No storage templates found.' }, 404
+        return {'message': 'No storage templates found.' }, 404
 
 def list_template_storage_disks(name):
     """
@@ -191,7 +191,7 @@ def list_template_storage_disks(name):
     if disks:
         return disks, 200
     else:
-        return { 'message': 'No storage template disks found.' }, 404
+        return {'message': 'No storage template disks found.' }, 404
 
 def template_list(limit):
     system_templates, code = list_template_system(limit)
@@ -204,14 +204,14 @@ def template_list(limit):
     if code != 200:
         storage_templates = []
 
-    return { "system_templates": system_templates, "network_templates": network_templates, "storage_templates": storage_templates }
+    return {"system_templates": system_templates, "network_templates": network_templates, "storage_templates": storage_templates }
 
 #
 # Template Create functions
 #
 def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=False, migration_method=None, ova=None):
     if list_template_system(name, is_fuzzy=False)[-1] != 404:
-        retmsg = { 'message': 'The system template "{}" already exists.'.format(name) }
+        retmsg = {'message': 'The system template "{}" already exists.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -221,17 +221,17 @@ def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, v
     conn, cur = open_database(config)
     try:
         cur.execute(query, args)
-        retmsg = { 'message': 'Added new system template "{}".'.format(name) }
+        retmsg = {'message': 'Added new system template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create system template "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to create system template "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def create_template_network(name, mac_template=None):
     if list_template_network(name, is_fuzzy=False)[-1] != 404:
-        retmsg = { 'message': 'The network template "{}" already exists.'.format(name) }
+        retmsg = {'message': 'The network template "{}" already exists.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -240,17 +240,17 @@ def create_template_network(name, mac_template=None):
         query = "INSERT INTO network_template (name, mac_template) VALUES (%s, %s);"
         args = (name, mac_template)
         cur.execute(query, args)
-        retmsg = { 'message': 'Added new network template "{}".'.format(name) }
+        retmsg = {'message': 'Added new network template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create network template "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to create network template "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def create_template_network_element(name, vni):
     if list_template_network(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The network template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The network template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -262,7 +262,7 @@ def create_template_network_element(name, vni):
         if int(network['vni']) == int(vni):
             found_vni = True
     if found_vni:
-        retmsg = { 'message': 'The VNI "{}" in network template "{}" already exists.'.format(vni, name) }
+        retmsg = {'message': 'The VNI "{}" in network template "{}" already exists.'.format(vni, name) }
         retcode = 400
         return retmsg, retcode
 
@@ -275,17 +275,17 @@ def create_template_network_element(name, vni):
         query = "INSERT INTO network (network_template, vni) VALUES (%s, %s);"
         args = (template_id, vni)
         cur.execute(query, args)
-        retmsg = { 'message': 'Added new network "{}" to network template "{}".'.format(vni, name) }
+        retmsg = {'message': 'Added new network "{}" to network template "{}".'.format(vni, name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create entry "{}": {}'.format(vni, e) }
+        retmsg = {'message': 'Failed to create entry "{}": {}'.format(vni, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def create_template_storage(name):
     if list_template_storage(name, is_fuzzy=False)[-1] != 404:
-        retmsg = { 'message': 'The storage template "{}" already exists.'.format(name) }
+        retmsg = {'message': 'The storage template "{}" already exists.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -294,17 +294,17 @@ def create_template_storage(name):
         query = "INSERT INTO storage_template (name) VALUES (%s);"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { 'message': 'Added new storage template "{}".'.format(name) }
+        retmsg = {'message': 'Added new storage template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def create_template_storage_element(name, disk_id, pool, source_volume=None, disk_size_gb=None, filesystem=None, filesystem_args=[], mountpoint=None):
     if list_template_storage(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The storage template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The storage template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -316,17 +316,17 @@ def create_template_storage_element(name, disk_id, pool, source_volume=None, dis
         if disk['disk_id'] == disk_id:
             found_disk = True
     if found_disk:
-        retmsg = { 'message': 'The disk "{}" in storage template "{}" already exists.'.format(disk_id, name) }
+        retmsg = {'message': 'The disk "{}" in storage template "{}" already exists.'.format(disk_id, name) }
         retcode = 400
         return retmsg, retcode
 
     if mountpoint and not filesystem:
-        retmsg = { "message": "A filesystem must be specified along with a mountpoint." }
+        retmsg = {"message": "A filesystem must be specified along with a mountpoint." }
         retcode = 400
         return retmsg, retcode
 
     if source_volume and (disk_size_gb or filesystem or mountpoint):
-        retmsg = { "message": "Clone volumes are not compatible with disk size, filesystem, or mountpoint specifications." }
+        retmsg = {"message": "Clone volumes are not compatible with disk size, filesystem, or mountpoint specifications." }
         retcode = 400
         return retmsg, retcode
 
@@ -343,10 +343,10 @@ def create_template_storage_element(name, disk_id, pool, source_volume=None, dis
             fsargs = ''
         args = (template_id, pool, disk_id, source_volume, disk_size_gb, mountpoint, filesystem, fsargs)
         cur.execute(query, args)
-        retmsg = { 'message': 'Added new disk "{}" to storage template "{}".'.format(disk_id, name) }
+        retmsg = {'message': 'Added new disk "{}" to storage template "{}".'.format(disk_id, name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create entry "{}": {}'.format(disk_id, e) }
+        retmsg = {'message': 'Failed to create entry "{}": {}'.format(disk_id, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
@@ -356,7 +356,7 @@ def create_template_storage_element(name, disk_id, pool, source_volume=None, dis
 #
 def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc=None, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=None, migration_method=None):
     if list_template_system(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The system template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The system template "{}" does not exist.'.format(name) }
         retcode = 404
         return retmsg, retcode
 
@@ -366,7 +366,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
         try:
             vcpu_count = int(vcpu_count)
         except Exception:
-            retmsg = { 'message': 'The vcpus value must be an integer.' }
+            retmsg = {'message': 'The vcpus value must be an integer.' }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'vcpu_count', 'data': vcpu_count})
@@ -375,7 +375,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
         try:
             vram_mb = int(vram_mb)
         except Exception:
-            retmsg = { 'message': 'The vram value must be an integer.' }
+            retmsg = {'message': 'The vram value must be an integer.' }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'vram_mb', 'data': vram_mb})
@@ -384,7 +384,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
         try:
             serial = bool(strtobool(serial))
         except Exception:
-            retmsg = { 'message': 'The serial value must be a boolean.' }
+            retmsg = {'message': 'The serial value must be a boolean.' }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'serial', 'data': serial})
@@ -393,7 +393,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
         try:
             vnc = bool(strtobool(vnc))
         except Exception:
-            retmsg = { 'message': 'The vnc value must be a boolean.' }
+            retmsg = {'message': 'The vnc value must be a boolean.' }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'vnc', 'data': vnc})
@@ -411,7 +411,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
         try:
             node_autostart = bool(strtobool(node_autostart))
         except Exception:
-            retmsg = { 'message': 'The node_autostart value must be a boolean.' }
+            retmsg = {'message': 'The node_autostart value must be a boolean.' }
             retcode = 400
         fields.append({'field': 'node_autostart', 'data': node_autostart})
 
@@ -424,10 +424,10 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
             query = "UPDATE system_template SET {} = %s WHERE name = %s;".format(field.get('field'))
             args = (field.get('data'), name)
             cur.execute(query, args)
-        retmsg = { "message": 'Modified system template "{}".'.format(name) }
+        retmsg = {"message": 'Modified system template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to modify entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to modify entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
@@ -437,7 +437,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
 #
 def delete_template_system(name):
     if list_template_system(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The system template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The system template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -446,17 +446,17 @@ def delete_template_system(name):
         query = "DELETE FROM system_template WHERE name = %s;"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed system template "{}".'.format(name) }
+        retmsg = {"message": 'Removed system template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_template_network(name):
     if list_template_network(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The network template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The network template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -472,17 +472,17 @@ def delete_template_network(name):
         query = "DELETE FROM network_template WHERE name = %s;"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed network template "{}".'.format(name) }
+        retmsg = {"message": 'Removed network template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_template_network_element(name, vni):
     if list_template_network(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The network template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The network template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -492,7 +492,7 @@ def delete_template_network_element(name, vni):
         if network['vni'] == int(vni):
             found_vni = True
     if not found_vni:
-        retmsg = { 'message': 'The VNI "{}" in network template "{}" does not exist.'.format(vni, name) }
+        retmsg = {'message': 'The VNI "{}" in network template "{}" does not exist.'.format(vni, name) }
         retcode = 400
         return retmsg, retcode
 
@@ -505,17 +505,17 @@ def delete_template_network_element(name, vni):
         query = "DELETE FROM network WHERE network_template = %s and vni = %s;"
         args = (template_id, vni)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed network "{}" from network template "{}".'.format(vni, name) }
+        retmsg = {"message": 'Removed network "{}" from network template "{}".'.format(vni, name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_template_storage(name):
     if list_template_storage(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The storage template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The storage template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -531,17 +531,17 @@ def delete_template_storage(name):
         query = "DELETE FROM storage_template WHERE name = %s;"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed storage template "{}".'.format(name) }
+        retmsg = {"message": 'Removed storage template "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_template_storage_element(name, disk_id):
     if list_template_storage(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The storage template "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The storage template "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -551,7 +551,7 @@ def delete_template_storage_element(name, disk_id):
         if disk['disk_id'] == disk_id:
             found_disk = True
     if not found_disk:
-        retmsg = { 'message': 'The disk "{}" in storage template "{}" does not exist.'.format(disk_id, name) }
+        retmsg = {'message': 'The disk "{}" in storage template "{}" does not exist.'.format(disk_id, name) }
         retcode = 400
         return retmsg, retcode
 
@@ -564,10 +564,10 @@ def delete_template_storage_element(name, disk_id):
         query = "DELETE FROM storage WHERE storage_template = %s and disk_id = %s;"
         args = (template_id, disk_id)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed disk "{}" from storage template "{}".'.format(disk_id, name) }
+        retmsg = {"message": 'Removed disk "{}" from storage template "{}".'.format(disk_id, name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
@@ -601,11 +601,11 @@ def list_userdata(limit, is_fuzzy=True):
     if data:
         return data, 200
     else:
-        return { 'message': 'No userdata documents found.' }, 404
+        return {'message': 'No userdata documents found.' }, 404
 
 def create_userdata(name, userdata):
     if list_userdata(name, is_fuzzy=False)[-1] != 404:
-        retmsg = { 'message': 'The userdata document "{}" already exists.'.format(name) }
+        retmsg = {'message': 'The userdata document "{}" already exists.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -614,17 +614,17 @@ def create_userdata(name, userdata):
         query = "INSERT INTO userdata (name, userdata) VALUES (%s, %s);"
         args = (name, userdata)
         cur.execute(query, args)
-        retmsg = { "message": 'Created userdata document "{}".'.format(name) }
+        retmsg = {"message": 'Created userdata document "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def update_userdata(name, userdata):
     if list_userdata(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The userdata "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The userdata "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -636,17 +636,17 @@ def update_userdata(name, userdata):
         query = "UPDATE userdata SET userdata = %s WHERE id = %s;"
         args = (userdata, tid)
         cur.execute(query, args)
-        retmsg = { "message": 'Updated userdata document "{}".'.format(name) }
+        retmsg = {"message": 'Updated userdata document "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to update entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to update entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_userdata(name):
     if list_userdata(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The userdata "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The userdata "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -655,10 +655,10 @@ def delete_userdata(name):
         query = "DELETE FROM userdata WHERE name = %s;"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed userdata document "{}".'.format(name) }
+        retmsg = {"message": 'Removed userdata document "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
@@ -692,11 +692,11 @@ def list_script(limit, is_fuzzy=True):
     if data:
         return data, 200
     else:
-        return { 'message': 'No scripts found.' }, 404
+        return {'message': 'No scripts found.' }, 404
 
 def create_script(name, script):
     if list_script(name, is_fuzzy=False)[-1] != 404:
-        retmsg = { 'message': 'The script "{}" already exists.'.format(name) }
+        retmsg = {'message': 'The script "{}" already exists.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -705,17 +705,17 @@ def create_script(name, script):
         query = "INSERT INTO script (name, script) VALUES (%s, %s);"
         args = (name, script)
         cur.execute(query, args)
-        retmsg = { "message": 'Created provisioning script "{}".'.format(name) }
+        retmsg = {"message": 'Created provisioning script "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def update_script(name, script):
     if list_script(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The script "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The script "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -727,17 +727,17 @@ def update_script(name, script):
         query = "UPDATE script SET script = %s WHERE id = %s;"
         args = (script, tid)
         cur.execute(query, args)
-        retmsg = { "message": 'Updated provisioning script "{}".'.format(name) }
+        retmsg = {"message": 'Updated provisioning script "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to update entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to update entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_script(name):
     if list_script(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The script "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The script "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -746,10 +746,10 @@ def delete_script(name):
         query = "DELETE FROM script WHERE name = %s;"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed provisioning script "{}".'.format(name) }
+        retmsg = {"message": 'Removed provisioning script "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
@@ -803,16 +803,16 @@ def list_profile(limit, is_fuzzy=True):
     if data:
         return data, 200
     else:
-        return { 'message': 'No profiles found.' }, 404
+        return {'message': 'No profiles found.' }, 404
 
 def create_profile(name, profile_type, system_template, network_template, storage_template, userdata=None, script=None, ova=None, arguments=None):
     if list_profile(name, is_fuzzy=False)[-1] != 404:
-        retmsg = { 'message': 'The profile "{}" already exists.'.format(name) }
+        retmsg = {'message': 'The profile "{}" already exists.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
     if profile_type not in ['provisioner', 'ova']:
-        retmsg = { 'message': 'A valid profile type (provisioner, ova) must be specified.' }
+        retmsg = {'message': 'A valid profile type (provisioner, ova) must be specified.' }
         retcode = 400
         return retmsg, retcode
 
@@ -824,7 +824,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
         if template['name'] == system_template:
             system_template_id = template['id']
     if not system_template_id:
-        retmsg = { 'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) }
+        retmsg = {'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) }
         retcode = 400
         return retmsg, retcode
 
@@ -836,7 +836,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
         if template['name'] == network_template:
             network_template_id = template['id']
     if not network_template_id and profile_type != 'ova':
-        retmsg = { 'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) }
+        retmsg = {'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) }
         retcode = 400
         return retmsg, retcode
 
@@ -848,7 +848,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
         if template['name'] == storage_template:
             storage_template_id = template['id']
     if not storage_template_id and profile_type != 'ova':
-        retmsg = { 'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) }
+        retmsg = {'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) }
         retcode = 400
         return retmsg, retcode
 
@@ -886,17 +886,17 @@ def create_profile(name, profile_type, system_template, network_template, storag
         query = "INSERT INTO profile (name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);"
         args = (name, profile_type, system_template_id, network_template_id, storage_template_id, userdata_id, script_id, ova_id, arguments_formatted)
         cur.execute(query, args)
-        retmsg = { "message": 'Created VM profile "{}".'.format(name) }
+        retmsg = {"message": 'Created VM profile "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def modify_profile(name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments=None):
     if list_profile(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The profile "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The profile "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -904,7 +904,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
 
     if profile_type is not None:
         if profile_type not in ['provisioner', 'ova']:
-            retmsg = { 'message': 'A valid profile type (provisioner, ova) must be specified.' }
+            retmsg = {'message': 'A valid profile type (provisioner, ova) must be specified.' }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'type', 'data': profile_type})
@@ -916,7 +916,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             if template['name'] == system_template:
                 system_template_id = template['id']
         if not system_template_id:
-            retmsg = { 'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) }
+            retmsg = {'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'system_template', 'data': system_template_id})
@@ -928,7 +928,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             if template['name'] == network_template:
                 network_template_id = template['id']
         if not network_template_id:
-            retmsg = { 'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) }
+            retmsg = {'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'network_template', 'data': network_template_id})
@@ -940,7 +940,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             if template['name'] == storage_template:
                 storage_template_id = template['id']
         if not storage_template_id:
-            retmsg = { 'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) }
+            retmsg = {'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'storage_template', 'data': storage_template_id})
@@ -952,7 +952,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             if template['name'] == userdata:
                 userdata_id = template['id']
         if not userdata_id:
-            retmsg = { 'message': 'The userdata template "{}" for profile "{}" does not exist.'.format(userdata, name) }
+            retmsg = {'message': 'The userdata template "{}" for profile "{}" does not exist.'.format(userdata, name) }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'userdata', 'data': userdata_id})
@@ -964,7 +964,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             if scr['name'] == script:
                 script_id = scr['id']
         if not script_id:
-            retmsg = { 'message': 'The script "{}" for profile "{}" does not exist.'.format(script, name) }
+            retmsg = {'message': 'The script "{}" for profile "{}" does not exist.'.format(script, name) }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'script', 'data': script_id})
@@ -976,7 +976,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             if ov['name'] == ova:
                 ova_id = ov['id']
         if not ova_id:
-            retmsg = { 'message': 'The OVA "{}" for profile "{}" does not exist.'.format(ova, name) }
+            retmsg = {'message': 'The OVA "{}" for profile "{}" does not exist.'.format(ova, name) }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'ova', 'data': ova_id})
@@ -994,17 +994,17 @@ def modify_profile(name, profile_type, system_template, network_template, storag
             query = "UPDATE profile SET {}=%s WHERE name=%s;".format(field.get('field'))
             args = (field.get('data'), name)
             cur.execute(query, args)
-        retmsg = { "message": 'Modified VM profile "{}".'.format(name) }
+        retmsg = {"message": 'Modified VM profile "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to modify entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to modify entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
 
 def delete_profile(name):
     if list_profile(name, is_fuzzy=False)[-1] != 200:
-        retmsg = { 'message': 'The profile "{}" does not exist.'.format(name) }
+        retmsg = {'message': 'The profile "{}" does not exist.'.format(name) }
         retcode = 400
         return retmsg, retcode
 
@@ -1013,10 +1013,10 @@ def delete_profile(name):
         query = "DELETE FROM profile WHERE name = %s;"
         args = (name,)
         cur.execute(query, args)
-        retmsg = { "message": 'Removed VM profile "{}".'.format(name) }
+        retmsg = {"message": 'Removed VM profile "{}".'.format(name) }
         retcode = 200
     except Exception as e:
-        retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) }
+        retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
         retcode = 400
     close_database(conn, cur)
     return retmsg, retcode
diff --git a/client-cli/cli_lib/ceph.py b/client-cli/cli_lib/ceph.py
index 1518bc2d..48b54e39 100644
--- a/client-cli/cli_lib/ceph.py
+++ b/client-cli/cli_lib/ceph.py
@@ -874,7 +874,7 @@ def ceph_volume_upload(config, pool, volume, image_format, image_file):
 
     bar = UploadProgressBar(image_file, end_message="Parsing file on remote side...", end_nl=False)
     upload_data = MultipartEncoder(
-        fields={ 'file': ('filename', open(image_file, 'rb'), 'application/octet-stream')}
+        fields={'file': ('filename', open(image_file, 'rb'), 'application/octet-stream')}
     )
     upload_monitor = MultipartEncoderMonitor(upload_data, bar.update)
 
diff --git a/client-cli/cli_lib/provisioner.py b/client-cli/cli_lib/provisioner.py
index c70201cb..a8c40b81 100644
--- a/client-cli/cli_lib/provisioner.py
+++ b/client-cli/cli_lib/provisioner.py
@@ -432,7 +432,7 @@ def ova_upload(config, name, ova_file, params):
 
     bar = UploadProgressBar(ova_file, end_message="Parsing file on remote side...", end_nl=False)
     upload_data = MultipartEncoder(
-        fields={ 'file': ('filename', open(ova_file, 'rb'), 'application/octet-stream')}
+        fields={'file': ('filename', open(ova_file, 'rb'), 'application/octet-stream')}
     )
     upload_monitor = MultipartEncoderMonitor(upload_data, bar.update)
 
diff --git a/client-cli/pvc.py b/client-cli/pvc.py
index ed29e44d..c3163727 100755
--- a/client-cli/pvc.py
+++ b/client-cli/pvc.py
@@ -85,7 +85,7 @@ def get_config(store_data, cluster=None):
         if os.path.isfile(cfgfile):
             host, port, scheme, api_key = read_from_yaml(cfgfile)
         else:
-            return { 'badcfg': True }
+            return {'badcfg': True }
         # Handle an all-wildcard address
         if host == '0.0.0.0':
             host = '127.0.0.1'
diff --git a/daemon-common/cluster.py b/daemon-common/cluster.py
index ea7a8d67..55395d9e 100644
--- a/daemon-common/cluster.py
+++ b/daemon-common/cluster.py
@@ -144,8 +144,8 @@ def getClusterInformation(zk_conn):
         except KeyError:
             ceph_osd_in = 0
 
-        up_texts = { 1: 'up', 0: 'down' }
-        in_texts = { 1: 'in', 0: 'out' }
+        up_texts = {1: 'up', 0: 'down' }
+        in_texts = {1: 'in', 0: 'out' }
 
         if not ceph_osd_up or not ceph_osd_in:
             ceph_osd_healthy_status[index] = False
diff --git a/daemon-common/common.py b/daemon-common/common.py
index 3fb622a2..039f481e 100644
--- a/daemon-common/common.py
+++ b/daemon-common/common.py
@@ -373,7 +373,7 @@ def getDomainControllers(parsed_xml):
                 controller_model = device.attrib.get('model')
             except KeyError:
                 controller_model = 'none'
-            controller_obj = { 'type': controller_type, 'model': controller_model }
+            controller_obj = {'type': controller_type, 'model': controller_model }
             dcontrollers.append(controller_obj)
 
     return dcontrollers
diff --git a/daemon-common/vm.py b/daemon-common/vm.py
index e9332b60..752670cc 100644
--- a/daemon-common/vm.py
+++ b/daemon-common/vm.py
@@ -274,7 +274,7 @@ def modify_vm(zk_conn, domain, restart, new_vm_config):
     if restart:
         lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
         lock.acquire()
-        zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'restart' })
+        zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'restart' })
         lock.release()
 
     return True, ''
@@ -301,7 +301,7 @@ def undefine_vm(zk_conn, domain):
         # Set the domain into stop mode
         lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
         lock.acquire()
-        zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'stop' })
+        zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'stop' })
         lock.release()
 
         # Wait for 2 seconds to allow state to flow to all nodes
@@ -330,7 +330,7 @@ def remove_vm(zk_conn, domain):
         # Set the domain into stop mode
         lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
         lock.acquire()
-        zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'stop' })
+        zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'stop' })
         lock.release()
 
         # Wait for 2 seconds to allow state to flow to all nodes
@@ -364,7 +364,7 @@ def start_vm(zk_conn, domain):
     # Set the VM to start
     lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
     lock.acquire()
-    zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'start' })
+    zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'start' })
     lock.release()
 
     return True, 'Starting VM "{}".'.format(domain)
@@ -385,7 +385,7 @@ def restart_vm(zk_conn, domain, wait=False):
     # Set the VM to restart
     lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
     lock.acquire()
-    zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'restart' })
+    zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'restart' })
     lock.release()
 
     if wait:
@@ -411,7 +411,7 @@ def shutdown_vm(zk_conn, domain, wait=False):
     # Set the VM to shutdown
     lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
     lock.acquire()
-    zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'shutdown' })
+    zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'shutdown' })
     lock.release()
 
     if wait:
@@ -430,7 +430,7 @@ def stop_vm(zk_conn, domain):
     # Set the VM to start
     lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
     lock.acquire()
-    zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'stop' })
+    zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'stop' })
     lock.release()
 
     return True, 'Forcibly stopping VM "{}".'.format(domain)
@@ -449,7 +449,7 @@ def disable_vm(zk_conn, domain):
     # Set the VM to start
     lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
     lock.acquire()
-    zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'disable' })
+    zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'disable' })
     lock.release()
 
     return True, 'Marked VM "{}" as disable.'.format(domain)
diff --git a/node-daemon/pvcnoded/Daemon.py b/node-daemon/pvcnoded/Daemon.py
index 93569658..0a38f8d3 100644
--- a/node-daemon/pvcnoded/Daemon.py
+++ b/node-daemon/pvcnoded/Daemon.py
@@ -557,7 +557,7 @@ def cleanup():
     logger.out('Terminating pvcnoded and cleaning up', state='s')
 
     # Set shutdown state in Zookeeper
-    zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(myhostname): 'shutdown' })
+    zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(myhostname): 'shutdown' })
 
     # Waiting for any flushes to complete
     logger.out('Waiting for any active flushes', state='s')
@@ -599,7 +599,7 @@ def cleanup():
     node_keepalive()
 
     # Set stop state in Zookeeper
-    zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(myhostname): 'stop' })
+    zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(myhostname): 'stop' })
 
     # Forcibly terminate dnsmasq because it gets stuck sometimes
     common.run_os_command('killall dnsmasq')
@@ -690,7 +690,7 @@ if current_primary and current_primary != 'none':
 else:
     if config['daemon_mode'] == 'coordinator':
         logger.out('No primary node found; creating with us as primary.', state='i')
-        zkhandler.writedata(zk_conn, { '/primary_node': myhostname })
+        zkhandler.writedata(zk_conn, {'/primary_node': myhostname })
 
 ###############################################################################
 # PHASE 7a - Ensure IPMI is reachable and working
@@ -742,8 +742,8 @@ if enable_networking:
     flush ruleset
     # Add the filter table and chains
     add table inet filter
-    add chain inet filter forward {{ type filter hook forward priority 0; }}
-    add chain inet filter input {{ type filter hook input priority 0; }}
+    add chain inet filter forward {{type filter hook forward priority 0; }}
+    add chain inet filter input {{type filter hook input priority 0; }}
     # Include static rules and network rules
     include "{rulesdir}/static/*"
     include "{rulesdir}/networks/*"
@@ -1042,7 +1042,7 @@ def collect_ceph_stats(queue):
         logger.out("Getting health stats from monitor", state='d', prefix='ceph-thread')
 
     # Get Ceph cluster health for local status output
-    command = { "prefix": "health", "format": "json" }
+    command = {"prefix": "health", "format": "json" }
     try:
         health_status = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])
         ceph_health = health_status['status']
@@ -1062,7 +1062,7 @@ def collect_ceph_stats(queue):
         if debug:
             logger.out("Set ceph health information in zookeeper (primary only)", state='d', prefix='ceph-thread')
 
-        command = { "prefix": "status", "format": "pretty" }
+        command = {"prefix": "status", "format": "pretty" }
         ceph_status = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii')
         try:
             zkhandler.writedata(zk_conn, {
@@ -1076,7 +1076,7 @@ def collect_ceph_stats(queue):
             logger.out("Set ceph rados df information in zookeeper (primary only)", state='d', prefix='ceph-thread')
 
         # Get rados df info
-        command = { "prefix": "df", "format": "pretty" }
+        command = {"prefix": "df", "format": "pretty" }
         ceph_df = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii')
         try:
             zkhandler.writedata(zk_conn, {
@@ -1090,7 +1090,7 @@ def collect_ceph_stats(queue):
             logger.out("Set pool information in zookeeper (primary only)", state='d', prefix='ceph-thread')
 
         # Get pool info
-        command = { "prefix": "df", "format": "json" }
+        command = {"prefix": "df", "format": "json" }
         try:
             ceph_pool_df_raw = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])['pools']
         except Exception as e:
@@ -1161,7 +1161,7 @@ def collect_ceph_stats(queue):
         # Parse the dump data
         osd_dump = dict()
 
-        command = { "prefix": "osd dump", "format": "json" }
+        command = {"prefix": "osd dump", "format": "json" }
         try:
             retcode, stdout, stderr = common.run_os_command('ceph osd dump --format json --connect-timeout 2', timeout=2)
             osd_dump_raw = json.loads(stdout)['osds']
@@ -1187,7 +1187,7 @@ def collect_ceph_stats(queue):
 
         osd_df = dict()
 
-        command = { "prefix": "osd df", "format": "json" }
+        command = {"prefix": "osd df", "format": "json" }
         try:
             osd_df_raw = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])['nodes']
         except Exception as e:
@@ -1214,7 +1214,7 @@ def collect_ceph_stats(queue):
 
         osd_status = dict()
 
-        command = { "prefix": "osd status", "format": "pretty" }
+        command = {"prefix": "osd status", "format": "pretty" }
         try:
             osd_status_raw = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii')
         except Exception as e:
@@ -1341,7 +1341,7 @@ def collect_vm_stats(queue):
                             raise
                     except Exception:
                         # Toggle a state "change"
-                        zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(domain): instance.getstate() })
+                        zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(domain): instance.getstate() })
         elif instance.getnode() == this_node.name:
             memprov += instance.getmemory()
 
@@ -1469,7 +1469,7 @@ def node_keepalive():
     past_state = zkhandler.readdata(zk_conn, '/nodes/{}/daemonstate'.format(this_node.name))
     if past_state != 'run':
         this_node.daemon_state = 'run'
-        zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(this_node.name): 'run' })
+        zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(this_node.name): 'run' })
     else:
         this_node.daemon_state = 'run'
 
@@ -1638,7 +1638,7 @@ def node_keepalive():
                             fence_thread = Thread(target=fencing.fenceNode, args=(node_name, zk_conn, config, logger), kwargs={})
                             fence_thread.start()
                             # Write the updated data after we start the fence thread
-                            zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(node_name): 'dead' })
+                            zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(node_name): 'dead' })
 
     if debug:
         logger.out("Keepalive finished", state='d', prefix='main-thread')
diff --git a/node-daemon/pvcnoded/NodeInstance.py b/node-daemon/pvcnoded/NodeInstance.py
index 104eef9f..f514ff1a 100644
--- a/node-daemon/pvcnoded/NodeInstance.py
+++ b/node-daemon/pvcnoded/NodeInstance.py
@@ -646,8 +646,8 @@ class NodeInstance(object):
 
             if target_node is None:
                 self.logger.out('Failed to find migration target for VM "{}"; shutting down and setting autostart flag'.format(dom_uuid), state='e')
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(dom_uuid): 'shutdown' })
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/node_autostart'.format(dom_uuid): 'True' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(dom_uuid): 'shutdown' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/node_autostart'.format(dom_uuid): 'True' })
             else:
                 self.logger.out('Migrating VM "{}" to node "{}"'.format(dom_uuid, target_node), state='i')
                 zkhandler.writedata(self.zk_conn, {
@@ -665,8 +665,8 @@ class NodeInstance(object):
                     break
                 time.sleep(0.2)
 
-        zkhandler.writedata(self.zk_conn, { '/nodes/{}/runningdomains'.format(self.name): '' })
-        zkhandler.writedata(self.zk_conn, { '/nodes/{}/domainstate'.format(self.name): 'flushed' })
+        zkhandler.writedata(self.zk_conn, {'/nodes/{}/runningdomains'.format(self.name): '' })
+        zkhandler.writedata(self.zk_conn, {'/nodes/{}/domainstate'.format(self.name): 'flushed' })
         self.flush_thread = None
         self.flush_stopper = False
         return
@@ -714,7 +714,7 @@ class NodeInstance(object):
             while zkhandler.readdata(self.zk_conn, '/domains/{}/state'.format(dom_uuid)) in ['migrate', 'unmigrate', 'shutdown']:
                 time.sleep(0.1)
 
-        zkhandler.writedata(self.zk_conn, { '/nodes/{}/domainstate'.format(self.name): 'ready' })
+        zkhandler.writedata(self.zk_conn, {'/nodes/{}/domainstate'.format(self.name): 'ready' })
         self.flush_thread = None
         self.flush_stopper = False
         return
diff --git a/node-daemon/pvcnoded/VMConsoleWatcherInstance.py b/node-daemon/pvcnoded/VMConsoleWatcherInstance.py
index e9b7470f..367fa542 100644
--- a/node-daemon/pvcnoded/VMConsoleWatcherInstance.py
+++ b/node-daemon/pvcnoded/VMConsoleWatcherInstance.py
@@ -86,7 +86,7 @@ class VMConsoleWatcherInstance(object):
             self.fetch_lines()
         # Update Zookeeper with the new loglines if they changed
         if self.loglines != self.last_loglines:
-            zkhandler.writedata(self.zk_conn, { '/domains/{}/consolelog'.format(self.domuuid): self.loglines })
+            zkhandler.writedata(self.zk_conn, {'/domains/{}/consolelog'.format(self.domuuid): self.loglines })
             self.last_loglines = self.loglines
 
     def fetch_lines(self):
diff --git a/node-daemon/pvcnoded/VMInstance.py b/node-daemon/pvcnoded/VMInstance.py
index 84b5e7bf..98e07bae 100644
--- a/node-daemon/pvcnoded/VMInstance.py
+++ b/node-daemon/pvcnoded/VMInstance.py
@@ -185,7 +185,7 @@ class VMInstance(object):
                 # Add the domain to the domain_list array
                 self.this_node.domain_list.append(self.domuuid)
                 # Push the change up to Zookeeper
-                zkhandler.writedata(self.zk_conn, { '/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) })
+                zkhandler.writedata(self.zk_conn, {'/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) })
             except Exception as e:
                 self.logger.out('Error adding domain to list: {}'.format(e), state='e')
 
@@ -195,7 +195,7 @@ class VMInstance(object):
                 # Remove the domain from the domain_list array
                 self.this_node.domain_list.remove(self.domuuid)
                 # Push the change up to Zookeeper
-                zkhandler.writedata(self.zk_conn, { '/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) })
+                zkhandler.writedata(self.zk_conn, {'/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) })
             except Exception as e:
                 self.logger.out('Error removing domain from list: {}'.format(e), state='e')
 
@@ -225,7 +225,7 @@ class VMInstance(object):
         if curstate == libvirt.VIR_DOMAIN_RUNNING:
             # If it is running just update the model
             self.addDomainToList()
-            zkhandler.writedata(self.zk_conn, { '/domains/{}/failedreason'.format(self.domuuid): '' })
+            zkhandler.writedata(self.zk_conn, {'/domains/{}/failedreason'.format(self.domuuid): '' })
         else:
             # Or try to create it
             try:
@@ -235,11 +235,11 @@ class VMInstance(object):
                 self.addDomainToList()
                 self.logger.out('Successfully started VM', state='o', prefix='Domain {}'.format(self.domuuid))
                 self.dom = dom
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/failedreason'.format(self.domuuid): '' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/failedreason'.format(self.domuuid): '' })
             except libvirt.libvirtError as e:
                 self.logger.out('Failed to create VM', state='e', prefix='Domain {}'.format(self.domuuid))
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'fail' })
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/failedreason'.format(self.domuuid): str(e) })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'fail' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/failedreason'.format(self.domuuid): str(e) })
                 self.dom = None
 
         lv_conn.close()
@@ -264,7 +264,7 @@ class VMInstance(object):
         self.start_vm()
         self.addDomainToList()
 
-        zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' })
+        zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
         lv_conn.close()
         self.inrestart = False
 
@@ -295,7 +295,7 @@ class VMInstance(object):
         self.removeDomainFromList()
 
         if self.inrestart is False:
-            zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'stop' })
+            zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'stop' })
 
         self.logger.out('Successfully stopped VM', state='o', prefix='Domain {}'.format(self.domuuid))
         self.dom = None
@@ -329,7 +329,7 @@ class VMInstance(object):
 
             if lvdomstate != libvirt.VIR_DOMAIN_RUNNING:
                 self.removeDomainFromList()
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'stop' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'stop' })
                 self.logger.out('Successfully shutdown VM', state='o', prefix='Domain {}'.format(self.domuuid))
                 self.dom = None
                 # Stop the log watcher
@@ -338,7 +338,7 @@ class VMInstance(object):
 
             if tick >= self.config['vm_shutdown_timeout']:
                 self.logger.out('Shutdown timeout ({}s) expired, forcing off'.format(self.config['vm_shutdown_timeout']), state='e', prefix='Domain {}'.format(self.domuuid))
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'stop' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'stop' })
                 break
 
         self.inshutdown = False
@@ -349,7 +349,7 @@ class VMInstance(object):
         if self.inrestart:
             # Wait to prevent race conditions
             time.sleep(1)
-            zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' })
+            zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
 
     # Migrate the VM to a target host
     def migrate_vm(self, force_live=False, force_shutdown=False):
@@ -458,7 +458,7 @@ class VMInstance(object):
 
         def migrate_shutdown():
             self.logger.out('Shutting down VM for offline migration', state='i', prefix='Domain {}'.format(self.domuuid))
-            zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'shutdown' })
+            zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'shutdown' })
             while zkhandler.readdata(self.zk_conn, '/domains/{}/state'.format(self.domuuid)) != 'stop':
                 time.sleep(0.5)
             return True
@@ -551,7 +551,7 @@ class VMInstance(object):
         self.logger.out('Receiving VM migration from node "{}"'.format(self.node), state='i', prefix='Domain {}'.format(self.domuuid))
 
         # Ensure our lock key is populated
-        zkhandler.writedata(self.zk_conn, { '/locks/domain_migrate/{}'.format(self.domuuid): self.domuuid })
+        zkhandler.writedata(self.zk_conn, {'/locks/domain_migrate/{}'.format(self.domuuid): self.domuuid })
 
         # Synchronize nodes A (I am writer)
         lock = zkhandler.writelock(self.zk_conn, '/locks/domain_migrate/{}'.format(self.domuuid))
@@ -601,11 +601,11 @@ class VMInstance(object):
             if lvdomstate == libvirt.VIR_DOMAIN_RUNNING:
                 # VM has been received and started
                 self.addDomainToList()
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
                 self.logger.out('Successfully received migrated VM', state='o', prefix='Domain {}'.format(self.domuuid))
             else:
                 # The receive somehow failed
-                zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'fail' })
+                zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'fail' })
         else:
             if self.node == self.this_node.name:
                 if self.state in ['start']:
@@ -613,7 +613,7 @@ class VMInstance(object):
                     self.logger.out('Receive aborted via state change', state='w', prefix='Domain {}'.format(self.domuuid))
                 elif self.state in ['stop']:
                     # The send was shutdown-based
-                    zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' })
+                    zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
                 else:
                     # The send failed or was aborted
                     self.logger.out('Migrate aborted or failed; VM in state {}'.format(self.state), state='w', prefix='Domain {}'.format(self.domuuid))
@@ -622,7 +622,7 @@ class VMInstance(object):
         lock.release()
         self.logger.out('Released write lock for synchronization phase D', state='o', prefix='Domain {}'.format(self.domuuid))
 
-        zkhandler.writedata(self.zk_conn, { '/locks/domain_migrate/{}'.format(self.domuuid): '' })
+        zkhandler.writedata(self.zk_conn, {'/locks/domain_migrate/{}'.format(self.domuuid): '' })
         self.inreceive = False
         return
 
@@ -681,7 +681,7 @@ class VMInstance(object):
                     elif self.state == "migrate" or self.state == "migrate-live":
                         # Start the log watcher
                         self.console_log_instance.start()
-                        zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' })
+                        zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
                         # Add domain to running list
                         self.addDomainToList()
                     # VM should be restarted
@@ -704,7 +704,7 @@ class VMInstance(object):
                         self.receive_migrate()
                     # VM should be restarted (i.e. started since it isn't running)
                     if self.state == "restart":
-                        zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' })
+                        zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
                     # VM should be shut down; ensure it's gone from this node's domain_list
                     elif self.state == "shutdown":
                         self.removeDomainFromList()
diff --git a/node-daemon/pvcnoded/common.py b/node-daemon/pvcnoded/common.py
index d39d5f85..f253b119 100644
--- a/node-daemon/pvcnoded/common.py
+++ b/node-daemon/pvcnoded/common.py
@@ -144,7 +144,7 @@ def findTargetNode(zk_conn, config, logger, dom_uuid):
             node_limit = ''
     except Exception:
         node_limit = ''
-        zkhandler.writedata(zk_conn, { '/domains/{}/node_limit'.format(dom_uuid): '' })
+        zkhandler.writedata(zk_conn, {'/domains/{}/node_limit'.format(dom_uuid): '' })
 
     # Determine VM search field
     try:
@@ -155,7 +155,7 @@ def findTargetNode(zk_conn, config, logger, dom_uuid):
     # If our search field is invalid, use and set the default (for next time)
     if search_field is None or search_field == 'None':
         search_field = config['migration_target_selector']
-        zkhandler.writedata(zk_conn, { '/domains/{}/node_selector'.format(dom_uuid): config['migration_target_selector'] })
+        zkhandler.writedata(zk_conn, {'/domains/{}/node_selector'.format(dom_uuid): config['migration_target_selector'] })
 
     if config['debug']:
         logger.out('Migrating VM {} with selector {}'.format(dom_uuid, search_field), state='d', prefix='node-flush')
diff --git a/node-daemon/pvcnoded/fencing.py b/node-daemon/pvcnoded/fencing.py
index d52bfc2a..17f6f591 100644
--- a/node-daemon/pvcnoded/fencing.py
+++ b/node-daemon/pvcnoded/fencing.py
@@ -62,9 +62,9 @@ def fenceNode(node_name, zk_conn, config, logger):
     # Force into secondary network state if needed
     if node_name in config['coordinators']:
         logger.out('Forcing secondary status for node "{}"'.format(node_name), state='i')
-        zkhandler.writedata(zk_conn, { '/nodes/{}/routerstate'.format(node_name): 'secondary' })
+        zkhandler.writedata(zk_conn, {'/nodes/{}/routerstate'.format(node_name): 'secondary' })
         if zkhandler.readdata(zk_conn, '/primary_node') == node_name:
-            zkhandler.writedata(zk_conn, { '/primary_node': 'none' })
+            zkhandler.writedata(zk_conn, {'/primary_node': 'none' })
 
     # If the fence succeeded and successful_fence is migrate
     if fence_status and config['successful_fence'] == 'migrate':
@@ -82,7 +82,7 @@ def migrateFromFencedNode(zk_conn, node_name, config, logger):
     dead_node_running_domains = zkhandler.readdata(zk_conn, '/nodes/{}/runningdomains'.format(node_name)).split()
 
     # Set the node to a custom domainstate so we know what's happening
-    zkhandler.writedata(zk_conn, { '/nodes/{}/domainstate'.format(node_name): 'fence-flush' })
+    zkhandler.writedata(zk_conn, {'/nodes/{}/domainstate'.format(node_name): 'fence-flush' })
 
     # Migrate a VM after a flush
     def fence_migrate_vm(dom_uuid):
@@ -109,7 +109,7 @@ def migrateFromFencedNode(zk_conn, node_name, config, logger):
         fence_migrate_vm(dom_uuid)
 
     # Set node in flushed state for easy remigrating when it comes back
-    zkhandler.writedata(zk_conn, { '/nodes/{}/domainstate'.format(node_name): 'flushed' })
+    zkhandler.writedata(zk_conn, {'/nodes/{}/domainstate'.format(node_name): 'flushed' })
 
 #
 # Perform an IPMI fence
diff --git a/node-daemon/pvcnoded/log.py b/node-daemon/pvcnoded/log.py
index 4082431e..b62c825d 100644
--- a/node-daemon/pvcnoded/log.py
+++ b/node-daemon/pvcnoded/log.py
@@ -44,25 +44,25 @@ class Logger(object):
     # Format maps
     format_map_colourized = {
         # Colourized formatting with chevron prompts (log_colours = True)
-        'o': { 'colour': fmt_green,   'prompt': '>>> '      },
-        'e': { 'colour': fmt_red,     'prompt': '>>> '      },
-        'w': { 'colour': fmt_yellow,  'prompt': '>>> '      },
-        't': { 'colour': fmt_purple,  'prompt': '>>> '      },
-        'i': { 'colour': fmt_blue,    'prompt': '>>> '      },
-        's': { 'colour': fmt_cyan,    'prompt': '>>> '      },
-        'd': { 'colour': fmt_white,   'prompt': '>>> '      },
-        'x': { 'colour': last_colour, 'prompt': last_prompt }
+        'o': {'colour': fmt_green,   'prompt': '>>> '      },
+        'e': {'colour': fmt_red,     'prompt': '>>> '      },
+        'w': {'colour': fmt_yellow,  'prompt': '>>> '      },
+        't': {'colour': fmt_purple,  'prompt': '>>> '      },
+        'i': {'colour': fmt_blue,    'prompt': '>>> '      },
+        's': {'colour': fmt_cyan,    'prompt': '>>> '      },
+        'd': {'colour': fmt_white,   'prompt': '>>> '      },
+        'x': {'colour': last_colour, 'prompt': last_prompt }
     }
     format_map_textual = {
         # Uncolourized formatting with text prompts (log_colours = False)
-        'o': { 'colour': '', 'prompt': 'ok: '      },
-        'e': { 'colour': '', 'prompt': 'failed: '  },
-        'w': { 'colour': '', 'prompt': 'warning: ' },
-        't': { 'colour': '', 'prompt': 'tick: '    },
-        'i': { 'colour': '', 'prompt': 'info: '    },
-        's': { 'colour': '', 'prompt': 'system: '  },
-        'd': { 'colour': '', 'prompt': 'debug: '   },
-        'x': { 'colour': '', 'prompt': last_prompt }
+        'o': {'colour': '', 'prompt': 'ok: '      },
+        'e': {'colour': '', 'prompt': 'failed: '  },
+        'w': {'colour': '', 'prompt': 'warning: ' },
+        't': {'colour': '', 'prompt': 'tick: '    },
+        'i': {'colour': '', 'prompt': 'info: '    },
+        's': {'colour': '', 'prompt': 'system: '  },
+        'd': {'colour': '', 'prompt': 'debug: '   },
+        'x': {'colour': '', 'prompt': last_prompt }
     }
 
     # Initialization of instance