tui: Clean up rest of pylint

src/virtManagerTui/adddomain.py

@@ -56,22 +56,62 @@ class DomainConfigScreen(ConfigScreen):
         self.__config.set_architecture(self.get_libvirt().get_default_architecture())
         self.__config.set_virt_type(self.get_libvirt().get_default_virt_type())
 
+        self.__guest_name = None
+        self.__install_url = None
+        self.__storage_volume = None
+        self.__network_bridges = None
+        self.__os_types = None
+        self.__os_variants = None
+        self.__virt_types = None
+        self.__storage_size = None
+        self.__storage_type = None
+        self.__storage_pool = None
+        self.__kickstart_url = None
+        self.__kernel_options = None
+        self.__install_type = None
+        self.__cpus = None
+        self.__memory = None
+        self.__allocate_storage = None
+        self.__enable_storage = None
+        self.__has_volumes = None
+        self.__install_media = None
+        self.__has_pools = None
+        self.__mac_address = None
+        self.__architectures = None
+        self.__iso_path = None
+        self.__install_source = None
+
     def get_elements_for_page(self, screen, page):
-        if page is VM_DETAILS_PAGE:        return self.get_vm_details_page(screen)
+        if page is VM_DETAILS_PAGE:
-        elif page is LOCAL_INSTALL_PAGE:   return self.get_local_install_page(screen)
+            return self.get_vm_details_page(screen)
-        elif page is SELECT_CDROM_PAGE:    return self.get_select_cdrom_page(screen)
+        elif page is LOCAL_INSTALL_PAGE:
-        elif page is SELECT_ISO_PAGE:      return self.get_select_iso_page(screen)
+            return self.get_local_install_page(screen)
-        elif page is NETWORK_INSTALL_PAGE: return self.get_network_install_page(screen)
+        elif page is SELECT_CDROM_PAGE:
-        elif page is OS_TYPE_PAGE:         return self.get_os_type_page(screen)
+            return self.get_select_cdrom_page(screen)
-        elif page is OS_VARIANT_PAGE:      return self.get_os_variant_page(screen)
+        elif page is SELECT_ISO_PAGE:
-        elif page is RAM_CPU_PAGE:         return self.get_ram_and_cpu_page(screen)
+            return self.get_select_iso_page(screen)
-        elif page is ENABLE_STORAGE_PAGE:  return self.get_enable_storage_page(screen)
+        elif page is NETWORK_INSTALL_PAGE:
-        elif page is LOCAL_STORAGE_PAGE:   return self.get_local_storage_page(screen)
+            return self.get_network_install_page(screen)
-        elif page is SELECT_POOL_PAGE:     return self.get_select_pool_page(screen)
+        elif page is OS_TYPE_PAGE:
-        elif page is SELECT_VOLUME_PAGE:   return self.get_select_volume_page(screen)
+            return self.get_os_type_page(screen)
-        elif page is BRIDGE_PAGE:          return self.get_bridge_page(screen)
+        elif page is OS_VARIANT_PAGE:
-        elif page is VIRT_DETAILS_PAGE:    return self.get_virt_details_page(screen)
+            return self.get_os_variant_page(screen)
-        elif page is CONFIRM_PAGE:         return self.get_confirm_page(screen)
+        elif page is RAM_CPU_PAGE:
+            return self.get_ram_and_cpu_page(screen)
+        elif page is ENABLE_STORAGE_PAGE:
+            return self.get_enable_storage_page(screen)
+        elif page is LOCAL_STORAGE_PAGE:
+            return self.get_local_storage_page(screen)
+        elif page is SELECT_POOL_PAGE:
+            return self.get_select_pool_page(screen)
+        elif page is SELECT_VOLUME_PAGE:
+            return self.get_select_volume_page(screen)
+        elif page is BRIDGE_PAGE:
+            return self.get_bridge_page(screen)
+        elif page is VIRT_DETAILS_PAGE:
+            return self.get_virt_details_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
         return []
 
     def get_page_list(self):
@@ -130,8 +170,10 @@ class DomainConfigScreen(ConfigScreen):
                 return True
             else:
                 errors.append("An install tree is required.")
-        elif page is OS_TYPE_PAGE: return True
+        elif page is OS_TYPE_PAGE:
-        elif page is OS_VARIANT_PAGE: return True
+            return True
+        elif page is OS_VARIANT_PAGE:
+            return True
         elif page is RAM_CPU_PAGE:
             if (len(self.__memory.value()) > 0 and len(self.__cpus.value()) > 0) \
                     and  (int(self.__memory.value()) > 0 and int(self.__cpus.value()) > 0):
@@ -145,7 +187,8 @@ class DomainConfigScreen(ConfigScreen):
                     errors.append("A value must be entered for CPUs.")
                 elif int(self.__cpus.value()) <= 0:
                     errors.append("A positive integer value must be entered for memory.")
-        elif page is ENABLE_STORAGE_PAGE: return True
+        elif page is ENABLE_STORAGE_PAGE:
+            return True
         elif page is LOCAL_STORAGE_PAGE:
             if len(self.__storage_size.value()) > 0:
                 if float(self.__storage_size.value()) > 0:
@@ -180,7 +223,8 @@ class DomainConfigScreen(ConfigScreen):
                 errors.append("Please select a virtualization type.")
             if self.__architectures.getSelection() is None:
                 errors.append("Please selection an architecture.")
-        elif page is CONFIRM_PAGE: return True
+        elif page is CONFIRM_PAGE:
+            return True
         return False
 
     def process_input(self, page):
@@ -257,7 +301,8 @@ class DomainConfigScreen(ConfigScreen):
             else:
                 result = SELECT_VOLUME_PAGE
         else:
-            if page > 1: result = page - 1
+            if page > 1:
+                result = page - 1
         return result
 
     def get_next_page(self, page):
@@ -293,12 +338,15 @@ class DomainConfigScreen(ConfigScreen):
         return result
 
     def page_has_finish(self, page):
-        if page is CONFIRM_PAGE: return True
+        if page is CONFIRM_PAGE:
+            return True
         return False
 
     def page_has_next(self, page):
-        if   page is SELECT_POOL_PAGE: return self.__has_pools
+        if   page is SELECT_POOL_PAGE:
-        elif page is SELECT_VOLUME_PAGE: return self.__has_volumes
+            return self.__has_pools
+        elif page is SELECT_VOLUME_PAGE:
+            return self.__has_volumes
         elif page < CONFIRM_PAGE:
             return True
 

src/virtManagerTui/addhost.py

@@ -43,10 +43,16 @@ class AddHostConfigScreen(ConfigScreen):
     def __init__(self):
         ConfigScreen.__init__(self, "Add A Remote Host")
         self.__configured = False
+        self.__connection = None
+        self.__hostname = None
+        self.__autoconnect = None
+        self.__hypervisor = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is DETAILS_PAGE: return self.get_details_page(screen)
+        if page is DETAILS_PAGE:
-        elif page is CONFIRM_PAGE: return self.get_confirm_page(screen)
+            return self.get_details_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def page_has_next(self, page):
         return page < CONFIRM_PAGE
@@ -65,7 +71,8 @@ class AddHostConfigScreen(ConfigScreen):
                 return True
             else:
                 errors.append("You must enter a remote hostname.")
-        elif page is CONFIRM_PAGE: return True
+        elif page is CONFIRM_PAGE:
+            return True
         return False
 
     def process_input(self, page):
@@ -75,15 +82,23 @@ class AddHostConfigScreen(ConfigScreen):
             hostname = self.__hostname.value()
 
             if   hv is HYPERVISOR_XEN:
-                if   conn is CONNECTION_LOCAL:    url = "xen:///"
+                if   conn is CONNECTION_LOCAL:
-                elif conn is CONNECTION_KERBEROS: url = "xen+tcp:///" + hostname + "/"
+                    url = "xen:///"
-                elif conn is CONNECTION_SSL:      url = "xen+tls:///" + hostname + "/"
+                elif conn is CONNECTION_KERBEROS:
-                elif conn is CONNECTION_SSH:      url = "xen+ssh:///" + hostname + "/"
+                    url = "xen+tcp:///" + hostname + "/"
+                elif conn is CONNECTION_SSL:
+                    url = "xen+tls:///" + hostname + "/"
+                elif conn is CONNECTION_SSH:
+                    url = "xen+ssh:///" + hostname + "/"
             elif hv is HYPERVISOR_KVM:
-                if   conn is CONNECTION_LOCAL:    url = "qemu:///system"
+                if   conn is CONNECTION_LOCAL:
-                elif conn is CONNECTION_KERBEROS: url = "qemu+tcp://" + hostname + "/system"
+                    url = "qemu:///system"
-                elif conn is CONNECTION_SSL:      url = "qemu+tls://" + hostname + "/system"
+                elif conn is CONNECTION_KERBEROS:
-                elif conn is CONNECTION_SSH:      url = "qemu+ssh://" + hostname + "/system"
+                    url = "qemu+tcp://" + hostname + "/system"
+                elif conn is CONNECTION_SSL:
+                    url = "qemu+tls://" + hostname + "/system"
+                elif conn is CONNECTION_SSH:
+                    url = "qemu+ssh://" + hostname + "/system"
 
             self.get_virt_manager_config().add_connection(url)
             self.set_finished()
@@ -127,7 +142,8 @@ class AddHostConfigScreen(ConfigScreen):
         grid.setField(snack.Label(hostname), 1, 2, anchorLeft = 1)
         grid.setField(snack.Label("Autoconnect on Startup:"), 0, 3, anchorRight = 1)
         label = "Yes"
-        if not self.__autoconnect.value(): label = "No"
+        if not self.__autoconnect.value():
+            label = "No"
         grid.setField(snack.Label(label), 1, 3, anchorLeft = 1)
         return [snack.Label("Confirm Connection"),
                 grid]

src/virtManagerTui/addpool.py

@@ -31,11 +31,21 @@ class AddStoragePoolConfigScreen(ConfigScreen):
     def __init__(self):
         ConfigScreen.__init__(self, "Add A Storage Pool")
         self.__config = PoolConfig(self.get_libvirt())
+        self.__hostname = None
+        self.__formats = None
+        self.__name = None
+        self.__type = None
+        self.__build_pool = None
+        self.__target_path = None
+        self.__source_path = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is POOL_NAME_PAGE:    return self.get_pool_name_page(screen)
+        if   page is POOL_NAME_PAGE:
-        elif page is POOL_DETAILS_PAGE: return self.get_pool_details_page(screen)
+            return self.get_pool_name_page(screen)
-        elif page is CONFIRM_PAGE:      return self.get_confirm_page(screen)
+        elif page is POOL_DETAILS_PAGE:
+            return self.get_pool_details_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def page_has_next(self, page):
         return page < CONFIRM_PAGE
@@ -83,7 +93,8 @@ class AddStoragePoolConfigScreen(ConfigScreen):
                     errors.append("you  must enter a source path.")
                     result = False
             return result
-        elif page is CONFIRM_PAGE: return True
+        elif page is CONFIRM_PAGE:
+            return True
         return False
 
     def process_input(self, page):

src/virtManagerTui/addvolume.py

@@ -33,23 +33,34 @@ class AddVolumeConfigScreen(StorageListConfigScreen):
     def __init__(self):
         StorageListConfigScreen.__init__(self, "Add A New Storage Volume")
         self.__config = StorageVolumeConfig()
+        self.__name = None
+        self.__capacity = None
+        self.__allocation = None
+        self.__formats = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is SELECT_POOL_PAGE:   return self.get_storage_pool_list_page(screen)
+        if   page is SELECT_POOL_PAGE:
-        elif page is VOLUME_NAME_PAGE:   return self.get_volume_name_page(screen)
+            return self.get_storage_pool_list_page(screen)
-        elif page is VOLUME_FORMAT_PAGE: return self.get_volume_format_page(screen)
+        elif page is VOLUME_NAME_PAGE:
-        elif page is MAX_CAPACITY_PAGE:  return self.get_max_capacity_page(screen)
+            return self.get_volume_name_page(screen)
-        elif page is CONFIRM_PAGE:       return self.get_confirm_page(screen)
+        elif page is VOLUME_FORMAT_PAGE:
+            return self.get_volume_format_page(screen)
+        elif page is MAX_CAPACITY_PAGE:
+            return self.get_max_capacity_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def page_has_next(self, page):
         if page is SELECT_POOL_PAGE:
             return self.has_selectable_pools()
         else:
-            if page < CONFIRM_PAGE: return True
+            if page < CONFIRM_PAGE:
+                return True
         return False
 
     def page_has_back(self, page):
-        if page > SELECT_POOL_PAGE: return True
+        if page > SELECT_POOL_PAGE:
+            return True
         return False
 
     def page_has_finish(self, page):
@@ -109,7 +120,8 @@ class AddVolumeConfigScreen(StorageListConfigScreen):
                     errors.append("An allocation value must be entered.")
             else:
                 errors.append("A maximum volume capacity must be entered.")
-        elif page is CONFIRM_PAGE: return True
+        elif page is CONFIRM_PAGE:
+            return True
         return False
 
     def process_input(self, page):

src/virtManagerTui/changehost.py

@@ -32,17 +32,21 @@ class ChangeHostConfigScreen(HostListConfigScreen):
         return "Currently: %s" % self.get_libvirt().get_url()
 
     def get_elements_for_page(self, screen, page):
-        if   page is CONNECTION_LIST_PAGE: return self.get_connection_list_page(screen)
+        if   page is CONNECTION_LIST_PAGE:
-        elif page is CONNECTED_PAGE:       return self.get_connected_page(screen)
+            return self.get_connection_list_page(screen)
+        elif page is CONNECTED_PAGE:
+            return self.get_connected_page(screen)
 
     def process_input(self, page):
         if   page is CONNECTION_LIST_PAGE:
             logging.info("Changing libvirt connection to %s" % self.get_selected_connection())
             self.get_libvirt().open_connection(self.get_selected_connection())
-        elif page is CONNECTED_PAGE: self.set_finished()
+        elif page is CONNECTED_PAGE:
+            self.set_finished()
 
     def page_has_next(self, page):
-        if page is CONNECTION_LIST_PAGE: return self.has_selectable_connections()
+        if page is CONNECTION_LIST_PAGE:
+            return self.has_selectable_connections()
         return False
 
     def page_has_back(self, page):

src/virtManagerTui/configscreen.py

@@ -66,7 +66,8 @@ class ConfigScreen:
         return False
 
     def get_back_page(self, page):
-        if page > 1: return page - 1
+        if page > 1:
+            return page - 1
         return page
 
     def go_back(self):
@@ -124,9 +125,12 @@ class ConfigScreen:
                 current_element += 1
             # create the navigation buttons
             buttons = []
-            if self.__current_page > 1: buttons.append(["Back", BACK_BUTTON, "F11"])
+            if self.__current_page > 1:
-            if self.page_has_next(self.__current_page): buttons.append(["Next", NEXT_BUTTON, "F12"])
+                buttons.append(["Back", BACK_BUTTON, "F11"])
-            if self.page_has_finish(self.__current_page): buttons.append(["Finish", FINISH_BUTTON, "F10"])
+            if self.page_has_next(self.__current_page):
+                buttons.append(["Next", NEXT_BUTTON, "F12"])
+            if self.page_has_finish(self.__current_page):
+                buttons.append(["Finish", FINISH_BUTTON, "F10"])
             buttons.append(["Cancel", CANCEL_BUTTON, "ESC"])
             buttonbar = snack.ButtonBar(screen, buttons)
             content.setField(buttonbar, 0, current_element, growx = 1)
@@ -165,6 +169,8 @@ class DomainListConfigScreen(ConfigScreen):
 
     def __init__(self, title):
         ConfigScreen.__init__(self, title)
+        self.__has_domains = None
+        self.__domain_list = None
 
     def get_domain_list_page(self, screen, defined=True, created=True):
         ignore = screen
@@ -198,6 +204,8 @@ class NetworkListConfigScreen(ConfigScreen):
 
     def __init__(self, title):
         ConfigScreen.__init__(self, title)
+        self.__has_networks = None
+        self.__network_list = None
 
     def get_network_list_page(self, screen, defined=True, started=True):
         ignore = screen
@@ -231,6 +239,10 @@ class StorageListConfigScreen(ConfigScreen):
 
     def __init__(self, title):
         ConfigScreen.__init__(self, title)
+        self.__has_pools = None
+        self.__pools_list = None
+        self.__has_volumes = None
+        self.__volumes_list = None
 
     def get_storage_pool_list_page(self, screen, defined=True, created=True):
         ignore = screen
@@ -285,6 +297,8 @@ class HostListConfigScreen(ConfigScreen):
 
     def __init__(self, title):
         ConfigScreen.__init__(self, title)
+        self.__has_connections = None
+        self.__connection_list = None
 
     def get_connection_list_page(self, screen):
         ignore = screen

src/virtManagerTui/createuser.py

@@ -31,12 +31,17 @@ class CreateUserConfigScreen(ConfigScreen):
     def __init__(self):
         ConfigScreen.__init__(self, "Create A User Account")
         self.__username = None
+        self.__password = None
+        self.__confirm = None
+        self.__adminuser = None
         self.__useradmin = libuser.admin()
         self.__user_worker = UserWorker()
 
     def get_elements_for_page(self, screen, page):
-        if   page is DETAILS_PAGE: return self.get_details_page(screen)
+        if   page is DETAILS_PAGE:
-        elif page is CONFIRM_PAGE: return self.get_confirm_page(screen)
+            return self.get_details_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def validate_input(self, page, errors):
         if page is DETAILS_PAGE:

src/virtManagerTui/definenet.py

@@ -37,16 +37,30 @@ class DefineNetworkConfigScreen(ConfigScreen):
     def __init__(self):
         ConfigScreen.__init__(self, "Create A Virtual Network Interface")
         self.__config = NetworkConfig()
+        self.__end_address = None
+        self.__start_address = None
+        self.__name = None
+        self.__isolated_network = None
+        self.__physical_devices = None
+        self.__ipv4_address = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is NETWORK_NAME_PAGE:            return self.get_network_name_page(screen)
+        if   page is NETWORK_NAME_PAGE:
-        elif page is IPV4_ADDRESS_PAGE:            return self.get_ipv4_address_page(screen)
+            return self.get_network_name_page(screen)
-        elif page is PUBLIC_NETWORK_ALERT_PAGE:    return self.get_public_network_alert_page(screen)
+        elif page is IPV4_ADDRESS_PAGE:
-        elif page is NETWORK_DETAILS_PAGE:         return self.get_network_details_page(screen)
+            return self.get_ipv4_address_page(screen)
-        elif page is DHCP_RANGE_PAGE:              return self.get_dhcp_range_page(screen)
+        elif page is PUBLIC_NETWORK_ALERT_PAGE:
-        elif page is NETWORK_TYPE_PAGE:            return self.get_network_type_page(screen)
+            return self.get_public_network_alert_page(screen)
-        elif page is SELECT_PHYSICAL_NETWORK_PAGE: return self.get_select_physical_network_page(screen)
+        elif page is NETWORK_DETAILS_PAGE:
-        elif page is SUMMARY_PAGE:                 return self.get_summary_page(screen)
+            return self.get_network_details_page(screen)
+        elif page is DHCP_RANGE_PAGE:
+            return self.get_dhcp_range_page(screen)
+        elif page is NETWORK_TYPE_PAGE:
+            return self.get_network_type_page(screen)
+        elif page is SELECT_PHYSICAL_NETWORK_PAGE:
+            return self.get_select_physical_network_page(screen)
+        elif page is SUMMARY_PAGE:
+            return self.get_summary_page(screen)
 
     def validate_input(self, page, errors):
         if page is NETWORK_NAME_PAGE:
@@ -66,8 +80,10 @@ class DefineNetworkConfigScreen(ConfigScreen):
                     errors.append("The network address could not be understood: %s" % str(error))
             else:
                 errors.append("Network must be entered in the format 1.2.3.4/8")
-        elif page is PUBLIC_NETWORK_ALERT_PAGE: return True
+        elif page is PUBLIC_NETWORK_ALERT_PAGE:
-        elif page is NETWORK_DETAILS_PAGE: return True
+            return True
+        elif page is NETWORK_DETAILS_PAGE:
+            return True
         elif page is DHCP_RANGE_PAGE:
             try:
                 if len(self.__start_address.value()) > 0 and len(self.__end_address.value()) > 0:
@@ -82,9 +98,12 @@ class DefineNetworkConfigScreen(ConfigScreen):
             except Exception, error:
                 logging.error(str(error))
                 errors.append("The start and/or end addresses could not be understood.")
-        elif page is NETWORK_TYPE_PAGE: return True
+        elif page is NETWORK_TYPE_PAGE:
-        elif page is SELECT_PHYSICAL_NETWORK_PAGE: return True
+            return True
-        elif page is SUMMARY_PAGE: return True
+        elif page is SELECT_PHYSICAL_NETWORK_PAGE:
+            return True
+        elif page is SUMMARY_PAGE:
+            return True
         return False
 
     def process_input(self, page):
@@ -125,14 +144,17 @@ class DefineNetworkConfigScreen(ConfigScreen):
         return ConfigScreen.get_back_page(self, page)
 
     def page_has_finish(self, page):
-        if page is SUMMARY_PAGE: return True
+        if page is SUMMARY_PAGE:
+            return True
         return False
 
     def page_has_next(self, page):
-        if page < SUMMARY_PAGE: return True
+        if page < SUMMARY_PAGE:
+            return True
 
     def page_has_back(self, page):
-        if page > NETWORK_NAME_PAGE: return True
+        if page > NETWORK_NAME_PAGE:
+            return True
         return False
 
     def get_network_name_page(self, screen):

src/virtManagerTui/hostmenu.py

@@ -35,9 +35,12 @@ class HostMenuScreen(MenuScreen):
                 ("Remove A Host", REMOVE_HOST))
 
     def handle_selection(self, item):
-        if   item is SELECT_HOST: ChangeHost()
+        if   item is SELECT_HOST:
-        elif item is ADD_HOST:    AddHost()
+            ChangeHost()
-        elif item is REMOVE_HOST: RemoveHost()
+        elif item is ADD_HOST:
+            AddHost()
+        elif item is REMOVE_HOST:
+            RemoveHost()
 
 def HostMenu():
     screen = HostMenuScreen()

src/virtManagerTui/libvirtworker.py

@@ -51,7 +51,8 @@ class VirtManagerConfig:
         result = []
         if os.path.exists(self.__filename):
             inp = file(self.__filename, "r")
-            for entry in inp: result.append(entry[0:-1])
+            for entry in inp:
+                result.append(entry[0:-1])
         return result
 
     def add_connection(self, connection):
@@ -75,11 +76,14 @@ class VirtManagerConfig:
 class LibvirtWorker:
     '''Provides utilities for interfacing with libvirt.'''
     def __init__(self, url = None):
-        if url is None: url = get_default_url()
+        if url is None:
+            url = get_default_url()
         logging.info("Connecting to libvirt: %s" % url)
         self.__url  = None
         self.__conn = None
         self.__vmmconn = None
+        self.__guest = None
+        self.__domain = None
 
         self.open_connection(url)
 
@@ -127,10 +131,13 @@ class LibvirtWorker:
             include = False
             domain = self.get_domain(uuid)
             if domain.status() in [libvirt.VIR_DOMAIN_RUNNING]:
-                if created: include = True
+                if created:
+                    include = True
             else:
-                if defined: include = True
+                if defined:
-            if include: result.append(uuid)
+                    include = True
+            if include:
+                result.append(uuid)
         return result
 
     def get_domain(self, uuid):
@@ -140,7 +147,8 @@ class LibvirtWorker:
     def domain_exists(self, name):
         '''Returns whether a domain with the specified node exists.'''
         domains = self.list_domains()
-        if name in domains: return True
+        if name in domains:
+            return True
         return False
 
     def undefine_domain(self, name):
@@ -169,10 +177,13 @@ class LibvirtWorker:
             include = False
             net = self.__vmmconn.get_net(uuid)
             if net.is_active():
-                if started: include = True
+                if started:
+                    include = True
             else:
-                if defined: include = True
+                if defined:
-            if include: result.append(uuid)
+                    include = True
+            if include:
+                result.append(uuid)
         return result
 
     def get_network(self, uuid):
@@ -184,7 +195,8 @@ class LibvirtWorker:
         '''
         self.__vmmconn.tick()
         result = self.__vmmconn.get_net(uuid)
-        if result is None: raise Exception("No such network exists: uuid=%s" % uuid)
+        if result is None:
+            raise Exception("No such network exists: uuid=%s" % uuid)
 
         return result
 
@@ -196,7 +208,8 @@ class LibvirtWorker:
 
         '''
         networks = self.list_networks()
-        if name in networks: return True
+        if name in networks:
+            return True
         return False
 
     def define_network(self, config):
@@ -238,14 +251,17 @@ class LibvirtWorker:
     def list_storage_pools(self, defined=True, created=True):
         '''Returns the list of all defined storage pools.'''
         pools = []
-        if defined: pools.extend(self.__conn.listDefinedStoragePools())
+        if defined:
-        if created: pools.extend(self.__conn.listStoragePools())
+            pools.extend(self.__conn.listDefinedStoragePools())
+        if created:
+            pools.extend(self.__conn.listStoragePools())
         return pools
 
     def storage_pool_exists(self, name):
         '''Returns whether a storage pool exists.'''
         pools = self.list_storage_pools()
-        if name in pools: return True
+        if name in pools:
+            return True
         return False
 
     def create_storage_pool(self, name):
@@ -341,7 +357,8 @@ class LibvirtWorker:
                 domain_type = domain.hypervisor_type
                 label = domain_type
 
-                if domain_type is "kvm" and guest_type is "xen": label = "xenner"
+                if domain_type is "kvm" and guest_type is "xen":
+                    label = "xenner"
                 elif domain_type is "xen":
                     if guest_type is "xen":
                         label = "xen (paravirt)"
@@ -357,7 +374,8 @@ class LibvirtWorker:
                     if row[0] == label:
                         label = None
                         break
-                if label is None: continue
+                if label is None:
+                    continue
 
                 result.append([label, domain_type, guest_type])
         return result
@@ -376,7 +394,8 @@ class LibvirtWorker:
     def get_hypervisor(self, virt_type):
         virt_types = self.get_virt_types()
         for typ in virt_types:
-            if typ[0] is virt_type: return typ[1]
+            if typ[0] is virt_type:
+                return typ[1]
         return None
 
     def get_default_virt_type(self):
@@ -386,7 +405,8 @@ class LibvirtWorker:
     def get_os_type(self, virt_type):
         virt_types = self.get_virt_types()
         for typ in virt_types:
-            if typ[0] is virt_type: return typ[2]
+            if typ[0] is virt_type:
+                return typ[2]
         return None
 
     def list_architectures(self):
@@ -399,13 +419,16 @@ class LibvirtWorker:
                     if row == label:
                         label = None
                         break
-                if label is None: continue
+                if label is None:
+                    continue
 
                 result.append(label)
         return result
 
     def define_domain(self, config, meter):
-        location = extra = kickstart = None
+        location = None
+        extra = None
+        kickstart = None
 
         if config.get_install_type() == DomainConfig.LOCAL_INSTALL:
             if config.get_use_cdrom_source():
@@ -432,16 +455,22 @@ class LibvirtWorker:
         self.__guest.maxmemory = config.get_memory()
 
         self.__guest.installer.location = location
-        if config.get_use_cdrom_source(): self.__guest.installer.cdrom = True
+        if config.get_use_cdrom_source():
+            self.__guest.installer.cdrom = True
         extraargs = ""
-        if extra: extraargs += extra
+        if extra:
-        if kickstart: extraargs += " ks=%s" % kickstart
+            extraargs += extra
-        if extraargs: self.__guest.installer.extraarags = extraargs
+        if kickstart:
+            extraargs += " ks=%s" % kickstart
+        if extraargs:
+            self.__guest.installer.extraarags = extraargs
 
         self.__guest.uuid = virtinst.util.uuidToString(virtinst.util.randomUUID())
 
-        if config.get_os_type() != "generic": self.__guest.os_type = config.get_os_type()
+        if config.get_os_type() != "generic":
-        if config.get_os_variant() != "generic": self.__guest.os_variant = config.get_os_variant()
+            self.__guest.os_type = config.get_os_type()
+        if config.get_os_variant() != "generic":
+            self.__guest.os_variant = config.get_os_variant()
 
         self.__guest._graphics_dev = virtinst.VirtualGraphics(type = virtinst.VirtualGraphics.TYPE_VNC)
         self.__guest.sound_devs = []

src/virtManagerTui/listnetworks.py

@@ -33,8 +33,10 @@ class ListNetworksConfigScreen(NetworkListConfigScreen):
         return (page is DETAILS_PAGE)
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_PAGE:    return self.get_network_list_page(screen)
+        if   page is LIST_PAGE:
-        elif page is DETAILS_PAGE: return self.get_network_details_page(screen)
+            return self.get_network_list_page(screen)
+        elif page is DETAILS_PAGE:
+            return self.get_network_details_page(screen)
 
     def get_network_details_page(self, screen):
         ignore = screen

src/virtManagerTui/listpools.py

@@ -29,8 +29,10 @@ class ListStoragePoolsConfigScreen(StorageListConfigScreen):
         StorageListConfigScreen.__init__(self, "List Storage Pools")
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_PAGE:    return self.get_storage_pool_list_page(screen)
+        if   page is LIST_PAGE:
-        elif page is DETAILS_PAGE: return self.get_pool_details_page(screen)
+            return self.get_storage_pool_list_page(screen)
+        elif page is DETAILS_PAGE:
+            return self.get_pool_details_page(screen)
 
     def page_has_next(self, page):
         if page is LIST_PAGE and self.has_selectable_pools():
@@ -38,7 +40,8 @@ class ListStoragePoolsConfigScreen(StorageListConfigScreen):
         return False
 
     def page_has_back(self, page):
-        if page is DETAILS_PAGE: return True
+        if page is DETAILS_PAGE:
+            return True
         return False
 
     def get_pool_details_page(self, screen):
@@ -55,7 +58,8 @@ class ListStoragePoolsConfigScreen(StorageListConfigScreen):
         grid.setField(volumes, 1, 1, anchorLeft = 1)
         grid.setField(snack.Label("Autostart:"), 0, 2, anchorRight = 1)
         label = "No"
-        if pool.autostart(): label = "Yes"
+        if pool.autostart():
+            label = "Yes"
         grid.setField(snack.Label(label), 1, 2, anchorLeft = 1)
         return [snack.Label("Details For Storage Pool: %s" % self.get_selected_pool()),
                 grid]

src/virtManagerTui/mainmenu.py

@@ -39,10 +39,14 @@ class MainMenuScreen(MenuScreen):
                 ("Host Administration",         HOST_MENU))
 
     def handle_selection(self, page):
-        if   page is NODE_MENU:    NodeMenu()
+        if   page is NODE_MENU:
-        elif page is NETWORK_MENU: NetworkMenu()
+            NodeMenu()
-        elif page is STORAGE_MENU: StoragePoolMenu()
+        elif page is NETWORK_MENU:
-        elif page is HOST_MENU:    HostMenu()
+            NetworkMenu()
+        elif page is STORAGE_MENU:
+            StoragePoolMenu()
+        elif page is HOST_MENU:
+            HostMenu()
 
 def MainMenu():
     screen = MainMenuScreen()

src/virtManagerTui/menuscreen.py

@@ -48,7 +48,8 @@ class MenuScreen:
             screen.finish()
 
             try:
-                if result.current() == EXIT_MENU: finished = True
+                if result.current() == EXIT_MENU:
+                    finished = True
                 else: self.handle_selection(result.current())
             except Exception, error:
                 screen = snack.SnackScreen()

src/virtManagerTui/migratedomain.py

@@ -29,15 +29,22 @@ class MigrateDomainConfigScreen(DomainListConfigScreen):
     def __init__(self):
         DomainListConfigScreen.__init__(self, "Migrate Virtual Machine")
         self.__configured = False
+        self.__confirm = None
+        self.__targets = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_DOMAINS:  return self.get_domain_list_page(screen)
+        if   page is LIST_DOMAINS:
-        elif page is SELECT_TARGET: return self.get_target_page(screen)
+            return self.get_domain_list_page(screen)
-        elif page is CONFIRM_PAGE:  return self.get_confirm_page(screen)
+        elif page is SELECT_TARGET:
+            return self.get_target_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def page_has_next(self, page):
-        if   page is LIST_DOMAINS: return self.has_selectable_domains()
+        if   page is LIST_DOMAINS:
-        else: return page < CONFIRM_PAGE
+            return self.has_selectable_domains()
+        else:
+            return page < CONFIRM_PAGE
 
     def page_has_back(self, page):
         return page < CONFIRM_PAGE
@@ -46,7 +53,8 @@ class MigrateDomainConfigScreen(DomainListConfigScreen):
         return page is CONFIRM_PAGE
 
     def validate_input(self, page, errors):
-        if   page is LIST_DOMAINS: return self.get_selected_domain() is not None
+        if   page is LIST_DOMAINS:
+            return self.get_selected_domain() is not None
         elif page is SELECT_TARGET:
             if self.__targets.current() is None:
                 errors.append("Please enter a target hostname or IP address.")

src/virtManagerTui/netmenu.py

@@ -41,11 +41,16 @@ class NetworkMenuScreen(MenuScreen):
                 ("List Networks",      LIST_NETWORKS))
 
     def handle_selection(self, item):
-        if   item is DEFINE_NETWORK:   DefineNetwork()
+        if   item is DEFINE_NETWORK:
-        elif item is START_NETWORK:    StartNetwork()
+            DefineNetwork()
-        elif item is STOP_NETWORK:     StopNetwork()
+        elif item is START_NETWORK:
-        elif item is UNDEFINE_NETWORK: UndefineNetwork()
+            StartNetwork()
-        elif item is LIST_NETWORKS:    ListNetworks()
+        elif item is STOP_NETWORK:
+            StopNetwork()
+        elif item is UNDEFINE_NETWORK:
+            UndefineNetwork()
+        elif item is LIST_NETWORKS:
+            ListNetworks()
 
 def NetworkMenu():
     screen = NetworkMenuScreen()

src/virtManagerTui/networkconfig.py

@@ -24,6 +24,9 @@ class NetworkConfig:
         self.set_ipv4_address("192.168.100.0/24")
         self.__isolated_network = True
         self.__physical_device = ""
+        self.__ipv4_end = None
+        self.__ipv4_start = None
+        self.__ipv4_address = None
 
     def set_name(self, name):
         self.__name = name

src/virtManagerTui/pausedomain.py

@@ -35,11 +35,13 @@ class PauseDomainConfigScreen(DomainListConfigScreen):
             return self.get_stop_page(screen)
 
     def page_has_next(self, page):
-        if page is self.LIST_PAGE: return self.has_selectable_domains()
+        if page is self.LIST_PAGE:
+            return self.has_selectable_domains()
         return False
 
     def page_has_back(self, page):
-        if page is self.STOP_PAGE: return True
+        if page is self.STOP_PAGE:
+            return True
         return False
 
     def validate_input(self, page, errors):

src/virtManagerTui/poolconfig.py

@@ -31,6 +31,14 @@ class PoolConfig:
         self.__source_path = ""
         self.__build_pool  = False
 
+        self.__needs_source_path = None
+        self.__needs_target_path = None
+        self.__pool = None
+        self.__needs_hostname = None
+        self.__needs_build_pool = None
+        self.__needs_format = None
+        self.__type = None
+
     def get_pool(self):
         return self.__pool
 

src/virtManagerTui/removedomain.py

@@ -28,25 +28,35 @@ class RemoveDomainConfigScreen(DomainListConfigScreen):
 
     def __init__(self):
         DomainListConfigScreen.__init__(self, "Remove A Domain")
+        self.__confirm_remove = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is self.LIST_PAGE:     return self.get_domain_list_page(screen)
+        if   page is self.LIST_PAGE:
-        elif page is self.CONFIRM_PAGE:  return self.get_confirm_page(screen)
+            return self.get_domain_list_page(screen)
-        elif page is self.REMOVE_PAGE: return self.get_remove_page(screen)
+        elif page is self.CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
+        elif page is self.REMOVE_PAGE:
+            return self.get_remove_page(screen)
 
     def page_has_next(self, page):
-        if   page is self.LIST_PAGE:     return self.has_selectable_domains()
+        if   page is self.LIST_PAGE:
-        elif page is self.CONFIRM_PAGE:  return True
+            return self.has_selectable_domains()
+        elif page is self.CONFIRM_PAGE:
+            return True
         return False
 
     def page_has_back(self, page):
-        if   page is self.CONFIRM_PAGE:  return True
+        if   page is self.CONFIRM_PAGE:
-        elif page is self.REMOVE_PAGE: return True
+            return True
+        elif page is self.REMOVE_PAGE:
+            return True
         return False
 
     def get_back_page(self, page):
-        if   page is self.CONFIRM_PAGE:  return self.LIST_PAGE
+        if   page is self.CONFIRM_PAGE:
-        elif page is self.REMOVE_PAGE: return self.LIST_PAGE
+            return self.LIST_PAGE
+        elif page is self.REMOVE_PAGE:
+            return self.LIST_PAGE
 
     def validate_input(self, page, errors):
         if page is self.LIST_PAGE:

src/virtManagerTui/removehost.py

@@ -26,10 +26,13 @@ CONFIRM_REMOVE_PAGE = 2
 class RemoveHostConfigScreen(HostListConfigScreen):
     def __init__(self):
         HostListConfigScreen.__init__(self, "Remove Host Connection")
+        self.__confirm = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is SELECT_HOST_PAGE:    return self.get_connection_list_page(screen)
+        if   page is SELECT_HOST_PAGE:
-        elif page is CONFIRM_REMOVE_PAGE: return self.get_confirm_remove_page(screen)
+            return self.get_connection_list_page(screen)
+        elif page is CONFIRM_REMOVE_PAGE:
+            return self.get_confirm_remove_page(screen)
 
     def page_has_next(self, page):
         return page is SELECT_HOST_PAGE and self.has_selectable_connections()
@@ -41,7 +44,8 @@ class RemoveHostConfigScreen(HostListConfigScreen):
         return page is CONFIRM_REMOVE_PAGE
 
     def validate_input(self, page, errors):
-        if   page is SELECT_HOST_PAGE: return True
+        if   page is SELECT_HOST_PAGE:
+            return True
         elif page is CONFIRM_REMOVE_PAGE:
             if self.__confirm.value():
                 return True

src/virtManagerTui/removepool.py

@@ -27,10 +27,13 @@ CONFIRM_PAGE       = 2
 class RemoveStoragePoolConfigScreen(StorageListConfigScreen):
     def __init__(self):
         StorageListConfigScreen.__init__(self, "Remove A Storage Pool")
+        self.__confirm = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_POOLS_PAGE: return self.get_storage_pool_list_page(screen)
+        if   page is LIST_POOLS_PAGE:
-        elif page is CONFIRM_PAGE:    return self.get_confirm_page(screen)
+            return self.get_storage_pool_list_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def page_has_next(self, page):
         return page is LIST_POOLS_PAGE and self.has_selectable_pools()

src/virtManagerTui/removevolume.py

@@ -29,20 +29,28 @@ class RemoveVolumeConfigScreen(StorageListConfigScreen):
     def __init__(self):
         StorageListConfigScreen.__init__(self, "Add A New Storage Volume")
         self.__config = StorageVolumeConfig()
+        self.__confirm = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is SELECT_POOL_PAGE:   return self.get_storage_pool_list_page(screen)
+        if   page is SELECT_POOL_PAGE:
-        elif page is SELECT_VOLUME_PAGE: return self.get_storage_volume_list_page(screen)
+            return self.get_storage_pool_list_page(screen)
-        elif page is CONFIRM_PAGE:       return self.get_confirm_page(screen)
+        elif page is SELECT_VOLUME_PAGE:
+            return self.get_storage_volume_list_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
 
     def page_has_next(self, page):
-        if   page is SELECT_POOL_PAGE:   return self.has_selectable_pools()
+        if   page is SELECT_POOL_PAGE:
-        elif page is SELECT_VOLUME_PAGE: return self.has_selectable_volumes()
+            return self.has_selectable_pools()
+        elif page is SELECT_VOLUME_PAGE:
+            return self.has_selectable_volumes()
         return False
 
     def validate_input(self, page, errors):
-        if   page is SELECT_POOL_PAGE:   return self.get_selected_pool() is not None
+        if   page is SELECT_POOL_PAGE:
-        elif page is SELECT_VOLUME_PAGE: return self.get_selected_volume() is not None
+            return self.get_selected_pool() is not None
+        elif page is SELECT_VOLUME_PAGE:
+            return self.get_selected_volume() is not None
         elif page is CONFIRM_PAGE:
             if self.__confirm.value():
                 return True

src/virtManagerTui/startdomain.py

@@ -35,11 +35,13 @@ class StartDomainConfigScreen(DomainListConfigScreen):
             return self.get_start_domain_page(screen)
 
     def page_has_next(self, page):
-        if page is self.LIST_PAGE: return self.has_selectable_domains()
+        if page is self.LIST_PAGE:
+            return self.has_selectable_domains()
         return False
 
     def page_has_back(self, page):
-        if page is self.START_PAGE: return True
+        if page is self.START_PAGE:
+            return True
         return False
 
     def validate_input(self, page, errors):

src/virtManagerTui/startnetwork.py

@@ -29,11 +29,14 @@ class StartNetworkConfigScreen(NetworkListConfigScreen):
         NetworkListConfigScreen.__init__(self, "Start A Network")
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_PAGE:  return self.get_network_list_page(screen, started = False)
+        if   page is LIST_PAGE:
-        elif page is START_PAGE: return self.get_start_network_page(screen)
+            return self.get_network_list_page(screen, started = False)
+        elif page is START_PAGE:
+            return self.get_start_network_page(screen)
 
     def page_has_next(self, page):
-        if page is LIST_PAGE: return self.has_selectable_networks()
+        if page is LIST_PAGE:
+            return self.has_selectable_networks()
 
     def page_has_back(self, page):
         return (page is START_PAGE)

src/virtManagerTui/startpool.py

@@ -29,8 +29,10 @@ class StartStoragePoolConfigScreen(StorageListConfigScreen):
         StorageListConfigScreen.__init__(self, "Start A Storage Pool")
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_POOLS_PAGE: return self.get_storage_pool_list_page(screen, created = False)
+        if   page is LIST_POOLS_PAGE:
-        elif page is FINAL_PAGE:      return self.get_final_page(screen)
+            return self.get_storage_pool_list_page(screen, created = False)
+        elif page is FINAL_PAGE:
+            return self.get_final_page(screen)
 
     def page_has_next(self, page):
         return page is LIST_POOLS_PAGE and self.has_selectable_pools()

src/virtManagerTui/stopdomain.py

@@ -35,11 +35,13 @@ class StopDomainConfigScreen(DomainListConfigScreen):
             return self.get_stop_page(screen)
 
     def page_has_next(self, page):
-        if page is self.LIST_PAGE: return self.has_selectable_domains()
+        if page is self.LIST_PAGE:
+            return self.has_selectable_domains()
         return False
 
     def page_has_back(self, page):
-        if page is self.STOP_PAGE: return True
+        if page is self.STOP_PAGE:
+            return True
         return False
 
     def validate_input(self, page, errors):

src/virtManagerTui/stopnetwork.py

@@ -29,15 +29,19 @@ class StopNetworkConfigScreen(NetworkListConfigScreen):
         NetworkListConfigScreen.__init__(self, "Stop A Network")
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_PAGE: return self.get_network_list_page(screen, defined = False)
+        if   page is LIST_PAGE:
-        elif page is STOP_PAGE: return self.get_stop_network_page(screen)
+            return self.get_network_list_page(screen, defined = False)
+        elif page is STOP_PAGE:
+            return self.get_stop_network_page(screen)
 
     def page_has_next(self, page):
-        if page is LIST_PAGE: return self.has_selectable_networks()
+        if page is LIST_PAGE:
+            return self.has_selectable_networks()
         return False
 
     def page_has_back(self, page):
-        if page is STOP_PAGE: return True
+        if page is STOP_PAGE:
+            return True
         return False
 
     def validate_input(self, page, errors):

src/virtManagerTui/stoppool.py

@@ -29,8 +29,10 @@ class StopStoragePoolConfigScreen(StorageListConfigScreen):
         StorageListConfigScreen.__init__(self, "Stop A Storage Pool")
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_POOLS_PAGE: return self.get_storage_pool_list_page(screen, defined = False)
+        if   page is LIST_POOLS_PAGE:
-        elif page is FINAL_PAGE:      return self.get_final_page(screen)
+            return self.get_storage_pool_list_page(screen, defined = False)
+        elif page is FINAL_PAGE:
+            return self.get_final_page(screen)
 
     def page_has_next(self, page):
         return page is LIST_POOLS_PAGE and self.has_selectable_pools()

src/virtManagerTui/storagemenu.py

@@ -47,13 +47,20 @@ class StoragePoolMenuScreen(MenuScreen):
                 ("List Storage Pools",      LIST_POOLS))
 
     def handle_selection(self, item):
-        if   item is ADD_POOL:      AddStoragePool()
+        if   item is ADD_POOL:
-        elif item is START_POOL:    StartStoragePool()
+            AddStoragePool()
-        elif item is STOP_POOL:     StopStoragePool()
+        elif item is START_POOL:
-        elif item is REMOVE_POOL:   RemoveStoragePool()
+            StartStoragePool()
-        elif item is ADD_VOLUME:    AddStorageVolume()
+        elif item is STOP_POOL:
-        elif item is REMOVE_VOLUME: RemoveStorageVolume()
+            StopStoragePool()
-        elif item is LIST_POOLS:    ListStoragePools()
+        elif item is REMOVE_POOL:
+            RemoveStoragePool()
+        elif item is ADD_VOLUME:
+            AddStorageVolume()
+        elif item is REMOVE_VOLUME:
+            RemoveStorageVolume()
+        elif item is LIST_POOLS:
+            ListStoragePools()
 
 def StoragePoolMenu():
     screen = StoragePoolMenuScreen()

src/virtManagerTui/undefinenetwork.py

@@ -28,28 +28,40 @@ UNDEFINE_PAGE = 3
 class UndefineNetworkConfigScreen(NetworkListConfigScreen):
     def __init__(self):
         NetworkListConfigScreen.__init__(self, "Undefine A Network")
+        self.__deleted_network_name = None
+        self.__confirm_undefine = None
 
     def get_elements_for_page(self, screen, page):
-        if   page is LIST_PAGE:     return self.get_network_list_page(screen, started = False)
+        if   page is LIST_PAGE:
-        elif page is CONFIRM_PAGE:  return self.get_confirm_page(screen)
+            return self.get_network_list_page(screen, started = False)
-        elif page is UNDEFINE_PAGE: return self.get_undefine_network_page(screen)
+        elif page is CONFIRM_PAGE:
+            return self.get_confirm_page(screen)
+        elif page is UNDEFINE_PAGE:
+            return self.get_undefine_network_page(screen)
 
     def page_has_next(self, page):
-        if page is LIST_PAGE:    return self.has_selectable_networks()
+        if page is LIST_PAGE:
-        if page is CONFIRM_PAGE: return True
+            return self.has_selectable_networks()
+        if page is CONFIRM_PAGE:
+            return True
         return False
 
     def page_has_back(self, page):
-        if page is CONFIRM_PAGE: return True
+        if page is CONFIRM_PAGE:
-        if page is UNDEFINE_PAGE: return True
+            return True
+        if page is UNDEFINE_PAGE:
+            return True
         return False
 
     def get_back_page(self, page):
-        if   page is CONFIRM_PAGE: return LIST_PAGE
+        if   page is CONFIRM_PAGE:
-        elif page is UNDEFINE_PAGE: return LIST_PAGE
+            return LIST_PAGE
+        elif page is UNDEFINE_PAGE:
+            return LIST_PAGE
 
     def validate_input(self, page, errors):
-        if   page is LIST_PAGE: return True
+        if   page is LIST_PAGE:
+            return True
         elif page is CONFIRM_PAGE:
             network = self.get_selected_network()
             if self.__confirm_undefine.value():
@@ -58,7 +70,8 @@ class UndefineNetworkConfigScreen(NetworkListConfigScreen):
                 return True
             else:
                 errors.append("You must confirm undefining %s." % network.get_name())
-        elif page is UNDEFINE_PAGE: return True
+        elif page is UNDEFINE_PAGE:
+            return True
         return False
 
     def get_confirm_page(self, screen):

src/virtManagerTui/userworker.py

@@ -32,6 +32,7 @@ class UserWorker:
         self.__admin.addUser(user)
         if other_group is not None:
             group = self.__admin.lookupGroupByName(other_group)
-            if group is None: raise Exception("Invalid group specified: %s" % other_group)
+            if group is None:
+                raise Exception("Invalid group specified: %s" % other_group)
             user.add('pw_gid', group.get('pw_gid')[0])
             self.__admin.modifyUser(user)

src/virtManagerTui/utils.py

@@ -19,7 +19,8 @@
 import re
 
 def string_is_not_blank(value):
-    if len(value) > 0: return True
+    if len(value) > 0:
+        return True
     return False
 
 def string_has_no_spaces(value):

src/virtManagerTui/volumeconfig.py

@@ -27,6 +27,8 @@ class StorageVolumeConfig:
         self.__format = None
         self.__max_capacity = 10000
         self.__allocation = 0
+        self.__pool_type = None
+        self.__volume_class = None
 
     def set_pool(self, pool):
         self.__pool = pool