Normalize white space

indent by 4 spaces
one spaces around assignments

Signed-off-by: Philipp Hahn <hahn@univention.de>

10 files changed, 433 insertions, 378 deletions

diff --git a/generator.py b/generator.py
index 7358d2c..f69466c 100755
--- a/generator.py
+++ b/generator.py
@@ -6,18 +6,18 @@
 functions = {}
 lxc_functions = {}
 qemu_functions = {}
-enums = {} # { enumType: { enumConstant: enumValue } }
-lxc_enums = {} # { enumType: { enumConstant: enumValue } }
-qemu_enums = {} # { enumType: { enumConstant: enumValue } }
+enums = {}  # { enumType: { enumConstant: enumValue } }
+lxc_enums = {}  # { enumType: { enumConstant: enumValue } }
+qemu_enums = {}  # { enumType: { enumConstant: enumValue } }
 event_ids = []
-params = [] # [ (paramName, paramValue)... ]
+params = []  # [ (paramName, paramValue)... ]
 
 import os
 import sys
 import string
 import re
 
-quiet=True
+quiet = True
 
 #######################################################################
 #
@@ -48,6 +48,7 @@ libvirt_headers = [
     "libvirt-stream",
 ]
 
+
 def getparser():
     # Attach parser to an unmarshalling object. return both objects.
     target = docParser()
@@ -55,6 +56,7 @@ def getparser():
     parser.setContentHandler(target)
     return parser, target
 
+
 class docParser(xml.sax.handler.ContentHandler):
     def __init__(self):
         self._methodname = None
@@ -94,13 +96,13 @@ class docParser(xml.sax.handler.ContentHandler):
             self.function_descr = None
             self.function_return = None
             self.function_file = None
-            self.function_module= None
+            self.function_module = None
             if 'name' in attrs.keys():
                 self.function = attrs['name']
             if 'file' in attrs.keys():
                 self.function_file = attrs['file']
             if 'module' in attrs.keys():
-                self.function_module= attrs['module']
+                self.function_module = attrs['module']
         elif tag == 'cond':
             self._data = []
         elif tag == 'info':
@@ -132,11 +134,11 @@ class docParser(xml.sax.handler.ContentHandler):
         elif tag == 'enum':
             # enums come from header files, hence virterror.h
             if attrs['file'] in libvirt_headers + ["virerror", "virterror"]:
-                enum(attrs['type'],attrs['name'],attrs['value'])
+                enum(attrs['type'], attrs['name'], attrs['value'])
             elif attrs['file'] == "libvirt-lxc":
-                lxc_enum(attrs['type'],attrs['name'],attrs['value'])
+                lxc_enum(attrs['type'], attrs['name'], attrs['value'])
             elif attrs['file'] == "libvirt-qemu":
-                qemu_enum(attrs['type'],attrs['name'],attrs['value'])
+                qemu_enum(attrs['type'], attrs['name'], attrs['value'])
         elif tag == "macro":
             if "string" in attrs.keys():
                 params.append((attrs['name'], attrs['string']))
@@ -148,21 +150,21 @@ class docParser(xml.sax.handler.ContentHandler):
             # functions come from source files, hence 'virerror.c'
             if self.function is not None:
                 if self.function_module in libvirt_headers + \
-                            ["event", "virevent", "virerror", "virterror"]:
+                        ["event", "virevent", "virerror", "virterror"]:
                     function(self.function, self.function_descr,
                              self.function_return, self.function_args,
                              self.function_file, self.function_module,
                              self.function_cond)
                 elif self.function_module == "libvirt-lxc":
                     lxc_function(self.function, self.function_descr,
-                             self.function_return, self.function_args,
-                             self.function_file, self.function_module,
-                             self.function_cond)
+                                 self.function_return, self.function_args,
+                                 self.function_file, self.function_module,
+                                 self.function_cond)
                 elif self.function_module == "libvirt-qemu":
                     qemu_function(self.function, self.function_descr,
-                             self.function_return, self.function_args,
-                             self.function_file, self.function_module,
-                             self.function_cond)
+                                  self.function_return, self.function_args,
+                                  self.function_file, self.function_module,
+                                  self.function_cond)
                 elif self.function_file == "python":
                     function(self.function, self.function_descr,
                              self.function_return, self.function_args,
@@ -170,9 +172,9 @@ class docParser(xml.sax.handler.ContentHandler):
                              self.function_cond)
                 elif self.function_file == "python-lxc":
                     lxc_function(self.function, self.function_descr,
-                                  self.function_return, self.function_args,
-                                  self.function_file, self.function_module,
-                                  self.function_cond)
+                                 self.function_return, self.function_args,
+                                 self.function_file, self.function_module,
+                                 self.function_cond)
                 elif self.function_file == "python-qemu":
                     qemu_function(self.function, self.function_descr,
                                   self.function_return, self.function_args,
@@ -211,23 +213,26 @@ def function(name, desc, ret, args, file, module, cond):
         name = "virConnectListDomainsID"
     functions[name] = (desc, ret, args, file, module, cond)
 
+
 def qemu_function(name, desc, ret, args, file, module, cond):
     global onlyOverrides
     if onlyOverrides and name not in qemu_functions:
         return
     qemu_functions[name] = (desc, ret, args, file, module, cond)
 
+
 def lxc_function(name, desc, ret, args, file, module, cond):
     global onlyOverrides
     if onlyOverrides and name not in lxc_functions:
         return
     lxc_functions[name] = (desc, ret, args, file, module, cond)
 
+
 def enum(type, name, value):
     if type not in enums:
         enums[type] = {}
     if (name.startswith('VIR_DOMAIN_EVENT_ID_') or
-        name.startswith('VIR_NETWORK_EVENT_ID_')):
+            name.startswith('VIR_NETWORK_EVENT_ID_')):
         event_ids.append(name)
     if value == 'VIR_TYPED_PARAM_INT':
         value = 1
@@ -251,6 +256,7 @@ def enum(type, name, value):
         return
     enums[type][name] = value
 
+
 def lxc_enum(type, name, value):
     if type not in lxc_enums:
         lxc_enums[type] = {}
@@ -258,6 +264,7 @@ def lxc_enum(type, name, value):
         return
     lxc_enums[type][name] = value
 
+
 def qemu_enum(type, name, value):
     if type not in qemu_enums:
         qemu_enums[type] = {}
@@ -292,18 +299,18 @@ skipped_modules = {
 }
 
 skipped_types = {
-#    'int *': "usually a return type",
-     'virConnectDomainEventCallback': "No function types in python",
-     'virConnectDomainEventGenericCallback': "No function types in python",
-     'virConnectDomainEventRTCChangeCallback': "No function types in python",
-     'virConnectDomainEventWatchdogCallback': "No function types in python",
-     'virConnectDomainEventIOErrorCallback': "No function types in python",
-     'virConnectDomainEventGraphicsCallback': "No function types in python",
-     'virConnectDomainQemuMonitorEventCallback': "No function types in python",
-     'virStreamEventCallback': "No function types in python",
-     'virEventHandleCallback': "No function types in python",
-     'virEventTimeoutCallback': "No function types in python",
-     'virDomainBlockJobInfoPtr': "Not implemented yet",
+    # 'int *': "usually a return type",
+    'virConnectDomainEventCallback': "No function types in python",
+    'virConnectDomainEventGenericCallback': "No function types in python",
+    'virConnectDomainEventRTCChangeCallback': "No function types in python",
+    'virConnectDomainEventWatchdogCallback': "No function types in python",
+    'virConnectDomainEventIOErrorCallback': "No function types in python",
+    'virConnectDomainEventGraphicsCallback': "No function types in python",
+    'virConnectDomainQemuMonitorEventCallback': "No function types in python",
+    'virStreamEventCallback': "No function types in python",
+    'virEventHandleCallback': "No function types in python",
+    'virEventTimeoutCallback': "No function types in python",
+    'virDomainBlockJobInfoPtr': "Not implemented yet",
 }
 
 #######################################################################
@@ -315,73 +322,73 @@ skipped_types = {
 
 py_types = {
     'void': (None, None, None, None),
-    'int':  ('i', None, "int", "int"),
-    'long':  ('l', None, "long", "long"),
-    'double':  ('d', None, "double", "double"),
-    'unsigned int':  ('I', None, "int", "int"),
-    'unsigned long':  ('l', None, "long", "long"),
-    'long long':  ('L', None, "longlong", "long long"),
-    'unsigned long long':  ('L', None, "longlong", "long long"),
-    'unsigned char *':  ('z', None, "charPtr", "char *"),
-    'char *':  ('z', None, "charPtr", "char *"),
-    'const char *':  ('z', None, "constcharPtr", "const char *"),
+    'int': ('i', None, "int", "int"),
+    'long': ('l', None, "long", "long"),
+    'double': ('d', None, "double", "double"),
+    'unsigned int': ('I', None, "int", "int"),
+    'unsigned long': ('l', None, "long", "long"),
+    'long long': ('L', None, "longlong", "long long"),
+    'unsigned long long': ('L', None, "longlong", "long long"),
+    'unsigned char *': ('z', None, "charPtr", "char *"),
+    'char *': ('z', None, "charPtr", "char *"),
+    'const char *': ('z', None, "constcharPtr", "const char *"),
     'size_t': ('n', None, "size_t", "size_t"),
 
-    'virDomainPtr':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
-    'virDomain *':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
-    'const virDomain *':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
+    'virDomainPtr': ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
+    'virDomain *': ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
+    'const virDomain *': ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
 
-    'virNetworkPtr':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
-    'virNetwork *':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
-    'const virNetwork *':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
+    'virNetworkPtr': ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
+    'virNetwork *': ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
+    'const virNetwork *': ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
 
-    'virNetworkPortPtr':  ('O', "virNetworkPort", "virNetworkPortPtr", "virNetworkPortPtr"),
-    'virNetworkPort *':  ('O', "virNetworkPort", "virNetworkPortPtr", "virNetworkPortPtr"),
-    'const virNetworkPort *':  ('O', "virNetworkPort", "virNetworkPortPtr", "virNetworkPortPtr"),
+    'virNetworkPortPtr': ('O', "virNetworkPort", "virNetworkPortPtr", "virNetworkPortPtr"),
+    'virNetworkPort *': ('O', "virNetworkPort", "virNetworkPortPtr", "virNetworkPortPtr"),
+    'const virNetworkPort *': ('O', "virNetworkPort", "virNetworkPortPtr", "virNetworkPortPtr"),
 
-    'virInterfacePtr':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
-    'virInterface *':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
-    'const virInterface *':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
+    'virInterfacePtr': ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
+    'virInterface *': ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
+    'const virInterface *': ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
 
-    'virStoragePoolPtr':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
-    'virStoragePool *':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
-    'const virStoragePool *':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
+    'virStoragePoolPtr': ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
+    'virStoragePool *': ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
+    'const virStoragePool *': ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
 
-    'virStorageVolPtr':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
-    'virStorageVol *':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
-    'const virStorageVol *':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
+    'virStorageVolPtr': ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
+    'virStorageVol *': ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
+    'const virStorageVol *': ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
 
-    'virConnectPtr':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
-    'virConnect *':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
-    'const virConnect *':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
+    'virConnectPtr': ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
+    'virConnect *': ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
+    'const virConnect *': ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
 
-    'virNodeDevicePtr':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
-    'virNodeDevice *':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
-    'const virNodeDevice *':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
+    'virNodeDevicePtr': ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
+    'virNodeDevice *': ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
+    'const virNodeDevice *': ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
 
-    'virSecretPtr':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
-    'virSecret *':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
-    'const virSecret *':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
+    'virSecretPtr': ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
+    'virSecret *': ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
+    'const virSecret *': ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
 
-    'virNWFilterPtr':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
-    'virNWFilter *':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
-    'const virNWFilter *':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
+    'virNWFilterPtr': ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
+    'virNWFilter *': ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
+    'const virNWFilter *': ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
 
-    'virNWFilterBindingPtr':  ('O', "virNWFilterBinding", "virNWFilterBindingPtr", "virNWFilterBindingPtr"),
-    'virNWFilterBinding *':  ('O', "virNWFilterBinding", "virNWFilterBindingPtr", "virNWFilterBindingPtr"),
-    'const virNWFilterBinding *':  ('O', "virNWFilterBinding", "virNWFilterBindingPtr", "virNWFilterBindingPtr"),
+    'virNWFilterBindingPtr': ('O', "virNWFilterBinding", "virNWFilterBindingPtr", "virNWFilterBindingPtr"),
+    'virNWFilterBinding *': ('O', "virNWFilterBinding", "virNWFilterBindingPtr", "virNWFilterBindingPtr"),
+    'const virNWFilterBinding *': ('O', "virNWFilterBinding", "virNWFilterBindingPtr", "virNWFilterBindingPtr"),
 
-    'virStreamPtr':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),
-    'virStream *':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),
-    'const virStream *':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),
+    'virStreamPtr': ('O', "virStream", "virStreamPtr", "virStreamPtr"),
+    'virStream *': ('O', "virStream", "virStreamPtr", "virStreamPtr"),
+    'const virStream *': ('O', "virStream", "virStreamPtr", "virStreamPtr"),
 
-    'virDomainCheckpointPtr':  ('O', "virDomainCheckpoint", "virDomainCheckpointPtr", "virDomainCheckpointPtr"),
-    'virDomainCheckpoint *':  ('O', "virDomainCheckpoint", "virDomainCheckpointPtr", "virDomainCheckpointPtr"),
-    'const virDomainCheckpoint *':  ('O', "virDomainCheckpoint", "virDomainCheckpointPtr", "virDomainCheckpointPtr"),
+    'virDomainCheckpointPtr': ('O', "virDomainCheckpoint", "virDomainCheckpointPtr", "virDomainCheckpointPtr"),
+    'virDomainCheckpoint *': ('O', "virDomainCheckpoint", "virDomainCheckpointPtr", "virDomainCheckpointPtr"),
+    'const virDomainCheckpoint *': ('O', "virDomainCheckpoint", "virDomainCheckpointPtr", "virDomainCheckpointPtr"),
 
-    'virDomainSnapshotPtr':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
-    'virDomainSnapshot *':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
-    'const virDomainSnapshot *':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
+    'virDomainSnapshotPtr': ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
+    'virDomainSnapshot *': ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
+    'const virDomainSnapshot *': ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
 }
 
 unknown_types = {}
@@ -534,66 +541,66 @@ qemu_skip_impl = (
 # or C code is generated. Generally should not be used for any more
 # functions than those already listed
 skip_function = (
-    'virConnectListDomains', # Python API is called virConnectListDomainsID for unknown reasons
-    'virConnSetErrorFunc', # Not used in Python API  XXX is this a bug ?
-    'virResetError', # Not used in Python API  XXX is this a bug ?
-    'virGetVersion', # Python C code is manually written
-    'virSetErrorFunc', # Python API is called virRegisterErrorHandler for unknown reasons
-    'virConnCopyLastError', # Python API is called virConnGetLastError instead
-    'virCopyLastError', # Python API is called virGetLastError instead
-    'virConnectOpenAuth', # Python C code is manually written
-    'virDefaultErrorFunc', # Python virErrorFuncHandler impl calls this from C
+    'virConnectListDomains',  # Python API is called virConnectListDomainsID for unknown reasons
+    'virConnSetErrorFunc',  # Not used in Python API  XXX is this a bug ?
+    'virResetError',  # Not used in Python API  XXX is this a bug ?
+    'virGetVersion',  # Python C code is manually written
+    'virSetErrorFunc',  # Python API is called virRegisterErrorHandler for unknown reasons
+    'virConnCopyLastError',  # Python API is called virConnGetLastError instead
+    'virCopyLastError',  # Python API is called virGetLastError instead
+    'virConnectOpenAuth',  # Python C code is manually written
+    'virDefaultErrorFunc',  # Python virErrorFuncHandler impl calls this from C
     'virConnectDomainEventRegister',   # overridden in virConnect.py
-    'virConnectDomainEventDeregister', # overridden in virConnect.py
+    'virConnectDomainEventDeregister',  # overridden in virConnect.py
     'virConnectDomainEventRegisterAny',   # overridden in virConnect.py
-    'virConnectDomainEventDeregisterAny', # overridden in virConnect.py
+    'virConnectDomainEventDeregisterAny',  # overridden in virConnect.py
     'virConnectNetworkEventRegisterAny',   # overridden in virConnect.py
-    'virConnectNetworkEventDeregisterAny', # overridden in virConnect.py
+    'virConnectNetworkEventDeregisterAny',  # overridden in virConnect.py
     'virConnectStoragePoolEventRegisterAny',   # overridden in virConnect.py
-    'virConnectStoragePoolEventDeregisterAny', # overridden in virConnect.py
+    'virConnectStoragePoolEventDeregisterAny',  # overridden in virConnect.py
     'virConnectNodeDeviceEventRegisterAny',   # overridden in virConnect.py
-    'virConnectNodeDeviceEventDeregisterAny', # overridden in virConnect.py
+    'virConnectNodeDeviceEventDeregisterAny',  # overridden in virConnect.py
     'virConnectSecretEventRegisterAny',   # overridden in virConnect.py
-    'virConnectSecretEventDeregisterAny', # overridden in virConnect.py
-    'virSaveLastError', # We have our own python error wrapper
-    'virFreeError', # Only needed if we use virSaveLastError
-    'virConnectListAllDomains', # overridden in virConnect.py
-    'virDomainListAllCheckpoints', # overridden in virDomain.py
-    'virDomainCheckpointListAllChildren', # overridden in virDomainCheckpoint.py
-    'virDomainListAllSnapshots', # overridden in virDomain.py
-    'virDomainSnapshotListAllChildren', # overridden in virDomainSnapshot.py
-    'virConnectListAllStoragePools', # overridden in virConnect.py
-    'virStoragePoolListAllVolumes', # overridden in virStoragePool.py
-    'virConnectListAllNetworks', # overridden in virConnect.py
-    'virNetworkListAllPorts', # overridden in virConnect.py
-    'virConnectListAllInterfaces', # overridden in virConnect.py
-    'virConnectListAllNodeDevices', # overridden in virConnect.py
-    'virConnectListAllNWFilters', # overridden in virConnect.py
-    'virConnectListAllNWFilterBindings', # overridden in virConnect.py
-    'virConnectListAllSecrets', # overridden in virConnect.py
-    'virConnectGetAllDomainStats', # overridden in virConnect.py
-    'virDomainListGetStats', # overridden in virConnect.py
-
-    'virStreamRecvAll', # Pure python libvirt-override-virStream.py
-    'virStreamSendAll', # Pure python libvirt-override-virStream.py
-    'virStreamRecv', # overridden in libvirt-override-virStream.py
-    'virStreamSend', # overridden in libvirt-override-virStream.py
-    'virStreamRecvHole', # overridden in libvirt-override-virStream.py
-    'virStreamSendHole', # overridden in libvirt-override-virStream.py
-    'virStreamRecvFlags', # overridden in libvirt-override-virStream.py
-    'virStreamSparseRecvAll', # overridden in libvirt-override-virStream.py
-    'virStreamSparseSendAll', # overridden in libvirt-override-virStream.py
-
-    'virConnectUnregisterCloseCallback', # overridden in virConnect.py
-    'virConnectRegisterCloseCallback', # overridden in virConnect.py
-
-    'virDomainCreateXMLWithFiles', # overridden in virConnect.py
-    'virDomainCreateWithFiles', # overridden in virDomain.py
-
-    'virDomainFSFreeze', # overridden in virDomain.py
-    'virDomainFSThaw', # overridden in virDomain.py
-    'virDomainGetTime', # overridden in virDomain.py
-    'virDomainSetTime', # overridden in virDomain.py
+    'virConnectSecretEventDeregisterAny',  # overridden in virConnect.py
+    'virSaveLastError',  # We have our own python error wrapper
+    'virFreeError',  # Only needed if we use virSaveLastError
+    'virConnectListAllDomains',  # overridden in virConnect.py
+    'virDomainListAllCheckpoints',  # overridden in virDomain.py
+    'virDomainCheckpointListAllChildren',  # overridden in virDomainCheckpoint.py
+    'virDomainListAllSnapshots',  # overridden in virDomain.py
+    'virDomainSnapshotListAllChildren',  # overridden in virDomainSnapshot.py
+    'virConnectListAllStoragePools',  # overridden in virConnect.py
+    'virStoragePoolListAllVolumes',  # overridden in virStoragePool.py
+    'virConnectListAllNetworks',  # overridden in virConnect.py
+    'virNetworkListAllPorts',  # overridden in virConnect.py
+    'virConnectListAllInterfaces',  # overridden in virConnect.py
+    'virConnectListAllNodeDevices',  # overridden in virConnect.py
+    'virConnectListAllNWFilters',  # overridden in virConnect.py
+    'virConnectListAllNWFilterBindings',  # overridden in virConnect.py
+    'virConnectListAllSecrets',  # overridden in virConnect.py
+    'virConnectGetAllDomainStats',  # overridden in virConnect.py
+    'virDomainListGetStats',  # overridden in virConnect.py
+
+    'virStreamRecvAll',  # Pure python libvirt-override-virStream.py
+    'virStreamSendAll',  # Pure python libvirt-override-virStream.py
+    'virStreamRecv',  # overridden in libvirt-override-virStream.py
+    'virStreamSend',  # overridden in libvirt-override-virStream.py
+    'virStreamRecvHole',  # overridden in libvirt-override-virStream.py
+    'virStreamSendHole',  # overridden in libvirt-override-virStream.py
+    'virStreamRecvFlags',  # overridden in libvirt-override-virStream.py
+    'virStreamSparseRecvAll',  # overridden in libvirt-override-virStream.py
+    'virStreamSparseSendAll',  # overridden in libvirt-override-virStream.py
+
+    'virConnectUnregisterCloseCallback',  # overridden in virConnect.py
+    'virConnectRegisterCloseCallback',  # overridden in virConnect.py
+
+    'virDomainCreateXMLWithFiles',  # overridden in virConnect.py
+    'virDomainCreateWithFiles',  # overridden in virDomain.py
+
+    'virDomainFSFreeze',  # overridden in virDomain.py
+    'virDomainFSThaw',  # overridden in virDomain.py
+    'virDomainGetTime',  # overridden in virDomain.py
+    'virDomainSetTime',  # overridden in virDomain.py
 
     # 'Ref' functions have no use for bindings users.
     "virConnectRef",
@@ -647,27 +654,27 @@ skip_function = (
     "virTypedParamsGetUInt",
     "virTypedParamsGetULLong",
 
-    'virNetworkDHCPLeaseFree', # only useful in C, python code uses list
-    'virDomainStatsRecordListFree', # only useful in C, python uses dict
-    'virDomainFSInfoFree', # only useful in C, python code uses list
-    'virDomainIOThreadInfoFree', # only useful in C, python code uses list
-    'virDomainInterfaceFree', # only useful in C, python code uses list
+    'virNetworkDHCPLeaseFree',  # only useful in C, python code uses list
+    'virDomainStatsRecordListFree',  # only useful in C, python uses dict
+    'virDomainFSInfoFree',  # only useful in C, python code uses list
+    'virDomainIOThreadInfoFree',  # only useful in C, python code uses list
+    'virDomainInterfaceFree',  # only useful in C, python code uses list
 )
 
 lxc_skip_function = (
-  "virDomainLxcEnterNamespace",
-  "virDomainLxcEnterSecurityLabel",
+    "virDomainLxcEnterNamespace",
+    "virDomainLxcEnterSecurityLabel",
 )
 qemu_skip_function = (
-    #"virDomainQemuAttach",
-    'virConnectDomainQemuMonitorEventRegister', # overridden in -qemu.py
-    'virConnectDomainQemuMonitorEventDeregister', # overridden in -qemu.py
+    # "virDomainQemuAttach",
+    'virConnectDomainQemuMonitorEventRegister',  # overridden in -qemu.py
+    'virConnectDomainQemuMonitorEventDeregister',  # overridden in -qemu.py
 )
 
 # Generate C code, but skip python impl
 function_skip_python_impl = (
-    "virStreamFree", # Needed in custom virStream __del__, but free shouldn't
-                     # be exposed in bindings
+    "virStreamFree",  # Needed in custom virStream __del__, but free shouldn't
+                      # be exposed in bindings
 )
 
 lxc_function_skip_python_impl = ()
@@ -677,6 +684,7 @@ function_skip_index_one = (
     "virDomainRevertToSnapshot",
 )
 
+
 def print_function_wrapper(module, name, output, export, include):
     global py_types
     global unknown_types
@@ -720,12 +728,12 @@ def print_function_wrapper(module, name, output, export, include):
             return 1
 
     c_call = ""
-    format=""
-    format_args=""
-    c_args=""
-    c_return=""
-    c_convert=""
-    num_bufs=0
+    format = ""
+    format_args = ""
+    c_args = ""
+    c_return = ""
+    c_convert = ""
+    num_bufs = 0
     for arg in args:
         # This should be correct
         if arg[1][0:6] == "const ":
@@ -739,8 +747,8 @@ def print_function_wrapper(module, name, output, export, include):
                 format_args = format_args + ", &pyobj_%s" % (arg[0])
                 c_args = c_args + "    PyObject *pyobj_%s;\n" % (arg[0])
                 c_convert = c_convert + \
-                   "    %s = (%s) Py%s_Get(pyobj_%s);\n" % (arg[0],
-                   arg[1], t, arg[0])
+                    "    %s = (%s) Py%s_Get(pyobj_%s);\n" % (
+                        arg[0], arg[1], t, arg[0])
             else:
                 format_args = format_args + ", &%s" % (arg[0])
             if f == 't#':
@@ -766,9 +774,9 @@ def print_function_wrapper(module, name, output, export, include):
         if file == "python_accessor":
             if args[1][1] == "char *":
                 c_call = "\n    VIR_FREE(%s->%s);\n" % (
-                                 args[0][0], args[1][0])
-                c_call = c_call + "    %s->%s = (%s)strdup((const xmlChar *)%s);\n" % (args[0][0],
-                                 args[1][0], args[1][1], args[1][0])
+                    args[0][0], args[1][0])
+                c_call = c_call + "    %s->%s = (%s)strdup((const xmlChar *)%s);\n" % (
+                    args[0][0], args[1][0], args[1][1], args[1][0])
             else:
                 c_call = "\n    %s->%s = %s;\n" % (args[0][0], args[1][0],
                                                    args[1][0])
@@ -782,7 +790,7 @@ def print_function_wrapper(module, name, output, export, include):
             c_call = "\n    c_retval = %s->%s;\n" % (args[0][0], ret[2])
         else:
             c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)
-        ret_convert = "    py_retval = libvirt_%sWrap((%s) c_retval);\n" % (n,c)
+        ret_convert = "    py_retval = libvirt_%sWrap((%s) c_retval);\n" % (n, c)
         if n == "charPtr":
             ret_convert = ret_convert + "    free(c_retval);\n"
         ret_convert = ret_convert + "    return py_retval;\n"
@@ -875,6 +883,7 @@ def print_function_wrapper(module, name, output, export, include):
             return 0
     return 1
 
+
 def print_c_pointer(classname, output, export, include):
     output.write("PyObject *\n")
     output.write("libvirt_%s_pointer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args)\n" % classname)
@@ -896,6 +905,7 @@ def print_c_pointer(classname, output, export, include):
     export.write("    { (char *)\"%s_pointer\", libvirt_%s_pointer, METH_VARARGS, NULL },\n" %
                  (classname, classname))
 
+
 def buildStubs(module, api_xml):
     global py_types
     global unknown_types
@@ -923,7 +933,7 @@ def buildStubs(module, api_xml):
         data = f.read()
         f.close()
         onlyOverrides = False
-        (parser, target)  = getparser()
+        (parser, target) = getparser()
         parser.feed(data)
         parser.close()
     except IOError:
@@ -943,7 +953,7 @@ def buildStubs(module, api_xml):
         data = f.read()
         f.close()
         onlyOverrides = True
-        (parser, target)  = getparser()
+        (parser, target) = getparser()
         parser.feed(data)
         parser.close()
     except IOError:
@@ -1019,6 +1029,7 @@ def buildStubs(module, api_xml):
         return -1
     return 0
 
+
 #######################################################################
 #
 #  This part writes part of the Python front-end classes based on
@@ -1075,18 +1086,18 @@ classes_destructors = {
     "virInterface": "virInterfaceFree",
     "virStoragePool": "virStoragePoolFree",
     "virStorageVol": "virStorageVolFree",
-    "virNodeDevice" : "virNodeDeviceFree",
+    "virNodeDevice": "virNodeDeviceFree",
     "virSecret": "virSecretFree",
     "virNWFilter": "virNWFilterFree",
     "virNWFilterBinding": "virNWFilterBindingFree",
     "virDomainCheckpoint": "virDomainCheckpointFree",
     "virDomainSnapshot": "virDomainSnapshotFree",
     # We hand-craft __del__ for this one
-    #"virStream": "virStreamFree",
+    # "virStream": "virStreamFree",
 }
 
 class_skip_connect_impl = {
-    "virConnect" : True,
+    "virConnect": True,
 }
 
 class_domain_impl = {
@@ -1126,16 +1137,19 @@ functions_int_exception_test = {
 }
 functions_int_default_test = "%s == -1"
 
-def is_integral_type (name):
-    return not re.search ("^(unsigned)? ?(int|long)$", name) is None
+
+def is_integral_type(name):
+    return not re.search("^(unsigned)? ?(int|long)$", name) is None
+
 
 def is_optional_arg(info):
     return re.search("^\(?optional\)?", info) is not None
 
-def is_python_noninteger_type (name):
 
+def is_python_noninteger_type(name):
     return name[-1:] == "*"
 
+
 def nameFixup(name, classe, type, file):
     # avoid a disastrous clash
     listname = classe + "List"
@@ -1344,28 +1358,30 @@ def functionSortKey(info):
     (index, func, name, ret, args, filename, mod) = info
     return func, filename
 
+
 def writeDoc(module, name, args, indent, output):
-     if module == "libvirt":
-         funcs = functions
-     elif module == "libvirt-lxc":
-         funcs = lxc_functions
-     elif module == "libvirt-qemu":
-         funcs = qemu_functions
-     if funcs[name][0] is None or funcs[name][0] == "":
-         return
-     val = funcs[name][0]
-     val = val.replace("NULL", "None")
-     output.write(indent)
-     output.write('"""')
-     i = val.find("\n")
-     while i >= 0:
-         str = val[0:i+1]
-         val = val[i+1:]
-         output.write(str)
-         i = val.find("\n")
-         output.write(indent)
-     output.write(val)
-     output.write(' """\n')
+    if module == "libvirt":
+        funcs = functions
+    elif module == "libvirt-lxc":
+        funcs = lxc_functions
+    elif module == "libvirt-qemu":
+        funcs = qemu_functions
+    if funcs[name][0] is None or funcs[name][0] == "":
+        return
+    val = funcs[name][0]
+    val = val.replace("NULL", "None")
+    output.write(indent)
+    output.write('"""')
+    i = val.find("\n")
+    while i >= 0:
+        str = val[0:i + 1]
+        val = val[i + 1:]
+        output.write(str)
+        i = val.find("\n")
+        output.write(indent)
+    output.write(val)
+    output.write(' """\n')
+
 
 def buildWrappers(module):
     global ctypes
@@ -1426,7 +1442,7 @@ def buildWrappers(module):
                 function_classes[classe].append(info)
                 break
             elif name[0:3] == "vir" and len(args) >= 2 and args[1][1] == type \
-                and file != "python_accessor" and not name in function_skip_index_one:
+                    and file != "python_accessor" and not name in function_skip_index_one:
                 found = 1
                 func = nameFixup(name, classe, type, file)
                 info = (1, func, name, ret, args, file, mod)
@@ -1522,8 +1538,8 @@ def buildWrappers(module):
                         classes.write("    if ret is None:return None\n")
                     else:
                         classes.write(
-                     "    if ret is None:raise libvirtError('%s() failed')\n" %
-                                      (name))
+                            "    if ret is None:raise libvirtError('%s() failed')\n" %
+                            (name))
 
                     r_type, r_info, r_field = ret
                     tinfo = classes_type[r_type]
@@ -1534,22 +1550,22 @@ def buildWrappers(module):
                 # For functions returning an integral type there are
                 # several things that we can do, depending on the
                 # contents of functions_int_*:
-                elif is_integral_type (ret[0]):
+                elif is_integral_type(ret[0]):
                     if name not in functions_noexcept:
                         if name in functions_int_exception_test:
                             test = functions_int_exception_test[name]
                         else:
                             test = functions_int_default_test
-                        classes.write (("    if " + test +
-                                        ": raise libvirtError ('%s() failed')\n") %
-                                       ("ret", name))
+                        classes.write(("    if " + test +
+                                       ": raise libvirtError ('%s() failed')\n") %
+                                      ("ret", name))
                     classes.write("    return ret\n")
 
-                elif is_python_noninteger_type (ret[0]):
+                elif is_python_noninteger_type(ret[0]):
                     if name not in functions_noexcept:
-                        classes.write (("    if %s is None" +
-                                        ": raise libvirtError ('%s() failed')\n") %
-                                       ("ret", name))
+                        classes.write(("    if %s is None" +
+                                       ": raise libvirtError ('%s() failed')\n") %
+                                      ("ret", name))
                     classes.write("    return ret\n")
 
                 else:
@@ -1575,39 +1591,39 @@ def buildWrappers(module):
                 classes.write("    # methods. This corresponds to the size of payload\n")
                 classes.write("    # of a stream packet.\n")
                 classes.write("    streamBufSize = 262120\n\n")
-            if classname in [ "virDomain", "virNetwork", "virInterface", "virStoragePool",
-                              "virStorageVol", "virNodeDevice", "virSecret","virStream",
-                              "virNWFilter", "virNWFilterBinding" ]:
+            if classname in ["virDomain", "virNetwork", "virInterface", "virStoragePool",
+                             "virStorageVol", "virNodeDevice", "virSecret", "virStream",
+                             "virNWFilter", "virNWFilterBinding"]:
                 classes.write("    def __init__(self, conn, _obj=None):\n")
-            elif classname in [ "virDomainCheckpoint", "virDomainSnapshot" ]:
+            elif classname in ["virDomainCheckpoint", "virDomainSnapshot"]:
                 classes.write("    def __init__(self, dom, _obj=None):\n")
-            elif classname in [ "virNetworkPort" ]:
+            elif classname in ["virNetworkPort"]:
                 classes.write("    def __init__(self, net, _obj=None):\n")
             else:
                 classes.write("    def __init__(self, _obj=None):\n")
-            if classname in [ "virDomain", "virNetwork", "virInterface",
-                              "virNodeDevice", "virSecret", "virStream",
-                              "virNWFilter", "virNWFilterBinding" ]:
+            if classname in ["virDomain", "virNetwork", "virInterface",
+                             "virNodeDevice", "virSecret", "virStream",
+                             "virNWFilter", "virNWFilterBinding"]:
                 classes.write("        self._conn = conn\n")
-            elif classname in [ "virStorageVol", "virStoragePool" ]:
+            elif classname in ["virStorageVol", "virStoragePool"]:
                 classes.write("        self._conn = conn if isinstance(conn, virConnect) else conn._conn  # type: virConnect\n")
-            elif classname in [ "virDomainCheckpoint", "virDomainSnapshot" ]:
+            elif classname in ["virDomainCheckpoint", "virDomainSnapshot"]:
                 classes.write("        self._dom = dom\n")
                 classes.write("        self._conn = dom.connect()\n")
-            elif classname in [ "virNetworkPort" ]:
+            elif classname in ["virNetworkPort"]:
                 classes.write("        self._net = net\n")
                 classes.write("        self._conn = net.connect()\n")
             classes.write("        if type(_obj).__name__ not in [\"PyCapsule\", \"PyCObject\"]:\n")
             classes.write("            raise Exception(\"Expected a wrapped C Object but got %s\" % type(_obj))\n")
             classes.write("        self._o = _obj\n\n")
-            destruct=None
+            destruct = None
             if classname in classes_destructors:
                 classes.write("    def __del__(self):\n")
                 classes.write("        if self._o is not None:\n")
                 classes.write("            libvirtmod.%s(self._o)\n" %
                               classes_destructors[classname])
                 classes.write("        self._o = None\n\n")
-                destruct=classes_destructors[classname]
+                destruct = classes_destructors[classname]
 
             if classname not in class_skip_connect_impl:
                 # Build python safe 'connect' method
@@ -1654,9 +1670,9 @@ def buildWrappers(module):
                         classes.write(", %s" % arg[0])
                     if arg[0] == "flags" or is_optional_arg(arg[2]):
                         if is_integral_type(arg[1]):
-                           classes.write("=0")
+                            classes.write("=0")
                         else:
-                           classes.write("=None")
+                            classes.write("=None")
                     n = n + 1
                 classes.write("):\n")
                 writeDoc(module, name, args, '        ', classes)
@@ -1704,36 +1720,36 @@ def buildWrappers(module):
                         else:
                             if classname == "virConnect":
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', conn=self)\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed', conn=self)\n" %
+                                    (name))
                             elif classname == "virDomain":
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', dom=self)\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed', dom=self)\n" %
+                                    (name))
                             elif classname == "virNetwork":
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', net=self)\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed', net=self)\n" %
+                                    (name))
                             elif classname == "virInterface":
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', net=self)\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed', net=self)\n" %
+                                    (name))
                             elif classname == "virStoragePool":
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', pool=self)\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed', pool=self)\n" %
+                                    (name))
                             elif classname == "virStorageVol":
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', vol=self)\n" %
-                                              (name))
-                            elif classname in [ "virDomainCheckpoint", "virDomainSnapshot"]:
+                                    "        if ret is None:raise libvirtError('%s() failed', vol=self)\n" %
+                                    (name))
+                            elif classname in ["virDomainCheckpoint", "virDomainSnapshot"]:
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed', dom=self._dom)\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed', dom=self._dom)\n" %
+                                    (name))
                             else:
                                 classes.write(
-                     "        if ret is None:raise libvirtError('%s() failed')\n" %
-                                              (name))
+                                    "        if ret is None:raise libvirtError('%s() failed')\n" %
+                                    (name))
 
                         #
                         # generate the returned class wrapper for the object
@@ -1752,75 +1768,75 @@ def buildWrappers(module):
                     # For functions returning an integral type there
                     # are several things that we can do, depending on
                     # the contents of functions_int_*:
-                    elif is_integral_type (ret[0]):
+                    elif is_integral_type(ret[0]):
                         if name not in functions_noexcept:
                             if name in functions_int_exception_test:
                                 test = functions_int_exception_test[name]
                             else:
                                 test = functions_int_default_test
                             if classname == "virConnect":
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed', conn=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed', conn=self)\n") %
+                                              ("ret", name))
                             elif classname == "virDomain":
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed', dom=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed', dom=self)\n") %
+                                              ("ret", name))
                             elif classname == "virNetwork":
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed', net=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed', net=self)\n") %
+                                              ("ret", name))
                             elif classname == "virInterface":
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed', net=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed', net=self)\n") %
+                                              ("ret", name))
                             elif classname == "virStoragePool":
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed', pool=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed', pool=self)\n") %
+                                              ("ret", name))
                             elif classname == "virStorageVol":
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed', vol=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed', vol=self)\n") %
+                                              ("ret", name))
                             else:
-                                classes.write (("        if " + test +
-                                                ": raise libvirtError ('%s() failed')\n") %
-                                               ("ret", name))
+                                classes.write(("        if " + test +
+                                               ": raise libvirtError('%s() failed')\n") %
+                                              ("ret", name))
 
-                        classes.write ("        return ret\n")
+                        classes.write("        return ret\n")
 
-                    elif is_python_noninteger_type (ret[0]):
+                    elif is_python_noninteger_type(ret[0]):
                         if name not in functions_noexcept:
                             if classname == "virConnect":
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed', conn=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed', conn=self)\n") %
+                                              ("ret", name))
                             elif classname == "virDomain":
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed', dom=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed', dom=self)\n") %
+                                              ("ret", name))
                             elif classname == "virNetwork":
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed', net=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed', net=self)\n") %
+                                              ("ret", name))
                             elif classname == "virInterface":
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed', net=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed', net=self)\n") %
+                                              ("ret", name))
                             elif classname == "virStoragePool":
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed', pool=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed', pool=self)\n") %
+                                              ("ret", name))
                             elif classname == "virStorageVol":
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed', vol=self)\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed', vol=self)\n") %
+                                              ("ret", name))
                             else:
-                                classes.write (("        if %s is None" +
-                                                ": raise libvirtError ('%s() failed')\n") %
-                                               ("ret", name))
+                                classes.write(("        if %s is None" +
+                                               ": raise libvirtError('%s() failed')\n") %
+                                              ("ret", name))
 
-                        classes.write ("        return ret\n")
+                        classes.write("        return ret\n")
                     else:
                         classes.write("        return ret\n")
 
@@ -1829,12 +1845,11 @@ def buildWrappers(module):
             try:
                 wantfuncs = []
                 extra = open("libvirt-override-" + classname + ".py", "r")
-                classes.write ("    #\n")
-                classes.write ("    # %s methods from %s.py (hand coded)\n" % (classname,classname))
-                classes.write ("    #\n")
+                classes.write("    #\n")
+                classes.write("    # %s methods from %s.py (hand coded)\n" % (classname, classname))
+                classes.write("    #\n")
                 cached = None
 
-
                 # Since we compile with older libvirt, we don't want to pull
                 # in manually written python methods which call C methods
                 # that don't exist. This code attempts to detect which
@@ -1854,7 +1869,7 @@ def buildWrappers(module):
                 for line in extra.readlines():
                     offset = line.find(" def ")
                     if offset != -1:
-                        name = line[offset+5:]
+                        name = line[offset + 5:]
                         offset = name.find("(")
                         name = name[0:offset]
                         if cached is not None:
@@ -1890,7 +1905,7 @@ def buildWrappers(module):
 
     # Resolve only one level of reference
     def resolveEnum(enum, data):
-        for name,val in enum.items():
+        for name, val in enum.items():
             try:
                 int(val)
             except ValueError:
@@ -1900,19 +1915,19 @@ def buildWrappers(module):
     enumvals = list(enums.items())
     # convert list of dicts to one dict
     enumData = {}
-    for type,enum in enumvals:
+    for type, enum in enumvals:
         enumData.update(enum)
 
     if enumvals is not None:
         enumvals.sort(key=lambda x: x[0])
-    for type,enum in enumvals:
+    for type, enum in enumvals:
         classes.write("# %s\n" % type)
         items = list(resolveEnum(enum, enumData).items())
         items.sort(key=enumsSortKey)
         if items[-1][0].endswith('_LAST'):
             del items[-1]
-        for name,value in items:
-            classes.write("%s = %s\n" % (name,value))
+        for name, value in items:
+            classes.write("%s = %s\n" % (name, value))
         classes.write("\n")
 
     classes.write("# typed parameter names\n")
@@ -1921,6 +1936,7 @@ def buildWrappers(module):
 
     classes.close()
 
+
 def qemuBuildWrappers(module):
     global qemu_functions
 
@@ -2027,12 +2043,12 @@ def qemuBuildWrappers(module):
     #
     # Generate enum constants
     #
-    for type,enum in sorted(qemu_enums.items()):
+    for type, enum in sorted(qemu_enums.items()):
         fd.write("# %s\n" % type)
         items = list(enum.items())
         items.sort(key=lambda i: (int(i[1]), i[0]))
-        for name,value in items:
-            fd.write("%s = %s\n" % (name,value))
+        for name, value in items:
+            fd.write("%s = %s\n" % (name, value))
         fd.write("\n")
 
     fd.close()
@@ -2142,12 +2158,12 @@ def lxcBuildWrappers(module):
     #
     # Generate enum constants
     #
-    for type,enum in sorted(lxc_enums.items()):
+    for type, enum in sorted(lxc_enums.items()):
         fd.write("# %s\n" % type)
         items = list(enum.items())
         items.sort(key=lambda i: (int(i[1]), i[0]))
-        for name,value in items:
-            fd.write("%s = %s\n" % (name,value))
+        for name, value in items:
+            fd.write("%s = %s\n" % (name, value))
         fd.write("\n")
 
     fd.close()
diff --git a/libvirt-override-virConnect.py b/libvirt-override-virConnect.py
index 7fe08e0..cf2b269 100644
--- a/libvirt-override-virConnect.py
+++ b/libvirt-override-virConnect.py
@@ -1,11 +1,11 @@
     def __del__(self):
         try:
-           for cb,opaque in self.domainEventCallbacks.items():
-               del self.domainEventCallbacks[cb]
-           del self.domainEventCallbacks
-           libvirtmod.virConnectDomainEventDeregister(self._o, self)
+            for cb, opaque in self.domainEventCallbacks.items():
+                del self.domainEventCallbacks[cb]
+            del self.domainEventCallbacks
+            libvirtmod.virConnectDomainEventDeregister(self._o, self)
         except AttributeError:
-           pass
+            pass
 
         if self._o is not None:
             libvirtmod.virConnectClose(self._o)
@@ -25,7 +25,8 @@
             if len(self.domainEventCallbacks) == 0:
                 del self.domainEventCallbacks
                 ret = libvirtmod.virConnectDomainEventDeregister(self._o, self)
-                if ret == -1: raise libvirtError ('virConnectDomainEventDeregister() failed', conn=self)
+                if ret == -1:
+                    raise libvirtError('virConnectDomainEventDeregister() failed', conn=self)
         except AttributeError:
             pass
 
@@ -35,15 +36,16 @@
         try:
             self.domainEventCallbacks[cb] = opaque
         except AttributeError:
-            self.domainEventCallbacks = {cb:opaque}
+            self.domainEventCallbacks = {cb: opaque}
             ret = libvirtmod.virConnectDomainEventRegister(self._o, self)
-            if ret == -1: raise libvirtError ('virConnectDomainEventRegister() failed', conn=self)
+            if ret == -1:
+                raise libvirtError('virConnectDomainEventRegister() failed', conn=self)
 
     def _dispatchDomainEventCallbacks(self, dom, event, detail):
         """Dispatches events to python user domain event callbacks
         """
         try:
-            for cb,opaque in self.domainEventCallbacks.items():
+            for cb, opaque in self.domainEventCallbacks.items():
                 cb(self, virDomain(self, _obj=dom), event, detail, opaque)
             return 0
         except AttributeError:
@@ -73,7 +75,7 @@
         cb = cbData["cb"]
         opaque = cbData["opaque"]
 
-        cb(self, virDomain(self, _obj=dom), offset ,opaque)
+        cb(self, virDomain(self, _obj=dom), offset, opaque)
         return 0
 
     def _dispatchDomainEventWatchdogCallback(self, dom, action, cbData):
@@ -108,8 +110,8 @@
         return 0
 
     def _dispatchDomainEventGraphicsCallback(self, dom, phase, localAddr,
-                                            remoteAddr, authScheme, subject,
-                                            cbData):
+                                             remoteAddr, authScheme, subject,
+                                             cbData):
         """Dispatches events to python user domain graphics event callbacks
         """
         cb = cbData["cb"]
@@ -272,7 +274,8 @@
            domain callback will disable delivery of this event type """
         try:
             ret = libvirtmod.virConnectDomainEventDeregisterAny(self._o, callbackID)
-            if ret == -1: raise libvirtError ('virConnectDomainEventDeregisterAny() failed', conn=self)
+            if ret == -1:
+                raise libvirtError('virConnectDomainEventDeregisterAny() failed', conn=self)
             del self.domainEventCallbackID[callbackID]
         except AttributeError:
             pass
@@ -291,7 +294,8 @@
            network callback will disable delivery of this event type"""
         try:
             ret = libvirtmod.virConnectNetworkEventDeregisterAny(self._o, callbackID)
-            if ret == -1: raise libvirtError ('virConnectNetworkEventDeregisterAny() failed', conn=self)
+            if ret == -1:
+                raise libvirtError('virConnectNetworkEventDeregisterAny() failed', conn=self)
             del self.networkEventCallbackID[callbackID]
         except AttributeError:
             pass
@@ -301,13 +305,13 @@
            callback will enable delivery of the events"""
         if not hasattr(self, 'networkEventCallbackID'):
             self.networkEventCallbackID = {}
-        cbData = { "cb": cb, "conn": self, "opaque": opaque }
+        cbData = {"cb": cb, "conn": self, "opaque": opaque}
         if net is None:
             ret = libvirtmod.virConnectNetworkEventRegisterAny(self._o, None, eventID, cbData)
         else:
             ret = libvirtmod.virConnectNetworkEventRegisterAny(self._o, net._o, eventID, cbData)
         if ret == -1:
-            raise libvirtError ('virConnectNetworkEventRegisterAny() failed', conn=self)
+            raise libvirtError('virConnectNetworkEventRegisterAny() failed', conn=self)
         self.networkEventCallbackID[ret] = opaque
         return ret
 
@@ -316,13 +320,13 @@
            callback will enable delivery of the events """
         if not hasattr(self, 'domainEventCallbackID'):
             self.domainEventCallbackID = {}
-        cbData = { "cb": cb, "conn": self, "opaque": opaque }
+        cbData = {"cb": cb, "conn": self, "opaque": opaque}
         if dom is None:
             ret = libvirtmod.virConnectDomainEventRegisterAny(self._o, None, eventID, cbData)
         else:
             ret = libvirtmod.virConnectDomainEventRegisterAny(self._o, dom._o, eventID, cbData)
         if ret == -1:
-            raise libvirtError ('virConnectDomainEventRegisterAny() failed', conn=self)
+            raise libvirtError('virConnectDomainEventRegisterAny() failed', conn=self)
         self.domainEventCallbackID[ret] = opaque
         return ret
 
@@ -351,7 +355,8 @@
            storage pool callback will disable delivery of this event type"""
         try:
             ret = libvirtmod.virConnectStoragePoolEventDeregisterAny(self._o, callbackID)
-            if ret == -1: raise libvirtError ('virConnectStoragePoolEventDeregisterAny() failed', conn=self)
+            if ret == -1:
+                raise libvirtError('virConnectStoragePoolEventDeregisterAny() failed', conn=self)
             del self.storagePoolEventCallbackID[callbackID]
         except AttributeError:
             pass
@@ -361,13 +366,13 @@
            callback will enable delivery of the events"""
         if not hasattr(self, 'storagePoolEventCallbackID'):
             self.storagePoolEventCallbackID = {}
-        cbData = { "cb": cb, "conn": self, "opaque": opaque }
+        cbData = {"cb": cb, "conn": self, "opaque": opaque}
         if pool is None:
             ret = libvirtmod.virConnectStoragePoolEventRegisterAny(self._o, None, eventID, cbData)
         else:
             ret = libvirtmod.virConnectStoragePoolEventRegisterAny(self._o, pool._o, eventID, cbData)
         if ret == -1:
-            raise libvirtError ('virConnectStoragePoolEventRegisterAny() failed', conn=self)
+            raise libvirtError('virConnectStoragePoolEventRegisterAny() failed', conn=self)
         self.storagePoolEventCallbackID[ret] = opaque
         return ret
 
@@ -396,7 +401,8 @@
            node device callback will disable delivery of this event type"""
         try:
             ret = libvirtmod.virConnectNodeDeviceEventDeregisterAny(self._o, callbackID)
-            if ret == -1: raise libvirtError ('virConnectNodeDeviceEventDeregisterAny() failed', conn=self)
+            if ret == -1:
+                raise libvirtError('virConnectNodeDeviceEventDeregisterAny() failed', conn=self)
             del self.nodeDeviceEventCallbackID[callbackID]
         except AttributeError:
             pass
@@ -406,13 +412,13 @@
            callback will enable delivery of the events"""
         if not hasattr(self, 'nodeDeviceEventCallbackID'):
             self.nodeDeviceEventCallbackID = {}
-        cbData = { "cb": cb, "conn": self, "opaque": opaque }
+        cbData = {"cb": cb, "conn": self, "opaque": opaque}
         if dev is None:
             ret = libvirtmod.virConnectNodeDeviceEventRegisterAny(self._o, None, eventID, cbData)
         else:
             ret = libvirtmod.virConnectNodeDeviceEventRegisterAny(self._o, dev._o, eventID, cbData)
         if ret == -1:
-            raise libvirtError ('virConnectNodeDeviceEventRegisterAny() failed', conn=self)
+            raise libvirtError('virConnectNodeDeviceEventRegisterAny() failed', conn=self)
         self.nodeDeviceEventCallbackID[ret] = opaque
         return ret
 
@@ -439,7 +445,8 @@
            secret callback will disable delivery of this event type"""
         try:
             ret = libvirtmod.virConnectSecretEventDeregisterAny(self._o, callbackID)
-            if ret == -1: raise libvirtError ('virConnectSecretEventDeregisterAny() failed', conn=self)
+            if ret == -1:
+                raise libvirtError('virConnectSecretEventDeregisterAny() failed', conn=self)
             del self.secretEventCallbackID[callbackID]
         except AttributeError:
             pass
@@ -449,13 +456,13 @@
            callback will enable delivery of the events"""
         if not hasattr(self, 'secretEventCallbackID'):
             self.secretEventCallbackID = {}
-        cbData = { "cb": cb, "conn": self, "opaque": opaque }
+        cbData = {"cb": cb, "conn": self, "opaque": opaque}
         if secret is None:
             ret = libvirtmod.virConnectSecretEventRegisterAny(self._o, None, eventID, cbData)
         else:
             ret = libvirtmod.virConnectSecretEventRegisterAny(self._o, secret._o, eventID, cbData)
         if ret == -1:
-            raise libvirtError ('virConnectSecretEventRegisterAny() failed', conn=self)
+            raise libvirtError('virConnectSecretEventRegisterAny() failed', conn=self)
         self.secretEventCallbackID[ret] = opaque
         return ret
 
@@ -563,19 +570,19 @@
         cb(self, reason, opaque)
         return 0
 
-
     def unregisterCloseCallback(self):
         """Removes a close event callback"""
         ret = libvirtmod.virConnectUnregisterCloseCallback(self._o)
-        if ret == -1: raise libvirtError ('virConnectUnregisterCloseCallback() failed', conn=self)
+        if ret == -1:
+            raise libvirtError('virConnectUnregisterCloseCallback() failed', conn=self)
 
     def registerCloseCallback(self, cb, opaque):
         """Adds a close event callback, providing a notification
          when a connection fails / closes"""
-        cbData = { "cb": cb, "conn": self, "opaque": opaque }
+        cbData = {"cb": cb, "conn": self, "opaque": opaque}
         ret = libvirtmod.virConnectRegisterCloseCallback(self._o, cbData)
         if ret == -1:
-            raise libvirtError ('virConnectRegisterCloseCallback() failed', conn=self)
+            raise libvirtError('virConnectRegisterCloseCallback() failed', conn=self)
         return ret
 
     def createXMLWithFiles(self, xmlDesc, files, flags=0):
@@ -604,11 +611,12 @@
         libvirtd daemon. Any domains marked for auto destroy will
         block attempts at migration, save-to-file, or snapshots. """
         ret = libvirtmod.virDomainCreateXMLWithFiles(self._o, xmlDesc, files, flags)
-        if ret is None:raise libvirtError('virDomainCreateXMLWithFiles() failed', conn=self)
-        __tmp = virDomain(self,_obj=ret)
+        if ret is None:
+            raise libvirtError('virDomainCreateXMLWithFiles() failed', conn=self)
+        __tmp = virDomain(self, _obj=ret)
         return __tmp
 
-    def getAllDomainStats(self, stats = 0, flags=0):
+    def getAllDomainStats(self, stats=0, flags=0):
         """Query statistics for all domains on a given connection.
 
         Report statistics of various parameters for a running VM according to @stats
@@ -656,7 +664,7 @@
 
         retlist = list()
         for elem in ret:
-            record = (virDomain(self, _obj=elem[0]) , elem[1])
+            record = (virDomain(self, _obj=elem[0]), elem[1])
             retlist.append(record)
 
         return retlist
@@ -703,7 +711,7 @@
 
         retlist = list()
         for elem in ret:
-            record = (virDomain(self, _obj=elem[0]) , elem[1])
+            record = (virDomain(self, _obj=elem[0]), elem[1])
             retlist.append(record)
 
         return retlist
diff --git a/libvirt-override-virDomain.py b/libvirt-override-virDomain.py
index 7ce34f1..7541c01 100644
--- a/libvirt-override-virDomain.py
+++ b/libvirt-override-virDomain.py
@@ -10,7 +10,6 @@
 
         return retlist
 
-
     def listAllCheckpoints(self, flags=0):
         """List all checkpoints and returns a list of checkpoint objects"""
         ret = libvirtmod.virDomainListAllCheckpoints(self._o, flags)
@@ -23,7 +22,6 @@
 
         return retlist
 
-
     def createWithFiles(self, files, flags=0):
         """Launch a defined domain. If the call succeeds the domain moves from the
         defined to the running domains pools.
@@ -58,30 +56,35 @@
         If the VIR_DOMAIN_START_FORCE_BOOT flag is set, then any managed save
         file for this domain is discarded, and the domain boots from scratch. """
         ret = libvirtmod.virDomainCreateWithFiles(self._o, files, flags)
-        if ret == -1: raise libvirtError ('virDomainCreateWithFiles() failed', dom=self)
+        if ret == -1:
+            raise libvirtError('virDomainCreateWithFiles() failed', dom=self)
         return ret
 
     def fsFreeze(self, mountpoints=None, flags=0):
         """Freeze specified filesystems within the guest """
         ret = libvirtmod.virDomainFSFreeze(self._o, mountpoints, flags)
-        if ret == -1: raise libvirtError ('virDomainFSFreeze() failed', dom=self)
+        if ret == -1:
+            raise libvirtError('virDomainFSFreeze() failed', dom=self)
         return ret
 
     def fsThaw(self, mountpoints=None, flags=0):
         """Thaw specified filesystems within the guest """
         ret = libvirtmod.virDomainFSThaw(self._o, mountpoints, flags)
-        if ret == -1: raise libvirtError ('virDomainFSThaw() failed', dom=self)
+        if ret == -1:
+            raise libvirtError('virDomainFSThaw() failed', dom=self)
         return ret
 
     def getTime(self, flags=0):
         """Extract information about guest time """
         ret = libvirtmod.virDomainGetTime(self._o, flags)
-        if ret == None: raise libvirtError ('virDomainGetTime() failed', dom=self)
+        if ret == None:
+            raise libvirtError('virDomainGetTime() failed', dom=self)
         return ret
 
     def setTime(self, time=None, flags=0):
         """Set guest time to the given value. @time is a dict containing
         'seconds' field for seconds and 'nseconds' field for nanoseconds """
         ret = libvirtmod.virDomainSetTime(self._o, time, flags)
-        if ret == -1: raise libvirtError ('virDomainSetTime() failed', dom=self)
+        if ret == -1:
+            raise libvirtError('virDomainSetTime() failed', dom=self)
         return ret
diff --git a/libvirt-override-virStream.py b/libvirt-override-virStream.py
index bc42704..c9d70db 100644
--- a/libvirt-override-virStream.py
+++ b/libvirt-override-virStream.py
@@ -3,7 +3,7 @@
             if self.cb:
                 libvirtmod.virStreamEventRemoveCallback(self._o)
         except AttributeError:
-           pass
+            pass
 
         if self._o is not None:
             libvirtmod.virStreamFree(self._o)
@@ -21,9 +21,10 @@
 
     def eventAddCallback(self, events, cb, opaque):
         self.cb = cb
-        cbData = {"stream": self, "cb" : cb, "opaque" : opaque}
+        cbData = {"stream": self, "cb": cb, "opaque": opaque}
         ret = libvirtmod.virStreamEventAddCallback(self._o, events, cbData)
-        if ret == -1: raise libvirtError ('virStreamEventAddCallback() failed')
+        if ret == -1:
+            raise libvirtError('virStreamEventAddCallback() failed')
 
     def recvAll(self, handler, opaque):
         """Receive the entire data stream, sending the data to the
@@ -105,7 +106,8 @@
         the request would block, integer -2 is returned.
         """
         ret = libvirtmod.virStreamRecv(self._o, nbytes)
-        if ret is None: raise libvirtError ('virStreamRecv() failed')
+        if ret is None:
+            raise libvirtError('virStreamRecv() failed')
         return ret
 
     def send(self, data):
@@ -123,20 +125,22 @@
         subsequent call.
         """
         ret = libvirtmod.virStreamSend(self._o, data)
-        if ret == -1: raise libvirtError ('virStreamSend() failed')
+        if ret == -1:
+            raise libvirtError('virStreamSend() failed')
         return ret
 
-    def recvHole(self, flags = 0):
+    def recvHole(self, flags=0):
         """This method is used to determine the length in bytes
         of the empty space to be created in a stream's target
         file when uploading or downloading sparsely populated
         files. This is the counterpart to sendHole.
         """
         ret = libvirtmod.virStreamRecvHole(self._o, flags)
-        if ret is None: raise libvirtError ('virStreamRecvHole() failed')
+        if ret is None:
+            raise libvirtError('virStreamRecvHole() failed')
         return ret
 
-    def sendHole(self, length, flags = 0):
+    def sendHole(self, length, flags=0):
         """Rather than transmitting empty file space, this method
         directs the stream target to create length bytes of empty
         space.  This method would be used when uploading or
@@ -144,10 +148,11 @@
         needless copy of empty file space.
         """
         ret = libvirtmod.virStreamSendHole(self._o, length, flags)
-        if ret == -1: raise libvirtError('virStreamSendHole() failed')
+        if ret == -1:
+            raise libvirtError('virStreamSendHole() failed')
         return ret
 
-    def recvFlags(self, nbytes, flags = 0):
+    def recvFlags(self, nbytes, flags=0):
         """Reads a series of bytes from the stream. This method may
         block the calling application for an arbitrary amount
         of time. This is just like recv except it has flags
@@ -162,7 +167,8 @@
         the request would block, integer -2 is returned.
         """
         ret = libvirtmod.virStreamRecvFlags(self._o, nbytes, flags)
-        if ret is None: raise libvirtError ('virStreamRecvFlags() failed')
+        if ret is None:
+            raise libvirtError('virStreamRecvFlags() failed')
         return ret
 
     def sparseRecvAll(self, handler, holeHandler, opaque):
diff --git a/libvirt-override.py b/libvirt-override.py
index ba01c89..ff422a6 100644
--- a/libvirt-override.py
+++ b/libvirt-override.py
@@ -78,6 +78,7 @@ class libvirtError(Exception):
             return None
         return self.err[8]
 
+
 #
 # register the libvirt global error handler
 #
@@ -86,18 +87,20 @@ def registerErrorHandler(f, ctx):
        The function is called back as f(ctx, error), with error
        being a list of information about the error being raised.
        Returns 1 in case of success."""
-    return libvirtmod.virRegisterErrorHandler(f,ctx)
+    return libvirtmod.virRegisterErrorHandler(f, ctx)
+
 
 def openAuth(uri, auth, flags=0):
     ret = libvirtmod.virConnectOpenAuth(uri, auth, flags)
-    if ret is None:raise libvirtError('virConnectOpenAuth() failed')
+    if ret is None:
+        raise libvirtError('virConnectOpenAuth() failed')
     return virConnect(_obj=ret)
 
 
 #
 # Return library version.
 #
-def getVersion (name = None):
+def getVersion(name=None):
     """If no name parameter is passed (or name is None) then the
     version of the libvirt library is returned as an integer.
 
@@ -110,10 +113,11 @@ def getVersion (name = None):
 
     Versions numbers are integers: 1000000*major + 1000*minor + release."""
     if name is None:
-        ret = libvirtmod.virGetVersion ()
+        ret = libvirtmod.virGetVersion()
     else:
-        ret = libvirtmod.virGetVersion (name)
-    if ret is None: raise libvirtError ("virGetVersion() failed")
+        ret = libvirtmod.virGetVersion(name)
+    if ret is None:
+        raise libvirtError("virGetVersion() failed")
     return ret
 
 
@@ -137,6 +141,7 @@ def _eventInvokeHandleCallback(watch, fd, event, opaque, opaquecompat=None):
 
     libvirtmod.virEventInvokeHandleCallback(watch, fd, event, callback, opaque)
 
+
 #
 # Invoke an EventTimeout callback
 #
@@ -157,6 +162,7 @@ def _eventInvokeTimeoutCallback(timer, opaque, opaquecompat=None):
 
     libvirtmod.virEventInvokeTimeoutCallback(timer, callback, opaque)
 
+
 def _dispatchEventHandleCallback(watch, fd, events, cbData):
     cb = cbData["cb"]
     opaque = cbData["opaque"]
@@ -164,6 +170,7 @@ def _dispatchEventHandleCallback(watch, fd, events, cbData):
     cb(watch, fd, events, opaque)
     return 0
 
+
 def _dispatchEventTimeoutCallback(timer, cbData):
     cb = cbData["cb"]
     opaque = cbData["opaque"]
@@ -171,6 +178,7 @@ def _dispatchEventTimeoutCallback(timer, cbData):
     cb(timer, opaque)
     return 0
 
+
 def virEventAddHandle(fd, events, cb, opaque):
     """
     register a callback for monitoring file handle events
@@ -186,11 +194,13 @@ def virEventAddHandle(fd, events, cb, opaque):
                events,  # int bitmap of events that have occurred
                opaque): # opaque data passed to eventAddHandle
     """
-    cbData = {"cb" : cb, "opaque" : opaque}
+    cbData = {"cb": cb, "opaque": opaque}
     ret = libvirtmod.virEventAddHandle(fd, events, cbData)
-    if ret == -1: raise libvirtError ('virEventAddHandle() failed')
+    if ret == -1:
+        raise libvirtError('virEventAddHandle() failed')
     return ret
 
+
 def virEventAddTimeout(timeout, cb, opaque):
     """
     register a callback for a timer event
@@ -206,9 +216,10 @@ def virEventAddTimeout(timeout, cb, opaque):
         def cb(timer,   # int id of the timer
                opaque): # opaque data passed to eventAddTimeout
     """
-    cbData = {"cb" : cb, "opaque" : opaque}
+    cbData = {"cb": cb, "opaque": opaque}
     ret = libvirtmod.virEventAddTimeout(timeout, cbData)
-    if ret == -1: raise libvirtError ('virEventAddTimeout() failed')
+    if ret == -1:
+        raise libvirtError('virEventAddTimeout() failed')
     return ret
 
 
diff --git a/libvirt-qemu-override.py b/libvirt-qemu-override.py
index 265a252..cba96a1 100644
--- a/libvirt-qemu-override.py
+++ b/libvirt-qemu-override.py
@@ -1,5 +1,6 @@
 # Manually written part of python bindings for libvirt-qemu
 
+
 def _dispatchQemuMonitorEventCallback(conn, dom, event, seconds, micros, details, cbData):
     """Dispatches events to python user qemu monitor event callbacks
     """
@@ -9,27 +10,30 @@ def _dispatchQemuMonitorEventCallback(conn, dom, event, seconds, micros, details
     cb(conn, libvirt.virDomain(conn, _obj=dom), event, seconds, micros, details, opaque)
     return 0
 
+
 def qemuMonitorEventDeregister(conn, callbackID):
     """Removes a qemu monitor event callback. De-registering for a callback
        will disable delivery of this event type"""
     try:
         ret = libvirtmod_qemu.virConnectDomainQemuMonitorEventDeregister(conn._o, callbackID)
-        if ret == -1: raise libvirt.libvirtError ('virConnectDomainQemuMonitorEventDeregister() failed')
+        if ret == -1:
+            raise libvirt.libvirtError('virConnectDomainQemuMonitorEventDeregister() failed')
         del conn.qemuMonitorEventCallbackID[callbackID]
     except AttributeError:
         pass
 
+
 def qemuMonitorEventRegister(conn, dom, event, cb, opaque, flags=0):
     """Adds a qemu monitor event callback. Registering for a monitor
        callback will enable delivery of the events"""
     if not hasattr(conn, 'qemuMonitorEventCallbackID'):
         conn.qemuMonitorEventCallbackID = {}
-    cbData = { "cb": cb, "conn": conn, "opaque": opaque }
+    cbData = {"cb": cb, "conn": conn, "opaque": opaque}
     if dom is None:
         ret = libvirtmod_qemu.virConnectDomainQemuMonitorEventRegister(conn._o, None, event, cbData, flags)
     else:
         ret = libvirtmod_qemu.virConnectDomainQemuMonitorEventRegister(conn._o, dom._o, event, cbData, flags)
     if ret == -1:
-        raise libvirt.libvirtError ('virConnectDomainQemuMonitorEventRegister() failed')
+        raise libvirt.libvirtError('virConnectDomainQemuMonitorEventRegister() failed')
     conn.qemuMonitorEventCallbackID[ret] = opaque
     return ret
diff --git a/libvirtaio.py b/libvirtaio.py
index f1811c1..1e8b0c7 100644
--- a/libvirtaio.py
+++ b/libvirtaio.py
@@ -78,6 +78,7 @@ class Callback(object):
         self.impl.log.debug('callback %d close(), scheduling ff', self.iden)
         self.impl.schedule_ff_callback(self.iden, self.opaque)
 
+
 #
 # file descriptors
 #
@@ -114,8 +115,8 @@ class Descriptor(object):
 
         # For the edge case of empty callbacks, any() returns False.
         if any(callback.event & ~(
-                    libvirt.VIR_EVENT_HANDLE_READABLE |
-                    libvirt.VIR_EVENT_HANDLE_WRITABLE)
+            libvirt.VIR_EVENT_HANDLE_READABLE |
+            libvirt.VIR_EVENT_HANDLE_WRITABLE)
                 for callback in self.callbacks.values()):
             warnings.warn(
                 'The only event supported are VIR_EVENT_HANDLE_READABLE '
@@ -161,6 +162,7 @@ class Descriptor(object):
         self.update()
         return callback
 
+
 class DescriptorDict(dict):
     '''Descriptors collection
 
@@ -175,6 +177,7 @@ class DescriptorDict(dict):
         self[fd] = descriptor
         return descriptor
 
+
 class FDCallback(Callback):
     '''Callback for file descriptor (watcher)
 
@@ -197,6 +200,7 @@ class FDCallback(Callback):
         self.event = event
         self.descriptor.update()
 
+
 #
 # timeouts
 #
@@ -242,7 +246,7 @@ class TimeoutCallback(Callback):
         if self.timeout >= 0 and self._task is None:
             self.impl.log.debug('timer %r start', self.iden)
             self._task = ensure_future(self._timer(),
-                loop=self.impl.loop)
+                                       loop=self.impl.loop)
 
         elif self.timeout < 0 and self._task is not None:
             self.impl.log.debug('timer %r stop', self.iden)
@@ -254,6 +258,7 @@ class TimeoutCallback(Callback):
         self.update(timeout=-1)
         super(TimeoutCallback, self).close()
 
+
 #
 # main implementation
 #
@@ -298,7 +303,7 @@ class virEventAsyncIOImpl(object):
         # pylint: disable=bad-whitespace
         self.log.debug('register()')
         libvirt.virEventRegisterImpl(
-            self._add_handle,  self._update_handle,  self._remove_handle,
+            self._add_handle, self._update_handle, self._remove_handle,
             self._add_timeout, self._update_timeout, self._remove_timeout)
         return self
 
@@ -350,11 +355,11 @@ class virEventAsyncIOImpl(object):
             https://libvirt.org/html/libvirt-libvirt-event.html#virEventAddHandleFuncFunc
         '''
         callback = FDCallback(self, cb, opaque,
-                descriptor=self.descriptors[fd], event=event)
+                              descriptor=self.descriptors[fd], event=event)
         assert callback.iden not in self.callbacks
 
         self.log.debug('add_handle(fd=%d, event=%d, cb=..., opaque=...) = %d',
-                fd, event, callback.iden)
+                       fd, event, callback.iden)
         self.callbacks[callback.iden] = callback
         self.descriptors[fd].add_handle(callback)
         self._pending_inc()
@@ -410,7 +415,7 @@ class virEventAsyncIOImpl(object):
         assert callback.iden not in self.callbacks
 
         self.log.debug('add_timeout(timeout=%d, cb=..., opaque=...) = %d',
-                timeout, callback.iden)
+                       timeout, callback.iden)
         self.callbacks[callback.iden] = callback
         callback.update(timeout=timeout)
         self._pending_inc()
@@ -448,10 +453,13 @@ class virEventAsyncIOImpl(object):
 
 
 _current_impl = None
+
+
 def getCurrentImpl():
     '''Return the current implementation, or None if not yet registered'''
     return _current_impl
 
+
 def virEventRegisterAsyncIOImpl(loop=None):
     '''Arrange for libvirt's callbacks to be dispatched via asyncio event loop
 
diff --git a/sanitytest.py b/sanitytest.py
index f187c15..90e6a7a 100644
--- a/sanitytest.py
+++ b/sanitytest.py
@@ -22,6 +22,7 @@ def get_libvirt_api_xml_path():
         sys.exit(proc.returncode)
     return stdout.splitlines()[0]
 
+
 # Path to the libvirt API XML file
 if len(sys.argv) >= 3:
     xml = sys.argv[2]
@@ -96,7 +97,7 @@ for n in set:
 # Phase 2: Identify all classes and methods in the 'libvirt' python module
 gotenums = []
 gottypes = []
-gotfunctions = { "libvirt": [] }
+gotfunctions = {"libvirt": []}
 
 for name in dir(libvirt):
     if name[0] == '_':
@@ -188,7 +189,6 @@ for cname in wantfunctions:
         name.endswith("Callback")):
         continue
 
-
     # virEvent APIs go into main 'libvirt' namespace not any class
     if name[0:8] == "virEvent":
         if name[-4:] == "Func":
@@ -231,7 +231,6 @@ for name in sorted(basicklassmap):
         else:
             continue
 
-
     # All the error handling methods need special handling
     if klass == "libvirt":
         if func in ["CopyLastError", "DefaultErrorFunc",
@@ -264,7 +263,7 @@ for name in sorted(basicklassmap):
                 "LookupByUUIDString", "LookupByVolume" "LookupByName",
                 "LookupByID", "LookupByName", "LookupByKey", "LookupByPath",
                 "LookupByMACString", "LookupByUsage", "LookupByVolume",
-                "LookupByTargetPath","LookupSCSIHostByWWN", "LookupByPortDev",
+                "LookupByTargetPath", "LookupSCSIHostByWWN", "LookupByPortDev",
                 "Restore", "RestoreFlags",
                 "SaveImageDefineXML", "SaveImageGetXMLDesc", "DefineXMLFlags"]:
         if klass != "virDomain":
@@ -386,7 +385,7 @@ for name in sorted(finalklassmap):
     # These exist in C and exist in python, but we've got
     # a pure-python impl so don't check them
     if name in ["virStreamRecvAll", "virStreamSendAll",
-            "virStreamSparseRecvAll", "virStreamSparseSendAll"]:
+                "virStreamSparseRecvAll", "virStreamSparseSendAll"]:
         continue
 
     try:
diff --git a/tests/test_conn.py b/tests/test_conn.py
index 9fee099..a5eb797 100644
--- a/tests/test_conn.py
+++ b/tests/test_conn.py
@@ -1,7 +1,7 @@
-
 import unittest
 import libvirt
 
+
 class TestLibvirtConn(unittest.TestCase):
     def setUp(self):
         self.conn = libvirt.open("test:///default")
diff --git a/tests/test_domain.py b/tests/test_domain.py
index b3fe255..2b3710b 100644
--- a/tests/test_domain.py
+++ b/tests/test_domain.py
@@ -1,7 +1,7 @@
-
 import unittest
 import libvirt
 
+
 class TestLibvirtDomain(unittest.TestCase):
     def setUp(self):
         self.conn = libvirt.open("test:///default")