Merge pull request #2829 from dirkmueller/fstrings

schaefi · web-flow · commit b4389ac02419 · 2025-06-03T11:21:08.000+02:00
Use f-strings where feasible
diff --git a/kiwi/boot/image/base.py b/kiwi/boot/image/base.py
@@ -84,7 +84,7 @@ def __init__(
 
         if not os.path.exists(target_dir):
             raise KiwiTargetDirectoryNotFound(
-                'target directory %s not found' % target_dir
+                f'target directory {target_dir} not found'
             )
 
         self.initrd_base_name = ''.join(
@@ -223,8 +223,7 @@ def get_boot_names(self) -> boot_names_type:
                     kernel_version='none', kernel_filename='none'
                 )
             raise KiwiDiskBootImageError(
-                'No kernel in boot image tree %s found' %
-                self.boot_root_directory
+                f'No kernel in boot image tree {self.boot_root_directory} found'
             )
         dracut_output_format = self._get_boot_image_output_file_format(
             kernel_info.version
@@ -294,8 +293,7 @@ def load_boot_xml_description(self) -> None:
         boot_config_file = boot_description_directory + '/config.xml'
         if not os.path.exists(boot_config_file):
             raise KiwiConfigFileNotFound(
-                'no Boot XML description found in %s' %
-                boot_description_directory
+                f'no Boot XML description found in {boot_description_directory}'
             )
         boot_description = XMLDescription(
             description=boot_config_file,
diff --git a/kiwi/bootloader/config/base.py b/kiwi/bootloader/config/base.py
@@ -381,7 +381,7 @@ def get_boot_path(self, target='disk'):
         """
         if target != 'disk' and target != 'iso':
             raise KiwiBootLoaderTargetError(
-                'Invalid boot loader target %s' % target
+                f'Invalid boot loader target {target}'
             )
         bootpath = '/boot'
         need_boot_partition = False
diff --git a/kiwi/bootloader/config/grub2.py b/kiwi/bootloader/config/grub2.py
@@ -104,7 +104,7 @@ def post_init(self, custom_args):
             self.arch = arch
         else:
             raise KiwiBootLoaderGrubPlatformError(
-                'host architecture %s not supported for grub2 setup' % arch
+                f'host architecture {arch} not supported for grub2 setup'
             )
 
         if self.custom_args and 'grub_directory_name' in self.custom_args:
@@ -417,7 +417,7 @@ def setup_install_image_config(
             self.config = template.substitute(parameters)
         except Exception as e:
             raise KiwiTemplateError(
-                '%s: %s' % (type(e).__name__, format(e))
+                f'{type(e).__name__}: {format(e)}'
             )
         if self.firmware.efi_mode() and self.early_boot_script_efi:
             self._copy_grub_config_to_efi_path(
@@ -488,7 +488,7 @@ def setup_live_image_config(
             self.config = template.substitute(parameters)
         except Exception as e:
             raise KiwiTemplateError(
-                '%s: %s' % (type(e).__name__, format(e))
+                f'{type(e).__name__}: {format(e)}'
             )
         if self.firmware.efi_mode() and self.early_boot_script_efi:
             self._copy_grub_config_to_efi_path(
@@ -1511,7 +1511,7 @@ def _copy_modules_to_boot_directory_from(self, module_path):
             )
         except Exception as e:
             raise KiwiBootLoaderGrubModulesError(
-                'Module synchronisation failed with: %s' % format(e)
+                f'Module synchronisation failed with: {format(e)}'
             )
 
     def _get_shim_install(self):
@@ -1656,7 +1656,7 @@ def _get_partition_start(self, disk_device):
                 start_track = int(fdasd_output.split(' ')[2].lstrip())
             except Exception:
                 raise KiwiDiskGeometryError(
-                    'unknown partition format: %s' % fdasd_output
+                    f'unknown partition format: {fdasd_output}'
                 )
             return '{0}'.format(start_track * blocks)
         else:
@@ -1699,7 +1699,7 @@ def _get_dasd_disk_geometry_element(self, disk_device, search):
             return int(fdasd_output.split(':')[1].lstrip())
         except Exception:
             raise KiwiDiskGeometryError(
-                'unknown format for disk geometry: %s' % fdasd_output
+                f'unknown format for disk geometry: {fdasd_output}'
             )
 
     def _create_loopback_config(self, filename):
@@ -1720,6 +1720,6 @@ def _get_custom_template(self) -> str:
         template_path = os.path.join(os.path.abspath(self.xml_state.xml_data.description_dir),
                                      self.xml_state.build_type.bootloader[0].get_grub_template())
         if not os.path.exists(template_path):
-            raise KiwiFileNotFound('failed to locate custom GRUB template %s' % template_file)
+            raise KiwiFileNotFound(f'failed to locate custom GRUB template {template_file}')
 
         return template_path
diff --git a/kiwi/bootloader/install/grub2.py b/kiwi/bootloader/install/grub2.py
@@ -176,8 +176,7 @@ def install(self):
             self.install_arguments.append('--no-nvram')
         else:
             raise KiwiBootLoaderGrubPlatformError(
-                'host architecture %s not supported for grub2 installation' %
-                self.arch
+                f'host architecture {self.arch} not supported for grub2 installation'
             )
 
         with ExitStack() as stack:
diff --git a/kiwi/builder/archive.py b/kiwi/builder/archive.py
@@ -81,7 +81,7 @@ def create(self) -> Result:
         supported_archives = Defaults.get_archive_image_types()
         if self.requested_archive_type not in supported_archives:
             raise KiwiArchiveSetupError(
-                'Unknown archive type: %s' % self.requested_archive_type
+                f'Unknown archive type: {self.requested_archive_type}'
             )
 
         if self.requested_archive_type == 'tbz':
diff --git a/kiwi/builder/disk.py b/kiwi/builder/disk.py
@@ -1714,8 +1714,8 @@ def _sync_system_to_image(
                 Command.run(
                     [
                         'dd',
-                        'if=%s' % squashed_root_file.name,
-                        'of=%s' % readonly_target
+                        f'if={squashed_root_file.name}',
+                        f'of={readonly_target}'
                     ]
                 )
                 if self.root_filesystem_embed_verity_metadata:
@@ -1779,8 +1779,8 @@ def _sync_system_to_image(
             Command.run(
                 [
                     'dd',
-                    'if=%s' % verity_root_file.name,
-                    'of=%s' % root_target
+                    f'if={verity_root_file.name}',
+                    f'of={root_target}'
                 ]
             )
             if self.root_filesystem_embed_verity_metadata:
diff --git a/kiwi/builder/filesystem.py b/kiwi/builder/filesystem.py
@@ -63,8 +63,7 @@ def __init__(
             self.requested_filesystem = self.requested_image_type
         if not self.requested_filesystem:
             raise KiwiFileSystemSetupError(
-                'No filesystem configured in %s type' %
-                self.requested_image_type
+                f'No filesystem configured in {self.requested_image_type} type'
             )
         self.filesystem_custom_parameters = {
             'mount_options': xml_state.get_fs_mount_option_list(),
@@ -120,7 +119,7 @@ def create(self) -> Result:
         supported_filesystems = Defaults.get_filesystem_image_types()
         if self.requested_filesystem not in supported_filesystems:
             raise KiwiFileSystemSetupError(
-                'Unknown filesystem: %s' % self.requested_filesystem
+                f'Unknown filesystem: {self.requested_filesystem}'
             )
         if self.requested_filesystem not in self.filesystems_no_device_node:
             self._operate_on_loop()
diff --git a/kiwi/builder/install.py b/kiwi/builder/install.py
@@ -339,7 +339,7 @@ def create_install_pxe_archive(self) -> None:
         if custom_cmdline:
             cmdline += ' ' + custom_cmdline
         with open(append_filename, 'w') as append:
-            append.write('%s\n' % cmdline)
+            append.write(f'{cmdline}\n')
 
         # create initrd for pxe install
         log.info('Creating pxe install boot image')
@@ -496,10 +496,10 @@ def _copy_system_image_initrd_to_iso_image(self) -> None:
     def _write_install_image_info_to_iso_image(self) -> None:
         iso_trigger = self.media_dir.name + '/config.isoclient'
         with open(iso_trigger, 'w') as iso_system:
-            iso_system.write('IMAGE="%s"\n' % self.squashed_diskname)
+            iso_system.write(f'IMAGE="{self.squashed_diskname}\"\n')
 
     def _write_install_image_info_to_boot_image(self) -> None:
         initrd_trigger = \
             self.boot_image_task.boot_root_directory + '/config.vmxsystem'
         with open(initrd_trigger, 'w') as vmx_system:
-            vmx_system.write('IMAGE="%s"\n' % self.squashed_diskname)
+            vmx_system.write(f'IMAGE="{self.squashed_diskname}\"\n')
diff --git a/kiwi/cli.py b/kiwi/cli.py
@@ -297,5 +297,5 @@ def _load_command_args(self):
             return docopt(self.command_loaded.__doc__, argv=argv)
         except Exception:
             raise KiwiCommandNotLoaded(
-                '%s command not loaded' % self.get_command()
+                f'{self.get_command()} command not loaded'
             )
diff --git a/kiwi/command.py b/kiwi/command.py
@@ -127,7 +127,7 @@ def run(
             )
 
         if not cmd_abspath:
-            message = 'Command "%s" not found in the environment' % command[0]
+            message = f'Command "{command[0]}" not found in the environment'
             if raise_on_command_not_found:
                 raise KiwiCommandNotFound(message)
             log.debug('EXEC: %s', message)
@@ -143,7 +143,7 @@ def run(
             )
         except (OSError, subprocess.SubprocessError) as e:
             raise KiwiCommandError(
-                '%s: %s: %s' % (command[0], type(e).__name__, format(e))
+                f'{command[0]}: {type(e).__name__}: {format(e)}'
             ) from e
 
         output, error = process.communicate()
@@ -209,7 +209,7 @@ def call(
             command[0], custom_env=environment, access_mode=os.X_OK
         ):
             raise KiwiCommandNotFound(
-                'Command "%s" not found in the environment' % command[0]
+                f'Command "{command[0]}" not found in the environment'
             )
         try:
             process = subprocess.Popen(
@@ -220,7 +220,7 @@ def call(
             )
         except Exception as e:
             raise KiwiCommandError(
-                '%s: %s' % (type(e).__name__, format(e))
+                f'{type(e).__name__}: {format(e)}'
             ) from e
 
         # guaranteed to be true as stdout & stderr equal subprocess.PIPE
diff --git a/kiwi/container/setup/base.py b/kiwi/container/setup/base.py
@@ -44,7 +44,7 @@ class ContainerSetupBase:
     def __init__(self, root_dir, custom_args=None):
         if not os.path.exists(root_dir):
             raise KiwiContainerSetupError(
-                'Container root directory %s does not exist' % root_dir
+                f'Container root directory {root_dir} does not exist'
             )
         self.root_dir = root_dir
         self.custom_args = custom_args or {}
@@ -123,8 +123,7 @@ def deactivate_systemd_service(self, name):
                 )
             except Exception as e:
                 raise KiwiContainerSetupError(
-                    'Failed to deactivate service %s: %s' %
-                    (name, format(e))
+                    f'Failed to deactivate service {name}: {format(e)}'
                 )
 
     def setup_root_console(self):
diff --git a/kiwi/filesystem/base.py b/kiwi/filesystem/base.py
@@ -187,7 +187,7 @@ def sync_data(self, exclude: List[str] = []) -> MountManager:
             )
         if not os.path.exists(self.root_dir):
             raise KiwiFileSystemSyncError(
-                'given root directory %s does not exist' % self.root_dir
+                f'given root directory {self.root_dir} does not exist'
             )
         self.filesystem_mount = MountManager(
             device=self.device_provider.get_device()
diff --git a/kiwi/logger.py b/kiwi/logger.py
@@ -177,7 +177,7 @@ def set_logfile(self, filename: str) -> None:
             self.log_handlers['file'] = handler
         except Exception as e:
             raise KiwiLogFileSetupFailed(
-                '%s: %s' % (type(e).__name__, format(e))
+                f'{type(e).__name__}: {format(e)}'
             )
 
     def set_log_socket(self, filename: str) -> None:
diff --git a/kiwi/package_manager/apt.py b/kiwi/package_manager/apt.py
@@ -297,7 +297,7 @@ def _process_install_requests_bootstrap(self) -> CommandCallT:
             )
         except Exception as e:
             raise KiwiDebianBootstrapError(
-                '%s: %s' % (type(e).__name__, format(e))
+                f'{type(e).__name__}: {format(e)}'
             )
 
     def process_install_requests(self) -> CommandCallT:
diff --git a/kiwi/partitioner/gpt.py b/kiwi/partitioner/gpt.py
@@ -96,7 +96,7 @@ def set_flag(self, partition_id: int, flag_name: str) -> None:
         """
         if flag_name not in self.flag_map:
             raise KiwiPartitionerGptFlagError(
-                'Unknown partition flag %s' % flag_name
+                f'Unknown partition flag {flag_name}'
             )
         if self.flag_map[flag_name]:
             Command.run(
diff --git a/kiwi/partitioner/msdos.py b/kiwi/partitioner/msdos.py
@@ -89,7 +89,7 @@ def set_flag(self, partition_id: int, flag_name: str) -> None:
         """
         if flag_name not in self.flag_map:
             raise KiwiPartitionerMsDosFlagError(
-                'Unknown partition flag %s' % flag_name
+                f'Unknown partition flag {flag_name}'
             )
         flag_val = self.flag_map[flag_name]
         if flag_val:
diff --git a/kiwi/solver/repository/base.py b/kiwi/solver/repository/base.py
@@ -373,4 +373,4 @@ def _get_random_solvable_name(self):
             )
 
     def _rand(self):
-        return '%02x' % random.randrange(1, 0xfe)
+        return f'{random.randrange(1, 254):02x}'
diff --git a/kiwi/storage/luks_device.py b/kiwi/storage/luks_device.py
@@ -105,7 +105,7 @@ def create_crypto_luks(
                 options += self.option_map[osname]
             else:
                 raise KiwiLuksSetupError(
-                    'no custom option configuration found for OS %s' % osname
+                    f'no custom option configuration found for OS {osname}'
                 )
         extra_options = []
         storage_device = self.storage_provider.get_device()
@@ -130,7 +130,7 @@ def create_crypto_luks(
                 [
                     'dd', 'if=/dev/urandom', 'bs=1M',
                     'count=%d' % storage_size_mbytes,
-                    'of=%s' % storage_device
+                    f'of={storage_device}'
                 ]
             )
 
diff --git a/kiwi/storage/mapped_device.py b/kiwi/storage/mapped_device.py
@@ -34,7 +34,7 @@ class MappedDevice(DeviceProvider):
     def __init__(self, device: str, device_provider: DeviceProvider):
         if not os.path.exists(device):
             raise KiwiMappedDeviceError(
-                'Device %s does not exist' % device
+                f'Device {device} does not exist'
             )
         self.device_provider = device_provider
         self.device = device
diff --git a/kiwi/storage/subformat/base.py b/kiwi/storage/subformat/base.py
@@ -164,7 +164,7 @@ def get_target_file_path_for_format(self, format_name: str) -> str:
         if format_name != 'raw':
             if format_name not in Defaults.get_disk_format_types():
                 raise KiwiFormatSetupError(
-                    'unsupported disk format %s' % format_name
+                    f'unsupported disk format {format_name}'
                 )
         return ''.join(
             [
diff --git a/kiwi/storage/subformat/ova.py b/kiwi/storage/subformat/ova.py
@@ -47,7 +47,7 @@ def post_init(self, custom_args: dict) -> None:
         """
         ovftype = self.xml_state.get_build_type_machine_section().get_ovftype()
         if ovftype != 'vmware':
-            raise KiwiFormatSetupError('Unsupported ovftype %s' % ovftype)
+            raise KiwiFormatSetupError(f'Unsupported ovftype {ovftype}')
         self.image_format = 'ova'
         self.options = self.get_qemu_option_list(custom_args)
         self.vmdk = DiskFormatVmdk(
diff --git a/kiwi/storage/subformat/vhdfixed.py b/kiwi/storage/subformat/vhdfixed.py
@@ -118,7 +118,7 @@ def _pack_net_guid_tag(self, tag):
         )
         if not tag_format:
             raise KiwiVhdTagError(
-                'disk tag %s does not match format' % tag
+                f'disk tag {tag} does not match format'
             )
 
         # pack first nibble into 4 byte unsigned long type
diff --git a/kiwi/storage/subformat/vmdk.py b/kiwi/storage/subformat/vmdk.py
@@ -171,5 +171,5 @@ def _create_vmware_settings_file(self):
                     config.write(custom_entry + os.linesep)
         except Exception as e:
             raise KiwiTemplateError(
-                '%s: %s' % (type(e).__name__, format(e))
+                f'{type(e).__name__}: {format(e)}'
             )
diff --git a/kiwi/system/identifier.py b/kiwi/system/identifier.py
@@ -60,7 +60,7 @@ def write(self, filename: str) -> None:
         :param str filename: file path name
         """
         with open(filename, 'w') as identifier:
-            identifier.write('%s\n' % self.image_id)
+            identifier.write(f'{self.image_id}\n')
 
     def write_to_disk(self, device_provider: DeviceProvider) -> None:
         """
diff --git a/kiwi/system/result.py b/kiwi/system/result.py
@@ -164,7 +164,7 @@ def dump(self, filename: str, portable: bool = True) -> None:
                     )
         except Exception as e:
             raise KiwiResultError(
-                'Failed to pickle dump results: %s' % format(e)
+                f'Failed to pickle dump results: {format(e)}'
             )
 
     @staticmethod
@@ -179,14 +179,14 @@ def load(filename: str) -> result_type:  # type: ignore
         """
         if not os.path.exists(filename):
             raise KiwiResultError(
-                'No result information %s found' % filename
+                f'No result information {filename} found'
             )
         try:
             with open(filename, 'rb') as result:
                 return pickle.load(result)
         except Exception as e:
             raise KiwiResultError(
-                'Failed to pickle load results: %s' % type(e).__name__
+                f'Failed to pickle load results: {type(e).__name__}'
             )
 
     @staticmethod
diff --git a/kiwi/system/root_bind.py b/kiwi/system/root_bind.py
diff --git a/kiwi/system/root_init.py b/kiwi/system/root_init.py
diff --git a/kiwi/system/uri.py b/kiwi/system/uri.py
diff --git a/kiwi/tasks/base.py b/kiwi/tasks/base.py
diff --git a/kiwi/utils/checksum.py b/kiwi/utils/checksum.py
diff --git a/kiwi/utils/compress.py b/kiwi/utils/compress.py
diff --git a/kiwi/volume_manager/base.py b/kiwi/volume_manager/base.py
diff --git a/kiwi/volume_manager/btrfs.py b/kiwi/volume_manager/btrfs.py
diff --git a/kiwi/volume_manager/lvm.py b/kiwi/volume_manager/lvm.py
diff --git a/kiwi/xml_parse.py b/kiwi/xml_parse.py

Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ def get_boot_path(self, target='disk'):`
`381`	`381`	`"""`
`382`	`382`	`if target != 'disk' and target != 'iso':`
`383`	`383`	`raise KiwiBootLoaderTargetError(`
`384`		`- 'Invalid boot loader target %s' % target`
	`384`	`+ f'Invalid boot loader target {target}'`
`385`	`385`	`)`
`386`	`386`	`bootpath = '/boot'`
`387`	`387`	`need_boot_partition = False`
Original file line number	Diff line number	Diff line change
`@@ -176,8 +176,7 @@ def install(self):`
`176`	`176`	`self.install_arguments.append('--no-nvram')`
`177`	`177`	`else:`
`178`	`178`	`raise KiwiBootLoaderGrubPlatformError(`
`179`		`- 'host architecture %s not supported for grub2 installation' %`
`180`		`- self.arch`
	`179`	`+ f'host architecture {self.arch} not supported for grub2 installation'`
`181`	`180`	`)`
`182`	`181`
`183`	`182`	`with ExitStack() as stack:`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ def create(self) -> Result:`
`81`	`81`	`supported_archives = Defaults.get_archive_image_types()`
`82`	`82`	`if self.requested_archive_type not in supported_archives:`
`83`	`83`	`raise KiwiArchiveSetupError(`
`84`		`- 'Unknown archive type: %s' % self.requested_archive_type`
	`84`	`+ f'Unknown archive type: {self.requested_archive_type}'`
`85`	`85`	`)`
`86`	`86`
`87`	`87`	`if self.requested_archive_type == 'tbz':`
Original file line number	Diff line number	Diff line change
`@@ -1714,8 +1714,8 @@ def _sync_system_to_image(`
`1714`	`1714`	`Command.run(`
`1715`	`1715`	`[`
`1716`	`1716`	`'dd',`
`1717`		`- 'if=%s' % squashed_root_file.name,`
`1718`		`- 'of=%s' % readonly_target`
	`1717`	`+ f'if={squashed_root_file.name}',`
	`1718`	`+ f'of={readonly_target}'`
`1719`	`1719`	`]`
`1720`	`1720`	`)`
`1721`	`1721`	`if self.root_filesystem_embed_verity_metadata:`
`@@ -1779,8 +1779,8 @@ def _sync_system_to_image(`
`1779`	`1779`	`Command.run(`
`1780`	`1780`	`[`
`1781`	`1781`	`'dd',`
`1782`		`- 'if=%s' % verity_root_file.name,`
`1783`		`- 'of=%s' % root_target`
	`1782`	`+ f'if={verity_root_file.name}',`
	`1783`	`+ f'of={root_target}'`
`1784`	`1784`	`]`
`1785`	`1785`	`)`
`1786`	`1786`	`if self.root_filesystem_embed_verity_metadata:`
Original file line number	Diff line number	Diff line change
`@@ -297,5 +297,5 @@ def _load_command_args(self):`
`297`	`297`	`return docopt(self.command_loaded.__doc__, argv=argv)`
`298`	`298`	`except Exception:`
`299`	`299`	`raise KiwiCommandNotLoaded(`
`300`		`- '%s command not loaded' % self.get_command()`
	`300`	`+ f'{self.get_command()} command not loaded'`
`301`	`301`	`)`