[master 3/4] Fix PEP8 indentation issues.

dwlehman installerbot-noreply at redhat.com
Wed Oct 28 20:05:37 UTC 2015


From: David Lehman <dlehman at redhat.com>

This is the exact result of running the following command:

  python3-autopep8 --select E1 --in-place $(find . -name \*.py)
---
 blivet/actionlist.py                         |   2 +-
 blivet/autopart.py                           |  46 +-
 blivet/blivet.py                             |  70 +--
 blivet/callbacks.py                          |   2 +-
 blivet/deviceaction.py                       |  14 +-
 blivet/devicefactory.py                      |  80 +--
 blivet/devicelibs/edd.py                     |  18 +-
 blivet/devicelibs/lvm.py                     |   2 +-
 blivet/devicelibs/mdraid.py                  |   8 +-
 blivet/devicelibs/raid.py                    |  10 +-
 blivet/devices/btrfs.py                      |  18 +-
 blivet/devices/container.py                  |   4 +-
 blivet/devices/device.py                     |   6 +-
 blivet/devices/disk.py                       |  16 +-
 blivet/devices/dm.py                         |   8 +-
 blivet/devices/lvm.py                        |  16 +-
 blivet/devices/md.py                         |  10 +-
 blivet/devices/partition.py                  |  38 +-
 blivet/devices/raid.py                       |   6 +-
 blivet/devices/storage.py                    |   6 +-
 blivet/devicetree.py                         |  38 +-
 blivet/fcoe.py                               |   8 +-
 blivet/formats/__init__.py                   |  10 +-
 blivet/formats/biosboot.py                   |   1 -
 blivet/formats/disklabel.py                  |  10 +-
 blivet/formats/dmraid.py                     |  11 +-
 blivet/formats/fs.py                         |  16 +-
 blivet/formats/luks.py                       |   1 -
 blivet/formats/lvmpv.py                      |   1 -
 blivet/formats/mdraid.py                     |   1 -
 blivet/formats/multipath.py                  |   1 -
 blivet/formats/prepboot.py                   |   1 -
 blivet/formats/swap.py                       |   2 +-
 blivet/iscsi.py                              |  26 +-
 blivet/osinstall.py                          |  56 +-
 blivet/partitioning.py                       | 210 +++----
 blivet/platform.py                           |   2 +-
 blivet/populator.py                          |  66 +--
 blivet/size.py                               |   2 +-
 blivet/tasks/fsck.py                         |  22 +-
 blivet/tasks/fsinfo.py                       |   2 +-
 blivet/tasks/fslabeling.py                   |   2 +-
 blivet/tasks/fsmkfs.py                       |   2 +-
 blivet/tasks/fsmount.py                      |   4 +-
 blivet/tasks/fsresize.py                     |   6 +-
 blivet/tasks/task.py                         |   4 +-
 blivet/udev.py                               |   2 +-
 blivet/util.py                               |   4 +-
 blivet/zfcp.py                               |  56 +-
 doc/conf.py                                  |  22 +-
 examples/factory.py                          |  12 +-
 examples/lvm.py                              |   4 +-
 examples/partitioning.py                     |   4 +-
 tests/__init__.py                            |   1 -
 tests/action_test.py                         | 250 ++++----
 tests/clearpart_test.py                      |  26 +-
 tests/devicefactory_test.py                  |  28 +-
 tests/devicelibs_test/edd_test.py            |  72 +--
 tests/devicelibs_test/raid_test.py           |  10 +-
 tests/devices_test/device_properties_test.py | 840 +++++++++++++--------------
 tests/devices_test/lvm_test.py               |  20 +-
 tests/devices_test/partition_test.py         |  10 +-
 tests/devicetree_test.py                     | 118 ++--
 tests/formats_test/disklabel_test.py         |  10 +-
 tests/formats_test/fslabeling.py             |   4 +-
 tests/formats_test/fstesting.py              |   2 +-
 tests/formats_test/init_test.py              |  18 +-
 tests/imagebackedtestcase.py                 |   2 +-
 tests/partitioning_test.py                   |  50 +-
 tests/pylint/runpylint.py                    |  38 +-
 tests/tsort_test.py                          |   2 +-
 71 files changed, 1241 insertions(+), 1249 deletions(-)

diff --git a/blivet/actionlist.py b/blivet/actionlist.py
index 915466d..cf42028 100644
--- a/blivet/actionlist.py
+++ b/blivet/actionlist.py
@@ -189,7 +189,7 @@ def _pre_process(self, devices=None):
         # Call pre_commit_fixup on all devices, including those we're going to
         # destroy (these are already removed from the tree)
         fixup_devices = devices + [a.device for a in self._actions
-                                                if a.is_destroy and a.is_device]
+                                   if a.is_destroy and a.is_device]
         for device in fixup_devices:
             device.pre_commit_fixup()
 
diff --git a/blivet/autopart.py b/blivet/autopart.py
index 4532858..1a54739 100644
--- a/blivet/autopart.py
+++ b/blivet/autopart.py
@@ -174,9 +174,9 @@ def _schedule_implicit_partitions(storage, disks, min_luks_entropy=0):
                 fmt_type = "btrfs"
             fmt_args = {}
         part = storage.new_partition(fmt_type=fmt_type,
-                                                fmt_args=fmt_args,
-                                                grow=True,
-                                                parents=[disk])
+                                     fmt_args=fmt_args,
+                                     grow=True,
+                                     parents=[disk])
         storage.create_device(part)
         devs.append(part)
 
@@ -235,15 +235,15 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
     for request in requests:
         if ((request.lv and storage.do_autopart and
              storage.autopart_type in (AUTOPART_TYPE_LVM,
-                                      AUTOPART_TYPE_LVM_THINP)) or
-            (request.btr and storage.autopart_type == AUTOPART_TYPE_BTRFS)):
+                                       AUTOPART_TYPE_LVM_THINP)) or
+                (request.btr and storage.autopart_type == AUTOPART_TYPE_BTRFS)):
             continue
 
         if request.required_space and request.required_space > free:
             continue
 
         elif request.fstype in ("prepboot", "efi", "macefi", "hfs+") and \
-             (storage.bootloader.skip_bootloader or stage1_device):
+                (storage.bootloader.skip_bootloader or stage1_device):
             # there should never be a need for more than one of these
             # partitions, so skip them.
             log.info("skipping unneeded stage1 %s request", request.fstype)
@@ -260,11 +260,11 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
                       getattr(stage1_device.format, "labelType", None) == "gpt")
             has_bios_boot = (stage1_device and
                              any([p.format.type == "biosboot"
-                                    for p in storage.partitions
-                                        if p.disk == stage1_device]))
+                                  for p in storage.partitions
+                                  if p.disk == stage1_device]))
             if (storage.bootloader.skip_bootloader or
                 not (stage1_device and stage1_device.is_disk and
-                    is_gpt and not has_bios_boot)):
+                     is_gpt and not has_bios_boot)):
                 # there should never be a need for more than one of these
                 # partitions, so skip them.
                 log.info("skipping unneeded stage1 %s request", request.fstype)
@@ -289,21 +289,21 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
             fmt_args = {}
 
         dev = storage.new_partition(fmt_type=fmt_type,
-                                            fmt_args=fmt_args,
-                                            size=request.size,
-                                            grow=request.grow,
-                                            maxsize=request.max_size,
-                                            mountpoint=request.mountpoint,
-                                            parents=disks,
-                                            weight=request.weight)
+                                    fmt_args=fmt_args,
+                                    size=request.size,
+                                    grow=request.grow,
+                                    maxsize=request.max_size,
+                                    mountpoint=request.mountpoint,
+                                    parents=disks,
+                                    weight=request.weight)
 
         # schedule the device for creation
         storage.create_device(dev)
 
         if request.encrypted and storage.encrypted_autopart:
             luks_fmt = get_format(request.fstype,
-                                 device=dev.path,
-                                 mountpoint=request.mountpoint)
+                                  device=dev.path,
+                                  mountpoint=request.mountpoint)
             luks_dev = LUKSDevice("luks-%s" % dev.name,
                                   fmt=luks_fmt,
                                   size=dev.size,
@@ -312,7 +312,7 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
 
         if storage.do_autopart and \
            storage.autopart_type in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP,
-                                    AUTOPART_TYPE_BTRFS):
+                                     AUTOPART_TYPE_BTRFS):
             # doing LVM/BTRFS -- make sure the newly created partition fits in some
             # free space together with one of the implicitly requested partitions
             smallest_implicit = sorted(implicit_devices, key=lambda d: d.size)[0]
@@ -381,8 +381,8 @@ def _schedule_volumes(storage, devs):
     for request in storage.autopart_requests:
         btr = storage.autopart_type == AUTOPART_TYPE_BTRFS and request.btr
         lv = (storage.autopart_type in (AUTOPART_TYPE_LVM,
-                                       AUTOPART_TYPE_LVM_THINP) and request.lv)
-        thinlv = (storage.autopart_type == AUTOPART_TYPE_LVM_THINP and
+                                        AUTOPART_TYPE_LVM_THINP) and request.lv)
+        thinlv = (storage.auto_part_type == AUTOPART_TYPE_LVM_THINP and
                   request.lv and request.thin)
         if thinlv and pool is None:
             # create a single thin pool in the vg
@@ -444,7 +444,7 @@ def do_reqpart(storage, requests):
 
     if disks == []:
         raise NotEnoughFreeSpaceError(_("Not enough free space on disks for "
-                                      "automatic partitioning"))
+                                        "automatic partitioning"))
 
     _schedule_partitions(storage, disks, [], requests=requests)
 
@@ -498,7 +498,7 @@ def do_autopart(storage, data, min_luks_entropy=0):
 
     if disks == []:
         raise NotEnoughFreeSpaceError(_("Not enough free space on disks for "
-                                      "automatic partitioning"))
+                                        "automatic partitioning"))
 
     devs = _schedule_partitions(storage, disks, devs, min_luks_entropy=min_luks_entropy)
 
diff --git a/blivet/blivet.py b/blivet/blivet.py
index 3d57cec..aa1a98e 100644
--- a/blivet/blivet.py
+++ b/blivet/blivet.py
@@ -527,9 +527,9 @@ def should_clear(self, device, **kwargs):
         """
         clear_part_type = kwargs.get("clear_part_type", self.config.clear_part_type)
         clear_part_disks = kwargs.get("clear_part_disks",
-                                    self.config.clear_part_disks)
+                                      self.config.clear_part_disks)
         clear_part_devices = kwargs.get("clear_part_devices",
-                                      self.config.clear_part_devices)
+                                        self.config.clear_part_devices)
 
         for disk in device.disks:
             # this will not include disks with hidden formats like multipath
@@ -689,7 +689,7 @@ def initialize_disk(self, disk):
 
         # create a new disklabel on the disk
         new_label = get_format("disklabel", device=disk.path,
-                             label_type=label_type)
+                               label_type=label_type)
         create_action = ActionCreateFormat(disk, fmt=new_label)
         self.devicetree.register_action(create_action)
 
@@ -737,7 +737,7 @@ def get_free_space(self, disks=None, clear_part_type=None):
         free = {}
         for disk in disks:
             should_clear = self.should_clear(disk, clear_part_type=clear_part_type,
-                                            clear_part_disks=[disk.name])
+                                             clear_part_disks=[disk.name])
             if should_clear:
                 free[disk.name] = (disk.size, Size(0))
                 continue
@@ -751,8 +751,8 @@ def get_free_space(self, disks=None, clear_part_type=None):
                     # operations to translate free filesystem space into free disk
                     # space
                     should_clear = self.should_clear(partition,
-                                                    clear_part_type=clear_part_type,
-                                                    clear_part_disks=[disk.name])
+                                                     clear_part_type=clear_part_type,
+                                                     clear_part_disks=[disk.name])
                     if should_clear:
                         disk_free += partition.size
                     elif hasattr(partition.format, "free"):
@@ -796,9 +796,9 @@ def new_partition(self, *args, **kwargs):
         """
         if 'fmt_type' in kwargs:
             kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
-                                         mountpoint=kwargs.pop("mountpoint",
-                                                               None),
-                                         **kwargs.pop("fmt_args", {}))
+                                       mountpoint=kwargs.pop("mountpoint",
+                                                             None),
+                                       **kwargs.pop("fmt_args", {}))
 
         if 'name' in kwargs:
             name = kwargs.pop("name")
@@ -811,7 +811,7 @@ def new_partition(self, *args, **kwargs):
                 mountpoint = getattr(fmt, "mountpoint", None)
 
                 kwargs["weight"] = _platform.weight(mountpoint=mountpoint,
-                                                        fstype=fmt.type)
+                                                    fstype=fmt.type)
 
         return PartitionDevice(name, *args, **kwargs)
 
@@ -835,23 +835,23 @@ def new_mdarray(self, *args, **kwargs):
         """
         if 'fmt_type' in kwargs:
             kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
-                                         mountpoint=kwargs.pop("mountpoint",
-                                                               None),
-                                         **kwargs.pop("fmt_args", {}))
+                                       mountpoint=kwargs.pop("mountpoint",
+                                                             None),
+                                       **kwargs.pop("fmt_args", {}))
 
         name = kwargs.pop("name", None)
         if name:
             safe_name = self.safe_device_name(name)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
-                                safe_name, name)
+                            safe_name, name)
                 name = safe_name
         else:
             swap = getattr(kwargs.get("fmt"), "type", None) == "swap"
             mountpoint = getattr(kwargs.get("fmt"), "mountpoint", None)
             name = self.suggest_device_name(prefix=short_product_name,
-                                          swap=swap,
-                                          mountpoint=mountpoint)
+                                            swap=swap,
+                                            mountpoint=mountpoint)
 
         return MDRaidArrayDevice(name, *args, **kwargs)
 
@@ -877,7 +877,7 @@ def new_vg(self, *args, **kwargs):
             safe_name = self.safe_device_name(name)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
-                                safe_name, name)
+                            safe_name, name)
                 name = safe_name
         else:
             hostname = ""
@@ -930,8 +930,8 @@ def new_lv(self, *args, **kwargs):
         mountpoint = kwargs.pop("mountpoint", None)
         if 'fmt_type' in kwargs:
             kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
-                                         mountpoint=mountpoint,
-                                         **kwargs.pop("fmt_args", {}))
+                                       mountpoint=mountpoint,
+                                       **kwargs.pop("fmt_args", {}))
 
         name = kwargs.pop("name", None)
         if name:
@@ -942,7 +942,7 @@ def new_lv(self, *args, **kwargs):
             if safe_name != full_name:
                 new_name = safe_name[len(safe_vg_name) + 1:]
                 log.warning("using '%s' instead of specified name '%s'",
-                                new_name, name)
+                            new_name, name)
                 name = new_name
         else:
             if kwargs.get("fmt") and kwargs["fmt"].type == "swap":
@@ -955,9 +955,9 @@ def new_lv(self, *args, **kwargs):
                 prefix = "pool"
 
             name = self.suggest_device_name(parent=vg,
-                                          swap=swap,
-                                          mountpoint=mountpoint,
-                                          prefix=prefix)
+                                            swap=swap,
+                                            mountpoint=mountpoint,
+                                            prefix=prefix)
 
         if "%s-%s" % (vg.name, name) in self.names:
             raise ValueError("name already in use")
@@ -1268,7 +1268,7 @@ def suggest_container_name(self, hostname=None, prefix=""):
         return name
 
     def suggest_device_name(self, parent=None, swap=None,
-                                  mountpoint=None, prefix=""):
+                            mountpoint=None, prefix=""):
         """ Return a suitable, unused name for a new device.
 
             :keyword parent: the parent device
@@ -1411,7 +1411,7 @@ def turn_on_swap(self):
 
     def mount_filesystems(self, read_only=None, skip_root=False):
         self.fsset.mount_filesystems(root_path=get_sysroot(),
-                                    read_only=read_only, skip_root=skip_root)
+                                     read_only=read_only, skip_root=skip_root)
 
     def umount_filesystems(self, swapoff=True):
         self.fsset.umount_filesystems(swapoff=swapoff)
@@ -1514,7 +1514,7 @@ def _check_valid_fstype(self, newtype):
             raise ValueError("unrecognized value %s for new default fs type" % newtype)
 
         if (not fmt.mountable or not fmt.formattable or not fmt.supported or
-            not fmt.linux_native):
+                not fmt.linux_native):
             log.debug("invalid default fstype: %r", fmt)
             raise ValueError("new value %s is not valid as a default fs type" % fmt)
 
@@ -1694,7 +1694,7 @@ def copy(self):
         # go through and re-get parted_partitions from the disks since they
         # don't get deep-copied
         hidden_partitions = [d for d in new.devicetree._hidden
-                                if isinstance(d, PartitionDevice)]
+                             if isinstance(d, PartitionDevice)]
         for partition in new.partitions + hidden_partitions:
             if not partition._parted_partition:
                 continue
@@ -1774,10 +1774,10 @@ def update_ksdata(self):
             self.ksdata.clearpart.devices = []
             self.ksdata.clearpart.drives = []
             fresh_disks = [d.name for d in self.disks if d.partitioned and
-                                                         not d.format.exists]
+                           not d.format.exists]
 
             destroy_actions = self.devicetree.find_actions(action_type="destroy",
-                                                          object_type="device")
+                                                           object_type="device")
 
             cleared_partitions = []
             partial = False
@@ -1809,15 +1809,15 @@ def _update_custom_storage_ksdata(self):
 
         # custom storage
         ks_map = {PartitionDevice: ("PartData", "partition"),
-                 TmpFSDevice: ("PartData", "partition"),
-                 LVMLogicalVolumeDevice: ("LogVolData", "logvol"),
-                 LVMVolumeGroupDevice: ("VolGroupData", "volgroup"),
-                 MDRaidArrayDevice: ("RaidData", "raid"),
-                 BTRFSDevice: ("BTRFSData", "btrfs")}
+                  TmpFSDevice: ("PartData", "partition"),
+                  LVMLogicalVolumeDevice: ("LogVolData", "logvol"),
+                  LVMVolumeGroupDevice: ("VolGroupData", "volgroup"),
+                  MDRaidArrayDevice: ("RaidData", "raid"),
+                  BTRFSDevice: ("BTRFSData", "btrfs")}
 
         # make a list of ancestors of all used devices
         devices = list(set(a for d in list(self.mountpoints.values()) + self.swaps
-                                for a in d.ancestors))
+                           for a in d.ancestors))
 
         # devices which share information with their distinct raw device
         complementary_devices = [d for d in devices if d.raw_device is not d]
diff --git a/blivet/callbacks.py b/blivet/callbacks.py
index 52f59ab..8947f13 100644
--- a/blivet/callbacks.py
+++ b/blivet/callbacks.py
@@ -78,4 +78,4 @@ def create_new_callbacks_register(create_format_pre=None,
 WaitForEntropyData = namedtuple("WaitForEntropyData",
                                 ["msg", "min_entropy"])
 ReportProgressData = namedtuple("ReportProgressData",
-                                 ["msg"])
+                                ["msg"])
diff --git a/blivet/deviceaction.py b/blivet/deviceaction.py
index ffb6c5f..6c42fe9 100644
--- a/blivet/deviceaction.py
+++ b/blivet/deviceaction.py
@@ -418,8 +418,8 @@ def obsoletes(self, action):
             if self.id >= action.id and not self.device.exists:
                 rc = True
             elif self.id > action.id and \
-                 self.device.exists and \
-                 not (action.is_destroy and action.is_format):
+                    self.device.exists and \
+                    not (action.is_destroy and action.is_format):
                 rc = True
             elif action.is_add and (action.device == self.device):
                 rc = True
@@ -893,8 +893,8 @@ def obsoletes(self, action):
         """
         retval = False
         if (action.is_remove and
-            action.device == self.device and
-            action.container == self.container):
+                action.device == self.device and
+                action.container == self.container):
             retval = True
         elif (action.is_add and
               action.device == self.device and
@@ -945,7 +945,7 @@ def requires(self, action):
         """
         retval = False
         if ((action.is_shrink or action.is_destroy) and
-            action.device.container == self.container):
+                action.device.container == self.container):
             retval = True
         elif action.is_add and action.container == self.container:
             retval = True
@@ -963,8 +963,8 @@ def obsoletes(self, action):
         """
         retval = False
         if (action.is_add and
-            action.device == self.device and
-            action.container == self.container):
+                action.device == self.device and
+                action.container == self.container):
             retval = True
         elif (action.is_remove and
               action.device == self.device and
diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py
index f76496a..54f5d9d 100644
--- a/blivet/devicefactory.py
+++ b/blivet/devicefactory.py
@@ -137,7 +137,7 @@ def get_device_factory(blivet, device_type, size, **kwargs):
 
     factory_class = class_table[device_type]
     log.debug("instantiating %s: %s, %s, %s, %s", factory_class,
-                blivet, size, [d.name for d in disks], kwargs)
+              blivet, size, [d.name for d in disks], kwargs)
     return factory_class(blivet, size, disks, **kwargs)
 
 
@@ -520,7 +520,7 @@ def get_container(self, device=None, name=None, allow_existing=False):
                     break
         else:
             containers = [c for c in self.container_list
-                            if allow_existing or not c.exists]
+                          if allow_existing or not c.exists]
             if containers:
                 # XXX All containers should have a "free" attribute
                 containers.sort(key=lambda c: getattr(c, "freeSpace", c.size),
@@ -662,9 +662,9 @@ def _create_device(self):
                 fmt_args["label"] = self.label
 
             fmt = get_format(self.fstype,
-                            mountpoint=self.mountpoint,
-                            min_luks_entropy=self.min_luks_entropy,
-                            **fmt_args)
+                             mountpoint=self.mountpoint,
+                             min_luks_entropy=self.min_luks_entropy,
+                             **fmt_args)
             luks_device = LUKSDevice("luks-" + device.name,
                                      parents=[device], fmt=fmt)
             self.storage.create_device(luks_device)
@@ -718,17 +718,17 @@ def _set_format(self):
         current_format = self.device.format
         if current_format.type != self.fstype:
             new_format = get_format(self.fstype,
-                                   mountpoint=self.mountpoint,
-                                   label=self.label,
-                                   exists=False)
+                                    mountpoint=self.mountpoint,
+                                    label=self.label,
+                                    exists=False)
             self.storage.format_device(self.device, new_format)
         else:
             if (hasattr(current_format, "mountpoint") and
-                current_format.mountpoint != self.mountpoint):
+                    current_format.mountpoint != self.mountpoint):
                 current_format.mountpoint = self.mountpoint
 
             if (hasattr(current_format, "label") and
-                current_format.label != self.label):
+                    current_format.label != self.label):
                 current_format.label = self.label
 
     def _set_encryption(self):
@@ -749,7 +749,7 @@ def _set_encryption(self):
             orig_device = self.device
             leaf_format = self.device.format
             self.storage.format_device(self.device, get_format("luks",
-                                                             min_luks_entropy=self.min_luks_entropy))
+                                                               min_luks_entropy=self.min_luks_entropy))
             luks_device = LUKSDevice("luks-%s" % self.device.name,
                                      fmt=leaf_format,
                                      parents=self.device)
@@ -761,19 +761,19 @@ def _set_encryption(self):
     def _set_name(self):
         if not self.device_name:
             self.device_name = self.storage.suggest_device_name(
-                                                  parent=self.container,
-                                                  swap=(self.fstype == "swap"),
-                                                  mountpoint=self.mountpoint)
+                parent=self.container,
+                swap=(self.fstype == "swap"),
+                mountpoint=self.mountpoint)
 
         safe_new_name = self.storage.safe_device_name(self.device_name)
         if self.device.name != safe_new_name:
             if safe_new_name in self.storage.names:
                 log.error("not renaming '%s' to in-use name '%s'",
-                            self.device.name, safe_new_name)
+                          self.device.name, safe_new_name)
                 return
 
             log.debug("renaming device '%s' to '%s'",
-                        self.device.name, safe_new_name)
+                      self.device.name, safe_new_name)
             self.device.name = safe_new_name
 
     def _post_create(self):
@@ -917,7 +917,7 @@ def _set_device_size(self):
         """ Set the size of a defined factory device. """
         if self.raw_device and self.size != self.raw_device.size:
             log.info("adjusting device size from %s to %s",
-                            self.raw_device.size, self.size)
+                     self.raw_device.size, self.size)
 
             base_size = self._get_base_size()
             size = self._get_device_size()
@@ -948,8 +948,8 @@ def _get_new_device(self, *args, **kwargs):
         kwargs["size"] = self._get_base_size()
 
         device = self.storage.new_partition(*args,
-                                           grow=True, maxsize=max_size,
-                                           **kwargs)
+                                            grow=True, maxsize=max_size,
+                                            **kwargs)
         return device
 
     def _set_disks(self):
@@ -988,8 +988,8 @@ def __init__(self, storage, size, disks, fstype=None, encrypted=False,
                 devices             an initial set of devices
         """
         super(PartitionSetFactory, self).__init__(storage, size, disks,
-                                                     fstype=fstype,
-                                                     encrypted=encrypted)
+                                                  fstype=fstype,
+                                                  encrypted=encrypted)
         self._devices = []
         if devices:
             self._devices = devices
@@ -1050,7 +1050,7 @@ def configure(self):
         # drop any new disks that don't have free space
         min_free = min(Size("500MiB"), self.parent_factory.size)
         add_disks = [d for d in add_disks if d.partitioned and
-                                             d.format.free >= min_free]
+                     d.format.free >= min_free]
 
         log.debug("add_disks: %s", [d.name for d in add_disks])
         log.debug("remove_disks: %s", [d.name for d in remove_disks])
@@ -1073,7 +1073,7 @@ def configure(self):
                 self.storage.destroy_device(member)
                 members.remove(member)
                 self.storage.format_device(member.slave,
-                                          get_format(self.fstype))
+                                           get_format(self.fstype))
                 members.append(member.slave)
                 if container:
                     container.parents.replace(member, member.slave)
@@ -1083,10 +1083,10 @@ def configure(self):
             if not member_encrypted and self.encrypted:
                 members.remove(member)
                 self.storage.format_device(member, get_format("luks",
-                                                             min_luks_entropy=self.min_luks_entropy))
+                                                              min_luks_entropy=self.min_luks_entropy))
                 luks_member = LUKSDevice("luks-%s" % member.name,
-                                    parents=[member],
-                                    fmt=get_format(self.fstype))
+                                         parents=[member],
+                                         fmt=get_format(self.fstype))
                 self.storage.create_device(luks_member)
                 members.append(luks_member)
                 if container:
@@ -1118,8 +1118,8 @@ def configure(self):
 
             try:
                 member = self.storage.new_partition(parents=[disk], grow=True,
-                                           size=base_size,
-                                           fmt_type=member_format)
+                                                    size=base_size,
+                                                    fmt_type=member_format)
             except (StorageError, blockdev.BlockDevError) as e:
                 log.error("failed to create new member partition: %s", e)
                 continue
@@ -1229,7 +1229,7 @@ def _set_device_size(self):
         size = self._get_device_size()
         if self.device and size != self.raw_device.size:
             log.info("adjusting device size from %s to %s",
-                            self.raw_device.size, size)
+                     self.raw_device.size, size)
             self.raw_device.size = size
             self.raw_device.req_grow = False
 
@@ -1319,16 +1319,16 @@ def _get_new_device(self, *args, **kwargs):
     def _set_name(self):
         if not self.device_name:
             self.device_name = self.storage.suggest_device_name(
-                                                  parent=self.container,
-                                                  swap=(self.fstype == "swap"),
-                                                  mountpoint=self.mountpoint)
+                parent=self.container,
+                swap=(self.fstype == "swap"),
+                mountpoint=self.mountpoint)
 
         lvname = "%s-%s" % (self.container.name, self.device_name)
         safe_new_name = self.storage.safe_device_name(lvname)
         if self.device.name != safe_new_name:
             if safe_new_name in self.storage.names:
                 log.error("not renaming '%s' to in-use name '%s'",
-                            self.device.name, safe_new_name)
+                          self.device.name, safe_new_name)
                 return
 
             if not safe_new_name.startswith(self.container.name):
@@ -1338,7 +1338,7 @@ def _set_name(self):
             # strip off the vg name before setting
             safe_new_name = safe_new_name[len(self.container.name) + 1:]
             log.debug("renaming device '%s' to '%s'",
-                        self.device.name, safe_new_name)
+                      self.device.name, safe_new_name)
             self.device.name = safe_new_name
 
     def _configure(self):
@@ -1352,7 +1352,7 @@ def _configure(self):
                 use_dev = member.raw_device
 
                 if ((self.container_raid_level and use_dev.type != "mdarray") or
-                    (not self.container_raid_level and use_dev.type == "mdarray")):
+                        (not self.container_raid_level and use_dev.type == "mdarray")):
                     self.container.parents.remove(member)
                     self.storage.destroy_device(member)
                     if member != use_dev:
@@ -1590,8 +1590,8 @@ def _set_container(self):
         self.pool = self.get_pool()
         if self.pool:
             log.debug("pool is %s ; size: %s ; free: %s", self.pool.name,
-                                                          self.pool.size,
-                                                          self.pool.free_space)
+                      self.pool.size,
+                      self.pool.free_space)
             for lv in self.pool.lvs:
                 log.debug("  %s size is %s", lv.name, lv.size)
 
@@ -1632,9 +1632,9 @@ def __init__(self, storage, size, disks, **kwargs):
 
     def _get_device_space(self):
         return self.raid_level.get_space(self.size,
-           len(self._get_member_devices()),
-           None,
-           blockdev.md.get_superblock_size)
+                                         len(self._get_member_devices()),
+                                         None,
+                                         blockdev.md.get_superblock_size)
 
     def _get_total_space(self):
         return self._get_device_space()
diff --git a/blivet/devicelibs/edd.py b/blivet/devicelibs/edd.py
index 2de52ed..edf2964 100644
--- a/blivet/devicelibs/edd.py
+++ b/blivet/devicelibs/edd.py
@@ -426,7 +426,7 @@ def devname_from_scsi_pci_dev(self):
             'chan': self.edd.channel,
             'dev': self.edd.scsi_id,
             'lun': self.edd.scsi_lun,
-            }
+        }
         path = tmpl0 % args
         pattern = tmpl1 % args
         matching_paths = glob.glob(pattern)
@@ -434,8 +434,8 @@ def devname_from_scsi_pci_dev(self):
             block_entries = os.listdir(path)
             if len(block_entries) == 1:
                 self.edd.sysfslink = "..%s/%s" % (
-                                path[len(fsroot) + len("/sys"):],
-                                block_entries[0])
+                    path[len(fsroot) + len("/sys"):],
+                    block_entries[0])
                 name = block_entries[0]
         elif len(matching_paths) > 1:
             log.error("edd: Too many devices match for pci dev %s channel %s "
@@ -447,8 +447,8 @@ def devname_from_scsi_pci_dev(self):
             block_entries = os.listdir(matching_paths[0])
             if len(block_entries) == 1:
                 self.edd.sysfslink = "..%s/%s" % (
-                                matching_paths[0][len(fsroot) + len("/sys"):],
-                                block_entries[0])
+                    matching_paths[0][len(fsroot) + len("/sys"):],
+                    block_entries[0])
                 name = block_entries[0]
         else:
             log.warning("edd: Could not find SCSI device for pci dev %s "
@@ -460,7 +460,7 @@ def devname_from_virt_pci_dev(self):
         args = {
             'fsroot': fsroot,
             'pci_dev': self.edd.pci_dev
-            }
+        }
         pattern = "%(fsroot)s/sys/devices/pci0000:00/0000:%(pci_dev)s/virtio*"
         matching_paths = glob.glob(pattern % args)
 
@@ -472,8 +472,8 @@ def devname_from_virt_pci_dev(self):
                 block_entries = os.listdir(newpath)
             if len(block_entries) == 1:
                 self.edd.sysfslink = "..%s/%s" % (
-                        matching_paths[0][len(fsroot) + len("/sys"):],
-                        block_entries[0])
+                    matching_paths[0][len(fsroot) + len("/sys"):],
+                    block_entries[0])
                 return block_entries[0]
             else:
                 # Virtio SCSI looks like scsi but with a virtio%d/ stuck in
@@ -598,7 +598,7 @@ def get_edd_dict(devices):
             old_edd_number = edd_dict.get(name)
             if old_edd_number:
                 log.info("edd: both edd entries 0x%x and 0x%x seem to map to %s",
-                          old_edd_number, edd_number, name)
+                         old_edd_number, edd_number, name)
                 # this means all the other data can be confused and useless
                 return {}
             edd_dict[name] = edd_number
diff --git a/blivet/devicelibs/lvm.py b/blivet/devicelibs/lvm.py
index 539d554..a2b2826 100644
--- a/blivet/devicelibs/lvm.py
+++ b/blivet/devicelibs/lvm.py
@@ -65,7 +65,7 @@
 # argument.  For every time we call an lvm_cc (lvm compose config) funciton
 # we regenerate the config_args with all global info.
 config_args_data = {"filterRejects": [],    # regular expressions to reject.
-                     "filterAccepts": []}   # regexp to accept
+                    "filterAccepts": []}   # regexp to accept
 
 
 def _set_global_config():
diff --git a/blivet/devicelibs/mdraid.py b/blivet/devicelibs/mdraid.py
index 7ace310..fe5af47 100644
--- a/blivet/devicelibs/mdraid.py
+++ b/blivet/devicelibs/mdraid.py
@@ -37,10 +37,10 @@ class MDRaidLevels(raid.RAIDLevels):
     @classmethod
     def is_raid_level(cls, level):
         return super(MDRaidLevels, cls).is_raid_level(level) and \
-           hasattr(level, 'get_max_spares') and \
-           hasattr(level, 'get_space') and \
-           hasattr(level, 'get_recommended_stride') and \
-           hasattr(level, 'get_size')
+            hasattr(level, 'get_max_spares') and \
+            hasattr(level, 'get_space') and \
+            hasattr(level, 'get_recommended_stride') and \
+            hasattr(level, 'get_size')
 
 RAID_levels = MDRaidLevels(["raid0", "raid1", "raid4", "raid5", "raid6", "raid10", "linear"])
 
diff --git a/blivet/devicelibs/raid.py b/blivet/devicelibs/raid.py
index 046a443..54ebce6 100644
--- a/blivet/devicelibs/raid.py
+++ b/blivet/devicelibs/raid.py
@@ -112,17 +112,17 @@ class RAIDn(RAIDLevel):
     is_uniform = property(lambda s: True)
 
     number = property(lambda s: int(s.level),
-       doc="A numeric code for this level")
+                      doc="A numeric code for this level")
 
     name = property(lambda s: "raid" + s.level,
-       doc="The canonical name for this level")
+                    doc="The canonical name for this level")
 
     alt_synth_names = property(lambda s: ["RAID" + s.level, s.level, s.number],
-       doc="names that can be synthesized from level but are not name")
+                               doc="names that can be synthesized from level but are not name")
 
     names = property(lambda s:
-       [n for n in [s.name] + [s.nick] + s.alt_synth_names if n is not None],
-       doc="all valid names for this level")
+                     [n for n in [s.name] + [s.nick] + s.alt_synth_names if n is not None],
+                     doc="all valid names for this level")
 
     # METHODS
     def get_max_spares(self, member_count):
diff --git a/blivet/devices/btrfs.py b/blivet/devices/btrfs.py
index ba0b716..a1d8b26 100644
--- a/blivet/devices/btrfs.py
+++ b/blivet/devices/btrfs.py
@@ -206,13 +206,13 @@ def __init__(self, *args, **kwargs):
         if self.parents and not self.format.type:
             label = getattr(self.parents[0].format, "label", None)
             self.format = get_format("btrfs",
-                                    exists=self.exists,
-                                    label=label,
-                                    vol_uuid=self.uuid,
-                                    device=self.path,
-                                    subvolspec=self.vol_id,
-                                    mountopts="subvolid=%d" % self.vol_id,
-                                    create_options=create_options)
+                                     exists=self.exists,
+                                     label=label,
+                                     vol_uuid=self.uuid,
+                                     device=self.path,
+                                     subvolspec=self.vol_id,
+                                     mountopts="subvolid=%d" % self.vol_id,
+                                     create_options=create_options)
             self.original_format = copy.deepcopy(self.format)
 
         self._default_subvolume_id = None
@@ -309,8 +309,8 @@ def _get_size(self):
         # Calculate the size as if it were a RAID with no superblock and a chunk_size of 1
         data_level = self.data_level or raid.Single
         return data_level.get_size([d.size for d in self.parents],
-                chunk_size=Size(1),
-                superblock_size_func=lambda x: 0)
+                                   chunk_size=Size(1),
+                                   superblock_size_func=lambda x: 0)
 
     def _remove_parent(self, member):
         levels = (l for l in (self.data_level, self.metadata_level) if l)
diff --git a/blivet/devices/container.py b/blivet/devices/container.py
index 3897b51..6e5b8c6 100644
--- a/blivet/devices/container.py
+++ b/blivet/devices/container.py
@@ -53,9 +53,9 @@ class ContainerDevice(StorageDevice):
     """
 
     _format_class_name = abc.abstractproperty(lambda s: None,
-        doc="The type of member devices' required format")
+                                              doc="The type of member devices' required format")
     _format_uuid_attr = abc.abstractproperty(lambda s: None,
-        doc="The container UUID attribute in the member format class")
+                                             doc="The container UUID attribute in the member format class")
 
     def __init__(self, *args, **kwargs):
         self.format_class = get_device_format_class(self._format_class_name)
diff --git a/blivet/devices/device.py b/blivet/devices/device.py
index 7254359..48ea554 100644
--- a/blivet/devices/device.py
+++ b/blivet/devices/device.py
@@ -97,8 +97,8 @@ def __deepcopy__(self, memo):
             For these parted objects, we just do a shallow copy.
         """
         return util.variable_copy(self, memo,
-           omit=('node',),
-           shallow=('_parted_partition',))
+                                  omit=('node',),
+                                  shallow=('_parted_partition',))
 
     def __repr__(self):
         s = ("%(type)s instance (%(id)s) --\n"
@@ -163,7 +163,7 @@ def _get_parent_list(self):
     @property
     def dict(self):
         d = {"type": self.type, "name": self.name,
-              "parents": [p.name for p in self.parents]}
+             "parents": [p.name for p in self.parents]}
         return d
 
     def remove_child(self):
diff --git a/blivet/devices/disk.py b/blivet/devices/disk.py
index ef2c973..27a8448 100644
--- a/blivet/devices/disk.py
+++ b/blivet/devices/disk.py
@@ -147,9 +147,9 @@ def __init__(self, name, fmt=None,
         self._dev_dir = os.path.dirname(name)
 
         super(DiskFile, self).__init__(_name, fmt=fmt, size=size,
-                            major=major, minor=minor, sysfs_path=sysfs_path,
-                            parents=parents, serial=serial, vendor=vendor,
-                            model=model, bus=bus, exists=exists)
+                                       major=major, minor=minor, sysfs_path=sysfs_path,
+                                       parents=parents, serial=serial, vendor=vendor,
+                                       model=model, bus=bus, exists=exists)
 
     #
     # Regular files do not have sysfs entries.
@@ -341,7 +341,7 @@ def _setup(self, orig=False):
         rc = util.run_program(["multipath", self.name])
         if rc:
             raise errors.MPathError("multipath activation failed for '%s'" %
-                            self.name, hardware_fault=True)
+                                    self.name, hardware_fault=True)
 
     def _post_setup(self):
         StorageDevice._post_setup(self)
@@ -400,10 +400,10 @@ def __init__(self, device, **kwargs):
             NetworkStorageDevice.__init__(self, host_address=self.node.address,
                                           nic=self.nic)
             log.debug("created new iscsi disk %s %s:%d via %s:%s", self.node.name,
-                                                                   self.node.address,
-                                                                   self.node.port,
-                                                                   self.node.iface,
-                                                                   self.nic)
+                      self.node.address,
+                      self.node.port,
+                      self.node.iface,
+                      self.nic)
 
     def dracut_setup_args(self):
         if self.ibft:
diff --git a/blivet/devices/dm.py b/blivet/devices/dm.py
index a908ef2..76892f6 100644
--- a/blivet/devices/dm.py
+++ b/blivet/devices/dm.py
@@ -46,8 +46,8 @@ class DMDevice(StorageDevice):
     _type = "dm"
     _dev_dir = "/dev/mapper"
     _external_dependencies = [
-       availability.KPARTX_APP,
-       availability.BLOCKDEV_DM_PLUGIN
+        availability.KPARTX_APP,
+        availability.BLOCKDEV_DM_PLUGIN
     ]
 
     def __init__(self, name, fmt=None, size=None, dm_uuid=None, uuid=None,
@@ -78,8 +78,8 @@ def __init__(self, name, fmt=None, size=None, dm_uuid=None, uuid=None,
                 stored in device metadata on disk.
         """
         super(DMDevice, self).__init__(name, fmt=fmt, size=size,
-                               exists=exists, uuid=uuid,
-                               parents=parents, sysfs_path=sysfs_path)
+                                       exists=exists, uuid=uuid,
+                                       parents=parents, sysfs_path=sysfs_path)
         self.target = target
         self.dm_uuid = dm_uuid
 
diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py
index 416f942..d753edd 100644
--- a/blivet/devices/lvm.py
+++ b/blivet/devices/lvm.py
@@ -125,8 +125,8 @@ def __init__(self, name, parents=None, size=None, free=None,
             self._complete = True
 
         super(LVMVolumeGroupDevice, self).__init__(name, parents=parents,
-                                            uuid=uuid, size=size,
-                                            exists=exists, sysfs_path=sysfs_path)
+                                                   uuid=uuid, size=size,
+                                                   exists=exists, sysfs_path=sysfs_path)
 
         self.free = util.numeric_type(free)
         self.pe_size = util.numeric_type(pe_size)
@@ -315,7 +315,7 @@ def _add_parent(self, member):
         super(LVMVolumeGroupDevice, self)._add_parent(member)
 
         if (self.exists and member.format.exists and
-            len(self.parents) + 1 == self.pv_count):
+                len(self.parents) + 1 == self.pv_count):
             self._complete = True
 
     def _remove_parent(self, member):
@@ -799,7 +799,7 @@ def _pre_create(self):
 
         if self.size > can_use:
             msg = ("%s LV's size (%s) exceeds the VG's usable free space (%s),"
-                  "shrinking the LV") % (self.name, self.size, can_use)
+                   "shrinking the LV") % (self.name, self.size, can_use)
             log.warning(msg)
             self.size = can_use
 
@@ -865,7 +865,7 @@ def isleaf(self):
         # Thin snapshots do not need to be removed prior to removal of the
         # origin, but the old snapshots do.
         non_thin_snapshots = any(s for s in self.snapshots
-                                    if not isinstance(s, LVMThinSnapShotDevice))
+                                 if not isinstance(s, LVMThinSnapShotDevice))
         return (super(LVMLogicalVolumeDevice, self).isleaf and
                 not non_thin_snapshots)
 
@@ -1045,8 +1045,8 @@ def __init__(self, name, vg, parent_lv=None, size=None, uuid=None,
         # and some parameters set to values reflecting the fact that this is an
         # internal LV
         super(LVMInternalLogicalVolumeDevice, self).__init__(name, parents=None,
-              size=size, uuid=uuid, seg_type=seg_type, fmt=None, exists=exists,
-              sysfs_path=sysfs_path, grow=None, maxsize=None, percent=None)
+                                                             size=size, uuid=uuid, seg_type=seg_type, fmt=None, exists=exists,
+                                                             sysfs_path=sysfs_path, grow=None, maxsize=None, percent=None)
 
         if parent_lv:
             self._parent_lv.add_internal_lv(self)
@@ -1200,7 +1200,7 @@ def resizable(self):
     # (only) thin pool metadata LVs can be resized directly
     def resize(self):
         if ((self._parent_lv and not isinstance(self._parent_lv, LVMThinPoolDevice)) or
-            re.search(r'_[rc]meta', self.lvname)):
+                re.search(r'_[rc]meta', self.lvname)):
             raise errors.DeviceError("RAID and cache pool metadata LVs cannot be resized directly")
 
         # skip the generic LVMInternalLogicalVolumeDevice class and call the
diff --git a/blivet/devices/md.py b/blivet/devices/md.py
index 9e19be3..3822f13 100644
--- a/blivet/devices/md.py
+++ b/blivet/devices/md.py
@@ -229,9 +229,9 @@ def size(self):
         if not self.exists or not self.media_present:
             try:
                 size = self.level.get_size([d.size for d in self.members],
-                    self.member_devices,
-                    self.chunk_size,
-                    self.get_superblock_size)
+                                           self.member_devices,
+                                           self.chunk_size,
+                                           self.get_superblock_size)
             except (blockdev.MDRaidError, errors.RaidError) as e:
                 log.info("could not calculate size of device %s for raid level %s: %s", self.name, self.level, e)
                 size = Size(0)
@@ -305,8 +305,8 @@ def _set_member_devices(self, number):
         self._member_devices = number
 
     member_devices = property(lambda d: d._get_member_devices(),
-                             lambda d, m: d._set_member_devices(m),
-                             doc="number of member devices")
+                              lambda d, m: d._set_member_devices(m),
+                              doc="number of member devices")
 
     def _get_spares(self):
         spares = 0
diff --git a/blivet/devices/partition.py b/blivet/devices/partition.py
index 6d1c626..ce358e3 100644
--- a/blivet/devices/partition.py
+++ b/blivet/devices/partition.py
@@ -251,7 +251,7 @@ def align_target_size(self, newsize):
             return newsize
 
         (_constraint, geometry) = self._compute_resize(self.parted_partition,
-                                                      newsize=newsize)
+                                                       newsize=newsize)
         return Size(geometry.getLength(unit="B"))
 
     def _set_target_size(self, newsize):
@@ -345,7 +345,7 @@ def _set_parted_partition(self, partition):
         self.update_name()
 
     parted_partition = property(lambda d: d._get_parted_partition(),
-                               lambda d, p: d._set_parted_partition(p))
+                                lambda d, p: d._set_parted_partition(p))
 
     def pre_commit_fixup(self):
         """ Re-get self.parted_partition from the original disklabel. """
@@ -361,14 +361,14 @@ def pre_commit_fixup(self):
             # getPartitionBySector doesn't work on extended partitions
             _partition = _disklabel.extended_partition
             log.debug("extended lookup found partition %s",
-                        device_path_to_name(getattr(_partition, "path", None) or "(none)"))
+                      device_path_to_name(getattr(_partition, "path", None) or "(none)"))
         else:
             # lookup the partition by sector to avoid the renumbering
             # nonsense entirely
             _sector = self.parted_partition.geometry.start
             _partition = _disklabel.parted_disk.getPartitionBySector(_sector)
             log.debug("sector-based lookup found partition %s",
-                        device_path_to_name(getattr(_partition, "path", None) or "(none)"))
+                      device_path_to_name(getattr(_partition, "path", None) or "(none)"))
 
         self.parted_partition = _partition
 
@@ -489,7 +489,7 @@ def remove_hook(self, modparent=True):
             if self.parted_partition.type == parted.PARTITION_EXTENDED and \
                     len(self.disk.format.logical_partitions) > 0:
                 raise ValueError("Cannot remove extended partition %s.  "
-                        "Logical partitions present." % self.name)
+                                 "Logical partitions present." % self.name)
 
             self.disk.format.remove_partition(self.parted_partition)
 
@@ -505,8 +505,8 @@ def add_hook(self, new=True):
             return
 
         self.disk.format.add_partition(self.parted_partition.geometry.start,
-                                      self.parted_partition.geometry.end,
-                                      self.parted_partition.type)
+                                       self.parted_partition.geometry.end,
+                                       self.parted_partition.type)
 
         # Look up the path by start sector to deal with automatic renumbering of
         # logical partitions on msdos disklabels.
@@ -575,8 +575,8 @@ def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
         self.disk.format.add_partition(self.parted_partition.geometry.start,
-                                      self.parted_partition.geometry.end,
-                                      self.parted_partition.type)
+                                       self.parted_partition.geometry.end,
+                                       self.parted_partition.type)
 
         self._wipe()
         try:
@@ -594,7 +594,7 @@ def _post_create(self):
             partition = self.disk.format.parted_disk.getPartitionBySector(start)
 
         log.debug("post-commit partition path is %s", getattr(partition,
-                                                             "path", None))
+                                                              "path", None))
         self.parted_partition = partition
         if not self.is_extended:
             # Ensure old metadata which lived in freespace so did not get
@@ -625,8 +625,8 @@ def _compute_resize(self, partition, newsize=None):
         current_dev = current_geom.device
         new_len = int(newsize // Size(current_dev.sectorSize))
         new_geometry = parted.Geometry(device=current_dev,
-                                      start=current_geom.start,
-                                      length=new_len)
+                                       start=current_geom.start,
+                                       length=new_len)
         # and align the end sector
         if new_geometry.length < current_geom.length:
             align = self.disk.format.end_alignment.alignUp
@@ -652,9 +652,9 @@ def resize(self):
         (constraint, geometry) = self._compute_resize(partition)
 
         parted_disk.setPartitionGeometry(partition=partition,
-                                        constraint=constraint,
-                                        start=geometry.start,
-                                        end=geometry.end)
+                                         constraint=constraint,
+                                         start=geometry.start,
+                                         end=geometry.end)
 
         self.disk.format.commit()
         self.update_size()
@@ -690,9 +690,9 @@ def _destroy(self):
             self.disk.original_format.commit()
         except errors.DiskLabelCommitError:
             self.disk.original_format.add_partition(
-                                        self.parted_partition.geometry.start,
-                                        self.parted_partition.geometry.end,
-                                        self.parted_partition.type)
+                self.parted_partition.geometry.start,
+                self.parted_partition.geometry.end,
+                self.parted_partition.type)
             self.parted_partition = self.disk.original_format.parted_disk.getPartitionByPath(self.path)
             raise
 
@@ -851,7 +851,7 @@ def max_size(self):
     @property
     def resizable(self):
         return super(PartitionDevice, self).resizable and \
-               self.disk.type != 'dasd'
+            self.disk.type != 'dasd'
 
     def check_size(self):
         """ Check to make sure the size of the device is allowed by the
diff --git a/blivet/devices/raid.py b/blivet/devices/raid.py
index 85fa3a3..6f999d1 100644
--- a/blivet/devices/raid.py
+++ b/blivet/devices/raid.py
@@ -54,9 +54,9 @@ def _validate_raid_level(self, level, parent_diff=0):
         num_members = len(self.members) + parent_diff  # pylint: disable=no-member
         if not self.exists and num_members < level.min_members:
             message = P_(
-               "RAID level %(raid_level)s requires that device have at least %(min_members)d member.",
-               "RAID level %(raid_level)s requires that device have at least %(min_members)d members.",
-               level.min_members
+                "RAID level %(raid_level)s requires that device have at least %(min_members)d member.",
+                "RAID level %(raid_level)s requires that device have at least %(min_members)d members.",
+                level.min_members
             )
             return message % {"raid_level": level, "min_members": level.min_members}
         return None
diff --git a/blivet/devices/storage.py b/blivet/devices/storage.py
index 61df3e9..b394d2b 100644
--- a/blivet/devices/storage.py
+++ b/blivet/devices/storage.py
@@ -232,8 +232,8 @@ def _set_target_size(self, newsize):
         self._target_size = newsize
 
     target_size = property(lambda s: s._get_target_size(),
-                          lambda s, v: s._set_target_size(v),
-                          doc="Target size of this device")
+                           lambda s, v: s._set_target_size(v),
+                           doc="Target size of this device")
 
     def __repr__(self):
         s = Device.__repr__(self)
@@ -834,7 +834,7 @@ def type_external_dependencies(cls):
             device type and of all superclass device types.
         """
         return set(
-           d for p in cls.__mro__ if issubclass(p, StorageDevice) for d in p._external_dependencies
+            d for p in cls.__mro__ if issubclass(p, StorageDevice) for d in p._external_dependencies
         )
 
     @classmethod
diff --git a/blivet/devicetree.py b/blivet/devicetree.py
index d1d022d..b8eb843 100644
--- a/blivet/devicetree.py
+++ b/blivet/devicetree.py
@@ -199,12 +199,12 @@ def _add_device(self, newdev, new=True):
         # don't include "req%d" partition names
         if ((newdev.type != "partition" or
              not newdev.name.startswith("req")) and
-            newdev.type != "btrfs volume" and
-            newdev.name not in self.names):
+                newdev.type != "btrfs volume" and
+                newdev.name not in self.names):
             self.names.append(newdev.name)
         log.info("added %s %s (id %d) to device tree", newdev.type,
-                                                       newdev.name,
-                                                       newdev.id)
+                 newdev.name,
+                 newdev.id)
 
     def _remove_device(self, dev, force=None, modparent=True):
         """ Remove a device from the tree.
@@ -243,8 +243,8 @@ def _remove_device(self, dev, force=None, modparent=True):
         if dev.name in self.names and getattr(dev, "complete", True):
             self.names.remove(dev.name)
         log.info("removed %s %s (id %d) from device tree", dev.type,
-                                                           dev.name,
-                                                           dev.id)
+                 dev.name,
+                 dev.id)
 
     def recursive_remove(self, device, actions=True):
         """ Remove a device after removing its dependent devices.
@@ -351,7 +351,7 @@ def cancel_action(self, action):
         log.info("canceled action %s", action)
 
     def find_actions(self, device=None, action_type=None, object_type=None,
-                    path=None, devid=None):
+                     path=None, devid=None):
         """ Find all actions that match all specified parameters.
 
             A value of None for any of the keyword arguments indicates that any
@@ -424,7 +424,7 @@ def get_related_disks(self, disk):
 
         """
         return set(d for dep in self.get_dependent_devices(disk, hidden=True)
-                        for d in dep.disks)
+                   for d in dep.disks)
 
     def hide(self, device):
         """ Hide the specified device.
@@ -471,13 +471,13 @@ def hide(self, device):
             # aggregate/container device (eg: lvm volume group).
             disks = [device]
             related_actions = [a for a in self._actions
-                                    if a.device.depends_on(device)]
+                               if a.device.depends_on(device)]
             for related_device in (a.device for a in related_actions):
                 disks.extend(related_device.disks)
 
             disks = set(disks)
             cancel = [a for a in self._actions
-                            if set(a.device.disks).intersection(disks)]
+                      if set(a.device.disks).intersection(disks)]
             for action in reversed(cancel):
                 self.cancel_action(action)
 
@@ -519,8 +519,8 @@ def unhide(self, device):
                not any(parent in self._hidden for parent in hidden.parents):
 
                 log.info("unhiding device %s %s (id %d)", hidden.type,
-                                                          hidden.name,
-                                                          hidden.id)
+                         hidden.name,
+                         hidden.id)
                 self._hidden.remove(hidden)
                 self._devices.append(hidden)
                 hidden.add_hook(new=False)
@@ -747,8 +747,8 @@ def get_device_by_name(self, name, incomplete=False, hidden=False):
         if name:
             devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
             result = next((d for d in devices if d.name == name or
-               (isinstance(d, _LVM_DEVICE_CLASSES) and d.name == name.replace("--", "-"))),
-               None)
+                           (isinstance(d, _LVM_DEVICE_CLASSES) and d.name == name.replace("--", "-"))),
+                          None)
         log_method_return(self, result)
         return result
 
@@ -773,8 +773,8 @@ def get_device_by_path(self, path, incomplete=False, hidden=False):
             # the end. So that the search can prefer leaves to interior nodes
             # the list that is searched is the reverse of the devices list.
             result = next((d for d in reversed(list(devices)) if d.path == path or
-               (isinstance(d, _LVM_DEVICE_CLASSES) and d.path == path.replace("--", "-"))),
-               None)
+                           (isinstance(d, _LVM_DEVICE_CLASSES) and d.path == path.replace("--", "-"))),
+                          None)
 
         log_method_return(self, result)
         return result
@@ -925,14 +925,14 @@ def resolve_device(self, devspec, blkid_tab=None, crypt_tab=None, options=None):
             # device-by-uuid
             uuid = devspec.partition("=")[2]
             if ((uuid.startswith('"') and uuid.endswith('"')) or
-                (uuid.startswith("'") and uuid.endswith("'"))):
+                    (uuid.startswith("'") and uuid.endswith("'"))):
                 uuid = uuid[1:-1]
             device = self.uuids.get(uuid)
         elif devspec.startswith("LABEL="):
             # device-by-label
             label = devspec.partition("=")[2]
             if ((label.startswith('"') and label.endswith('"')) or
-                (label.startswith("'") and label.endswith("'"))):
+                    (label.startswith("'") and label.endswith("'"))):
                 label = label[1:-1]
             device = self.labels.get(label)
         elif re.match(r'(0x)?[A-Fa-f0-9]{2}(p\d+)?$', devspec):
@@ -1067,7 +1067,7 @@ def handle_nodev_filesystems(self):
                     continue
 
                 log.info("found nodev %s filesystem mounted at %s",
-                            fstype, mountpoint)
+                         fstype, mountpoint)
                 # nodev filesystems require some special handling.
                 # For now, a lot of this is based on the idea that it's a losing
                 # battle to require the presence of an FS class for every type
diff --git a/blivet/fcoe.py b/blivet/fcoe.py
index c50a7b0..ed0b8b1 100644
--- a/blivet/fcoe.py
+++ b/blivet/fcoe.py
@@ -121,15 +121,15 @@ def add_san(self, nic, dcb=False, auto_vlan=True):
             self._start_lldpad()
             util.run_program(["dcbtool", "sc", nic, "dcb", "on"])
             util.run_program(["dcbtool", "sc", nic, "app:fcoe",
-                                                "e:1", "a:1", "w:1"])
+                              "e:1", "a:1", "w:1"])
             rc, out = util.run_program_and_capture_output(["fipvlan", "-c", "-s", "-f",
-                                               "-fcoe", nic], stderr_to_stdout=True)
+                                                           "-fcoe", nic], stderr_to_stdout=True)
         else:
             if auto_vlan:
                 # certain network configrations require the VLAN layer module:
                 util.run_program(["modprobe", "8021q"])
                 rc, out = util.run_program_and_capture_output(["fipvlan", '-c', '-s', '-f',
-                                                   "-fcoe", nic], stderr_to_stdout=True)
+                                                               "-fcoe", nic], stderr_to_stdout=True)
             else:
                 f = open("/sys/module/libfcoe/parameters/create", "w")
                 f.write(nic)
@@ -153,7 +153,7 @@ def write(self, root):
 
         for nic, dcb, auto_vlan in self.nics:
             fd = util.eintr_retry_call(os.open, root + "/etc/fcoe/cfg-" + nic,
-                                                os.O_RDWR | os.O_CREAT)
+                                       os.O_RDWR | os.O_CREAT)
             config = '# Created by anaconda\n'
             config += '# Enable/Disable FCoE service at the Ethernet port\n'
             config += 'FCOE_ENABLE="yes"\n'
diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py
index 1a5e14b..af6c828 100644
--- a/blivet/formats/__init__.py
+++ b/blivet/formats/__init__.py
@@ -51,7 +51,7 @@ def register_device_format(fmt_class):
 
     device_formats[fmt_class._type] = fmt_class
     log.debug("registered device format class %s as %s", fmt_class.__name__,
-                                                         fmt_class._type)
+              fmt_class._type)
 
 default_fstypes = ("ext4", "ext3", "ext2")
 
@@ -97,7 +97,7 @@ def get_format(fmt_type, *args, **kwargs):
         fmt._name = fmt_type
 
     log.debug("getFormat('%s') returning %s instance with object id %d",
-       fmt_type, fmt.__class__.__name__, fmt.id)
+              fmt_type, fmt.__class__.__name__, fmt.id)
     return fmt
 
 
@@ -302,9 +302,9 @@ def _get_options(self):
         return self._options
 
     options = property(
-       lambda s: s._get_options(),
-       lambda s, v: s._set_options(v),
-       doc="fstab entry option string"
+        lambda s: s._get_options(),
+        lambda s, v: s._set_options(v),
+        doc="fstab entry option string"
     )
 
     def _set_create_options(self, options):
diff --git a/blivet/formats/biosboot.py b/blivet/formats/biosboot.py
index 6fa04b1..34001cc 100644
--- a/blivet/formats/biosboot.py
+++ b/blivet/formats/biosboot.py
@@ -62,4 +62,3 @@ def supported(self):
         return super(BIOSBoot, self).supported and isinstance(platform.platform, platform.X86)
 
 register_device_format(BIOSBoot)
-
diff --git a/blivet/formats/disklabel.py b/blivet/formats/disklabel.py
index f10edbe..9ea89a3 100644
--- a/blivet/formats/disklabel.py
+++ b/blivet/formats/disklabel.py
@@ -82,8 +82,8 @@ def __deepcopy__(self, memo):
             We can't do copy.deepcopy on parted objects, which is okay.
         """
         return util.variable_copy(self, memo,
-           shallow=('_parted_device', '_optimal_alignment', '_minimal_alignment',),
-           duplicate=('_parted_disk', '_orig_parted_disk'))
+                                  shallow=('_parted_device', '_optimal_alignment', '_minimal_alignment',),
+                                  duplicate=('_parted_disk', '_orig_parted_disk'))
 
     def __repr__(self):
         s = DeviceFormat.__repr__(self)
@@ -299,7 +299,7 @@ def add_partition(self, start, end, ptype=None):
 
         constraint = parted.Constraint(exactGeom=geometry)
         self.parted_disk.addPartition(partition=new_partition,
-                                     constraint=constraint)
+                                      constraint=constraint)
 
     def remove_partition(self, partition):
         """ Remove a partition from the disklabel.
@@ -359,7 +359,7 @@ def _get_disk_label_alignment(self):
                 self._disk_label_alignment = self.parted_disk.partitionAlignment
             except _ped.CreateException:
                 self._disk_label_alignment = parted.Alignment(offset=0,
-                                                            grainSize=1)
+                                                              grainSize=1)
 
         return self._disk_label_alignment
 
@@ -457,7 +457,7 @@ def get_end_alignment(self, size=None, alignment=None):
             alignment = self.get_alignment(size=size)
 
         return parted.Alignment(offset=alignment.offset - 1,
-                            grainSize=alignment.grainSize)
+                                grainSize=alignment.grainSize)
 
     @property
     def alignment(self):
diff --git a/blivet/formats/dmraid.py b/blivet/formats/dmraid.py
index 13a3084..2ba9dcf 100644
--- a/blivet/formats/dmraid.py
+++ b/blivet/formats/dmraid.py
@@ -44,11 +44,11 @@ class DMRaidMember(DeviceFormat):
     #     One problem that presents is the possibility of someone passing
     #     a dmraid member to the MDRaidArrayDevice constructor.
     _udev_types = ["adaptec_raid_member", "ddf_raid_member",
-                 "hpt37x_raid_member", "hpt45x_raid_member",
-                 "isw_raid_member",
-                 "jmicron_raid_member", "lsi_mega_raid_member",
-                 "nvidia_raid_member", "promise_fasttrack_raid_member",
-                 "silicon_medley_raid_member", "via_raid_member"]
+                   "hpt37x_raid_member", "hpt45x_raid_member",
+                   "isw_raid_member",
+                   "jmicron_raid_member", "lsi_mega_raid_member",
+                   "nvidia_raid_member", "promise_fasttrack_raid_member",
+                   "silicon_medley_raid_member", "via_raid_member"]
     _supported = True                   # is supported
     _packages = ["dmraid"]              # required packages
     _hidden = True                      # hide devices with this formatting?
@@ -103,4 +103,3 @@ def destroy(self, **kwargs):
     DMRaidMember._udev_types = []
 
 register_device_format(DMRaidMember)
-
diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py
index ce31206..d386a21 100644
--- a/blivet/formats/fs.py
+++ b/blivet/formats/fs.py
@@ -142,7 +142,7 @@ def __init__(self, **kwargs):
                 self.update_size_info()
             except FSError:
                 log.warning("%s filesystem on %s needs repair", self.type,
-                                                                self.device)
+                            self.device)
 
         self._target_size = self._size
 
@@ -214,7 +214,7 @@ def label_format_ok(self, label):
         return label is None or (self._labelfs is not None and self._labelfs.label_format_ok(label))
 
     label = property(lambda s: s._get_label(), lambda s, l: s._set_label(l),
-       doc="this filesystem's label")
+                     doc="this filesystem's label")
 
     def _set_target_size(self, newsize):
         """ Set the target size for this filesystem.
@@ -243,14 +243,14 @@ def _get_target_size(self):
         return self._target_size
 
     target_size = property(_get_target_size, _set_target_size,
-                          doc="Target size for this filesystem")
+                           doc="Target size for this filesystem")
 
     def _get_size(self):
         """ Get this filesystem's size. """
         return self.target_size if self.resizable else self._size
 
     size = property(_get_size, doc="This filesystem's size, accounting "
-                                  "for pending changes")
+                    "for pending changes")
 
     def update_size_info(self):
         """ Update this filesystem's current and minimum size (for resize). """
@@ -431,7 +431,7 @@ def do_resize(self):
         # contains it. To round up would risk quietly setting a target size too
         # large for the device to hold.
         rounded = self.target_size.round_to_nearest(self._resize.unit,
-                                                 rounding=ROUND_DOWN)
+                                                    rounding=ROUND_DOWN)
 
         # 1. target size was between the min size and max size values prior to
         #    rounding (see _set_target_size)
@@ -524,7 +524,7 @@ def system_mountpoint(self):
         # It is possible to have multiple mountpoints, return the last one
         try:
             return mounts_cache.get_mountpoints(self.device,
-                                              getattr(self, "subvolspec", None))[-1]
+                                                getattr(self, "subvolspec", None))[-1]
         except IndexError:
             return None
 
@@ -783,8 +783,8 @@ def sync(self, root='/'):
             available under the install root.
         """
         if not self.status or not self.system_mountpoint or \
-            not self.system_mountpoint.startswith(root) or \
-            not self._sync.available:
+                not self.system_mountpoint.startswith(root) or \
+                not self._sync.available:
             return
 
         try:
diff --git a/blivet/formats/luks.py b/blivet/formats/luks.py
index 5b9599d..4d9347d 100644
--- a/blivet/formats/luks.py
+++ b/blivet/formats/luks.py
@@ -273,4 +273,3 @@ def escrow(self, directory, backup_passphrase):
 
 
 register_device_format(LUKS)
-
diff --git a/blivet/formats/lvmpv.py b/blivet/formats/lvmpv.py
index 471e681..65bab91 100644
--- a/blivet/formats/lvmpv.py
+++ b/blivet/formats/lvmpv.py
@@ -144,4 +144,3 @@ def status(self):
                 os.path.isdir("/dev/%s" % self.vg_name))
 
 register_device_format(LVMPhysicalVolume)
-
diff --git a/blivet/formats/mdraid.py b/blivet/formats/mdraid.py
index 4f499f9..9212c15 100644
--- a/blivet/formats/mdraid.py
+++ b/blivet/formats/mdraid.py
@@ -111,4 +111,3 @@ def hidden(self):
     MDRaidMember._udev_types.append("isw_raid_member")
 
 register_device_format(MDRaidMember)
-
diff --git a/blivet/formats/multipath.py b/blivet/formats/multipath.py
index 0b2d2e2..064b171 100644
--- a/blivet/formats/multipath.py
+++ b/blivet/formats/multipath.py
@@ -81,4 +81,3 @@ def destroy(self, **kwargs):
         raise MultipathMemberError("destruction of multipath members is non-sense")
 
 register_device_format(MultipathMember)
-
diff --git a/blivet/formats/prepboot.py b/blivet/formats/prepboot.py
index 249c2b2..4d80975 100644
--- a/blivet/formats/prepboot.py
+++ b/blivet/formats/prepboot.py
@@ -100,4 +100,3 @@ def supported(self):
         return super(PPCPRePBoot, self).supported and isinstance(platform.platform, platform.IPSeriesPPC)
 
 register_device_format(PPCPRePBoot)
-
diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py
index c378c5e..ef4da08 100644
--- a/blivet/formats/swap.py
+++ b/blivet/formats/swap.py
@@ -108,7 +108,7 @@ def label_format_ok(self, label):
         return True
 
     label = property(lambda s: s._get_label(), lambda s, l: s._set_label(l),
-       doc="the label for this swap space")
+                     doc="the label for this swap space")
 
     def _set_priority(self, priority):
         # pylint: disable=attribute-defined-outside-init
diff --git a/blivet/iscsi.py b/blivet/iscsi.py
index 72a2f50..3a14537 100644
--- a/blivet/iscsi.py
+++ b/blivet/iscsi.py
@@ -110,10 +110,10 @@ def _call_discover_targets(con_write, con_recv, ipaddr, port, authinfo):
             # TODO: change libiscsi.node to pickable object
             for node in found_nodes:
                 nodes.append({'name': node.name,
-                             'tpgt': node.tpgt,
-                             'address': node.address,
-                             'port': node.port,
-                             'iface': node.iface})
+                              'tpgt': node.tpgt,
+                              'address': node.address,
+                              'port': node.port,
+                              'iface': node.iface})
 
             con_write.send((True, nodes))
 
@@ -222,7 +222,7 @@ def _start_ibft(self):
             try:
                 node.login()
                 log.info("iscsi IBFT: logged into %s at %s:%s through %s",
-                    node.name, node.address, node.port, node.iface)
+                         node.name, node.address, node.port, node.iface)
                 self.ibft_nodes.append(node)
             except IOError as e:
                 log.error("Could not log into ibft iscsi target %s: %s",
@@ -285,7 +285,7 @@ def startup(self):
         self.initiator_set = True
 
         for fulldir in (os.path.join("/var/lib/iscsi", d) for d in
-           ['ifaces', 'isns', 'nodes', 'send_targets', 'slp', 'static']):
+                        ['ifaces', 'isns', 'nodes', 'send_targets', 'slp', 'static']):
             if not os.path.isdir(fulldir):
                 os.makedirs(fulldir, 0o755)
 
@@ -295,7 +295,7 @@ def startup(self):
         # not present in iscsi-initiator-utils for Fedora.
         try:
             iscsiuio = util.find_program_in_path('iscsiuio',
-                                                   raise_on_error=True)
+                                                 raise_on_error=True)
         except RuntimeError:
             log.info("iscsi: iscsiuio not found.")
         else:
@@ -388,7 +388,7 @@ def discover(self, ipaddr, port="3260", username=None, password=None,
                 if not logged_in]
 
     def log_into_node(self, node, username=None, password=None,
-                  r_username=None, r_password=None):
+                      r_username=None, r_password=None):
         """
         Raises IOError.
         """
@@ -407,7 +407,7 @@ def log_into_node(self, node, username=None, password=None,
             node.login()
             rc = True
             log.info("iSCSI: logged into %s at %s:%s through %s",
-                    node.name, node.address, node.port, node.iface)
+                     node.name, node.address, node.port, node.iface)
             if not self._mark_node_active(node):
                 log.error("iSCSI: node not found among discovered")
         except (IOError, ValueError) as e:
@@ -417,9 +417,9 @@ def log_into_node(self, node, username=None, password=None,
         return (rc, msg)
 
     def add_target(self, ipaddr, port="3260", user=None, pw=None,
-                  user_in=None, pw_in=None, target=None, iface=None,
-                  discover_user=None, discover_pw=None,
-                  discover_user_in=None, discover_pw_in=None):
+                   user_in=None, pw_in=None, target=None, iface=None,
+                   discover_user=None, discover_pw=None,
+                   discover_user_in=None, discover_pw_in=None):
         """
         Connect to iSCSI server specified by IP address and port
         and add all targets found on the server and authenticate if necessary.
@@ -468,7 +468,7 @@ def add_target(self, ipaddr, port="3260", user=None, pw=None,
                 node_net_iface = self.ifaces.get(node.iface, node.iface)
                 if iface != node_net_iface:
                     log.debug("iscsi: skipping logging to iscsi node '%s' via %s",
-                               node.name, node_net_iface)
+                              node.name, node_net_iface)
                     continue
 
             found = found + 1
diff --git a/blivet/osinstall.py b/blivet/osinstall.py
index a15880a..c57168b 100644
--- a/blivet/osinstall.py
+++ b/blivet/osinstall.py
@@ -187,9 +187,9 @@ def parse_fstab(devicetree, chroot=None):
 
             # find device in the tree
             device = devicetree.resolve_device(devspec,
-                                              crypt_tab=crypt_tab,
-                                              blkid_tab=blkid_tab,
-                                              options=options)
+                                               crypt_tab=crypt_tab,
+                                               blkid_tab=blkid_tab,
+                                               options=options)
 
             if device is None:
                 continue
@@ -264,10 +264,10 @@ def _find_existing_installations(devicetree):
                 name = _("Unknown Linux")
             elif "linux" in product.lower():
                 name = _("%(product)s %(version)s for %(arch)s") % \
-                        {"product": product, "version": version, "arch": architecture}
+                    {"product": product, "version": version, "arch": architecture}
             else:
                 name = _("%(product)s Linux %(version)s for %(arch)s") % \
-                        {"product": product, "version": version, "arch": architecture}
+                    {"product": product, "version": version, "arch": architecture}
 
         (mounts, swaps) = parse_fstab(devicetree, chroot=get_sysroot())
         util.umount(mountpoint=get_sysroot())
@@ -311,8 +311,8 @@ def sysfs(self):
     def dev(self):
         if not self._dev:
             self._dev = DirectoryDevice("/dev",
-               fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True),
-               exists=True)
+                                        fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True),
+                                        exists=True)
 
         return self._dev
 
@@ -356,8 +356,8 @@ def efivars(self):
     def run(self):
         if not self._run:
             self._run = DirectoryDevice("/run",
-               fmt=get_format("bind", device="/run", mountpoint="/run", exists=True),
-               exists=True)
+                                        fmt=get_format("bind", device="/run", mountpoint="/run", exists=True),
+                                        exists=True)
 
         return self._run
 
@@ -390,9 +390,9 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
 
         # find device in the tree
         device = self.devicetree.resolve_device(devspec,
-                                               crypt_tab=self.crypt_tab,
-                                               blkid_tab=self.blkid_tab,
-                                               options=options)
+                                                crypt_tab=self.crypt_tab,
+                                                blkid_tab=self.blkid_tab,
+                                                options=options)
 
         if device:
             # fall through to the bottom of this block
@@ -404,15 +404,15 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
             # NFS -- preserve but otherwise ignore
             device = NFSDevice(devspec,
                                fmt=get_format(fstype,
-                                                exists=True,
-                                                device=devspec))
+                                              exists=True,
+                                              device=devspec))
         elif devspec.startswith("/") and fstype == "swap":
             # swap file
             device = FileDevice(devspec,
                                 parents=get_containing_device(devspec, self.devicetree),
                                 fmt=get_format(fstype,
-                                                 device=devspec,
-                                                 exists=True),
+                                               device=devspec,
+                                               exists=True),
                                 exists=True)
         elif fstype == "bind" or "bind" in options:
             # bind mount... set fstype so later comparison won't
@@ -426,8 +426,8 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
             parents = get_containing_device(devspec, self.devicetree)
             device = DirectoryDevice(devspec, parents=parents, exists=True)
             device.format = get_format("bind",
-                                      device=device.path,
-                                      exists=True)
+                                       device=device.path,
+                                       exists=True)
         elif mountpoint in ("/proc", "/sys", "/dev/shm", "/dev/pts",
                             "/sys/fs/selinux", "/proc/bus/usb", "/sys/firmware/efi/efivars"):
             # drop these now -- we'll recreate later
@@ -442,7 +442,7 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
 
         if device is None:
             log.error("failed to resolve %s (%s) from fstab", devspec,
-                                                              fstype)
+                      fstype)
             raise UnrecognizedFSTabEntryError()
 
         device.setup()
@@ -672,7 +672,7 @@ def create_swap_file(self, device, size):
         basedir = os.path.normpath("%s/%s" % (get_target_physical_root(),
                                               device.format.mountpoint))
         while os.path.exists("%s/%s" % (basedir, filename)) or \
-              self.devicetree.get_device_by_name(filename):
+                self.devicetree.get_device_by_name(filename):
             count += 1
             filename = "/SWAP-%d" % count
 
@@ -838,8 +838,8 @@ def fstab(self):
                 options = device.format.options
                 if not mountpoint:
                     log.warning("%s filesystem on %s has no mountpoint",
-                                                            fstype,
-                                                            device.path)
+                                fstype,
+                                device.path)
                     continue
 
             options = options or "defaults"
@@ -1022,7 +1022,7 @@ def parse(self, chroot=""):
 
                 # resolve devspec to a device in the tree
                 device = self.devicetree.resolve_device(devspec,
-                                                       blkid_tab=self.blkid_tab)
+                                                        blkid_tab=self.blkid_tab)
                 if device:
                     self.mappings[name] = {"device": device,
                                            "keyfile": keyfile,
@@ -1045,8 +1045,8 @@ def populate(self):
             options = device.format.options or ""
 
             self.mappings[device.format.map_name] = {"device": device,
-                                                    "keyfile": key_file,
-                                                    "options": options}
+                                                     "keyfile": key_file,
+                                                     "options": options}
 
     def crypttab(self):
         """ Write out /etc/crypttab """
@@ -1128,7 +1128,7 @@ def turn_on_filesystems(storage, mount_only=False, callbacks=None):
 
 def write_escrow_packets(storage):
     escrow_devices = [d for d in storage.devices if d.format.type == 'luks' and
-                     d.format.escrow_cert]
+                      d.format.escrow_cert]
 
     if not escrow_devices:
         return
@@ -1209,8 +1209,8 @@ def mount_existing_system(fsset, root_device, read_only=None):
     else:
         root_device.setup()
         root_device.format.mount(chroot=root_path,
-                                mountpoint="/",
-                                options=read_only)
+                                 mountpoint="/",
+                                 options=read_only)
 
     fsset.parse_fstab()
     fsset.mount_filesystems(root_path=root_path, read_only=read_only, skip_root=True)
diff --git a/blivet/partitioning.py b/blivet/partitioning.py
index f9f5736..1371203 100644
--- a/blivet/partitioning.py
+++ b/blivet/partitioning.py
@@ -172,8 +172,8 @@ def get_next_partition_type(disk, no_primary=None):
 
 
 def get_best_free_space_region(disk, part_type, req_size, start=None,
-                           boot=None, best_free=None, grow=None,
-                           alignment=None):
+                               boot=None, best_free=None, grow=None,
+                               alignment=None):
     """ Return the "best" free region on the specified disk.
 
         For non-boot partitions, we return the largest free region on the
@@ -219,7 +219,7 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
         if start is not None and \
            not alignment.isAligned(free_geom, free_geom.start):
             log.debug("aligning start sector of region %d-%d", free_geom.start,
-                                                               free_geom.end)
+                      free_geom.end)
             try:
                 aligned_start = alignment.alignUp(free_geom, free_geom.start)
             except ArithmeticError:
@@ -238,7 +238,7 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
                                         end=free_geom.end)
 
         log.debug("checking %d-%d (%s)", free_geom.start, free_geom.end,
-                                         Size(free_geom.getLength(unit="B")))
+                  Size(free_geom.getLength(unit="B")))
         if start is not None and not free_geom.containsSector(start):
             log.debug("free region does not contain requested start sector")
             continue
@@ -246,7 +246,7 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
         if extended:
             in_extended = extended.geometry.contains(free_geom)
             if ((in_extended and part_type == parted.PARTITION_NORMAL) or
-                (not in_extended and part_type == parted.PARTITION_LOGICAL)):
+                    (not in_extended and part_type == parted.PARTITION_LOGICAL)):
                 log.debug("free region not suitable for request")
                 continue
 
@@ -260,12 +260,12 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
             req_end = free_start + req_size
             if req_end > max_boot:
                 log.debug("free range position would place boot req above %s",
-                            max_boot)
+                          max_boot)
                 continue
 
         log.debug("current free range is %d-%d (%s)", free_geom.start,
-                                                      free_geom.end,
-                                                      Size(free_geom.getLength(unit="B")))
+                  free_geom.end,
+                  Size(free_geom.getLength(unit="B")))
         free_size = Size(free_geom.getLength(unit="B"))
 
         # For boot partitions, we want the first suitable region we find.
@@ -330,8 +330,8 @@ def remove_new_partitions(disks, remove, all_partitions):
         :rtype: NoneType
     """
     log.debug("removing all non-preexisting partitions %s from disk(s) %s",
-                ["%s(id %d)" % (p.name, p.id) for p in remove],
-                [d.name for d in disks])
+              ["%s(id %d)" % (p.name, p.id) for p in remove],
+              [d.name for d in disks])
     for part in remove:
         if part.parted_partition and part.disk in disks:
             if part.exists:
@@ -351,7 +351,7 @@ def remove_new_partitions(disks, remove, all_partitions):
         extended = disk.format.extended_partition
         if extended and not disk.format.logical_partitions and \
            (flags.installer_mode or
-            extended not in (p.parted_partition for p in all_partitions)):
+                extended not in (p.parted_partition for p in all_partitions)):
             log.debug("removing empty extended partition from %s", disk.name)
             disk.format.parted_disk.removePartition(extended)
 
@@ -443,7 +443,7 @@ def add_partition(disklabel, free, part_type, size, start=None, end=None):
                                  geometry=new_geom)
     constraint = parted.Constraint(exactGeom=new_geom)
     disklabel.parted_disk.addPartition(partition=partition,
-                                      constraint=constraint)
+                                       constraint=constraint)
     return partition
 
 
@@ -609,12 +609,12 @@ def do_partitioning(storage):
             problem = part.check_size()
             if problem < 0:
                 raise PartitioningError(_("partition is too small for %(format)s formatting "
-                                        "(allowable size is %(min_size)s to %(max_size)s)")
+                                          "(allowable size is %(min_size)s to %(max_size)s)")
                                         % {"format": part.format.name, "min_size": part.format.min_size,
                                             "max_size": part.format.max_size})
             elif problem > 0:
                 raise PartitioningError(_("partition is too large for %(format)s formatting "
-                                        "(allowable size is %(min_size)s to %(max_size)s)")
+                                          "(allowable size is %(min_size)s to %(max_size)s)")
                                         % {"format": part.format.name, "min_size": part.format.min_size,
                                             "max_size": part.format.max_size})
 
@@ -651,8 +651,8 @@ def allocate_partitions(storage, disks, partitions, freespace):
         and parents attributes set once they have been allocated.
     """
     log.debug("allocatePartitions: disks=%s ; partitions=%s",
-                [d.name for d in disks],
-                ["%s(id %d)" % (p.name, p.id) for p in partitions])
+              [d.name for d in disks],
+              ["%s(id %d)" % (p.name, p.id) for p in partitions])
 
     new_partitions = [p for p in partitions if not p.exists]
     new_partitions.sort(key=_partition_compare_key)
@@ -693,11 +693,11 @@ def allocate_partitions(storage, disks, partitions, freespace):
         log.debug("allocating partition: %s ; id: %d ; disks: %s ;\n"
                   "boot: %s ; primary: %s ; size: %s ; grow: %s ; "
                   "max_size: %s ; start: %s ; end: %s", _part.name, _part.id,
-                                    [d.name for d in req_disks],
-                                    boot, _part.req_primary,
-                                    _part.req_size, _part.req_grow,
-                                    _part.req_max_size, _part.req_start_sector,
-                                    _part.req_end_sector)
+                  [d.name for d in req_disks],
+                  boot, _part.req_primary,
+                  _part.req_size, _part.req_grow,
+                  _part.req_max_size, _part.req_start_sector,
+                  _part.req_end_sector)
         free = None
         use_disk = None
         part_type = None
@@ -736,7 +736,7 @@ def allocate_partitions(storage, disks, partitions, freespace):
 
             if _part.req_primary and new_part_type != parted.PARTITION_NORMAL:
                 if (disklabel.parted_disk.primaryPartitionCount <
-                    disklabel.parted_disk.maxPrimaryPartitionCount):
+                        disklabel.parted_disk.maxPrimaryPartitionCount):
                     # don't fail to create a primary if there are only three
                     # primary partitions on the disk (#505269)
                     new_part_type = parted.PARTITION_NORMAL
@@ -745,33 +745,33 @@ def allocate_partitions(storage, disks, partitions, freespace):
                     log.debug("no primary slots available on %s", _disk.name)
                     continue
             elif _part.req_part_type is not None and \
-                 new_part_type != _part.req_part_type:
+                    new_part_type != _part.req_part_type:
                 new_part_type = _part.req_part_type
 
             best = get_best_free_space_region(disklabel.parted_disk,
-                                          new_part_type,
-                                          req_size,
-                                          start=_part.req_start_sector,
-                                          best_free=current_free,
-                                          boot=boot,
-                                          grow=_part.req_grow,
-                                          alignment=alignment)
+                                              new_part_type,
+                                              req_size,
+                                              start=_part.req_start_sector,
+                                              best_free=current_free,
+                                              boot=boot,
+                                              grow=_part.req_grow,
+                                              alignment=alignment)
 
             if best == free and not _part.req_primary and \
                new_part_type == parted.PARTITION_NORMAL:
                 # see if we can do better with a logical partition
                 log.debug("not enough free space for primary -- trying logical")
                 new_part_type = get_next_partition_type(disklabel.parted_disk,
-                                                     no_primary=True)
+                                                        no_primary=True)
                 if new_part_type:
                     best = get_best_free_space_region(disklabel.parted_disk,
-                                                  new_part_type,
-                                                  req_size,
-                                                  start=_part.req_start_sector,
-                                                  best_free=current_free,
-                                                  boot=boot,
-                                                  grow=_part.req_grow,
-                                                  alignment=alignment)
+                                                      new_part_type,
+                                                      req_size,
+                                                      start=_part.req_start_sector,
+                                                      best_free=current_free,
+                                                      boot=boot,
+                                                      grow=_part.req_grow,
+                                                      alignment=alignment)
 
             if best and free != best:
                 update = True
@@ -798,17 +798,17 @@ def allocate_partitions(storage, disks, partitions, freespace):
                             if new_part_type == parted.PARTITION_EXTENDED and \
                                new_part_type != _part.req_part_type:
                                 add_partition(disklabel, best, new_part_type,
-                                             None)
+                                              None)
 
                                 _part_type = parted.PARTITION_LOGICAL
 
                                 _free = get_best_free_space_region(disklabel.parted_disk,
-                                                               _part_type,
-                                                               req_size,
-                                                               start=_part.req_start_sector,
-                                                               boot=boot,
-                                                               grow=_part.req_grow,
-                                                               alignment=alignment)
+                                                                   _part_type,
+                                                                   req_size,
+                                                                   start=_part.req_start_sector,
+                                                                   boot=boot,
+                                                                   grow=_part.req_grow,
+                                                                   alignment=alignment)
                                 if not _free:
                                     log.info("not enough space after adding "
                                              "extended partition for growth test")
@@ -821,14 +821,14 @@ def allocate_partitions(storage, disks, partitions, freespace):
                             temp_part = None
                             try:
                                 temp_part = add_partition(disklabel,
-                                                         _free,
-                                                         _part_type,
-                                                         req_size,
-                                                         _part.req_start_sector,
-                                                         _part.req_end_sector)
+                                                          _free,
+                                                          _part_type,
+                                                          req_size,
+                                                          _part.req_start_sector,
+                                                          _part.req_end_sector)
                             except ArithmeticError as e:
                                 log.debug("failed to allocate aligned partition "
-                                         "for growth test")
+                                          "for growth test")
                                 continue
 
                             _part.parted_partition = temp_part
@@ -836,7 +836,7 @@ def allocate_partitions(storage, disks, partitions, freespace):
                             temp_parts.append(_part)
 
                         chunks = get_disk_chunks(all_disks[disk_path],
-                                               temp_parts, freespace)
+                                                 temp_parts, freespace)
 
                         # grow all growable requests
                         disk_growth = 0  # in sectors
@@ -853,13 +853,13 @@ def allocate_partitions(storage, disks, partitions, freespace):
                                           req.device.name,
                                           req.growth,
                                           sectors_to_size(req.growth,
-                                                        disk_sector_size),
+                                                          disk_sector_size),
                                           sectors_to_size(req.growth + req.base,
-                                                        disk_sector_size))
+                                                          disk_sector_size))
                         log.debug("disk %s growth: %d (%s)",
-                                        disk_path, disk_growth,
-                                        sectors_to_size(disk_growth,
-                                                      disk_sector_size))
+                                  disk_path, disk_growth,
+                                  sectors_to_size(disk_growth,
+                                                  disk_sector_size))
 
                     if temp_part:
                         disklabel.parted_disk.removePartition(temp_part)
@@ -876,7 +876,7 @@ def allocate_partitions(storage, disks, partitions, freespace):
                     # choice yielded greater total growth
                     if free is not None and new_growth <= growth:
                         log.debug("keeping old free: %d <= %d", new_growth,
-                                                                growth)
+                                  growth)
                         update = False
                     else:
                         growth = new_growth
@@ -885,12 +885,12 @@ def allocate_partitions(storage, disks, partitions, freespace):
                     # now we know we are choosing a new free space,
                     # so update the disk and part type
                     log.debug("updating use_disk to %s, type: %s",
-                                _disk.name, new_part_type)
+                              _disk.name, new_part_type)
                     part_type = new_part_type
                     use_disk = _disk
                     log.debug("new free: %d-%d / %s", best.start,
-                                                      best.end,
-                                                      Size(best.getLength(unit="B")))
+                              best.end,
+                              Size(best.getLength(unit="B")))
                     log.debug("new free allows for %d sectors of growth", growth)
                     free = best
 
@@ -924,26 +924,26 @@ def allocate_partitions(storage, disks, partitions, freespace):
             # recalculate freespace
             log.debug("recalculating free space")
             free = get_best_free_space_region(disklabel.parted_disk,
-                                          part_type,
-                                          aligned_size,
-                                          start=_part.req_start_sector,
-                                          boot=boot,
-                                          grow=_part.req_grow,
-                                          alignment=disklabel.alignment)
+                                              part_type,
+                                              aligned_size,
+                                              start=_part.req_start_sector,
+                                              boot=boot,
+                                              grow=_part.req_grow,
+                                              alignment=disklabel.alignment)
             if not free:
                 raise PartitioningError(_("not enough free space after "
-                                        "creating extended partition"))
+                                          "creating extended partition"))
 
         try:
             partition = add_partition(disklabel, free, part_type, aligned_size,
-                                _part.req_start_sector, _part.req_end_sector)
+                                      _part.req_start_sector, _part.req_end_sector)
         except ArithmeticError:
             raise PartitioningError(_("failed to allocate aligned partition"))
 
         log.debug("created partition %s of %s and added it to %s",
-                partition.getDeviceNodeName(),
-                Size(partition.getLength(unit="B")),
-                disklabel.device)
+                  partition.getDeviceNodeName(),
+                  Size(partition.getLength(unit="B")),
+                  disklabel.device)
 
         # this one sets the name
         _part.parted_partition = partition
@@ -971,7 +971,7 @@ def __init__(self, device):
         self.growth = 0                     # growth in sectors
         self.max_growth = 0                 # max growth in sectors
         self.done = not getattr(device, "req_grow", True)  # can we grow this
-                                                           # request more?
+        # request more?
         self.base = 0                       # base sectors
 
     @property
@@ -1017,8 +1017,8 @@ def __init__(self, partition):
 
         if partition.req_grow:
             limits = [l for l in [size_to_sectors(partition.req_max_size, sector_size),
-                         size_to_sectors(partition.format.max_size, sector_size),
-                         partition.parted_partition.disk.maxPartitionLength] if l > 0]
+                                  size_to_sectors(partition.format.max_size, sector_size),
+                                  partition.parted_partition.disk.maxPartitionLength] if l > 0]
 
             if limits:
                 max_sectors = min(limits)
@@ -1043,8 +1043,8 @@ def __init__(self, lv):
 
         if lv.req_grow:
             limits = [int(l // lv.vg.pe_size) for l in
-                        (lv.vg.align(lv.req_max_size),
-                         lv.vg.align(lv.format.max_size)) if l > Size(0)]
+                      (lv.vg.align(lv.req_max_size),
+                       lv.vg.align(lv.format.max_size)) if l > Size(0)]
 
             if limits:
                 max_units = min(limits)
@@ -1079,7 +1079,7 @@ def __init__(self, length, requests=None):
         self.length = length
         self.pool = length                  # free unit count
         self.base = 0                       # sum of growable requests' base
-                                            # sizes
+        # sizes
         self.requests = []                  # list of Request instances
         if isinstance(requests, list):
             for req in requests:
@@ -1136,7 +1136,7 @@ def reclaim(self, request, amount):
         log.debug("reclaim: %s %d (%s)", request, amount, self.length_to_size(amount))
         if request.growth < amount:
             log.error("tried to reclaim %d from request with %d of growth",
-                        amount, request.growth)
+                      amount, request.growth)
             raise ValueError(_("cannot reclaim more than request has grown"))
 
         request.growth -= amount
@@ -1195,8 +1195,8 @@ def trim_over_grown_request(self, req, base=None):
                 # we've grown beyond the maximum. put some back.
                 extra = req.growth - max_growth
                 log.debug("taking back %d (%s) from %d (%s)",
-                            extra, self.length_to_size(extra),
-                            req.device.id, req.device.name)
+                          extra, self.length_to_size(extra),
+                          req.device.id, req.device.name)
                 self.pool += extra
                 req.growth = max_growth
 
@@ -1244,7 +1244,7 @@ def grow_requests(self, uniform=False):
                 growth = int(last_pool / self.remaining)
 
             log.debug("%d requests and %s (%s) left in chunk",
-                        self.remaining, self.pool, self.length_to_size(self.pool))
+                      self.remaining, self.pool, self.length_to_size(self.pool))
             for p in self.requests:
                 if p.done or p in self.skip_list:
                     continue
@@ -1259,14 +1259,14 @@ def grow_requests(self, uniform=False):
                 p.growth += growth
                 self.pool -= growth
                 log.debug("adding %s (%s) to %d (%s)",
-                            growth, self.length_to_size(growth),
-                            p.device.id, p.device.name)
+                          growth, self.length_to_size(growth),
+                          p.device.id, p.device.name)
 
                 new_base = self.trim_over_grown_request(p, base=new_base)
                 log.debug("new grow amount for request %d (%s) is %s "
                           "units, or %s",
-                            p.device.id, p.device.name, p.growth,
-                            self.length_to_size(p.growth))
+                          p.device.id, p.device.name, p.growth,
+                          self.length_to_size(p.growth))
 
         if self.pool:
             # allocate any leftovers in pool to the first partition
@@ -1279,14 +1279,14 @@ def grow_requests(self, uniform=False):
                 p.growth += growth
                 self.pool = 0
                 log.debug("adding %s (%s) to %d (%s)",
-                            growth, self.length_to_size(growth),
-                            p.device.id, p.device.name)
+                          growth, self.length_to_size(growth),
+                          p.device.id, p.device.name)
 
                 self.trim_over_grown_request(p)
                 log.debug("new grow amount for request %d (%s) is %s "
                           "units, or %s",
-                            p.device.id, p.device.name, p.growth,
-                            self.length_to_size(p.growth))
+                          p.device.id, p.device.name, p.growth,
+                          self.length_to_size(p.growth))
 
                 if self.pool == 0:
                     break
@@ -1352,7 +1352,7 @@ def add_request(self, req):
         """
         if not isinstance(req, PartitionRequest):
             raise ValueError(_("DiskChunk requests must be of type "
-                             "PartitionRequest"))
+                               "PartitionRequest"))
 
         if not self.requests:
             # when adding the first request to the chunk, adjust the pool
@@ -1365,7 +1365,7 @@ def add_request(self, req):
                 # cannot continue
                 log.error("chunk start sector is beyond disklabel maximum")
                 raise PartitioningError(_("partitions allocated outside "
-                                        "disklabel limits"))
+                                          "disklabel limits"))
 
             new_pool = chunk_end - self.geometry.start + 1
             if new_pool != self.pool:
@@ -1450,7 +1450,7 @@ def add_request(self, req):
         """
         if not isinstance(req, LVRequest):
             raise ValueError(_("VGChunk requests must be of type "
-                             "LVRequest"))
+                               "LVRequest"))
 
         super(VGChunk, self).add_request(req)
 
@@ -1579,7 +1579,7 @@ def __init__(self, devices, size):
 
     def allocate(self, amount):
         log.debug("allocating %d to TotalSizeSet with %d/%d (%d needed)",
-                    amount, self.allocated, self.size, self.needed)
+                  amount, self.allocated, self.size, self.needed)
         self.allocated += amount
 
     @property
@@ -1588,7 +1588,7 @@ def needed(self):
 
     def deallocate(self, amount):
         log.debug("deallocating %d from TotalSizeSet with %d/%d (%d needed)",
-                    amount, self.allocated, self.size, self.needed)
+                  amount, self.allocated, self.size, self.needed)
         self.allocated -= amount
 
 
@@ -1640,7 +1640,7 @@ def manage_size_sets(size_sets, chunks):
                 # TotalSizeSet members are trimmed to achieve the requested
                 # total size
                 log.debug("set: %s %d/%d", [d.name for d in ss.devices],
-                                           ss.allocated, ss.size)
+                          ss.allocated, ss.size)
 
                 for device in ss.devices:
                     request = requests_by_device[device]
@@ -1730,8 +1730,8 @@ def grow_partitions(disks, partitions, free, size_sets=None):
         :returns: :const:`None`
     """
     log.debug("growPartitions: disks=%s, partitions=%s",
-            [d.name for d in disks],
-            ["%s(id %d)" % (p.name, p.id) for p in partitions])
+              [d.name for d in disks],
+              ["%s(id %d)" % (p.name, p.id) for p in partitions])
     all_growable = [p for p in partitions if p.req_grow]
     if not all_growable:
         log.debug("no growable partitions")
@@ -1797,7 +1797,7 @@ def grow_partitions(disks, partitions, free, size_sets=None):
             for p in chunk.requests:
                 ptype = p.device.parted_partition.type
                 log.debug("partition %s (%d): %s", p.device.name,
-                                                   p.device.id, ptype)
+                          p.device.id, ptype)
                 if ptype == parted.PARTITION_EXTENDED:
                     continue
 
@@ -1818,7 +1818,7 @@ def grow_partitions(disks, partitions, free, size_sets=None):
                                                start=start,
                                                end=end)
                 log.debug("new geometry for %s: %s", p.device.name,
-                                                     new_geometry)
+                          new_geometry)
                 start = end + 1
                 new_partition = parted.Partition(disk=disklabel.parted_disk,
                                                  type=ptype,
@@ -1827,7 +1827,7 @@ def grow_partitions(disks, partitions, free, size_sets=None):
 
             # remove all new partitions from this chunk
             remove_new_partitions([disk], [r.device for r in chunk.requests],
-                                partitions)
+                                  partitions)
             log.debug("back from remove_new_partitions")
 
             # adjust the extended partition as needed
@@ -1871,10 +1871,10 @@ def grow_partitions(disks, partitions, free, size_sets=None):
                     name = partition.getDeviceNodeName()
 
                 log.debug("setting %s new geometry: %s", name,
-                                                         partition.geometry)
+                          partition.geometry)
                 constraint = parted.Constraint(exactGeom=partition.geometry)
                 disklabel.parted_disk.addPartition(partition=partition,
-                                                  constraint=constraint)
+                                                   constraint=constraint)
                 path = partition.path
                 if device:
                     # set the device's name
@@ -1966,7 +1966,7 @@ def grow_lvm(storage):
             continue
 
         log.debug("vg %s: %s free ; lvs: %s", vg.name, total_free,
-                                              [l.lvname for l in vg.lvs])
+                  [l.lvname for l in vg.lvs])
 
         # don't include thin lvs in the vg's growth calculation
         fatlvs = [lv for lv in vg.lvs if lv not in vg.thinlvs]
@@ -1985,7 +1985,7 @@ def grow_lvm(storage):
             raise ValueError("sum of percentages within a vg cannot exceed 100")
 
         percent_base = sum(vg.align(lv.req_size, roundup=False) / vg.pe_size
-                            for lv in percentage_based_lvs)
+                           for lv in percentage_based_lvs)
         percentage_basis = vg.free_extents + percent_base
         for lv in percentage_based_lvs:
             new_extents = int(lv.req_percent * Decimal('0.01') * percentage_basis)
diff --git a/blivet/platform.py b/blivet/platform.py
index 6d97138..04716d0 100644
--- a/blivet/platform.py
+++ b/blivet/platform.py
@@ -138,7 +138,7 @@ def best_disklabel_type(self, device):
             # that is large enough to address the whole device
             label_type = self.default_disklabel_type
             log.debug("default disklabel type for %s is %s", device.name,
-                                                             label_type)
+                      label_type)
             for lt in self.disklabel_types:
                 l = parted.freshDisk(device=parted_device, ty=lt)
                 if l.maxPartitionStartSector > parted_device.length:
diff --git a/blivet/populator.py b/blivet/populator.py
index f08cdf6..c8bb764 100644
--- a/blivet/populator.py
+++ b/blivet/populator.py
@@ -170,8 +170,8 @@ def is_ignored(self, info):
             return False
 
         if udev.device_get_md_container(info) and \
-               udev.device_is_md(info) and \
-               udev.device_get_md_name(info):
+                udev.device_is_md(info) and \
+                udev.device_get_md_name(info):
             md_name = udev.device_get_md_name(info)
             # mdadm may have appended _<digit>+ if the current hostname
             # does not match the one in the array metadata
@@ -310,7 +310,7 @@ def add_udev_dm_device(self, info):
         # if this is a luks device whose map name is not what we expect,
         # fix up the map name and see if that sorts us out
         handle_luks = (udev.device_is_dm_luks(info) and
-                        (self._cleanup or not flags.installer_mode))
+                       (self._cleanup or not flags.installer_mode))
         if device is None and handle_luks and slave_devices:
             slave_dev = slave_devices[0]
             slave_dev.format.map_name = name
@@ -528,7 +528,7 @@ def add_udev_disk_device(self, info):
                 container_info = udev.get_device(container_sysfs)
                 if not container_info:
                     log.error("failed to find md container %s at %s",
-                                parent_name, container_sysfs)
+                              parent_name, container_sysfs)
                     return
 
                 self.add_udev_device(container_info)
@@ -567,9 +567,9 @@ def add_udev_disk_device(self, info):
             log.info("%s is a disk", name)
 
         device = disk_type(name,
-                          major=udev.device_get_major(info),
-                          minor=udev.device_get_minor(info),
-                          sysfs_path=sysfs_path, **kwargs)
+                           major=udev.device_get_major(info),
+                           minor=udev.device_get_minor(info),
+                           sysfs_path=sysfs_path, **kwargs)
 
         if disk_type == DASDDevice:
             self.dasd.append(device)
@@ -631,8 +631,8 @@ def add_udev_device(self, info, update_orig_fmt=False):
         # make sure this device was not scheduled for removal and also has not
         # been hidden
         removed = [a.device for a in self.devicetree.actions.find(
-                                                        action_type="destroy",
-                                                        object_type="device")]
+            action_type="destroy",
+            object_type="device")]
         for ignored in removed + self.devicetree._hidden:
             if (sysfs_path and ignored.sysfs_path == sysfs_path) or \
                (uuid and uuid in (ignored.uuid, ignored.format.uuid)):
@@ -706,7 +706,7 @@ def add_udev_device(self, info, update_orig_fmt=False):
             log.info("%s is a loop device", name)
             device = self.add_udev_loop_device(info)
         elif udev.device_is_dm_mpath(info) and \
-             not udev.device_is_dm_partition(info):
+                not udev.device_is_dm_partition(info):
             log.info("%s is a multipath device", name)
             device = self.add_udev_multipath_device(info)
         elif udev.device_is_dm_lvm(info):
@@ -792,9 +792,9 @@ def handle_udev_disk_label_format(self, info, device):
         if not device.partitionable:
             try:
                 fmt = formats.get_format("disklabel",
-                                        device=device.path,
-                                        label_type=disklabel_type,
-                                        exists=True)
+                                         device=device.path,
+                                         label_type=disklabel_type,
+                                         exists=True)
             except InvalidDiskLabelError:
                 log.warning("disklabel detected but not usable on %s",
                             device.name)
@@ -804,8 +804,8 @@ def handle_udev_disk_label_format(self, info, device):
 
         try:
             fmt = formats.get_format("disklabel",
-                                    device=device.path,
-                                    exists=True)
+                                     device=device.path,
+                                     exists=True)
         except InvalidDiskLabelError as e:
             log.info("no usable disklabel on %s", device.name)
             if disklabel_type == "gpt":
@@ -830,7 +830,7 @@ def handle_udev_luks_format(self, info, device):
                 device.format.passphrase = passphrase
             elif device.format.uuid in self.__luks_devs:
                 log.info("skipping previously-skipped luks device %s",
-                            device.name)
+                         device.name)
             elif self._cleanup or flags.testing:
                 # if we're only building the devicetree so that we can
                 # tear down all of the devices we don't need a passphrase
@@ -876,7 +876,7 @@ def handle_vg_lvs(self, vg_device):
         """ Handle setup of the LV's in the vg_device. """
         vg_name = vg_device.name
         lv_info = dict((k, v) for (k, v) in iter(self.devicetree.lv_info.items())
-                                if v.vg_name == vg_name)
+                       if v.vg_name == vg_name)
 
         self.names.extend(n for n in lv_info.keys() if n not in self.names)
 
@@ -939,7 +939,7 @@ def add_lv(lv):
                 origin_name = blockdev.lvm.lvorigin(vg_name, lv_name)
                 if not origin_name:
                     log.error("lvm snapshot '%s-%s' has unknown origin",
-                                vg_name, lv_name)
+                              vg_name, lv_name)
                     return
 
                 if origin_name.endswith("_vorigin]"):
@@ -948,7 +948,7 @@ def add_lv(lv):
                 else:
                     origin_device_name = "%s-%s" % (vg_name, origin_name)
                     add_required_lv(origin_device_name,
-                                  "failed to locate origin lv")
+                                    "failed to locate origin lv")
                     origin = self.get_device_by_name(origin_device_name)
 
                 lv_kwargs["origin"] = origin
@@ -1211,12 +1211,12 @@ def handle_udev_md_member_format(self, info, device):
 
             try:
                 md_array = array_type(
-                   md_name,
-                   level=md_level,
-                   member_devices=md_devices,
-                   uuid=md_uuid,
-                   metadata_version=md_metadata,
-                   exists=True
+                    md_name,
+                    level=md_level,
+                    member_devices=md_devices,
+                    uuid=md_uuid,
+                    metadata_version=md_metadata,
+                    exists=True
                 )
             except (ValueError, DeviceError) as e:
                 log.error("failed to create md array: %s", e)
@@ -1326,11 +1326,11 @@ def handle_btrfs_format(self, info, device):
                     raise DeviceTreeError("could not find parent for subvol")
 
                 fmt = formats.get_format("btrfs",
-                                        device=btrfs_dev.path,
-                                        exists=True,
-                                        vol_uuid=btrfs_dev.format.vol_uuid,
-                                        subvolspec=vol_path,
-                                        mountopts="subvol=%s" % vol_path)
+                                         device=btrfs_dev.path,
+                                         exists=True,
+                                         vol_uuid=btrfs_dev.format.vol_uuid,
+                                         subvolspec=vol_path,
+                                         mountopts="subvol=%s" % vol_path)
                 if vol_id in snapshot_ids:
                     device_class = BTRFSSnapShotDevice
                 else:
@@ -1373,7 +1373,7 @@ def handle_udev_device_format(self, info, device):
             self.handle_udev_disk_label_format(info, device)
             if device.partitioned or self.is_ignored(info) or \
                (not device.partitionable and
-                device.format.type == "disklabel"):
+                    device.format.type == "disklabel"):
                 # If the device has a disklabel, or the user chose not to
                 # create one, we are finished with this device. Otherwise
                 # it must have some non-disklabel formatting, in which case
@@ -1464,7 +1464,7 @@ def handle_udev_device_format(self, info, device):
                 log.info("got format: %s", device.format)
         except FSError:
             log.warning("type '%s' on '%s' invalid, assuming no format",
-                      format_designator, name)
+                        format_designator, name)
             device.format = formats.DeviceFormat()
             return
 
@@ -1635,7 +1635,7 @@ def populate(self, cleanup_only=False):
 
     def _populate(self):
         log.info("DeviceTree.populate: ignored_disks is %s ; exclusive_disks is %s",
-                    self.ignored_disks, self.exclusive_disks)
+                 self.ignored_disks, self.exclusive_disks)
 
         self.devicetree.drop_lvm_cache()
 
diff --git a/blivet/size.py b/blivet/size.py
index b90066a..383b61c 100644
--- a/blivet/size.py
+++ b/blivet/size.py
@@ -196,7 +196,7 @@ def parse_spec(spec):
     # be detected when an exception is raised during conversion of the numeric
     # part to a numeric value.
     spec_re = re.compile(
-       r"""(?P<numeric> # the numeric part consists of three parts, below
+        r"""(?P<numeric> # the numeric part consists of three parts, below
            (-|\+)? # optional sign character
            (?P<base>([0-9\.]+)) # the base
            (?P<exp>(e|E)(-|\+)[0-9]+)?) # optional exponent
diff --git a/blivet/tasks/fsck.py b/blivet/tasks/fsck.py
index f6ff393..a3ed775 100644
--- a/blivet/tasks/fsck.py
+++ b/blivet/tasks/fsck.py
@@ -42,7 +42,7 @@ class FSCK(task.BasicApplication, fstask.FSTask):
     description = "fsck"
 
     options = abc.abstractproperty(
-       doc="Options for invoking the application.")
+        doc="Options for invoking the application.")
 
     # IMPLEMENTATION methods
 
@@ -84,15 +84,15 @@ def do_task(self):
         error_msg = self._error_message(rc)
         if error_msg is not None:
             hdr = "%(type)s filesystem check failure on %(device)s: " % \
-                    {"type": self.fs.type, "device": self.fs.device}
+                {"type": self.fs.type, "device": self.fs.device}
 
             raise FSError(hdr + error_msg)
 
 
 class DosFSCK(FSCK):
     _fsck_errors = {1: "Recoverable errors have been detected or dosfsck has "
-                      "discovered an internal inconsistency.",
-                   2: "Usage error."}
+                    "discovered an internal inconsistency.",
+                    2: "Usage error."}
 
     ext = availability.DOSFSCK_APP
     options = ["-n"]
@@ -108,10 +108,10 @@ def _error_message(self, rc):
 
 class Ext2FSCK(FSCK):
     _fsck_errors = {4: "File system errors left uncorrected.",
-                   8: "Operational error.",
-                   16: "Usage or syntax error.",
-                   32: "e2fsck cancelled by user request.",
-                   128: "Shared library error."}
+                    8: "Operational error.",
+                    16: "Usage or syntax error.",
+                    32: "e2fsck cancelled by user request.",
+                    128: "Shared library error."}
 
     ext = availability.E2FSCK_APP
     options = ["-f", "-p", "-C", "0"]
@@ -123,9 +123,9 @@ def _error_message(self, rc):
 
 class HFSPlusFSCK(FSCK):
     _fsck_errors = {3: "Quick check found a dirty filesystem; no repairs done.",
-                   4: "Root filesystem was dirty. System should be rebooted.",
-                   8: "Corrupt filesystem, repairs did not succeed.",
-                   47: "Major error found; no repairs attempted."}
+                    4: "Root filesystem was dirty. System should be rebooted.",
+                    8: "Corrupt filesystem, repairs did not succeed.",
+                    47: "Major error found; no repairs attempted."}
     ext = availability.FSCK_HFSPLUS_APP
     options = []
 
diff --git a/blivet/tasks/fsinfo.py b/blivet/tasks/fsinfo.py
index 33733dc..af208f5 100644
--- a/blivet/tasks/fsinfo.py
+++ b/blivet/tasks/fsinfo.py
@@ -39,7 +39,7 @@ class FSInfo(task.BasicApplication, fstask.FSTask):
     description = "filesystem info"
 
     options = abc.abstractproperty(
-       doc="Options for invoking the application.")
+        doc="Options for invoking the application.")
 
     @property
     def _info_command(self):
diff --git a/blivet/tasks/fslabeling.py b/blivet/tasks/fslabeling.py
index 7179039..b843af6 100644
--- a/blivet/tasks/fslabeling.py
+++ b/blivet/tasks/fslabeling.py
@@ -31,7 +31,7 @@ class FSLabeling(object):
     """
 
     default_label = abc.abstractproperty(
-       doc="Default label set on this filesystem at creation.")
+        doc="Default label set on this filesystem at creation.")
 
     @abc.abstractmethod
     def label_format_ok(self, label):
diff --git a/blivet/tasks/fsmkfs.py b/blivet/tasks/fsmkfs.py
index 078c226..d0da5b2 100644
--- a/blivet/tasks/fsmkfs.py
+++ b/blivet/tasks/fsmkfs.py
@@ -45,7 +45,7 @@ class FSMkfs(task.BasicApplication, FSMkfsTask):
     description = "mkfs"
 
     label_option = abc.abstractproperty(
-       doc="Option for setting a filesystem label.")
+        doc="Option for setting a filesystem label.")
 
     args = abc.abstractproperty(doc="options for creating filesystem")
 
diff --git a/blivet/tasks/fsmount.py b/blivet/tasks/fsmount.py
index aa175f3..b3ebd6c 100644
--- a/blivet/tasks/fsmount.py
+++ b/blivet/tasks/fsmount.py
@@ -58,8 +58,8 @@ def _has_driver(self):
     @property
     def _can_mount(self):
         return (self.mount_type in fslib.kernel_filesystems) or \
-           (os.access("/sbin/mount.%s" % (self.mount_type,), os.X_OK)) or \
-           self._has_driver
+            (os.access("/sbin/mount.%s" % (self.mount_type,), os.X_OK)) or \
+            self._has_driver
 
     @property
     def _availability_errors(self):
diff --git a/blivet/tasks/fsresize.py b/blivet/tasks/fsresize.py
index a56cf26..343acaf 100644
--- a/blivet/tasks/fsresize.py
+++ b/blivet/tasks/fsresize.py
@@ -110,9 +110,9 @@ def size_spec(self):
     @property
     def args(self):
         return [
-           "-ff",  # need at least two 'f's to fully suppress interaction
-           "-s", self.size_spec(),
-           self.fs.device
+            "-ff",  # need at least two 'f's to fully suppress interaction
+            "-s", self.size_spec(),
+            self.fs.device
         ]
 
 
diff --git a/blivet/tasks/task.py b/blivet/tasks/task.py
index d5a4192..9ac4301 100644
--- a/blivet/tasks/task.py
+++ b/blivet/tasks/task.py
@@ -40,7 +40,7 @@ class Task(object):
     def availability_errors(self):
         """ Reasons if this task or the tasks it depends on are unavailable. """
         return self._availability_errors + \
-           [e for t in self.depends_on for e in t.availability_errors]
+            [e for t in self.depends_on for e in t.availability_errors]
 
     @property
     def available(self):
@@ -52,7 +52,7 @@ def available(self):
         return self.availability_errors == []
 
     _availability_errors = abc.abstractproperty(
-       doc="Reasons if the necessary external tools are unavailable.")
+        doc="Reasons if the necessary external tools are unavailable.")
 
     depends_on = abc.abstractproperty(doc="tasks that this task depends on")
 
diff --git a/blivet/udev.py b/blivet/udev.py
index c6854ec..7fc6189 100644
--- a/blivet/udev.py
+++ b/blivet/udev.py
@@ -53,7 +53,7 @@ def get_device(sysfs_path):
 def get_devices(subsystem="block"):
     settle()
     return [d for d in global_udev.list_devices(subsystem=subsystem)
-                        if not __is_blacklisted_blockdev(d.sys_name)]
+            if not __is_blacklisted_blockdev(d.sys_name)]
 
 
 def settle(quiet=False):
diff --git a/blivet/util.py b/blivet/util.py
index 86e6601..9d1aa20 100644
--- a/blivet/util.py
+++ b/blivet/util.py
@@ -165,7 +165,7 @@ def get_mount_device(mountpoint):
         loop_name = os.path.basename(mount_device)
         mount_device = blockdev.loop.get_backing_file(loop_name)
         log.debug("found backing file %s for loop device %s", mount_device,
-                                                              loop_name)
+                  loop_name)
 
     if mount_device:
         log.debug("%s is mounted on %s", mount_device, mountpoint)
@@ -254,7 +254,7 @@ def get_cow_sysfs_path(dev_path, dev_sysfsPath):
     cow_path = dev_path + "-cow"
     if not os.path.islink(cow_path):
         raise RuntimeError("get_cow_sysfs_path: Could not find cow device for" %
-                            (dev_path))
+                           (dev_path))
 
     # dev path for cow devices is actually a link to a dm device (e.g. /dev/dm-X)
     # we need the 'dm-X' name for sysfs_path (e.g. /sys/devices/virtual/block/dm-X)
diff --git a/blivet/zfcp.py b/blivet/zfcp.py
index d43cc65..329cfde 100644
--- a/blivet/zfcp.py
+++ b/blivet/zfcp.py
@@ -84,7 +84,7 @@ def online_device(self):
 
         if not os.path.exists(online):
             raise ValueError(_("zFCP device %s not found, not even in device ignore list.") %
-                    (self.devnum,))
+                             (self.devnum,))
 
         try:
             f = open(online, "r")
@@ -94,8 +94,8 @@ def online_device(self):
                 logged_write_line_to_file(online, "1")
         except IOError as e:
             raise ValueError(_("Could not set zFCP device %(devnum)s "
-                                "online (%(e)s).")
-                              % {'devnum': self.devnum, 'e': e})
+                               "online (%(e)s).")
+                             % {'devnum': self.devnum, 'e': e})
 
         if not os.path.exists(portdir):
             if os.path.exists(portadd):
@@ -105,15 +105,15 @@ def online_device(self):
                     udev.settle()
                 except IOError as e:
                     raise ValueError(_("Could not add WWPN %(wwpn)s to zFCP "
-                                        "device %(devnum)s (%(e)s).")
-                                      % {'wwpn': self.wwpn,
+                                       "device %(devnum)s (%(e)s).")
+                                     % {'wwpn': self.wwpn,
                                          'devnum': self.devnum,
                                          'e': e})
             else:
                 # newer zfcp sysfs interface with auto port scan
                 raise ValueError(_("WWPN %(wwpn)s not found at zFCP device "
-                                    "%(devnum)s.") % {'wwpn': self.wwpn,
-                                                      'devnum': self.devnum})
+                                   "%(devnum)s.") % {'wwpn': self.wwpn,
+                                                     'devnum': self.devnum})
         else:
             if os.path.exists(portadd):
                 # older zfcp sysfs interface
@@ -127,14 +127,14 @@ def online_device(self):
                 udev.settle()
             except IOError as e:
                 raise ValueError(_("Could not add LUN %(fcplun)s to WWPN "
-                                    "%(wwpn)s on zFCP device %(devnum)s "
-                                    "(%(e)s).")
-                                  % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
+                                   "%(wwpn)s on zFCP device %(devnum)s "
+                                   "(%(e)s).")
+                                 % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
                                      'devnum': self.devnum, 'e': e})
         else:
             raise ValueError(_("LUN %(fcplun)s at WWPN %(wwpn)s on zFCP "
-                                "device %(devnum)s already configured.")
-                              % {'fcplun': self.fcplun,
+                               "device %(devnum)s already configured.")
+                             % {'fcplun': self.fcplun,
                                  'wwpn': self.wwpn,
                                  'devnum': self.devnum})
 
@@ -145,17 +145,17 @@ def online_device(self):
             f.close()
         except IOError as e:
             raise ValueError(_("Could not read failed attribute of LUN "
-                                "%(fcplun)s at WWPN %(wwpn)s on zFCP device "
-                                "%(devnum)s (%(e)s).")
-                              % {'fcplun': self.fcplun,
+                               "%(fcplun)s at WWPN %(wwpn)s on zFCP device "
+                               "%(devnum)s (%(e)s).")
+                             % {'fcplun': self.fcplun,
                                  'wwpn': self.wwpn,
                                  'devnum': self.devnum,
                                  'e': e})
         if fail != "0":
             self.offline_device()
             raise ValueError(_("Failed LUN %(fcplun)s at WWPN %(wwpn)s on "
-                                "zFCP device %(devnum)s removed again.")
-                              % {'fcplun': self.fcplun,
+                               "zFCP device %(devnum)s removed again.")
+                             % {'fcplun': self.fcplun,
                                  'wwpn': self.wwpn,
                                  'devnum': self.devnum})
 
@@ -211,18 +211,18 @@ def offline_device(self):
             self.offline_scsi_device()
         except IOError as e:
             raise ValueError(_("Could not correctly delete SCSI device of "
-                                "zFCP %(devnum)s %(wwpn)s %(fcplun)s "
-                                "(%(e)s).")
-                              % {'devnum': self.devnum, 'wwpn': self.wwpn,
+                               "zFCP %(devnum)s %(wwpn)s %(fcplun)s "
+                               "(%(e)s).")
+                             % {'devnum': self.devnum, 'wwpn': self.wwpn,
                                  'fcplun': self.fcplun, 'e': e})
 
         try:
             logged_write_line_to_file(unitremove, self.fcplun)
         except IOError as e:
             raise ValueError(_("Could not remove LUN %(fcplun)s at WWPN "
-                                "%(wwpn)s on zFCP device %(devnum)s "
-                                "(%(e)s).")
-                              % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
+                               "%(wwpn)s on zFCP device %(devnum)s "
+                               "(%(e)s).")
+                             % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
                                  'devnum': self.devnum, 'e': e})
 
         if os.path.exists(portadd):
@@ -238,8 +238,8 @@ def offline_device(self):
                 logged_write_line_to_file(portremove, self.wwpn)
             except IOError as e:
                 raise ValueError(_("Could not remove WWPN %(wwpn)s on zFCP "
-                                    "device %(devnum)s (%(e)s).")
-                                  % {'wwpn': self.wwpn,
+                                   "device %(devnum)s (%(e)s).")
+                                 % {'wwpn': self.wwpn,
                                      'devnum': self.devnum, 'e': e})
 
         if os.path.exists(portadd):
@@ -254,7 +254,7 @@ def offline_device(self):
             # newer zfcp sysfs interface with auto port scan
             import glob
             luns = glob.glob("%s/0x????????????????/0x????????????????"
-                          % (devdir,))
+                             % (devdir,))
             if len(luns) != 0:
                 log.info("Not setting zFCP device %s offline since it still has other LUNs, e.g. %s.",
                          self.devnum, luns[0])
@@ -264,8 +264,8 @@ def offline_device(self):
             logged_write_line_to_file(offline, "0")
         except IOError as e:
             raise ValueError(_("Could not set zFCP device %(devnum)s "
-                                "offline (%(e)s).")
-                              % {'devnum': self.devnum, 'e': e})
+                               "offline (%(e)s).")
+                             % {'devnum': self.devnum, 'e': e})
 
         return True
 
diff --git a/doc/conf.py b/doc/conf.py
index e452490..2b62ffb 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -173,21 +173,21 @@
 # -- Options for LaTeX output --------------------------------------------------
 
 latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
 
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
 
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'Blivet.tex', u'Blivet Documentation',
-   u'David Lehman', 'manual'),
+    ('index', 'Blivet.tex', u'Blivet Documentation',
+     u'David Lehman', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -230,9 +230,9 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'Blivet', u'Blivet Documentation',
-   u'David Lehman', 'Blivet', 'One line description of project.',
-   'Miscellaneous'),
+    ('index', 'Blivet', u'Blivet Documentation',
+     u'David Lehman', 'Blivet', 'One line description of project.',
+     'Miscellaneous'),
 ]
 
 # Documents to append as an appendix to all manuals.
diff --git a/examples/factory.py b/examples/factory.py
index 1f92fba..a2f1649 100644
--- a/examples/factory.py
+++ b/examples/factory.py
@@ -25,16 +25,16 @@
 
     # create an lv named data in a vg named testvg
     device = b.factory_device(blivet.devicefactory.DEVICE_TYPE_LVM,
-                             Size("50GiB"), disks=[disk1, disk2],
-                             fstype="xfs", mountpoint="/data")
+                              Size("50GiB"), disks=[disk1, disk2],
+                              fstype="xfs", mountpoint="/data")
     print_devices(b)
 
     # change testvg to have an md RAID1 pv instead of partition pvs
     device = b.factory_device(blivet.devicefactory.DEVICE_TYPE_LVM,
-                             Size("50GiB"), disks=[disk1, disk2],
-                             fstype="xfs", mountpoint="/data",
-                             container_raid_level="raid1",
-                             device=device)
+                              Size("50GiB"), disks=[disk1, disk2],
+                              fstype="xfs", mountpoint="/data",
+                              container_raid_level="raid1",
+                              device=device)
     print_devices(b)
 
     b.devicetree.process_actions()
diff --git a/examples/lvm.py b/examples/lvm.py
index 7621925..564cf00 100644
--- a/examples/lvm.py
+++ b/examples/lvm.py
@@ -31,12 +31,12 @@
 
     # new lv with base size 5GiB and unbounded growth and an ext4 filesystem
     dev = b.new_lv(fmt_type="ext4", size=Size("5GiB"), grow=True,
-                  parents=[vg], name="unbounded")
+                   parents=[vg], name="unbounded")
     b.create_device(dev)
 
     # new lv with base size 5GiB and growth up to 15GiB and an ext4 filesystem
     dev = b.new_lv(fmt_type="ext4", size=Size("5GiB"), grow=True,
-                  maxsize=Size("15GiB"), parents=[vg], name="bounded")
+                   maxsize=Size("15GiB"), parents=[vg], name="bounded")
     b.create_device(dev)
 
     # new lv with a fixed size of 2GiB formatted as swap space
diff --git a/examples/partitioning.py b/examples/partitioning.py
index 7c362f1..875f207 100644
--- a/examples/partitioning.py
+++ b/examples/partitioning.py
@@ -27,13 +27,13 @@
     # new partition on either disk1 or disk2 with base size 10GiB and growth
     # up to a maximum size of 50GiB
     dev = b.new_partition(size=Size("10MiB"), maxsize=Size("50GiB"),
-                         grow=True, parents=[disk1, disk2])
+                          grow=True, parents=[disk1, disk2])
     b.create_device(dev)
 
     # new partition on disk1 with base size 5GiB and unbounded growth and an
     # ext4 filesystem
     dev = b.new_partition(fmt_type="ext4", size=Size("5GiB"), grow=True,
-                         parents=[disk1])
+                          parents=[disk1])
     b.create_device(dev)
 
     # new partition on any suitable disk with a fixed size of 2GiB formatted
diff --git a/tests/__init__.py b/tests/__init__.py
index 6f41f47..47c7c52 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -5,4 +5,3 @@
 if six.PY2:
     TestCase.assertRaisesRegex = TestCase.assertRaisesRegexp
     TestCase.assertRegex = TestCase.assertRegexpMatches
-
diff --git a/tests/action_test.py b/tests/action_test.py
index fbab7d3..fe3c759 100644
--- a/tests/action_test.py
+++ b/tests/action_test.py
@@ -24,11 +24,11 @@
 from blivet.deviceaction import ActionRemoveMember
 
 DEVICE_CLASSES = [
-   DiskDevice,
-   PartitionDevice,
-   MDRaidArrayDevice,
-   LVMVolumeGroupDevice,
-   LVMLogicalVolumeDevice
+    DiskDevice,
+    PartitionDevice,
+    MDRaidArrayDevice,
+    LVMVolumeGroupDevice,
+    LVMLogicalVolumeDevice
 ]
 
 
@@ -46,9 +46,9 @@ def setUp(self):
 
         for name in ["sda", "sdb", "sdc", "sdd"]:
             disk = self.new_device(device_class=DiskDevice,
-                                  name=name, size=Size("100 GiB"))
+                                   name=name, size=Size("100 GiB"))
             disk.format = self.new_format("disklabel", path=disk.path,
-                                         exists=True)
+                                          exists=True)
             self.storage.devicetree._add_device(disk)
 
         # create a layout similar to autopart as a starting point
@@ -56,44 +56,44 @@ def setUp(self):
         sdb = self.storage.devicetree.get_device_by_name("sdb")
 
         sda1 = self.new_device(device_class=PartitionDevice,
-                              exists=True, name="sda1", parents=[sda],
-                              size=Size("500 MiB"))
+                               exists=True, name="sda1", parents=[sda],
+                               size=Size("500 MiB"))
         sda1.format = self.new_format("ext4", mountpoint="/boot",
-                                     device_instance=sda1,
-                                     device=sda1.path, exists=True)
+                                      device_instance=sda1,
+                                      device=sda1.path, exists=True)
         self.storage.devicetree._add_device(sda1)
 
         sda2 = self.new_device(device_class=PartitionDevice,
-                              size=Size("99.5 GiB"), name="sda2",
-                              parents=[sda], exists=True)
+                               size=Size("99.5 GiB"), name="sda2",
+                               parents=[sda], exists=True)
         sda2.format = self.new_format("lvmpv", device=sda2.path, exists=True)
         self.storage.devicetree._add_device(sda2)
 
         sdb1 = self.new_device(device_class=PartitionDevice,
-                              size=Size("99.999 GiB"), name="sdb1",
-                              parents=[sdb], exists=True)
+                               size=Size("99.999 GiB"), name="sdb1",
+                               parents=[sdb], exists=True)
         sdb1.format = self.new_format("lvmpv", device=sdb1.path, exists=True)
         self.storage.devicetree._add_device(sdb1)
 
         vg = self.new_device(device_class=LVMVolumeGroupDevice,
-                            name="VolGroup", parents=[sda2, sdb1],
-                            exists=True)
+                             name="VolGroup", parents=[sda2, sdb1],
+                             exists=True)
         self.storage.devicetree._add_device(vg)
 
         lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_root", parents=[vg],
-                                 size=Size("160 GiB"), exists=True)
+                                  name="lv_root", parents=[vg],
+                                  size=Size("160 GiB"), exists=True)
         lv_root.format = self.new_format("ext4", mountpoint="/",
-                                        device_instance=lv_root,
-                                        device=lv_root.path, exists=True)
+                                         device_instance=lv_root,
+                                         device=lv_root.path, exists=True)
         self.storage.devicetree._add_device(lv_root)
 
         lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_swap", parents=[vg],
-                                 size=Size("4000 MiB"), exists=True)
+                                  name="lv_swap", parents=[vg],
+                                  size=Size("4000 MiB"), exists=True)
         lv_swap.format = self.new_format("swap", device=lv_swap.path,
-                                        device_instance=lv_swap,
-                                        exists=True)
+                                         device_instance=lv_swap,
+                                         exists=True)
         self.storage.devicetree._add_device(lv_swap)
 
     def test_actions(self):
@@ -136,38 +136,38 @@ def test_actions(self):
         self.assertNotEqual(sda, None, "failed to find disk 'sda'")
 
         sda1 = self.new_device(device_class=PartitionDevice,
-                              name="sda1", size=Size("500 MiB"),
-                              parents=[sda])
+                               name="sda1", size=Size("500 MiB"),
+                               parents=[sda])
         self.schedule_create_device(sda1)
 
         sda2 = self.new_device(device_class=PartitionDevice,
-                              name="sda2", size=Size("100 GiB"),
-                              parents=[sda])
+                               name="sda2", size=Size("100 GiB"),
+                               parents=[sda])
         self.schedule_create_device(sda2)
         fmt = self.new_format("lvmpv", device=sda2.path)
         self.schedule_create_format(device=sda2, fmt=fmt)
 
         vg = self.new_device(device_class=LVMVolumeGroupDevice,
-                            name="vg", parents=[sda2])
+                             name="vg", parents=[sda2])
         self.schedule_create_device(vg)
 
         lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_root", parents=[vg],
-                                 size=Size("60 GiB"))
+                                  name="lv_root", parents=[vg],
+                                  size=Size("60 GiB"))
         self.schedule_create_device(lv_root)
         fmt = self.new_format("ext4", device=lv_root.path, mountpoint="/")
         self.schedule_create_format(device=lv_root, fmt=fmt)
 
         lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_swap", parents=[vg],
-                                 size=Size("4000 MiB"))
+                                  name="lv_swap", parents=[vg],
+                                  size=Size("4000 MiB"))
         self.schedule_create_device(lv_swap)
         fmt = self.new_format("swap", device=lv_swap.path)
         self.schedule_create_format(device=lv_swap, fmt=fmt)
 
         sda3 = self.new_device(device_class=PartitionDevice,
-                              name="sda3", parents=[sda],
-                              size=Size("40 GiB"))
+                               name="sda3", parents=[sda],
+                               size=Size("40 GiB"))
         self.schedule_create_device(sda3)
         fmt = self.new_format("mdmember", device=sda3.path)
         self.schedule_create_format(device=sda3, fmt=fmt)
@@ -176,16 +176,16 @@ def test_actions(self):
         self.assertNotEqual(sdb, None, "failed to find disk 'sdb'")
 
         sdb1 = self.new_device(device_class=PartitionDevice,
-                              name="sdb1", parents=[sdb],
-                              size=Size("40 GiB"))
+                               name="sdb1", parents=[sdb],
+                               size=Size("40 GiB"))
         self.schedule_create_device(sdb1)
         fmt = self.new_format("mdmember", device=sdb1.path,)
         self.schedule_create_format(device=sdb1, fmt=fmt)
 
         md0 = self.new_device(device_class=MDRaidArrayDevice,
-                             name="md0", level="raid0", minor=0,
-                             member_devices=2, total_devices=2,
-                             parents=[sdb1, sda3])
+                              name="md0", level="raid0", minor=0,
+                              member_devices=2, total_devices=2,
+                              parents=[sdb1, sda3])
         self.schedule_create_device(md0)
 
         fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
@@ -201,7 +201,7 @@ def test_action_creation(self):
         # XXX resizable depends on existence, so this is covered implicitly
         sdd = self.storage.devicetree.get_device_by_name("sdd")
         p = self.new_device(device_class=PartitionDevice,
-                           name="sdd1", size=Size("32 GiB"), parents=[sdd])
+                            name="sdd1", size=Size("32 GiB"), parents=[sdd])
         with self.assertRaises(ValueError):
             ActionResizeDevice(p, p.size + Size("7232 MiB"))
 
@@ -274,8 +274,8 @@ def test_action_registration(self):
         sdc = self.storage.devicetree.get_device_by_name("sdc")
         self.assertNotEqual(sdc, None)
         sdc1 = self.new_device(device_class=PartitionDevice,
-                              name="sdc1", size=Size("100 GiB"),
-                              parents=[sdc], exists=True)
+                               name="sdc1", size=Size("100 GiB"),
+                               parents=[sdc], exists=True)
 
         sdc1_format = self.new_format("ext2", device=sdc1.path, mountpoint="/")
         create_sdc1_format = ActionCreateFormat(sdc1, sdc1_format)
@@ -324,8 +324,8 @@ def test_action_registration(self):
         sdd1 = self.storage.devicetree.get_device_by_name("sdd1")
         self.assertEqual(sdd1, None)
         sdd1 = self.new_device(device_class=PartitionDevice,
-                              name="sdd1", size=Size("100 GiB"),
-                              parents=[sdd])
+                               name="sdd1", size=Size("100 GiB"),
+                               parents=[sdd])
         a = ActionCreateDevice(sdd1)
         self.storage.devicetree.register_action(a)
         sdd1 = self.storage.devicetree.get_device_by_name("sdd1")
@@ -338,7 +338,7 @@ def test_action_obsoletes(self):
         self.assertNotEqual(sdc, None)
 
         sdc1 = self.new_device(device_class=PartitionDevice,
-                              name="sdc1", parents=[sdc], size=Size("40 GiB"))
+                               name="sdc1", parents=[sdc], size=Size("40 GiB"))
 
         # ActionCreateDevice
         #
@@ -464,31 +464,31 @@ def test_action_pruning(self):
         self.assertNotEqual(sda, None, "failed to find disk 'sda'")
 
         sda1 = self.new_device(device_class=PartitionDevice,
-                              name="sda1", size=Size("500 MiB"),
-                              parents=[sda])
+                               name="sda1", size=Size("500 MiB"),
+                               parents=[sda])
         self.schedule_create_device(sda1)
 
         sda2 = self.new_device(device_class=PartitionDevice,
-                              name="sda2", size=Size("100 GiB"),
-                              parents=[sda])
+                               name="sda2", size=Size("100 GiB"),
+                               parents=[sda])
         self.schedule_create_device(sda2)
         fmt = self.new_format("lvmpv", device=sda2.path)
         self.schedule_create_format(device=sda2, fmt=fmt)
 
         vg = self.new_device(device_class=LVMVolumeGroupDevice,
-                            name="vg", parents=[sda2])
+                             name="vg", parents=[sda2])
         self.schedule_create_device(vg)
 
         lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_root", parents=[vg],
-                                 size=Size("60 GiB"))
+                                  name="lv_root", parents=[vg],
+                                  size=Size("60 GiB"))
         self.schedule_create_device(lv_root)
         fmt = self.new_format("ext4", device=lv_root.path, mountpoint="/")
         self.schedule_create_format(device=lv_root, fmt=fmt)
 
         lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_swap", parents=[vg],
-                                 size=Size("4 GiB"))
+                                  name="lv_swap", parents=[vg],
+                                  size=Size("4 GiB"))
         self.schedule_create_device(lv_swap)
         fmt = self.new_format("swap", device=lv_swap.path)
         self.schedule_create_format(device=lv_swap, fmt=fmt)
@@ -496,8 +496,8 @@ def test_action_pruning(self):
         # we'll soon schedule destroy actions for these members and the array,
         # which will test pruning. the whole mess should reduce to nothing
         sda3 = self.new_device(device_class=PartitionDevice,
-                              name="sda3", parents=[sda],
-                              size=Size("40 GiB"))
+                               name="sda3", parents=[sda],
+                               size=Size("40 GiB"))
         self.schedule_create_device(sda3)
         fmt = self.new_format("mdmember", device=sda3.path)
         self.schedule_create_format(device=sda3, fmt=fmt)
@@ -506,16 +506,16 @@ def test_action_pruning(self):
         self.assertNotEqual(sdb, None, "failed to find disk 'sdb'")
 
         sdb1 = self.new_device(device_class=PartitionDevice,
-                              name="sdb1", parents=[sdb],
-                              size=Size("40 GiB"))
+                               name="sdb1", parents=[sdb],
+                               size=Size("40 GiB"))
         self.schedule_create_device(sdb1)
         fmt = self.new_format("mdmember", device=sdb1.path,)
         self.schedule_create_format(device=sdb1, fmt=fmt)
 
         md0 = self.new_device(device_class=MDRaidArrayDevice,
-                             name="md0", level="raid0", minor=0,
-                             member_devices=2, total_devices=2,
-                             parents=[sdb1, sda3])
+                              name="md0", level="raid0", minor=0,
+                              member_devices=2, total_devices=2,
+                              parents=[sdb1, sda3])
         self.schedule_create_device(md0)
 
         fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
@@ -591,38 +591,38 @@ def test_action_dependencies(self):
         sda = self.storage.devicetree.get_device_by_name("sda")
         sdb = self.storage.devicetree.get_device_by_name("sdb")
         sda1 = self.new_device(device_class=PartitionDevice, name="sda1",
-                              size=Size("500 MiB"), parents=[sda])
+                               size=Size("500 MiB"), parents=[sda])
         sda1_format = self.new_format("ext4", mountpoint="/boot",
-                                     device=sda1.path)
+                                      device=sda1.path)
         self.schedule_create_device(sda1)
         self.schedule_create_format(device=sda1, fmt=sda1_format)
 
         sda2 = self.new_device(device_class=PartitionDevice, name="sda2",
-                              size=Size("99.5 GiB"), parents=[sda])
+                               size=Size("99.5 GiB"), parents=[sda])
         sda2_format = self.new_format("lvmpv", device=sda2.path)
         self.schedule_create_device(sda2)
         self.schedule_create_format(device=sda2, fmt=sda2_format)
 
         sdb1 = self.new_device(device_class=PartitionDevice, name="sdb1",
-                              size=Size("100 GiB"), parents=[sdb])
+                               size=Size("100 GiB"), parents=[sdb])
         sdb1_format = self.new_format("lvmpv", device=sdb1.path)
         self.schedule_create_device(sdb1)
         self.schedule_create_format(device=sdb1, fmt=sdb1_format)
 
         vg = self.new_device(device_class=LVMVolumeGroupDevice,
-                            name="VolGroup", parents=[sda2, sdb1])
+                             name="VolGroup", parents=[sda2, sdb1])
         self.schedule_create_device(vg)
 
         lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_root", parents=[vg],
-                                 size=Size("160 GiB"))
+                                  name="lv_root", parents=[vg],
+                                  size=Size("160 GiB"))
         self.schedule_create_device(lv_root)
         fmt = self.new_format("ext4", device=lv_root.path, mountpoint="/")
         self.schedule_create_format(device=lv_root, fmt=fmt)
 
         lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_swap", parents=[vg],
-                                 size=Size("4 GiB"))
+                                  name="lv_swap", parents=[vg],
+                                  size=Size("4 GiB"))
         self.schedule_create_device(lv_swap)
         fmt = self.new_format("swap", device=lv_swap.path)
         self.schedule_create_format(device=lv_swap, fmt=fmt)
@@ -633,8 +633,8 @@ def test_action_dependencies(self):
         lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
         self.assertNotEqual(lv_root, None)
         actions = self.storage.devicetree.actions.find(action_type="create",
-                                                      object_type="device",
-                                                      device=lv_root)
+                                                       object_type="device",
+                                                       device=lv_root)
         self.assertEqual(len(actions), 1,
                          "wrong number of device create actions for lv_root: "
                          "%d" % len(actions))
@@ -644,8 +644,8 @@ def test_action_dependencies(self):
         self.assertNotEqual(vgs, [])
         vg = vgs[0]
         actions = self.storage.devicetree.actions.find(action_type="create",
-                                                      object_type="device",
-                                                      device=vg)
+                                                       object_type="device",
+                                                       device=vg)
         self.assertEqual(len(actions), 1,
                          "wrong number of device create actions for VolGroup")
         create_vg_action = actions[0]
@@ -658,7 +658,7 @@ def test_action_dependencies(self):
         for pv in pvs:
             # include device and format create actions for each pv
             actions = self.storage.devicetree.actions.find(action_type="create",
-                                                          device=pv)
+                                                           device=pv)
             self.assertEqual(len(actions), 2,
                              "wrong number of device create actions for "
                              "pv %s" % pv.name)
@@ -677,12 +677,12 @@ def test_action_dependencies(self):
         self.assertNotEqual(sdc, None)
 
         sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
-                              parents=[sdc], size=Size("50 GiB"))
+                               parents=[sdc], size=Size("50 GiB"))
         create_sdc1 = self.schedule_create_device(sdc1)
         self.assertEqual(isinstance(create_sdc1, ActionCreateDevice), True)
 
         sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
-                              parents=[sdc], size=Size("50 GiB"))
+                               parents=[sdc], size=Size("50 GiB"))
         create_sdc2 = self.schedule_create_device(sdc2)
         self.assertEqual(isinstance(create_sdc2, ActionCreateDevice), True)
 
@@ -695,8 +695,8 @@ def test_action_dependencies(self):
         sda1 = self.storage.devicetree.get_device_by_name("sda1")
         self.assertNotEqual(sda1, None)
         actions = self.storage.devicetree.actions.find(action_type="create",
-                                                      object_type="device",
-                                                      device=sda1)
+                                                       object_type="device",
+                                                       device=sda1)
         self.assertEqual(len(actions), 1,
                          "wrong number of create actions found for sda1")
         create_sda1 = actions[0]
@@ -714,21 +714,21 @@ def test_action_dependencies(self):
         self.assertNotEqual(sdd, None)
 
         sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
-                              parents=[sdc], size=Size("40 GiB"))
+                               parents=[sdc], size=Size("40 GiB"))
         self.schedule_create_device(sdc1)
         fmt = self.new_format("mdmember", device=sdc1.path)
         self.schedule_create_format(device=sdc1, fmt=fmt)
 
         sdd1 = self.new_device(device_class=PartitionDevice, name="sdd1",
-                              parents=[sdd], size=Size("40 GiB"))
+                               parents=[sdd], size=Size("40 GiB"))
         self.schedule_create_device(sdd1)
         fmt = self.new_format("mdmember", device=sdd1.path,)
         self.schedule_create_format(device=sdd1, fmt=fmt)
 
         md0 = self.new_device(device_class=MDRaidArrayDevice,
-                             name="md0", level="raid0", minor=0,
-                             member_devices=2, total_devices=2,
-                             parents=[sdc1, sdd1])
+                              name="md0", level="raid0", minor=0,
+                              member_devices=2, total_devices=2,
+                              parents=[sdc1, sdd1])
         self.schedule_create_device(md0)
         fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
         self.schedule_create_format(device=md0, fmt=fmt)
@@ -751,11 +751,11 @@ def test_action_dependencies(self):
         # numbered partition, eg: destroy sda2 before destroying sda1
         self.destroy_all_devices(disks=["sdc", "sdd"])
         sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
-                              parents=[sdc], size=Size("50 GiB"))
+                               parents=[sdc], size=Size("50 GiB"))
         self.schedule_create_device(sdc1)
 
         sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
-                              parents=[sdc], size=Size("40 GiB"))
+                               parents=[sdc], size=Size("40 GiB"))
         self.schedule_create_device(sdc2)
 
         destroy_sdc1 = self.schedule_destroy_device(sdc1)
@@ -770,17 +770,17 @@ def test_action_dependencies(self):
         self.assertNotEqual(sdd, None)
 
         sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
-                              parents=[sdc], size=Size("50 GiB"))
+                               parents=[sdc], size=Size("50 GiB"))
         create_pv = self.schedule_create_device(sdc1)
         fmt = self.new_format("lvmpv", device=sdc1.path)
         create_pv_format = self.schedule_create_format(device=sdc1, fmt=fmt)
 
         testvg = self.new_device(device_class=LVMVolumeGroupDevice,
-                                name="testvg", parents=[sdc1])
+                                 name="testvg", parents=[sdc1])
         create_vg = self.schedule_create_device(testvg)
         testlv = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                name="testlv", parents=[testvg],
-                                size=Size("30 GiB"))
+                                 name="testlv", parents=[testvg],
+                                 size=Size("30 GiB"))
         create_lv = self.schedule_create_device(testlv)
         fmt = self.new_format("ext4", device=testlv.path)
         create_lv_format = self.schedule_create_format(device=testlv, fmt=fmt)
@@ -805,18 +805,18 @@ def test_action_dependencies(self):
         #     we instantiate and use actions directly
         self.destroy_all_devices(disks=["sdc", "sdd"])
         sdc1 = self.new_device(device_class=PartitionDevice, exists=True,
-                              name="sdc1", parents=[sdc],
-                              size=Size("50 GiB"))
+                               name="sdc1", parents=[sdc],
+                               size=Size("50 GiB"))
         sdc1.format = self.new_format("lvmpv", device=sdc1.path, exists=True,
-                                     device_instance=sdc1)
+                                      device_instance=sdc1)
         testvg = self.new_device(device_class=LVMVolumeGroupDevice, exists=True,
-                                name="testvg", parents=[sdc1],
-                                size=Size("50 GiB"))
+                                 name="testvg", parents=[sdc1],
+                                 size=Size("50 GiB"))
         testlv = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                exists=True, size=Size("30 GiB"),
-                                name="testlv", parents=[testvg])
+                                 exists=True, size=Size("30 GiB"),
+                                 name="testlv", parents=[testvg])
         testlv.format = self.new_format("ext4", device=testlv.path,
-                                       exists=True, device_instance=testlv)
+                                        exists=True, device_instance=testlv)
 
         # ActionResizeDevice
         # an action that resizes a device should require an action that grows
@@ -947,7 +947,7 @@ def test_action_dependencies(self):
         self.assertEqual(destroy_lv_format.requires(destroy_pv_format), False)
 
         sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
-                              size=Size("5 GiB"), parents=[sdc])
+                               size=Size("5 GiB"), parents=[sdc])
         create_sdc2 = self.schedule_create_device(sdc2)
 
         # create actions should always require destroy actions -- even for
@@ -1036,44 +1036,44 @@ def test_container_actions(self):
         # create something like an existing lvm autopart layout across two disks
         #
         sda1 = self.new_device(device_class=PartitionDevice,
-                              exists=True, name="sda1", parents=[sda],
-                              size=Size("500 MiB"))
+                               exists=True, name="sda1", parents=[sda],
+                               size=Size("500 MiB"))
         sda1.format = self.new_format("ext4", mountpoint="/boot",
-                                     device_instance=sda1,
-                                     device=sda1.path, exists=True)
+                                      device_instance=sda1,
+                                      device=sda1.path, exists=True)
         self.storage.devicetree._add_device(sda1)
 
         sda2 = self.new_device(device_class=PartitionDevice,
-                              size=Size("99.5 GiB"), name="sda2",
-                              parents=[sda], exists=True)
+                               size=Size("99.5 GiB"), name="sda2",
+                               parents=[sda], exists=True)
         sda2.format = self.new_format("lvmpv", device=sda2.path, exists=True)
         self.storage.devicetree._add_device(sda2)
 
         sdb1 = self.new_device(device_class=PartitionDevice,
-                              size=Size("99.999 GiB"), name="sdb1",
-                              parents=[sdb], exists=True)
+                               size=Size("99.999 GiB"), name="sdb1",
+                               parents=[sdb], exists=True)
         sdb1.format = self.new_format("lvmpv", device=sdb1.path, exists=True)
         self.storage.devicetree._add_device(sdb1)
 
         vg = self.new_device(device_class=LVMVolumeGroupDevice,
-                            name="VolGroup", parents=[sda2, sdb1],
-                            exists=True)
+                             name="VolGroup", parents=[sda2, sdb1],
+                             exists=True)
         self.storage.devicetree._add_device(vg)
 
         lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_root", parents=[vg],
-                                 size=Size("160 GiB"), exists=True)
+                                  name="lv_root", parents=[vg],
+                                  size=Size("160 GiB"), exists=True)
         lv_root.format = self.new_format("ext4", mountpoint="/",
-                                        device_instance=lv_root,
-                                        device=lv_root.path, exists=True)
+                                         device_instance=lv_root,
+                                         device=lv_root.path, exists=True)
         self.storage.devicetree._add_device(lv_root)
 
         lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                 name="lv_swap", parents=[vg],
-                                 size=Size("4000 MiB"), exists=True)
+                                  name="lv_swap", parents=[vg],
+                                  size=Size("4000 MiB"), exists=True)
         lv_swap.format = self.new_format("swap", device=lv_swap.path,
-                                        device_instance=lv_swap,
-                                        exists=True)
+                                         device_instance=lv_swap,
+                                         exists=True)
         self.storage.devicetree._add_device(lv_swap)
 
         #
@@ -1081,11 +1081,11 @@ def test_container_actions(self):
         #
         sdc = self.storage.devicetree.get_device_by_name("sdc")
         sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
-                              size=Size("50 GiB"), parents=[sdc])
+                               size=Size("50 GiB"), parents=[sdc])
         sdc1_format = self.new_format("lvmpv", device=sdc1.path)
         create_sdc1 = self.schedule_create_device(sdc1)
         create_sdc1_format = self.schedule_create_format(device=sdc1,
-                                                       fmt=sdc1_format)
+                                                         fmt=sdc1_format)
 
         self.assertEqual(len(vg.parents), 2)
 
@@ -1098,12 +1098,12 @@ def test_container_actions(self):
         self.assertEqual(add_sdc1.requires(create_sdc1_format), True)
 
         new_lv = self.new_device(device_class=LVMLogicalVolumeDevice,
-                                name="newlv", parents=[vg],
-                                size=Size("20 GiB"))
+                                 name="newlv", parents=[vg],
+                                 size=Size("20 GiB"))
         create_new_lv = self.schedule_create_device(new_lv)
         new_lv_format = self.new_format("xfs", device=new_lv.path)
         create_new_lv_format = self.schedule_create_format(device=new_lv,
-                                                         fmt=new_lv_format)
+                                                           fmt=new_lv_format)
 
         self.assertEqual(create_new_lv.requires(add_sdc1), True)
         self.assertEqual(create_new_lv_format.requires(add_sdc1), False)
@@ -1136,7 +1136,7 @@ def test_container_actions(self):
         self.assertEqual(remove_sdb1.obsoletes(add_sdb1), True)
 
         sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
-                              size=Size("5 GiB"), parents=[sdc])
+                               size=Size("5 GiB"), parents=[sdc])
         create_sdc2 = self.schedule_create_device(sdc2)
 
         # destroy/resize/create sequencing does not apply to container actions
diff --git a/tests/clearpart_test.py b/tests/clearpart_test.py
index f321c08..3ded684 100644
--- a/tests/clearpart_test.py
+++ b/tests/clearpart_test.py
@@ -28,7 +28,7 @@ def test_should_clear(self):
         # sda is a disk with an existing disklabel containing two partitions
         sda = DiskDevice("sda", size=100000, exists=True)
         sda.format = blivet.formats.get_format("disklabel", device=sda.path,
-                                              exists=True)
+                                               exists=True)
         sda.format._parted_disk = mock.Mock()
         sda.format._parted_device = mock.Mock()
         sda.format._parted_disk.configure_mock(partitions=[])
@@ -38,26 +38,26 @@ def test_should_clear(self):
         sda1 = PartitionDevice("sda1", size=500, exists=True,
                                parents=[sda])
         sda1._parted_partition = mock.Mock(**{'type': PARTITION_NORMAL,
-                                             'getFlag.return_value': 0})
+                                              'getFlag.return_value': 0})
         sda1.format = blivet.formats.get_format("ext4", mountpoint="/boot",
-                                               device=sda1.path,
-                                               exists=True)
+                                                device=sda1.path,
+                                                exists=True)
         b.devicetree._add_device(sda1)
 
         # sda2 is a partition containing an existing vfat filesystem
         sda2 = PartitionDevice("sda2", size=10000, exists=True,
                                parents=[sda])
         sda2._parted_partition = mock.Mock(**{'type': PARTITION_NORMAL,
-                                             'getFlag.return_value': 0})
+                                              'getFlag.return_value': 0})
         sda2.format = blivet.formats.get_format("vfat", mountpoint="/foo",
-                                               device=sda2.path,
-                                               exists=True)
+                                                device=sda2.path,
+                                                exists=True)
         b.devicetree._add_device(sda2)
 
         # sdb is an unpartitioned disk containing an xfs filesystem
         sdb = DiskDevice("sdb", size=100000, exists=True)
         sdb.format = blivet.formats.get_format("xfs", device=sdb.path,
-                                              exists=True)
+                                               exists=True)
         b.devicetree._add_device(sdb)
 
         # sdc is an unformatted/uninitialized/empty disk
@@ -67,7 +67,7 @@ def test_should_clear(self):
         # sdd is a disk containing an existing disklabel with no partitions
         sdd = DiskDevice("sdd", size=100000, exists=True)
         sdd.format = blivet.formats.get_format("disklabel", device=sdd.path,
-                                              exists=True)
+                                               exists=True)
         b.devicetree._add_device(sdd)
 
         #
@@ -138,11 +138,11 @@ def test_should_clear(self):
                         msg="type linux should clear linux-native whole-disk "
                             "formatting regardless of initlabel setting")
         self.assertTrue(b.should_clear(sdc),
-                         msg="type linux should clear unformatted disks when "
-                             "initlabel is set")
+                        msg="type linux should clear unformatted disks when "
+                        "initlabel is set")
         self.assertTrue(b.should_clear(sdd),
-                         msg="type linux should clear disks with empty "
-                             "partition tables when initlabel is set")
+                        msg="type linux should clear disks with empty "
+                        "partition tables when initlabel is set")
 
         sda1.protected = True
         self.assertFalse(b.should_clear(sda1),
diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py
index 9c3a614..1ea3f74 100644
--- a/tests/devicefactory_test.py
+++ b/tests/devicefactory_test.py
@@ -66,7 +66,7 @@ def _clean_up_disk_files(self):
     def _factory_device(self, *args, **kwargs):
         """ Run the device factory and return the device it produces. """
         factory = devicefactory.get_device_factory(self.b,
-                                    *args, **kwargs)
+                                                   *args, **kwargs)
         factory.configure()
         return factory.device
 
@@ -230,7 +230,7 @@ def test_normalize_size(self):
         # PartitionFactory
         size = self.b.disks[0].size - Size("4 MiB")
         device = self._factory_device(self.device_type, size,
-                                     disks=self.b.disks, **kwargs)
+                                      disks=self.b.disks, **kwargs)
         self.assertAlmostEqual(device.size, size, delta=self._get_size_delta())
 
         factory.size = None
@@ -418,7 +418,7 @@ class LVMThinPFactoryTestCase(LVMFactoryTestCase):
 
     def _validate_factory_device(self, *args, **kwargs):
         super(LVMThinPFactoryTestCase, self)._validate_factory_device(*args,
-                                                                    **kwargs)
+                                                                      **kwargs)
         device = args[0]
 
         if kwargs.get("encrypted", False):
@@ -517,20 +517,20 @@ def _get_test_factory_args(self):
 
     def test_mdfactory(self):
         factory1 = devicefactory.get_device_factory(self.b,
-           devicefactory.DEVICE_TYPE_MD,
-           Size("1 GiB"),
-           raid_level=raid.RAID1)
+                                                    devicefactory.DEVICE_TYPE_MD,
+                                                    Size("1 GiB"),
+                                                    raid_level=raid.RAID1)
 
         factory2 = devicefactory.get_device_factory(self.b,
-           devicefactory.DEVICE_TYPE_MD,
-           Size("1 GiB"),
-           raid_level=0)
+                                                    devicefactory.DEVICE_TYPE_MD,
+                                                    Size("1 GiB"),
+                                                    raid_level=0)
 
         with self.assertRaisesRegex(devicefactory.DeviceFactoryError, "must have some RAID level"):
             devicefactory.get_device_factory(
-               self.b,
-               devicefactory.DEVICE_TYPE_MD,
-               Size("1 GiB"))
+                self.b,
+                devicefactory.DEVICE_TYPE_MD,
+                Size("1 GiB"))
 
         with self.assertRaisesRegex(RaidError, "requires at least"):
             factory1._get_device_space()
@@ -543,8 +543,8 @@ def test_mdfactory(self):
         self.assertIsNone(factory1.get_container())
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.assertIsNotNone(factory1._get_new_device(parents=parents))
 
diff --git a/tests/devicelibs_test/edd_test.py b/tests/devicelibs_test/edd_test.py
index 743e011..62c7b4d 100644
--- a/tests/devicelibs_test/edd_test.py
+++ b/tests/devicelibs_test/edd_test.py
@@ -59,13 +59,13 @@ def setUp(self):
         edd.log.setLevel(logging.DEBUG)
         newlog = mock.MagicMock(name='log')
         newlog.debug = mock.Mock(name='debug',
-                        side_effect=self._edd_logger.debug)
+                                 side_effect=self._edd_logger.debug)
         newlog.info = mock.Mock(name='info',
-                        side_effect=self._edd_logger.info)
+                                side_effect=self._edd_logger.info)
         newlog.warning = mock.Mock(name='warning',
-                        side_effect=self._edd_logger.warning)
+                                   side_effect=self._edd_logger.warning)
         newlog.error = mock.Mock(name='error',
-                        side_effect=self._edd_logger.error)
+                                 side_effect=self._edd_logger.error)
         edd.log = newlog
 
     def tearDown(self):
@@ -110,26 +110,26 @@ def test_collect_edd_data_sata_usb(self):
         self._set_fs_root(edd, "sata_usb")
         fakeedd = {
             0x80: FakeEddEntry(version="0x30", mbr_sig="0x00000000",
-                           sectors=312581808, host_bus="PCI", type="SATA",
-                           pci_dev="00:1f.2", channel=255, ata_device=1,
-                           interface="SATA    \tdevice: 1",
-                           sysfspath="/sys/firmware/edd/int13_dev80"),
+                               sectors=312581808, host_bus="PCI", type="SATA",
+                               pci_dev="00:1f.2", channel=255, ata_device=1,
+                               interface="SATA    \tdevice: 1",
+                               sysfspath="/sys/firmware/edd/int13_dev80"),
             0x81: FakeEddEntry(version="0x21", mbr_sig="0x96a20d28",
-                           sectors=31293440, host_bus="PCI", type="USB",
-                           pci_dev="ff:ff.255", channel=255,
-                           usb_serial=0x30302e31,
-                           interface="USB     \tserial_number: 30302e31",
-                           sysfspath="/sys/firmware/edd/int13_dev81"),
-            }
+                               sectors=31293440, host_bus="PCI", type="USB",
+                               pci_dev="ff:ff.255", channel=255,
+                               usb_serial=0x30302e31,
+                               interface="USB     \tserial_number: 30302e31",
+                               sysfspath="/sys/firmware/edd/int13_dev81"),
+        }
 
         edd_dict = edd.collect_edd_data()
         self.debug('edd_dict: %s', edd_dict)
         debugs = [
             ("edd: found device 0x%x at %s", 0x80,
-                    '/sys/firmware/edd/int13_dev80'),
+             '/sys/firmware/edd/int13_dev80'),
             ("edd: found device 0x%x at %s", 0x81,
-                    '/sys/firmware/edd/int13_dev81'),
-            ]
+             '/sys/firmware/edd/int13_dev81'),
+        ]
         self.assertEqual(len(edd_dict), 2)
         self.assertEqual(fakeedd[0x80], edd_dict[0x80])
         self.assertEqual(fakeedd[0x81], edd_dict[0x81])
@@ -139,23 +139,23 @@ def test_get_edd_dict_sata_usb(self):
         # test with sata sda, usb sdb
         self._set_fs_root(edd, "sata_usb")
         devices = (FakeDevice("sda"),
-                 FakeDevice("sdb"),
-                 )
+                   FakeDevice("sdb"),
+                   )
         fakeedd = {
             0x80: FakeEddEntry(version="0x30", mbr_sig="0x00000000",
-                           sectors=312581808, host_bus="PCI", type="SATA",
-                           pci_dev="00:1f.2", channel=255, ata_device=1,
-                           interface="SATA    \tdevice: 1",
-                           sysfspath="/sys/firmware/edd/int13_dev80",
-                           sysfslink="../devices/pci0000:00/0000:00:1f.2/ata2"
-                                     "/host1/target1:0:0/1:0:0:0/block/sda"),
+                               sectors=312581808, host_bus="PCI", type="SATA",
+                               pci_dev="00:1f.2", channel=255, ata_device=1,
+                               interface="SATA    \tdevice: 1",
+                               sysfspath="/sys/firmware/edd/int13_dev80",
+                               sysfslink="../devices/pci0000:00/0000:00:1f.2/ata2"
+                               "/host1/target1:0:0/1:0:0:0/block/sda"),
             0x81: FakeEddEntry(version="0x21", mbr_sig="0x96a20d28",
-                           sectors=31293440, host_bus="PCI", type="USB",
-                           pci_dev="ff:ff.255", channel=255,
-                           usb_serial=0x30302e31,
-                           interface="USB     \tserial_number: 30302e31",
-                           sysfspath="/sys/firmware/edd/int13_dev81"),
-            }
+                               sectors=31293440, host_bus="PCI", type="USB",
+                               pci_dev="ff:ff.255", channel=255,
+                               usb_serial=0x30302e31,
+                               interface="USB     \tserial_number: 30302e31",
+                               sysfspath="/sys/firmware/edd/int13_dev81"),
+        }
 
         edd_dict = edd.get_edd_dict(devices)
         self.debug('edd_dict: %s', edd_dict)
@@ -166,19 +166,19 @@ def test_get_edd_dict_sata_usb(self):
             ("edd: data extracted from 0x%x:\n%s", 0x80, fakeedd[0x80]),
             ("edd: data extracted from 0x%x:\n%s", 0x81, fakeedd[0x81]),
             ("edd: found device 0x%x at %s", 0x80,
-                    '/sys/firmware/edd/int13_dev80'),
+             '/sys/firmware/edd/int13_dev80'),
             ("edd: found device 0x%x at %s", 0x81,
-                    '/sys/firmware/edd/int13_dev81'),
-            ]
+             '/sys/firmware/edd/int13_dev81'),
+        ]
         infos = [
             ("edd: MBR signature on %s is zero. new disk image?", "sda"),
             ("edd: collected mbr signatures: %s", {'sdb': '0x96a20d28'}),
             ("edd: matched 0x%x to %s using PCI dev", 0x80, "sda"),
             ("edd: matched 0x%x to %s using MBR sig", 0x81, "sdb"),
-            ]
+        ]
         warnings = [
             ("edd: interface type %s is not implemented (%s)", "USB",
                 "/sys/firmware/edd/int13_dev81"),
             ("edd: interface details: %s", "USB     \tserial_number: 30302e31"),
-            ]
+        ]
         self.check_logs(debugs=debugs, infos=infos, warnings=warnings)
diff --git a/tests/devicelibs_test/raid_test.py b/tests/devicelibs_test/raid_test.py
index 0298fc7..5b1a039 100644
--- a/tests/devicelibs_test/raid_test.py
+++ b/tests/devicelibs_test/raid_test.py
@@ -115,15 +115,15 @@ def test_raid(self):
         sizes = [Size("32MiB"), Size("128MiB"), Size("128MiB"), Size("64MiB")]
         for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
             self.assertEqual(r.get_size(sizes, 4, Size("1MiB"), lambda x: Size(0)),
-               r.get_net_array_size(4, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
+                             r.get_net_array_size(4, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
 
         for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
             self.assertEqual(r.get_size(sizes, 5, Size("1MiB"), lambda x: Size(0)),
-               r.get_net_array_size(5, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
+                             r.get_net_array_size(5, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
 
         for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
             self.assertEqual(r.get_size(sizes, 4, Size("1MiB"), lambda x: Size("32MiB")),
-               Size(0) if isinstance(r, raid.RAIDn) else (sum(sizes, Size(0)) - 4 * Size("32MiB")))
+                             Size(0) if isinstance(r, raid.RAIDn) else (sum(sizes, Size(0)) - 4 * Size("32MiB")))
 
         for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
             if isinstance(r, raid.RAIDn):
@@ -138,9 +138,9 @@ def test_raid(self):
         # names
         ##
         self.assertListEqual(raid.RAID0.names,
-           ["raid0", "stripe", "RAID0", "0", 0])
+                             ["raid0", "stripe", "RAID0", "0", 0])
         self.assertListEqual(raid.RAID10.names,
-           ["raid10", "RAID10", "10", 10])
+                             ["raid10", "RAID10", "10", 10])
 
         ##
         # __init__
diff --git a/tests/devices_test/device_properties_test.py b/tests/devices_test/device_properties_test.py
index 0887d89..e9ee634 100644
--- a/tests/devices_test/device_properties_test.py
+++ b/tests/devices_test/device_properties_test.py
@@ -60,29 +60,29 @@ class DeviceStateTestCase(unittest.TestCase):
 
     def __init__(self, methodName='run_test'):
         self._state_functions = {
-           "current_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-           "direct": xform(self.assertTrue),
-           "exists": xform(self.assertFalse),
-           "format": xform(self.assertIsNotNone),
-           "format_args": xform(lambda x, m: self.assertEqual(x, [], m)),
-           "is_disk": xform(self.assertFalse),
-           "isleaf": xform(self.assertTrue),
-           "major": xform(lambda x, m: self.assertEqual(x, 0, m)),
-           "max_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-           "media_present": xform(self.assertTrue),
-           "minor": xform(lambda x, m: self.assertEqual(x, 0, m)),
-           "parents": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
-                                    self.assertIsInstance(x, ParentList, m)),
-           "partitionable": xform(self.assertFalse),
-           "path": xform(lambda x, m: self.assertRegex(x, "^/dev", m)),
-           "raw_device": xform(self.assertIsNotNone),
-           "resizable": xform(self.assertFalse),
-           "size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-           "status": xform(self.assertFalse),
-           "sysfs_path": xform(lambda x, m: self.assertEqual(x, "", m)),
-           "target_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-           "type": xform(lambda x, m: self.assertEqual(x, "mdarray", m)),
-           "uuid": xform(self.assertIsNone)
+            "current_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+            "direct": xform(self.assertTrue),
+            "exists": xform(self.assertFalse),
+            "format": xform(self.assertIsNotNone),
+            "format_args": xform(lambda x, m: self.assertEqual(x, [], m)),
+            "is_disk": xform(self.assertFalse),
+            "isleaf": xform(self.assertTrue),
+            "major": xform(lambda x, m: self.assertEqual(x, 0, m)),
+            "max_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+            "media_present": xform(self.assertTrue),
+            "minor": xform(lambda x, m: self.assertEqual(x, 0, m)),
+            "parents": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+                             self.assertIsInstance(x, ParentList, m)),
+            "partitionable": xform(self.assertFalse),
+            "path": xform(lambda x, m: self.assertRegex(x, "^/dev", m)),
+            "raw_device": xform(self.assertIsNotNone),
+            "resizable": xform(self.assertFalse),
+            "size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+            "status": xform(self.assertFalse),
+            "sysfs_path": xform(lambda x, m: self.assertEqual(x, "", m)),
+            "target_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+            "type": xform(lambda x, m: self.assertEqual(x, "mdarray", m)),
+            "uuid": xform(self.assertIsNone)
         }
         super(DeviceStateTestCase, self).__init__(methodName=methodName)
 
@@ -122,17 +122,17 @@ class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
     def __init__(self, methodName='run_test'):
         super(MDRaidArrayDeviceTestCase, self).__init__(methodName=methodName)
         state_functions = {
-           "create_bitmap": xform(lambda d, a: self.assertFalse),
-           "description": xform(self.assertIsNotNone),
-           "format_class": xform(self.assertIsNotNone),
-           "level": xform(self.assertIsNone),
-           "mdadm_format_uuid": xform(self.assertIsNone),
-           "member_devices": xform(lambda x, m: self.assertEqual(x, 0, m)),
-           "members": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
-                                    self.assertIsInstance(x, list, m)),
-           "metadata_version": xform(lambda x, m: self.assertEqual(x, "default", m)),
-           "spares": xform(lambda x, m: self.assertEqual(x, 0, m)),
-           "total_devices": xform(lambda x, m: self.assertEqual(x, 0, m))
+            "create_bitmap": xform(lambda d, a: self.assertFalse),
+            "description": xform(self.assertIsNotNone),
+            "format_class": xform(self.assertIsNotNone),
+            "level": xform(self.assertIsNone),
+            "mdadm_format_uuid": xform(self.assertIsNone),
+            "member_devices": xform(lambda x, m: self.assertEqual(x, 0, m)),
+            "members": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+                             self.assertIsInstance(x, list, m)),
+            "metadata_version": xform(lambda x, m: self.assertEqual(x, "default", m)),
+            "spares": xform(lambda x, m: self.assertEqual(x, 0, m)),
+            "total_devices": xform(lambda x, m: self.assertEqual(x, 0, m))
         }
         self._state_functions.update(state_functions)
 
@@ -143,207 +143,207 @@ def setUp(self):
         MDRaidArrayDevice.get_superblock_size = lambda a, s: Size(0)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember"))
         ]
         self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, total_devices=1, member_devices=1)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember"), size=Size("1 GiB")),
-           DiskDevice("name2", fmt=get_format("mdmember"), size=Size("1 GiB"))
+            DiskDevice("name1", fmt=get_format("mdmember"), size=Size("1 GiB")),
+            DiskDevice("name2", fmt=get_format("mdmember"), size=Size("1 GiB"))
         ]
         self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents,
                                       total_devices=2, member_devices=2)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev3 = MDRaidArrayDevice("dev3", level="raid1", parents=parents)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember")),
-           DiskDevice("name3", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember")),
+            DiskDevice("name3", fmt=get_format("mdmember"))
         ]
         self.dev4 = MDRaidArrayDevice("dev4", level="raid4", parents=parents)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember")),
-           DiskDevice("name3", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember")),
+            DiskDevice("name3", fmt=get_format("mdmember"))
         ]
         self.dev5 = MDRaidArrayDevice("dev5", level="raid5", parents=parents)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember")),
-           DiskDevice("name3", fmt=get_format("mdmember")),
-           DiskDevice("name4", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember")),
+            DiskDevice("name3", fmt=get_format("mdmember")),
+            DiskDevice("name4", fmt=get_format("mdmember"))
         ]
         self.dev6 = MDRaidArrayDevice("dev6", level="raid6", parents=parents)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember")),
-           DiskDevice("name3", fmt=get_format("mdmember")),
-           DiskDevice("name4", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember")),
+            DiskDevice("name3", fmt=get_format("mdmember")),
+            DiskDevice("name4", fmt=get_format("mdmember"))
         ]
         self.dev7 = MDRaidArrayDevice("dev7", level="raid10", parents=parents)
 
         self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True)
 
         parents_1 = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         dev_1 = MDContainerDevice(
-           "parent",
-           level="container",
-           parents=parents_1,
-           total_devices=2,
-           member_devices=2,
-           exists=True
+            "parent",
+            level="container",
+            parents=parents_1,
+            total_devices=2,
+            member_devices=2,
+            exists=True
         )
         self.dev9 = MDBiosRaidArrayDevice(
-           "dev9",
-           level="raid0",
-           member_devices=1,
-           parents=[dev_1],
-           total_devices=1,
-           exists=True
+            "dev9",
+            level="raid0",
+            member_devices=1,
+            parents=[dev_1],
+            total_devices=1,
+            exists=True
         )
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev10 = MDRaidArrayDevice(
-           "dev10",
-           level="raid0",
-           parents=parents,
-           size=Size("32 MiB"))
+            "dev10",
+            level="raid0",
+            parents=parents,
+            size=Size("32 MiB"))
 
         parents_1 = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         dev_1 = MDContainerDevice(
-           "parent",
-           level="container",
-           parents=parents,
-           total_devices=2,
-           member_devices=2
+            "parent",
+            level="container",
+            parents=parents,
+            total_devices=2,
+            member_devices=2
         )
         self.dev11 = MDBiosRaidArrayDevice(
-           "dev11",
-           level=1,
-           exists=True,
-           parents=[dev_1],
-           size=Size("32 MiB"))
+            "dev11",
+            level=1,
+            exists=True,
+            parents=[dev_1],
+            size=Size("32 MiB"))
 
         self.dev13 = MDRaidArrayDevice(
-           "dev13",
-           level=0,
-           member_devices=2,
-           parents=[
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")})],
-           size=Size("32 MiB"),
-           total_devices=2)
+            "dev13",
+            level=0,
+            member_devices=2,
+            parents=[
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")})],
+            size=Size("32 MiB"),
+            total_devices=2)
 
         self.dev14 = MDRaidArrayDevice(
-           "dev14",
-           level=4,
-           member_devices=3,
-           parents=[
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")})],
-           total_devices=3)
+            "dev14",
+            level=4,
+            member_devices=3,
+            parents=[
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")})],
+            total_devices=3)
 
         self.dev15 = MDRaidArrayDevice(
-           "dev15",
-           level=5,
-           member_devices=3,
-           parents=[
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")})],
-           total_devices=3)
+            "dev15",
+            level=5,
+            member_devices=3,
+            parents=[
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")})],
+            total_devices=3)
 
         self.dev16 = MDRaidArrayDevice(
-           "dev16",
-           level=6,
-           member_devices=4,
-           parents=[
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")})],
-           total_devices=4)
+            "dev16",
+            level=6,
+            member_devices=4,
+            parents=[
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")})],
+            total_devices=4)
 
         self.dev17 = MDRaidArrayDevice(
-           "dev17",
-           level=10,
-           member_devices=4,
-           parents=[
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")})],
-           total_devices=4)
+            "dev17",
+            level=10,
+            member_devices=4,
+            parents=[
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")})],
+            total_devices=4)
 
         self.dev18 = MDRaidArrayDevice(
-           "dev18",
-           level=10,
-           member_devices=4,
-           parents=[
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("4 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": get_format("mdmember")})],
-           total_devices=5)
+            "dev18",
+            level=10,
+            member_devices=4,
+            parents=[
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("4 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")}),
+                Mock(**{"size": Size("2 MiB"),
+                        "format": get_format("mdmember")})],
+            total_devices=5)
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev19 = MDRaidArrayDevice(
-           "dev19",
-           level="raid1",
-           parents=parents,
-           uuid='3386ff85-f501-2621-4a43-5f061eb47236'
+            "dev19",
+            level="raid1",
+            parents=parents,
+            uuid='3386ff85-f501-2621-4a43-5f061eb47236'
         )
 
         parents = [
-           DiskDevice("name1", fmt=get_format("mdmember")),
-           DiskDevice("name2", fmt=get_format("mdmember"))
+            DiskDevice("name1", fmt=get_format("mdmember")),
+            DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev20 = MDRaidArrayDevice(
-           "dev20",
-           level="raid1",
-           parents=parents,
-           uuid='Just-pretending'
+            "dev20",
+            level="raid1",
+            parents=parents,
+            uuid='Just-pretending'
         )
 
     def tearDown(self):
@@ -360,180 +360,180 @@ def test_mdraid_array_device_init(self):
         # level tests
         ##
         self.state_check(self.dev1,
-           level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           media_present=xform(self.assertFalse),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
+                         level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         media_present=xform(self.assertFalse),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
         self.state_check(self.dev2,
-           create_bitmap=xform(self.assertFalse),
-           level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("2 GiB"), m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
+                         create_bitmap=xform(self.assertFalse),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("2 GiB"), m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
         self.state_check(self.dev3,
-           level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
         self.state_check(self.dev4,
-           level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
         self.state_check(self.dev5,
-           level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
         self.state_check(self.dev6,
-           level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
         self.state_check(self.dev7,
-           level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
 
         ##
         # existing device tests
         ##
         self.state_check(self.dev8,
-           exists=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-           metadata_version=xform(self.assertIsNone))
+                         exists=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+                         metadata_version=xform(self.assertIsNone))
 
         ##
         # mdbiosraidarray tests
         ##
         self.state_check(self.dev9,
-           create_bitmap=xform(self.assertFalse),
-           is_disk=xform(self.assertTrue),
-           exists=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           partitionable=xform(self.assertTrue),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
+                         create_bitmap=xform(self.assertFalse),
+                         is_disk=xform(self.assertTrue),
+                         exists=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         partitionable=xform(self.assertTrue),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
 
         ##
         # mdcontainer tests
         ##
         dev9_container = self.dev9.parents[0]
         self.state_check(dev9_container,
-           create_bitmap=xform(self.assertFalse),
-           direct=xform(self.assertFalse),
-           is_disk=xform(self.assertFalse),
-           isleaf=xform(self.assertFalse),
-           exists=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
-           media_present=xform(self.assertFalse),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           partitionable=xform(self.assertFalse),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
+                         create_bitmap=xform(self.assertFalse),
+                         direct=xform(self.assertFalse),
+                         is_disk=xform(self.assertFalse),
+                         isleaf=xform(self.assertFalse),
+                         exists=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
+                         media_present=xform(self.assertFalse),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         partitionable=xform(self.assertFalse),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
 
         ##
         # size tests
         ##
         self.state_check(self.dev10,
-           create_bitmap=xform(self.assertFalse),
-           level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
+                         create_bitmap=xform(self.assertFalse),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
 
         self.state_check(self.dev11,
-           is_disk=xform(self.assertTrue),
-           exists=xform(lambda x, m: self.assertEqual(x, True, m)),
-           level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-           current_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           max_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           partitionable=xform(self.assertTrue),
-           size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
+                         is_disk=xform(self.assertTrue),
+                         exists=xform(lambda x, m: self.assertEqual(x, True, m)),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+                         current_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+                         max_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         partitionable=xform(self.assertTrue),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+                         target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
 
         self.state_check(self.dev13,
-           create_bitmap=xform(self.assertFalse),
-           level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
-           target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
+                         create_bitmap=xform(self.assertFalse),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+                         target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
 
         self.state_check(self.dev14,
-           create_bitmap=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+                         create_bitmap=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
 
         self.state_check(self.dev15,
-           create_bitmap=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+                         create_bitmap=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
 
         self.state_check(self.dev16,
-           create_bitmap=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
+                         create_bitmap=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
 
         self.state_check(self.dev17,
-           create_bitmap=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
+                         create_bitmap=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
 
         self.state_check(self.dev18,
-           create_bitmap=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
-           member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
-           members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
-           parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
-           spares=xform(lambda x, m: self.assertEqual(x, 1, m)),
-           total_devices=xform(lambda x, m: self.assertEqual(x, 5, m)))
+                         create_bitmap=xform(self.assertTrue),
+                         level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+                         member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+                         parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+                         spares=xform(lambda x, m: self.assertEqual(x, 1, m)),
+                         total_devices=xform(lambda x, m: self.assertEqual(x, 5, m)))
 
         self.state_check(self.dev19,
-                        level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-                        mdadm_format_uuid=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), m)),
-                        members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-                        parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-                        uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+                         mdadm_format_uuid=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m)))
 
         self.state_check(self.dev20,
-                        level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-                        members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-                        parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-                        uuid=xform(lambda x, m: self.assertEqual(x, self.dev20.uuid, m)))
+                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+                         members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+                         uuid=xform(lambda x, m: self.assertEqual(x, self.dev20.uuid, m)))
 
         with self.assertRaisesRegex(DeviceError, "invalid"):
             MDRaidArrayDevice("dev")
@@ -543,14 +543,14 @@ def test_mdraid_array_device_init(self):
 
         with self.assertRaisesRegex(DeviceError, "invalid"):
             MDRaidArrayDevice(
-               "dev",
-               parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
+                "dev",
+                parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
 
         with self.assertRaisesRegex(DeviceError, "at least 2 members"):
             MDRaidArrayDevice(
-               "dev",
-               level="raid0",
-               parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
+                "dev",
+                level="raid0",
+                parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
 
         with self.assertRaisesRegex(DeviceError, "invalid"):
             MDRaidArrayDevice("dev", level="junk")
@@ -578,29 +578,29 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
     def __init__(self, methodName='run_test'):
         super(BTRFSDeviceTestCase, self).__init__(methodName=methodName)
         state_functions = {
-           "data_level": lambda d, a: self.assertFalse(hasattr(d, a)),
-           "fstab_spec": xform(self.assertIsNotNone),
-           "media_present": xform(self.assertTrue),
-           "metadata_level": lambda d, a: self.assertFalse(hasattr(d, a)),
-           "type": xform(lambda x, m: self.assertEqual(x, "btrfs", m)),
-           "vol_id": xform(lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m))}
+            "data_level": lambda d, a: self.assertFalse(hasattr(d, a)),
+            "fstab_spec": xform(self.assertIsNotNone),
+            "media_present": xform(self.assertTrue),
+            "metadata_level": lambda d, a: self.assertFalse(hasattr(d, a)),
+            "type": xform(lambda x, m: self.assertEqual(x, "btrfs", m)),
+            "vol_id": xform(lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m))}
         self._state_functions.update(state_functions)
 
     def setUp(self):
         self.dev1 = BTRFSVolumeDevice("dev1",
-           parents=[StorageDevice("deva",
-              fmt=blivet.formats.get_format("btrfs"),
-              size=BTRFS_MIN_MEMBER_SIZE)])
+                                      parents=[StorageDevice("deva",
+                                                             fmt=blivet.formats.get_format("btrfs"),
+                                                             size=BTRFS_MIN_MEMBER_SIZE)])
 
         self.dev2 = BTRFSSubVolumeDevice("dev2",
-           parents=[self.dev1],
-           fmt=blivet.formats.get_format("btrfs"))
+                                         parents=[self.dev1],
+                                         fmt=blivet.formats.get_format("btrfs"))
 
         dev = StorageDevice("deva",
-           fmt=blivet.formats.get_format("btrfs"),
-           size=Size("500 MiB"))
+                            fmt=blivet.formats.get_format("btrfs"),
+                            size=Size("500 MiB"))
         self.dev3 = BTRFSVolumeDevice("dev3",
-           parents=[dev])
+                                      parents=[dev])
 
     def test_btrfsdevice_init(self):
         """Tests the state of a BTRFSDevice after initialization.
@@ -609,32 +609,32 @@ def test_btrfsdevice_init(self):
         """
 
         self.state_check(self.dev1,
-           current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           data_level=xform(self.assertIsNone),
-           isleaf=xform(self.assertFalse),
-           max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           metadata_level=xform(self.assertIsNone),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
+                         current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         data_level=xform(self.assertIsNone),
+                         isleaf=xform(self.assertFalse),
+                         max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         metadata_level=xform(self.assertIsNone),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
 
         self.state_check(self.dev2,
-           target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "btrfs subvolume", m)),
-           vol_id=xform(self.assertIsNone))
+                         target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "btrfs subvolume", m)),
+                         vol_id=xform(self.assertIsNone))
 
         self.state_check(self.dev3,
-           current_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
-           data_level=xform(self.assertIsNone),
-           max_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
-           metadata_level=xform(self.assertIsNone),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
-           type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
+                         current_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
+                         data_level=xform(self.assertIsNone),
+                         max_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
+                         metadata_level=xform(self.assertIsNone),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
 
         with self.assertRaisesRegex(ValueError, "BTRFSDevice.*must have at least one parent"):
             BTRFSVolumeDevice("dev")
@@ -703,27 +703,27 @@ def test_btrfssnap_shot_device_init(self):
 
         vol.exists = True
         snap = BTRFSSnapShotDevice("snap1",
-           fmt=blivet.formats.get_format("btrfs"),
-           parents=[vol],
-           source=vol)
+                                   fmt=blivet.formats.get_format("btrfs"),
+                                   parents=[vol],
+                                   source=vol)
         self.state_check(snap,
-           current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "btrfs snapshot", m)),
-           vol_id=xform(self.assertIsNone))
+                         current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "btrfs snapshot", m)),
+                         vol_id=xform(self.assertIsNone))
         self.state_check(vol,
-           current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           data_level=xform(self.assertIsNone),
-           exists=xform(self.assertTrue),
-           isleaf=xform(self.assertFalse),
-           max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           metadata_level=xform(self.assertIsNone),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
+                         current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         data_level=xform(self.assertIsNone),
+                         exists=xform(self.assertTrue),
+                         isleaf=xform(self.assertFalse),
+                         max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         metadata_level=xform(self.assertIsNone),
+                         parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+                         size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+                         type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
 
         self.assertEqual(snap.isleaf, True)
         self.assertEqual(snap.direct, True)
@@ -743,7 +743,7 @@ def __init__(self, methodName="run_test"):
             "parents": xform(lambda x, m: self.assertEqual(len(x), 1, m) and
                              self.assertIsInstance(x, ParentList) and
                              self.assertIsInstance(x[0], LVMVolumeGroupDevice)),
-            }
+        }
 
         self._state_functions.update(state_functions)
 
@@ -761,71 +761,71 @@ def setUp(self):
         vg2 = LVMVolumeGroupDevice("testvg2", parents=[pv2, pv3])
         cache_req = LVMCacheRequest(Size("512 MiB"), [pv3], "writethrough")
         self.cached_lv = LVMLogicalVolumeDevice("testcachedlv", parents=[vg2],
-                                    fmt=blivet.formats.get_format("xfs"),
-                                    exists=False, cache_request=cache_req)
+                                                fmt=blivet.formats.get_format("xfs"),
+                                                exists=False, cache_request=cache_req)
 
     def test_lvmlogical_volume_device_init(self):
         self.state_check(self.lv,
-            # 1 GiB - one extent
-            max_size=xform(lambda x, m: self.assertEqual(x, Size("1020 MiB"), m) and
-                          self.assertIsInstance(x, Size, m)),
-            snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
-            seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
-            req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
-            req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                               self.assertIsInstance(x, Size, m)),
-            req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                           self.assertIsInstance(x, Size, m)),
-            req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-            copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
-            log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                          self.assertIsInstance(x, Size, m)),
-            metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                               self.assertIsInstance(x, Size, m)),
-            mirrored=xform(lambda x, m: self.assertFalse(x, m)),
-            vg_space_used=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                              self.assertIsInstance(x, Size, m)),
-            vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
-            container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
-            map_name=xform(lambda x, m: self.assertEqual(x, "testvg-testlv", m)),
-            path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg-testlv", m)),
-            lvname=xform(lambda x, m: self.assertEqual(x, "testlv", m)),
-            complete=xform(lambda x, m: self.assertTrue(x, m)),
-            isleaf=xform(lambda x, m: self.assertTrue(x, m)),
-            direct=xform(lambda x, m: self.assertTrue(x, m)),
-            cached=xform(lambda x, m: self.assertFalse(x, m)),
-        )
+                         # 1 GiB - one extent
+                         max_size=xform(lambda x, m: self.assertEqual(x, Size("1020 MiB"), m) and
+                                        self.assertIsInstance(x, Size, m)),
+                         snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
+                         seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
+                         req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
+                         req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                            self.assertIsInstance(x, Size, m)),
+                         req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                        self.assertIsInstance(x, Size, m)),
+                         req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+                         copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
+                         log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                        self.assertIsInstance(x, Size, m)),
+                         metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                             self.assertIsInstance(x, Size, m)),
+                         mirrored=xform(lambda x, m: self.assertFalse(x, m)),
+                         vg_space_used=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                             self.assertIsInstance(x, Size, m)),
+                         vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+                         container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+                         map_name=xform(lambda x, m: self.assertEqual(x, "testvg-testlv", m)),
+                         path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg-testlv", m)),
+                         lvname=xform(lambda x, m: self.assertEqual(x, "testlv", m)),
+                         complete=xform(lambda x, m: self.assertTrue(x, m)),
+                         isleaf=xform(lambda x, m: self.assertTrue(x, m)),
+                         direct=xform(lambda x, m: self.assertTrue(x, m)),
+                         cached=xform(lambda x, m: self.assertFalse(x, m)),
+                         )
 
     def test_lvmlogical_volume_device_init_cached(self):
         self.state_check(self.cached_lv,
-            # 2 * (1 GiB - one extent) - 512 MiB - 8 MiB
-            #       PVfree               cache     pmspare
-            max_size=xform(lambda x, m: self.assertEqual(x, Size("1520 MiB"), m) and
-                          self.assertIsInstance(x, Size, m)),
-            snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
-            seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
-            req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
-            req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                               self.assertIsInstance(x, Size, m)),
-            req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                           self.assertIsInstance(x, Size, m)),
-            req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-            copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
-            log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                          self.assertIsInstance(x, Size, m)),
-            metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
-                               self.assertIsInstance(x, Size, m)),
-            mirrored=xform(lambda x, m: self.assertFalse(x, m)),
-            vg_space_used=xform(lambda x, m: self.assertEqual(x, Size("512 MiB"), m) and
-                              self.assertIsInstance(x, Size, m)),
-            vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
-            container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
-            map_name=xform(lambda x, m: self.assertEqual(x, "testvg2-testcachedlv", m)),
-            path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg2-testcachedlv", m)),
-            lvname=xform(lambda x, m: self.assertEqual(x, "testcachedlv", m)),
-            complete=xform(lambda x, m: self.assertTrue(x, m)),
-            isleaf=xform(lambda x, m: self.assertTrue(x, m)),
-            direct=xform(lambda x, m: self.assertTrue(x, m)),
-            cached=xform(lambda x, m: self.assertTrue(x, m)),
-            cache=xform(lambda x, m: self.assertIsInstance(x, LVMCache, m)),
-        )
+                         # 2 * (1 GiB - one extent) - 512 MiB - 8 MiB
+                         #       PVfree               cache     pmspare
+                         max_size=xform(lambda x, m: self.assertEqual(x, Size("1520 MiB"), m) and
+                                        self.assertIsInstance(x, Size, m)),
+                         snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
+                         seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
+                         req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
+                         req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                            self.assertIsInstance(x, Size, m)),
+                         req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                        self.assertIsInstance(x, Size, m)),
+                         req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+                         copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
+                         log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                        self.assertIsInstance(x, Size, m)),
+                         metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+                                             self.assertIsInstance(x, Size, m)),
+                         mirrored=xform(lambda x, m: self.assertFalse(x, m)),
+                         vg_space_used=xform(lambda x, m: self.assertEqual(x, Size("512 MiB"), m) and
+                                             self.assertIsInstance(x, Size, m)),
+                         vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+                         container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+                         map_name=xform(lambda x, m: self.assertEqual(x, "testvg2-testcachedlv", m)),
+                         path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg2-testcachedlv", m)),
+                         lvname=xform(lambda x, m: self.assertEqual(x, "testcachedlv", m)),
+                         complete=xform(lambda x, m: self.assertTrue(x, m)),
+                         isleaf=xform(lambda x, m: self.assertTrue(x, m)),
+                         direct=xform(lambda x, m: self.assertTrue(x, m)),
+                         cached=xform(lambda x, m: self.assertTrue(x, m)),
+                         cache=xform(lambda x, m: self.assertIsInstance(x, LVMCache, m)),
+                         )
diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py
index 2094d6a..d3d761d 100644
--- a/tests/devices_test/lvm_test.py
+++ b/tests/devices_test/lvm_test.py
@@ -15,13 +15,13 @@
 from blivet.size import Size
 
 DEVICE_CLASSES = [
-   LVMLogicalVolumeDevice,
-   LVMSnapShotDevice,
-   LVMThinLogicalVolumeDevice,
-   LVMThinPoolDevice,
-   LVMThinSnapShotDevice,
-   LVMVolumeGroupDevice,
-   StorageDevice
+    LVMLogicalVolumeDevice,
+    LVMSnapShotDevice,
+    LVMThinLogicalVolumeDevice,
+    LVMThinPoolDevice,
+    LVMThinSnapShotDevice,
+    LVMVolumeGroupDevice,
+    StorageDevice
 ]
 
 
@@ -98,7 +98,7 @@ def test_lvmcached_logical_volume_init(self):
         pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
                            size=Size("1 GiB"))
         pv2 = StorageDevice("pv2", fmt=blivet.formats.get_format("lvmpv"),
-                           size=Size("512 MiB"))
+                            size=Size("512 MiB"))
         vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
 
         cache_req = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
@@ -147,7 +147,7 @@ def test_target_size(self):
 
         # ValueError if size smaller than min_size
         with self.assertRaisesRegex(ValueError,
-                                     "size.*smaller than the minimum"):
+                                    "size.*smaller than the minimum"):
             lv.target_size = Size("1 MiB")
 
         # target size should be unchanged
@@ -155,7 +155,7 @@ def test_target_size(self):
 
         # ValueError if size larger than max_size
         with self.assertRaisesRegex(ValueError,
-                                     "size.*larger than the maximum"):
+                                    "size.*larger than the maximum"):
             lv.target_size = Size("1 GiB")
 
         # target size should be unchanged
diff --git a/tests/devices_test/partition_test.py b/tests/devices_test/partition_test.py
index ee2227c..724541f 100644
--- a/tests/devices_test/partition_test.py
+++ b/tests/devices_test/partition_test.py
@@ -49,21 +49,21 @@ def test_target_size(self):
 
             # ValueError if not Size
             with self.assertRaisesRegex(ValueError,
-                                         "new size must.*type Size"):
+                                        "new size must.*type Size"):
                 device.target_size = 22
 
             self.assertEqual(device.target_size, orig_size)
 
             # ValueError if size smaller than min_size
             with self.assertRaisesRegex(ValueError,
-                                         "size.*smaller than the minimum"):
+                                        "size.*smaller than the minimum"):
                 device.target_size = Size("1 MiB")
 
             self.assertEqual(device.target_size, orig_size)
 
             # ValueError if size larger than max_size
             with self.assertRaisesRegex(ValueError,
-                                         "size.*larger than the maximum"):
+                                        "size.*larger than the maximum"):
                 device.target_size = Size("11 MiB")
 
             self.assertEqual(device.target_size, orig_size)
@@ -122,7 +122,7 @@ def test_min_max_size_alignment(self):
             min_end_sector = partition.geometry.start + min_sectors - 1
             self.assertEqual(
                 disk.format.end_alignment.isAligned(partition.geometry,
-                                                   min_end_sector),
+                                                    min_end_sector),
                 False)
 
             # The end sector based on device min size should be aligned.
@@ -130,7 +130,7 @@ def test_min_max_size_alignment(self):
             min_end_sector = partition.geometry.start + min_sectors - 1
             self.assertEqual(
                 disk.format.end_alignment.isAligned(partition.geometry,
-                                                   min_end_sector),
+                                                    min_end_sector),
                 True)
 
             ##
diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py
index cd8bd85..84848b6 100644
--- a/tests/devicetree_test.py
+++ b/tests/devicetree_test.py
@@ -42,7 +42,7 @@ def test_resolve_device(self):
         dt._add_device(dev3)
 
         dt.edd_dict.update({"dev1": 0x81,
-                           "dev2": 0x82})
+                            "dev2": 0x82})
 
         self.assertEqual(dt.resolve_device(dev1.name), dev1)
         self.assertEqual(dt.resolve_device("LABEL=%s" % dev1_label), dev1)
@@ -88,8 +88,8 @@ def collect_expected_data(self):
         """ Collect the attribute data we plan to validate later. """
         # only look at devices on the disk images -- no loops, &c
         for device in (d for d in self.blivet.devices
-                            if d.disks and
-                               set(d.disks).issubset(set(self.blivet.disks))):
+                       if d.disks and
+                       set(d.disks).issubset(set(self.blivet.disks))):
             attr_dict = {}
             device._parted_device = None  # force update from disk for size, &c
             for attr in self._validate_attrs:
@@ -161,8 +161,8 @@ def run_test(self):
 
                 actual = recursive_getattr(device, attr)
                 self.assertEqual(actual, expected,
-                        msg=("attribute mismatch for %s: %s (%s/%s)"
-                             % (device_id, attr, expected, actual)))
+                                 msg=("attribute mismatch for %s: %s (%s/%s)"
+                                      % (device_id, attr, expected, actual)))
 
 
 class LVMTestCase(BlivetResetTestCase):
@@ -172,23 +172,23 @@ class LVMTestCase(BlivetResetTestCase):
     def _set_up_storage(self):
         # This isn't exactly autopart, but it should be plenty close to it.
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                                  Size("500 MiB"),
-                                  disks=self.blivet.disks[:],
-                                  fstype="swap")
+                                   Size("500 MiB"),
+                                   disks=self.blivet.disks[:],
+                                   fstype="swap")
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                                  None,
-                                  disks=self.blivet.disks[:])
+                                   None,
+                                   disks=self.blivet.disks[:])
 
 
 class LVMSnapShotTestCase(BlivetResetTestCase):
 
     def _set_up_storage(self):
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                                  Size("1 GiB"),
-                                  label="ROOT",
-                                  disks=self.blivet.disks[:],
-                                  container_name="blivet_test",
-                                  container_size=devicefactory.SIZE_POLICY_MAX)
+                                   Size("1 GiB"),
+                                   label="ROOT",
+                                   disks=self.blivet.disks[:],
+                                   container_name="blivet_test",
+                                   container_size=devicefactory.SIZE_POLICY_MAX)
 
     def setUp(self):
         super(BlivetResetTestCase, self).setUp()  # pylint: disable=bad-super-call
@@ -206,22 +206,22 @@ class LVMThinpTestCase(BlivetResetTestCase):
 
     def _set_up_storage(self):
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                                  Size("500 MiB"),
-                                  fstype="swap",
-                                  disks=self.blivet.disks[:])
+                                   Size("500 MiB"),
+                                   fstype="swap",
+                                   disks=self.blivet.disks[:])
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_THINP,
-                                  None,
-                                  label="ROOT",
-                                  disks=self.blivet.disks[:])
+                                   None,
+                                   label="ROOT",
+                                   disks=self.blivet.disks[:])
 
 
 class LVMThinSnapShotTestCase(LVMThinpTestCase):
 
     def _set_up_storage(self):
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_THINP,
-                                  Size("1 GiB"),
-                                  label="ROOT",
-                                  disks=self.blivet.disks[:])
+                                   Size("1 GiB"),
+                                   label="ROOT",
+                                   disks=self.blivet.disks[:])
 
     def setUp(self):
         super(BlivetResetTestCase, self).setUp()  # pylint: disable=bad-super-call
@@ -241,9 +241,9 @@ class LVMRaidTestCase(BlivetResetTestCase):
     def _set_up_storage(self):
         # This isn't exactly autopart, but it should be plenty close to it.
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                          Size("500 MiB"),
-                          disks=self.blivet.disks[:],
-                          container_size=devicefactory.SIZE_POLICY_MAX)
+                                   Size("500 MiB"),
+                                   disks=self.blivet.disks[:],
+                                   container_size=devicefactory.SIZE_POLICY_MAX)
 
     def setUp(self):
         super(BlivetResetTestCase, self).setUp()  # pylint: disable=bad-super-call
@@ -278,43 +278,43 @@ def skip_attr(self, device, attr):
 
     def _set_up_storage(self):
         device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
-                                           Size("200 MiB"),
-                                           disks=self.blivet.disks[:],
-                                           raid_level=self.level,
-                                           label="v090",
-                                           name="2")
+                                            Size("200 MiB"),
+                                            disks=self.blivet.disks[:],
+                                            raid_level=self.level,
+                                            label="v090",
+                                            name="2")
         device.metadata_version = "0.90"
 
         device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
-                                           Size("200 MiB"),
-                                           disks=self.blivet.disks[:],
-                                           raid_level=self.level,
-                                           label="v1",
-                                           name="one")
+                                            Size("200 MiB"),
+                                            disks=self.blivet.disks[:],
+                                            raid_level=self.level,
+                                            label="v1",
+                                            name="one")
         device.metadata_version = "1.0"
 
         device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
-                                           Size("200 MiB"),
-                                           disks=self.blivet.disks[:],
-                                           raid_level=self.level,
-                                           label="v11",
-                                           name="oneone")
+                                            Size("200 MiB"),
+                                            disks=self.blivet.disks[:],
+                                            raid_level=self.level,
+                                            label="v11",
+                                            name="oneone")
         device.metadata_version = "1.1"
 
         device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
-                                           Size("200 MiB"),
-                                           disks=self.blivet.disks[:],
-                                           raid_level=self.level,
-                                           label="v12",
-                                           name="onetwo")
+                                            Size("200 MiB"),
+                                            disks=self.blivet.disks[:],
+                                            raid_level=self.level,
+                                            label="v12",
+                                            name="onetwo")
         device.metadata_version = "1.2"
 
         device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
-                                           Size("200 MiB"),
-                                           disks=self.blivet.disks[:],
-                                           raid_level=self.level,
-                                           label="vdefault",
-                                           name="default")
+                                            Size("200 MiB"),
+                                            disks=self.blivet.disks[:],
+                                            raid_level=self.level,
+                                            label="vdefault",
+                                            name="default")
 
 
 @unittest.skip("temporarily disabled due to mdadm issues")
@@ -323,11 +323,11 @@ class LVMOnMDTestCase(BlivetResetTestCase):
 
     def _set_up_storage(self):
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                                  Size("200 MiB"),
-                                  disks=self.blivet.disks[:],
-                                  container_raid_level="raid1",
-                                  fstype="swap")
+                                   Size("200 MiB"),
+                                   disks=self.blivet.disks[:],
+                                   container_raid_level="raid1",
+                                   fstype="swap")
         self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
-                                  None,
-                                  disks=self.blivet.disks[:],
-                                  container_raid_level="raid1")
+                                   None,
+                                   disks=self.blivet.disks[:],
+                                   container_raid_level="raid1")
diff --git a/tests/formats_test/disklabel_test.py b/tests/formats_test/disklabel_test.py
index 4c1a317..a4f92cd 100644
--- a/tests/formats_test/disklabel_test.py
+++ b/tests/formats_test/disklabel_test.py
@@ -36,11 +36,11 @@ def test_get_alignment(self):
 
         # expected end alignments
         optimal_end_alignment = parted.Alignment(
-                                        grainSize=optimal_alignment.grainSize,
-                                        offset=-1)
+            grainSize=optimal_alignment.grainSize,
+            offset=-1)
         minimal_end_alignment = parted.Alignment(
-                                        grainSize=minimal_alignment.grainSize,
-                                        offset=-1)
+            grainSize=minimal_alignment.grainSize,
+            offset=-1)
 
         # make sure the private methods all return the expected values
         self.assertEqual(dl._get_disk_label_alignment(), disklabel_alignment)
@@ -49,7 +49,7 @@ def test_get_alignment(self):
 
         # validate result when passing a start alignment to get_end_alignment
         self.assertEqual(dl.get_end_alignment(alignment=optimal_alignment),
-                                            optimal_end_alignment)
+                         optimal_end_alignment)
         self.assertEqual(dl.get_end_alignment(alignment=minimal_alignment),
                          minimal_end_alignment)
 
diff --git a/tests/formats_test/fslabeling.py b/tests/formats_test/fslabeling.py
index 47d817a..d835489 100644
--- a/tests/formats_test/fslabeling.py
+++ b/tests/formats_test/fslabeling.py
@@ -16,10 +16,10 @@ class LabelingAsRoot(loopbackedtestcase.LoopBackedTestCase):
     """
 
     _fs_class = abc.abstractproperty(
-       doc="The class of the filesystem being tested on.")
+        doc="The class of the filesystem being tested on.")
 
     _invalid_label = abc.abstractproperty(
-       doc="A label which is invalid for this filesystem.")
+        doc="A label which is invalid for this filesystem.")
 
     def __init__(self, methodName='run_test'):
         super(LabelingAsRoot, self).__init__(methodName=methodName, device_spec=[Size("100 MiB")])
diff --git a/tests/formats_test/fstesting.py b/tests/formats_test/fstesting.py
index 407b051..2c86911 100644
--- a/tests/formats_test/fstesting.py
+++ b/tests/formats_test/fstesting.py
@@ -25,7 +25,7 @@ def can_resize(an_fs):
 class FSAsRoot(loopbackedtestcase.LoopBackedTestCase):
 
     _fs_class = abc.abstractproperty(
-       doc="The class of the filesystem being tested on.")
+        doc="The class of the filesystem being tested on.")
 
     _DEVICE_SIZE = Size("100 MiB")
 
diff --git a/tests/formats_test/init_test.py b/tests/formats_test/init_test.py
index cf9a736..6d35920 100644
--- a/tests/formats_test/init_test.py
+++ b/tests/formats_test/init_test.py
@@ -11,23 +11,23 @@ def test_formats_methods(self):
         # get_device_format_class
         ##
         format_pairs = {
-           None: formats.DeviceFormat,
-           "bogus": None,
-           "biosboot": formats.biosboot.BIOSBoot,
-           "BIOS Boot": formats.biosboot.BIOSBoot,
-           "nodev": formats.fs.NoDevFS
-           }
+            None: formats.DeviceFormat,
+            "bogus": None,
+            "biosboot": formats.biosboot.BIOSBoot,
+            "BIOS Boot": formats.biosboot.BIOSBoot,
+            "nodev": formats.fs.NoDevFS
+        }
         format_names = format_pairs.keys()
         format_values = [format_pairs[k] for k in format_names]
 
         self.assertEqual(
-           [formats.get_device_format_class(x) for x in format_names],
-           format_values)
+            [formats.get_device_format_class(x) for x in format_names],
+            format_values)
 
         # A DeviceFormat object is returned if lookup by name fails
         for name in format_names:
             self.assertIs(formats.get_format(name).__class__,
-               formats.DeviceFormat if format_pairs[name] is None else format_pairs[name])
+                          formats.DeviceFormat if format_pairs[name] is None else format_pairs[name])
         # Consecutively constructed DeviceFormat objects have consecutive ids
         names = [key for key in format_pairs.keys() if format_pairs[key] is not None]
         objs = [formats.get_format(name) for name in names]
diff --git a/tests/imagebackedtestcase.py b/tests/imagebackedtestcase.py
index c070991..01e2929 100644
--- a/tests/imagebackedtestcase.py
+++ b/tests/imagebackedtestcase.py
@@ -32,7 +32,7 @@ class ImageBackedTestCase(unittest.TestCase):
     """ Whether or not to create a disklabel on the disks. """
 
     disks = {"disk1": Size("2 GiB"),
-              "disk2": Size("2 GiB")}
+             "disk2": Size("2 GiB")}
     """ The names and sizes of the disk images to create/use. """
 
     def set_up_disks(self):
diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py
index 05ed22e..3d836bd 100644
--- a/tests/partitioning_test.py
+++ b/tests/partitioning_test.py
@@ -40,7 +40,7 @@
 class PartitioningTestCase(unittest.TestCase):
 
     def get_disk(self, disk_type, primary_count=0,
-                has_extended=False, logical_count=0):
+                 has_extended=False, logical_count=0):
         """ Return a mock representing a parted.Disk. """
         disk = Mock()
 
@@ -86,28 +86,28 @@ def test_next_partition_type(self):
 
         # four primaries and an extended, available logical -> logical
         disk = self.get_disk(disk_type="dos", primary_count=4, has_extended=True,
-                            logical_count=9)
+                             logical_count=9)
         self.assertEqual(get_next_partition_type(disk), parted.PARTITION_LOGICAL)
 
         # four primaries and an extended, no available logical -> None
         disk = self.get_disk(disk_type="dos", primary_count=4, has_extended=True,
-                            logical_count=11)
+                             logical_count=11)
         self.assertEqual(get_next_partition_type(disk), None)
 
         # four primaries and no extended -> None
         disk = self.get_disk(disk_type="dos", primary_count=4,
-                            has_extended=False)
+                             has_extended=False)
         self.assertEqual(get_next_partition_type(disk), None)
 
         # free primary slot, extended, no free logical slot -> primary
         disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True,
-                            logical_count=11)
+                             logical_count=11)
         self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
 
         # free primary slot, extended, no free logical slot w/ no_primary
         # -> None
         disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True,
-                            logical_count=11)
+                             logical_count=11)
         self.assertEqual(get_next_partition_type(disk, no_primary=True), None)
 
         #
@@ -154,7 +154,7 @@ def test_add_partition(self):
             #
             self.assertEqual(len(disk.format.partitions), 0)
             part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
-                                Size("10 MiB") - Size(37))
+                                 Size("10 MiB") - Size(37))
             self.assertEqual(len(disk.format.partitions), 1)
 
             # an unaligned size still yields an aligned partition
@@ -184,7 +184,7 @@ def test_add_partition(self):
                 length = 4096  # 2 MiB
                 size = Size(sector_size * length)
                 part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
-                                    size)
+                                     size)
                 self.assertEqual(part.geometry.length, length)
                 self.assertEqual(optimal.isAligned(free, part.geometry.start),
                                  False)
@@ -204,7 +204,7 @@ def test_add_partition(self):
             start_sector = 5003
             end_sector = 15001
             part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
-                                None, start_sector, end_sector)
+                                 None, start_sector, end_sector)
             self.assertEqual(len(disk.format.partitions), 1)
 
             # start and end sectors are exactly as specified
@@ -218,18 +218,18 @@ def test_add_partition(self):
             # fail: add a logical partition to a primary free region
             #
             with self.assertRaisesRegex(parted.PartitionException,
-                                         "no extended partition"):
+                                        "no extended partition"):
                 part = add_partition(disk.format, free, parted.PARTITION_LOGICAL,
-                                    Size("10 MiB"))
+                                     Size("10 MiB"))
 
             # add an extended partition to the disk
             placeholder = add_partition(disk.format, free,
-                                       parted.PARTITION_NORMAL, Size("10 MiB"))
+                                        parted.PARTITION_NORMAL, Size("10 MiB"))
             all_free = disk.format.parted_disk.getFreeSpaceRegions()
             add_partition(disk.format, all_free[1],
-                         parted.PARTITION_EXTENDED, Size("30 MiB"),
-                         alignment.alignUp(all_free[1],
-                                           placeholder.geometry.end))
+                          parted.PARTITION_EXTENDED, Size("30 MiB"),
+                          alignment.alignUp(all_free[1],
+                                            placeholder.geometry.end))
 
             disk.format.remove_partition(placeholder)
             self.assertEqual(len(disk.format.partitions), 1)
@@ -239,8 +239,8 @@ def test_add_partition(self):
             # add a logical partition to an extended free regions
             #
             part = add_partition(disk.format, all_free[1],
-                                parted.PARTITION_LOGICAL,
-                                Size("10 MiB"), all_free[1].start)
+                                 parted.PARTITION_LOGICAL,
+                                 Size("10 MiB"), all_free[1].start)
             self.assertEqual(part.type, parted.PARTITION_LOGICAL)
 
             disk.format.remove_partition(part)
@@ -251,8 +251,8 @@ def test_add_partition(self):
             #
             with self.assertRaisesRegex(parted.PartitionException, "overlap"):
                 part = add_partition(disk.format, all_free[1],
-                                    parted.PARTITION_NORMAL,
-                                    Size("10 MiB"), all_free[1].start)
+                                     parted.PARTITION_NORMAL,
+                                     Size("10 MiB"), all_free[1].start)
 
     def test_chunk(self):
         dev1 = Mock()
@@ -329,7 +329,7 @@ def test_disk_chunk1(self):
             partitions = [p1, p2]
             free = get_free_regions([disk])
             self.assertEqual(len(free), 1,
-                              "free region count %d not expected" % len(free))
+                             "free region count %d not expected" % len(free))
 
             b = Mock()
             allocate_partitions(b, disks, partitions, free)
@@ -392,7 +392,7 @@ def test_disk_chunk2(self):
             partitions = [p1, p2, p3, p4, p5]
             free = get_free_regions([disk])
             self.assertEqual(len(free), 1,
-                              "free region count %d not expected" % len(free))
+                             "free region count %d not expected" % len(free))
 
             b = Mock()
             allocate_partitions(b, disks, partitions, free)
@@ -543,7 +543,7 @@ def test_vgchunk_with_cache(self):
         # LVMVolumeGroupDevice.extents) -- 1024 MiB for caches, 8 MiB for the
         # pmspare LV
         pv2 = StorageDevice("pv2", size=Size("1033 MiB"),
-                           fmt=get_format("lvmpv"))
+                            fmt=get_format("lvmpv"))
         vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
 
         cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
@@ -588,7 +588,7 @@ def test_vgchunk_with_cache_pvfree(self):
         # need (including the 8MiB pmspare LV) and which should thus be split
         # into the LVs
         pv2 = StorageDevice("pv2", size=Size("1077 MiB"),
-                           fmt=get_format("lvmpv"))
+                            fmt=get_format("lvmpv"))
         vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
 
         cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
@@ -632,7 +632,7 @@ def test_align_free_regions(self):
         disk = Mock()
         disk.format.alignment.grainSize = 2048
         disk.format.parted_disk.getFreeSpaceRegions.return_value = [Mock(start=1, end=2049, length=2049),
-                                                                   Mock(start=1, end=2048, length=2048)]
+                                                                    Mock(start=1, end=2048, length=2048)]
 
         free = get_free_regions([disk])
         self.assertEqual(free[0].length, 2049)
@@ -709,7 +709,7 @@ def test_explicit_extended_partitions(self):
         """ Verify that explicitly requested extended partitions work. """
         disk = self.blivet.disks[0]
         p1 = self.blivet.new_partition(size=Size("500 MiB"),
-                                      part_type=parted.PARTITION_EXTENDED)
+                                       part_type=parted.PARTITION_EXTENDED)
         self.blivet.create_device(p1)
         do_partitioning(self.blivet)
 
diff --git a/tests/pylint/runpylint.py b/tests/pylint/runpylint.py
index bc836a6..d7bd01c 100755
--- a/tests/pylint/runpylint.py
+++ b/tests/pylint/runpylint.py
@@ -11,29 +11,29 @@ def __init__(self):
         PocketLintConfig.__init__(self)
 
         self.falsePositives = [FalsePositive(r"BTRFSVolumeDevice._create: Instance of 'DeviceFormat' has no 'label' member"),
-                                FalsePositive(r"Catching an exception which doesn't inherit from BaseException: (BlockDev|DM|Crypto|Swap|LVM|Btrfs|MDRaid|G)Error$"),
-                                FalsePositive(r"Function 'run_program' has no 'called' member"),
-                                FalsePositive(r"(PartitioningTestCase|PartitionDeviceTestCase).*: Instance of 'DeviceFormat' has no .* member"),
-                                FalsePositive(r"Instance of 'int' has no .* member"),
-                                FalsePositive(r"Instance of 'LUKSDevice' has no .* member"),
-                                FalsePositive(r"Method 'do_task' is abstract in class 'Task' but is not overridden"),
-                                FalsePositive(r"Method 'do_task' is abstract in class 'UnimplementedTask' but is not overridden"),
-                                FalsePositive(r"No value for argument 'member_count' in unbound method call$"),
-                                FalsePositive(r"No value for argument 'smallest_member_size' in unbound method call$")
-                              ]
+                               FalsePositive(r"Catching an exception which doesn't inherit from BaseException: (BlockDev|DM|Crypto|Swap|LVM|Btrfs|MDRaid|G)Error$"),
+                               FalsePositive(r"Function 'run_program' has no 'called' member"),
+                               FalsePositive(r"(PartitioningTestCase|PartitionDeviceTestCase).*: Instance of 'DeviceFormat' has no .* member"),
+                               FalsePositive(r"Instance of 'int' has no .* member"),
+                               FalsePositive(r"Instance of 'LUKSDevice' has no .* member"),
+                               FalsePositive(r"Method 'do_task' is abstract in class 'Task' but is not overridden"),
+                               FalsePositive(r"Method 'do_task' is abstract in class 'UnimplementedTask' but is not overridden"),
+                               FalsePositive(r"No value for argument 'member_count' in unbound method call$"),
+                               FalsePositive(r"No value for argument 'smallest_member_size' in unbound method call$")
+                               ]
 
     @property
     def disabledOptions(self):
         return ["W0105",           # String statement has no effect
-                 "W0110",           # map/filter on lambda could be replaced by comprehension
-                 "W0141",           # Used builtin function %r
-                 "W0142",           # Used * or ** magic
-                 "W0212",           # Access to a protected member of a client class
-                 "W0511",           # Used when a warning note as FIXME or XXX is detected.
-                 "W0603",           # Using the global statement
-                 "W0614",           # Unused import %s from wildcard import
-                 "I0011",           # Locally disabling %s
-               ]
+                "W0110",           # map/filter on lambda could be replaced by comprehension
+                "W0141",           # Used builtin function %r
+                "W0142",           # Used * or ** magic
+                "W0212",           # Access to a protected member of a client class
+                "W0511",           # Used when a warning note as FIXME or XXX is detected.
+                "W0603",           # Using the global statement
+                "W0614",           # Unused import %s from wildcard import
+                "I0011",           # Locally disabling %s
+                ]
 
 if __name__ == "__main__":
     conf = BlivetLintConfig()
diff --git a/tests/tsort_test.py b/tests/tsort_test.py
index 1d34957..16f2a8c 100644
--- a/tests/tsort_test.py
+++ b/tests/tsort_test.py
@@ -46,7 +46,7 @@ def check_order(order, graph):
 
         # verify output list is of the correct length
         self.assertFalse(len(order) != len(graph['items']),
-                    "sorted list length is incorrect")
+                         "sorted list length is incorrect")
 
         # verify that all ordering constraints are satisfied
         self.assertTrue(check_order(order, graph),


-- 
To view this commit on github, visit https://github.com/rhinstaller/blivet/commit/52d761defbe5b2c9c9ab38da30fb2bcc5f5d64a3


More information about the anaconda-patches mailing list