@@ -12,15 +12,15 @@ class ConfirmWindow(Window):

     def __init__(self, height, width, maxy, maxx, menu_starty, message, info=False):

         if info:

-            items =   [('OK',  self.exit_function, True)]

+            items = [('OK', self.exit_function, True)]

         else:

-            items =   [

-                        ('Yes',  self.exit_function, True),

-                        ('No',  self.exit_function, False)

-                    ]

-        self.menu = Menu(menu_starty,  maxx, items, can_navigate_outside = False, horizontal=True)

+            items = [

+                ('Yes', self.exit_function, True),

+                ('No', self.exit_function, False)

+                ]

+        self.menu = Menu(menu_starty, maxx, items, can_navigate_outside=False, horizontal=True)

         super(ConfirmWindow, self).__init__(height, width, maxy, maxx, 'Confirm', False, self.menu)

-        self.addstr(0,0, message)

+        self.addstr(0, 0, message)

     def exit_function(self, yes):

         return ActionResult(True, {'yes': yes})

@@ -14,12 +14,16 @@ class Device(object):

     @staticmethod

     def refresh_devices():

-        devices_list = subprocess.check_output(['lsblk', '-d', '-I', '8,259', '-n', '--output', 'NAME,SIZE,MODEL'], stderr=open(os.devnull, 'w'))

+        devices_list = subprocess.check_output(['lsblk', '-d', '-I', '8,259', '-n',

+                                                '--output', 'NAME,SIZE,MODEL'],

+                                               stderr=open(os.devnull, 'w'))

         return Device.wrap_devices_from_list(devices_list)

     @staticmethod

     def refresh_devices_bytes():

-        devices_list = subprocess.check_output(['lsblk', '-d', '--bytes', '-I', '8,259', '-n', '--output', 'NAME,SIZE,MODEL'], stderr=open(os.devnull, 'w'))

+        devices_list = subprocess.check_output(['lsblk', '-d', '--bytes', '-I',

+                                                '8,259', '-n', '--output', 'NAME,SIZE,MODEL'],

+                                               stderr=open(os.devnull, 'w'))

         return Device.wrap_devices_from_list(devices_list)

     @staticmethod

@@ -30,15 +34,15 @@ class Device(object):

             cols = deviceline.split(None, 2)

             #skip Virtual NVDIMM from install list

             colstr = cols[0].decode()

-            if(colstr.startswith("pmem")):

+            if colstr.startswith("pmem"):

                 continue

             model = "Unknown"

-            if(len(cols) >= 3):

+            if len(cols) >= 3:

                 model = cols[2].decode()

             devices.append(

-                    Device(model #Model

-                        , '/dev/' + cols[0].decode() #Path

-                        , cols[1].decode() #size

-                        ))

+                Device(model #Model

+                       , '/dev/' + cols[0].decode() #Path

+                       , cols[1].decode() #size

+                      ))

         return devices

@@ -16,8 +16,8 @@ from window import Window

 from actionresult import ActionResult

 class Installer(object):

-    def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False,

-                 rpm_path = "../stage/RPMS", log_path = "../stage/LOGS"):

+    def __init__(self, install_config, maxy=0, maxx=0, iso_installer=False,

+                 rpm_path="../stage/RPMS", log_path="../stage/LOGS"):

         self.install_config = install_config

         self.iso_installer = iso_installer

         self.rpm_path = rpm_path

@@ -33,7 +33,7 @@ class Installer(object):

             self.working_directory = self.install_config['working_directory']

         else:

             self.working_directory = "/mnt/photon-root"

-        self.photon_root = self.working_directory + "/photon-chroot";

+        self.photon_root = self.working_directory + "/photon-chroot"

         self.restart_command = "shutdown"

@@ -53,8 +53,11 @@ class Installer(object):

             self.progress_width = self.width - self.progress_padding

             self.starty = (self.maxy - self.height) // 2

             self.startx = (self.maxx - self.width) // 2

-            self.window = Window(self.height, self.width, self.maxy, self.maxx, 'Installing Photon', False)

-            self.progress_bar = ProgressBar(self.starty + 3, self.startx + self.progress_padding // 2, self.progress_width)

+            self.window = Window(self.height, self.width, self.maxy, self.maxx,

+                                 'Installing Photon', False)

+            self.progress_bar = ProgressBar(self.starty + 3,

+                                            self.startx + self.progress_padding // 2,

+                                            self.progress_width)

         signal.signal(signal.SIGINT, self.exit_gracefully)

@@ -62,7 +65,8 @@ class Installer(object):

     def exit_gracefully(self, signal, frame):

         if self.iso_installer:

             self.progress_bar.hide()

-            self.window.addstr(0, 0, 'Oops, Installer got interrupted.\n\nPress any key to get to the bash...')

+            self.window.addstr(0, 0, 'Oops, Installer got interrupted.\n\n' +

+                               'Press any key to get to the bash...')

             self.window.content_window().getch()

         modules.commons.dump(modules.commons.LOG_FILE_NAME)

@@ -86,15 +90,17 @@ class Installer(object):

             self.progress_bar.show()

             #self.rpm_path = "https://dl.bintray.com/vmware/photon_release_1.0_TP2_x86_64"

             if self.rpm_path.startswith("https://") or self.rpm_path.startswith("http://"):

-                cmdoption = 's/baseurl.*/baseurl={}/g'.format(self.rpm_path.replace('/','\/'))

-                process = subprocess.Popen(['sed', '-i', cmdoption,'/etc/yum.repos.d/photon-iso.repo']) 

+                cmdoption = 's/baseurl.*/baseurl={}/g'.format(self.rpm_path.replace('/', '\/'))

+                process = subprocess.Popen(['sed', '-i', cmdoption,

+                                            '/etc/yum.repos.d/photon-iso.repo'])

                 retval = process.wait()

                 if retval != 0:

                     modules.commons.log(modules.commons.LOG_INFO, "Failed to reset repo")

                     self.exit_gracefully(None, None)

-            cmdoption = 's/cachedir=\/var/cachedir={}/g'.format(self.photon_root.replace('/','\/'))

-            process = subprocess.Popen(['sed', '-i', cmdoption,'/etc/tdnf/tdnf.conf']) 

+            cmdoption = ('s/cachedir=\/var/cachedir={}/g'

+                         .format(self.photon_root.replace('/', '\/')))

+            process = subprocess.Popen(['sed', '-i', cmdoption, '/etc/tdnf/tdnf.conf'])

             retval = process.wait()

             if retval != 0:

                 modules.commons.log(modules.commons.LOG_INFO, "Failed to reset tdnf cachedir")

@@ -110,10 +116,13 @@ class Installer(object):

             packages_to_install = {}

             total_size = 0

             with open(modules.commons.TDNF_CMDLINE_FILE_NAME, "w") as tdnf_cmdline_file:

-                tdnf_cmdline_file.write("tdnf install --installroot {0} --nogpgcheck {1}".format(self.photon_root, " ".join(selected_packages)))

+                tdnf_cmdline_file.write("tdnf install --installroot {0} --nogpgcheck {1}"

+                                        .format(self.photon_root, " ".join(selected_packages)))

             with open(modules.commons.TDNF_LOG_FILE_NAME, "w") as tdnf_errlog:

-                process = subprocess.Popen(

-                    ['tdnf', 'install'] + selected_packages + ['--installroot', self.photon_root, '--nogpgcheck', '--assumeyes'], stdout=subprocess.PIPE, stderr=tdnf_errlog)

+                process = subprocess.Popen(['tdnf', 'install'] + selected_packages +

+                                           ['--installroot', self.photon_root, '--nogpgcheck',

+                                            '--assumeyes'], stdout=subprocess.PIPE,

+                                           stderr=tdnf_errlog)

                 while True:

                     output = process.stdout.readline().decode()

                     if output == '':

@@ -150,7 +159,9 @@ class Installer(object):

                         self.progress_bar.update_message(output)

                 # 0 : succeed; 137 : package already installed; 65 : package not found in repo.

                 if retval != 0 and retval != 137:

-                    modules.commons.log(modules.commons.LOG_ERROR, "Failed to install some packages, refer to {0}".format(modules.commons.TDNF_LOG_FILE_NAME))

+                    modules.commons.log(modules.commons.LOG_ERROR,

+                                        "Failed to install some packages, refer to {0}"

+                                        .format(modules.commons.TDNF_LOG_FILE_NAME))

                     self.exit_gracefully(None, None)

         else:

         #install packages

@@ -176,7 +187,8 @@ class Installer(object):

             # Execute post installation modules

             self.execute_modules(modules.commons.POST_INSTALL)

             if os.path.exists(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME):

-                shutil.copy(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME, self.photon_root + '/var/log/')

+                shutil.copy(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME,

+                            self.photon_root + '/var/log/')

             if self.iso_installer and os.path.isdir("/sys/firmware/efi"):

                 self.install_config['boot'] = 'efi'

@@ -187,32 +199,32 @@ class Installer(object):

             try:

                 if self.install_config['boot'] == 'bios':

                     process = subprocess.Popen(

-                                  [self.setup_grub_command, '-w', self.photon_root,

-                                  "bios", self.install_config['disk']['disk'],

-                                  self.install_config['disk']['root'],

-                                  self.install_config['disk']['boot'],

-                                  self.install_config['disk']['bootdirectory'],

-                                  str(self.install_config['disk']['boot_partition_number'])],

-                                  stdout=self.output)

+                        [self.setup_grub_command, '-w', self.photon_root,

+                         "bios", self.install_config['disk']['disk'],

+                         self.install_config['disk']['root'],

+                         self.install_config['disk']['boot'],

+                         self.install_config['disk']['bootdirectory'],

+                         str(self.install_config['disk']['boot_partition_number'])],

+                        stdout=self.output)

                 elif self.install_config['boot'] == 'efi':

                     process = subprocess.Popen(

-                                  [self.setup_grub_command, '-w', self.photon_root,

-                                  "efi", self.install_config['disk']['disk'],

-                                  self.install_config['disk']['root'],

-                                  self.install_config['disk']['boot'],

-                                  self.install_config['disk']['bootdirectory'],

-                                  str(self.install_config['disk']['boot_partition_number'])],

-                                  stdout=self.output)

+                        [self.setup_grub_command, '-w', self.photon_root,

+                         "efi", self.install_config['disk']['disk'],

+                         self.install_config['disk']['root'],

+                         self.install_config['disk']['boot'],

+                         self.install_config['disk']['bootdirectory'],

+                         str(self.install_config['disk']['boot_partition_number'])],

+                        stdout=self.output)

             except:

                 #install bios if variable is not set.

                 process = subprocess.Popen(

-                              [self.setup_grub_command, '-w', self.photon_root,

-                              "bios", self.install_config['disk']['disk'],

-                              self.install_config['disk']['root'],

-                              self.install_config['disk']['boot'],

-                              self.install_config['disk']['bootdirectory'],

-                              str(self.install_config['disk']['boot_partition_number'])],

-                              stdout=self.output)

+                    [self.setup_grub_command, '-w', self.photon_root,

+                     "bios", self.install_config['disk']['disk'],

+                     self.install_config['disk']['root'],

+                     self.install_config['disk']['boot'],

+                     self.install_config['disk']['bootdirectory'],

+                     str(self.install_config['disk']['boot_partition_number'])],

+                    stdout=self.output)

             retval = process.wait()

             self.update_fstab()

@@ -222,13 +234,15 @@ class Installer(object):

         command = [self.unmount_disk_command, '-w', self.photon_root]

         if not self.install_config['iso_system']:

-            command.extend(self.generate_partitions_param(reverse = True))

+            command.extend(self.generate_partitions_param(reverse=True))

         process = subprocess.Popen(command, stdout=self.output)

         retval = process.wait()

         if self.iso_installer:

             self.progress_bar.hide()

-            self.window.addstr(0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\nPress any key to continue to boot...'.format(self.progress_bar.time_elapsed))

+            self.window.addstr(0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\n' +

+                               'Press any key to continue to boot...'

+                               .format(self.progress_bar.time_elapsed))

             eject_cdrom = True

             if 'ui_install' in self.install_config:

                 self.window.content_window().getch()

@@ -238,7 +252,7 @@ class Installer(object):

                 process = subprocess.Popen(['eject', '-r'], stdout=self.output)

                 process.wait()

         return ActionResult(True, None)

-        

+

     def copy_rpms(self):

         # prepare the RPMs list

         json_pkg_to_rpm_map = JsonWrapper(self.install_config["pkg_to_rpm_map_file"])

@@ -247,12 +261,13 @@ class Installer(object):

         self.rpms_tobeinstalled = []

         selected_packages = self.install_config['packages']

-        for pkg in selected_packages: 

+        for pkg in selected_packages:

             if pkg in pkg_to_rpm_map:

                 if not pkg_to_rpm_map[pkg]['rpm'] is None:

                     name = pkg_to_rpm_map[pkg]['rpm']

                     basename = os.path.basename(name)

-                    self.rpms_tobeinstalled.append({'filename': basename, 'path': name, 'package' : pkg})

+                    self.rpms_tobeinstalled.append({'filename': basename, 'path': name,

+                                                    'package' : pkg})

         # Copy the rpms

         for rpm in self.rpms_tobeinstalled:

@@ -264,36 +279,45 @@ class Installer(object):

         retval = process.wait()

         # Copy the installer files

-        process = subprocess.Popen(['cp', '-r', "../installer", self.photon_root], stdout=self.output)

+        process = subprocess.Popen(['cp', '-r', "../installer", self.photon_root],

+                                   stdout=self.output)

         retval = process.wait()

         # Create the rpms directory

-        process = subprocess.Popen(['mkdir', '-p', self.photon_root + '/RPMS'], stdout=self.output)

+        process = subprocess.Popen(['mkdir', '-p', self.photon_root + '/RPMS'],

+                                   stdout=self.output)

         retval = process.wait()

         self.copy_rpms()

     def bind_installer(self):

         # Make the photon_root/installer directory if not exits

-        process = subprocess.Popen(['mkdir', '-p', os.path.join(self.photon_root, "installer")], stdout=self.output)

+        process = subprocess.Popen(['mkdir', '-p', os.path.join(self.photon_root, "installer")],

+                                   stdout=self.output)

         retval = process.wait()

-        # The function finalize_system will access the file /installer/mk-finalize-system.sh after chroot to photon_root. 

-        # Bind the /installer folder to self.photon_root/installer, so that after chroot to photon_root,

+        # The function finalize_system will access the file /installer/mk-finalize-system.sh

+        # after chroot to photon_root.

+        # Bind the /installer folder to self.photon_root/installer, so that after chroot

+        # to photon_root,

         # the file can still be accessed as /installer/mk-finalize-system.sh.

-        process = subprocess.Popen(['mount', '--bind', '/installer', os.path.join(self.photon_root, "installer")], stdout=self.output)

+        process = subprocess.Popen(['mount', '--bind', '/installer',

+                                    os.path.join(self.photon_root, "installer")],

+                                   stdout=self.output)

         retval = process.wait()

     def bind_repo_dir(self):

         rpm_cache_dir = self.photon_root + '/cache/tdnf/photon-iso/rpms'

         if self.rpm_path.startswith("https://") or self.rpm_path.startswith("http://"):

             return

-        if subprocess.call(['mkdir', '-p', rpm_cache_dir]) != 0 or subprocess.call(['mount', '--bind', self.rpm_path, rpm_cache_dir]) != 0:

+        if (subprocess.call(['mkdir', '-p', rpm_cache_dir]) != 0 or

+                subprocess.call(['mount', '--bind', self.rpm_path, rpm_cache_dir]) != 0):

             modules.commons.log(modules.commons.LOG_ERROR, "Fail to bind cache rpms")

             self.exit_gracefully(None, None)

     def unbind_repo_dir(self):

         rpm_cache_dir = self.photon_root + '/cache/tdnf/photon-iso/rpms'

         if self.rpm_path.startswith("https://") or self.rpm_path.startswith("http://"):

             return

-        if subprocess.call(['umount', rpm_cache_dir]) != 0  or subprocess.call(['rm', '-rf', rpm_cache_dir]) != 0:

+        if (subprocess.call(['umount', rpm_cache_dir]) != 0 or

+                subprocess.call(['rm', '-rf', rpm_cache_dir]) != 0):

             modules.commons.log(modules.commons.LOG_ERROR, "Fail to unbind cache rpms")

             self.exit_gracefully(None, None)

@@ -309,7 +333,7 @@ class Installer(object):

                 if 'mountpoint' in partition and partition['mountpoint'] == '/':

                     options = options + ',barrier,noatime,noacl,data=ordered'

                     fsck = 1

-            

+

                 if partition['filesystem'] == 'swap':

                     mountpoint = 'swap'

                     dump = 0

@@ -328,7 +352,7 @@ class Installer(object):

             # Add the cdrom entry

             fstab_file.write("/dev/cdrom\t/mnt/cdrom\tiso9660\tro,noauto\t0\t0\n")

-    def generate_partitions_param(self, reverse = False):

+    def generate_partitions_param(self, reverse=False):

         if reverse:

             step = -1

         else:

@@ -343,48 +367,57 @@ class Installer(object):

     def initialize_system(self):

         #Setup the disk

-        if (not self.install_config['iso_system']):

+        if not self.install_config['iso_system']:

             command = [self.mount_command, '-w', self.photon_root]

             command.extend(self.generate_partitions_param())

             process = subprocess.Popen(command, stdout=self.output)

             retval = process.wait()

-        

+

         if self.iso_installer:

             self.bind_installer()

             self.bind_repo_dir()

-            process = subprocess.Popen([self.prepare_command, '-w', self.photon_root, 'install'], stdout=self.output)

+            process = subprocess.Popen([self.prepare_command, '-w', self.photon_root, 'install'],

+                                       stdout=self.output)

             retval = process.wait()

         else:

             self.copy_files()

             #Setup the filesystem basics

-            process = subprocess.Popen([self.prepare_command, '-w', self.photon_root], stdout=self.output)

+            process = subprocess.Popen([self.prepare_command, '-w', self.photon_root],

+                                       stdout=self.output)

             retval = process.wait()

     def finalize_system(self):

         #Setup the disk

-        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, self.finalize_command, '-w', self.photon_root], stdout=self.output)

+        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root,

+                                    self.finalize_command, '-w', self.photon_root],

+                                   stdout=self.output)

         retval = process.wait()

         if self.iso_installer:

             modules.commons.dump(modules.commons.LOG_FILE_NAME)

             shutil.copy(modules.commons.LOG_FILE_NAME, self.photon_root + '/var/log/')

-            shutil.copy(modules.commons.TDNF_LOG_FILE_NAME, self.photon_root + '/var/log/')

+            shutil.copy(modules.commons.TDNF_LOG_FILE_NAME, self.photon_root +

+                        '/var/log/')

             # unmount the installer directory

-            process = subprocess.Popen(['umount', os.path.join(self.photon_root, "installer")], stdout=self.output)

+            process = subprocess.Popen(['umount', os.path.join(self.photon_root,

+                                                               "installer")],

+                                       stdout=self.output)

             retval = process.wait()

             # remove the installer directory

-            process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "installer")], stdout=self.output)

+            process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "installer")],

+                                       stdout=self.output)

             retval = process.wait()

             self.unbind_repo_dir()

             # Disable the swap file

             process = subprocess.Popen(['swapoff', '-a'], stdout=self.output)

             retval = process.wait()

             # remove the tdnf cache directory and the swapfile.

-            process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "cache")], stdout=self.output)

+            process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "cache")],

+                                       stdout=self.output)

             retval = process.wait()

-    def install_package(self,  rpm_file_names):

+    def install_package(self, rpm_file_names):

         rpms = set(rpm_file_names)

         rpm_paths = []

@@ -394,13 +427,19 @@ class Installer(object):

                     rpm_paths.append(os.path.join(root, f))

         # --nodeps is for hosts which do not support rich dependencies

-        rpm_params = ['--nodeps', '--root', self.photon_root, '--dbpath', '/var/lib/rpm']

+        rpm_params = ['--nodeps', '--root', self.photon_root, '--dbpath',

+                      '/var/lib/rpm']

-        if ('type' in self.install_config and (self.install_config['type'] in ['micro', 'minimal'])) or self.install_config['iso_system']:

+        if (('type' in self.install_config and

+             (self.install_config['type'] in ['micro', 'minimal'])) or

+                self.install_config['iso_system']):

             rpm_params.append('--excludedocs')

-        modules.commons.log(modules.commons.LOG_INFO, "installing packages {0}, with params {1}".format(rpm_paths, rpm_params))

-        process = subprocess.Popen(['rpm', '-Uvh'] + rpm_params + rpm_paths, stderr=subprocess.STDOUT)

+        modules.commons.log(modules.commons.LOG_INFO,

+                            "installing packages {0}, with params {1}"

+                            .format(rpm_paths, rpm_params))

+        process = subprocess.Popen(['rpm', '-Uvh'] + rpm_params + rpm_paths,

+                                   stderr=subprocess.STDOUT)

         return process.wait()

     def execute_modules(self, phase):

@@ -413,22 +452,27 @@ class Installer(object):

                 __import__(module)

                 mod = sys.modules[module]

             except ImportError:

-                modules.commons.log(modules.commons.LOG_ERROR, 'Error importing module {}'.format(module))

+                modules.commons.log(modules.commons.LOG_ERROR,

+                                    'Error importing module {}'.format(module))

                 continue

-            

+

             # the module default is disabled

             if not hasattr(mod, 'enabled') or mod.enabled == False:

-                modules.commons.log(modules.commons.LOG_INFO, "module {} is not enabled".format(module))

+                modules.commons.log(modules.commons.LOG_INFO,

+                                    "module {} is not enabled".format(module))

                 continue

             # check for the install phase

             if not hasattr(mod, 'install_phase'):

-                modules.commons.log(modules.commons.LOG_ERROR, "Error: can not defind module {} phase".format(module))

+                modules.commons.log(modules.commons.LOG_ERROR,

+                                    "Error: can not defind module {} phase".format(module))

                 continue

             if mod.install_phase != phase:

-                modules.commons.log(modules.commons.LOG_INFO, "Skipping module {0} for phase {1}".format(module, phase))

+                modules.commons.log(modules.commons.LOG_INFO,

+                                    "Skipping module {0} for phase {1}".format(module, phase))

                 continue

             if not hasattr(mod, 'execute'):

-                modules.commons.log(modules.commons.LOG_ERROR, "Error: not able to execute module {}".format(module))

+                modules.commons.log(modules.commons.LOG_ERROR,

+                                    "Error: not able to execute module {}".format(module))

                 continue

             mod.execute(module, self.install_config, self.photon_root)

@@ -8,9 +8,9 @@ from ostreeinstaller import OstreeInstaller

 from ostreeserverinstaller import OstreeServerInstaller

 class InstallerContainer(object):

-    def __init__(self, install_config, maxy = 0, maxx = 0,

-        iso_installer = False, rpm_path = "../stage/RPMS",

-        log_path = "../stage/LOGS"):

+    def __init__(self, install_config, maxy=0, maxx=0,

+                 iso_installer=False, rpm_path="../stage/RPMS",

+                 log_path="../stage/LOGS"):

         self.install_config = install_config

         self.maxy = maxy

@@ -22,10 +22,14 @@ class InstallerContainer(object):

     def install(self, params):

         installer = None

         if self.install_config['type'] == "ostree_host":

-            installer = OstreeInstaller(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path)

+            installer = OstreeInstaller(self.install_config, self.maxy, self.maxx,

+                                        self.iso_installer, self.rpm_path, self.log_path)

         elif self.install_config['type'] == "ostree_server":

-            installer = OstreeServerInstaller(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path)

+            installer = OstreeServerInstaller(self.install_config, self.maxy, self.maxx,

+                                              self.iso_installer, self.rpm_path,

+                                              self.log_path)

         else:

-            installer = Installer(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path)

+            installer = Installer(self.install_config, self.maxy, self.maxx,

+                                  self.iso_installer, self.rpm_path, self.log_path)

-        return installer.install(params)

\ No newline at end of file

+        return installer.install(params)

@@ -9,7 +9,7 @@ import collections

 class JsonWrapper(object):

-    def __init__(self,  filename):

+    def __init__(self, filename):

         self.filename = filename

     def read(self):

@@ -17,7 +17,7 @@ class JsonWrapper(object):

             self.data = json.load(json_data, object_pairs_hook=collections.OrderedDict)

         return self.data

-    def write(self,  data):

+    def write(self, data):

         self.data = data

-        with open(self.filename,  'wb') as outfile:

-            json.dump(data,  outfile)

+        with open(self.filename, 'wb') as outfile:

+            json.dump(data, outfile)

@@ -8,7 +8,7 @@ from actionresult import ActionResult

 from textpane import TextPane

 class License(object):

-    def __init__(self,  maxy, maxx):

+    def __init__(self, maxy, maxx):

         self.maxx = maxx

         self.maxy = maxy

         self.win_width = maxx - 4

@@ -21,17 +21,17 @@ class License(object):

         self.text_height = self.win_height - 6

         self.text_width = self.win_width - 6

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False)

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx,

+                             'Welcome to the Photon installer', False)

     def display(self, params):

-        accept_decline_items =  [

-                                    ('<Accept>', self.accept_function),

-                                    ('<Cancel>', self.exit_function)

-                                ]

+        accept_decline_items = [('<Accept>', self.accept_function),

+                                ('<Cancel>', self.exit_function)]

         title = 'VMWARE 2.0 LICENSE AGREEMENT'

         self.window.addstr(0, (self.win_width - len(title)) // 2, title)

-        self.text_pane = TextPane(self.text_starty, self.maxx, self.text_width, "EULA.txt", self.text_height, accept_decline_items)

+        self.text_pane = TextPane(self.text_starty, self.maxx, self.text_width,

+                                  "EULA.txt", self.text_height, accept_decline_items)

         self.window.set_action_panel(self.text_pane)

@@ -41,4 +41,3 @@ class LinuxSelector(object):

         self.window.addstr(1, 0, 'Photon OS on a VMware hypervisor.')

         self.window.addstr(2, 0, 'Which type of Linux kernel would you like to install?')

         return self.window.do_action()

-

@@ -8,7 +8,9 @@ from actionresult import ActionResult

 from action import Action

 class Menu(Action):

-    def __init__(self, starty, maxx, items, height = 0, selector_menu = False, can_navigate_outside = True, horizontal = False, default_selected = 0, save_sel = False, tab_enable = True):

+    def __init__(self, starty, maxx, items, height=0, selector_menu=False,

+                 can_navigate_outside=True, horizontal=False, default_selected=0,

+                 save_sel=False, tab_enable=True):

         self.can_navigate_outside = can_navigate_outside

         self.horizontal = horizontal

         self.horizontal_padding = 10

@@ -19,7 +21,7 @@ class Menu(Action):

         self.width = self.lengthen_items()

         self.num_items = len(self.items)

         self.save_sel = save_sel

-        self.tab_enable=tab_enable

+        self.tab_enable = tab_enable

         if height == 0 or height > self.num_items:

             self.height = self.num_items

         else:

@@ -85,9 +87,9 @@ class Menu(Action):

         elif self.position >= len(self.items):

             self.position = len(self.items)-1

-        if (self.position >= self.head_position + self.height):

+        if self.position >= self.head_position + self.height:

             self.head_position = self.position - self.height + 1

-        if (self.position < self.head_position):

+        if self.position < self.head_position:

             self.head_position = self.position

@@ -95,7 +97,7 @@ class Menu(Action):

         if self.show_scroll:

             remaining_above = self.head_position

             remaining_down = self.num_items - self.height - self.head_position#

-            

+

             up = int(round(remaining_above * self.height / float(self.num_items)))

             down = self.height - up - self.filled

@@ -119,12 +121,12 @@ class Menu(Action):

             for index in range(down):

                 self.window.addch(index + up + self.filled, self.width - 2, curses.ACS_CKBOARD)

-    def refresh(self, highligh = True):

+    def refresh(self, highligh=True):

         self.window.clear()

         for index, item in enumerate(self.items_strings):

-            if (index < self.head_position):

+            if index < self.head_position:

                 continue

-            elif (index > self.head_position + self.height - 1):

+            elif index > self.head_position + self.height - 1:

                 continue

             elif index == self.position:

                 if highligh:

@@ -189,9 +191,9 @@ class Menu(Action):

                     return ActionResult(False, {'diskIndex': self.position})

                 else:

                     return ActionResult(False, None)

-            

+

             elif key == curses.KEY_UP or key == curses.KEY_LEFT:

-                if not self.tab_enable and key==curses.KEY_LEFT:

+                if not self.tab_enable and key == curses.KEY_LEFT:

                     if self.save_sel:

                         return ActionResult(False, {'diskIndex': self.position, 'direction':-1})

                     elif self.selector_menu:

@@ -202,7 +204,7 @@ class Menu(Action):

                 self.navigate(-1)

             elif key == curses.KEY_DOWN or key == curses.KEY_RIGHT:

-                if not self.tab_enable and key==curses.KEY_RIGHT:

+                if not self.tab_enable and key == curses.KEY_RIGHT:

                     if self.save_sel:

                         return ActionResult(False, {'diskIndex': self.position, 'direction':1})

                     else:

@@ -217,4 +219,3 @@ class Menu(Action):

             elif key == curses.KEY_HOME:

                 self.navigate(-self.position)

-

@@ -61,9 +61,6 @@ cp EFI_$(uname -m)/BOOT/* ${BUILDROOT}/installer/EFI/BOOT/

 # grubx64.efi is generated on Photon OS by using grub2-efi >= 2.02-7:

 # # grub2-efi-mkimage -o grubx64.efi -p /boot/grub2 -O x86_64-efi  fat iso9660 part_gpt part_msdos  normal boot linux configfile loopback chain  efifwsetup efi_gop efi_uga  ls search search_label search_fs_uuid search_fs_file  gfxterm gfxterm_background gfxterm_menu test all_video loadenv  exfat ext2 udf halt gfxmenu png tga lsefi help linuxefi

-# grubaa64.efi is generated on Photon OS by using grub2-efi >= 2.02-7:

-#grub2-mkimage -o bootaa64.efi -p /boot/grub2 -O arm64-efi  fat iso9660 part_gpt part_msdos  normal boot linux configfile loopback chain efifwsetup efi_gop efinet ls search search_label search_fs_uuid search_fs_file  gfxterm gfxterm_background gfxterm_menu test all_video loadenv  exfat ext2 udf halt gfxmenu png tga lsefi help all_video

-

 # both bootx64.efi and grubx64.efi are signed with VMware key

 EFI_IMAGE=boot/grub2/efiboot.img

 EFI_FOLDER=`readlink -f ${STAGE_PATH}/efiboot`

@@ -10,7 +10,7 @@ from window import Window

 from actionresult import ActionResult

 class PackageSelector(object):

-    def __init__(self,  maxy, maxx, install_config, options_file):

+    def __init__(self, maxy, maxx, install_config, options_file):

         self.install_config = install_config

         self.maxx = maxx

         self.maxy = maxy

@@ -25,8 +25,8 @@ class PackageSelector(object):

         self.load_package_list(options_file)

         self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx,

-                             'Select Installation', True, action_panel = self.package_menu,

-                             can_go_next = True, position = 1)

+                             'Select Installation', True, action_panel=self.package_menu,

+                             can_go_next=True, position=1)

     @staticmethod

     def get_packages_to_install(options, config_type, output_data_path):

@@ -34,8 +34,12 @@ class PackageSelector(object):

         for install_option in options:

             if install_option[0] == config_type:

                 for include_type in install_option[1]["include"]:

-                    package_list = package_list + PackageSelector.get_packages_to_install(options, include_type, output_data_path)

-                json_wrapper_package_list = JsonWrapper(os.path.join(output_data_path, install_option[1]["file"]))

+                    package_list = (package_list +

+                                    PackageSelector.get_packages_to_install(options,

+                                                                            include_type,

+                                                                            output_data_path))

+                json_wrapper_package_list = JsonWrapper(os.path.join(output_data_path,

+                                                                     install_option[1]["file"]))

                 package_list_json = json_wrapper_package_list.read()

                 package_list = package_list + package_list_json["packages"]

                 break

@@ -64,19 +68,26 @@ class PackageSelector(object):

         visible_options_cnt = 0

         for install_option in options_sorted:

             if install_option[1]["visible"] == True:

-                package_list = PackageSelector.get_packages_to_install(options_sorted, install_option[0], base_path)

-                additional_files = PackageSelector.get_additional_files_to_copy_in_iso(options_sorted, base_path, install_option[0])

-                self.package_menu_items.append((install_option[1]["title"], self.exit_function, [install_option[0], package_list, additional_files] ))

+                package_list = PackageSelector.get_packages_to_install(options_sorted,

+                                                                       install_option[0],

+                                                                       base_path)

+                additional_files = PackageSelector.get_additional_files_to_copy_in_iso(

+                    options_sorted, base_path, install_option[0])

+                self.package_menu_items.append((install_option[1]["title"],

+                                                self.exit_function,

+                                                [install_option[0],

+                                                 package_list, additional_files]))

                 if install_option[0] == 'minimal':

                     default_selected = visible_options_cnt

                 visible_options_cnt = visible_options_cnt + 1

-        self.package_menu = Menu(self.menu_starty,  self.maxx, self.package_menu_items, default_selected = default_selected, tab_enable=False)

+        self.package_menu = Menu(self.menu_starty, self.maxx, self.package_menu_items,

+                                 default_selected=default_selected, tab_enable=False)

-    def exit_function(self,  selected_item_params):

-        self.install_config['type'] = selected_item_params[0];

-        self.install_config['packages'] = selected_item_params[1];

+    def exit_function(self, selected_item_params):

+        self.install_config['type'] = selected_item_params[0]

+        self.install_config['packages'] = selected_item_params[1]

         self.install_config['additional-files'] = selected_item_params[2]

         return ActionResult(True, {'custom': False})

@@ -1,4 +1,4 @@

-from window import Window 

+from window import Window

 from windowstringreader import WindowStringReader

 from textpane import TextPane

 from readmultext import ReadMulText

@@ -31,7 +31,8 @@ class PartitionISO(object):

         for index, device in enumerate(self.devices):

             self.disk_size.append((device.path, int(device.size) / 1048576))

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False, can_go_next=False)

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx,

+                             'Welcome to the Photon installer', False, can_go_next=False)

         Device.refresh_devices()

     def display(self, params):

@@ -40,9 +41,10 @@ class PartitionISO(object):

             return ActionResult(False, {'goBack':True})

         if 'autopartition' in self.install_config and self.install_config['autopartition'] == True:

             return ActionResult(True, None)

-        if 'delete_partition' in self.install_config and self.install_config['delete_partition'] == True:

+        if ('delete_partition' in self.install_config and

+                self.install_config['delete_partition'] == True):

             self.delete()

-            self.install_config['delete_partition']=False

+            self.install_config['delete_partition'] = False

         self.device_index = self.install_config['diskindex']

@@ -62,12 +64,18 @@ class PartitionISO(object):

         title = 'Current partitions:\n'

         self.window.addstr(0, (self.win_width - len(title)) // 2, title)

-        info = "Unpartitioned space: "+str(self.disk_size[self.device_index][1])+ " MB, Total size: "+ str(int(self.devices[self.device_index].size)/ 1048576)+" MB"

+        info = ("Unpartitioned space: " +

+                str(self.disk_size[self.device_index][1])+

+                " MB, Total size: "+

+                str(int(self.devices[self.device_index].size)/ 1048576) + " MB")

-        self.text_pane = TextPane(self.text_starty, self.maxx, self.text_width, 

-            "EULA.txt", self.text_height, self.disk_buttom_items, 

-            partition = True, popupWindow = True, install_config = self.install_config, 

-            text_items = self.text_items, table_space=self.table_space, default_start=1, info=info, size_left=str(self.disk_size[self.device_index][1]))

+        self.text_pane = TextPane(self.text_starty, self.maxx, self.text_width,

+                                  "EULA.txt", self.text_height, self.disk_buttom_items,

+                                  partition=True, popupWindow=True,

+                                  install_config=self.install_config,

+                                  text_items=self.text_items, table_space=self.table_space,

+                                  default_start=1, info=info,

+                                  size_left=str(self.disk_size[self.device_index][1]))

         self.window.set_action_panel(self.text_pane)

@@ -82,19 +90,24 @@ class PartitionISO(object):

         devicedata = self.devices[self.device_index].path

         #no empty fields unless swap

-        if typedata == 'swap' and (len(mtdata)!=0 or len(typedata) == 0 or len(devicedata) == 0):

+        if (typedata == 'swap' and

+                (len(mtdata) != 0 or len(typedata) == 0 or len(devicedata) == 0)):

             return False, "invalid swap data "

-        if typedata != 'swap' and (len(sizedata) == 0 or len(mtdata) == 0 or len(typedata) == 0 or len(devicedata) == 0):

-            if not self.has_empty and len(mtdata) != 0 and len(typedata) != 0 and len(devicedata) != 0:

+        if (typedata != 'swap' and

+                (len(sizedata) == 0 or

+                 len(mtdata) == 0 or

+                 len(typedata) == 0 or

+                 len(devicedata) == 0)):

+            if not self.has_empty and mtdata and typedata and devicedata:

                 self.has_empty = True

             else:

                 return False, "Input cannot be empty"

-        if typedata !='swap' and typedata!='ext3' and typedata!='ext4':

+        if typedata != 'swap' and typedata != 'ext3' and typedata != 'ext4':

             return False, "Invalid type"

-        if len(mtdata)!=0 and mtdata[0] !='/':

+        if len(mtdata) != 0 and mtdata[0] != '/':

             return False, "Invalid path"

         if mtdata in self.path_checker:

@@ -104,7 +117,7 @@ class PartitionISO(object):

         #valid size: must not exceed memory limit

         curr_size = self.disk_size[i][1]

-        if len(sizedata)!=0:

+        if len(sizedata) != 0:

             try:

                 int(sizedata)

             except ValueError:

@@ -114,10 +127,10 @@ class PartitionISO(object):

                 return False, "invalid device size"

             #if valid, update the size and return true

             new_size = (self.disk_size[i][0], int(curr_size)- int(sizedata))

-            self.disk_size[i] =new_size

+            self.disk_size[i] = new_size

-        if mtdata=="/":

-            self.has_slash=True

+        if mtdata == "/":

+            self.has_slash = True

         self.path_checker.append(mtdata)

         return True, None

@@ -127,21 +140,23 @@ class PartitionISO(object):

         self.install_config['partition_disk'] = self.devices[self.device_index].path

         self.partition_items = []

-        self.partition_items.append(('Size in MB: '+str(self.disk_size[self.device_index][1])+' available'))

+        self.partition_items.append(('Size in MB: ' +

+                                     str(self.disk_size[self.device_index][1]) +

+                                     ' available'))

         self.partition_items.append(('Type: (ext3, ext4, swap)'))

         self.partition_items.append(('Mountpoint:'))

         self.create_window = ReadMulText(

-                self.maxy, self.maxx, 0,

-                self.install_config,

-                str(self.install_config['partitionsnumber']) + 'partition_info',

-                self.partition_items,

-                None,

-                None,

-                None,

-                self.validate_partition,   #validation function of the input

-                None,

-                True,

-                )

+            self.maxy, self.maxx, 0,

+            self.install_config,

+            str(self.install_config['partitionsnumber']) + 'partition_info',

+            self.partition_items,

+            None,

+            None,

+            None,

+            self.validate_partition,   #validation function of the input

+            None,

+            True,

+            )

         result = self.create_window.do_action()

         if result.success:

             self.install_config['partitionsnumber'] = self.install_config['partitionsnumber'] + 1

@@ -161,18 +176,23 @@ class PartitionISO(object):

     def next(self):

         if self.install_config['partitionsnumber'] == 0:

-            window_height=9

-            window_width=40

-            window_starty=(self.maxy-window_height) // 2+5

-            confirm_window=ConfirmWindow(window_height,window_width,self.maxy, self.maxx, window_starty, 'Partition information cannot be empty', info=True)

+            window_height = 9

+            window_width = 40

+            window_starty = (self.maxy-window_height) // 2 + 5

+            confirm_window = ConfirmWindow(window_height, window_width, self.maxy,

+                                           self.maxx, window_starty,

+                                           'Partition information cannot be empty',

+                                           info=True)

             confirm_window.do_action()

             return self.display(False)

         #must have /

         if not self.has_slash:

-            window_height=9

-            window_width=40

-            window_starty=(self.maxy-window_height) // 2 + 5

-            confirm_window=ConfirmWindow(window_height,window_width,self.maxy, self.maxx, window_starty, 'Missing /', info=True)

+            window_height = 9