[master 1/4] Make all names conform to PEP8.

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


From: David Lehman <dlehman at redhat.com>

Several conversions were done, eg:

  auto_part -> autopart
  autopartition -> autopart
  file_system -> filesystem
  multi_path -> multipath
  boot_loader -> bootloader
  sub_volume -> subvolume
---
 Makefile                                     |   2 +-
 blivet/__init__.py                           |  40 +-
 blivet/actionlist.py                         |  54 +--
 blivet/arch.py                               |  84 ++--
 blivet/autopart.py                           | 180 +++----
 blivet/blivet.py                             | 676 +++++++++++++--------------
 blivet/callbacks.py                          |   2 +-
 blivet/deviceaction.py                       | 244 +++++-----
 blivet/devicefactory.py                      | 174 +++----
 blivet/devicelibs/btrfs.py                   |   2 +-
 blivet/devicelibs/mdraid.py                  |   4 +-
 blivet/devicelibs/raid.py                    |  36 +-
 blivet/devices/__init__.py                   |   2 +-
 blivet/devices/btrfs.py                      | 250 +++++-----
 blivet/devices/container.py                  |  34 +-
 blivet/devices/device.py                     |  62 +--
 blivet/devices/disk.py                       | 102 ++--
 blivet/devices/dm.py                         |  86 ++--
 blivet/devices/file.py                       |  20 +-
 blivet/devices/lib.py                        |  30 +-
 blivet/devices/loop.py                       |  24 +-
 blivet/devices/luks.py                       |  32 +-
 blivet/devices/lvm.py                        | 584 +++++++++++------------
 blivet/devices/md.py                         | 310 ++++++------
 blivet/devices/nfs.py                        |   8 +-
 blivet/devices/nodev.py                      |  16 +-
 blivet/devices/optical.py                    |   6 +-
 blivet/devices/partition.py                  | 530 ++++++++++-----------
 blivet/devices/raid.py                       |  22 +-
 blivet/devices/storage.py                    | 291 ++++++------
 blivet/devicetree.py                         | 294 ++++++------
 blivet/fcoe.py                               |  20 +-
 blivet/formats/__init__.py                   | 125 ++---
 blivet/formats/biosboot.py                   |   8 +-
 blivet/formats/disklabel.py                  | 250 +++++-----
 blivet/formats/dmraid.py                     |  14 +-
 blivet/formats/fs.py                         | 521 ++++++++++-----------
 blivet/formats/luks.py                       |  94 ++--
 blivet/formats/lvmpv.py                      |  50 +-
 blivet/formats/mdraid.py                     |  20 +-
 blivet/formats/multipath.py                  |   8 +-
 blivet/formats/prepboot.py                   |   8 +-
 blivet/formats/swap.py                       |  24 +-
 blivet/iscsi.py                              |  60 +--
 blivet/mounts.py                             |  30 +-
 blivet/osinstall.py                          | 418 ++++++++---------
 blivet/partitioning.py                       | 470 +++++++++----------
 blivet/partspec.py                           |  20 +-
 blivet/platform.py                           | 136 +++---
 blivet/populator.py                          | 558 +++++++++++-----------
 blivet/size.py                               |  56 +--
 blivet/tasks/availability.py                 |  42 +-
 blivet/tasks/fsck.py                         |  32 +-
 blivet/tasks/fsinfo.py                       |   8 +-
 blivet/tasks/fslabeling.py                   |  18 +-
 blivet/tasks/fsminsize.py                    |  66 +--
 blivet/tasks/fsmkfs.py                       |  26 +-
 blivet/tasks/fsmount.py                      |  56 +--
 blivet/tasks/fsreadlabel.py                  |  12 +-
 blivet/tasks/fsresize.py                     |  30 +-
 blivet/tasks/fssize.py                       |  24 +-
 blivet/tasks/fssync.py                       |  18 +-
 blivet/tasks/fswritelabel.py                 |   8 +-
 blivet/tasks/task.py                         |  26 +-
 blivet/udev.py                               |   8 +-
 blivet/util.py                               |  12 +-
 blivet/zfcp.py                               |  62 ++-
 doc/conf.py                                  |  10 +-
 examples/factory.py                          |  20 +-
 examples/lvm.py                              |  34 +-
 examples/partitioning.py                     |  30 +-
 tests/action_test.py                         | 544 ++++++++++-----------
 tests/clearpart_test.py                      | 128 ++---
 tests/devicefactory_test.py                  | 202 ++++----
 tests/devicelibs_test/edd_test.py            |   8 +-
 tests/devicelibs_test/mdraid_test.py         |  14 +-
 tests/devicelibs_test/raid_test.py           |  26 +-
 tests/devices_test/dependencies_test.py      |  32 +-
 tests/devices_test/device_names_test.py      |  18 +-
 tests/devices_test/device_packages_test.py   |   8 +-
 tests/devices_test/device_properties_test.py | 464 +++++++++---------
 tests/devices_test/lvm_test.py               |  72 +--
 tests/devices_test/network_test.py           |  12 +-
 tests/devices_test/partition_test.py         | 130 +++---
 tests/devices_test/size_test.py              |  40 +-
 tests/devicetree_test.py                     |  88 ++--
 tests/formats_test/device_test.py            |   4 +-
 tests/formats_test/disklabel_test.py         |  40 +-
 tests/formats_test/fs_test.py                |  30 +-
 tests/formats_test/fslabeling.py             |  86 ++--
 tests/formats_test/fstesting.py              | 236 +++++-----
 tests/formats_test/init_test.py              |   6 +-
 tests/formats_test/labeling_test.py          |  56 +--
 tests/formats_test/selinux_test.py           |  12 +-
 tests/imagebackedtestcase.py                 |  20 +-
 tests/loopbackedtestcase.py                  |  54 +--
 tests/parentlist_test.py                     |   4 +-
 tests/partitioning_test.py                   | 292 ++++++------
 tests/pylint/runpylint.py                    |   4 +-
 tests/size_test.py                           | 320 ++++++-------
 tests/storagetestcase.py                     | 118 ++---
 tests/tasks_test/basic_tests.py              |  18 +-
 tests/tsort_test.py                          |  10 +-
 tests/util_test.py                           |   2 +-
 104 files changed, 5364 insertions(+), 5367 deletions(-)

diff --git a/Makefile b/Makefile
index 047a2dd..11de95e 100644
--- a/Makefile
+++ b/Makefile
@@ -56,7 +56,7 @@ install-requires:
 	@echo "*** Installing the dependencies required for testing and analysis ***"
 	dnf install -y $(TEST_DEPENDENCIES)
 
-test: check-requires
+test: #check-requires
 	@echo "*** Running unittests with $(PYTHON) ***"
 	PYTHONPATH=.:tests/ $(PYTHON) -m unittest discover -v -s tests/ -p '*_test.py'
 
diff --git a/blivet/__init__.py b/blivet/__init__.py
index 37094c2..950fc40 100644
--- a/blivet/__init__.py
+++ b/blivet/__init__.py
@@ -31,9 +31,9 @@
 ##
 iutil = None
 ROOT_PATH = '/'
-_storageRoot = ROOT_PATH
+_storage_root = ROOT_PATH
 _sysroot = ROOT_PATH
-shortProductName = 'blivet'
+short_product_name = 'blivet'
 ERROR_RAISE = 0
 
 class ErrorHandler(object):
@@ -41,7 +41,7 @@ def cb(self, exn):
         # pylint: disable=unused-argument
         return ERROR_RAISE
 
-errorHandler = ErrorHandler()
+error_handler = ErrorHandler()
 
 get_bootloader = lambda: None
 
@@ -77,7 +77,7 @@ def cb(self, exn):
 # initialize the libblockdev library
 from gi.repository import GLib
 from gi.repository import BlockDev as blockdev
-if arch.isS390():
+if arch.is_s390():
     _REQUESTED_PLUGIN_NAMES = set(("lvm", "btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm", "s390"))
 else:
     _REQUESTED_PLUGIN_NAMES = set(("lvm", "btrfs", "swap", "crypto", "loop", "mdraid", "mpath", "dm"))
@@ -98,34 +98,34 @@ def enable_installer_mode():
     """ Configure the module for use by anaconda (OS installer). """
     global iutil
     global ROOT_PATH
-    global _storageRoot
+    global _storage_root
     global _sysroot
-    global shortProductName
+    global short_product_name
     global get_bootloader
-    global errorHandler
+    global error_handler
     global ERROR_RAISE
 
     from pyanaconda import iutil # pylint: disable=redefined-outer-name
-    from pyanaconda.constants import shortProductName # pylint: disable=redefined-outer-name
-    from pyanaconda.bootloader import get_bootloader # pylint: disable=redefined-outer-name
-    from pyanaconda.errors import errorHandler # pylint: disable=redefined-outer-name
+    from pyanaconda.constants import shortProductName as short_product_name # pylint: disable=redefined-outer-name
+    from pyanaconda.bootloader import getBootloader as get_bootloader # pylint: disable=redefined-outer-name
+    from pyanaconda.errors import errorHandler as error_handler # pylint: disable=redefined-outer-name
     from pyanaconda.errors import ERROR_RAISE # pylint: disable=redefined-outer-name
 
     if hasattr(iutil, 'getTargetPhysicalRoot'):
         # For anaconda versions > 21.43
-        _storageRoot = iutil.getTargetPhysicalRoot() # pylint: disable=no-name-in-module
+        _storage_root = iutil.getTargetPhysicalRoot() # pylint: disable=no-name-in-module
         _sysroot = iutil.getSysroot()
     else:
         # For prior anaconda versions
         from pyanaconda.constants import ROOT_PATH # pylint: disable=redefined-outer-name,no-name-in-module
-        _storageRoot = _sysroot = ROOT_PATH
+        _storage_root = _sysroot = ROOT_PATH
 
     from pyanaconda.anaconda_log import program_log_lock
     util.program_log_lock = program_log_lock
 
     flags.installer_mode = True
 
-def getSysroot():
+def get_sysroot():
     """Returns the path to the target OS installation.
 
     For traditional installations, this is the same as the physical
@@ -133,23 +133,23 @@ def getSysroot():
     """
     return _sysroot
 
-def getTargetPhysicalRoot():
+def get_target_physical_root():
     """Returns the path to the "physical" storage root.
 
     This may be distinct from the sysroot, which could be a
     chroot-type subdirectory of the physical root.  This is used for
     example by all OSTree-based installations.
     """
-    return _storageRoot
+    return _storage_root
 
-def setSysroot(storageRoot, sysroot=None):
+def set_sysroot(storage_root, sysroot=None):
     """Change the OS root path.
-       :param storageRoot: The root of physical storage
-       :param sysroot: An optional chroot subdirectory of storageRoot
+       :param storage_root: The root of physical storage
+       :param sysroot: An optional chroot subdirectory of storage_root
     """
-    global _storageRoot
+    global _storage_root
     global _sysroot
-    _storageRoot = _sysroot = storageRoot
+    _storage_root = _sysroot = storage_root
     if sysroot is not None:
         _sysroot = sysroot
 
diff --git a/blivet/actionlist.py b/blivet/actionlist.py
index 97d5761..29af89b 100644
--- a/blivet/actionlist.py
+++ b/blivet/actionlist.py
@@ -150,7 +150,7 @@ def sort(self):
             actions.append(self._actions[idx])
         self._actions = actions
 
-    def _preProcess(self, devices=None):
+    def _pre_process(self, devices=None):
         """ Prepare the action queue for execution. """
         devices = devices or []
         for action in self._actions:
@@ -159,7 +159,7 @@ def _preProcess(self, devices=None):
         log.info("pruning action queue...")
         self.prune()
 
-        problematic = self._findActiveDevicesOnActionDisks(devices=devices)
+        problematic = self._find_active_devices_on_action_disks(devices=devices)
         if problematic:
             if flags.installer_mode:
                 for device in devices:
@@ -178,18 +178,18 @@ def _preProcess(self, devices=None):
         log.info("resetting parted disks...")
         for device in devices:
             if device.partitioned:
-                device.format.resetPartedDisk()
+                device.format.reset_parted_disk()
 
-            if device.originalFormat.type == "disklabel" and \
-               device.originalFormat != device.format:
-                device.originalFormat.resetPartedDisk()
+            if device.original_format.type == "disklabel" and \
+               device.original_format != device.format:
+                device.original_format.reset_parted_disk()
 
-        # Call preCommitFixup on all devices, including those we're going to
+        # 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.isDestroy and a.isDevice]
+                                                if a.is_destroy and a.is_device]
         for device in fixup_devices:
-            device.preCommitFixup()
+            device.pre_commit_fixup()
 
         # setup actions to create any extended partitions we added
         #
@@ -202,7 +202,7 @@ def _preProcess(self, devices=None):
         #     directly here.
         for device in devices:
             if isinstance(device, PartitionDevice) and \
-               device.isExtended and not device.exists and \
+               device.is_extended and not device.exists and \
                not self.find(device=device, action_type="create"):
                 # don't properly register the action since the device is
                 # already in the tree
@@ -217,25 +217,25 @@ def _preProcess(self, devices=None):
             log.debug("action: %s", action)
 
             # Remove lvm filters for devices we are operating on
-            for device in (d for d in devices if d.dependsOn(action.device)):
+            for device in (d for d in devices if d.depends_on(action.device)):
                 lvm.lvm_cc_removeFilterRejectRegexp(device.name)
 
-    def _postProcess(self, devices=None):
+    def _post_process(self, devices=None):
         """ Clean up relics from action queue execution. """
         devices = devices or []
-        # removal of partitions makes use of originalFormat, so it has to stay
+        # removal of partitions makes use of original_format, so it has to stay
         # up to date in case of multiple passes through this method
         for disk in (d for d in devices if d.partitioned):
-            disk.format.updateOrigPartedDisk()
-            disk.originalFormat = copy.deepcopy(disk.format)
+            disk.format.update_orig_parted_disk()
+            disk.original_format = copy.deepcopy(disk.format)
 
         # now we have to update the parted partitions of all devices so they
         # match the parted disks we just updated
         for partition in (d for d in devices if isinstance(d, PartitionDevice)):
-            pdisk = partition.disk.format.partedDisk
-            partition.partedPartition = pdisk.getPartitionByPath(partition.path)
+            pdisk = partition.disk.format.parted_disk
+            partition.parted_partition = pdisk.getPartitionByPath(partition.path)
 
-    def _findActiveDevicesOnActionDisks(self, devices=None):
+    def _find_active_devices_on_action_disks(self, devices=None):
         """ Return a list of devices using the disks we plan to change. """
         # Find out now if there are active devices using partitions on disks
         # whose disklabels we are going to change. If there are, do not proceed.
@@ -243,7 +243,7 @@ def _findActiveDevicesOnActionDisks(self, devices=None):
         disks = []
         for action in self._actions:
             disk = None
-            if action.isFormat and action.format.type == "disklabel":
+            if action.is_format and action.format.type == "disklabel":
                 disk = action.device
 
             if disk is not None and disk not in disks:
@@ -251,17 +251,17 @@ def _findActiveDevicesOnActionDisks(self, devices=None):
 
         active = []
         for dev in devices:
-            if dev.status and not dev.isDisk and \
+            if dev.status and not dev.is_disk and \
                not isinstance(dev, PartitionDevice):
                 active.append(dev)
 
-            elif dev.format.status and not dev.isDisk:
+            elif dev.format.status and not dev.is_disk:
                 active.append(dev)
 
         devices = [a.name for a in active if any(d in disks for d in a.disks)]
         return devices
 
-    def process(self, callbacks=None, devices=None, dryRun=None):
+    def process(self, callbacks=None, devices=None, dry_run=None):
         """
         Execute all registered actions.
 
@@ -271,11 +271,11 @@ def process(self, callbacks=None, devices=None, dryRun=None):
 
         """
         devices = devices or []
-        self._preProcess(devices=devices)
+        self._pre_process(devices=devices)
 
         for action in self._actions[:]:
             log.info("executing action: %s", action)
-            if not dryRun:
+            if not dry_run:
                 try:
                     action.execute(callbacks)
                 except DiskLabelCommitError:
@@ -284,7 +284,7 @@ def process(self, callbacks=None, devices=None, dryRun=None):
                     # include deps no longer in the tree due to pending removal
                     devs = devices + [a.device for a in self._actions]
                     for dep in set(devs):
-                        if dep.exists and dep.dependsOn(action.device.disk):
+                        if dep.exists and dep.depends_on(action.device.disk):
                             dep.teardown(recursive=True)
 
                     action.execute(callbacks)
@@ -292,9 +292,9 @@ def process(self, callbacks=None, devices=None, dryRun=None):
                 for device in devices:
                     # make sure we catch any renumbering parted does
                     if device.exists and isinstance(device, PartitionDevice):
-                        device.updateName()
+                        device.update_name()
                         device.format.device = device.path
 
                 self._completed_actions.append(self._actions.pop(0))
 
-        self._postProcess(devices=devices)
+        self._post_process(devices=devices)
diff --git a/blivet/arch.py b/blivet/arch.py
index dd4a9f3..ed81438 100644
--- a/blivet/arch.py
+++ b/blivet/arch.py
@@ -43,18 +43,18 @@
 # DMI information paths
 DMI_CHASSIS_VENDOR = "/sys/class/dmi/id/chassis_vendor"
 
-def getPPCMachine():
+def get_ppc_machine():
     """
     :return: The PPC machine type, or None if not PPC.
     :rtype: string
 
     """
-    if not isPPC():
+    if not is_ppc():
         return None
 
     # ppc machine hash
     # Note: This is a substring match!
-    ppcType = { 'Mac'      : 'PMac',
+    ppc_type = { 'Mac'      : 'PMac',
                 'Book'     : 'PMac',
                 'CHRP'     : 'pSeries',
                 'CHRP IBM' : 'pSeries', # @TODO the CHRP entry above should match this
@@ -89,7 +89,7 @@ def getPPCMachine():
         if part is None:
             continue
 
-        for _type in ppcType.items():
+        for _type in ppc_type.items():
             if _type[0] in part:
                 return _type[1]
 
@@ -97,15 +97,15 @@ def getPPCMachine():
 
     return None
 
-def getPPCMacID():
+def get_ppc_mac_id():
     """
     :return: The powermac machine type, or None if not PPC or a powermac.
     :rtype: string
 
     """
-    if not isPPC():
+    if not is_ppc():
         return None
-    if getPPCMachine() != "PMac":
+    if get_ppc_machine() != "PMac":
         return None
 
     with open('/proc/cpuinfo', 'r') as f:
@@ -117,7 +117,7 @@ def getPPCMacID():
     log.warning("No Power Mac machine id")
     return None
 
-def getPPCMacGen():
+def get_ppc_mac_gen():
     """
     :return: The PPC generation, or None if not PPC or a powermac.
     :rtype: string
@@ -125,11 +125,11 @@ def getPPCMacGen():
     """
     # XXX: should NuBus be here?
     # Note: This is a substring match!
-    pmacGen = ['OldWorld', 'NewWorld', 'NuBus']
+    pmac_gen = ['OldWorld', 'NewWorld', 'NuBus']
 
-    if not isPPC():
+    if not is_ppc():
         return None
-    if getPPCMachine() != "PMac":
+    if get_ppc_machine() != "PMac":
         return None
 
     gen = None
@@ -143,22 +143,22 @@ def getPPCMacGen():
         log.warning("Unable to find pmac-generation")
         return None
 
-    for _type in pmacGen:
+    for _type in pmac_gen:
         if _type in gen:
             return _type
 
     log.warning("Unknown Power Mac generation: %s", gen)
     return None
 
-def getPPCMacBook():
+def get_ppc_mac_book():
     """
-    :return: True if the hardware is an iBook or PowerBook, False otherwise.
+    :return: True if the hardware is an i_book or PowerBook, False otherwise.
     :rtype: string
 
     """
-    if not isPPC():
+    if not is_ppc():
         return False
-    if getPPCMachine() != "PMac":
+    if get_ppc_machine() != "PMac":
         return False
 
     #@TBD - Search for 'book' anywhere in cpuinfo? Shouldn't this be more restrictive?
@@ -169,7 +169,7 @@ def getPPCMacBook():
 
     return False
 
-def isAARCH64():
+def is_aarch64():
     """
     :return: True if the hardware supports Aarch64, False otherwise.
     :rtype: boolean
@@ -177,33 +177,33 @@ def isAARCH64():
     """
     return os.uname()[4] == 'aarch64'
 
-def getARMMachine():
+def get_arm_machine():
     """
     :return: The ARM processor variety type, or None if not ARM.
     :rtype: string
 
     """
-    if not isARM():
+    if not is_arm():
         return None
 
     if flags.arm_platform:
         return flags.arm_platform
 
-    armMachine = os.uname()[2].rpartition('.' )[2]
+    arm_machine = os.uname()[2].rpartition('.' )[2]
 
-    if armMachine.startswith('arm'):
+    if arm_machine.startswith('arm'):
         # @TBD - Huh? Don't you want the arm machine name here?
         return None
     else:
-        return armMachine
+        return arm_machine
 
-def isCell():
+def is_cell():
     """
     :return: True if the hardware is the Cell platform, False otherwise.
     :rtype: boolean
 
     """
-    if not isPPC():
+    if not is_ppc():
         return False
 
     with open('/proc/cpuinfo', 'r') as f:
@@ -213,13 +213,13 @@ def isCell():
 
     return False
 
-def isMactel():
+def is_mactel():
     """
     :return: True if the hardware is an Intel-based Apple Mac, False otherwise.
     :rtype: boolean
 
     """
-    if not isX86():
+    if not is_x86():
         mactel = False
     elif not os.path.isfile(DMI_CHASSIS_VENDOR):
         mactel = False
@@ -231,7 +231,7 @@ def isMactel():
             mactel = False
     return mactel
 
-def isEfi():
+def is_efi():
     """
     :return: True if the hardware supports EFI, False otherwise.
     :rtype: boolean
@@ -245,7 +245,7 @@ def isEfi():
 
 # Architecture checking functions
 
-def isX86(bits=None):
+def is_x86(bits=None):
     """:return: True if the hardware supports X86, False otherwise.
     :rtype: boolean
     :param bits: The number of bits used to define a memory address.
@@ -275,7 +275,7 @@ def isX86(bits=None):
 
     return False
 
-def isPPC(bits=None):
+def is_ppc(bits=None):
     """
     :return: True if the hardware supports PPC, False otherwise.
     :rtype: boolean
@@ -297,7 +297,7 @@ def isPPC(bits=None):
 
     return False
 
-def isS390():
+def is_s390():
     """
     :return: True if the hardware supports PPC, False otherwise.
     :rtype: boolean
@@ -305,7 +305,7 @@ def isS390():
     """
     return os.uname()[4].startswith('s390')
 
-def isIA64():
+def is_ia64():
     """
     :return: True if the hardware supports IA64, False otherwise.
     :rtype: boolean
@@ -313,7 +313,7 @@ def isIA64():
     """
     return os.uname()[4] == 'ia64'
 
-def isAlpha():
+def is_alpha():
     """
     :return: True if the hardware supports Alpha, False otherwise.
     :rtype: boolean
@@ -321,7 +321,7 @@ def isAlpha():
     """
     return os.uname()[4].startswith('alpha')
 
-def isARM():
+def is_arm():
     """
     :return: True if the hardware supports ARM, False otherwise.
     :rtype: boolean
@@ -329,31 +329,31 @@ def isARM():
     """
     return os.uname()[4].startswith('arm')
 
-def getArch():
+def get_arch():
     """
     :return: The hardware architecture
     :rtype: string
 
     """
-    if isX86(bits=32):
+    if is_x86(bits=32):
         return 'i386'
-    elif isX86(bits=64):
+    elif is_x86(bits=64):
         return 'x86_64'
-    elif isPPC(bits=32):
+    elif is_ppc(bits=32):
         return 'ppc'
-    elif isPPC(bits=64):
+    elif is_ppc(bits=64):
         # ppc64 and ppc64le are distinct architectures
         return os.uname()[4]
-    elif isAARCH64():
+    elif is_aarch64():
         return 'aarch64'
-    elif isAlpha():
+    elif is_alpha():
         return 'alpha'
-    elif isARM():
+    elif is_arm():
         return 'arm'
     else:
         return os.uname()[4]
 
-def numBits():
+def num_bits():
     """ Return an integer representing the length
         of the "word" used by the current architecture
         -> it is usually either 32 or 64
diff --git a/blivet/autopart.py b/blivet/autopart.py
index 1359ba0..c33f6e0 100644
--- a/blivet/autopart.py
+++ b/blivet/autopart.py
@@ -18,7 +18,7 @@
 # Red Hat Author(s): Dave Lehman <dlehman at redhat.com>
 #
 
-"""This module provides functions related to autopartitioning."""
+"""This module provides functions related to automatic partitioning."""
 
 import parted
 from decimal import Decimal
@@ -28,8 +28,8 @@
 from .devices.partition import PartitionDevice, FALLBACK_DEFAULT_PART_SIZE
 from .devices.luks import LUKSDevice
 from .errors import NoDisksError, NotEnoughFreeSpaceError
-from .formats import getFormat
-from .partitioning import doPartitioning, getFreeRegions, growLVM
+from .formats import get_format
+from .partitioning import do_partitioning, get_free_regions, grow_lvm
 from .i18n import _
 
 from pykickstart.constants import AUTOPART_TYPE_BTRFS, AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP, AUTOPART_TYPE_PLAIN
@@ -40,7 +40,7 @@
 # maximum ratio of swap size to disk size (10 %)
 MAX_SWAP_DISK_RATIO = Decimal('0.1')
 
-def swapSuggestion(quiet=False, hibernation=False, disk_space=None):
+def swap_suggestion(quiet=False, hibernation=False, disk_space=None):
     """
     Suggest the size of the swap partition that will be created.
 
@@ -101,12 +101,12 @@ def swapSuggestion(quiet=False, hibernation=False, disk_space=None):
 
     return swap
 
-def _getCandidateDisks(storage):
+def _get_candidate_disks(storage):
     """ Return a list of disks to be used for autopart/reqpart.
 
         Disks must be partitioned and have a single free region large enough
         for a default-sized (500MiB) partition. They must also be in
-        :attr:`StorageDiscoveryConfig.clearPartDisks` if it is non-empty.
+        :attr:`StorageDiscoveryConfig.clear_part_disks` if it is non-empty.
 
         :param storage: a Blivet instance
         :type storage: :class:`~.Blivet`
@@ -115,17 +115,17 @@ def _getCandidateDisks(storage):
     """
     disks = []
     for disk in storage.partitioned:
-        if storage.config.clearPartDisks and \
-           (disk.name not in storage.config.clearPartDisks):
+        if storage.config.clear_part_disks and \
+           (disk.name not in storage.config.clear_part_disks):
             continue
 
-        part = disk.format.firstPartition
+        part = disk.format.first_partition
         while part:
             if not part.type & parted.PARTITION_FREESPACE:
                 part = part.nextPartition()
                 continue
 
-            if Size(part.getLength(unit="B")) > PartitionDevice.defaultSize:
+            if Size(part.getLength(unit="B")) > PartitionDevice.default_size:
                 disks.append(disk)
                 break
 
@@ -133,7 +133,7 @@ def _getCandidateDisks(storage):
 
     return disks
 
-def _scheduleImplicitPartitions(storage, disks, min_luks_entropy=0):
+def _schedule_implicit_partitions(storage, disks, min_luks_entropy=0):
     """ Schedule creation of a lvm/btrfs member partitions for autopart.
 
         We create one such partition on each disk. They are not allocated until
@@ -153,33 +153,33 @@ def _scheduleImplicitPartitions(storage, disks, min_luks_entropy=0):
     devs = []
 
     # only schedule the partitions if either lvm or btrfs autopart was chosen
-    if storage.autoPartType == AUTOPART_TYPE_PLAIN:
+    if storage.autopart_type == AUTOPART_TYPE_PLAIN:
         return devs
 
     for disk in disks:
-        if storage.encryptedAutoPart:
+        if storage.encrypted_autopart:
             fmt_type = "luks"
-            fmt_args = {"passphrase": storage.encryptionPassphrase,
-                        "cipher": storage.encryptionCipher,
-                        "escrow_cert": storage.autoPartEscrowCert,
-                        "add_backup_passphrase": storage.autoPartAddBackupPassphrase,
+            fmt_args = {"passphrase": storage.encryption_passphrase,
+                        "cipher": storage.encryption_cipher,
+                        "escrow_cert": storage.autopart_escrow_cert,
+                        "add_backup_passphrase": storage.autopart_add_backup_passphrase,
                         "min_luks_entropy": min_luks_entropy}
         else:
-            if storage.autoPartType in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP):
+            if storage.autopart_type in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP):
                 fmt_type = "lvmpv"
             else:
                 fmt_type = "btrfs"
             fmt_args = {}
-        part = storage.newPartition(fmt_type=fmt_type,
+        part = storage.new_partition(fmt_type=fmt_type,
                                                 fmt_args=fmt_args,
                                                 grow=True,
                                                 parents=[disk])
-        storage.createDevice(part)
+        storage.create_device(part)
         devs.append(part)
 
     return devs
 
-def _schedulePartitions(storage, disks, implicit_devices, min_luks_entropy=0, requests=None):
+def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, requests=None):
     """ Schedule creation of autopart/reqpart partitions.
 
         This only schedules the requests for actual partitions.
@@ -192,17 +192,17 @@ def _schedulePartitions(storage, disks, implicit_devices, min_luks_entropy=0, re
                                  luks format creation
         :type min_luks_entropy: int
         :param requests: list of partitioning requests to operate on,
-                         or `~.storage.autoPartitionRequests` by default
+                         or `~.storage.autopart_requests` by default
         :type requests: list of :class:`~.partspec.PartSpec` instances
         :returns: None
         :rtype: None
     """
     if not requests:
-        requests = storage.autoPartitionRequests
+        requests = storage.autopart_requests
 
-    # basis for requests with requiredSpace is the sum of the sizes of the
+    # basis for requests with required_space is the sum of the sizes of the
     # two largest free regions
-    all_free = (Size(reg.getLength(unit="B")) for reg in getFreeRegions(disks))
+    all_free = (Size(reg.get_length(unit="B")) for reg in get_free_regions(disks))
     all_free = sorted(all_free, reverse=True)
     if not all_free:
         # this should never happen since we've already filtered the disks
@@ -229,13 +229,13 @@ def _schedulePartitions(storage, disks, implicit_devices, min_luks_entropy=0, re
     # First pass is for partitions only. We'll do LVs later.
     #
     for request in requests:
-        if ((request.lv and storage.doAutoPart and
-             storage.autoPartType in (AUTOPART_TYPE_LVM,
+        if ((request.lv and storage.do_autopart and
+             storage.autopart_type in (AUTOPART_TYPE_LVM,
                                       AUTOPART_TYPE_LVM_THINP)) or
-            (request.btr and storage.autoPartType == AUTOPART_TYPE_BTRFS)):
+            (request.btr and storage.autopart_type == AUTOPART_TYPE_BTRFS)):
             continue
 
-        if request.requiredSpace and request.requiredSpace > free:
+        if request.required_space and request.required_space > free:
             continue
 
         elif request.fstype in ("prepboot", "efi", "macefi", "hfs+") and \
@@ -259,7 +259,7 @@ def _schedulePartitions(storage, disks, implicit_devices, min_luks_entropy=0, re
                                     for p in storage.partitions
                                         if p.disk == stage1_device]))
             if (storage.bootloader.skip_bootloader or
-                not (stage1_device and stage1_device.isDisk and
+                not (stage1_device and stage1_device.is_disk and
                     is_gpt and not has_bios_boot)):
                 # there should never be a need for more than one of these
                 # partitions, so skip them.
@@ -273,41 +273,41 @@ def _schedulePartitions(storage, disks, implicit_devices, min_luks_entropy=0, re
             raise NotEnoughFreeSpaceError(_("No big enough free space on disks for "
                                             "automatic partitioning"))
 
-        if request.encrypted and storage.encryptedAutoPart:
+        if request.encrypted and storage.encrypted_autopart:
             fmt_type = "luks"
-            fmt_args = {"passphrase": storage.encryptionPassphrase,
-                        "cipher": storage.encryptionCipher,
-                        "escrow_cert": storage.autoPartEscrowCert,
-                        "add_backup_passphrase": storage.autoPartAddBackupPassphrase,
+            fmt_args = {"passphrase": storage.encryption_passphrase,
+                        "cipher": storage.encryption_cipher,
+                        "escrow_cert": storage.autopart_escrow_cert,
+                        "add_backup_passphrase": storage.autopart_add_backup_passphrase,
                         "min_luks_entropy": min_luks_entropy}
         else:
             fmt_type = request.fstype
             fmt_args = {}
 
-        dev = storage.newPartition(fmt_type=fmt_type,
+        dev = storage.new_partition(fmt_type=fmt_type,
                                             fmt_args=fmt_args,
                                             size=request.size,
                                             grow=request.grow,
-                                            maxsize=request.maxSize,
+                                            maxsize=request.max_size,
                                             mountpoint=request.mountpoint,
                                             parents=disks,
                                             weight=request.weight)
 
         # schedule the device for creation
-        storage.createDevice(dev)
+        storage.create_device(dev)
 
-        if request.encrypted and storage.encryptedAutoPart:
-            luks_fmt = getFormat(request.fstype,
+        if request.encrypted and storage.encrypted_autopart:
+            luks_fmt = get_format(request.fstype,
                                  device=dev.path,
                                  mountpoint=request.mountpoint)
             luks_dev = LUKSDevice("luks-%s" % dev.name,
                                   fmt=luks_fmt,
                                   size=dev.size,
                                   parents=dev)
-            storage.createDevice(luks_dev)
+            storage.create_device(luks_dev)
 
-        if storage.doAutoPart and \
-           storage.autoPartType in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP,
+        if storage.do_autopart and \
+           storage.autopart_type in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP,
                                     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
@@ -321,7 +321,7 @@ def _schedulePartitions(storage, disks, implicit_devices, min_luks_entropy=0, re
 
     return implicit_devices
 
-def _scheduleVolumes(storage, devs):
+def _schedule_volumes(storage, devs):
     """ Schedule creation of autopart lvm/btrfs volumes.
 
         Schedules encryption of member devices if requested, schedules creation
@@ -342,54 +342,54 @@ def _scheduleVolumes(storage, devs):
     if not devs:
         return
 
-    if storage.autoPartType in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP):
-        new_container = storage.newVG
-        new_volume = storage.newLV
+    if storage.autopart_type in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP):
+        new_container = storage.new_vg
+        new_volume = storage.new_lv
         format_name = "lvmpv"
     else:
-        new_container = storage.newBTRFS
-        new_volume = storage.newBTRFS
+        new_container = storage.new_btrfs
+        new_volume = storage.new_btrfs
         format_name = "btrfs"
 
-    if storage.encryptedAutoPart:
+    if storage.encrypted_autopart:
         pvs = []
         for dev in devs:
             pv = LUKSDevice("luks-%s" % dev.name,
-                            fmt=getFormat(format_name, device=dev.path),
+                            fmt=get_format(format_name, device=dev.path),
                             size=dev.size,
                             parents=dev)
             pvs.append(pv)
-            storage.createDevice(pv)
+            storage.create_device(pv)
     else:
         pvs = devs
 
     # create a vg containing all of the autopart pvs
     container = new_container(parents=pvs)
-    storage.createDevice(container)
+    storage.create_device(container)
 
     #
-    # Convert storage.autoPartitionRequests into Device instances and
+    # Convert storage.autopart_requests into Device instances and
     # schedule them for creation.
     #
     # Second pass, for LVs only.
     pool = None
-    for request in storage.autoPartitionRequests:
-        btr = storage.autoPartType == AUTOPART_TYPE_BTRFS and request.btr
-        lv = (storage.autoPartType in (AUTOPART_TYPE_LVM,
+    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.autoPartType == AUTOPART_TYPE_LVM_THINP and
+        thinlv = (storage.autopart_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
-            pool = storage.newLV(parents=[container], thin_pool=True, grow=True)
-            storage.createDevice(pool)
+            pool = storage.new_lv(parents=[container], thin_pool=True, grow=True)
+            storage.create_device(pool)
 
         if not btr and not lv and not thinlv:
             continue
 
         # required space isn't relevant on btrfs
         if (lv or thinlv) and \
-           request.requiredSpace and request.requiredSpace > container.size:
+           request.required_space and request.required_space > container.size:
             continue
 
         if request.fstype is None:
@@ -397,7 +397,7 @@ def _scheduleVolumes(storage, devs):
                 # btrfs volumes can only contain btrfs filesystems
                 request.fstype = "btrfs"
             else:
-                request.fstype = storage.defaultFSType
+                request.fstype = storage.default_fstype
 
         kwargs = {"mountpoint": request.mountpoint,
                   "fmt_type": request.fstype}
@@ -409,7 +409,7 @@ def _scheduleVolumes(storage, devs):
 
             kwargs.update({"parents": parents,
                            "grow": request.grow,
-                           "maxsize": request.maxSize,
+                           "maxsize": request.max_size,
                            "size": request.size,
                            "thin_volume": thinlv})
         else:
@@ -420,30 +420,30 @@ def _scheduleVolumes(storage, devs):
         dev = new_volume(**kwargs)
 
         # schedule the device for creation
-        storage.createDevice(dev)
+        storage.create_device(dev)
 
-def doReqPartition(storage, requests):
+def do_reqpart(storage, requests):
     """Perform automatic partitioning of just required platform-specific
-       partitions.  This is incompatible with doAutoPartition.
+       partitions.  This is incompatible with do_autopart.
 
        :param storage: a :class:`~.Blivet` instance
        :type storage: :class:`~.Blivet`
        :param requests: list of partitioning requests to operate on,
-                        or `~.storage.autoPartitionRequests` by default
+                        or `~.storage.autopart_requests` by default
        :type requests: list of :class:`~.partspec.PartSpec` instances
     """
     if not storage.partitioned:
         raise NoDisksError(_("No usable disks selected"))
 
-    disks = _getCandidateDisks(storage)
+    disks = _get_candidate_disks(storage)
 
     if disks == []:
         raise NotEnoughFreeSpaceError(_("Not enough free space on disks for "
                                       "automatic partitioning"))
 
-    _schedulePartitions(storage, disks, [], requests=requests)
+    _schedule_partitions(storage, disks, [], requests=requests)
 
-def doAutoPartition(storage, data, min_luks_entropy=0):
+def do_autopart(storage, data, min_luks_entropy=0):
     """ Perform automatic partitioning.
 
         :param storage: a :class:`~.Blivet` instance
@@ -454,40 +454,40 @@ def doAutoPartition(storage, data, min_luks_entropy=0):
                                  luks format creation
         :type min_luks_entropy: int
 
-        :attr:`Blivet.doAutoPart` controls whether this method creates the
-        automatic partitioning layout. :attr:`Blivet.autoPartType` controls
+        :attr:`Blivet.do_autopart` controls whether this method creates the
+        automatic partitioning layout. :attr:`Blivet.autopart_type` controls
         which variant of autopart used. It uses one of the pykickstart
         AUTOPART_TYPE_* constants. The set of eligible disks is defined in
-        :attr:`StorageDiscoveryConfig.clearPartDisks`.
+        :attr:`StorageDiscoveryConfig.clear_part_disks`.
 
         .. note::
 
             Clearing of partitions is handled separately, in
-            :meth:`~.Blivet.clearPartitions`.
+            :meth:`~.Blivet.clear_partitions`.
     """
     # pylint: disable=unused-argument
-    log.debug("doAutoPart: %s", storage.doAutoPart)
-    log.debug("encryptedAutoPart: %s", storage.encryptedAutoPart)
-    log.debug("autoPartType: %s", storage.autoPartType)
-    log.debug("clearPartType: %s", storage.config.clearPartType)
-    log.debug("clearPartDisks: %s", storage.config.clearPartDisks)
-    log.debug("autoPartitionRequests:\n%s", "".join([str(p) for p in storage.autoPartitionRequests]))
+    log.debug("do_autopart: %s", storage.do_autopart)
+    log.debug("encrypted_autopart: %s", storage.encrypted_autopart)
+    log.debug("autopart_type: %s", storage.autopart_type)
+    log.debug("clear_part_type: %s", storage.config.clear_part_type)
+    log.debug("clear_part_disks: %s", storage.config.clear_part_disks)
+    log.debug("autopart_requests:\n%s", "".join([str(p) for p in storage.autopart_requests]))
     log.debug("storage.disks: %s", [d.name for d in storage.disks])
     log.debug("storage.partitioned: %s", [d.name for d in storage.partitioned])
     log.debug("all names: %s", [d.name for d in storage.devices])
-    log.debug("boot disk: %s", getattr(storage.bootDisk, "name", None))
+    log.debug("boot disk: %s", getattr(storage.boot_disk, "name", None))
 
     disks = []
     devs = []
 
-    if not storage.doAutoPart:
+    if not storage.do_autopart:
         return
 
     if not storage.partitioned:
         raise NoDisksError(_("No usable disks selected"))
 
-    disks = _getCandidateDisks(storage)
-    devs = _scheduleImplicitPartitions(storage, disks, min_luks_entropy)
+    disks = _get_candidate_disks(storage)
+    devs = _schedule_implicit_partitions(storage, disks, min_luks_entropy)
     log.debug("candidate disks: %s", disks)
     log.debug("devs: %s", devs)
 
@@ -495,17 +495,17 @@ def doAutoPartition(storage, data, min_luks_entropy=0):
         raise NotEnoughFreeSpaceError(_("Not enough free space on disks for "
                                       "automatic partitioning"))
 
-    devs = _schedulePartitions(storage, disks, devs, min_luks_entropy=min_luks_entropy)
+    devs = _schedule_partitions(storage, disks, devs, min_luks_entropy=min_luks_entropy)
 
     # run the autopart function to allocate and grow partitions
-    doPartitioning(storage)
-    _scheduleVolumes(storage, devs)
+    do_partitioning(storage)
+    _schedule_volumes(storage, devs)
 
     # grow LVs
-    growLVM(storage)
+    grow_lvm(storage)
 
-    storage.setUpBootLoader()
+    storage.set_up_boot_loader()
 
     # only newly added swaps should appear in the fstab
     new_swaps = (dev for dev in storage.swaps if not dev.format.exists)
-    storage.setFstabSwaps(new_swaps)
+    storage.set_fstab_swaps(new_swaps)
diff --git a/blivet/blivet.py b/blivet/blivet.py
index 50a4378..e87d7a4 100644
--- a/blivet/blivet.py
+++ b/blivet/blivet.py
@@ -34,7 +34,7 @@
 from .storage_log import log_method_call, log_exception_info
 from .devices import BTRFSDevice, BTRFSSubVolumeDevice, BTRFSVolumeDevice
 from .devices import LVMLogicalVolumeDevice, LVMThinLogicalVolumeDevice, LVMThinPoolDevice, LVMVolumeGroupDevice
-from .devices import MDRaidArrayDevice, PartitionDevice, TmpFSDevice, devicePathToName
+from .devices import MDRaidArrayDevice, PartitionDevice, TmpFSDevice, device_path_to_name
 from .deviceaction import ActionCreateDevice, ActionCreateFormat, ActionDestroyDevice
 from .deviceaction import ActionDestroyFormat, ActionResizeDevice, ActionResizeFormat
 from .devicelibs.edd import get_edd_dict
@@ -45,14 +45,14 @@
 from .formats import get_default_filesystem_type
 from .flags import flags
 from .platform import platform as _platform
-from .formats import getFormat
-from .osinstall import FSSet, findExistingInstallations
+from .formats import get_format
+from .osinstall import FSSet, find_existing_installations
 from . import arch
 from . import iscsi
 from . import fcoe
 from . import zfcp
 from . import devicefactory
-from . import get_bootloader, getSysroot, shortProductName, __version__
+from . import get_bootloader, get_sysroot, short_product_name, __version__
 from .util import open  # pylint: disable=redefined-builtin
 
 from .i18n import _
@@ -63,8 +63,8 @@
 def empty_device(device, devicetree):
     empty = True
     if device.partitioned:
-        partitions = devicetree.getChildren(device)
-        empty = all([p.isMagic for p in partitions])
+        partitions = devicetree.get_children(device)
+        empty = all([p.is_magic for p in partitions])
     else:
         empty = (device.format.type is None)
 
@@ -74,20 +74,20 @@ class StorageDiscoveryConfig(object):
     """ Class to encapsulate various detection/initialization parameters. """
     def __init__(self):
         # storage configuration variables
-        self.ignoreDiskInteractive = False
-        self.ignoredDisks = []
-        self.exclusiveDisks = []
-        self.clearPartType = None
-        self.clearPartDisks = []
-        self.clearPartDevices = []
-        self.initializeDisks = False
-        self.protectedDevSpecs = []
-        self.diskImages = {}
-        self.zeroMbr = False
-
-        # Whether clearPartitions removes scheduled/non-existent devices and
+        self.ignore_disk_interactive = False
+        self.ignored_disks = []
+        self.exclusive_disks = []
+        self.clear_part_type = None
+        self.clear_part_disks = []
+        self.clear_part_devices = []
+        self.initialize_disks = False
+        self.protected_dev_specs = []
+        self.disk_images = {}
+        self.zero_mbr = False
+
+        # Whether clear_partitions removes scheduled/non-existent devices and
         # disklabels depends on this flag.
-        self.clearNonExistent = False
+        self.clear_non_existent = False
 
     def update(self, ksdata):
         """ Update configuration from ksdata source.
@@ -95,13 +95,13 @@ def update(self, ksdata):
             :param ksdata: kickstart data used as data source
             :type ksdata: :class:`pykickstart.Handler`
         """
-        self.ignoredDisks = ksdata.ignoredisk.ignoredisk[:]
-        self.exclusiveDisks = ksdata.ignoredisk.onlyuse[:]
-        self.clearPartType = ksdata.clearpart.type
-        self.clearPartDisks = ksdata.clearpart.drives[:]
-        self.clearPartDevices = ksdata.clearpart.devices[:]
-        self.initializeDisks = ksdata.clearpart.initAll
-        self.zeroMbr = ksdata.zerombr.zerombr
+        self.ignored_disks = ksdata.ignoredisk.ignoredisk[:]
+        self.exclusive_disks = ksdata.ignoredisk.onlyuse[:]
+        self.clear_part_type = ksdata.clearpart.type
+        self.clear_part_disks = ksdata.clearpart.drives[:]
+        self.clear_part_devices = ksdata.clearpart.devices[:]
+        self.initialize_disks = ksdata.clearpart.init_all
+        self.zero_mbr = ksdata.zerombr.zerombr
 
 class Blivet(object):
     """ Top-level class for managing storage configuration. """
@@ -116,35 +116,35 @@ def __init__(self, ksdata=None):
         self.config = StorageDiscoveryConfig()
 
         # storage configuration variables
-        self.doAutoPart = False
-        self.clearPartChoice = None
-        self.encryptedAutoPart = False
-        self.autoPartType = AUTOPART_TYPE_LVM
-        self.encryptionPassphrase = None
-        self.encryptionCipher = None
-        self.escrowCertificates = {}
-        self.autoPartEscrowCert = None
-        self.autoPartAddBackupPassphrase = False
-        self.autoPartitionRequests = []
-        self.eddDict = {}
+        self.do_autopart = False
+        self.clear_part_choice = None
+        self.encrypted_autopart = False
+        self.autopart_type = AUTOPART_TYPE_LVM
+        self.encryption_passphrase = None
+        self.encryption_cipher = None
+        self.escrow_certificates = {}
+        self.autopart_escrow_cert = None
+        self.autopart_add_backup_passphrase = False
+        self.autopart_requests = []
+        self.edd_dict = {}
         self.dasd = []
 
-        self.__luksDevs = {}
+        self.__luks_devs = {}
         self.size_sets = []
-        self.setDefaultFSType(get_default_filesystem_type())
-        self._defaultBootFSType = None
+        self.set_default_fstype(get_default_filesystem_type())
+        self._default_boot_fstype = None
 
         self.iscsi = iscsi.iscsi()
         self.fcoe = fcoe.fcoe()
         self.zfcp = zfcp.ZFCP()
 
-        self._nextID = 0
-        self._dumpFile = "%s/storage.state" % tempfile.gettempdir()
+        self._next_id = 0
+        self._dump_file = "%s/storage.state" % tempfile.gettempdir()
 
         # these will both be empty until our reset method gets called
         self.devicetree = DeviceTree(conf=self.config,
-                                     passphrase=self.encryptionPassphrase,
-                                     luksDict=self.__luksDevs,
+                                     passphrase=self.encryption_passphrase,
+                                     luks_dict=self.__luks_devs,
                                      iscsi=self.iscsi,
                                      dasd=self.dasd)
         self.fsset = FSSet(self.devicetree)
@@ -152,7 +152,7 @@ def __init__(self, ksdata=None):
         self.services = set()
         self._free_space_snapshot = None
 
-    def doIt(self, callbacks=None):
+    def do_it(self, callbacks=None):
         """
         Commit queued changes to disk.
 
@@ -161,23 +161,23 @@ def doIt(self, callbacks=None):
 
         """
 
-        self.devicetree.processActions(callbacks=callbacks)
+        self.devicetree.process_actions(callbacks=callbacks)
         if not flags.installer_mode:
             return
 
         # now set the boot partition's flag
         if self.bootloader and not self.bootloader.skip_bootloader:
             if self.bootloader.stage2_bootable:
-                boot = self.bootDevice
+                boot = self.boot_device
             else:
-                boot = self.bootLoaderDevice
+                boot = self.boot_loader_device
 
             if boot.type == "mdarray":
-                bootDevs = boot.parents
+                boot_devs = boot.parents
             else:
-                bootDevs = [boot]
+                boot_devs = [boot]
 
-            for dev in bootDevs:
+            for dev in boot_devs:
                 if not hasattr(dev, "bootable"):
                     log.info("Skipping %s, not bootable", dev)
                     continue
@@ -185,8 +185,8 @@ def doIt(self, callbacks=None):
                 # Dos labels can only have one partition marked as active
                 # and unmarking ie the windows partition is not a good idea
                 skip = False
-                if dev.disk.format.partedDisk.type == "msdos":
-                    for p in dev.disk.format.partedDisk.partitions:
+                if dev.disk.format.parted_disk.type == "msdos":
+                    for p in dev.disk.format.parted_disk.partitions:
                         if p.type == parted.PARTITION_NORMAL and \
                            p.getFlag(parted.PARTITION_BOOT):
                             skip = True
@@ -195,7 +195,7 @@ def doIt(self, callbacks=None):
                 # GPT labeled disks should only have bootable set on the
                 # EFI system partition (parted sets the EFI System GUID on
                 # GPT partitions with the boot flag)
-                if dev.disk.format.labelType == "gpt" and \
+                if dev.disk.format.label_type == "gpt" and \
                    dev.format.type not in ["efi", "macefi"]:
                     skip = True
 
@@ -204,28 +204,28 @@ def doIt(self, callbacks=None):
                     continue
 
                 # hfs+ partitions on gpt can't be marked bootable via parted
-                if dev.disk.format.partedDisk.type != "gpt" or \
+                if dev.disk.format.parted_disk.type != "gpt" or \
                         dev.format.type not in ["hfs+", "macefi"]:
                     log.info("setting boot flag on %s", dev.name)
                     dev.bootable = True
 
                 # Set the boot partition's name on disk labels that support it
-                if dev.partedPartition.disk.supportsFeature(parted.DISK_TYPE_PARTITION_NAME):
-                    ped_partition = dev.partedPartition.getPedPartition()
-                    ped_partition.set_name(dev.format.name)
+                if dev.parted_partition.disk.supportsFeature(parted.DISK_TYPE_PARTITION_NAME):
+                    ped_partition = dev.parted_partition.getPedPartition()
+                    ped_partition.setName(dev.format.name)
                     log.info("Setting label on %s to '%s'", dev, dev.format.name)
 
                 dev.disk.setup()
-                dev.disk.format.commitToDisk()
+                dev.disk.format.commit_to_disk()
 
         if flags.installer_mode:
-            self.dumpState("final")
+            self.dump_state("final")
 
     @property
-    def nextID(self):
+    def next_id(self):
         """ Used for creating unique placeholder names. """
-        newid = self._nextID
-        self._nextID += 1
+        newid = self._next_id
+        self._next_id += 1
         return newid
 
     def shutdown(self):
@@ -234,29 +234,29 @@ def shutdown(self):
             return
 
         try:
-            self.devicetree.teardownAll()
+            self.devicetree.teardown_all()
         except Exception: # pylint: disable=broad-except
             log_exception_info(log.error, "failure tearing down device tree")
 
-    def reset(self, cleanupOnly=False):
+    def reset(self, cleanup_only=False):
         """ Reset storage configuration to reflect actual system state.
 
             This will cancel any queued actions and rescan from scratch but not
             clobber user-obtained information like passphrases, iscsi config, &c
 
-            :keyword cleanupOnly: prepare the tree only to deactivate devices
-            :type cleanupOnly: bool
+            :keyword cleanup_only: prepare the tree only to deactivate devices
+            :type cleanup_only: bool
 
             See :meth:`devicetree.Devicetree.populate` for more information
-            about the cleanupOnly keyword argument.
+            about the cleanup_only keyword argument.
         """
         log.info("resetting Blivet (version %s) instance %s", __version__, self)
         if flags.installer_mode:
             # save passphrases for luks devices so we don't have to reprompt
-            self.encryptionPassphrase = None
+            self.encryption_passphrase = None
             for device in self.devices:
                 if device.format.type == "luks" and device.format.exists:
-                    self.savePassphrase(device)
+                    self.save_passphrase(device)
 
         if self.ksdata:
             self.config.update(self.ksdata)
@@ -272,14 +272,14 @@ def reset(self, cleanupOnly=False):
             self.dasd = []
 
         self.devicetree.reset(conf=self.config,
-                              passphrase=self.encryptionPassphrase,
-                              luksDict=self.__luksDevs,
+                              passphrase=self.encryption_passphrase,
+                              luks_dict=self.__luks_devs,
                               iscsi=self.iscsi,
                               dasd=self.dasd)
-        self.devicetree.populate(cleanupOnly=cleanupOnly)
+        self.devicetree.populate(cleanup_only=cleanup_only)
         self.fsset = FSSet(self.devicetree)
-        self.eddDict = get_edd_dict(self.partitioned)
-        self.devicetree.eddDict = self.eddDict
+        self.edd_dict = get_edd_dict(self.partitioned)
+        self.devicetree.edd_dict = self.edd_dict
         if self.bootloader:
             # clear out bootloader attributes that refer to devices that are
             # no longer in the tree
@@ -287,16 +287,16 @@ def reset(self, cleanupOnly=False):
 
         self.roots = []
         if flags.installer_mode:
-            self.roots = findExistingInstallations(self.devicetree)
-            self.dumpState("initial")
+            self.roots = find_existing_installations(self.devicetree)
+            self.dump_state("initial")
 
         if not flags.installer_mode:
-            self.devicetree.handleNodevFilesystems()
+            self.devicetree.handle_nodev_filesystems()
 
-        self.updateBootLoaderDiskList()
+        self.update_boot_loader_disk_list()
 
     @property
-    def unusedDevices(self):
+    def unused_devices(self):
         used_devices = []
         for root in self.roots:
             for device in list(root.mounts.values()) + root.swaps:
@@ -313,8 +313,8 @@ def unusedDevices(self):
 
         for device in self.partitions:
             if getattr(device, "isLogical", False):
-                extended = device.disk.format.extendedPartition.path
-                used_devices.append(self.devicetree.getDeviceByPath(extended))
+                extended = device.disk.format.extended_partition.path
+                used_devices.append(self.devicetree.get_device_by_path(extended))
 
         used = set(used_devices)
         _all = set(self.devices)
@@ -339,12 +339,12 @@ def disks(self):
         """
         disks = []
         for device in self.devicetree.devices:
-            if device.isDisk:
-                if not device.mediaPresent:
+            if device.is_disk:
+                if not device.media_present:
                     log.info("Skipping disk: %s: No media present", device.name)
                     continue
                 disks.append(device)
-        disks.sort(key=self.compareDisksKey)
+        disks.sort(key=self.compare_disks_key)
         return disks
 
     @property
@@ -365,7 +365,7 @@ def partitioned(self):
             if not device.partitioned:
                 continue
 
-            if not device.mediaPresent:
+            if not device.media_present:
                 log.info("Skipping device: %s: No media present", device.name)
                 continue
 
@@ -382,7 +382,7 @@ def partitions(self):
             does not necessarily reflect the actual on-disk state of the
             system's disks.
         """
-        partitions = self.devicetree.getDevicesByInstance(PartitionDevice)
+        partitions = self.devicetree.get_devices_by_instance(PartitionDevice)
         partitions.sort(key=lambda d: d.name)
         return partitions
 
@@ -394,7 +394,7 @@ def vgs(self):
             does not necessarily reflect the actual on-disk state of the
             system's disks.
         """
-        vgs = self.devicetree.getDevicesByType("lvmvg")
+        vgs = self.devicetree.get_devices_by_type("lvmvg")
         vgs.sort(key=lambda d: d.name)
         return vgs
 
@@ -417,7 +417,7 @@ def thinlvs(self):
             does not necessarily reflect the actual on-disk state of the
             system's disks.
         """
-        thin = self.devicetree.getDevicesByType("lvmthinlv")
+        thin = self.devicetree.get_devices_by_type("lvmthinlv")
         thin.sort(key=lambda d: d.name)
         return thin
 
@@ -429,7 +429,7 @@ def thinpools(self):
             does not necessarily reflect the actual on-disk state of the
             system's disks.
         """
-        pools = self.devicetree.getDevicesByType("lvmthinpool")
+        pools = self.devicetree.get_devices_by_type("lvmthinpool")
         pools.sort(key=lambda d: d.name)
         return pools
 
@@ -454,14 +454,14 @@ def mdarrays(self):
             does not necessarily reflect the actual on-disk state of the
             system's disks.
         """
-        arrays = self.devicetree.getDevicesByType("mdarray")
+        arrays = self.devicetree.get_devices_by_type("mdarray")
         arrays.sort(key=lambda d: d.name)
         return arrays
 
     @property
     def mdcontainers(self):
         """ A list of the MD containers in the device tree. """
-        arrays = self.devicetree.getDevicesByType("mdcontainer")
+        arrays = self.devicetree.get_devices_by_type("mdcontainer")
         arrays.sort(key=lambda d: d.name)
         return arrays
 
@@ -479,14 +479,14 @@ def mdmembers(self):
         return members
 
     @property
-    def btrfsVolumes(self):
+    def btrfs_volumes(self):
         """ A list of the BTRFS volumes in the device tree.
 
             This is based on the current state of the device tree and
             does not necessarily reflect the actual on-disk state of the
             system's disks.
         """
-        return sorted(self.devicetree.getDevicesByType("btrfs volume"),
+        return sorted(self.devicetree.get_devices_by_type("btrfs volume"),
                       key=lambda d: d.name)
 
     @property
@@ -502,45 +502,45 @@ def swaps(self):
         swaps.sort(key=lambda d: d.name)
         return swaps
 
-    def shouldClear(self, device, **kwargs):
+    def should_clear(self, device, **kwargs):
         """ Return True if a clearpart settings say a device should be cleared.
 
             :param device: the device (required)
             :type device: :class:`~.devices.StorageDevice`
-            :keyword clearPartType: overrides :attr:`self.config.clearPartType`
-            :type clearPartType: int
-            :keyword clearPartDisks: overrides
-                                     :attr:`self.config.clearPartDisks`
-            :type clearPartDisks: list
-            :keyword clearPartDevices: overrides
-                                       :attr:`self.config.clearPartDevices`
-            :type clearPartDevices: list
-            :returns: whether or not clearPartitions should remove this device
+            :keyword clear_part_type: overrides :attr:`self.config.clear_part_type`
+            :type clear_part_type: int
+            :keyword clear_part_disks: overrides
+                                     :attr:`self.config.clear_part_disks`
+            :type clear_part_disks: list
+            :keyword clear_part_devices: overrides
+                                       :attr:`self.config.clear_part_devices`
+            :type clear_part_devices: list
+            :returns: whether or not clear_partitions should remove this device
             :rtype: bool
         """
-        clearPartType = kwargs.get("clearPartType", self.config.clearPartType)
-        clearPartDisks = kwargs.get("clearPartDisks",
-                                    self.config.clearPartDisks)
-        clearPartDevices = kwargs.get("clearPartDevices",
-                                      self.config.clearPartDevices)
+        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)
+        clear_part_devices = kwargs.get("clear_part_devices",
+                                      self.config.clear_part_devices)
 
         for disk in device.disks:
             # this will not include disks with hidden formats like multipath
             # and firmware raid member disks
-            if clearPartDisks and disk.name not in clearPartDisks:
+            if clear_part_disks and disk.name not in clear_part_disks:
                 return False
 
-        if not self.config.clearNonExistent:
-            if (device.isDisk and not device.format.exists) or \
-               (not device.isDisk and not device.exists):
+        if not self.config.clear_non_existent:
+            if (device.is_disk and not device.format.exists) or \
+               (not device.is_disk and not device.exists):
                 return False
 
-        # the only devices we want to clear when clearPartType is
+        # the only devices we want to clear when clear_part_type is
         # CLEARPART_TYPE_NONE are uninitialized disks, or disks with no
-        # partitions, in clearPartDisks, and then only when we have been asked
+        # partitions, in clear_part_disks, and then only when we have been asked
         # to initialize disks as needed
-        if clearPartType in [CLEARPART_TYPE_NONE, None]:
-            if not self.config.initializeDisks or not device.isDisk:
+        if clear_part_type in [CLEARPART_TYPE_NONE, None]:
+            if not self.config.initialize_disks or not device.is_disk:
                 return False
 
             if not empty_device(device, self.devicetree):
@@ -550,22 +550,22 @@ def shouldClear(self, device, **kwargs):
             # Never clear the special first partition on a Mac disk label, as
             # that holds the partition table itself.
             # Something similar for the third partition on a Sun disklabel.
-            if device.isMagic:
+            if device.is_magic:
                 return False
 
             # We don't want to fool with extended partitions, freespace, &c
-            if not device.isPrimary and not device.isLogical:
+            if not device.is_primary and not device.is_logical:
                 return False
 
-            if clearPartType == CLEARPART_TYPE_LINUX and \
-               not device.format.linuxNative and \
-               not device.getFlag(parted.PARTITION_LVM) and \
-               not device.getFlag(parted.PARTITION_RAID) and \
-               not device.getFlag(parted.PARTITION_SWAP):
+            if clear_part_type == CLEARPART_TYPE_LINUX and \
+               not device.format.linux_native and \
+               not device.get_flag(parted.PARTITION_LVM) and \
+               not device.get_flag(parted.PARTITION_RAID) and \
+               not device.get_flag(parted.PARTITION_SWAP):
                 return False
-        elif device.isDisk:
-            if device.partitioned and clearPartType != CLEARPART_TYPE_ALL:
-                # if clearPartType is not CLEARPART_TYPE_ALL but we'll still be
+        elif device.is_disk:
+            if device.partitioned and clear_part_type != CLEARPART_TYPE_ALL:
+                # if clear_part_type is not CLEARPART_TYPE_ALL but we'll still be
                 # removing every partition from the disk, return True since we
                 # will want to be able to create a new disklabel on this disk
                 if not empty_device(device, self.devicetree):
@@ -575,28 +575,28 @@ def shouldClear(self, device, **kwargs):
             if device.format.hidden:
                 return False
 
-            # When clearPartType is CLEARPART_TYPE_LINUX and a disk has non-
+            # When clear_part_type is CLEARPART_TYPE_LINUX and a disk has non-
             # linux whole-disk formatting, do not clear it. The exception is
             # the case of an uninitialized disk when we've been asked to
             # initialize disks as needed
-            if (clearPartType == CLEARPART_TYPE_LINUX and
-                not ((self.config.initializeDisks and
+            if (clear_part_type == CLEARPART_TYPE_LINUX and
+                not ((self.config.initialize_disks and
                       empty_device(device, self.devicetree)) or
-                     (not device.partitioned and device.format.linuxNative))):
+                     (not device.partitioned and device.format.linux_native))):
                 return False
 
         # Don't clear devices holding install media.
-        descendants = self.devicetree.getDependentDevices(device)
+        descendants = self.devicetree.get_dependent_devices(device)
         if device.protected or any(d.protected for d in descendants):
             return False
 
-        if clearPartType == CLEARPART_TYPE_LIST and \
-           device.name not in clearPartDevices:
+        if clear_part_type == CLEARPART_TYPE_LIST and \
+           device.name not in clear_part_devices:
             return False
 
         return True
 
-    def recursiveRemove(self, device):
+    def recursive_remove(self, device):
         """ Remove a device after removing its dependent devices.
 
             If the device is not a leaf, all of its dependents are removed
@@ -605,9 +605,9 @@ def recursiveRemove(self, device):
             formatting is removed by no attempt is made to actually remove the
             disk device.
         """
-        self.devicetree.recursiveRemove(device)
+        self.devicetree.recursive_remove(device)
 
-    def clearPartitions(self):
+    def clear_partitions(self):
         """ Clear partitions and dependent devices from disks.
 
             This is also where zerombr is handled.
@@ -617,33 +617,33 @@ def clearPartitions(self):
         # partitions. This can still happen through the UI but it makes sense to
         # avoid it where possible.
         partitions = sorted(self.partitions,
-                            key=lambda p: p.partedPartition.number,
+                            key=lambda p: p.parted_partition.number,
                             reverse=True)
         for part in partitions:
             log.debug("clearpart: looking at %s", part.name)
-            if not self.shouldClear(part):
+            if not self.should_clear(part):
                 continue
 
-            self.recursiveRemove(part)
-            log.debug("partitions: %s", [p.getDeviceNodeName() for p in part.partedPartition.disk.partitions])
+            self.recursive_remove(part)
+            log.debug("partitions: %s", [p.getDeviceNodeName() for p in part.parted_partition.disk.partitions])
 
         # now remove any empty extended partitions
-        self.removeEmptyExtendedPartitions()
+        self.remove_empty_extended_partitions()
 
         # ensure all disks have appropriate disklabels
         for disk in self.disks:
-            zerombr = (self.config.zeroMbr and disk.format.type is None)
-            should_clear = self.shouldClear(disk)
+            zerombr = (self.config.zero_mbr and disk.format.type is None)
+            should_clear = self.should_clear(disk)
             if should_clear:
-                self.recursiveRemove(disk)
+                self.recursive_remove(disk)
 
             if zerombr or should_clear:
                 log.debug("clearpart: initializing %s", disk.name)
-                self.initializeDisk(disk)
+                self.initialize_disk(disk)
 
-        self.updateBootLoaderDiskList()
+        self.update_boot_loader_disk_list()
 
-    def initializeDisk(self, disk):
+    def initialize_disk(self, disk):
         """ (Re)initialize a disk by creating a disklabel on it.
 
             The disk should not contain any partitions except perhaps for a
@@ -658,61 +658,61 @@ def initializeDisk(self, disk):
         """
         # first, remove magic mac/sun partitions from the parted Disk
         if disk.partitioned:
-            magic = disk.format.magicPartitionNumber
+            magic = disk.format.magic_partition_number
             expected = 0
             if magic:
                 expected = 1
                 # remove the magic partition
-                for part in self.devicetree.getChildren(disk):
-                    if part.partedPartition.number == magic:
+                for part in self.devicetree.get_children(disk):
+                    if part.parted_partition.number == magic:
                         log.debug("removing %s", part.name)
                         # We can't schedule the magic partition for removal
                         # because parted will not allow us to remove it from the
                         # disk. Still, we need it out of the devicetree.
-                        self.devicetree._removeDevice(part, modparent=False)
+                        self.devicetree._remove_device(part, modparent=False)
 
             if len(disk.format.partitions) > expected:
                 raise ValueError("cannot initialize a disk that has partitions")
 
         # remove existing formatting from the disk
         destroy_action = ActionDestroyFormat(disk)
-        self.devicetree.registerAction(destroy_action)
+        self.devicetree.register_action(destroy_action)
 
-        labelType = _platform.bestDiskLabelType(disk)
+        label_type = _platform.best_disklabel_type(disk)
 
         # create a new disklabel on the disk
-        newLabel = getFormat("disklabel", device=disk.path,
-                             labelType=labelType)
-        create_action = ActionCreateFormat(disk, fmt=newLabel)
-        self.devicetree.registerAction(create_action)
+        new_label = get_format("disklabel", device=disk.path,
+                             label_type=label_type)
+        create_action = ActionCreateFormat(disk, fmt=new_label)
+        self.devicetree.register_action(create_action)
 
-    def removeEmptyExtendedPartitions(self):
+    def remove_empty_extended_partitions(self):
         for disk in self.partitioned:
             log.debug("checking whether disk %s has an empty extended", disk.name)
-            extended = disk.format.extendedPartition
-            logical_parts = disk.format.logicalPartitions
+            extended = disk.format.extended_partition
+            logical_parts = disk.format.logical_partitions
             log.debug("extended is %s ; logicals is %s", extended, [p.getDeviceNodeName() for p in logical_parts])
             if extended and not logical_parts:
                 log.debug("removing empty extended partition from %s", disk.name)
-                extended_name = devicePathToName(extended.getDeviceNodeName())
-                extended = self.devicetree.getDeviceByName(extended_name)
-                self.destroyDevice(extended)
+                extended_name = device_path_to_name(extended.getDeviceNodeName())
+                extended = self.devicetree.get_device_by_name(extended_name)
+                self.destroy_device(extended)
 
-    def getFreeSpace(self, disks=None, clearPartType=None):
+    def get_free_space(self, disks=None, clear_part_type=None):
         """ Return a dict with free space info for each disk.
 
             The dict values are 2-tuples: (disk_free, fs_free). fs_free is
             space available by shrinking filesystems. disk_free is space not
             allocated to any partition.
 
-            disks and clearPartType allow specifying a set of disks other than
-            self.disks and a clearPartType value other than
-            self.config.clearPartType.
+            disks and clear_part_type allow specifying a set of disks other than
+            self.disks and a clear_part_type value other than
+            self.config.clear_part_type.
 
             :keyword disks: overrides :attr:`disks`
             :type disks: list
-            :keyword clearPartType: overrides :attr:`self.config.clearPartType`
-            :type clearPartType: int
+            :keyword clear_part_type: overrides :attr:`self.config.clear_part_type`
+            :type clear_part_type: int
             :returns: dict with disk name keys and tuple (disk, fs) free values
             :rtype: dict
 
@@ -724,13 +724,13 @@ def getFreeSpace(self, disks=None, clearPartType=None):
         if disks is None:
             disks = self.disks
 
-        if clearPartType is None:
-            clearPartType = self.config.clearPartType
+        if clear_part_type is None:
+            clear_part_type = self.config.clear_part_type
 
         free = {}
         for disk in disks:
-            should_clear = self.shouldClear(disk, clearPartType=clearPartType,
-                                            clearPartDisks=[disk.name])
+            should_clear = self.should_clear(disk, clear_part_type=clear_part_type,
+                                            clear_part_disks=[disk.name])
             if should_clear:
                 free[disk.name] = (disk.size, Size(0))
                 continue
@@ -743,9 +743,9 @@ def getFreeSpace(self, disks=None, clearPartType=None):
                     # only check actual filesystems since lvm &c require a bunch of
                     # operations to translate free filesystem space into free disk
                     # space
-                    should_clear = self.shouldClear(partition,
-                                                    clearPartType=clearPartType,
-                                                    clearPartDisks=[disk.name])
+                    should_clear = self.should_clear(partition,
+                                                    clear_part_type=clear_part_type,
+                                                    clear_part_disks=[disk.name])
                     if should_clear:
                         disk_free += partition.size
                     elif hasattr(partition.format, "free"):
@@ -764,7 +764,7 @@ def names(self):
         """ A list of all of the known in-use device names. """
         return self.devicetree.names
 
-    def deviceDeps(self, device):
+    def device_deps(self, device):
         """ Return a list of the devices that depend on the specified device.
 
             :param device: the subtree root device
@@ -772,9 +772,9 @@ def deviceDeps(self, device):
             :returns: list of dependent devices
             :rtype: list
         """
-        return self.devicetree.getDependentDevices(device)
+        return self.devicetree.get_dependent_devices(device)
 
-    def newPartition(self, *args, **kwargs):
+    def new_partition(self, *args, **kwargs):
         """ Return a new (unallocated) PartitionDevice instance.
 
             :keyword fmt_type: format type
@@ -788,7 +788,7 @@ def newPartition(self, *args, **kwargs):
             :class:`~.devices.PartitionDevice` constructor.
         """
         if 'fmt_type' in kwargs:
-            kwargs["fmt"] = getFormat(kwargs.pop("fmt_type"),
+            kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
                                          mountpoint=kwargs.pop("mountpoint",
                                                                None),
                                          **kwargs.pop("fmt_args", {}))
@@ -796,7 +796,7 @@ def newPartition(self, *args, **kwargs):
         if 'name' in kwargs:
             name = kwargs.pop("name")
         else:
-            name = "req%d" % self.nextID
+            name = "req%d" % self.next_id
 
         if "weight" not in kwargs:
             fmt = kwargs.get("fmt")
@@ -809,7 +809,7 @@ def newPartition(self, *args, **kwargs):
 
         return PartitionDevice(name, *args, **kwargs)
 
-    def newMDArray(self, *args, **kwargs):
+    def new_mdarray(self, *args, **kwargs):
         """ Return a new MDRaidArrayDevice instance.
 
             :keyword fmt_type: format type
@@ -828,14 +828,14 @@ def newMDArray(self, *args, **kwargs):
             format type, mountpoint, hostname, and/or product name.
         """
         if 'fmt_type' in kwargs:
-            kwargs["fmt"] = getFormat(kwargs.pop("fmt_type"),
+            kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
                                          mountpoint=kwargs.pop("mountpoint",
                                                                None),
                                          **kwargs.pop("fmt_args", {}))
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safeDeviceName(name)
+            safe_name = self.safe_device_name(name)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                                 safe_name, name)
@@ -843,13 +843,13 @@ def newMDArray(self, *args, **kwargs):
         else:
             swap = getattr(kwargs.get("fmt"), "type", None) == "swap"
             mountpoint = getattr(kwargs.get("fmt"), "mountpoint", None)
-            name = self.suggestDeviceName(prefix=shortProductName,
+            name = self.suggest_device_name(prefix=short_product_name,
                                           swap=swap,
                                           mountpoint=mountpoint)
 
         return MDRaidArrayDevice(name, *args, **kwargs)
 
-    def newVG(self, *args, **kwargs):
+    def new_vg(self, *args, **kwargs):
         """ Return a new LVMVolumeGroupDevice instance.
 
             :returns: the new volume group device
@@ -868,7 +868,7 @@ def newVG(self, *args, **kwargs):
 
         name = kwargs.pop("name", None)
         if name:
-            safe_name = self.safeDeviceName(name)
+            safe_name = self.safe_device_name(name)
             if safe_name != name:
                 log.warning("using '%s' instead of specified name '%s'",
                                 safe_name, name)
@@ -878,14 +878,14 @@ def newVG(self, *args, **kwargs):
             if self.ksdata and self.ksdata.network.hostname is not None:
                 hostname = self.ksdata.network.hostname
 
-            name = self.suggestContainerName(hostname=hostname)
+            name = self.suggest_container_name(hostname=hostname)
 
         if name in self.names:
             raise ValueError("name already in use")
 
         return LVMVolumeGroupDevice(name, pvs, *args, **kwargs)
 
-    def newLV(self, *args, **kwargs):
+    def new_lv(self, *args, **kwargs):
         """ Return a new LVMLogicalVolumeDevice instance.
 
             :keyword fmt_type: format type
@@ -923,16 +923,16 @@ def newLV(self, *args, **kwargs):
 
         mountpoint = kwargs.pop("mountpoint", None)
         if 'fmt_type' in kwargs:
-            kwargs["fmt"] = getFormat(kwargs.pop("fmt_type"),
+            kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
                                          mountpoint=mountpoint,
                                          **kwargs.pop("fmt_args", {}))
 
         name = kwargs.pop("name", None)
         if name:
             # make sure the specified name is sensible
-            safe_vg_name = self.safeDeviceName(vg.name)
+            safe_vg_name = self.safe_device_name(vg.name)
             full_name = "%s-%s" % (safe_vg_name, name)
-            safe_name = self.safeDeviceName(full_name)
+            safe_name = self.safe_device_name(full_name)
             if safe_name != full_name:
                 new_name = safe_name[len(safe_vg_name)+1:]
                 log.warning("using '%s' instead of specified name '%s'",
@@ -948,7 +948,7 @@ def newLV(self, *args, **kwargs):
             if thin_pool:
                 prefix = "pool"
 
-            name = self.suggestDeviceName(parent=vg,
+            name = self.suggest_device_name(parent=vg,
                                           swap=swap,
                                           mountpoint=mountpoint,
                                           prefix=prefix)
@@ -970,7 +970,7 @@ def newLV(self, *args, **kwargs):
 
         return device_class(name, *args, **kwargs)
 
-    def newBTRFS(self, *args, **kwargs):
+    def new_btrfs(self, *args, **kwargs):
         """ Return a new BTRFSVolumeDevice or BRFSSubVolumeDevice.
 
             :keyword fmt_args: arguments for format constructor
@@ -1012,7 +1012,7 @@ def newBTRFS(self, *args, **kwargs):
             if not name:
                 # for btrfs this only needs to ensure the subvol name is not
                 # already in use within the parent volume
-                name = self.suggestDeviceName(mountpoint=mountpoint)
+                name = self.suggest_device_name(mountpoint=mountpoint)
             fmt_args["mountopts"] = "subvol=%s" % name
             fmt_args["subvolspec"] = name
             kwargs.pop("metaDataLevel", None)
@@ -1026,7 +1026,7 @@ def newBTRFS(self, *args, **kwargs):
                 if self.ksdata and self.ksdata.network.hostname is not None:
                     hostname = self.ksdata.network.hostname
 
-                name = self.suggestContainerName(hostname=hostname)
+                name = self.suggest_container_name(hostname=hostname)
             if "label" not in fmt_args:
                 fmt_args["label"] = name
             fmt_args["subvolspec"] = MAIN_VOLUME_ID
@@ -1036,10 +1036,10 @@ def newBTRFS(self, *args, **kwargs):
 
         # this is to avoid auto-scheduled format create actions
         device = dev_class(name, **kwargs)
-        device.format = getFormat("btrfs", **fmt_args)
+        device.format = get_format("btrfs", **fmt_args)
         return device
 
-    def newBTRFSSubVolume(self, *args, **kwargs):
+    def new_btrfs_sub_volume(self, *args, **kwargs):
         """ Return a new BRFSSubVolumeDevice.
 
             :keyword fmt_args: arguments for format constructor
@@ -1059,24 +1059,24 @@ def newBTRFSSubVolume(self, *args, **kwargs):
 
         """
         kwargs["subvol"] = True
-        return self.newBTRFS(*args, **kwargs)
+        return self.new_btrfs(*args, **kwargs)
 
-    def newTmpFS(self, *args, **kwargs):
+    def new_tmp_fs(self, *args, **kwargs):
         """ Return a new TmpFSDevice. """
         return TmpFSDevice(*args, **kwargs)
 
-    def createDevice(self, device):
+    def create_device(self, device):
         """ Schedule creation of a device.
 
             :param device: the device to schedule creation of
             :type device: :class:`~.devices.StorageDevice`
             :rtype: None
         """
-        self.devicetree.registerAction(ActionCreateDevice(device))
-        if device.format.type and not device.formatImmutable:
-            self.devicetree.registerAction(ActionCreateFormat(device))
+        self.devicetree.register_action(ActionCreateDevice(device))
+        if device.format.type and not device.format_immutable:
+            self.devicetree.register_action(ActionCreateFormat(device))
 
-    def destroyDevice(self, device):
+    def destroy_device(self, device):
         """ Schedule destruction of a device.
 
             :param device: the device to schedule destruction of
@@ -1087,14 +1087,14 @@ def destroyDevice(self, device):
             raise ValueError("cannot modify protected device")
 
         if device.format.exists and device.format.type and \
-           not device.formatImmutable:
+           not device.format_immutable:
             # schedule destruction of any formatting while we're at it
-            self.devicetree.registerAction(ActionDestroyFormat(device))
+            self.devicetree.register_action(ActionDestroyFormat(device))
 
         action = ActionDestroyDevice(device)
-        self.devicetree.registerAction(action)
+        self.devicetree.register_action(action)
 
-    def formatDevice(self, device, fmt):
+    def format_device(self, device, fmt):
         """ Schedule formatting of a device.
 
             :param device: the device to create the formatting on
@@ -1111,24 +1111,24 @@ def formatDevice(self, device, fmt):
         if device.protected:
             raise ValueError("cannot modify protected device")
 
-        self.devicetree.registerAction(ActionDestroyFormat(device))
-        self.devicetree.registerAction(ActionCreateFormat(device, fmt))
+        self.devicetree.register_action(ActionDestroyFormat(device))
+        self.devicetree.register_action(ActionCreateFormat(device, fmt))
 
-    def resetDevice(self, device):
+    def reset_device(self, device):
         """ Cancel all scheduled actions and reset formatting.
 
             :param device: the device to reset
             :type device: :class:`~.devices.StorageDevice`
             :rtype: None
         """
-        actions = self.devicetree.findActions(device=device)
+        actions = self.devicetree.find_actions(device=device)
         for action in reversed(actions):
-            self.devicetree.cancelAction(action)
+            self.devicetree.cancel_action(action)
 
         # make sure any random overridden attributes are reset
-        device.format = copy.deepcopy(device.originalFormat)
+        device.format = copy.deepcopy(device.original_format)
 
-    def resizeDevice(self, device, new_size):
+    def resize_device(self, device, new_size):
         """ Schedule a resize of a device and its formatting, if any.
 
             :param device: the device to resize
@@ -1158,14 +1158,14 @@ def resizeDevice(self, device, new_size):
             classes.reverse()
 
         for action_class in classes:
-            self.devicetree.registerAction(action_class(device, new_size))
+            self.devicetree.register_action(action_class(device, new_size))
 
-    def formatByDefault(self, device):
+    def format_by_default(self, device):
         """Return whether the device should be reformatted by default."""
         formatlist = ['/boot', '/var', '/tmp', '/usr']
         exceptlist = ['/home', '/usr/local', '/opt', '/var/www']
 
-        if not device.format.linuxNative:
+        if not device.format.linux_native:
             return False
 
         if device.format.mountable:
@@ -1188,7 +1188,7 @@ def formatByDefault(self, device):
         # be safe for anything else and default to off
         return False
 
-    def mustFormat(self, device):
+    def must_format(self, device):
         """ Return a string explaining why the device must be reformatted.
 
             Return None if the device need not be reformatted.
@@ -1198,7 +1198,7 @@ def mustFormat(self, device):
 
         return None
 
-    def safeDeviceName(self, name):
+    def safe_device_name(self, name):
         """ Convert a device name to something safe and return that.
 
             LVM limits lv names to 128 characters. I don't know the limits for
@@ -1223,7 +1223,7 @@ def safeDeviceName(self, name):
 
         return tmp
 
-    def suggestContainerName(self, hostname=None, prefix=""):
+    def suggest_container_name(self, hostname=None, prefix=""):
         """ Return a reasonable, unused device name.
 
             :keyword hostname: the system's hostname
@@ -1232,12 +1232,12 @@ def suggestContainerName(self, hostname=None, prefix=""):
             :rtype: str
         """
         if not prefix:
-            prefix = shortProductName
+            prefix = short_product_name
 
         # try to create a device name incorporating the hostname
         if hostname not in (None, "", 'localhost', 'localhost.localdomain'):
             template = "%s_%s" % (prefix, hostname.split('.')[0].lower())
-            template = self.safeDeviceName(template)
+            template = self.safe_device_name(template)
         else:
             template = prefix
 
@@ -1261,7 +1261,7 @@ def suggestContainerName(self, hostname=None, prefix=""):
 
         return name
 
-    def suggestDeviceName(self, parent=None, swap=None,
+    def suggest_device_name(self, parent=None, swap=None,
                                   mountpoint=None, prefix=""):
         """ Return a suitable, unused name for a new device.
 
@@ -1288,7 +1288,7 @@ def suggestDeviceName(self, parent=None, swap=None,
         if prefix and body:
             body = "_" + body
 
-        template = self.safeDeviceName(prefix + body)
+        template = self.safe_device_name(prefix + body)
         names = self.names
         name = template
         def full_name(name, parent):
@@ -1317,19 +1317,19 @@ def full_name(name, parent):
 
         return name
 
-    def savePassphrase(self, device):
+    def save_passphrase(self, device):
         """ Save a device's LUKS passphrase in case of reset. """
         passphrase = device.format._LUKS__passphrase
         if passphrase:
-            self.__luksDevs[device.format.uuid] = passphrase
-            self.devicetree.saveLUKSpassphrase(device)
+            self.__luks_devs[device.format.uuid] = passphrase
+            self.devicetree.save_luks_passphrase(device)
 
-    def setupDiskImages(self):
-        self.devicetree.setDiskImages(self.config.diskImages)
-        self.devicetree.setupDiskImages()
+    def setup_disk_images(self):
+        self.devicetree.set_disk_images(self.config.disk_images)
+        self.devicetree.setup_disk_images()
 
     @property
-    def fileSystemFreeSpace(self):
+    def file_system_free_space(self):
         """ Combined free space in / and /usr as :class:`~.size.Size`. """
         mountpoints = ["/", "/usr"]
         free = Size(0)
@@ -1350,14 +1350,14 @@ def fileSystemFreeSpace(self):
             if device.format.exists:
                 free += device.format.free
             else:
-                free += device.format.freeSpaceEstimate(device.size)
+                free += device.format.free_space_estimate(device.size)
 
         return free
 
-    def dumpState(self, suffix):
+    def dump_state(self, suffix):
         """ Dump the current device list to the storage shelf. """
         key = "devices.%d.%s" % (time.time(), suffix)
-        with contextlib.closing(shelve.open(self._dumpFile)) as shelf:
+        with contextlib.closing(shelve.open(self._dump_file)) as shelf:
             try:
                 shelf[key] = [d.dict for d in self.devices]
             except AttributeError:
@@ -1377,46 +1377,46 @@ def packages(self):
 
     def write(self):
         """ Write out all storage-related configuration files. """
-        if not os.path.isdir("%s/etc" % getSysroot()):
-            os.mkdir("%s/etc" % getSysroot())
+        if not os.path.isdir("%s/etc" % get_sysroot()):
+            os.mkdir("%s/etc" % get_sysroot())
 
         self.fsset.write()
-        self.makeMtab()
-        self.iscsi.write(getSysroot(), self)
-        self.fcoe.write(getSysroot())
-        self.zfcp.write(getSysroot())
-        self.write_dasd_conf(self.dasd, getSysroot())
+        self.make_mtab()
+        self.iscsi.write(get_sysroot(), self)
+        self.fcoe.write(get_sysroot())
+        self.zfcp.write(get_sysroot())
+        self.write_dasd_conf(self.dasd, get_sysroot())
 
     def write_dasd_conf(self, disks, root):
         """ Write /etc/dasd.conf to target system for all DASD devices
             configured during installation.
         """
-        if not (arch.isS390() and disks):
+        if not (arch.is_s390() and disks):
             return
 
         with open(os.path.realpath(root + "/etc/dasd.conf"), "w") as f:
             for dasd in sorted(disks, key=lambda d: d.name):
-                fields = [dasd.busid] + dasd.getOpts()
+                fields = [dasd.busid] + dasd.get_opts()
                 f.write("%s\n" % " ".join(fields),)
 
-    def turnOnSwap(self):
-        self.fsset.turnOnSwap(rootPath=getSysroot())
+    def turn_on_swap(self):
+        self.fsset.turn_on_swap(root_path=get_sysroot())
 
-    def mountFilesystems(self, readOnly=None, skipRoot=False):
-        self.fsset.mountFilesystems(rootPath=getSysroot(),
-                                    readOnly=readOnly, skipRoot=skipRoot)
+    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)
 
-    def umountFilesystems(self, swapoff=True):
-        self.fsset.umountFilesystems(swapoff=swapoff)
+    def umount_filesystems(self, swapoff=True):
+        self.fsset.umount_filesystems(swapoff=swapoff)
 
-    def parseFSTab(self, chroot=None):
-        self.fsset.parseFSTab(chroot=chroot)
+    def parse_fstab(self, chroot=None):
+        self.fsset.parse_fstab(chroot=chroot)
 
-    def mkDevRoot(self):
-        self.fsset.mkDevRoot()
+    def mk_dev_root(self):
+        self.fsset.mk_dev_root()
 
-    def createSwapFile(self, device, size):
-        self.fsset.createSwapFile(device, size)
+    def create_swap_file(self, device, size):
+        self.fsset.create_swap_file(device, size)
 
     @property
     def bootloader(self):
@@ -1425,15 +1425,15 @@ def bootloader(self):
 
         return self._bootloader
 
-    def updateBootLoaderDiskList(self):
+    def update_boot_loader_disk_list(self):
         if not self.bootloader:
             return
 
         boot_disks = [d for d in self.disks if d.partitioned]
-        boot_disks.sort(key=self.compareDisksKey)
+        boot_disks.sort(key=self.compare_disks_key)
         self.bootloader.set_disk_list(boot_disks)
 
-    def setUpBootLoader(self, early=False):
+    def set_up_boot_loader(self, early=False):
         """ Propagate ksdata into BootLoader.
 
             :keyword bool early: Set to True to skip stage1_device setup
@@ -1454,32 +1454,32 @@ def setUpBootLoader(self, early=False):
 
         # Need to make sure bootDrive has been setup from the latest information
         self.ksdata.bootloader.execute(self, self.ksdata, None)
-        self.bootloader.stage1_disk = self.devicetree.resolveDevice(self.ksdata.bootloader.bootDrive)
-        self.bootloader.stage2_device = self.bootDevice
+        self.bootloader.stage1_disk = self.devicetree.resolve_device(self.ksdata.bootloader.bootDrive)
+        self.bootloader.stage2_device = self.boot_device
         if not early:
             self.bootloader.set_stage1_device(self.devices)
 
     @property
-    def bootDisk(self):
+    def boot_disk(self):
         disk = None
         if self.ksdata:
             spec = self.ksdata.bootloader.bootDrive
-            disk = self.devicetree.resolveDevice(spec)
+            disk = self.devicetree.resolve_device(spec)
         return disk
 
     @property
-    def bootDevice(self):
+    def boot_device(self):
         dev = None
         if self.fsset:
-            dev = self.mountpoints.get("/boot", self.rootDevice)
+            dev = self.mountpoints.get("/boot", self.root_device)
         return dev
 
     @property
-    def bootLoaderDevice(self):
+    def boot_loader_device(self):
         return getattr(self.bootloader, "stage1_device", None)
 
     @property
-    def bootFSTypes(self):
+    def boot_fstypes(self):
         """A list of all valid filesystem types for the boot partition."""
         fstypes = []
         if self.bootloader:
@@ -1487,14 +1487,14 @@ def bootFSTypes(self):
         return fstypes
 
     @property
-    def defaultBootFSType(self):
+    def default_boot_fstype(self):
         """The default filesystem type for the boot partition."""
-        if self._defaultBootFSType:
-            return self._defaultBootFSType
+        if self._default_boot_fstype:
+            return self._default_boot_fstype
 
         fstype = None
         if self.bootloader:
-            fstype = self.bootFSTypes[0]
+            fstype = self.boot_fstypes[0]
         return fstype
 
     def _check_valid_fstype(self, newtype):
@@ -1502,18 +1502,18 @@ def _check_valid_fstype(self, newtype):
 
             Raise ValueError on invalid input.
         """
-        fmt = getFormat(newtype)
+        fmt = get_format(newtype)
         if fmt.type is None:
             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.linuxNative):
+            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)
 
-        self._defaultFSType = newtype # pylint: disable=attribute-defined-outside-init
+        self._default_fstype = newtype # pylint: disable=attribute-defined-outside-init
 
-    def setDefaultBootFSType(self, newtype):
+    def set_default_boot_fstype(self, newtype):
         """ Set the default /boot fstype for this instance.
 
             Raise ValueError on invalid input.
@@ -1521,13 +1521,13 @@ def setDefaultBootFSType(self, newtype):
         log.debug("trying to set new default /boot fstype to '%s'", newtype)
         # This will raise ValueError if it isn't valid
         self._check_valid_fstype(newtype)
-        self._defaultBootFSType = newtype
+        self._default_boot_fstype = newtype
 
     @property
-    def defaultFSType(self):
-        return self._defaultFSType
+    def default_fstype(self):
+        return self._default_fstype
 
-    def setDefaultFSType(self, newtype):
+    def set_default_fstype(self, newtype):
         """ Set the default fstype for this instance.
 
             Raise ValueError on invalid input.
@@ -1535,20 +1535,20 @@ def setDefaultFSType(self, newtype):
         log.debug("trying to set new default fstype to '%s'", newtype)
         # This will raise ValueError if it isn't valid
         self._check_valid_fstype(newtype)
-        self._defaultFSType = newtype # pylint: disable=attribute-defined-outside-init
+        self._default_fstype = newtype # pylint: disable=attribute-defined-outside-init
 
     @property
     def mountpoints(self):
         return self.fsset.mountpoints
 
     @property
-    def rootDevice(self):
-        return self.fsset.rootDevice
+    def root_device(self):
+        return self.fsset.root_device
 
-    def makeMtab(self):
+    def make_mtab(self):
         path = "/etc/mtab"
         target = "/proc/self/mounts"
-        path = os.path.normpath("%s/%s" % (getSysroot(), path))
+        path = os.path.normpath("%s/%s" % (get_sysroot(), path))
 
         if os.path.islink(path):
             # return early if the mtab symlink is already how we like it
@@ -1562,24 +1562,24 @@ def makeMtab(self):
 
         os.symlink(target, path)
 
-    def compareDisks(self, first, second):
+    def compare_disks(self, first, second):
         if not isinstance(first, str):
             first = first.name
         if not isinstance(second, str):
             second = second.name
 
-        if first in self.eddDict and second in self.eddDict:
-            one = self.eddDict[first]
-            two = self.eddDict[second]
+        if first in self.edd_dict and second in self.edd_dict:
+            one = self.edd_dict[first]
+            two = self.edd_dict[second]
             if (one < two):
                 return -1
             elif (one > two):
                 return 1
 
         # if one is in the BIOS and the other not prefer the one in the BIOS
-        if first in self.eddDict:
+        if first in self.edd_dict:
             return -1
-        if second in self.eddDict:
+        if second in self.edd_dict:
             return 1
 
         if first.startswith("hd"):
@@ -1621,28 +1621,28 @@ def compareDisks(self, first, second):
         return 0
 
     @property
-    def compareDisksKey(self):
-        return functools.cmp_to_key(self.compareDisks)
+    def compare_disks_key(self):
+        return functools.cmp_to_key(self.compare_disks)
 
-    def getFSType(self, mountpoint=None):
+    def get_fstype(self, mountpoint=None):
         """ Return the default filesystem type based on mountpoint. """
-        fstype = self.defaultFSType
+        fstype = self.default_fstype
         if not mountpoint:
             # just return the default
             pass
         elif mountpoint.lower() in ("swap", "biosboot", "prepboot"):
             fstype = mountpoint.lower()
         elif mountpoint == "/boot":
-            fstype = self.defaultBootFSType
+            fstype = self.default_boot_fstype
         elif mountpoint == "/boot/efi":
-            if arch.isMactel():
+            if arch.is_mactel():
                 fstype = "macefi"
             else:
                 fstype = "efi"
 
         return fstype
 
-    def factoryDevice(self, device_type, size, **kwargs):
+    def factory_device(self, device_type, size, **kwargs):
         """ Schedule creation of a device based on a top-down specification.
 
             :param device_type: device type constant
@@ -1663,7 +1663,7 @@ def factoryDevice(self, device_type, size, **kwargs):
         #    return
 
         if not kwargs.get("fstype"):
-            kwargs["fstype"] = self.getFSType(mountpoint=kwargs.get("mountpoint"))
+            kwargs["fstype"] = self.get_fstype(mountpoint=kwargs.get("mountpoint"))
             if kwargs["fstype"] == "swap":
                 kwargs["mountpoint"] = None
 
@@ -1684,23 +1684,23 @@ def factoryDevice(self, device_type, size, **kwargs):
     def copy(self):
         log.debug("starting Blivet copy")
         new = copy.deepcopy(self)
-        # go through and re-get partedPartitions from the disks since they
+        # 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)]
         for partition in new.partitions + hidden_partitions:
-            if not partition._partedPartition:
+            if not partition._parted_partition:
                 continue
 
             # update the refs in req_disks as well
-            req_disks = (new.devicetree.getDeviceByID(disk.id) for disk in partition.req_disks)
+            req_disks = (new.devicetree.get_device_by_id(disk.id) for disk in partition.req_disks)
             partition.req_disks = [disk for disk in req_disks if disk is not None]
 
-            p = partition.disk.format.partedDisk.getPartitionByPath(partition.path)
-            partition.partedPartition = p
+            p = partition.disk.format.parted_disk.getPartitionByPath(partition.path)
+            partition.parted_partition = p
 
         for root in new.roots:
-            root.swaps = [new.devicetree.getDeviceByID(d.id, hidden=True) for d in root.swaps]
+            root.swaps = [new.devicetree.get_device_by_id(d.id, hidden=True) for d in root.swaps]
             root.swaps = [s for s in root.swaps if s]
 
             removed = set()
@@ -1708,7 +1708,7 @@ def copy(self):
                 if old_dev is None:
                     continue
 
-                new_dev = new.devicetree.getDeviceByID(old_dev.id, hidden=True)
+                new_dev = new.devicetree.get_device_by_id(old_dev.id, hidden=True)
                 if new_dev is None:
                     # if the device has been removed don't include this
                     # mountpoint at all
@@ -1722,7 +1722,7 @@ def copy(self):
         log.debug("finished Blivet copy")
         return new
 
-    def updateKSData(self):
+    def update_ksdata(self):
         """ Update ksdata to reflect the settings of this Blivet instance. """
         if not self.ksdata or not self.mountpoints:
             return
@@ -1742,21 +1742,21 @@ def updateKSData(self):
         # bootloader
 
         # ignoredisk
-        if self.config.ignoredDisks:
-            self.ksdata.ignoredisk.drives = self.config.ignoredDisks[:]
-        elif self.config.exclusiveDisks:
-            self.ksdata.ignoredisk.onlyuse = self.config.exclusiveDisks[:]
+        if self.config.ignored_disks:
+            self.ksdata.ignoredisk.drives = self.config.ignored_disks[:]
+        elif self.config.exclusive_disks:
+            self.ksdata.ignoredisk.onlyuse = self.config.exclusive_disks[:]
 
         # autopart
-        self.ksdata.autopart.autopart = self.doAutoPart
-        self.ksdata.autopart.type = self.autoPartType
-        self.ksdata.autopart.encrypted = self.encryptedAutoPart
+        self.ksdata.autopart.autopart = self.do_autopart
+        self.ksdata.autopart.type = self.autopart_type
+        self.ksdata.autopart.encrypted = self.encrypted_autopart
 
         # clearpart
-        self.ksdata.clearpart.type = self.config.clearPartType
-        self.ksdata.clearpart.drives = self.config.clearPartDisks[:]
-        self.ksdata.clearpart.devices = self.config.clearPartDevices[:]
-        self.ksdata.clearpart.initAll = self.config.initializeDisks
+        self.ksdata.clearpart.type = self.config.clear_part_type
+        self.ksdata.clearpart.drives = self.config.clear_part_disks[:]
+        self.ksdata.clearpart.devices = self.config.clear_part_devices[:]
+        self.ksdata.clearpart.init_all = self.config.initialize_disks
         if self.ksdata.clearpart.type == CLEARPART_TYPE_NONE:
             # Make a list of initialized disks and of removed partitions. If any
             # partitions were removed from disks that were not completely
@@ -1769,7 +1769,7 @@ def updateKSData(self):
             fresh_disks = [d.name for d in self.disks if d.partitioned and
                                                          not d.format.exists]
 
-            destroy_actions = self.devicetree.findActions(action_type="destroy",
+            destroy_actions = self.devicetree.find_actions(action_type="destroy",
                                                           object_type="device")
 
             cleared_partitions = []
@@ -1792,16 +1792,16 @@ def updateKSData(self):
                 self.ksdata.clearpart.type = CLEARPART_TYPE_ALL
                 self.ksdata.clearpart.drives = fresh_disks
 
-        if self.doAutoPart:
+        if self.do_autopart:
             return
 
-        self._updateCustomStorageKSData()
+        self._update_custom_storage_ksdata()
 
-    def _updateCustomStorageKSData(self):
+    def _update_custom_storage_ksdata(self):
         """ Update KSData for custom storage. """
 
         # custom storage
-        ksMap = {PartitionDevice: ("PartData", "partition"),
+        ks_map = {PartitionDevice: ("PartData", "partition"),
                  TmpFSDevice: ("PartData", "partition"),
                  LVMLogicalVolumeDevice: ("LogVolData", "logvol"),
                  LVMVolumeGroupDevice: ("VolGroupData", "volgroup"),
@@ -1817,12 +1817,12 @@ def _updateCustomStorageKSData(self):
 
         devices.sort(key=lambda d: len(d.ancestors))
         for device in devices:
-            cls = next((c for c in ksMap if isinstance(device, c)), None)
+            cls = next((c for c in ks_map if isinstance(device, c)), None)
             if cls is None:
                 log.info("omitting ksdata: %s", device)
                 continue
 
-            class_attr, list_attr = ksMap[cls]
+            class_attr, list_attr = ks_map[cls]
 
             cls = getattr(self.ksdata, class_attr)
             data = cls()    # all defaults
@@ -1835,24 +1835,24 @@ def _updateCustomStorageKSData(self):
 
             device = complements[0] if complements else device
 
-            device.populateKSData(data)
+            device.populate_ksdata(data)
 
             parent = getattr(self.ksdata, list_attr)
             parent.dataList().append(data)
 
     @property
-    def freeSpaceSnapshot(self):
+    def free_space_snapshot(self):
         # if no snapshot is available, do it now and return it
-        self._free_space_snapshot = self._free_space_snapshot or self.getFreeSpace()
+        self._free_space_snapshot = self._free_space_snapshot or self.get_free_space()
 
         return self._free_space_snapshot
 
-    def createFreeSpaceSnapshot(self):
-        self._free_space_snapshot = self.getFreeSpace()
+    def create_free_space_snapshot(self):
+        self._free_space_snapshot = self.get_free_space()
 
         return self._free_space_snapshot
 
-    def addFstabSwap(self, device):
+    def add_fstab_swap(self, device):
         """
         Add swap device to the list of swaps that should appear in the fstab.
 
@@ -1861,9 +1861,9 @@ def addFstabSwap(self, device):
 
         """
 
-        self.fsset.addFstabSwap(device)
+        self.fsset.add_fstab_swap(device)
 
-    def removeFstabSwap(self, device):
+    def remove_fstab_swap(self, device):
         """
         Remove swap device from the list of swaps that should appear in the fstab.
 
@@ -1872,9 +1872,9 @@ def removeFstabSwap(self, device):
 
         """
 
-        self.fsset.removeFstabSwap(device)
+        self.fsset.remove_fstab_swap(device)
 
-    def setFstabSwaps(self, devices):
+    def set_fstab_swaps(self, devices):
         """
         Set swap devices that should appear in the fstab.
 
@@ -1884,4 +1884,4 @@ def setFstabSwaps(self, devices):
 
         """
 
-        self.fsset.setFstabSwaps(devices)
+        self.fsset.set_fstab_swaps(devices)
diff --git a/blivet/callbacks.py b/blivet/callbacks.py
index db52dc0..23ac52e 100644
--- a/blivet/callbacks.py
+++ b/blivet/callbacks.py
@@ -27,7 +27,7 @@
 from collections import namedtuple
 
 # A private namedtuple class with self-descriptive fields for passing callbacks
-# to the blivet.doIt method. Each field should be populated with a function
+# to the blivet.do_it method. Each field should be populated with a function
 # taking the matching CallbackTypeData (create_format_pre ->
 # CreateFormatPreData, etc.)  object or None if no such callback is provided.
 _CallbacksRegister = namedtuple("_CallbacksRegister",
diff --git a/blivet/deviceaction.py b/blivet/deviceaction.py
index 41b8289..820a34f 100644
--- a/blivet/deviceaction.py
+++ b/blivet/deviceaction.py
@@ -27,7 +27,7 @@
 from .util import get_current_entropy
 from .devices import StorageDevice
 from .devices import PartitionDevice, LVMLogicalVolumeDevice
-from .formats import getFormat, luks
+from .formats import get_format, luks
 from parted import partitionFlag, PARTITION_LBA
 from .i18n import _, N_
 from .callbacks import CreateFormatPreData, CreateFormatPostData
@@ -142,14 +142,14 @@ class DeviceAction(util.ObjectID):
 """
     type = ACTION_TYPE_NONE
     obj = ACTION_OBJECT_NONE
-    typeDescStr = ""
+    type_desc_str = ""
 
     def __init__(self, device):
         util.ObjectID.__init__(self)
         if not isinstance(device, StorageDevice):
             raise ValueError("arg 1 must be a StorageDevice instance")
 
-        unavailable_dependencies = device.unavailableDependencies
+        unavailable_dependencies = device.unavailable_dependencies
         if unavailable_dependencies:
             dependencies_str = ", ".join(str(d) for d in unavailable_dependencies)
             raise ValueError("device type %s requires unavailable_dependencies: %s" % (device.type, dependencies_str))
@@ -167,7 +167,7 @@ def execute(self, callbacks=None):
         Perform the action.
 
         :param callbacks: callbacks to be run when matching actions are
-                          executed (see :meth:`~.blivet.Blivet.doIt`)
+                          executed (see :meth:`~.blivet.Blivet.do_it`)
 
         """
         # pylint: disable=unused-argument
@@ -183,43 +183,43 @@ def cancel(self):
         self._applied = False
 
     @property
-    def isDestroy(self):
+    def is_destroy(self):
         return self.type == ACTION_TYPE_DESTROY
 
     @property
-    def isCreate(self):
+    def is_create(self):
         return self.type == ACTION_TYPE_CREATE
 
     @property
-    def isResize(self):
+    def is_resize(self):
         return self.type == ACTION_TYPE_RESIZE
 
     @property
-    def isShrink(self):
-        return (self.isResize and self.dir == RESIZE_SHRINK) # pylint: disable=no-member
+    def is_shrink(self):
+        return (self.is_resize and self.dir == RESIZE_SHRINK) # pylint: disable=no-member
 
     @property
-    def isGrow(self):
-        return (self.isResize and self.dir == RESIZE_GROW) # pylint: disable=no-member
+    def is_grow(self):
+        return (self.is_resize and self.dir == RESIZE_GROW) # pylint: disable=no-member
 
     @property
-    def isAdd(self):
+    def is_add(self):
         return self.type == ACTION_TYPE_ADD
 
     @property
-    def isRemove(self):
+    def is_remove(self):
         return self.type == ACTION_TYPE_REMOVE
 
     @property
-    def isDevice(self):
+    def is_device(self):
         return self.obj == ACTION_OBJECT_DEVICE
 
     @property
-    def isContainer(self):
+    def is_container(self):
         return self.obj == ACTION_OBJECT_CONTAINER
 
     @property
-    def isFormat(self):
+    def is_format(self):
         return self.obj == ACTION_OBJECT_FORMAT
 
     @property
@@ -227,28 +227,28 @@ def format(self):
         return self.device.format
 
     @property
-    def typeString(self):
+    def type_string(self):
         """ String indicating if this action is a create, destroy or resize. """
         return action_strings[self.type]
 
     @property
-    def objectString(self):
+    def object_string(self):
         """ String indicating if this action's operand is device or format. """
         return object_strings[self.obj]
 
     @property
-    def resizeString(self):
+    def resize_string(self):
         """ String representing the direction of a resize action. """
         s = ""
-        if self.isResize:
+        if self.is_resize:
             s = resize_strings[self.dir] # pylint: disable=no-member
 
         return s
 
     @property
-    def objectTypeString(self):
+    def object_type_string(self):
         """ String representing the type of the operand device or format. """
-        if self.isFormat:
+        if self.is_format:
             s = self.format.name
         else:
             s = self.device.type
@@ -256,30 +256,30 @@ def objectTypeString(self):
         return s
 
     @property
-    def typeDesc(self):
-        return _(self.typeDescStr)
+    def type_desc(self):
+        return _(self.type_desc_str)
 
     # Force str and unicode types since there's a good chance that the self.device.*
     # strings are unicode.
-    def _toString(self):
-        s = "[%d] %s" % (self.id, self.typeDescStr)
-        if self.isResize:
-            s += " (%s)" % self.resizeString
-        if self.isFormat:
+    def _to_string(self):
+        s = "[%d] %s" % (self.id, self.type_desc_str)
+        if self.is_resize:
+            s += " (%s)" % self.resize_string
+        if self.is_format:
             s += " %s on" % self.format.desc
         s += " %s %s (id %d)" % (self.device.type, self.device.name,
                                  self.device.id)
         return s
 
     def __str__(self):
-        return util.stringize(self._toString())
+        return util.stringize(self._to_string())
 
     def __unicode__(self):
-        return util.unicodeize(self._toString())
+        return util.unicodeize(self._to_string())
 
     def requires(self, action):
         """ Return True if self requires action. """
-        return (not (self.isContainer or action.isContainer) and
+        return (not (self.is_container or action.is_container) and
                 self.type < action.type)
 
     def obsoletes(self, action):
@@ -298,7 +298,7 @@ class ActionCreateDevice(DeviceAction):
     """ Action representing the creation of a new device. """
     type = ACTION_TYPE_CREATE
     obj = ACTION_OBJECT_DEVICE
-    typeDescStr = N_("create device")
+    type_desc_str = N_("create device")
 
     def __init__(self, device):
         if device.exists:
@@ -323,18 +323,18 @@ def requires(self, action):
                 - the other action adds a member to this device's container
         """
         rc = super(ActionCreateDevice, self).requires(action)
-        if self.device.dependsOn(action.device):
+        if self.device.depends_on(action.device):
             rc = True
-        elif (action.isCreate and action.isDevice and
+        elif (action.is_create and action.is_device and
               isinstance(self.device, PartitionDevice) and
               isinstance(action.device, PartitionDevice) and
               self.device.disk == action.device.disk):
             # create partitions in ascending numerical order
-            selfNum = self.device.partedPartition.number
-            otherNum = action.device.partedPartition.number
-            if selfNum > otherNum:
+            self_num = self.device.parted_partition.number
+            other_num = action.device.parted_partition.number
+            if self_num > other_num:
                 rc = True
-        elif (action.isCreate and action.isDevice and
+        elif (action.is_create and action.is_device and
               isinstance(self.device, LVMLogicalVolumeDevice) and
               isinstance(action.device, LVMLogicalVolumeDevice) and
               self.device.vg == action.device.vg):
@@ -342,7 +342,7 @@ def requires(self, action):
             # is not taken by non-cached LVs
             if not self.device.cached and action.device.cached:
                 rc = True
-        elif (action.isAdd and action.container == self.container):
+        elif (action.is_add and action.container == self.container):
             rc = True
 
         return rc
@@ -352,7 +352,7 @@ class ActionDestroyDevice(DeviceAction):
     """ An action representing the deletion of an existing device. """
     type = ACTION_TYPE_DESTROY
     obj = ACTION_OBJECT_DEVICE
-    typeDescStr = N_("destroy device")
+    type_desc_str = N_("destroy device")
 
     def __init__(self, device):
         # XXX should we insist that device.fs be None?
@@ -374,22 +374,22 @@ def requires(self, action):
                 - the other action removes this action's device from a container
         """
         rc = super(ActionDestroyDevice, self).requires(action)
-        if action.device.dependsOn(self.device) and action.isDestroy:
+        if action.device.depends_on(self.device) and action.is_destroy:
             rc = True
-        elif (action.isDestroy and action.isDevice and
+        elif (action.is_destroy and action.is_device and
               isinstance(self.device, PartitionDevice) and
               isinstance(action.device, PartitionDevice) and
               self.device.disk == action.device.disk):
             # remove partitions in descending numerical order
-            selfNum = self.device.partedPartition.number
-            otherNum = action.device.partedPartition.number
-            if selfNum < otherNum:
+            self_num = self.device.parted_partition.number
+            other_num = action.device.parted_partition.number
+            if self_num < other_num:
                 rc = True
-        elif (action.isDestroy and action.isFormat and
+        elif (action.is_destroy and action.is_format and
               action.device.id == self.device.id):
             # device destruction comes after destruction of device's format
             rc = True
-        elif (action.isRemove and action.device == self.device):
+        elif (action.is_remove and action.device == self.device):
             rc = True
         return rc
 
@@ -412,11 +412,11 @@ def obsoletes(self, action):
                 rc = True
             elif self.id > action.id and \
                  self.device.exists and \
-                 not (action.isDestroy and action.isFormat):
+                 not (action.is_destroy and action.is_format):
                 rc = True
-            elif action.isAdd and (action.device == self.device):
+            elif action.is_add and (action.device == self.device):
                 rc = True
-        elif action.isAdd and (action.container == self.device):
+        elif action.is_add and (action.container == self.device):
             rc = True
 
         return rc
@@ -426,39 +426,39 @@ class ActionResizeDevice(DeviceAction):
     """ An action representing the resizing of an existing device. """
     type = ACTION_TYPE_RESIZE
     obj = ACTION_OBJECT_DEVICE
-    typeDescStr = N_("resize device")
+    type_desc_str = N_("resize device")
 
     def __init__(self, device, newsize):
         if not device.resizable:
             raise ValueError("device is not resizable")
 
-        if device.currentSize == newsize:
+        if device.current_size == newsize:
             raise ValueError("new size same as old size")
 
-        if newsize < device.minSize:
+        if newsize < device.min_size:
             raise ValueError("new size is too small")
 
-        if device.maxSize and newsize > device.maxSize:
+        if device.max_size and newsize > device.max_size:
             raise ValueError("new size is too large")
 
         DeviceAction.__init__(self, device)
-        if newsize > device.currentSize:
+        if newsize > device.current_size:
             self.dir = RESIZE_GROW
         else:
             self.dir = RESIZE_SHRINK
-        if device.targetSize > Size(0):
-            self.origsize = device.targetSize
+        if device.target_size > Size(0):
+            self.origsize = device.target_size
         else:
             self.origsize = device.size
 
-        self._targetSize = newsize
+        self._target_size = newsize
 
     def apply(self):
         """ apply changes related to the action to the device(s) """
         if self._applied:
             return
 
-        self.device.targetSize = self._targetSize
+        self.device.target_size = self._target_size
         super(ActionResizeDevice, self).apply()
 
     def execute(self, callbacks=None):
@@ -469,7 +469,7 @@ def cancel(self):
         if not self._applied:
             return
 
-        self.device.targetSize = self.origsize
+        self.device.target_size = self.origsize
         super(ActionResizeDevice, self).cancel()
 
     def requires(self, action):
@@ -487,18 +487,18 @@ def requires(self, action):
                 - the other action adds a member to this device's container
         """
         retval = super(ActionResizeDevice, self).requires(action)
-        if action.isResize:
+        if action.is_resize:
             if self.device.id == action.device.id and \
                self.dir == action.dir and \
-               action.isFormat and self.isShrink:
+               action.is_format and self.is_shrink:
                 retval = True
-            elif action.isGrow and self.device.dependsOn(action.device):
+            elif action.is_grow and self.device.depends_on(action.device):
                 retval = True
-            elif action.isShrink and action.device.dependsOn(self.device):
+            elif action.is_shrink and action.device.depends_on(self.device):
                 retval = True
-        elif (action.isRemove and action.device == self.device):
+        elif (action.is_remove and action.device == self.device):
             retval = True
-        elif (action.isAdd and action.container == self.container):
+        elif (action.is_add and action.container == self.container):
             retval = True
 
         return retval
@@ -508,7 +508,7 @@ class ActionCreateFormat(DeviceAction):
     """ An action representing creation of a new filesystem. """
     type = ACTION_TYPE_CREATE
     obj = ACTION_OBJECT_FORMAT
-    typeDescStr = N_("create format")
+    type_desc_str = N_("create format")
 
     def __init__(self, device, fmt=None):
         """
@@ -520,14 +520,14 @@ def __init__(self, device, fmt=None):
             If no format is specified, it is assumed that the format is already
             associated with the device.
         """
-        if device.formatImmutable:
+        if device.format_immutable:
             raise ValueError("this device's formatting cannot be modified")
 
         DeviceAction.__init__(self, device)
         if fmt:
-            self.origFormat = device.format
+            self.orig_format = device.format
         else:
-            self.origFormat = getFormat(None)
+            self.orig_format = get_format(None)
 
         self._format = fmt or device.format
 
@@ -554,17 +554,17 @@ def execute(self, callbacks=None):
         if isinstance(self.device, PartitionDevice):
             for flag in partitionFlag.keys():
                 # Keep the LBA flag on pre-existing partitions
-                if flag in [ PARTITION_LBA, self.format.partedFlag ]:
+                if flag in [ PARTITION_LBA, self.format.parted_flag ]:
                     continue
-                self.device.unsetFlag(flag)
+                self.device.unset_flag(flag)
 
-            if self.format.partedFlag is not None:
-                self.device.setFlag(self.format.partedFlag)
+            if self.format.parted_flag is not None:
+                self.device.set_flag(self.format.parted_flag)
 
-            if self.format.partedSystem is not None:
-                self.device.partedPartition.system = self.format.partedSystem
+            if self.format.parted_system is not None:
+                self.device.parted_partition.system = self.format.parted_system
 
-            self.device.disk.format.commitToDisk()
+            self.device.disk.format.commit_to_disk()
             udev.settle()
 
         if isinstance(self.device.format, luks.LUKS):
@@ -587,18 +587,18 @@ def execute(self, callbacks=None):
 
         self.device.setup()
         self.device.format.create(device=self.device.path,
-                                  options=self.device.formatArgs)
+                                  options=self.device.format_args)
 
         # Get the UUID now that the format is created
         udev.settle()
-        self.device.updateSysfsPath()
-        info = udev.get_device(self.device.sysfsPath)
+        self.device.update_sysfs_path()
+        info = udev.get_device(self.device.sysfs_path)
         # only do this if the format has a device known to udev
         # (the format might not have a normal device at all)
         if info:
             if self.device.format.type != "btrfs":
                 self.device.format.uuid = udev.device_get_uuid(info)
-            self.device.deviceLinks = udev.device_get_symlinks(info)
+            self.device.device_links = udev.device_get_symlinks(info)
         elif self.device.format.type != "tmpfs":
             # udev lookup failing is a serious issue for anything other than tmpfs
             log.error("udev lookup failed for device: %s", self.device)
@@ -611,7 +611,7 @@ def cancel(self):
         if not self._applied:
             return
 
-        self.device.format = self.origFormat
+        self.device.format = self.orig_format
         super(ActionCreateFormat, self).cancel()
 
     def requires(self, action):
@@ -626,10 +626,10 @@ def requires(self, action):
                   device
         """
         return (super(ActionCreateFormat, self).requires(action) or
-                (self.device.dependsOn(action.device) and
-                 not ((action.isDestroy and action.isDevice) or
-                      action.isContainer)) or
-                (action.isDevice and (action.isCreate or action.isResize) and
+                (self.device.depends_on(action.device) and
+                 not ((action.is_destroy and action.is_device) or
+                      action.is_container)) or
+                (action.is_device and (action.is_create or action.is_resize) and
                  self.device.id == action.device.id))
 
     def obsoletes(self, action):
@@ -642,7 +642,7 @@ def obsoletes(self, action):
         """
         return (self.device.id == action.device.id and
                 self.obj == action.obj and
-                not (action.isDestroy and action.format.exists) and
+                not (action.is_destroy and action.format.exists) and
                 self.id > action.id)
 
 
@@ -650,14 +650,14 @@ class ActionDestroyFormat(DeviceAction):
     """ An action representing the removal of an existing filesystem. """
     type = ACTION_TYPE_DESTROY
     obj = ACTION_OBJECT_FORMAT
-    typeDescStr = N_("destroy format")
+    type_desc_str = N_("destroy format")
 
     def __init__(self, device):
-        if device.formatImmutable:
+        if device.format_immutable:
             raise ValueError("this device's formatting cannot be modified")
 
         DeviceAction.__init__(self, device)
-        self.origFormat = self.device.format
+        self.orig_format = self.device.format
 
         if not device.format.destroyable:
             raise ValueError("resource to destroy this format type %s is unavailable" % device.format.type)
@@ -683,12 +683,12 @@ def cancel(self):
         if not self._applied:
             return
 
-        self.device.format = self.origFormat
+        self.device.format = self.orig_format
         super(ActionDestroyFormat, self).cancel()
 
     @property
     def format(self):
-        return self.origFormat
+        return self.orig_format
 
     def requires(self, action):
         """ Return True if self requires action.
@@ -700,9 +700,9 @@ def requires(self, action):
                 - the other action removes this action's device from a container
         """
         retval = super(ActionDestroyFormat, self).requires(action)
-        if action.device.dependsOn(self.device) and action.isDestroy:
+        if action.device.depends_on(self.device) and action.is_destroy:
             retval = True
-        elif (action.isRemove and action.device == self.device):
+        elif (action.is_remove and action.device == self.device):
             retval = True
 
         return retval
@@ -724,7 +724,7 @@ def obsoletes(self, action):
         same_device = self.device.id == action.device.id
         format_action = self.obj == action.obj
         if same_device and format_action:
-            if action.isDestroy:
+            if action.is_destroy:
                 if self.format.exists and not action.format.exists:
                     retval = True
                 elif not self.format.exists and action.format.exists:
@@ -746,37 +746,37 @@ class ActionResizeFormat(DeviceAction):
     """
     type = ACTION_TYPE_RESIZE
     obj = ACTION_OBJECT_FORMAT
-    typeDescStr = N_("resize format")
+    type_desc_str = N_("resize format")
 
     def __init__(self, device, newsize):
-        if device.formatImmutable:
+        if device.format_immutable:
             raise ValueError("this device's formatting cannot be modified")
 
         if not device.format.resizable:
             raise ValueError("format is not resizable")
 
-        if device.format.currentSize == newsize:
+        if device.format.current_size == newsize:
             raise ValueError("new size same as old size")
 
         DeviceAction.__init__(self, device)
-        if newsize > device.format.currentSize:
+        if newsize > device.format.current_size:
             self.dir = RESIZE_GROW
         else:
             self.dir = RESIZE_SHRINK
 
-        if device.format.targetSize > Size(0):
-            self.origSize = device.format.targetSize
-        # no targetSize -- original size for device was its currentSize
+        if device.format.target_size > Size(0):
+            self.orig_size = device.format.target_size
+        # no target_size -- original size for device was its current_size
         else:
-            self.origSize = device.format.currentSize
+            self.orig_size = device.format.current_size
 
-        self._targetSize = newsize
+        self._target_size = newsize
 
     def apply(self):
         if self._applied:
             return
 
-        self.device.format.targetSize = self._targetSize
+        self.device.format.target_size = self._target_size
         super(ActionResizeFormat, self).apply()
 
     def execute(self, callbacks=None):
@@ -786,7 +786,7 @@ def execute(self, callbacks=None):
             callbacks.resize_format_pre(ResizeFormatPreData(msg))
 
         self.device.setup(orig=True)
-        self.device.format.doResize()
+        self.device.format.do_resize()
 
         if callbacks and callbacks.resize_format_post:
             msg = _("Resized filesystem on %(device)s") % {"device": self.device.path}
@@ -796,7 +796,7 @@ def cancel(self):
         if not self._applied:
             return
 
-        self.device.format.targetSize = self.origSize
+        self.device.format.target_size = self.orig_size
         super(ActionResizeFormat, self).cancel()
 
     def requires(self, action):
@@ -813,16 +813,16 @@ def requires(self, action):
                 - the other action removes this action's device from a container
         """
         retval = super(ActionResizeFormat, self).requires(action)
-        if action.isResize:
+        if action.is_resize:
             if self.device.id == action.device.id and \
                self.dir == action.dir and \
-               action.isDevice and self.isGrow:
+               action.is_device and self.is_grow:
                 retval = True
-            elif action.isShrink and action.device.dependsOn(self.device):
+            elif action.is_shrink and action.device.depends_on(self.device):
                 retval = True
-            elif action.isGrow and self.device.dependsOn(action.device):
+            elif action.is_grow and self.device.depends_on(action.device):
                 retval = True
-        elif (action.isRemove and action.device == self.device):
+        elif (action.is_remove and action.device == self.device):
             retval = True
 
         return retval
@@ -832,7 +832,7 @@ class ActionAddMember(DeviceAction):
     """ An action representing addition of a member device to a container. """
     type = ACTION_TYPE_ADD
     obj = ACTION_OBJECT_CONTAINER
-    typeDescStr = N_("add container member")
+    type_desc_str = N_("add container member")
 
     def __init__(self, container, device):
         super(ActionAddMember, self).__init__(device)
@@ -864,7 +864,7 @@ def requires(self, action):
             required by
                 - any create/grow action on a device in the same container
         """
-        return ((action.isCreate or action.isResize) and
+        return ((action.is_create or action.is_resize) and
                 action.device == self.device)
 
     def obsoletes(self, action):
@@ -879,11 +879,11 @@ def obsoletes(self, action):
                 - remove same member from same container
         """
         retval = False
-        if (action.isRemove and
+        if (action.is_remove and
             action.device == self.device and
             action.container == self.container):
             retval = True
-        elif (action.isAdd and
+        elif (action.is_add and
               action.device == self.device and
               action.container == self.container and
               action.id > self.id):
@@ -896,7 +896,7 @@ class ActionRemoveMember(DeviceAction):
     """ An action representing removal of a member device from a container. """
     type = ACTION_TYPE_REMOVE
     obj = ACTION_OBJECT_CONTAINER
-    typeDescStr = N_("remove container member")
+    type_desc_str = N_("remove container member")
 
     def __init__(self, container, device):
         super(ActionRemoveMember, self).__init__(device)
@@ -930,10 +930,10 @@ def requires(self, action):
                 - any destroy/resize action on the device
         """
         retval = False
-        if ((action.isShrink or action.isDestroy) and
+        if ((action.is_shrink or action.is_destroy) and
             action.device.container == self.container):
             retval = True
-        elif action.isAdd and action.container == self.container:
+        elif action.is_add and action.container == self.container:
             retval = True
 
         return retval
@@ -948,11 +948,11 @@ def obsoletes(self, action):
                 - add same member to same container
         """
         retval = False
-        if (action.isAdd and
+        if (action.is_add and
             action.device == self.device and
             action.container == self.container):
             retval = True
-        elif (action.isRemove and
+        elif (action.is_remove and
               action.device == self.device and
               action.container == self.container and
               action.id > self.id):
diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py
index 0c795be..10e978e 100644
--- a/blivet/devicefactory.py
+++ b/blivet/devicefactory.py
@@ -25,14 +25,14 @@
 from .devices import BTRFSDevice, DiskDevice
 from .devices import LUKSDevice, LVMLogicalVolumeDevice, LVMThinPoolDevice
 from .devices import PartitionDevice, MDRaidArrayDevice
-from .formats import getFormat
+from .formats import get_format
 from .devicelibs import btrfs
 from .devicelibs import mdraid
 from .devicelibs import lvm
 from .devicelibs import raid
 from .partitioning import SameSizeSet
 from .partitioning import TotalSizeSet
-from .partitioning import doPartitioning
+from .partitioning import do_partitioning
 from .size import Size
 
 import gi
@@ -75,7 +75,7 @@ def is_supported_device_type(device_type):
     elif device_type == DEVICE_TYPE_MD:
         devices = [MDRaidArrayDevice]
 
-    return not any(c.unavailableTypeDependencies() for c in devices)
+    return not any(c.unavailable_type_dependencies() for c in devices)
 
 def get_supported_raid_levels(device_type):
     """ Return the supported raid levels for this device type.
@@ -95,7 +95,7 @@ def get_supported_raid_levels(device_type):
         pkg = mdraid
 
     if pkg and all(d.available for d in pkg.EXTERNAL_DEPENDENCIES):
-        return set(pkg.RAID_levels)
+        return set(pkg.raid_levels)
     else:
         return set()
 
@@ -113,7 +113,7 @@ def get_device_type(device):
                     "mdarray": DEVICE_TYPE_MD}
 
     use_dev = device.raw_device
-    if use_dev.isDisk:
+    if use_dev.is_disk:
         device_type = DEVICE_TYPE_DISK
     else:
         device_type = device_types.get(use_dev.type)
@@ -219,7 +219,7 @@ class DeviceFactory(object):
 
             # Write the new devices to disk and create the filesystems they
             # contain.
-            _blivet.doIt()
+            _blivet.do_it()
 
 
         Some operations (on non-existent devices) these classes do support:
@@ -299,7 +299,7 @@ def __init__(self, storage, size, disks, fstype=None, mountpoint=None,
 
         if encrypted and size:
             # encrypted, bump size up with LUKS metadata size
-            size += getFormat("luks").minSize
+            size += get_format("luks").min_size
 
         self.storage = storage          # a Blivet instance
         self.size = size                # the requested size for this device
@@ -327,7 +327,7 @@ def __init__(self, storage, size, disks, fstype=None, mountpoint=None,
         self.device = device
 
         if not self.fstype:
-            self.fstype = self.storage.getFSType(mountpoint=self.mountpoint)
+            self.fstype = self.storage.get_fstype(mountpoint=self.mountpoint)
             if fstype == "swap":
                 self.mountpoint = None
 
@@ -357,7 +357,7 @@ def raid_level(self, value):
         if value is None:
             self._raid_level = None
         else:
-            self._raid_level = raid.getRaidLevel(value)
+            self._raid_level = raid.get_raid_level(value)
 
     @property
     def container_raid_level(self):
@@ -375,12 +375,12 @@ def container_raid_level(self, value):
         if value is None:
             self._container_raid_level = None
         else:
-            self._container_raid_level = raid.getRaidLevel(value)
+            self._container_raid_level = raid.get_raid_level(value)
     #
     # methods related to device size and disk space requirements
     #
     def _get_free_disk_space(self):
-        free_info = self.storage.getFreeSpace(disks=self.disks)
+        free_info = self.storage.get_free_space(disks=self.disks)
         return sum(d[0] for d in free_info.values())
 
     def _normalize_size(self):
@@ -388,11 +388,11 @@ def _normalize_size(self):
             self._handle_no_size()
 
         size = self.size
-        fmt = getFormat(self.fstype)
-        if size < fmt.minSize:
-            size = fmt.minSize
-        elif fmt.maxSize and size > fmt.maxSize:
-            size = fmt.maxSize
+        fmt = get_format(self.fstype)
+        if size < fmt.min_size:
+            size = fmt.min_size
+        elif fmt.max_size and size > fmt.max_size:
+            size = fmt.max_size
 
         if self.size != size:
             log.debug("adjusted size from %s to %s to honor format limits",
@@ -536,7 +536,7 @@ def _create_container(self):
         parents = self._get_parent_devices()
         self.container = self._get_new_container(name=self.container_name,
                                                  parents=parents)
-        self.storage.createDevice(self.container)
+        self.storage.create_device(self.container)
         if self.container_name is None:
             self.container_name = self.container.name
 
@@ -638,7 +638,7 @@ def _create_device(self):
             log.error("device instance creation failed: %s", e)
             raise
 
-        self.storage.createDevice(device)
+        self.storage.create_device(device)
         e = None
         try:
             self._post_create()
@@ -649,7 +649,7 @@ def _create_device(self):
                 e = StorageError("failed to create device")
 
         if e:
-            self.storage.destroyDevice(device)
+            self.storage.destroy_device(device)
             raise StorageError(e)
 
         ret = device
@@ -658,13 +658,13 @@ def _create_device(self):
             if self.label:
                 fmt_args["label"] = self.label
 
-            fmt = getFormat(self.fstype,
+            fmt = get_format(self.fstype,
                             mountpoint=self.mountpoint,
                             min_luks_entropy=self.min_luks_entropy,
                             **fmt_args)
             luks_device = LUKSDevice("luks-" + device.name,
                                      parents=[device], fmt=fmt)
-            self.storage.createDevice(luks_device)
+            self.storage.create_device(luks_device)
             ret = luks_device
 
         self.device = ret
@@ -706,19 +706,19 @@ def _set_size(self):
             log.error("device post-create method failed: %s", e)
             raise
         else:
-            if (self.device.size < self.device.format.minSize or
-                (self.device.size == self.device.format.minSize and
-                 self.size > self.device.format.minSize)):
+            if (self.device.size < self.device.format.min_size or
+                (self.device.size == self.device.format.min_size and
+                 self.size > self.device.format.min_size)):
                 raise StorageError("failed to adjust device -- not enough free space in specified disks?")
 
     def _set_format(self):
         current_format = self.device.format
         if current_format.type != self.fstype:
-            new_format = getFormat(self.fstype,
+            new_format = get_format(self.fstype,
                                    mountpoint=self.mountpoint,
                                    label=self.label,
                                    exists=False)
-            self.storage.formatDevice(self.device, new_format)
+            self.storage.format_device(self.device, new_format)
         else:
             if (hasattr(current_format, "mountpoint") and
                 current_format.mountpoint != self.mountpoint):
@@ -737,32 +737,32 @@ def _set_encryption(self):
             leaf_format = self.device.format
             if parent_container:
                 parent_container.parents.remove(orig_device)
-            self.storage.destroyDevice(self.device)
-            self.storage.formatDevice(self.raw_device, leaf_format)
+            self.storage.destroy_device(self.device)
+            self.storage.format_device(self.raw_device, leaf_format)
             self.device = raw_device
             if parent_container:
                 parent_container.parents.append(self.device)
         elif self.encrypted and not isinstance(self.device, LUKSDevice):
             orig_device = self.device
             leaf_format = self.device.format
-            self.storage.formatDevice(self.device, getFormat("luks",
+            self.storage.format_device(self.device, get_format("luks",
                                                              min_luks_entropy=self.min_luks_entropy))
             luks_device = LUKSDevice("luks-%s" % self.device.name,
                                      fmt=leaf_format,
                                      parents=self.device)
-            self.storage.createDevice(luks_device)
+            self.storage.create_device(luks_device)
             self.device = luks_device
             if parent_container:
                 parent_container.parents.replace(orig_device, self.device)
 
     def _set_name(self):
         if not self.device_name:
-            self.device_name = self.storage.suggestDeviceName(
+            self.device_name = self.storage.suggest_device_name(
                                                   parent=self.container,
                                                   swap=(self.fstype == "swap"),
                                                   mountpoint=self.mountpoint)
 
-        safe_new_name = self.storage.safeDeviceName(self.device_name)
+        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'",
@@ -892,14 +892,14 @@ class PartitionFactory(DeviceFactory):
     #
     def _get_base_size(self):
         if self.device:
-            min_format_size = self.device.format.minSize
+            min_format_size = self.device.format.min_size
         else:
-            min_format_size = getFormat(self.fstype).minSize
+            min_format_size = get_format(self.fstype).min_size
 
         # min_format_size may be None here, make sure it is a number
         min_format_size = min_format_size or 0
         if self.encrypted:
-            min_format_size += getFormat("luks").minSize
+            min_format_size += get_format("luks").min_size
 
         return max(Size("1MiB"), min_format_size)
 
@@ -941,7 +941,7 @@ def _get_new_device(self, *args, **kwargs):
         max_size = kwargs.pop("size")
         kwargs["size"] = self._get_base_size()
 
-        device = self.storage.newPartition(*args,
+        device = self.storage.new_partition(*args,
                                            grow=True, maxsize=max_size,
                                            **kwargs)
         return device
@@ -954,7 +954,7 @@ def _set_name(self):
 
     def _post_create(self):
         try:
-            doPartitioning(self.storage)
+            do_partitioning(self.storage)
         except (StorageError, blockdev.BlockDevError) as e:
             log.error("failed to allocate partitions: %s", e)
             raise
@@ -1061,10 +1061,10 @@ def configure(self):
         for member in members[:]:
             member_encrypted = isinstance(member, LUKSDevice)
             if member_encrypted and not self.encrypted:
-                self.storage.destroyDevice(member)
+                self.storage.destroy_device(member)
                 members.remove(member)
-                self.storage.formatDevice(member.slave,
-                                          getFormat(self.fstype))
+                self.storage.format_device(member.slave,
+                                          get_format(self.fstype))
                 members.append(member.slave)
                 if container:
                     container.parents.replace(member, member.slave)
@@ -1073,12 +1073,12 @@ def configure(self):
 
             if not member_encrypted and self.encrypted:
                 members.remove(member)
-                self.storage.formatDevice(member, getFormat("luks",
+                self.storage.format_device(member, get_format("luks",
                                                              min_luks_entropy=self.min_luks_entropy))
                 luks_member = LUKSDevice("luks-%s" % member.name,
                                     parents=[member],
-                                    fmt=getFormat(self.fstype))
-                self.storage.createDevice(luks_member)
+                                    fmt=get_format(self.fstype))
+                self.storage.create_device(luks_member)
                 members.append(luks_member)
                 if container:
                     container.parents.replace(member, luks_member)
@@ -1108,19 +1108,19 @@ def configure(self):
                 member_format = self.fstype
 
             try:
-                member = self.storage.newPartition(parents=[disk], grow=True,
+                member = self.storage.new_partition(parents=[disk], grow=True,
                                            size=base_size,
                                            fmt_type=member_format)
             except (StorageError, blockdev.BlockDevError) as e:
                 log.error("failed to create new member partition: %s", e)
                 continue
 
-            self.storage.createDevice(member)
+            self.storage.create_device(member)
             if self.encrypted:
-                fmt = getFormat(self.fstype)
+                fmt = get_format(self.fstype)
                 member = LUKSDevice("luks-%s" % member.name,
                                     parents=[member], fmt=fmt)
-                self.storage.createDevice(member)
+                self.storage.create_device(member)
 
             members.append(member)
             new_members.append(member)
@@ -1137,10 +1137,10 @@ def configure(self):
                 container.parents.remove(member)
 
             if isinstance(member, LUKSDevice):
-                self.storage.destroyDevice(member)
+                self.storage.destroy_device(member)
                 member = member.slave
 
-            self.storage.destroyDevice(member)
+            self.storage.destroy_device(member)
 
         ##
         ## Determine target container size.
@@ -1184,7 +1184,7 @@ def _handle_no_size(self):
 
         if self.container and (self.container.exists or
                                self.container_size != SIZE_POLICY_AUTO):
-            self.size = self.container.freeSpace
+            self.size = self.container.free_space
 
             if self.container_size == SIZE_POLICY_MAX:
                 self.size += self._get_free_disk_space()
@@ -1203,7 +1203,7 @@ def _get_device_space(self):
 
     def _get_device_size(self):
         size = self.size
-        free = self.container.freeSpace
+        free = self.container.free_space
         if self.device:
             free += self.raw_device.size
 
@@ -1232,7 +1232,7 @@ def _get_total_space(self):
             # automatic container size management
             if self.container:
                 size += sum([p.size for p in self.container.parents])
-                size -= self.container.freeSpace
+                size -= self.container.free_space
         elif self.container_size == SIZE_POLICY_MAX:
             # grow the container as large as possible
             if self.container:
@@ -1272,14 +1272,14 @@ def container_list(self):
         return self.storage.vgs[:]
 
     def _get_new_container(self, *args, **kwargs):
-        return self.storage.newVG(*args, **kwargs)
+        return self.storage.new_vg(*args, **kwargs)
 
     def _check_container_size(self):
         """ Raise an exception if the container cannot hold its devices. """
         if not self.container:
             return
 
-        free_space = self.container.freeSpace + getattr(self.device, "size", 0)
+        free_space = self.container.free_space + getattr(self.device, "size", 0)
         if free_space < 0:
             raise DeviceFactoryError("container changes impossible due to "
                                      "the devices it already contains")
@@ -1297,23 +1297,23 @@ def _get_child_factory_kwargs(self):
                 kwargs["device"] = self.container.parents[0]
                 kwargs["name"] = self.container.parents[0].name
             else:
-                kwargs["name"] = self.storage.suggestDeviceName(prefix="pv")
+                kwargs["name"] = self.storage.suggest_device_name(prefix="pv")
 
         return kwargs
 
     def _get_new_device(self, *args, **kwargs):
         """ Create and return the factory device as a StorageDevice. """
-        return self.storage.newLV(*args, **kwargs)
+        return self.storage.new_lv(*args, **kwargs)
 
     def _set_name(self):
         if not self.device_name:
-            self.device_name = self.storage.suggestDeviceName(
+            self.device_name = self.storage.suggest_device_name(
                                                   parent=self.container,
                                                   swap=(self.fstype == "swap"),
                                                   mountpoint=self.mountpoint)
 
         lvname = "%s-%s" % (self.container.name, self.device_name)
-        safe_new_name = self.storage.safeDeviceName(lvname)
+        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'",
@@ -1343,15 +1343,15 @@ def _configure(self):
                 if ((self.container_raid_level and use_dev.type != "mdarray") or
                     (not self.container_raid_level and use_dev.type == "mdarray")):
                     self.container.parents.remove(member)
-                    self.storage.destroyDevice(member)
+                    self.storage.destroy_device(member)
                     if member != use_dev:
-                        self.storage.destroyDevice(use_dev)
+                        self.storage.destroy_device(use_dev)
 
                     # for md pv we also need to remove the md member partitions
                     if not self.container_raid_level and \
                        use_dev.type == "mdarray":
                         for mdmember in use_dev.parents[:]:
-                            self.storage.destroyDevice(mdmember)
+                            self.storage.destroy_device(mdmember)
 
         super(LVMFactory, self)._configure()
 
@@ -1410,9 +1410,9 @@ def _get_device_size(self):
         # calculate device size based on space in the pool
         pool_size = self.pool.size
         log.debug("pool size is %s", pool_size)
-        free = pool_size - self.pool.usedSpace
+        free = pool_size - self.pool.used_space
         if self.device:
-            free += self.raw_device.poolSpaceUsed
+            free += self.raw_device.pool_space_used
 
         size = self.size
         if free < size:
@@ -1447,12 +1447,12 @@ def _get_total_space(self):
         # this does not apply if a specific container size was requested
         if self.container_size in (SIZE_POLICY_AUTO, SIZE_POLICY_MAX):
             if self.container_size == SIZE_POLICY_AUTO and \
-               self.pool and not self.pool.exists and self.pool.freeSpace > 0:
+               self.pool and not self.pool.exists and self.pool.free_space > 0:
                 # this is mostly for cleaning up after removing a thin lv
-                size -= self.pool.freeSpace
+                size -= self.pool.free_space
                 log.debug("size cut to %s to omit pool free space", size)
 
-                pad = Size(blockdev.lvm.get_thpool_padding(self.pool.freeSpace, self._pesize))
+                pad = Size(blockdev.lvm.get_thpool_padding(self.pool.free_space, self._pesize))
                 size -= pad
                 log.debug("size cut to %s to omit pool padding from free "
                           "space", size)
@@ -1487,7 +1487,7 @@ def get_pool(self):
         # that would prevent users from setting up custom pools on tty2.
         pool = None
         pools = [p for p in self.pool_list if p.vg == self.container]
-        pools.sort(key=lambda p: p.freeSpace, reverse=True)
+        pools.sort(key=lambda p: p.free_space, reverse=True)
         if pools:
             new_pools = [p for p in pools if not p.exists]
             if new_pools:
@@ -1517,14 +1517,14 @@ def _get_pool_size(self):
         size = self.size    # projected size for the pool (not padded)
         free = Size(0)# total space within the vg that is available to us
         if self.pool:
-            free += self.pool.freeSpace # pools are always auto-sized
+            free += self.pool.free_space # pools are always auto-sized
             # pool lv sizes go toward projected pool size and vg free space
-            size += self.pool.usedSpace
-            free += self.pool.usedSpace
-            log.debug("increasing free and size by pool used (%s)", self.pool.usedSpace)
+            size += self.pool.used_space
+            free += self.pool.used_space
+            log.debug("increasing free and size by pool used (%s)", self.pool.used_space)
             if self.device:
-                log.debug("reducing size by device space (%s)", self.device.poolSpaceUsed)
-                size -= self.device.poolSpaceUsed   # don't count our device
+                log.debug("reducing size by device space (%s)", self.device.pool_space_used)
+                size -= self.device.pool_space_used   # don't count our device
 
             # increase vg free space by the size of the current pool's pad
             pad = Size(blockdev.lvm.get_thpool_padding(self.pool.size, self._pesize))
@@ -1532,7 +1532,7 @@ def _get_pool_size(self):
             free += pad
 
         # round to nearest extent. free rounds down, size rounds up.
-        free = self.container.align(free + self.container.freeSpace)
+        free = self.container.align(free + self.container.free_space)
         size = self.container.align(size, roundup=True)
 
         pad = Size(blockdev.lvm.get_thpool_padding(size, self._pesize))
@@ -1566,7 +1566,7 @@ def _create_pool(self):
             raise DeviceFactoryError("not enough free space for thin pool")
 
         self.pool = self._get_new_pool(size=size, parents=[self.container])
-        self.storage.createDevice(self.pool)
+        self.storage.create_device(self.pool)
 
     #
     # methods to configure the factory's container (both vg and pool)
@@ -1577,7 +1577,7 @@ def _set_container(self):
         if self.pool:
             log.debug("pool is %s ; size: %s ; free: %s", self.pool.name,
                                                           self.pool.size,
-                                                          self.pool.freeSpace)
+                                                          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 _set_raid_level(self):
     def _get_new_device(self, *args, **kwargs):
         """ Create and return the factory device as a StorageDevice. """
         kwargs["level"] = self.raid_level
-        kwargs["totalDevices"] = len(kwargs.get("parents"))
-        kwargs["memberDevices"] = len(kwargs.get("parents"))
-        return self.storage.newMDArray(*args, **kwargs)
+        kwargs["total_devices"] = len(kwargs.get("parents"))
+        kwargs["member_devices"] = len(kwargs.get("parents"))
+        return self.storage.new_mdarray(*args, **kwargs)
 
     @property
     def container_list(self):
@@ -1658,7 +1658,7 @@ def __init__(self, storage, size, disks, **kwargs):
             log.info("overriding encryption setting for btrfs factory")
             self.encrypted = False
 
-        self.container_raid_level = self.container_raid_level or btrfs.RAID_levels.raidLevel("single")
+        self.container_raid_level = self.container_raid_level or btrfs.raid_levels.raid_level("single")
         if self.container_raid_level.is_uniform:
             self.size_set_class = SameSizeSet
         else:
@@ -1707,25 +1707,25 @@ def _get_device_space(self):
 
     @property
     def container_list(self):
-        return self.storage.btrfsVolumes[:]
+        return self.storage.btrfs_volumes[:]
 
     def _get_new_container(self, *args, **kwargs):
-        return self.storage.newBTRFS(*args, **kwargs)
+        return self.storage.new_btrfs(*args, **kwargs)
 
     def _create_container(self):
         """ Create the container device required by this factory device. """
         parents = self._get_parent_devices()
         self.container = self._get_new_container(name=self.container_name,
-                                                 dataLevel=self.container_raid_level,
+                                                 data_level=self.container_raid_level,
                                                  parents=parents)
-        self.storage.createDevice(self.container)
+        self.storage.create_device(self.container)
 
     def _set_container_raid_level(self):
-        # TODO: write BTRFSVolumeDevice.setRAIDLevel
+        # TODO: write BTRFSVolumeDevice.set_raid_level
         # make sure the member count is adequate for the new level
 
         # set the new level
-        self.container.dataLevel = self.container_raid_level
+        self.container.data_level = self.container_raid_level
 
     def _get_child_factory_kwargs(self):
         kwargs = super(BTRFSFactory, self)._get_child_factory_kwargs()
@@ -1737,7 +1737,7 @@ def _get_new_device(self, *args, **kwargs):
         kwargs["dataLevel"] = self.container_raid_level
         kwargs["metaDataLevel"] = self.container_raid_level
         kwargs["subvol"] = True
-        return self.storage.newBTRFS(*args, **kwargs)
+        return self.storage.new_btrfs(*args, **kwargs)
 
     def _set_name(self):
         super(BTRFSFactory, self)._set_name()
diff --git a/blivet/devicelibs/btrfs.py b/blivet/devicelibs/btrfs.py
index c8d9319..9d49b66 100644
--- a/blivet/devicelibs/btrfs.py
+++ b/blivet/devicelibs/btrfs.py
@@ -33,7 +33,7 @@
 # if any component device is less than this size, mkfs.btrfs will fail
 MIN_MEMBER_SIZE = Size("16 MiB")
 
-RAID_levels = raid.RAIDLevels(["raid0", "raid1", "raid10", "single"])
+raid_levels = raid.RAIDLevels(["raid0", "raid1", "raid10", "single"])
 
 metadata_levels = raid.RAIDLevels(["raid0", "raid1", "raid10", "single", "dup"])
 
diff --git a/blivet/devicelibs/mdraid.py b/blivet/devicelibs/mdraid.py
index 2f63f8e..7692d91 100644
--- a/blivet/devicelibs/mdraid.py
+++ b/blivet/devicelibs/mdraid.py
@@ -33,8 +33,8 @@
 
 class MDRaidLevels(raid.RAIDLevels):
     @classmethod
-    def isRaidLevel(cls, level):
-        return super(MDRaidLevels, cls).isRaidLevel(level) and \
+    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 \
diff --git a/blivet/devicelibs/raid.py b/blivet/devicelibs/raid.py
index 17ea0e8..093181a 100644
--- a/blivet/devicelibs/raid.py
+++ b/blivet/devicelibs/raid.py
@@ -314,7 +314,7 @@ def get_space(self, size, num_members, chunk_size=None, superblock_size_func=Non
 
 class RAIDLevels(object):
     """A class which keeps track of registered RAID levels. This class
-       may be extended, overriding the isRaid method to include any
+       may be extended, overriding the is_raid method to include any
        additional properties that a client of this package may require
        for its RAID levels.
     """
@@ -336,10 +336,10 @@ def __init__(self, levels=None):
             if len(matches) != 1:
                 raise RaidError("invalid standard RAID level descriptor %s" % level)
             else:
-                self.addRaidLevel(matches[0])
+                self.add_raid_level(matches[0])
 
     @classmethod
-    def isRaidLevel(cls, level):
+    def is_raid_level(cls, level):
         """Return False if level does not satisfy minimum requirements for
            a RAID level, otherwise return True.
 
@@ -359,7 +359,7 @@ def isRaidLevel(cls, level):
         """
         return len(level.names) > 0 and level.name in level.names
 
-    def raidLevel(self, descriptor):
+    def raid_level(self, descriptor):
         """Return RAID object corresponding to descriptor.
 
            :param object descriptor: a RAID level descriptor
@@ -375,7 +375,7 @@ def raidLevel(self, descriptor):
                 return level
         raise RaidError("invalid RAID level descriptor %s" % descriptor)
 
-    def addRaidLevel(self, level):
+    def add_raid_level(self, level):
         """Adds level to levels if it is not already there.
 
            :param object level: an object representing a RAID level
@@ -384,7 +384,7 @@ def addRaidLevel(self, level):
 
            Does not allow duplicate level objects.
         """
-        if not self.isRaidLevel(level):
+        if not self.is_raid_level(level):
             raise RaidError("level is not a valid RAID level")
         self._raid_levels.add(level)
 
@@ -421,7 +421,7 @@ def _get_recommended_stride(self, member_count):
         return member_count * 16
 
 RAID0 = RAID0()
-ALL_LEVELS.addRaidLevel(RAID0)
+ALL_LEVELS.add_raid_level(RAID0)
 
 class RAID1(RAIDn):
     level = property(lambda s: "1")
@@ -450,7 +450,7 @@ def _get_recommended_stride(self, member_count):
         return None
 
 RAID1 = RAID1()
-ALL_LEVELS.addRaidLevel(RAID1)
+ALL_LEVELS.add_raid_level(RAID1)
 
 class RAID4(RAIDn):
     level = property(lambda s: "4")
@@ -479,7 +479,7 @@ def _get_recommended_stride(self, member_count):
         return (member_count - 1) * 16
 
 RAID4 = RAID4()
-ALL_LEVELS.addRaidLevel(RAID4)
+ALL_LEVELS.add_raid_level(RAID4)
 
 class RAID5(RAIDn):
     level = property(lambda s: "5")
@@ -508,7 +508,7 @@ def _get_recommended_stride(self, member_count):
         return (member_count - 1) * 16
 
 RAID5 = RAID5()
-ALL_LEVELS.addRaidLevel(RAID5)
+ALL_LEVELS.add_raid_level(RAID5)
 
 class RAID6(RAIDn):
     level = property(lambda s: "6")
@@ -537,7 +537,7 @@ def _get_recommended_stride(self, member_count):
         return None
 
 RAID6 = RAID6()
-ALL_LEVELS.addRaidLevel(RAID6)
+ALL_LEVELS.add_raid_level(RAID6)
 
 class RAID10(RAIDn):
     level = property(lambda s: "10")
@@ -566,7 +566,7 @@ def _get_recommended_stride(self, member_count):
         return None
 
 RAID10 = RAID10()
-ALL_LEVELS.addRaidLevel(RAID10)
+ALL_LEVELS.add_raid_level(RAID10)
 
 class Container(RAIDLevel):
     name = "container"
@@ -591,7 +591,7 @@ def get_size(self, member_sizes, num_members=None, chunk_size=None, superblock_s
         return sum(member_sizes, Size(0))
 
 Container = Container()
-ALL_LEVELS.addRaidLevel(Container)
+ALL_LEVELS.add_raid_level(Container)
 
 class ErsatzRAID(RAIDLevel):
     """ A superclass for a raid level which is not really a raid level at
@@ -638,7 +638,7 @@ class Linear(ErsatzRAID):
     names = [name]
 
 Linear = Linear()
-ALL_LEVELS.addRaidLevel(Linear)
+ALL_LEVELS.add_raid_level(Linear)
 
 class Single(ErsatzRAID):
     """ subclass with canonical btrfs name. """
@@ -646,7 +646,7 @@ class Single(ErsatzRAID):
     names = [name]
 
 Single = Single()
-ALL_LEVELS.addRaidLevel(Single)
+ALL_LEVELS.add_raid_level(Single)
 
 class Dup(RAIDLevel):
     """ A RAID level which expresses one way btrfs metadata may be distributed.
@@ -662,9 +662,9 @@ def has_redundancy(self):
         return True
 
 Dup = Dup()
-ALL_LEVELS.addRaidLevel(Dup)
+ALL_LEVELS.add_raid_level(Dup)
 
-def getRaidLevel(descriptor):
+def get_raid_level(descriptor):
     """ Convenience function to return a RAID level for the descriptor.
 
         :param object descriptor: a RAID level descriptor
@@ -676,4 +676,4 @@ def getRaidLevel(descriptor):
 
         Raises a RaidError is there is no RAID object for the descriptor.
     """
-    return ALL_LEVELS.raidLevel(descriptor)
+    return ALL_LEVELS.raid_level(descriptor)
diff --git a/blivet/devices/__init__.py b/blivet/devices/__init__.py
index cf1ec34..4f697ca 100644
--- a/blivet/devices/__init__.py
+++ b/blivet/devices/__init__.py
@@ -19,7 +19,7 @@
 # Red Hat Author(s): David Lehman <dlehman at redhat.com>
 #
 
-from .lib import get_device_majors, devicePathToName, deviceNameToDiskByPath, ParentList
+from .lib import get_device_majors, device_path_to_name, device_name_to_disk_by_path, ParentList
 from .device import Device
 from .storage import StorageDevice
 from .disk import DiskDevice, DiskFile, DMRaidArrayDevice, MultipathDevice, iScsiDiskDevice, FcoeDiskDevice, DASDDevice, ZFCPDiskDevice
diff --git a/blivet/devices/btrfs.py b/blivet/devices/btrfs.py
index 6319298..957703b 100644
--- a/blivet/devices/btrfs.py
+++ b/blivet/devices/btrfs.py
@@ -36,7 +36,7 @@
 from ..storage_log import log_method_call
 from .. import udev
 from .. import util
-from ..formats import getFormat, DeviceFormat
+from ..formats import get_format, DeviceFormat
 from ..size import Size
 
 import logging
@@ -67,34 +67,34 @@ def __init__(self, *args, **kwargs):
         self.req_size = kwargs.pop("size", None)
         super(BTRFSDevice, self).__init__(*args, **kwargs)
 
-    def updateSysfsPath(self):
+    def update_sysfs_path(self):
         """ Update this device's sysfs path. """
         log_method_call(self, self.name, status=self.status)
-        self.parents[0].updateSysfsPath()
-        self.sysfsPath = self.parents[0].sysfsPath
-        log.debug("%s sysfsPath set to %s", self.name, self.sysfsPath)
+        self.parents[0].update_sysfs_path()
+        self.sysfs_path = self.parents[0].sysfs_path
+        log.debug("%s sysfs_path set to %s", self.name, self.sysfs_path)
 
-    def updateSize(self):
+    def update_size(self):
         pass
 
-    def _postCreate(self):
-        super(BTRFSDevice, self)._postCreate()
+    def _post_create(self):
+        super(BTRFSDevice, self)._post_create()
         self.format.exists = True
         self.format.device = self.path
 
-    def _preDestroy(self):
+    def _pre_destroy(self):
         """ Preparation and precondition checking for device destruction. """
-        super(BTRFSDevice, self)._preDestroy()
-        self.setupParents(orig=True)
+        super(BTRFSDevice, self)._pre_destroy()
+        self.setup_parents(orig=True)
 
-    def _getSize(self):
+    def _get_size(self):
         return sum((d.size for d in self.parents), Size(0))
 
-    def _setSize(self, newsize):
+    def _set_size(self, newsize):
         raise RuntimeError("cannot directly set size of btrfs volume")
 
     @property
-    def currentSize(self):
+    def current_size(self):
         return self.size
 
     @property
@@ -111,12 +111,12 @@ def _do_temp_mount(self, orig=False):
             raise errors.FSError("format doesn't exist")
 
         if orig:
-            fmt = self.originalFormat
+            fmt = self.original_format
         else:
             fmt = self.format
 
         if fmt.status:
-            yield fmt.systemMountpoint
+            yield fmt.system_mountpoint
 
         else:
             tmpdir = tempfile.mkdtemp(prefix=self._temp_dir_prefix)
@@ -142,23 +142,23 @@ def direct(self):
         return True
 
     @property
-    def fstabSpec(self):
-        if self.format.volUUID:
-            spec = "UUID=%s" % self.format.volUUID
+    def fstab_spec(self):
+        if self.format.vol_uuid:
+            spec = "UUID=%s" % self.format.vol_uuid
         else:
-            spec = super(BTRFSDevice, self).fstabSpec
+            spec = super(BTRFSDevice, self).fstab_spec
         return spec
 
     @classmethod
-    def isNameValid(cls, name):
-        # Override StorageDevice.isNameValid to allow pretty much anything
+    def is_name_valid(cls, name):
+        # Override StorageDevice.is_name_valid to allow pretty much anything
         return not('\x00' in name)
 
 class BTRFSVolumeDevice(BTRFSDevice, ContainerDevice, RaidDevice):
     _type = "btrfs volume"
     vol_id = btrfs.MAIN_VOLUME_ID
-    _formatClassName = property(lambda s: "btrfs")
-    _formatUUIDAttr = property(lambda s: "volUUID")
+    _format_class_name = property(lambda s: "btrfs")
+    _format_uuid_attr = property(lambda s: "vol_uuid")
 
     def __init__(self, *args, **kwargs):
         """
@@ -169,32 +169,32 @@ def __init__(self, *args, **kwargs):
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat`
             :keyword str uuid: UUID of top-level filesystem/volume
-            :keyword str sysfsPath: sysfs device path
-            :keyword dataLevel: RAID level for data
-            :type dataLevel: any valid raid level descriptor
-            :keyword metaDataLevel: RAID level for metadata
-            :type metaDataLevel: any valid raid level descriptor
+            :keyword str sysfs_path: sysfs device path
+            :keyword data_level: RAID level for data
+            :type data_level: any valid raid level descriptor
+            :keyword metadata_level: RAID level for metadata
+            :type metadata_level: any valid raid level descriptor
         """
         # pop these arguments before the constructor call to avoid
         # unrecognized keyword error in superclass constructor
-        dataLevel = kwargs.pop("dataLevel", None)
-        metaDataLevel = kwargs.pop("metaDataLevel", None)
-        createOptions = kwargs.pop("createOptions", None)
+        data_level = kwargs.pop("data_level", None)
+        metadata_level = kwargs.pop("metadata_level", None)
+        create_options = kwargs.pop("create_options", None)
 
         super(BTRFSVolumeDevice, self).__init__(*args, **kwargs)
 
         # avoid attribute-defined-outside-init pylint warning
-        self._dataLevel = self._metaDataLevel = None
+        self._data_level = self._metadata_level = None
 
         # assign after constructor to avoid AttributeErrors in setter functions
         try:
-            self.dataLevel = dataLevel
-            self.metaDataLevel = metaDataLevel
+            self.data_level = data_level
+            self.metadata_level = metadata_level
         except errors.BTRFSValueError as e:
             # Could not set the levels, so set loose the parents that were
             # added in superclass constructor.
             for dev in self.parents:
-                dev.removeChild()
+                dev.remove_child()
             raise e
 
         self.subvolumes = []
@@ -202,23 +202,23 @@ def __init__(self, *args, **kwargs):
 
         if self.parents and not self.format.type:
             label = getattr(self.parents[0].format, "label", None)
-            self.format = getFormat("btrfs",
+            self.format = get_format("btrfs",
                                     exists=self.exists,
                                     label=label,
-                                    volUUID=self.uuid,
+                                    vol_uuid=self.uuid,
                                     device=self.path,
                                     subvolspec=self.vol_id,
                                     mountopts="subvolid=%d" % self.vol_id,
-                                    createOptions=createOptions)
-            self.originalFormat = copy.deepcopy(self.format)
+                                    create_options=create_options)
+            self.original_format = copy.deepcopy(self.format)
 
-        self._defaultSubVolumeID = None
+        self._default_subvolume_id = None
 
     @property
     def members(self):
         return list(self.parents)
 
-    def _setLevel(self, value, data):
+    def _set_level(self, value, data):
         """ Sets a valid level for this device and level type.
 
             :param object value: value for this RAID level
@@ -232,28 +232,28 @@ def _setLevel(self, value, data):
         """
         level = None
         if value:
-            levels = btrfs.RAID_levels if data else btrfs.metadata_levels
+            levels = btrfs.raid_levels if data else btrfs.metadata_levels
             try:
-                level = self._getLevel(value, levels)
+                level = self._get_level(value, levels)
             except ValueError as e:
                 raise errors.BTRFSValueError(e)
 
         if data:
-            self._dataLevel = level
+            self._data_level = level
         else:
-            self._metaDataLevel = level
+            self._metadata_level = level
 
     @property
-    def dataLevel(self):
+    def data_level(self):
         """ Return the RAID level for data.
 
             :returns: raid level
             :rtype: an object that represents a raid level
         """
-        return self._dataLevel
+        return self._data_level
 
-    @dataLevel.setter
-    def dataLevel(self, value):
+    @data_level.setter
+    def data_level(self, value):
         """ Set the RAID level for data.
 
             :param object value: new raid level
@@ -261,19 +261,19 @@ def dataLevel(self, value):
             :raises :class:`~.errors.BTRFSValueError`: if value represents
             an invalid level.
         """
-        self._setLevel(value, True)
+        self._set_level(value, True)
 
     @property
-    def metaDataLevel(self):
+    def metadata_level(self):
         """ Return the RAID level for metadata.
 
             :returns: raid level
             :rtype: an object that represents a raid level
         """
-        return self._metaDataLevel
+        return self._metadata_level
 
-    @metaDataLevel.setter
-    def metaDataLevel(self, value):
+    @metadata_level.setter
+    def metadata_level(self, value):
         """ Set the RAID level for metadata.
 
             :param object value: new raid level
@@ -281,18 +281,18 @@ def metaDataLevel(self, value):
             :raises :class:`~.errors.BTRFSValueError`: if value represents
             an invalid level.
         """
-        self._setLevel(value, False)
+        self._set_level(value, False)
 
     @property
-    def formatImmutable(self):
-        return super(BTRFSVolumeDevice, self).formatImmutable or self.exists
+    def format_immutable(self):
+        return super(BTRFSVolumeDevice, self).format_immutable or self.exists
 
-    def _setName(self, value):
+    def _set_name(self, value):
         self._name = value  # name is not used outside of blivet
 
-    def _setFormat(self, fmt):
+    def _set_format(self, fmt):
         """ Set the Device's format. """
-        super(BTRFSVolumeDevice, self)._setFormat(fmt)
+        super(BTRFSVolumeDevice, self)._set_format(fmt)
         self.name = "btrfs.%d" % self.id
         label = getattr(self.format, "label", None)
         if label:
@@ -302,50 +302,50 @@ def _setFormat(self, fmt):
             # propagate mount options specified for members via kickstart
             self.format.mountopts = self.parents[0].format.mountopts
 
-    def _getSize(self):
+    def _get_size(self):
         # Calculate the size as if it were a RAID with no superblock and a chunk_size of 1
-        dataLevel = self.dataLevel or raid.Single
-        return dataLevel.get_size([d.size for d in self.parents],
+        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)
 
-    def _removeParent(self, member):
-        levels = (l for l in (self.dataLevel, self.metaDataLevel) if l)
+    def _remove_parent(self, member):
+        levels = (l for l in (self.data_level, self.metadata_level) if l)
         for l in levels:
-            error_msg = self._validateParentRemoval(l, member)
+            error_msg = self._validate_parent_removal(l, member)
             if error_msg:
                 raise errors.DeviceError(error_msg)
-        super(BTRFSVolumeDevice, self)._removeParent(member)
+        super(BTRFSVolumeDevice, self)._remove_parent(member)
 
-    def _addSubVolume(self, vol):
+    def _add_subvolume(self, vol):
         if vol.name in [v.name for v in self.subvolumes]:
             raise errors.BTRFSValueError("subvolume %s already exists" % vol.name)
 
         self.subvolumes.append(vol)
 
-    def _removeSubVolume(self, name):
+    def _remove_subvolume(self, name):
         if name not in [v.name for v in self.subvolumes]:
             raise errors.BTRFSValueError("cannot remove non-existent subvolume %s" % name)
 
         names = [v.name for v in self.subvolumes]
         self.subvolumes.pop(names.index(name))
 
-    def listSubVolumes(self, snapshotsOnly=False):
+    def list_subvolumes(self, snapshots_only=False):
         subvols = []
         if flags.installer_mode:
             self.setup(orig=True)
-        elif not self.originalFormat.status:
+        elif not self.original_format.status:
             return subvols
 
         try:
             with self._do_temp_mount(orig=True) as mountpoint:
                 try:
                     subvols = blockdev.btrfs.list_subvolumes(mountpoint,
-                                                             snapshots_only=snapshotsOnly)
+                                                             snapshots_only=snapshots_only)
                 except blockdev.BtrfsError as e:
                     log.debug("failed to list subvolumes: %s", e)
                 else:
-                    self._getDefaultSubVolumeID()
+                    self._get_default_subvolume_id()
 
         except errors.FSError as e:
             pass
@@ -353,16 +353,16 @@ def listSubVolumes(self, snapshotsOnly=False):
         return subvols
 
     @util.deprecated('1.16', '')
-    def createSubVolumes(self):
+    def create_subvolumes(self):
         for _name, subvol in self.subvolumes:
             if subvol.exists:
                 continue
             subvol.create()
 
-    def removeSubVolume(self, name):
+    def remove_subvolume(self, name):
         raise NotImplementedError()
 
-    def _getDefaultSubVolumeID(self):
+    def _get_default_subvolume_id(self):
         subvolid = None
         with self._do_temp_mount() as mountpoint:
             try:
@@ -370,9 +370,9 @@ def _getDefaultSubVolumeID(self):
             except blockdev.BtrfsError as e:
                 log.debug("failed to get default subvolume id: %s", e)
 
-        self._defaultSubVolumeID = subvolid
+        self._default_subvolume_id = subvolid
 
-    def _setDefaultSubVolumeID(self, vol_id):
+    def _set_default_subvolume_id(self, vol_id):
         """ Set a new default subvolume by id.
 
             This writes the change to the filesystem, which must be mounted.
@@ -388,38 +388,38 @@ def _setDefaultSubVolumeID(self, vol_id):
                 # able to remove the subvolume.
                 raise
             else:
-                self._defaultSubVolumeID = vol_id
+                self._default_subvolume_id = vol_id
 
     @property
-    def defaultSubVolume(self):
+    def default_subvolume(self):
         default = None
-        if self._defaultSubVolumeID is None:
+        if self._default_subvolume_id is None:
             return None
 
-        if self._defaultSubVolumeID == self.vol_id:
+        if self._default_subvolume_id == self.vol_id:
             return self
 
         for sv in self.subvolumes:
-            if sv.vol_id == self._defaultSubVolumeID:
+            if sv.vol_id == self._default_subvolume_id:
                 default = sv
                 break
 
         return default
 
-    def _preCreate(self):
+    def _pre_create(self):
         if any(p.size < btrfs.MIN_MEMBER_SIZE for p in self.parents):
             raise errors.DeviceCreateError("All BTRFS member devices must have size at least %s." % btrfs.MIN_MEMBER_SIZE)
 
-        super(BTRFSVolumeDevice, self)._preCreate()
+        super(BTRFSVolumeDevice, self)._pre_create()
 
     def _create(self):
         log_method_call(self, self.name, status=self.status)
-        if self.dataLevel:
-            data_level = str(self.dataLevel)
+        if self.data_level:
+            data_level = str(self.data_level)
         else:
             data_level = None
-        if self.metaDataLevel:
-            md_level = str(self.metaDataLevel)
+        if self.metadata_level:
+            md_level = str(self.metadata_level)
         else:
             md_level = None
         blockdev.btrfs.create_volume([d.path for d in self.parents],
@@ -427,16 +427,16 @@ def _create(self):
                                      data_level=data_level,
                                      md_level=md_level)
 
-    def _postCreate(self):
-        super(BTRFSVolumeDevice, self)._postCreate()
-        info = udev.get_device(self.sysfsPath)
+    def _post_create(self):
+        super(BTRFSVolumeDevice, self)._post_create()
+        info = udev.get_device(self.sysfs_path)
         if not info:
             log.error("failed to get updated udev info for new btrfs volume")
         else:
-            self.format.volUUID = udev.device_get_uuid(info)
+            self.format.vol_uuid = udev.device_get_uuid(info)
 
         self.format.exists = True
-        self.originalFormat.exists = True
+        self.original_format.exists = True
 
     def _destroy(self):
         log_method_call(self, self.name, status=self.status)
@@ -455,17 +455,17 @@ def _add(self, member):
         with self._do_temp_mount() as mountpoint:
             blockdev.btrfs.add_device(mountpoint, member.path)
 
-    def populateKSData(self, data):
-        super(BTRFSVolumeDevice, self).populateKSData(data)
-        data.dataLevel = self.dataLevel.name if self.dataLevel else None
-        data.metaDataLevel = self.metaDataLevel.name if self.metaDataLevel else None
+    def populate_ksdata(self, data):
+        super(BTRFSVolumeDevice, self).populate_ksdata(data)
+        data.data_level = self.data_level.name if self.data_level else None
+        data.metadata_level = self.metadata_level.name if self.metadata_level else None
         data.devices = ["btrfs.%d" % p.id for p in self.parents]
         data.preexist = self.exists
 
 class BTRFSSubVolumeDevice(BTRFSDevice):
     """ A btrfs subvolume pseudo-device. """
     _type = "btrfs subvolume"
-    _formatImmutable = True
+    _format_immutable = True
 
     def __init__(self, *args, **kwargs):
         """
@@ -475,7 +475,7 @@ def __init__(self, *args, **kwargs):
             :keyword :class:`~.ParentList` parents: a list of parent devices
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat`
-            :keyword str sysfsPath: sysfs device path
+            :keyword str sysfs_path: sysfs device path
         """
         self.vol_id = kwargs.pop("vol_id", None)
 
@@ -487,11 +487,11 @@ def __init__(self, *args, **kwargs):
         if not isinstance(self.parents[0], BTRFSDevice):
             raise errors.BTRFSValueError("%s unique parent must be a BTRFSDevice." % self.type)
 
-        self.volume._addSubVolume(self)
+        self.volume._add_subvolume(self)
 
-    def _setFormat(self, fmt):
+    def _set_format(self, fmt):
         """ Set the Device's format. """
-        super(BTRFSSubVolumeDevice, self)._setFormat(fmt)
+        super(BTRFSSubVolumeDevice, self)._set_format(fmt)
         if self.exists:
             return
 
@@ -528,7 +528,7 @@ def volume(self):
     def container(self):
         return self.volume
 
-    def setupParents(self, orig=False):
+    def setup_parents(self, orig=False):
         """ Run setup method of all parent devices. """
         log_method_call(self, name=self.name, orig=orig, kids=self.kids)
         self.volume.setup(orig=orig)
@@ -539,36 +539,36 @@ def _create(self):
         with self.volume._do_temp_mount() as mountpoint:
             blockdev.btrfs.create_subvolume(mountpoint, self.name)
 
-    def _postCreate(self):
-        super(BTRFSSubVolumeDevice, self)._postCreate()
-        self.format.volUUID = self.volume.format.volUUID
+    def _post_create(self):
+        super(BTRFSSubVolumeDevice, self)._post_create()
+        self.format.vol_uuid = self.volume.format.vol_uuid
 
     def _destroy(self):
         log_method_call(self, self.name, status=self.status)
 
         with self.volume._do_temp_mount() as mountpoint:
-            if self.volume._defaultSubVolumeID == self.vol_id:
+            if self.volume._default_subvolume_id == self.vol_id:
                 # btrfs does not allow removal of the default subvolume
-                self.volume._setDefaultSubVolumeID(self.volume.vol_id)
+                self.volume._set_default_subvolume_id(self.volume.vol_id)
 
             blockdev.btrfs.delete_subvolume(mountpoint, self.name)
 
-    def removeHook(self, modparent=True):
+    def remove_hook(self, modparent=True):
         if modparent:
-            self.volume._removeSubVolume(self.name)
+            self.volume._remove_subvolume(self.name)
 
-        super(BTRFSSubVolumeDevice, self).removeHook(modparent=modparent)
+        super(BTRFSSubVolumeDevice, self).remove_hook(modparent=modparent)
 
-    def addHook(self, new=True):
-        super(BTRFSSubVolumeDevice, self).addHook(new=new)
+    def add_hook(self, new=True):
+        super(BTRFSSubVolumeDevice, self).add_hook(new=new)
         if new:
             return
 
         if self not in self.volume.subvolumes:
-            self.volume._addSubVolume(self)
+            self.volume._add_subvolume(self)
 
-    def populateKSData(self, data):
-        super(BTRFSSubVolumeDevice, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(BTRFSSubVolumeDevice, self).populate_ksdata(data)
         data.subvol = True
         data.name = self.name
         data.preexist = self.exists
@@ -598,9 +598,9 @@ def __init__(self, *args, **kwargs):
             :keyword :class:`~.ParentList` parents: a list of parent devices
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat`
-            :keyword str sysfsPath: sysfs device path
+            :keyword str sysfs_path: sysfs device path
             :keyword :class:`~.BTRFSDevice` source: the snapshot source
-            :keyword bool readOnly: create a read-only snapshot
+            :keyword bool read_only: create a read-only snapshot
 
             Snapshot source can be either a subvolume or a top-level volume.
 
@@ -619,12 +619,12 @@ def __init__(self, *args, **kwargs):
         self.source = source
         """ the snapshot's source subvolume """
 
-        self.readOnly = kwargs.pop("readOnly", False)
+        self.read_only = kwargs.pop("read_only", False)
 
         super(BTRFSSnapShotDevice, self).__init__(*args, **kwargs)
 
         if source and getattr(source, "volume", source) != self.volume:
-            self.volume._removeSubVolume(self.name)
+            self.volume._remove_subvolume(self.name)
             self.parents = []
             raise errors.BTRFSValueError("btrfs snapshot and source must be in the same volume")
 
@@ -639,8 +639,8 @@ def _create(self):
 
             dest_path = "%s/%s" % (mountpoint, self.name)
 
-            blockdev.btrfs.create_snapshot(source_path, dest_path, ro=self.readOnly)
+            blockdev.btrfs.create_snapshot(source_path, dest_path, ro=self.read_only)
 
-    def dependsOn(self, dep):
+    def depends_on(self, dep):
         return (dep == self.source or
-                super(BTRFSSnapShotDevice, self).dependsOn(dep))
+                super(BTRFSSnapShotDevice, self).depends_on(dep))
diff --git a/blivet/devices/container.py b/blivet/devices/container.py
index bd5353c..fdfba8e 100644
--- a/blivet/devices/container.py
+++ b/blivet/devices/container.py
@@ -50,19 +50,19 @@ class ContainerDevice(StorageDevice):
         :meth:`.deviceaction.ActionRemoveMember.execute`.
     """
 
-    _formatClassName = abc.abstractproperty(lambda s: None,
+    _format_class_name = abc.abstractproperty(lambda s: None,
         doc="The type of member devices' required format")
-    _formatUUIDAttr = abc.abstractproperty(lambda s: None,
+    _format_uuid_attr = abc.abstractproperty(lambda s: None,
         doc="The container UUID attribute in the member format class")
 
     def __init__(self, *args, **kwargs):
-        self.formatClass = get_device_format_class(self._formatClassName)
-        if not self.formatClass:
-            raise errors.StorageError("cannot find '%s' class" % self._formatClassName)
+        self.format_class = get_device_format_class(self._format_class_name)
+        if not self.format_class:
+            raise errors.StorageError("cannot find '%s' class" % self._format_class_name)
 
         super(ContainerDevice, self).__init__(*args, **kwargs)
 
-    def _verifyMemberUuid(self, member, expect_equality=True, require_existence=True):
+    def _verify_member_uuid(self, member, expect_equality=True, require_existence=True):
         """ Whether the member's array UUID has the proper relationship
             with its array's UUID.
 
@@ -73,15 +73,15 @@ def _verifyMemberUuid(self, member, expect_equality=True, require_existence=True
             :returns: error msg if the UUIDs lack the correct relationship
             :rtype: str or NoneType
         """
-        if not self._formatUUIDAttr:
+        if not self._format_uuid_attr:
             log.info("No attribute name corresponding to member's array UUID.")
             return None
 
-        if not hasattr(member.format, self._formatUUIDAttr):
-            log.warning("Attribute name (%s) which specifies member format's array UUID does not exist for this object (%s).", self._formatUUIDAttr, member)
+        if not hasattr(member.format, self._format_uuid_attr):
+            log.warning("Attribute name (%s) which specifies member format's array UUID does not exist for this object (%s).", self._format_uuid_attr, member)
             return None
 
-        member_fmt_uuid = getattr(member.format, self._formatUUIDAttr)
+        member_fmt_uuid = getattr(member.format, self._format_uuid_attr)
 
         # If either UUID can not be obtained, nothing to check.
         if self.exists and (not member_fmt_uuid or not self.uuid):
@@ -104,7 +104,7 @@ def _verifyMemberUuid(self, member, expect_equality=True, require_existence=True
 
         return None
 
-    def _addParent(self, member):
+    def _add_parent(self, member):
         """ Add a member device to the container.
 
             :param member: the member device to add
@@ -114,14 +114,14 @@ def _addParent(self, member):
             contents at all.
         """
         log_method_call(self, self.name, member=member.name)
-        if not isinstance(member.format, self.formatClass):
+        if not isinstance(member.format, self.format_class):
             raise ValueError("member has wrong format")
 
-        error = self._verifyMemberUuid(member)
+        error = self._verify_member_uuid(member)
         if error:
             raise ValueError("cannot add member with mismatched UUID")
 
-        super(ContainerDevice, self)._addParent(member)
+        super(ContainerDevice, self)._add_parent(member)
 
     @abc.abstractmethod
     def _add(self, member):
@@ -145,7 +145,7 @@ def add(self, member):
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        error = self._verifyMemberUuid(member, expect_equality=False)
+        error = self._verify_member_uuid(member, expect_equality=False)
         if error:
             log.error("cannot re-add member: %s (%s)", member, error)
             raise ValueError("cannot add members that are already part of the container")
@@ -178,7 +178,7 @@ def remove(self, member):
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        error = self._verifyMemberUuid(member, require_existence=False)
+        error = self._verify_member_uuid(member, require_existence=False)
         if error:
             log.error("cannot remove non-member: %s (%s)", member, error)
             raise ValueError("cannot remove members that are not part of the container")
@@ -188,5 +188,5 @@ def remove(self, member):
         if member in self.parents:
             self.parents.remove(member)
 
-    def updateSize(self):
+    def update_size(self):
         pass
diff --git a/blivet/devices/device.py b/blivet/devices/device.py
index 247f792..e5e3f95 100644
--- a/blivet/devices/device.py
+++ b/blivet/devices/device.py
@@ -77,9 +77,9 @@ def __init__(self, name, parents=None):
         util.ObjectID.__init__(self)
         self.kids = 0
 
-        # Copy only the validity check from _setName so we don't try to check a
+        # Copy only the validity check from _set_name so we don't try to check a
         # bunch of inappropriate state properties during __init__ in subclasses
-        if not self.isNameValid(name):
+        if not self.is_name_valid(name):
             raise ValueError("%s is not a valid name for this device" % name)
         self._name = name
 
@@ -96,7 +96,7 @@ def __deepcopy__(self, memo):
         """
         return util.variable_copy(self, memo,
            omit=('node',),
-           shallow=('_partedPartition',))
+           shallow=('_parted_partition',))
 
     def __repr__(self):
         s = ("%(type)s instance (%(id)s) --\n"
@@ -110,52 +110,52 @@ def __repr__(self):
         return s
 
     # Force str and unicode types in case type or name is unicode
-    def _toString(self):
+    def _to_string(self):
         s = "%s %s (%d)" % (self.type, self.name, self.id)
         return s
 
     def __str__(self):
-        return util.stringize(self._toString())
+        return util.stringize(self._to_string())
 
     def __unicode__(self):
-        return util.unicodeize(self._toString())
+        return util.unicodeize(self._to_string())
 
-    def _addParent(self, parent):
+    def _add_parent(self, parent):
         """ Called before adding a parent to this device.
 
             See :attr:`~.ParentList.appendfunc`.
         """
-        parent.addChild()
+        parent.add_child()
 
-    def _removeParent(self, parent):
+    def _remove_parent(self, parent):
         """ Called before removing a parent from this device.
 
             See :attr:`~.ParentList.removefunc`.
         """
-        parent.removeChild()
+        parent.remove_child()
 
-    def _initParentList(self):
+    def _init_parent_list(self):
         """ Initialize this instance's parent list. """
         if not hasattr(self, "_parents"):
             # pylint: disable=attribute-defined-outside-init
-            self._parents = ParentList(appendfunc=self._addParent,
-                                       removefunc=self._removeParent)
+            self._parents = ParentList(appendfunc=self._add_parent,
+                                       removefunc=self._remove_parent)
 
         # iterate over a copy of the parent list because we are altering it in
         # the for-cycle
         for parent in list(self._parents):
             self._parents.remove(parent)
 
-    def _setParentList(self, parents):
+    def _set_parent_list(self, parents):
         """ Set this instance's parent list. """
-        self._initParentList()
+        self._init_parent_list()
         for parent in parents:
             self._parents.append(parent)
 
-    def _getParentList(self):
+    def _get_parent_list(self):
         return self._parents
 
-    parents = property(_getParentList, _setParentList,
+    parents = property(_get_parent_list, _set_parent_list,
                        doc="devices upon which this device is built")
 
     @property
@@ -164,12 +164,12 @@ def dict(self):
               "parents": [p.name for p in self.parents]}
         return d
 
-    def removeChild(self):
+    def remove_child(self):
         """ Decrement the child counter for this device. """
         log_method_call(self, name=self.name, kids=self.kids)
         self.kids -= 1
 
-    def addChild(self):
+    def add_child(self):
         """ Increment the child counter for this device. """
         log_method_call(self, name=self.name, kids=self.kids)
         self.kids += 1
@@ -190,7 +190,7 @@ def destroy(self):
         """ Destroy the device. """
         raise NotImplementedError("destroy method not defined for Device")
 
-    def setupParents(self, orig=False):
+    def setup_parents(self, orig=False):
         """ Run setup method of all parent devices.
 
             :keyword orig: set up original format instead of current format
@@ -200,7 +200,7 @@ def setupParents(self, orig=False):
         for parent in self.parents:
             parent.setup(orig=orig)
 
-    def teardownParents(self, recursive=None):
+    def teardown_parents(self, recursive=None):
         """ Run teardown method of all parent devices.
 
             :keyword recursive: tear down all ancestor devices recursively
@@ -209,7 +209,7 @@ def teardownParents(self, recursive=None):
         for parent in self.parents:
             parent.teardown(recursive=recursive)
 
-    def dependsOn(self, dep):
+    def depends_on(self, dep):
         """ Return True if this device depends on dep.
 
             This device depends on another device if the other device is an
@@ -226,12 +226,12 @@ def dependsOn(self, dep):
             return True
 
         for parent in self.parents:
-            if parent.dependsOn(dep):
+            if parent.depends_on(dep):
                 return True
 
         return False
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         return set()
 
     @property
@@ -239,16 +239,16 @@ def status(self):
         """ Is this device currently active and ready for use? """
         return False
 
-    def _getName(self):
+    def _get_name(self):
         return self._name
 
-    def _setName(self, value):
-        if not self.isNameValid(value):
+    def _set_name(self, value):
+        if not self.is_name_valid(value):
             raise ValueError("%s is not a valid name for this device" % value)
         self._name = value
 
-    name = property(lambda s: s._getName(),
-                    lambda s, v: s._setName(v),
+    name = property(lambda s: s._get_name(),
+                    lambda s, v: s._set_name(v),
                     doc="This device's name")
 
     @property
@@ -257,7 +257,7 @@ def isleaf(self):
         return self.kids == 0
 
     @property
-    def typeDescription(self):
+    def type_description(self):
         """ String describing the device type. """
         return self._type
 
@@ -289,7 +289,7 @@ def packages(self):
         return packages
 
     @classmethod
-    def isNameValid(cls, name): # pylint: disable=unused-argument
+    def is_name_valid(cls, name): # pylint: disable=unused-argument
         """Is the device name valid for the device type?"""
 
         # By default anything goes
diff --git a/blivet/devices/disk.py b/blivet/devices/disk.py
index 1abfab5..f4c8a45 100644
--- a/blivet/devices/disk.py
+++ b/blivet/devices/disk.py
@@ -51,14 +51,14 @@ class DiskDevice(StorageDevice):
 
         This is not the only kind of device that is treated as a disk. More
         useful than checking isinstance(device, DiskDevice) is checking
-        device.isDisk.
+        device.is_disk.
     """
     _type = "disk"
     _partitionable = True
-    _isDisk = True
+    _is_disk = True
 
     def __init__(self, name, fmt=None,
-                 size=None, major=None, minor=None, sysfsPath='',
+                 size=None, major=None, minor=None, sysfs_path='',
                  parents=None, serial=None, vendor="", model="", bus="",
                  exists=True):
         """
@@ -72,8 +72,8 @@ def __init__(self, name, fmt=None,
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
             :keyword uuid: universally unique identifier (device -- not fs)
             :type uuid: str
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword removable: whether or not this is a removable device
             :type removable: bool
             :keyword serial: the ID_SERIAL_RAW, ID_SERIAL or ID_SERIAL_SHORT for
@@ -90,7 +90,7 @@ def __init__(self, name, fmt=None,
         """
         StorageDevice.__init__(self, name, fmt=fmt, size=size,
                                major=major, minor=minor, exists=exists,
-                               sysfsPath=sysfsPath, parents=parents,
+                               sysfs_path=sysfs_path, parents=parents,
                                serial=serial, model=model,
                                vendor=vendor, bus=bus)
 
@@ -100,26 +100,26 @@ def __repr__(self):
         return s
 
     @property
-    def mediaPresent(self):
+    def media_present(self):
         if flags.testing:
             return True
 
         # Some drivers (cpqarray <blegh>) make block device nodes for
         # controllers with no disks attached and then report a 0 size,
         # treat this as no media present
-        return self.exists and self.currentSize > Size(0)
+        return self.exists and self.current_size > Size(0)
 
     @property
     def description(self):
         return " ".join(s for s in (self.vendor, self.model) if s)
 
-    def _preDestroy(self):
+    def _pre_destroy(self):
         """ Destroy the device. """
         log_method_call(self, self.name, status=self.status)
-        if not self.mediaPresent:
+        if not self.media_present:
             raise errors.DeviceError("cannot destroy disk with no media", self.name)
 
-        StorageDevice._preDestroy(self)
+        StorageDevice._pre_destroy(self)
 
 class DiskFile(DiskDevice):
     """ This is a file that we will pretend is a disk.
@@ -129,10 +129,10 @@ class DiskFile(DiskDevice):
         class as a non-root user. It is not known how the system will behave if
         partitions are committed to one of these disks.
     """
-    _devDir = ""
+    _dev_dir = ""
 
     def __init__(self, name, fmt=None,
-                 size=None, major=None, minor=None, sysfsPath='',
+                 size=None, major=None, minor=None, sysfs_path='',
                  parents=None, serial=None, vendor="", model="", bus="",
                  exists=True):
         """
@@ -140,10 +140,10 @@ def __init__(self, name, fmt=None,
             :keyword :class:`~.formats.DeviceFormat` fmt: the device's format
         """
         _name = os.path.basename(name)
-        self._devDir = os.path.dirname(name)
+        self._dev_dir = os.path.dirname(name)
 
         super(DiskFile, self).__init__(_name, fmt=fmt, size=size,
-                            major=major, minor=minor, sysfsPath=sysfsPath,
+                            major=major, minor=minor, sysfs_path=sysfs_path,
                             parents=parents, serial=serial, vendor=vendor,
                             model=model, bus=bus, exists=exists)
 
@@ -151,17 +151,17 @@ def __init__(self, name, fmt=None,
     # Regular files do not have sysfs entries.
     #
     @property
-    def sysfsPath(self):
+    def sysfs_path(self):
         return ""
 
-    @sysfsPath.setter
-    def sysfsPath(self, value):
+    @sysfs_path.setter
+    def sysfs_path(self, value):
         pass
 
-    def updateSysfsPath(self):
+    def update_sysfs_path(self):
         pass
 
-    def readCurrentSize(self):
+    def read_current_size(self):
         size = Size(0)
         if self.exists and os.path.exists(self.path):
             st = os.stat(self.path)
@@ -174,13 +174,13 @@ class DMRaidArrayDevice(DMDevice, ContainerDevice):
     _type = "dm-raid array"
     _packages = ["dmraid"]
     _partitionable = True
-    _isDisk = True
-    _formatClassName = property(lambda s: "dmraidmember")
-    _formatUUIDAttr = property(lambda s: None)
+    _is_disk = True
+    _format_class_name = property(lambda s: "dmraidmember")
+    _format_uuid_attr = property(lambda s: None)
     _external_dependencies = [availability.BLOCKDEV_DM_PLUGIN]
 
     def __init__(self, name, fmt=None,
-                 size=None, parents=None, sysfsPath=''):
+                 size=None, parents=None, sysfs_path=''):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -190,15 +190,15 @@ def __init__(self, name, fmt=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
 
             DMRaidArrayDevices always exist. Blivet cannot create or destroy
             them.
         """
         super(DMRaidArrayDevice, self).__init__(name, fmt=fmt, size=size,
                                                 parents=parents, exists=True,
-                                                sysfsPath=sysfsPath)
+                                                sysfs_path=sysfs_path)
 
 
     @property
@@ -229,7 +229,7 @@ def teardown(self, recursive=None):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        if not self._preTeardown(recursive=recursive):
+        if not self._pre_teardown(recursive=recursive):
             return
 
         log.debug("not tearing down dmraid device %s", self.name)
@@ -248,7 +248,7 @@ def description(self):
     def model(self):
         return self.description
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         return set(["rd.dm.uuid=%s" % self.name])
 
 class MultipathDevice(DMDevice):
@@ -256,11 +256,11 @@ class MultipathDevice(DMDevice):
     _type = "dm-multipath"
     _packages = ["device-mapper-multipath"]
     _partitionable = True
-    _isDisk = True
+    _is_disk = True
     _external_dependencies = [availability.MULTIPATH_APP]
 
     def __init__(self, name, fmt=None, size=None, serial=None,
-                 parents=None, sysfsPath=''):
+                 parents=None, sysfs_path=''):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -270,8 +270,8 @@ def __init__(self, name, fmt=None, size=None, serial=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword serial: the device's serial number
             :type serial: str
 
@@ -280,7 +280,7 @@ def __init__(self, name, fmt=None, size=None, serial=None,
         """
 
         DMDevice.__init__(self, name, fmt=fmt, size=size,
-                          parents=parents, sysfsPath=sysfsPath,
+                          parents=parents, sysfs_path=sysfs_path,
                           exists=True)
 
         self.identity = serial
@@ -316,7 +316,7 @@ def vendor(self):
     def description(self):
         return "WWID %s" % (self.wwid,)
 
-    def addParent(self, parent):
+    def add_parent(self, parent):
         """ Add a parent device to the mpath. """
         log_method_call(self, self.name, status=self.status)
         if self.status:
@@ -336,9 +336,9 @@ def _setup(self, orig=False):
             raise errors.MPathError("multipath activation failed for '%s'" %
                             self.name, hardware_fault=True)
 
-    def _postSetup(self):
-        StorageDevice._postSetup(self)
-        self.setupPartitions()
+    def _post_setup(self):
+        StorageDevice._post_setup(self)
+        self.setup_partitions()
         udev.settle()
 
 
@@ -399,7 +399,7 @@ def __init__(self, device, **kwargs):
                                                                    self.node.iface,
                                                                    self.nic)
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         if self.ibft:
             return set(["iscsi_firmware"])
 
@@ -413,7 +413,7 @@ def dracutSetupArgs(self):
             address = "[%s]" % address
 
         netroot="netroot=iscsi:"
-        auth = self.node.getAuth()
+        auth = self.node.get_auth()
         if auth:
             netroot += "%s:%s" % (auth.username, auth.password)
             if len(auth.reverse_username) or len(auth.reverse_password):
@@ -459,7 +459,7 @@ def __init__(self, device, **kwargs):
         log.debug("created new fcoe disk %s (%s) @ %s",
                   device, self.identifier, self.nic)
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         dcb = True
 
         for nic, dcb, _auto_vlan in fcoe().nics:
@@ -469,14 +469,14 @@ def dracutSetupArgs(self):
             return set()
 
         if dcb:
-            dcbOpt = "dcb"
+            dcb_opt = "dcb"
         else:
-            dcbOpt = "nodcb"
+            dcb_opt = "nodcb"
 
         if self.nic in fcoe().added_nics:
-            return set(["fcoe=%s:%s" % (self.nic, dcbOpt)])
+            return set(["fcoe=%s:%s" % (self.nic, dcb_opt)])
         else:
-            return set(["fcoe=edd:%s" % dcbOpt])
+            return set(["fcoe=edd:%s" % dcb_opt])
 
 
 class ZFCPDiskDevice(DiskDevice):
@@ -519,7 +519,7 @@ def description(self):
                   'wwpn': self.wwpn,
                   'lun': self.fcp_lun}
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         return set(["rd.zfcp=%s,%s,%s" % (self.hba_id, self.wwpn, self.fcp_lun,)])
 
 class DASDDevice(DiskDevice):
@@ -550,15 +550,15 @@ def __init__(self, device, **kwargs):
     def description(self):
         return "DASD device %s" % self.busid
 
-    def getOpts(self):
+    def get_opts(self):
         return ["%s=%s" % (k, v) for k, v in self.opts.items() if v == '1']
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         conf = "/etc/dasd.conf"
         line = None
         if os.path.isfile(conf):
             f = open(conf)
-            # grab the first line that starts with our busID
+            # grab the first line that starts with our bus_id
             for l in f.readlines():
                 if l.startswith(self.busid):
                     line = l.rstrip()
@@ -566,10 +566,10 @@ def dracutSetupArgs(self):
 
             f.close()
 
-        # See if we got a line.  If not, grab our getOpts
+        # See if we got a line.  If not, grab our get_opts
         if not line:
             line = self.busid
-            for devopt in self.getOpts():
+            for devopt in self.get_opts():
                 line += " %s" % devopt
 
         # Create a translation mapping from dasd.conf format to module format
diff --git a/blivet/devices/dm.py b/blivet/devices/dm.py
index 04cc390..a1e9db1 100644
--- a/blivet/devices/dm.py
+++ b/blivet/devices/dm.py
@@ -42,14 +42,14 @@
 class DMDevice(StorageDevice):
     """ A device-mapper device """
     _type = "dm"
-    _devDir = "/dev/mapper"
+    _dev_dir = "/dev/mapper"
     _external_dependencies = [
        availability.KPARTX_APP,
        availability.BLOCKDEV_DM_PLUGIN
     ]
 
-    def __init__(self, name, fmt=None, size=None, dmUuid=None, uuid=None,
-                 target=None, exists=False, parents=None, sysfsPath=''):
+    def __init__(self, name, fmt=None, size=None, dm_uuid=None, uuid=None,
+                 target=None, exists=False, parents=None, sysfs_path=''):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -61,62 +61,62 @@ def __init__(self, name, fmt=None, size=None, dmUuid=None, uuid=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
-            :keyword dmUuid: device-mapper UUID (see note below)
-            :type dmUuid: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
+            :keyword dm_uuid: device-mapper UUID (see note below)
+            :type dm_uuid: str
             :type str uuid: device UUID (see note below)
             :keyword target: device mapper table/target name (eg: "linear")
             :type target: str
 
             .. note::
 
-                The dmUuid is not necessarily persistent, as it is based on
+                The dm_uuid is not necessarily persistent, as it is based on
                 map name in many cases. The uuid, however, is a persistent UUID
                 stored in device metadata on disk.
         """
         super(DMDevice, self).__init__(name, fmt=fmt, size=size,
                                exists=exists, uuid=uuid,
-                               parents=parents, sysfsPath=sysfsPath)
+                               parents=parents, sysfs_path=sysfs_path)
         self.target = target
-        self.dmUuid = dmUuid
+        self.dm_uuid = dm_uuid
 
     def __repr__(self):
         s = StorageDevice.__repr__(self)
-        s += ("  target = %(target)s  dmUuid = %(dmUuid)s" %
-              {"target": self.target, "dmUuid": self.dmUuid})
+        s += ("  target = %(target)s  dm_uuid = %(dm_uuid)s" %
+              {"target": self.target, "dm_uuid": self.dm_uuid})
         return s
 
     @property
     def dict(self):
         d = super(DMDevice, self).dict
-        d.update({"target": self.target, "dmUuid": self.dmUuid})
+        d.update({"target": self.target, "dm_uuid": self.dm_uuid})
         return d
 
     @property
-    def fstabSpec(self):
+    def fstab_spec(self):
         """ Return the device specifier for use in /etc/fstab. """
         return self.path
 
     @property
-    def mapName(self):
+    def map_name(self):
         """ This device's device-mapper map name """
         return self.name
 
     @property
     def status(self):
         try:
-            return blockdev.dm.map_exists(self.mapName, True, True)
+            return blockdev.dm.map_exists(self.map_name, True, True)
         except blockdev.DMError as e:
             if "Not running as root" in str(e):
                 return False
             else:
                 raise
 
-    #def getTargetType(self):
-    #    return dm.getDmTarget(name=self.name)
+    #def get_target_type(self):
+    #    return dm.get_dm_target(name=self.name)
 
-    def getDMNode(self):
+    def get_dm_node(self):
         """ Return the dm-X (eg: dm-0) device node for this device. """
         log_method_call(self, self.name, status=self.status)
         if not self.exists:
@@ -124,14 +124,14 @@ def getDMNode(self):
 
         return blockdev.dm.node_from_name(self.name)
 
-    def setupPartitions(self):
+    def setup_partitions(self):
         log_method_call(self, name=self.name, kids=self.kids)
         rc = util.run_program(["kpartx", "-a", "-s", self.path])
         if rc:
             raise errors.DMError("partition activation failed for '%s'" % self.name)
         udev.settle()
 
-    def teardownPartitions(self):
+    def teardown_partitions(self):
         log_method_call(self, name=self.name, kids=self.kids)
         rc = util.run_program(["kpartx", "-d", "-s", self.path])
         if rc:
@@ -142,13 +142,13 @@ def teardownPartitions(self):
             if dev.startswith(prefix) and dev[len(prefix):].isdigit():
                 blockdev.dm.remove(dev)
 
-    def _setName(self, value):
+    def _set_name(self, value):
         """ Set the device's map name. """
         if value == self._name:
             return
 
         log_method_call(self, self.name, status=self.status)
-        super(DMDevice, self)._setName(value)
+        super(DMDevice, self)._set_name(value)
 
     @property
     def slave(self):
@@ -159,10 +159,10 @@ def slave(self):
 class DMLinearDevice(DMDevice):
     _type = "dm-linear"
     _partitionable = True
-    _isDisk = True
+    _is_disk = True
 
-    def __init__(self, name, fmt=None, size=None, dmUuid=None,
-                 exists=False, parents=None, sysfsPath=''):
+    def __init__(self, name, fmt=None, size=None, dm_uuid=None,
+                 exists=False, parents=None, sysfs_path=''):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -174,33 +174,33 @@ def __init__(self, name, fmt=None, size=None, dmUuid=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
-            :keyword dmUuid: device-mapper UUID
-            :type dmUuid: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
+            :keyword dm_uuid: device-mapper UUID
+            :type dm_uuid: str
         """
         if not parents:
             raise ValueError("DMLinearDevice requires a backing block device")
 
         DMDevice.__init__(self, name, fmt=fmt, size=size,
-                          parents=parents, sysfsPath=sysfsPath,
-                          exists=exists, target="linear", dmUuid=dmUuid)
+                          parents=parents, sysfs_path=sysfs_path,
+                          exists=exists, target="linear", dm_uuid=dm_uuid)
 
     def _setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        slave_length = self.slave.currentSize / LINUX_SECTOR_SIZE
+        slave_length = self.slave.current_size / LINUX_SECTOR_SIZE
         blockdev.dm.create_linear(self.name, self.slave.path, slave_length,
-                                  self.dmUuid)
+                                  self.dm_uuid)
 
-    def _postSetup(self):
-        StorageDevice._postSetup(self)
-        self.setupPartitions()
+    def _post_setup(self):
+        StorageDevice._post_setup(self)
+        self.setup_partitions()
         udev.settle()
 
     def _teardown(self, recursive=False):
-        self.teardownPartitions()
+        self.teardown_partitions()
         udev.settle()
         blockdev.dm.remove(self.name)
         udev.settle()
@@ -212,7 +212,7 @@ def teardown(self, recursive=None):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        if not self._preTeardown(recursive=recursive):
+        if not self._pre_teardown(recursive=recursive):
             return
 
         log.debug("not tearing down dm-linear device %s", self.name)
@@ -228,7 +228,7 @@ class DMCryptDevice(DMDevice):
     _encrypted = True
 
     def __init__(self, name, fmt=None, size=None, uuid=None,
-                 exists=False, sysfsPath='', parents=None):
+                 exists=False, sysfs_path='', parents=None):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -240,9 +240,9 @@ def __init__(self, name, fmt=None, size=None, uuid=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
         """
         DMDevice.__init__(self, name, fmt=fmt, size=size,
-                          parents=parents, sysfsPath=sysfsPath,
+                          parents=parents, sysfs_path=sysfs_path,
                           exists=exists, target="crypt")
diff --git a/blivet/devices/file.py b/blivet/devices/file.py
index a2845eb..804bb0e 100644
--- a/blivet/devices/file.py
+++ b/blivet/devices/file.py
@@ -38,7 +38,7 @@ class FileDevice(StorageDevice):
         This exists because of swap files.
     """
     _type = "file"
-    _devDir = ""
+    _dev_dir = ""
 
     def __init__(self, path, fmt=None, size=None,
                  exists=False, parents=None):
@@ -61,13 +61,13 @@ def __init__(self, path, fmt=None, size=None,
                                exists=exists, parents=parents)
 
     @property
-    def fstabSpec(self):
+    def fstab_spec(self):
         return self.name
 
     @property
     def path(self):
         try:
-            root = self.parents[0].format.systemMountpoint
+            root = self.parents[0].format.system_mountpoint
             mountpoint = self.parents[0].format.mountpoint
         except (AttributeError, IndexError):
             root = ""
@@ -81,7 +81,7 @@ def path(self):
 
         return os.path.normpath("%s%s" % (root, self.name))
 
-    def _getSize(self):
+    def _get_size(self):
         size = self._size
         if self.exists and os.path.exists(self.path):
             st = os.stat(self.path)
@@ -89,17 +89,17 @@ def _getSize(self):
 
         return size
 
-    def _preSetup(self, orig=False):
+    def _pre_setup(self, orig=False):
         if self.format and self.format.exists and not self.format.status:
             self.format.device = self.path
 
-        return StorageDevice._preSetup(self, orig=orig)
+        return StorageDevice._pre_setup(self, orig=orig)
 
-    def _preTeardown(self, recursive=None):
+    def _pre_teardown(self, recursive=None):
         if self.format and self.format.exists and not self.format.status:
             self.format.device = self.path
 
-        return StorageDevice._preTeardown(self, recursive=recursive)
+        return StorageDevice._pre_teardown(self, recursive=recursive)
 
     def _create(self):
         """ Create the device. """
@@ -127,8 +127,8 @@ def _destroy(self):
         os.unlink(self.path)
 
     @classmethod
-    def isNameValid(cls, name):
-        # Override StorageDevice.isNameValid to allow /
+    def is_name_valid(cls, name):
+        # Override StorageDevice.is_name_valid to allow /
         return not('\x00' in name or name == '.' or name == '..')
 
 class SparseFileDevice(FileDevice):
diff --git a/blivet/devices/lib.py b/blivet/devices/lib.py
index f760c89..4d8cf69 100644
--- a/blivet/devices/lib.py
+++ b/blivet/devices/lib.py
@@ -41,21 +41,21 @@ def get_device_majors():
     return majors
 device_majors = get_device_majors()
 
-def devicePathToName(devicePath):
+def device_path_to_name(device_path):
     """ Return a name based on the given path to a device node.
 
-        :param devicePath: the path to a device node
-        :type devicePath: str
+        :param device_path: the path to a device node
+        :type device_path: str
         :returns: the name
         :rtype: str
     """
-    if not devicePath:
+    if not device_path:
         return None
 
-    if devicePath.startswith("/dev/"):
-        name = devicePath[5:]
+    if device_path.startswith("/dev/"):
+        name = device_path[5:]
     else:
-        name = devicePath
+        name = device_path
 
     if name.startswith("mapper/"):
         name = name[7:]
@@ -68,26 +68,26 @@ def devicePathToName(devicePath):
 
     return name
 
-def deviceNameToDiskByPath(deviceName=None):
+def device_name_to_disk_by_path(device_name=None):
     """ Return a /dev/disk/by-path/ symlink path for the given device name.
 
-        :param deviceName: the device name
-        :type deviceName: str
+        :param device_name: the device name
+        :type device_name: str
         :returns: the full path to a /dev/disk/by-path/ symlink, or None
         :rtype: str or NoneType
     """
-    if not deviceName:
+    if not device_name:
         return ""
 
     ret = None
     for dev in udev.get_devices():
-        if udev.device_get_name(dev) == deviceName:
+        if udev.device_get_name(dev) == device_name:
             ret = udev.device_get_by_path(dev)
             break
 
     if ret:
         return ret
-    raise errors.DeviceNotFoundError(deviceName)
+    raise errors.DeviceNotFoundError(device_name)
 
 class ParentList(object):
     """ A list with auditing and side-effects for additions and removals.
@@ -183,5 +183,5 @@ def replace(self, x, y):
 
         idx = self.items.index(x)
         self.items[idx] = y
-        x.removeChild()
-        y.addChild()
+        x.remove_child()
+        y.add_child()
diff --git a/blivet/devices/loop.py b/blivet/devices/loop.py
index 27c56b0..95d07d6 100644
--- a/blivet/devices/loop.py
+++ b/blivet/devices/loop.py
@@ -40,7 +40,7 @@ class LoopDevice(StorageDevice):
     _type = "loop"
     _external_dependencies = [availability.BLOCKDEV_LOOP_PLUGIN]
 
-    def __init__(self, name=None, fmt=None, size=None, sysfsPath=None,
+    def __init__(self, name=None, fmt=None, size=None, sysfs_path=None,
                  exists=False, parents=None):
         """
             :param name: the device name (generally a device node's basename)
@@ -66,10 +66,10 @@ def __init__(self, name=None, fmt=None, size=None, sysfsPath=None,
         StorageDevice.__init__(self, name, fmt=fmt, size=size,
                                exists=True, parents=parents)
 
-    def _setName(self, value):
+    def _set_name(self, value):
         self._name = value  # actual name is set by losetup
 
-    def updateName(self):
+    def update_name(self):
         """ Update this device's name. """
         if not self.slave.status:
             # if the backing device is inactive, so are we
@@ -95,10 +95,10 @@ def status(self):
     def size(self):
         return self.slave.size
 
-    def _preSetup(self, orig=False):
+    def _pre_setup(self, orig=False):
         if not os.path.exists(self.slave.path):
             raise errors.DeviceError("specified file (%s) does not exist" % self.slave.path)
-        return StorageDevice._preSetup(self, orig=orig)
+        return StorageDevice._pre_setup(self, orig=orig)
 
     def _setup(self, orig=False):
         """ Open, or set up, a device. """
@@ -106,10 +106,10 @@ def _setup(self, orig=False):
                         controllable=self.controllable)
         blockdev.loop.setup(self.slave.path)
 
-    def _postSetup(self):
-        StorageDevice._postSetup(self)
-        self.updateName()
-        self.updateSysfsPath()
+    def _post_setup(self):
+        StorageDevice._post_setup(self)
+        self.update_name()
+        self.update_sysfs_path()
 
     def _teardown(self, recursive=False):
         """ Close, or tear down, a device. """
@@ -117,10 +117,10 @@ def _teardown(self, recursive=False):
                         controllable=self.controllable)
         blockdev.loop.teardown(self.path)
 
-    def _postTeardown(self, recursive=False):
-        StorageDevice._postTeardown(self, recursive=recursive)
+    def _post_teardown(self, recursive=False):
+        StorageDevice._post_teardown(self, recursive=recursive)
         self.name = "tmploop%d" % self.id
-        self.sysfsPath = ''
+        self.sysfs_path = ''
 
     @property
     def slave(self):
diff --git a/blivet/devices/luks.py b/blivet/devices/luks.py
index 197926f..b91e8df 100644
--- a/blivet/devices/luks.py
+++ b/blivet/devices/luks.py
@@ -34,7 +34,7 @@ class LUKSDevice(DMCryptDevice):
     _packages = ["cryptsetup"]
 
     def __init__(self, name, fmt=None, size=None, uuid=None,
-                 exists=False, sysfsPath='', parents=None):
+                 exists=False, sysfs_path='', parents=None):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -46,13 +46,13 @@ def __init__(self, name, fmt=None, size=None, uuid=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword uuid: the device UUID
             :type uuid: str
         """
         DMCryptDevice.__init__(self, name, fmt=fmt, size=size,
-                               parents=parents, sysfsPath=sysfsPath,
+                               parents=parents, sysfs_path=sysfs_path,
                                uuid=None, exists=exists)
 
     @property
@@ -64,25 +64,25 @@ def size(self):
         if not self.exists:
             size = self.slave.size - crypto.LUKS_METADATA_SIZE
         else:
-            size = self.currentSize
+            size = self.current_size
         return size
 
-    def _postCreate(self):
-        self.name = self.slave.format.mapName
-        StorageDevice._postCreate(self)
+    def _post_create(self):
+        self.name = self.slave.format.map_name
+        StorageDevice._post_create(self)
 
-    def _postTeardown(self, recursive=False):
+    def _post_teardown(self, recursive=False):
         if not recursive:
-            # this is handled by StorageDevice._postTeardown if recursive
+            # this is handled by StorageDevice._post_teardown if recursive
             # is True
-            self.teardownParents(recursive=recursive)
+            self.teardown_parents(recursive=recursive)
 
-        StorageDevice._postTeardown(self, recursive=recursive)
+        StorageDevice._post_teardown(self, recursive=recursive)
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         return set(["rd.luks.uuid=luks-%s" % self.slave.format.uuid])
 
-    def populateKSData(self, data):
-        self.slave.populateKSData(data)
+    def populate_ksdata(self, data):
+        self.slave.populate_ksdata(data)
         data.encrypted = True
-        super(LUKSDevice, self).populateKSData(data)
+        super(LUKSDevice, self).populate_ksdata(data)
diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py
index 39d245c..3c21107 100644
--- a/blivet/devices/lvm.py
+++ b/blivet/devices/lvm.py
@@ -74,17 +74,17 @@ class LVMVolumeGroupDevice(ContainerDevice):
     """ An LVM Volume Group """
     _type = "lvmvg"
     _packages = ["lvm2"]
-    _formatClassName = property(lambda s: "lvmpv")
-    _formatUUIDAttr = property(lambda s: "vgUuid")
-    _formatImmutable = True
+    _format_class_name = property(lambda s: "lvmpv")
+    _format_uuid_attr = property(lambda s: "vg_uuid")
+    _format_immutable = True
 
     @staticmethod
     def get_supported_pe_sizes():
         return [Size(pe_size) for pe_size in blockdev.lvm.get_supported_pe_sizes()]
 
     def __init__(self, name, parents=None, size=None, free=None,
-                 peSize=None, peCount=None, peFree=None, pvCount=None,
-                 uuid=None, exists=False, sysfsPath=''):
+                 pe_size=None, pe_count=None, pe_free=None, pv_count=None,
+                 uuid=None, exists=False, sysfs_path=''):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -92,10 +92,10 @@ def __init__(self, name, parents=None, size=None, free=None,
             :type exists: bool
             :keyword parents: a list of parent devices
             :type parents: list of :class:`StorageDevice`
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
-            :keyword peSize: physical extent size
-            :type peSize: :class:`~.size.Size`
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
+            :keyword pe_size: physical extent size
+            :type pe_size: :class:`~.size.Size`
 
             For existing VG's only:
 
@@ -103,61 +103,61 @@ def __init__(self, name, parents=None, size=None, free=None,
             :type size: :class:`~.size.Size`
             :keyword free -- amount of free space in the VG
             :type free: :class:`~.size.Size`
-            :keyword peFree: number of free extents
-            :type peFree: int
-            :keyword peCount -- total number of extents
-            :type peCount: int
-            :keyword pvCount: number of PVs in this VG
-            :type pvCount: int
+            :keyword pe_free: number of free extents
+            :type pe_free: int
+            :keyword pe_count -- total number of extents
+            :type pe_count: int
+            :keyword pv_count: number of PVs in this VG
+            :type pv_count: int
             :keyword uuid: the VG UUID
             :type uuid: str
         """
-        # These attributes are used by _addParent, so they must be initialized
+        # These attributes are used by _add_parent, so they must be initialized
         # prior to instantiating the superclass.
         self._lvs = []
-        self.hasDuplicate = False
+        self.has_duplicate = False
         self._complete = False  # have we found all of this VG's PVs?
-        self.pvCount = util.numeric_type(pvCount)
-        if exists and not pvCount:
+        self.pv_count = util.numeric_type(pv_count)
+        if exists and not pv_count:
             self._complete = True
 
         super(LVMVolumeGroupDevice, self).__init__(name, parents=parents,
                                             uuid=uuid, size=size,
-                                            exists=exists, sysfsPath=sysfsPath)
+                                            exists=exists, sysfs_path=sysfs_path)
 
         self.free = util.numeric_type(free)
-        self.peSize = util.numeric_type(peSize)
-        self.peCount = util.numeric_type(peCount)
-        self.peFree = util.numeric_type(peFree)
-        self.reserved_percent = 0
-        self.reserved_space = Size(0)
+        self.pe_size = util.numeric_type(pe_size)
+        self.pe_count = util.numeric_type(pe_count)
+        self.pe_free = util.numeric_type(pe_free)
+        self._reserved_percent = 0
+        self._reserved_space = Size(0)
 
-        # TODO: validate peSize if given
-        if not self.peSize:
-            self.peSize = lvm.LVM_PE_SIZE
+        # TODO: validate pe_size if given
+        if not self.pe_size:
+            self.pe_size = lvm.LVM_PE_SIZE
 
         if not self.exists:
-            self.pvCount = len(self.parents)
+            self.pv_count = len(self.parents)
 
         # >0 is fixed
         self.size_policy = self.size
 
     def __repr__(self):
         s = super(LVMVolumeGroupDevice, self).__repr__()
-        s += ("  free = %(free)s  PE Size = %(peSize)s  PE Count = %(peCount)s\n"
-              "  PE Free = %(peFree)s  PV Count = %(pvCount)s\n"
+        s += ("  free = %(free)s  PE Size = %(pe_size)s  PE Count = %(pe_count)s\n"
+              "  PE Free = %(pe_free)s  PV Count = %(pv_count)s\n"
               "  modified = %(modified)s"
-              "  extents = %(extents)s  free space = %(freeSpace)s\n"
-              "  free extents = %(freeExtents)s"
+              "  extents = %(extents)s  free space = %(free_space)s\n"
+              "  free extents = %(free_extents)s"
               "  reserved percent = %(rpct)s  reserved space = %(res)s\n"
               "  PVs = %(pvs)s\n"
               "  LVs = %(lvs)s" %
-              {"free": self.free, "peSize": self.peSize, "peCount": self.peCount,
-               "peFree": self.peFree, "pvCount": self.pvCount,
-               "modified": self.isModified,
-               "extents": self.extents, "freeSpace": self.freeSpace,
-               "freeExtents": self.freeExtents,
-               "rpct": self.reserved_percent, "res": self.reserved_space,
+              {"free": self.free, "pe_size": self.pe_size, "pe_count": self.pe_count,
+               "pe_free": self.pe_free, "pv_count": self.pv_count,
+               "modified": self.is_modified,
+               "extents": self.extents, "free_space": self.free_space,
+               "free_extents": self.free_extents,
+               "rpct": self._reserved_percent, "res": self._reserved_space,
                "pvs": pprint.pformat([str(p) for p in self.pvs]),
                "lvs": pprint.pformat([str(l) for l in self.lvs])})
         return s
@@ -165,18 +165,18 @@ def __repr__(self):
     @property
     def dict(self):
         d = super(LVMVolumeGroupDevice, self).dict
-        d.update({"free": self.free, "peSize": self.peSize,
-                  "peCount": self.peCount, "peFree": self.peFree,
-                  "pvCount": self.pvCount, "extents": self.extents,
-                  "freeSpace": self.freeSpace,
-                  "freeExtents": self.freeExtents,
-                  "reserved_percent": self.reserved_percent,
-                  "reserved_space": self.reserved_space,
-                  "lvNames": [lv.name for lv in self.lvs]})
+        d.update({"free": self.free, "pe_size": self.pe_size,
+                  "pe_count": self.pe_count, "pe_free": self.pe_free,
+                  "pv_count": self.pv_count, "extents": self.extents,
+                  "free_space": self.free_space,
+                  "free_extents": self.free_extents,
+                  "reserved_percent": self._reserved_percent,
+                  "reserved_space": self._reserved_space,
+                  "lv_names": [lv.name for lv in self.lvs]})
         return d
 
     @property
-    def mapName(self):
+    def map_name(self):
         """ This device's device-mapper map name """
         # Thank you lvm for this lovely hack.
         return self.name.replace("-","--")
@@ -184,15 +184,15 @@ def mapName(self):
     @property
     def path(self):
         """ Device node representing this device. """
-        return "%s/%s" % (self._devDir, self.mapName)
+        return "%s/%s" % (self._dev_dir, self.map_name)
 
-    def updateSysfsPath(self):
+    def update_sysfs_path(self):
         """ Update this device's sysfs path. """
         log_method_call(self, self.name, status=self.status)
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        self.sysfsPath = ''
+        self.sysfs_path = ''
 
     @property
     def status(self):
@@ -216,10 +216,10 @@ def status(self):
 
         return True
 
-    def _preSetup(self, orig=False):
+    def _pre_setup(self, orig=False):
         if self.exists and not self.complete:
             raise errors.DeviceError("cannot activate VG with missing PV(s)", self.name)
-        return StorageDevice._preSetup(self, orig=orig)
+        return StorageDevice._pre_setup(self, orig=orig)
 
     def _teardown(self, recursive=None):
         """ Close, or tear down, a device. """
@@ -231,16 +231,16 @@ def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
         pv_list = [pv.path for pv in self.parents]
-        blockdev.lvm.vgcreate(self.name, pv_list, self.peSize)
+        blockdev.lvm.vgcreate(self.name, pv_list, self.pe_size)
 
-    def _postCreate(self):
+    def _post_create(self):
         self._complete = True
-        super(LVMVolumeGroupDevice, self)._postCreate()
+        super(LVMVolumeGroupDevice, self)._post_create()
 
-    def _preDestroy(self):
-        StorageDevice._preDestroy(self)
+    def _pre_destroy(self):
+        StorageDevice._pre_destroy(self)
         # set up the pvs since lvm needs access to them to do the vgremove
-        self.setupParents(orig=True)
+        self.setup_parents(orig=True)
 
     def _destroy(self):
         """ Destroy the device. """
@@ -275,7 +275,7 @@ def _remove(self, member):
     def _add(self, member):
         blockdev.lvm.vgextend(self.name, member.path)
 
-    def _addLogVol(self, lv):
+    def _add_log_vol(self, lv):
         """ Add an LV to this VG. """
         if lv in self._lvs:
             raise ValueError("lv is already part of this vg")
@@ -285,7 +285,7 @@ def _addLogVol(self, lv):
         # FIXME: add a "isthin" property and/or "ispool"?
         if not lv.exists and not self.growable and \
            not isinstance(lv, LVMThinLogicalVolumeDevice) and \
-           lv.size > self.freeSpace:
+           lv.size > self.free_space:
             raise errors.DeviceError("new lv is too large to fit in free space", self.name)
 
         log.debug("Adding %s/%s to %s", lv.name, lv.size, self.name)
@@ -296,7 +296,7 @@ def _addLogVol(self, lv):
         if origin:
             origin.snapshots.append(lv)
 
-    def _removeLogVol(self, lv):
+    def _remove_log_vol(self, lv):
         """ Remove an LV from this VG. """
         if lv not in self.lvs:
             raise ValueError("specified lv is not part of this vg")
@@ -308,27 +308,27 @@ def _removeLogVol(self, lv):
         if origin:
             origin.snapshots.remove(lv)
 
-    def _addParent(self, member):
-        super(LVMVolumeGroupDevice, self)._addParent(member)
+    def _add_parent(self, member):
+        super(LVMVolumeGroupDevice, self)._add_parent(member)
 
         if (self.exists and member.format.exists and
-            len(self.parents) + 1 == self.pvCount):
+            len(self.parents) + 1 == self.pv_count):
             self._complete = True
 
-    def _removeParent(self, member):
+    def _remove_parent(self, member):
         # XXX It would be nice to raise an exception if removing this member
         #     would not leave enough space, but the devicefactory relies on it
         #     being possible to _temporarily_ overcommit the VG.
         #
-        #     Maybe removeMember could be a wrapper with the checks and the
+        #     Maybe remove_member could be a wrapper with the checks and the
         #     devicefactory could call the _ versions to bypass the checks.
-        super(LVMVolumeGroupDevice, self)._removeParent(member)
+        super(LVMVolumeGroupDevice, self)._remove_parent(member)
 
     # We can't rely on lvm to tell us about our size, free space, &c
     # since we could have modifications queued, unless the VG and all of
     # its PVs already exist.
     @property
-    def isModified(self):
+    def is_modified(self):
         """ Return True if the VG has changes queued that LVM is unaware of. """
         modified = True
         if self.exists and not [d for d in self.pvs if not d.exists]:
@@ -337,55 +337,55 @@ def isModified(self):
         return modified
 
     @property
-    def reservedSpace(self):
+    def reserved_space(self):
         """ Reserved space in this VG """
         reserved = Size(0)
-        if self.reserved_percent > 0:
-            reserved = self.reserved_percent * Decimal('0.01') * self.size
-        elif self.reserved_space > Size(0):
-            reserved = self.reserved_space
+        if self._reserved_percent > 0:
+            reserved = self._reserved_percent * Decimal('0.01') * self.size
+        elif self._reserved_space > Size(0):
+            reserved = self._reserved_space
 
         # reserve space for the pmspare LV LVM creates behind our back
-        reserved += self.pmSpareSize
+        reserved += self.pmspare_size
 
         return self.align(reserved, roundup=True)
 
     @property
     def size(self):
         """ The size of this VG """
-        # TODO: just ask lvm if isModified returns False
+        # TODO: just ask lvm if is_modified returns False
 
         # sum up the sizes of the PVs, subtract the unusable (meta data) space
         # and align to pesize
         # NOTE: we either specify data alignment in a PV or the default is used
-        #       which is both handled by pv.format.peStart, but LVM takes into
+        #       which is both handled by pv.format.pe_start, but LVM takes into
         #       account also the underlying block device which means that e.g.
         #       for an MD RAID device, it tries to align everything also to chunk
         #       size and alignment offset of such device which may result in up
         #       to a twice as big non-data area
-        # TODO: move this to either LVMPhysicalVolume's peStart property once
+        # TODO: move this to either LVMPhysicalVolume's pe_start property once
         #       formats know about their devices or to a new LVMPhysicalVolumeDevice
         #       class once it exists
         avail = Size(0)
         for pv in self.pvs:
             if isinstance(pv, MDRaidArrayDevice):
-                avail += self.align(pv.size - 2 * pv.format.peStart)
+                avail += self.align(pv.size - 2 * pv.format.pe_start)
             else:
-                avail += self.align(pv.size - pv.format.peStart)
+                avail += self.align(pv.size - pv.format.pe_start)
 
         return avail
 
     @property
     def extents(self):
         """ Number of extents in this VG """
-        # TODO: just ask lvm if isModified returns False
+        # TODO: just ask lvm if is_modified returns False
 
-        return int(self.size / self.peSize)
+        return int(self.size / self.pe_size)
 
     @property
-    def freeSpace(self):
+    def free_space(self):
         """ The amount of free space in this VG. """
-        # TODO: just ask lvm if isModified returns False
+        # TODO: just ask lvm if is_modified returns False
 
         # get the number of disks used by PVs on RAID (if any)
         raid_disks = 0
@@ -395,22 +395,22 @@ def freeSpace(self):
 
         # total the sizes of any LVs
         log.debug("%s size is %s", self.name, self.size)
-        used = sum((lv.vgSpaceUsed for lv in self.lvs), Size(0))
-        used += self.reservedSpace
+        used = sum((lv.vg_space_used for lv in self.lvs), Size(0))
+        used += self.reserved_space
         free = self.size - used
         log.debug("vg %s has %s free", self.name, free)
         return free
 
     @property
-    def freeExtents(self):
+    def free_extents(self):
         """ The number of free extents in this VG. """
-        # TODO: just ask lvm if isModified returns False
-        return int(self.freeSpace / self.peSize)
+        # TODO: just ask lvm if is_modified returns False
+        return int(self.free_space / self.pe_size)
 
     def align(self, size, roundup=False):
         """ Align a size to a multiple of physical extent size. """
         size = util.numeric_type(size)
-        return size.roundToNearest(self.peSize, rounding=ROUND_UP if roundup else ROUND_DOWN)
+        return size.round_to_nearest(self.pe_size, rounding=ROUND_UP if roundup else ROUND_DOWN)
 
     @property
     def pvs(self):
@@ -431,18 +431,18 @@ def thinlvs(self):
         return [l for l in self._lvs if isinstance(l, LVMThinLogicalVolumeDevice)]
 
     @property
-    def cachedLVs(self):
+    def cached_lvs(self):
         return [l for l in self._lvs if l.cached]
 
     @property
-    def pmSpareSize(self):
+    def pmspare_size(self):
         """Size of the pmspare LV LVM creates in every VG that contains some metadata
         (even internal) LV. The size of such LV is equal to the size of the
         biggest metadata LV in the VG.
 
         """
         # TODO: report correctly/better for existing VGs
-        return max([lv.metaDataSize for lv in self.lvs] + [Size(0)])
+        return max([lv.metadata_size for lv in self.lvs] + [Size(0)])
 
     @property
     def complete(self):
@@ -450,7 +450,7 @@ def complete(self):
         Return True if complete.
         """
         # vgs with duplicate names are overcomplete, which is not what we want
-        if self.hasDuplicate:
+        if self.has_duplicate:
             return False
 
         return self._complete or not self.exists
@@ -460,18 +460,18 @@ def direct(self):
         """ Is this device directly accessible? """
         return False
 
-    def populateKSData(self, data):
-        super(LVMVolumeGroupDevice, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(LVMVolumeGroupDevice, self).populate_ksdata(data)
         data.vgname = self.name
         data.physvols = ["pv.%d" % p.id for p in self.parents]
         data.preexist = self.exists
         if not self.exists:
-            data.pesize = self.peSize.convertTo(KiB)
+            data.pesize = self.pe_size.convert_to(KiB)
 
         # reserved percent/space
 
     @classmethod
-    def isNameValid(cls, name):
+    def is_name_valid(cls, name):
         # No . or ..
         if name == '.' or name == '..':
             return False
@@ -495,12 +495,12 @@ class LVMLogicalVolumeDevice(DMDevice):
     _type = "lvmlv"
     _resizable = True
     _packages = ["lvm2"]
-    _containerClass = LVMVolumeGroupDevice
+    _container_class = LVMVolumeGroupDevice
     _external_dependencies = [availability.BLOCKDEV_LVM_PLUGIN]
 
-    def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
-                 fmt=None, exists=False, sysfsPath='', grow=None, maxsize=None,
-                 percent=None, cacheRequest=None):
+    def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None,
+                 fmt=None, exists=False, sysfs_path='', grow=None, maxsize=None,
+                 percent=None, cache_request=None):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -512,15 +512,15 @@ def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword uuid: the device UUID
             :type uuid: str
 
             For existing LVs only:
 
-            :keyword segType: segment type (eg: "linear", "raid1")
-            :type segType: str
+            :keyword seg_type: segment type (eg: "linear", "raid1")
+            :type seg_type: str
 
             For non-existent LVs only:
 
@@ -530,8 +530,8 @@ def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
             :type maxsize: :class:`~.size.Size`
             :keyword percent: percent of VG space to take
             :type percent: int
-            :keyword cacheRequest: parameters of requested cache (if any)
-            :type cacheRequest: :class:`~.devices.lvm.LVMCacheRequest`
+            :keyword cache_request: parameters of requested cache (if any)
+            :type cache_request: :class:`~.devices.lvm.LVMCacheRequest`
 
         """
 
@@ -539,11 +539,11 @@ def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
         # try to access self.snapshots.
         self.snapshots = []
         DMDevice.__init__(self, name, size=size, fmt=fmt,
-                          sysfsPath=sysfsPath, parents=parents,
+                          sysfs_path=sysfs_path, parents=parents,
                           exists=exists)
 
         self.uuid = uuid
-        self.segType = segType or "linear"
+        self.seg_type = seg_type or "linear"
 
         self.req_grow = None
         self.req_max_size = Size(0)
@@ -561,33 +561,33 @@ def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
         self._check_parents()
         self._add_to_parents()
 
-        self._metaDataSize = Size(0)
+        self._metadata_size = Size(0)
         self._internal_lvs = []
         self._cache = None
 
-        if cacheRequest and not self.exists:
-            self._cache = LVMCache(self, size=cacheRequest.size, exists=False,
-                                   fast_pvs=cacheRequest.fast_devs, mode=cacheRequest.mode)
+        if cache_request and not self.exists:
+            self._cache = LVMCache(self, size=cache_request.size, exists=False,
+                                   fast_pvs=cache_request.fast_devs, mode=cache_request.mode)
 
     def _check_parents(self):
         """Check that this device has parents as expected"""
 
         if isinstance(self.parents, (list, ParentList)):
             if len(self.parents) != 1:
-                raise ValueError("constructor requires a single %s instance" % self._containerClass.__name__)
+                raise ValueError("constructor requires a single %s instance" % self._container_class.__name__)
 
             container = self.parents[0]
         else:
             container = self.parents
 
-        if not isinstance(container, self._containerClass):
-            raise ValueError("constructor requires a %s instance" % self._containerClass.__name__)
+        if not isinstance(container, self._container_class):
+            raise ValueError("constructor requires a %s instance" % self._container_class.__name__)
 
     def _add_to_parents(self):
         """Add this device to its parents"""
 
         # a normal LV has only exactly parent -- the VG it belongs to
-        self._parents[0]._addLogVol(self)
+        self._parents[0]._add_log_vol(self)
 
     @property
     def copies(self):
@@ -595,14 +595,14 @@ def copies(self):
         return len(image_lvs) or 1
 
     @property
-    def logSize(self):
+    def log_size(self):
         log_lvs = (int_lv for int_lv in self._internal_lvs if isinstance(int_lv, LVMLogLogicalVolumeDevice))
         return Size(sum(lv.size for lv in log_lvs))
 
     @property
-    def metaDataSize(self):
-        if self._metaDataSize:
-            return self._metaDataSize
+    def metadata_size(self):
+        if self._metadata_size:
+            return self._metadata_size
         elif self.cached:
             return self.cache.md_size
 
@@ -616,8 +616,8 @@ def __repr__(self):
               "  mirror copies = %(copies)d"
               "  VG space used = %(vgspace)s" %
               {"vgdev": self.vg, "percent": self.req_percent,
-               "copies": self.copies, "type": self.segType,
-               "vgspace": self.vgSpaceUsed })
+               "copies": self.copies, "type": self.seg_type,
+               "vgspace": self.vg_space_used })
         return s
 
     @property
@@ -625,7 +625,7 @@ def dict(self):
         d = super(LVMLogicalVolumeDevice, self).dict
         if self.exists:
             d.update({"copies": self.copies,
-                      "vgspace": self.vgSpaceUsed})
+                      "vgspace": self.vg_space_used})
         else:
             d.update({"percent": self.req_percent})
 
@@ -635,7 +635,7 @@ def dict(self):
     def mirrored(self):
         return self.copies > 1
 
-    def _setSize(self, size):
+    def _set_size(self, size):
         if not isinstance(size, Size):
             raise ValueError("new size must of type Size")
 
@@ -646,35 +646,35 @@ def _setSize(self, size):
         # space for it. A similar reasoning applies to shrinking the LV.
         if not self.exists and \
            not isinstance(self, LVMThinLogicalVolumeDevice) and \
-           size > self.size and size > self.vg.freeSpace + self.vgSpaceUsed:
-            log.error("failed to set size: %s short", size - (self.vg.freeSpace + self.vgSpaceUsed))
+           size > self.size and size > self.vg.free_space + self.vg_space_used:
+            log.error("failed to set size: %s short", size - (self.vg.free_space + self.vg_space_used))
             raise ValueError("not enough free space in volume group")
 
-        super(LVMLogicalVolumeDevice, self)._setSize(size)
+        super(LVMLogicalVolumeDevice, self)._set_size(size)
 
-    size = property(StorageDevice._getSize, _setSize)
+    size = property(StorageDevice._get_size, _set_size)
 
     @property
-    def maxSize(self):
+    def max_size(self):
         """ The maximum size this lv can be. """
-        max_lv = self.size + self.vg.freeSpace
-        max_format = self.format.maxSize
+        max_lv = self.size + self.vg.free_space
+        max_format = self.format.max_size
         return min(max_lv, max_format) if max_format else max_lv
 
     @property
-    def vgSpaceUsed(self):
+    def vg_space_used(self):
         """ Space occupied by this LV, not including snapshots. """
         if self.cached:
             cache_size = self.cache.size
         else:
             cache_size = Size(0)
         return (self.vg.align(self.size, roundup=True) * self.copies
-                + self.logSize + self.metaDataSize + cache_size)
+                + self.log_size + self.metadata_size + cache_size)
 
-    def _setFormat(self, fmt):
-        super(LVMLogicalVolumeDevice, self)._setFormat(fmt)
+    def _set_format(self, fmt):
+        super(LVMLogicalVolumeDevice, self)._set_format(fmt)
         for snapshot in (s for s in self.snapshots if not s.exists):
-            snapshot._updateFormatFromOrigin()
+            snapshot._update_format_from_origin()
 
     @property
     def vg(self):
@@ -686,25 +686,25 @@ def container(self):
         return self.vg
 
     @property
-    def mapName(self):
+    def map_name(self):
         """ This device's device-mapper map name """
         # Thank you lvm for this lovely hack.
-        return "%s-%s" % (self.vg.mapName, self._name.replace("-","--"))
+        return "%s-%s" % (self.vg.map_name, self._name.replace("-","--"))
 
     @property
     def path(self):
         """ Device node representing this device. """
-        return "%s/%s" % (self._devDir, self.mapName)
+        return "%s/%s" % (self._dev_dir, self.map_name)
 
-    def getDMNode(self):
+    def get_dm_node(self):
         """ Return the dm-X (eg: dm-0) device node for this device. """
         log_method_call(self, self.name, status=self.status)
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        return blockdev.dm.node_from_name(self.mapName)
+        return blockdev.dm.node_from_name(self.map_name)
 
-    def _getName(self):
+    def _get_name(self):
         """ This device's name. """
         return "%s-%s" % (self.vg.name, self._name)
 
@@ -718,17 +718,17 @@ def complete(self):
         """ Test if vg exits and if it has all pvs. """
         return self.vg.complete
 
-    def setupParents(self, orig=False):
+    def setup_parents(self, orig=False):
         # parent is a vg, which has no formatting (or device for that matter)
-        Device.setupParents(self, orig=orig)
+        Device.setup_parents(self, orig=orig)
 
-    def _preSetup(self, orig=False):
+    def _pre_setup(self, orig=False):
         # If the lvmetad socket exists and any PV is inactive before we call
-        # setupParents (via _preSetup, below), we should wait for auto-
+        # setup_parents (via _pre_setup, below), we should wait for auto-
         # activation before trying to manually activate this LV.
         auto_activate = (lvm.lvmetad_socket_exists() and
                          any(not pv.status for pv in self.vg.pvs))
-        if not super(LVMLogicalVolumeDevice, self)._preSetup(orig=orig):
+        if not super(LVMLogicalVolumeDevice, self)._pre_setup(orig=orig):
             return False
 
         if auto_activate:
@@ -766,20 +766,20 @@ def _teardown(self, recursive=None):
                         controllable=self.controllable)
         blockdev.lvm.lvdeactivate(self.vg.name, self._name)
 
-    def _postTeardown(self, recursive=False):
+    def _post_teardown(self, recursive=False):
         try:
             # It's likely that teardown of a VG will fail due to other
             # LVs being active (filesystems mounted, &c), so don't let
             # it bring everything down.
-            StorageDevice._postTeardown(self, recursive=recursive)
+            StorageDevice._post_teardown(self, recursive=recursive)
         except errors.StorageError:
             if recursive:
                 log.debug("vg %s teardown failed; continuing", self.vg.name)
             else:
                 raise
 
-    def _preCreate(self):
-        super(LVMLogicalVolumeDevice, self)._preCreate()
+    def _pre_create(self):
+        super(LVMLogicalVolumeDevice, self)._pre_create()
 
         try:
             vg_info = blockdev.lvm.vginfo(self.vg.name)
@@ -831,10 +831,10 @@ def _create(self):
             blockdev.lvm.cache_create_cached_lv(self.vg.name, self._name, self.size, self.cache.size, self.cache.md_size,
                                                 mode, 0, slow_pvs+fast_pvs, fast_pvs)
 
-    def _preDestroy(self):
-        StorageDevice._preDestroy(self)
+    def _pre_destroy(self):
+        StorageDevice._pre_destroy(self)
         # set up the vg's pvs so lvm can remove the lv
-        self.vg.setupParents(orig=True)
+        self.vg.setup_parents(orig=True)
 
     def _destroy(self):
         """ Destroy the device. """
@@ -845,10 +845,10 @@ def resize(self):
         log_method_call(self, self.name, status=self.status)
 
         # Setup VG parents (in case they are dmraid partitions for example)
-        self.vg.setupParents(orig=True)
+        self.vg.setup_parents(orig=True)
 
-        if self.originalFormat.exists:
-            self.originalFormat.teardown()
+        if self.original_format.exists:
+            self.original_format.teardown()
         if self.format.exists:
             self.format.teardown()
 
@@ -871,12 +871,12 @@ def direct(self):
         # its only dependent devices are snapshots
         return super(LVMLogicalVolumeDevice, self).isleaf
 
-    def dracutSetupArgs(self):
-        # Note no mapName usage here, this is a lvm cmdline name, which
+    def dracut_setup_args(self):
+        # Note no map_name usage here, this is a lvm cmdline name, which
         # is different (ofcourse)
         return set(["rd.lvm.lv=%s/%s" % (self.vg.name, self._name)])
 
-    def checkSize(self):
+    def check_size(self):
         """ Check to make sure the size of the device is allowed by the
             format used.
 
@@ -885,55 +885,55 @@ def checkSize(self):
             1  - Too large
             -1 - Too small
         """
-        if self.format.maxSize and self.size > self.format.maxSize:
+        if self.format.max_size and self.size > self.format.max_size:
             return 1
-        elif (self.format.minSize and
+        elif (self.format.min_size and
               (not self.req_grow and
-               self.size < self.format.minSize) or
+               self.size < self.format.min_size) or
               (self.req_grow and self.req_max_size and
-               self.req_max_size < self.format.minSize)):
+               self.req_max_size < self.format.min_size)):
             return -1
         return 0
 
-    def removeHook(self, modparent=True):
+    def remove_hook(self, modparent=True):
         if modparent:
-            self.vg._removeLogVol(self)
+            self.vg._remove_log_vol(self)
 
-        super(LVMLogicalVolumeDevice, self).removeHook(modparent=modparent)
+        super(LVMLogicalVolumeDevice, self).remove_hook(modparent=modparent)
 
-    def addHook(self, new=True):
-        super(LVMLogicalVolumeDevice, self).addHook(new=new)
+    def add_hook(self, new=True):
+        super(LVMLogicalVolumeDevice, self).add_hook(new=new)
         if new:
             return
 
         if self not in self.vg.lvs:
-            self.vg._addLogVol(self)
+            self.vg._add_log_vol(self)
 
-    def populateKSData(self, data):
-        super(LVMLogicalVolumeDevice, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(LVMLogicalVolumeDevice, self).populate_ksdata(data)
         data.vgname = self.vg.name
         data.name = self.lvname
         data.preexist = self.exists
-        data.resize = (self.exists and self.targetSize and
-                       self.targetSize != self.currentSize)
+        data.resize = (self.exists and self.target_size and
+                       self.target_size != self.current_size)
         if not self.exists:
             data.grow = self.req_grow
             if self.req_grow:
-                data.size = self.req_size.convertTo(MiB)
-                data.maxSizeMB = self.req_max_size.convertTo(MiB)
+                data.size = self.req_size.convert_to(MiB)
+                data.max_size_mb = self.req_max_size.convert_to(MiB)
             else:
-                data.size = self.size.convertTo(MiB)
+                data.size = self.size.convert_to(MiB)
 
             data.percent = self.req_percent
         elif data.resize:
-            data.size = self.targetSize.convertTo(MiB)
+            data.size = self.target_size.convert_to(MiB)
 
     @classmethod
-    def isNameValid(cls, name):
+    def is_name_valid(cls, name):
         # Check that the LV name is valid
 
         # Start with the checks shared with volume groups
-        if not LVMVolumeGroupDevice.isNameValid(name):
+        if not LVMVolumeGroupDevice.is_name_valid(name):
             return False
 
         # And now the ridiculous ones
@@ -952,11 +952,11 @@ def isNameValid(cls, name):
 
         return True
 
-    def addInternalLV(self, int_lv):
+    def add_internal_lv(self, int_lv):
         if int_lv not in self._internal_lvs:
             self._internal_lvs.append(int_lv)
 
-    def removeInternalLV(self, int_lv):
+    def remove_internal_lv(self, int_lv):
         if int_lv in self._internal_lvs:
             self._internal_lvs.remove(int_lv)
         else:
@@ -1012,13 +1012,13 @@ class LVMInternalLogicalVolumeDevice(LVMLogicalVolumeDevice):
     takes_extra_space = abc.abstractproperty(doc="whether LVs of this type take space in a VG or are part of their parent LVs")
 
     @classmethod
-    def isNameValid(cls, name):
+    def is_name_valid(cls, name):
         # override checks for normal LVs, internal LVs typically have names that
         # are forbidden for normal LVs
         return True
 
     def __init__(self, name, vg, parent_lv=None, size=None, uuid=None,
-                 exists=False, segType=None, sysfsPath=''):
+                 exists=False, seg_type=None, sysfs_path=''):
         """
         :param vg: the VG this internal LV belongs to
         :type vg: :class:`LVMVolumeGroupDevice`
@@ -1039,11 +1039,11 @@ 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, segType=segType, fmt=None, exists=exists,
-              sysfsPath=sysfsPath, 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.addInternalLV(self)
+            self._parent_lv.add_internal_lv(self)
 
     def _check_parents(self):
         # an internal LV should have no parents
@@ -1071,13 +1071,13 @@ def parent_lv(self):
     @parent_lv.setter
     def parent_lv(self, parent_lv):
         if self._parent_lv:
-            self._parent_lv.removeInternalLV(self)
+            self._parent_lv.remove_internal_lv(self)
         self._parent_lv = parent_lv
         if self._parent_lv:
-            self._parent_lv.addInternalLV(self)
+            self._parent_lv.add_internal_lv(self)
 
     # internal LVs follow different rules limitting size
-    def _setSize(self, size):
+    def _set_size(self, size):
         if not isinstance(size, Size):
             raise ValueError("new size must of type Size")
 
@@ -1088,15 +1088,15 @@ def _setSize(self, size):
                 raise ValueError("Internal LV cannot be bigger than its parent LV")
         else:
             # same rules apply as for any other LV
-            super(LVMInternalLogicalVolumeDevice, self)._setSize(size)
+            super(LVMInternalLogicalVolumeDevice, self)._set_size(size)
 
     @property
-    def maxSize(self):
+    def max_size(self):
         # no format, so maximum size is only limitted by either the parent LV or the VG
         if not self.takes_extra_space:
-            return self._parent_lv.maxSize()
+            return self._parent_lv.max_size
         else:
-            return self.size + self.vg.freeSpace
+            return self.size + self.vg.free_space
 
     def __repr__(self):
         s = "%s:\n" % self.__class__.__name__
@@ -1108,8 +1108,8 @@ def __repr__(self):
               "  mirror copies = %(copies)d"
               "  VG space used = %(vgspace)s" %
               {"vgdev": self.vg, "percent": self.req_percent,
-               "copies": self.copies, "type": self.segType,
-               "vgspace": self.vgSpaceUsed })
+               "copies": self.copies, "type": self.seg_type,
+               "vgspace": self.vg_space_used })
         return s
 
     # generally changes should be done on the parent LV (exceptions should
@@ -1138,21 +1138,21 @@ def display_lvname(self):
     # these two methods are not needed right now, because they are only called
     # when devices are added/removed to/from the DeviceTree, but they may come
     # handy in the future
-    def addHook(self, new=True):
+    def add_hook(self, new=True):
         # skip LVMLogicalVolumeDevice in the class hierarchy -- we don't want to
         # add an internal LV to the VG (it's only referenced by the parent LV)
         # pylint: disable=bad-super-call
-        super(LVMLogicalVolumeDevice, self).addHook(new=new)
-        self._parent_lv.addInternalLV(self)
+        super(LVMLogicalVolumeDevice, self).add_hook(new=new)
+        self._parent_lv.add_internal_lv(self)
 
-    def removeHook(self, modparent=True):
+    def remove_hook(self, modparent=True):
         if modparent:
-            self._parent_lv.removeInternalLV(self)
+            self._parent_lv.remove_internal_lv(self)
 
         # skip LVMLogicalVolumeDevice in the class hierarchy -- we cannot remove
         # an internal LV from the VG (it's only referenced by the parent LV)
         # pylint: disable=bad-super-call
-        super(LVMLogicalVolumeDevice, self).removeHook(modparent=modparent)
+        super(LVMLogicalVolumeDevice, self).remove_hook(modparent=modparent)
 
     @property
     def direct(self):
@@ -1263,10 +1263,10 @@ def __init__(self, origin=None, vorigin=False, exists=False):
             using space in the vg directly. Only preexisting vorigin snapshots
             are supported here.
         """
-        self._originSpecifiedCheck(origin, vorigin, exists)
-        self._originTypeCheck(origin)
-        self._originExistenceCheck(origin)
-        self._voriginExistenceCheck(vorigin, exists)
+        self._origin_specified_check(origin, vorigin, exists)
+        self._origin_type_check(origin)
+        self._origin_existence_check(origin)
+        self._vorigin_existence_check(vorigin, exists)
 
         self.origin = origin
         """ the snapshot's source volume """
@@ -1274,24 +1274,24 @@ def __init__(self, origin=None, vorigin=False, exists=False):
         self.vorigin = vorigin
         """ a boolean flag indicating a vorigin snapshot """
 
-    def _originSpecifiedCheck(self, origin, vorigin, exists):
+    def _origin_specified_check(self, origin, vorigin, exists):
         # pylint: disable=unused-argument
         if not origin and not vorigin:
             raise ValueError("lvm snapshot devices require an origin lv")
 
-    def _originTypeCheck(self, origin):
+    def _origin_type_check(self, origin):
         if origin and not isinstance(origin, LVMLogicalVolumeDevice):
             raise ValueError("lvm snapshot origin must be a logical volume")
 
-    def _originExistenceCheck(self, origin):
+    def _origin_existence_check(self, origin):
         if origin and not origin.exists:
             raise ValueError("lvm snapshot origin volume must already exist")
 
-    def _voriginExistenceCheck(self, vorigin, exists):
+    def _vorigin_existence_check(self, vorigin, exists):
         if vorigin and not exists:
             raise ValueError("only existing vorigin snapshots are supported")
 
-    def _updateFormatFromOrigin(self):
+    def _update_format_from_origin(self):
         """ Update the snapshot's format to reflect the origin's.
 
             .. note::
@@ -1304,20 +1304,20 @@ def _updateFormatFromOrigin(self):
         fmt.exists = False
         if hasattr(fmt, "mountpoint"):
             fmt.mountpoint = ""
-            fmt._chrootedMountpoint = None
+            fmt._chrooted_mountpoint = None
             fmt.device = self.path # pylint: disable=no-member
 
-        super(LVMSnapShotBase, self)._setFormat(fmt)
+        super(LVMSnapShotBase, self)._set_format(fmt)
 
-    def _setFormat(self, fmt):
+    def _set_format(self, fmt):
         # If a snapshot exists it can have a format that is distinct from its
         # origin's. If it does not exist its format must be a copy of its
         # origin's.
         if self.exists: # pylint: disable=no-member
-            super(LVMSnapShotBase, self)._setFormat(fmt)
+            super(LVMSnapShotBase, self)._set_format(fmt)
         else:
             log.info("copying %s origin's format", self.name) # pylint: disable=no-member
-            self._updateFormatFromOrigin()
+            self._update_format_from_origin()
 
     @abc.abstractmethod
     def _create(self):
@@ -1347,10 +1347,10 @@ def merge(self):
 class LVMSnapShotDevice(LVMSnapShotBase, LVMLogicalVolumeDevice):
     """ An LVM snapshot """
     _type = "lvmsnapshot"
-    _formatImmutable = True
+    _format_immutable = True
 
-    def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
-                 fmt=None, exists=False, sysfsPath='', grow=None, maxsize=None,
+    def __init__(self, name, parents=None, size=None, uuid=None, seg_type=None,
+                 fmt=None, exists=False, sysfs_path='', grow=None, maxsize=None,
                  percent=None, origin=None, vorigin=False):
         """ Create an LVMSnapShotDevice instance.
 
@@ -1365,9 +1365,9 @@ def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
             :keyword :class:`~.ParentList` parents: list of parent devices
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat`
-            :keyword str sysfsPath: sysfs device path
+            :keyword str sysfs_path: sysfs device path
             :keyword str uuid: the device UUID
-            :keyword str segType: segment type
+            :keyword str seg_type: segment type
 
             :keyword :class:`~.StorageDevice` origin: the origin/source volume
             :keyword bool vorigin: is this a vorigin snapshot?
@@ -1390,8 +1390,8 @@ def __init__(self, name, parents=None, size=None, uuid=None, segType=None,
 
         LVMLogicalVolumeDevice.__init__(self, name, parents=parents, size=size,
                                         uuid=uuid, fmt=None, exists=exists,
-                                        segType=segType,
-                                        sysfsPath=sysfsPath, grow=grow,
+                                        seg_type=seg_type,
+                                        sysfs_path=sysfs_path, grow=grow,
                                         maxsize=maxsize, percent=percent)
 
     def setup(self, orig=False):
@@ -1413,23 +1413,23 @@ def _destroy(self):
         # that it is okay to remove the active snapshot
         blockdev.lvm.lvremove(self.vg.name, self._name, force=True)
 
-    def _getPartedDevicePath(self):
+    def _get_parted_device_path(self):
         return "%s-cow" % self.path
 
-    def dependsOn(self, dep):
+    def depends_on(self, dep):
         # pylint: disable=bad-super-call
         return (self.origin == dep or
-                super(LVMSnapShotBase, self).dependsOn(dep))
+                super(LVMSnapShotBase, self).depends_on(dep))
 
-    def readCurrentSize(self):
+    def read_current_size(self):
         log_method_call(self, exists=self.exists, path=self.path,
-                        sysfsPath=self.sysfsPath)
+                        sysfs_path=self.sysfs_path)
         size = Size(0)
-        if self.exists and os.path.isdir(self.sysfsPath):
-            cowSysfsPath = util.get_cow_sysfs_path(self.path, self.sysfsPath)
+        if self.exists and os.path.isdir(self.sysfs_path):
+            cow_sysfs_path = util.get_cow_sysfs_path(self.path, self.sysfs_path)
 
-            if os.path.exists(cowSysfsPath) and os.path.isdir(cowSysfsPath):
-                blocks = int(util.get_sysfs_attr(cowSysfsPath, "size"))
+            if os.path.exists(cow_sysfs_path) and os.path.isdir(cow_sysfs_path):
+                blocks = int(util.get_sysfs_attr(cow_sysfs_path, "size"))
                 size = Size(blocks * LINUX_SECTOR_SIZE)
 
         return size
@@ -1440,9 +1440,9 @@ class LVMThinPoolDevice(LVMLogicalVolumeDevice):
     _resizable = False
 
     def __init__(self, name, parents=None, size=None, uuid=None,
-                 fmt=None, exists=False, sysfsPath='',
+                 fmt=None, exists=False, sysfs_path='',
                  grow=None, maxsize=None, percent=None,
-                 metadatasize=None, chunksize=None, segType=None, profile=None):
+                 metadatasize=None, chunksize=None, seg_type=None, profile=None):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -1454,12 +1454,12 @@ def __init__(self, name, parents=None, size=None, uuid=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword uuid: the device UUID
             :type uuid: str
-            :keyword segType: segment type
-            :type segType: str
+            :keyword seg_type: segment type
+            :type seg_type: str
 
             For non-existent pools only:
 
@@ -1488,33 +1488,33 @@ def __init__(self, name, parents=None, size=None, uuid=None,
         super(LVMThinPoolDevice, self).__init__(name, parents=parents,
                                                 size=size, uuid=uuid,
                                                 fmt=fmt, exists=exists,
-                                                sysfsPath=sysfsPath, grow=grow,
+                                                sysfs_path=sysfs_path, grow=grow,
                                                 maxsize=maxsize,
                                                 percent=percent,
-                                                segType=segType)
+                                                seg_type=seg_type)
 
-        self._metaDataSize = metadatasize or Size(0)
-        self.chunkSize = chunksize or Size(0)
+        self._metadata_size = metadatasize or Size(0)
+        self.chunk_size = chunksize or Size(0)
         self.profile = profile
         self._lvs = []
 
-    def _addLogVol(self, lv):
+    def _add_log_vol(self, lv):
         """ Add an LV to this pool. """
         if lv in self._lvs:
             raise ValueError("lv is already part of this vg")
 
         # TODO: add some checking to prevent overcommit for preexisting
-        self.vg._addLogVol(lv)
+        self.vg._add_log_vol(lv)
         log.debug("Adding %s/%s to %s", lv.name, lv.size, self.name)
         self._lvs.append(lv)
 
-    def _removeLogVol(self, lv):
+    def _remove_log_vol(self, lv):
         """ Remove an LV from this pool. """
         if lv not in self._lvs:
             raise ValueError("specified lv is not part of this vg")
 
         self._lvs.remove(lv)
-        self.vg._removeLogVol(lv)
+        self.vg._remove_log_vol(lv)
 
     @property
     def lvs(self):
@@ -1522,18 +1522,18 @@ def lvs(self):
         return self._lvs[:]     # we don't want folks changing our list
 
     @property
-    def vgSpaceUsed(self):
-        space = super(LVMThinPoolDevice, self).vgSpaceUsed
-        space += Size(blockdev.lvm.get_thpool_padding(space, self.vg.peSize))
+    def vg_space_used(self):
+        space = super(LVMThinPoolDevice, self).vg_space_used
+        space += Size(blockdev.lvm.get_thpool_padding(space, self.vg.pe_size))
         return space
 
     @property
-    def usedSpace(self):
-        return sum((l.poolSpaceUsed for l in self.lvs), Size(0))
+    def used_space(self):
+        return sum((l.pool_space_used for l in self.lvs), Size(0))
 
     @property
-    def freeSpace(self):
-        return self.size - self.usedSpace
+    def free_space(self):
+        return self.size - self.used_space
 
     def _create(self):
         """ Create the device. """
@@ -1544,11 +1544,11 @@ def _create(self):
             profile_name = None
         # TODO: chunk size, data/metadata split --> profile
         blockdev.lvm.thpoolcreate(self.vg.name, self.lvname, self.size,
-                                  md_size=self.metaDataSize,
-                                  chunk_size=self.chunkSize,
+                                  md_size=self.metadata_size,
+                                  chunk_size=self.chunk_size,
                                   profile=profile_name)
 
-    def dracutSetupArgs(self):
+    def dracut_setup_args(self):
         return set()
 
     @property
@@ -1556,19 +1556,19 @@ def direct(self):
         """ Is this device directly accessible? """
         return False
 
-    def populateKSData(self, data):
-        super(LVMThinPoolDevice, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(LVMThinPoolDevice, self).populate_ksdata(data)
         data.mountpoint = "none"
         data.thin_pool = True
-        data.metadata_size = self.metaDataSize.convertTo(MiB)
-        data.chunk_size = self.chunkSize.convertTo(KiB)
+        data.metadata_size = self.metadata_size.convert_to(MiB)
+        data.chunk_size = self.chunk_size.convert_to(KiB)
         if self.profile:
             data.profile = self.profile.name
 
 class LVMThinLogicalVolumeDevice(LVMLogicalVolumeDevice):
     """ An LVM Thin Logical Volume """
     _type = "lvmthinlv"
-    _containerClass = LVMThinPoolDevice
+    _container_class = LVMThinPoolDevice
 
     @property
     def pool(self):
@@ -1579,7 +1579,7 @@ def vg(self):
         return self.pool.vg
 
     @property
-    def poolSpaceUsed(self):
+    def pool_space_used(self):
         """ The total space used within the thin pool by this volume.
 
             This should probably align to the greater of vg extent size and
@@ -1589,24 +1589,24 @@ def poolSpaceUsed(self):
         return self.vg.align(self.size, roundup=True)
 
     @property
-    def vgSpaceUsed(self):
+    def vg_space_used(self):
         return Size(0)    # the pool's size is already accounted for in the vg
 
-    def _setSize(self, size):
+    def _set_size(self, size):
         if not isinstance(size, Size):
             raise ValueError("new size must of type Size")
 
         size = self.vg.align(size)
         size = self.vg.align(util.numeric_type(size))
-        super(LVMThinLogicalVolumeDevice, self)._setSize(size)
+        super(LVMThinLogicalVolumeDevice, self)._set_size(size)
 
-    size = property(StorageDevice._getSize, _setSize)
+    size = property(StorageDevice._get_size, _set_size)
 
-    def _preCreate(self):
-        # skip LVMLogicalVolumeDevice's _preCreate() method as it checks for a
+    def _pre_create(self):
+        # skip LVMLogicalVolumeDevice's _pre_create() method as it checks for a
         # free space in a VG which doesn't make sense for a ThinLV and causes a
         # bug by limitting the ThinLV's size to VG free space which is nonsense
-        super(LVMLogicalVolumeDevice, self)._preCreate() # pylint: disable=bad-super-call
+        super(LVMLogicalVolumeDevice, self)._pre_create() # pylint: disable=bad-super-call
 
     def _create(self):
         """ Create the device. """
@@ -1614,24 +1614,24 @@ def _create(self):
         blockdev.lvm.thlvcreate(self.vg.name, self.pool.lvname, self.lvname,
                                 self.size)
 
-    def removeHook(self, modparent=True):
+    def remove_hook(self, modparent=True):
         if modparent:
-            self.pool._removeLogVol(self)
+            self.pool._remove_log_vol(self)
 
         # pylint: disable=bad-super-call
-        super(LVMLogicalVolumeDevice, self).removeHook(modparent=modparent)
+        super(LVMLogicalVolumeDevice, self).remove_hook(modparent=modparent)
 
-    def addHook(self, new=True):
+    def add_hook(self, new=True):
         # pylint: disable=bad-super-call
-        super(LVMLogicalVolumeDevice, self).addHook(new=new)
+        super(LVMLogicalVolumeDevice, self).add_hook(new=new)
         if new:
             return
 
         if self not in self.pool.lvs:
-            self.pool._addLogVol(self)
+            self.pool._add_log_vol(self)
 
-    def populateKSData(self, data):
-        super(LVMThinLogicalVolumeDevice, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(LVMThinLogicalVolumeDevice, self).populate_ksdata(data)
         data.thin_volume = True
         data.pool_name = self.pool.lvname
 
@@ -1639,17 +1639,17 @@ class LVMThinSnapShotDevice(LVMSnapShotBase, LVMThinLogicalVolumeDevice):
     """ An LVM Thin Snapshot """
     _type = "lvmthinsnapshot"
     _resizable = False
-    _formatImmutable = True
+    _format_immutable = True
 
-    def __init__(self, name, parents=None, sysfsPath='', origin=None,
-                 fmt=None, uuid=None, size=None, exists=False, segType=None):
+    def __init__(self, name, parents=None, sysfs_path='', origin=None,
+                 fmt=None, uuid=None, size=None, exists=False, seg_type=None):
         """
             :param str name: the name of the device
             :param :class:`~.ParentList` parents: parent devices
-            :param str sysfsPath: path to this device's /sys directory
+            :param str sysfs_path: path to this device's /sys directory
             :keyword origin: the origin(source) volume for the snapshot
             :type origin: :class:`~.LVMLogicalVolumeDevice` or None
-            :keyword str segType: segment type
+            :keyword str seg_type: segment type
             :keyword :class:`~.formats.DeviceFormat` fmt: this device's format
             :keyword str uuid: the device UUID
             :keyword :class:`~.size.Size` size: the device's size
@@ -1670,11 +1670,11 @@ def __init__(self, name, parents=None, sysfsPath='', origin=None,
 
         LVMSnapShotBase.__init__(self, origin=origin, exists=exists)
         LVMThinLogicalVolumeDevice.__init__(self, name, parents=parents,
-                                            sysfsPath=sysfsPath,fmt=fmt,
-                                            segType=segType,
+                                            sysfs_path=sysfs_path,fmt=fmt,
+                                            seg_type=seg_type,
                                             uuid=uuid, size=size, exists=exists)
 
-    def _originSpecifiedCheck(self, origin, vorigin, exists):
+    def _origin_specified_check(self, origin, vorigin, exists):
         if not exists and not origin:
             raise ValueError("non-existent lvm thin snapshots require an origin")
 
@@ -1696,15 +1696,15 @@ def _create(self):
         blockdev.lvm.thsnapshotcreate(self.vg.name, self.origin.lvname, self._name,
                                       pool_name=pool_name)
 
-    def _postCreate(self):
-        super(LVMThinSnapShotDevice, self)._postCreate()
+    def _post_create(self):
+        super(LVMThinSnapShotDevice, self)._post_create()
         # A snapshot's format exists as soon as the snapshot has been created.
         self.format.exists = True
 
-    def dependsOn(self, dep):
+    def depends_on(self, dep):
         # once a thin snapshot exists it no longer depends on its origin
         return ((self.origin == dep and not self.exists) or
-                super(LVMThinSnapShotDevice, self).dependsOn(dep))
+                super(LVMThinSnapShotDevice, self).depends_on(dep))
 
 class LVMCache(Cache):
     """Class providing the cache-related functionality of a cached LV"""
@@ -1763,7 +1763,7 @@ def md_size(self):
             return self._md_size
 
     @property
-    def vgSpaceUsed(self):
+    def vg_space_used(self):
         return self.size + self.md_size
 
     @property
diff --git a/blivet/devices/md.py b/blivet/devices/md.py
index 56ab1e6..fa13ba8 100644
--- a/blivet/devices/md.py
+++ b/blivet/devices/md.py
@@ -49,15 +49,15 @@ class MDRaidArrayDevice(ContainerDevice, RaidDevice):
     """ An mdraid (Linux RAID) device. """
     _type = "mdarray"
     _packages = ["mdadm"]
-    _devDir = "/dev/md"
-    _formatClassName = property(lambda s: "mdmember")
-    _formatUUIDAttr = property(lambda s: "mdUuid")
+    _dev_dir = "/dev/md"
+    _format_class_name = property(lambda s: "mdmember")
+    _format_uuid_attr = property(lambda s: "md_uuid")
     _external_dependencies = [availability.BLOCKDEV_MDRAID_PLUGIN]
 
     def __init__(self, name, level=None, major=None, minor=None, size=None,
-                 memberDevices=None, totalDevices=None,
-                 uuid=None, fmt=None, exists=False, metadataVersion=None,
-                 parents=None, sysfsPath=''):
+                 member_devices=None, total_devices=None,
+                 uuid=None, fmt=None, exists=False, metadata_version=None,
+                 parents=None, sysfs_path=''):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -69,17 +69,17 @@ def __init__(self, name, level=None, major=None, minor=None, size=None,
             :type parents: list of :class:`StorageDevice`
             :keyword fmt: this device's formatting
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword uuid: the device UUID
             :type uuid: str
 
             :keyword level: the device's RAID level
             :type level: any valid RAID level descriptor
-            :keyword int memberDevices: the number of active member devices
-            :keyword int totalDevices: the total number of member devices
-            :keyword metadataVersion: the version of the device's md metadata
-            :type metadataVersion: str (eg: "0.90")
+            :keyword int member_devices: the number of active member devices
+            :keyword int total_devices: the total number of member devices
+            :keyword metadata_version: the version of the device's md metadata
+            :type metadata_version: str (eg: "0.90")
             :keyword minor: the device minor (obsolete?)
             :type minor: int
 
@@ -98,10 +98,10 @@ def __init__(self, name, level=None, major=None, minor=None, size=None,
         """
         # pylint: disable=unused-argument
 
-        # These attributes are used by _addParent, so they must be initialized
+        # These attributes are used by _add_parent, so they must be initialized
         # prior to instantiating the superclass.
-        self._memberDevices = 0     # the number of active (non-spare) members
-        self._totalDevices = 0      # the total number of members
+        self._member_devices = 0     # the number of active (non-spare) members
+        self._total_devices = 0      # the total number of members
 
         # avoid attribute-defined-outside-init pylint warning
         self._level = None
@@ -109,7 +109,7 @@ def __init__(self, name, level=None, major=None, minor=None, size=None,
         super(MDRaidArrayDevice, self).__init__(name, uuid=uuid,
                                                 exists=exists, size=size,
                                                 parents=parents,
-                                                sysfsPath=sysfsPath)
+                                                sysfs_path=sysfs_path)
 
         try:
             self.level = level
@@ -117,33 +117,33 @@ def __init__(self, name, level=None, major=None, minor=None, size=None,
             # Could not set the level, so set loose the parents that were
             # added in superclass constructor.
             for dev in self.parents:
-                dev.removeChild()
+                dev.remove_child()
             raise e
 
         self.uuid = uuid
-        self._totalDevices = util.numeric_type(totalDevices)
-        self.memberDevices = util.numeric_type(memberDevices)
+        self._total_devices = util.numeric_type(total_devices)
+        self.member_devices = util.numeric_type(member_devices)
 
-        self.chunkSize = mdraid.MD_CHUNK_SIZE
+        self.chunk_size = mdraid.MD_CHUNK_SIZE
 
-        if not self.exists and not isinstance(metadataVersion, str):
-            self.metadataVersion = "default"
+        if not self.exists and not isinstance(metadata_version, str):
+            self.metadata_version = "default"
         else:
-            self.metadataVersion = metadataVersion
+            self.metadata_version = metadata_version
 
         self.format = fmt
 
         if self.parents and self.parents[0].type == "mdcontainer" and self.type != "mdbiosraidarray":
             raise errors.DeviceError("A device with mdcontainer member must be mdbiosraidarray.")
 
-        if self.exists and self.mdadmFormatUUID and not flags.testing:
+        if self.exists and self.mdadm_format_uuid and not flags.testing:
             # this is a hack to work around mdadm's insistence on giving
             # really high minors to arrays it has no config entry for
             with open("/etc/mdadm.conf", "a") as c:
-                c.write("ARRAY %s UUID=%s\n" % (self.path, self.mdadmFormatUUID))
+                c.write("ARRAY %s UUID=%s\n" % (self.path, self.mdadm_format_uuid))
 
     @property
-    def mdadmFormatUUID(self):
+    def mdadm_format_uuid(self):
         """ This array's UUID, formatted for external use.
 
             :returns: the array's UUID in mdadm format, if available
@@ -184,14 +184,14 @@ def level(self, value):
             :returns:     None
         """
         try:
-            level = self._getLevel(value, self._levels)
+            level = self._get_level(value, self._levels)
         except ValueError as e:
             raise errors.DeviceError(e)
 
         self._level = level
 
     @property
-    def createBitmap(self):
+    def create_bitmap(self):
         """ Whether or not a bitmap should be created on the array.
 
             If the the array is sufficiently small, a bitmap yields no benefit.
@@ -207,7 +207,7 @@ def createBitmap(self):
             # action.
             return False
 
-    def getSuperBlockSize(self, raw_array_size):
+    def get_superblock_size(self, raw_array_size):
         """Estimate the superblock size for a member of an array,
            given the total available memory for this array and raid level.
 
@@ -217,35 +217,35 @@ def getSuperBlockSize(self, raw_array_size):
            :rtype: :class:`~.size.Size`
         """
         return blockdev.md.get_superblock_size(raw_array_size,
-                                               version=self.metadataVersion)
+                                               version=self.metadata_version)
 
     @property
     def size(self):
         """Returns the actual or estimated size depending on whether or
            not the array exists.
         """
-        if not self.exists or not self.mediaPresent:
+        if not self.exists or not self.media_present:
             try:
                 size = self.level.get_size([d.size for d in self.members],
-                    self.memberDevices,
-                    self.chunkSize,
-                    self.getSuperBlockSize)
+                    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)
             log.debug("non-existent RAID %s size == %s", self.level, size)
         else:
-            size = self.currentSize
+            size = self.current_size
             log.debug("existing RAID %s size == %s", self.level, size)
 
         return size
 
-    def updateSize(self):
+    def update_size(self):
         # container size is determined by the member disks, so there is nothing
         # to update in that case
         if self.type != "mdcontainer":
             # pylint: disable=bad-super-call
-            super(ContainerDevice, self).updateSize()
+            super(ContainerDevice, self).update_size()
 
     @property
     def description(self):
@@ -255,87 +255,87 @@ def description(self):
     def __repr__(self):
         s = StorageDevice.__repr__(self)
         s += ("  level = %(level)s  spares = %(spares)s\n"
-              "  members = %(memberDevices)s\n"
-              "  total devices = %(totalDevices)s"
-              "  metadata version = %(metadataVersion)s" %
+              "  members = %(member_devices)s\n"
+              "  total devices = %(total_devices)s"
+              "  metadata version = %(metadata_version)s" %
               {"level": self.level, "spares": self.spares,
-               "memberDevices": self.memberDevices,
-               "totalDevices": self.totalDevices,
-               "metadataVersion": self.metadataVersion})
+               "member_devices": self.member_devices,
+               "total_devices": self.total_devices,
+               "metadata_version": self.metadata_version})
         return s
 
     @property
     def dict(self):
         d = super(MDRaidArrayDevice, self).dict
         d.update({"level": str(self.level),
-                  "spares": self.spares, "memberDevices": self.memberDevices,
-                  "totalDevices": self.totalDevices,
-                  "metadataVersion": self.metadataVersion})
+                  "spares": self.spares, "member_devices": self.member_devices,
+                  "total_devices": self.total_devices,
+                  "metadata_version": self.metadata_version})
         return d
 
     @property
-    def mdadmConfEntry(self):
+    def mdadm_conf_entry(self):
         """ This array's mdadm.conf entry. """
-        uuid = self.mdadmFormatUUID
-        if self.memberDevices is None or not uuid:
+        uuid = self.mdadm_format_uuid
+        if self.member_devices is None or not uuid:
             raise errors.DeviceError("array is not fully defined", self.name)
 
         fmt = "ARRAY %s level=%s num-devices=%d UUID=%s\n"
-        return fmt % (self.path, self.level, self.memberDevices, uuid)
+        return fmt % (self.path, self.level, self.member_devices, uuid)
 
     @property
-    def totalDevices(self):
+    def total_devices(self):
         """ Total number of devices in the array, including spares. """
         if not self.exists:
-            return self._totalDevices
+            return self._total_devices
         else:
             return len(self.parents)
 
-    def _getMemberDevices(self):
-        return self._memberDevices
+    def _get_member_devices(self):
+        return self._member_devices
 
-    def _setMemberDevices(self, number):
+    def _set_member_devices(self, number):
         if not isinstance(number, six.integer_types):
-            raise ValueError("memberDevices must be an integer")
+            raise ValueError("member_devices must be an integer")
 
-        if not self.exists and number > self.totalDevices:
-            raise ValueError("memberDevices cannot be greater than totalDevices")
-        self._memberDevices = number
+        if not self.exists and number > self.total_devices:
+            raise ValueError("member_devices cannot be greater than total_devices")
+        self._member_devices = number
 
-    memberDevices = property(lambda d: d._getMemberDevices(),
-                             lambda d, m: d._setMemberDevices(m),
+    member_devices = property(lambda d: d._get_member_devices(),
+                             lambda d, m: d._set_member_devices(m),
                              doc="number of member devices")
 
-    def _getSpares(self):
+    def _get_spares(self):
         spares = 0
-        if self.memberDevices is not None:
-            if self.totalDevices is not None and \
-               self.totalDevices > self.memberDevices:
-                spares = self.totalDevices - self.memberDevices
-            elif self.totalDevices is None:
-                spares = self.memberDevices
-                self._totalDevices = self.memberDevices
+        if self.member_devices is not None:
+            if self.total_devices is not None and \
+               self.total_devices > self.member_devices:
+                spares = self.total_devices - self.member_devices
+            elif self.total_devices is None:
+                spares = self.member_devices
+                self._total_devices = self.member_devices
         return spares
 
-    def _setSpares(self, spares):
+    def _set_spares(self, spares):
         max_spares = self.level.get_max_spares(len(self.parents))
         if spares > max_spares:
             log.debug("failed to set new spares value %d (max is %d)",
                       spares, max_spares)
             raise errors.DeviceError("new spares value is too large")
 
-        if self.totalDevices > spares:
-            self.memberDevices = self.totalDevices - spares
+        if self.total_devices > spares:
+            self.member_devices = self.total_devices - spares
 
-    spares = property(_getSpares, _setSpares)
+    spares = property(_get_spares, _set_spares)
 
-    def _addParent(self, member):
-        super(MDRaidArrayDevice, self)._addParent(member)
+    def _add_parent(self, member):
+        super(MDRaidArrayDevice, self)._add_parent(member)
 
         if self.status and member.format.exists:
             # we always probe since the device may not be set up when we want
             # information about it
-            self._size = self.currentSize
+            self._size = self.current_size
 
         # These should be incremented when adding new member devices except
         # during devicetree.populate. When detecting existing arrays we will
@@ -343,26 +343,26 @@ def _addParent(self, member):
         # whether we found all of the members, so we shouldn't change them in
         # that case.
         if not member.format.exists:
-            self._totalDevices += 1
-            self.memberDevices += 1
+            self._total_devices += 1
+            self.member_devices += 1
 
         # The new member hasn't been added yet, so account for it explicitly.
-        is_disk = self.isDisk and member.isDisk
+        is_disk = self.is_disk and member.is_disk
         for p in self.parents:
             p.format._hidden = is_disk
 
         member.format._hidden = is_disk
 
-    def _removeParent(self, member):
-        error_msg = self._validateParentRemoval(self.level, member)
+    def _remove_parent(self, member):
+        error_msg = self._validate_parent_removal(self.level, member)
         if error_msg:
             raise errors.DeviceError(error_msg)
 
-        super(MDRaidArrayDevice, self)._removeParent(member)
-        self.memberDevices -= 1
+        super(MDRaidArrayDevice, self)._remove_parent(member)
+        self.member_devices -= 1
 
     @property
-    def _trueStatusStrings(self):
+    def _true_status_strings(self):
         """ Strings in state file for which status() should return True."""
         return ("clean", "active", "active-idle", "readonly", "read-auto")
 
@@ -379,35 +379,35 @@ def status(self):
         if not self.exists:
             return status
 
-        if os.path.exists(self.path) and not self.sysfsPath:
+        if os.path.exists(self.path) and not self.sysfs_path:
             # the array has been activated from outside of blivet
-            self.updateSysfsPath()
+            self.update_sysfs_path()
 
             # make sure the active array is the one we expect
-            info = udev.get_device(self.sysfsPath)
+            info = udev.get_device(self.sysfs_path)
             uuid = udev.device_get_md_uuid(info)
             if uuid and uuid != self.uuid:
                 log.warning("md array %s is active, but has UUID %s -- not %s",
                             self.path, uuid, self.uuid)
-                self.sysfsPath = ""
+                self.sysfs_path = ""
                 return status
 
-        state_file = "%s/md/array_state" % self.sysfsPath
+        state_file = "%s/md/array_state" % self.sysfs_path
         try:
             state = open(state_file).read().strip()
-            if state in self._trueStatusStrings:
+            if state in self._true_status_strings:
                 status = True
         except IOError:
             status = False
 
         return status
 
-    def memberStatus(self, member):
+    def member_status(self, member):
         if not (self.status and member.status):
             return
 
-        member_name = os.path.basename(member.sysfsPath)
-        path = "/sys/%s/md/dev-%s/state" % (self.sysfsPath, member_name)
+        member_name = os.path.basename(member.sysfs_path)
+        path = "/sys/%s/md/dev-%s/state" % (self.sysfs_path, member_name)
         try:
             state = open(path).read().strip()
         except IOError:
@@ -419,7 +419,7 @@ def memberStatus(self, member):
     def degraded(self):
         """ Return True if the array is running in degraded mode. """
         rc = False
-        degraded_file = "%s/md/degraded" % self.sysfsPath
+        degraded_file = "%s/md/degraded" % self.sysfs_path
         if os.access(degraded_file, os.R_OK):
             val = open(degraded_file).read().strip()
             if val == "1":
@@ -445,11 +445,11 @@ def complete(self):
         """ An MDRaidArrayDevice is complete if it has at least as many
             component devices as its count of active devices.
         """
-        return (self.memberDevices <= len(self.members)) or not self.exists
+        return (self.member_devices <= len(self.members)) or not self.exists
 
-    def _postSetup(self):
-        super(MDRaidArrayDevice, self)._postSetup()
-        self.updateSysfsPath()
+    def _post_setup(self):
+        super(MDRaidArrayDevice, self)._post_setup()
+        self.update_sysfs_path()
 
     def _setup(self, orig=False):
         """ Open, or set up, a device. """
@@ -460,24 +460,24 @@ def _setup(self, orig=False):
             member.setup(orig=orig)
             disks.append(member.path)
 
-        blockdev.md.activate(self.path, members=disks, uuid=self.mdadmFormatUUID)
+        blockdev.md.activate(self.path, members=disks, uuid=self.mdadm_format_uuid)
 
-    def _postTeardown(self, recursive=False):
-        super(MDRaidArrayDevice, self)._postTeardown(recursive=recursive)
+    def _post_teardown(self, recursive=False):
+        super(MDRaidArrayDevice, self)._post_teardown(recursive=recursive)
         # mdadm reuses minors indiscriminantly when there is no mdadm.conf, so
         # we need to clear the sysfs path now so our status method continues to
         # give valid results
-        self.sysfsPath = ''
+        self.sysfs_path = ''
 
     def teardown(self, recursive=None):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        # we don't really care about the return value of _preTeardown here.
+        # we don't really care about the return value of _pre_teardown here.
         # see comment just above md_deactivate call
-        self._preTeardown(recursive=recursive)
+        self._pre_teardown(recursive=recursive)
 
-        if self.isDisk:
+        if self.is_disk:
             # treat arrays whose members are disks as partitionable disks
             return
 
@@ -487,45 +487,45 @@ def teardown(self, recursive=None):
         if self.exists and os.path.exists(self.path):
             blockdev.md.deactivate(self.path)
 
-        self._postTeardown(recursive=recursive)
+        self._post_teardown(recursive=recursive)
 
-    def preCommitFixup(self):
+    def pre_commit_fixup(self):
         """ Determine create parameters for this set """
         log_method_call(self, self.name)
         # UEFI firmware/bootloader cannot read 1.1 or 1.2 metadata arrays
         if getattr(self.format, "mountpoint", None) == "/boot/efi":
-            self.metadataVersion = "1.0"
+            self.metadata_version = "1.0"
 
-    def _postCreate(self):
+    def _post_create(self):
         # this is critical since our status method requires a valid sysfs path
-        self.exists = True  # this is needed to run updateSysfsPath
-        self.updateSysfsPath()
-        StorageDevice._postCreate(self)
+        self.exists = True  # this is needed to run update_sysfs_path
+        self.update_sysfs_path()
+        StorageDevice._post_create(self)
 
         # update our uuid attribute with the new array's UUID
         # XXX this won't work for containers since no UUID is reported for them
         info = blockdev.md.detail(self.path)
         self.uuid = info.uuid
         for member in self.members:
-            member.format.mdUuid = self.uuid
+            member.format.md_uuid = self.uuid
 
     def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
         disks = [disk.path for disk in self.members]
-        spares = len(self.members) - self.memberDevices
+        spares = len(self.members) - self.member_devices
         level = None
         if self.level:
             level = str(self.level)
         blockdev.md.create(self.path, level, disks, spares,
-                           version=self.metadataVersion,
-                           bitmap=self.createBitmap)
+                           version=self.metadata_version,
+                           bitmap=self.create_bitmap)
         udev.settle()
 
     def _remove(self, member):
         self.setup()
         # see if the device must be marked as failed before it can be removed
-        fail = (self.memberStatus(member) == "in_sync")
+        fail = (self.member_status(member) == "in_sync")
         blockdev.md.remove(self.path, member.path, fail)
 
     def _add(self, member):
@@ -548,13 +548,13 @@ def _add(self, member):
         blockdev.md.add(self.path, member.path, raid_devs=raid_devices)
 
     @property
-    def formatArgs(self):
-        formatArgs = []
+    def format_args(self):
+        format_args = []
         if self.format.type == "ext2":
-            recommended_stride = self.level.get_recommended_stride(self.memberDevices)
+            recommended_stride = self.level.get_recommended_stride(self.member_devices)
             if recommended_stride:
-                formatArgs = ['-R', 'stride=%d' % recommended_stride ]
-        return formatArgs
+                format_args = ['-R', 'stride=%d' % recommended_stride ]
+        return format_args
 
     @property
     def model(self):
@@ -565,17 +565,17 @@ def partitionable(self):
         return self.exists and self.parents and all(p.partitionable for p in self.members)
 
     @property
-    def isDisk(self):
-        return self.exists and self.parents and all(p.isDisk for p in self.members)
+    def is_disk(self):
+        return self.exists and self.parents and all(p.is_disk for p in self.members)
 
-    def dracutSetupArgs(self):
-        return set(["rd.md.uuid=%s" % self.mdadmFormatUUID])
+    def dracut_setup_args(self):
+        return set(["rd.md.uuid=%s" % self.mdadm_format_uuid])
 
-    def populateKSData(self, data):
-        if self.isDisk:
+    def populate_ksdata(self, data):
+        if self.is_disk:
             return
 
-        super(MDRaidArrayDevice, self).populateKSData(data)
+        super(MDRaidArrayDevice, self).populate_ksdata(data)
         data.level = self.level.name
         data.spares = self.spares
         data.members = ["raid.%d" % p.id for p in self.parents]
@@ -599,23 +599,23 @@ def description(self):
         return "BIOS RAID container"
 
     @property
-    def mdadmConfEntry(self):
-        uuid = self.mdadmFormatUUID
+    def mdadm_conf_entry(self):
+        uuid = self.mdadm_format_uuid
         if not uuid:
             raise errors.DeviceError("array is not fully defined", self.name)
 
         return "ARRAY %s UUID=%s\n" % (self.path, uuid)
 
     @property
-    def _trueStatusStrings(self):
+    def _true_status_strings(self):
         return ("clean", "active", "active-idle", "readonly", "read-auto", "inactive")
 
     def teardown(self, recursive=None):
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        # we don't really care about the return value of _preTeardown here.
+        # we don't really care about the return value of _pre_teardown here.
         # see comment just above md_deactivate call
-        self._preTeardown(recursive=recursive)
+        self._pre_teardown(recursive=recursive)
 
         # Since BIOS RAID sets (containers in mdraid terminology) never change
         # there is no need to stop them and later restart them. Not stopping
@@ -623,13 +623,13 @@ def teardown(self, recursive=None):
         return
 
     @property
-    def mediaPresent(self):
+    def media_present(self):
         # Containers should not get any format handling done
         # (the device node does not allow read / write calls)
         return False
 
     @property
-    def isDisk(self):
+    def is_disk(self):
         return False
 
     @property
@@ -639,8 +639,8 @@ def partitionable(self):
 class MDBiosRaidArrayDevice(MDRaidArrayDevice):
 
     _type = "mdbiosraidarray"
-    _formatClassName = property(lambda s: None)
-    _isDisk = True
+    _format_class_name = property(lambda s: None)
+    _is_disk = True
     _partitionable = True
 
     def __init__(self, name, **kwargs):
@@ -648,13 +648,13 @@ def __init__(self, name, **kwargs):
 
         # For container members probe size now, as we cannot determine it
         # when teared down.
-        self._size = self.currentSize
+        self._size = self.current_size
 
     @property
-    def isDisk(self):
+    def is_disk(self):
         # pylint: disable=bad-super-call
         # skip MDRaidArrayDevice and use the version in StorageDevice
-        return super(MDRaidArrayDevice, self).isDisk
+        return super(MDRaidArrayDevice, self).is_disk
 
     @property
     def partitionable(self):
@@ -674,8 +674,8 @@ def description(self):
         return "BIOS RAID set (%s)" % levelstr
 
     @property
-    def mdadmConfEntry(self):
-        uuid = self.mdadmFormatUUID
+    def mdadm_conf_entry(self):
+        uuid = self.mdadm_format_uuid
         if not uuid:
             raise errors.DeviceError("array is not fully defined", self.name)
 
@@ -694,35 +694,35 @@ def devices(self):
         return self.parents[0].devices
 
     @property
-    def totalDevices(self):
-        return self.parents[0].totalDevices
+    def total_devices(self):
+        return self.parents[0].total_devices
 
-    def _getMemberDevices(self):
-        return self.parents[0].memberDevices
+    def _get_member_devices(self):
+        return self.parents[0].member_devices
 
-    def _addParent(self, member):
+    def _add_parent(self, member):
         # pylint: disable=bad-super-call
-        super(MDRaidArrayDevice, self)._addParent(member)
+        super(MDRaidArrayDevice, self)._add_parent(member)
 
         if self.status and member.format.exists:
             # we always probe since the device may not be set up when we want
             # information about it
-            self._size = self.currentSize
+            self._size = self.current_size
 
-    def _removeParent(self, member):
-        error_msg = self._validateParentRemoval(self.level, member)
+    def _remove_parent(self, member):
+        error_msg = self._validate_parent_removal(self.level, member)
         if error_msg:
             raise errors.DeviceError(error_msg)
 
         # pylint: disable=bad-super-call
-        super(MDRaidArrayDevice, self)._removeParent(member)
+        super(MDRaidArrayDevice, self)._remove_parent(member)
 
     def teardown(self, recursive=None):
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        # we don't really care about the return value of _preTeardown here.
+        # we don't really care about the return value of _pre_teardown here.
         # see comment just above md_deactivate call
-        self._preTeardown(recursive=recursive)
+        self._pre_teardown(recursive=recursive)
 
         # Since BIOS RAID sets (containers in mdraid terminology) never change
         # there is no need to stop them and later restart them. Not stopping
diff --git a/blivet/devices/nfs.py b/blivet/devices/nfs.py
index da00114..84038ab 100644
--- a/blivet/devices/nfs.py
+++ b/blivet/devices/nfs.py
@@ -63,16 +63,16 @@ def teardown(self, recursive=None):
     def create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
-        self._preCreate()
+        self._pre_create()
 
     def destroy(self):
         """ Destroy the device. """
         log_method_call(self, self.name, status=self.status)
 
-    def updateSize(self):
+    def update_size(self):
         pass
 
     @classmethod
-    def isNameValid(cls, name):
-        # Override StorageDevice.isNameValid to allow /
+    def is_name_valid(cls, name):
+        # Override StorageDevice.is_name_valid to allow /
         return not('\x00' in name or name == '.' or name == '..')
diff --git a/blivet/devices/nodev.py b/blivet/devices/nodev.py
index 8016587..1c360cf 100644
--- a/blivet/devices/nodev.py
+++ b/blivet/devices/nodev.py
@@ -59,7 +59,7 @@ def teardown(self, recursive=False):
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
         # just make sure the format is unmounted
-        self._preTeardown(recursive=recursive)
+        self._pre_teardown(recursive=recursive)
 
     def create(self):
         """ Create the device. """
@@ -68,15 +68,15 @@ def create(self):
     def destroy(self):
         """ Destroy the device. """
         log_method_call(self, self.name, status=self.status)
-        self._preDestroy()
+        self._pre_destroy()
 
-    def updateSize(self):
+    def update_size(self):
         pass
 
 class TmpFSDevice(NoDevice):
     """ A nodev device for a tmpfs filesystem. """
     _type = "tmpfs"
-    _formatImmutable = True
+    _format_immutable = True
 
     def __init__(self, *args, **kwargs):
         """Create a tmpfs device"""
@@ -86,7 +86,7 @@ def __init__(self, *args, **kwargs):
         # the tmpfs device does not exist until mounted
         self.exists = False
         self._size = kwargs["size"]
-        self._targetSize = self._size
+        self._target_size = self._size
 
     @property
     def size(self):
@@ -98,11 +98,11 @@ def size(self):
             return Size(0)
 
     @property
-    def fstabSpec(self):
+    def fstab_spec(self):
         return self._type
 
-    def populateKSData(self, data):
-        super(TmpFSDevice, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(TmpFSDevice, self).populate_ksdata(data)
         # we need to supply a format to ksdata, otherwise the kickstart line
         # would include --noformat, resulting in an invalid command combination
         data.format = self.format
diff --git a/blivet/devices/optical.py b/blivet/devices/optical.py
index 591fd01..c99ec16 100644
--- a/blivet/devices/optical.py
+++ b/blivet/devices/optical.py
@@ -38,15 +38,15 @@ class OpticalDevice(StorageDevice):
     _type = "cdrom"
 
     def __init__(self, name, major=None, minor=None, exists=False,
-                 fmt=None, parents=None, sysfsPath='', vendor="",
+                 fmt=None, parents=None, sysfs_path='', vendor="",
                  model=""):
         StorageDevice.__init__(self, name, fmt=fmt,
                                major=major, minor=minor, exists=True,
-                               parents=parents, sysfsPath=sysfsPath,
+                               parents=parents, sysfs_path=sysfs_path,
                                vendor=vendor, model=model)
 
     @property
-    def mediaPresent(self):
+    def media_present(self):
         """ Return a boolean indicating whether or not the device contains
             media.
         """
diff --git a/blivet/devices/partition.py b/blivet/devices/partition.py
index fab9b23..7cc1a1d 100644
--- a/blivet/devices/partition.py
+++ b/blivet/devices/partition.py
@@ -34,7 +34,7 @@
 from ..flags import flags
 from ..storage_log import log_method_call
 from .. import udev
-from ..formats import DeviceFormat, getFormat
+from ..formats import DeviceFormat, get_format
 from ..size import Size, MiB
 
 import logging
@@ -43,7 +43,7 @@
 from .device import Device
 from .storage import StorageDevice
 from .dm import DMDevice
-from .lib import devicePathToName, deviceNameToDiskByPath, LINUX_SECTOR_SIZE
+from .lib import device_path_to_name, device_name_to_disk_by_path, LINUX_SECTOR_SIZE
 
 DEFAULT_PART_SIZE = Size("500MiB")
 
@@ -62,13 +62,13 @@ class PartitionDevice(StorageDevice):
     """
     _type = "partition"
     _resizable = True
-    defaultSize = DEFAULT_PART_SIZE
+    default_size = DEFAULT_PART_SIZE
 
     def __init__(self, name, fmt=None,
                  size=None, grow=False, maxsize=None, start=None, end=None,
                  major=None, minor=None, bootable=None,
-                 sysfsPath='', parents=None, exists=False,
-                 partType=None, primary=False, weight=0):
+                 sysfs_path='', parents=None, exists=False,
+                 part_type=None, primary=False, weight=0):
         """
             :param name: the device name (generally a device node's basename)
             :type name: str
@@ -87,14 +87,14 @@ def __init__(self, name, fmt=None,
             :type major: long
             :keyword minor: the device minor
             :type minor: long
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
 
             For non-existent partitions only:
 
-            :keyword partType: parted type constant, eg:
+            :keyword part_type: parted type constant, eg:
                                 :const:`parted.PARTITION_NORMAL`
-            :type partType: parted partition type constant
+            :type part_type: parted partition type constant
             :keyword grow: whether or not to grow the partition
             :type grow: bool
             :keyword maxsize: max size for growable partitions
@@ -114,7 +114,7 @@ def __init__(self, name, fmt=None,
                 adjusted for optimal alignment. That is up to the caller.
         """
         self.req_disks = []
-        self.req_partType = None
+        self.req_part_type = None
         self.req_primary = None
         self.req_grow = None
         self.req_bootable = None
@@ -128,21 +128,21 @@ def __init__(self, name, fmt=None,
 
         self._bootable = False
 
-        # FIXME: Validate partType, but only if this is a new partition
+        # FIXME: Validate part_type, but only if this is a new partition
         #        Otherwise, overwrite it with the partition's type.
-        self._partType = None
-        self._partedPartition = None
-        self._origPath = None
+        self._part_type = None
+        self._parted_partition = None
+        self._orig_path = None
 
         if not exists and size is None:
             if start is not None and end is not None:
                 size = Size(0)
             else:
-                size = self.defaultSize
+                size = self.default_size
 
         StorageDevice.__init__(self, name, fmt=fmt, size=size,
                                major=major, minor=minor, exists=exists,
-                               sysfsPath=sysfsPath, parents=parents)
+                               sysfs_path=sysfs_path, parents=parents)
 
         if not exists:
             # this is a request, not a partition -- it has no parents
@@ -155,27 +155,27 @@ def __init__(self, name, fmt=None,
 
         if self.exists and not flags.testing:
             log.debug("looking up parted Partition: %s", self.path)
-            self._partedPartition = self.disk.format.partedDisk.getPartitionByPath(self.path)
-            if not self._partedPartition:
+            self._parted_partition = self.disk.format.parted_disk.getPartitionByPath(self.path)
+            if not self._parted_partition:
                 raise errors.DeviceError("cannot find parted partition instance", self.name)
 
-            self._origPath = self.path
+            self._orig_path = self.path
             # collect information about the partition from parted
             self.probe()
-            if self.getFlag(parted.PARTITION_PREP):
+            if self.get_flag(parted.PARTITION_PREP):
                 # the only way to identify a PPC PReP Boot partition is to
                 # check the partition type/flags, so do it here.
-                self.format = getFormat("prepboot", device=self.path, exists=True)
-            elif self.getFlag(parted.PARTITION_BIOS_GRUB):
+                self.format = get_format("prepboot", device=self.path, exists=True)
+            elif self.get_flag(parted.PARTITION_BIOS_GRUB):
                 # the only way to identify a BIOS Boot partition is to
                 # check the partition type/flags, so do it here.
-                self.format = getFormat("biosboot", device=self.path, exists=True)
+                self.format = get_format("biosboot", device=self.path, exists=True)
         else:
             # XXX It might be worthwhile to create a shit-simple
             #     PartitionRequest class and pass one to this constructor
             #     for new partitions.
             self.req_name = name
-            self.req_partType = partType
+            self.req_part_type = part_type
             self.req_primary = primary
             self.req_max_size = Size(util.numeric_type(maxsize))
             self.req_grow = grow
@@ -192,51 +192,51 @@ def __init__(self, name, fmt=None,
             self.req_start_sector = start
             self.req_end_sector = end
 
-        # update currentSize again now when we have partedPartition and
-        # information about partType
+        # update current_size again now when we have parted_partition and
+        # information about part_type
         if self.exists and self.status:
-            self.updateSize()
+            self.update_size()
 
     def __repr__(self):
         s = StorageDevice.__repr__(self)
         s += ("  grow = %(grow)s  max size = %(maxsize)s  bootable = %(bootable)s\n"
-              "  part type = %(partType)s  primary = %(primary)s"
+              "  part type = %(part_type)s  primary = %(primary)s"
               "  start sector = %(start)s  end sector = %(end)s\n"
-              "  partedPartition = %(partedPart)s\n"
+              "  parted_partition = %(parted_part)s\n"
               "  disk = %(disk)s\n" %
               {"grow": self.req_grow, "maxsize": self.req_max_size,
-               "bootable": self.bootable, "partType": self.partType,
+               "bootable": self.bootable, "part_type": self.part_type,
                "primary": self.req_primary,
                "start": self.req_start_sector, "end": self.req_end_sector,
-               "partedPart": self.partedPartition, "disk": self.disk})
+               "parted_part": self.parted_partition, "disk": self.disk})
 
-        if self.partedPartition:
+        if self.parted_partition:
             s += ("  start = %(start)s  end = %(end)s  length = %(length)s\n"
                   "  flags = %(flags)s" %
-                  {"length": self.partedPartition.geometry.length,
-                   "start": self.partedPartition.geometry.start,
-                   "end": self.partedPartition.geometry.end,
-                   "flags": self.partedPartition.getFlagsAsString()})
+                  {"length": self.parted_partition.geometry.length,
+                   "start": self.parted_partition.geometry.start,
+                   "end": self.parted_partition.geometry.end,
+                   "flags": self.parted_partition.getFlagsAsString()})
 
         return s
 
     @property
     def dict(self):
         d = super(PartitionDevice, self).dict
-        d.update({"type": self.partType})
+        d.update({"type": self.part_type})
         if not self.exists:
             d.update({"grow": self.req_grow, "maxsize": self.req_max_size,
                       "bootable": self.bootable,
                       "primary": self.req_primary})
 
-        if self.partedPartition:
-            d.update({"length": self.partedPartition.geometry.length,
-                      "start": self.partedPartition.geometry.start,
-                      "end": self.partedPartition.geometry.end,
-                      "flags": self.partedPartition.getFlagsAsString()})
+        if self.parted_partition:
+            d.update({"length": self.parted_partition.geometry.length,
+                      "start": self.parted_partition.geometry.start,
+                      "end": self.parted_partition.geometry.end,
+                      "flags": self.parted_partition.getFlagsAsString()})
         return d
 
-    def alignTargetSize(self, newsize):
+    def align_target_size(self, newsize):
         """ Return newsize adjusted to allow for an end-aligned partition.
 
             :param :class:`~.Size` newsize: proposed/unaligned target size
@@ -248,17 +248,17 @@ def alignTargetSize(self, newsize):
         if newsize == Size(0):
             return newsize
 
-        (_constraint, geometry) = self._computeResize(self.partedPartition,
+        (_constraint, geometry) = self._compute_resize(self.parted_partition,
                                                       newsize=newsize)
         return Size(geometry.getLength(unit="B"))
 
-    def _setTargetSize(self, newsize):
+    def _set_target_size(self, newsize):
         if not isinstance(newsize, Size):
             raise ValueError("new size must of type Size")
 
         if newsize != self.size:
             try:
-                aligned = self.alignTargetSize(newsize)
+                aligned = self.align_target_size(newsize)
             except _ped.CreateException:
                 # this gets handled in superclass setter, below
                 aligned = newsize
@@ -268,133 +268,133 @@ def _setTargetSize(self, newsize):
 
             # change this partition's geometry in-memory so that other
             # partitioning operations can complete (e.g., autopart)
-            super(PartitionDevice, self)._setTargetSize(newsize)
-            disk = self.disk.format.partedDisk
+            super(PartitionDevice, self)._set_target_size(newsize)
+            disk = self.disk.format.parted_disk
 
             # resize the partition's geometry in memory
-            (constraint, geometry) = self._computeResize(self.partedPartition)
-            disk.setPartitionGeometry(partition=self.partedPartition,
+            (constraint, geometry) = self._compute_resize(self.parted_partition)
+            disk.setPartitionGeometry(partition=self.parted_partition,
                                       constraint=constraint,
                                       start=geometry.start, end=geometry.end)
 
     @property
     def path(self):
         if not self.parents:
-            devDir = StorageDevice._devDir
+            dev_dir = StorageDevice._dev_dir
         else:
-            devDir = self.parents[0]._devDir
+            dev_dir = self.parents[0]._dev_dir
 
-        return "%s/%s" % (devDir, self.name)
+        return "%s/%s" % (dev_dir, self.name)
 
     @property
-    def partType(self):
+    def part_type(self):
         """ Get the partition's type (as parted constant). """
         try:
-            ptype = self.partedPartition.type
+            ptype = self.parted_partition.type
         except AttributeError:
-            ptype = self._partType
+            ptype = self._part_type
 
         if not self.exists and ptype is None:
-            ptype = self.req_partType
+            ptype = self.req_part_type
 
         return ptype
 
     @property
-    def isExtended(self):
-        return (self.partType is not None and
-                self.partType & parted.PARTITION_EXTENDED)
+    def is_extended(self):
+        return (self.part_type is not None and
+                self.part_type & parted.PARTITION_EXTENDED)
 
     @property
-    def isLogical(self):
-        return (self.partType is not None and
-                self.partType & parted.PARTITION_LOGICAL)
+    def is_logical(self):
+        return (self.part_type is not None and
+                self.part_type & parted.PARTITION_LOGICAL)
 
     @property
-    def isPrimary(self):
-        return (self.partType is not None and
-                self.partType == parted.PARTITION_NORMAL)
+    def is_primary(self):
+        return (self.part_type is not None and
+                self.part_type == parted.PARTITION_NORMAL)
 
     @property
-    def isProtected(self):
-        return (self.partType is not None and
-                self.partType & parted.PARTITION_PROTECTED)
+    def is_protected(self):
+        return (self.part_type is not None and
+                self.part_type & parted.PARTITION_PROTECTED)
 
     @property
-    def fstabSpec(self):
+    def fstab_spec(self):
         spec = self.path
         if self.disk and self.disk.type == 'dasd':
-            spec = deviceNameToDiskByPath(self.name)
+            spec = device_name_to_disk_by_path(self.name)
         elif self.format and self.format.uuid:
             spec = "UUID=%s" % self.format.uuid
         return spec
 
-    def _getPartedPartition(self):
-        return self._partedPartition
+    def _get_parted_partition(self):
+        return self._parted_partition
 
-    def _setPartedPartition(self, partition):
+    def _set_parted_partition(self, partition):
         """ Set this PartitionDevice's parted Partition instance. """
         log_method_call(self, self.name)
 
         if partition is not None and not isinstance(partition, parted.Partition):
             raise ValueError("partition must be None or a parted.Partition instance")
 
-        log.debug("device %s new partedPartition %s", self.name, partition)
-        self._partedPartition = partition
-        self.updateName()
+        log.debug("device %s new parted_partition %s", self.name, partition)
+        self._parted_partition = partition
+        self.update_name()
 
-    partedPartition = property(lambda d: d._getPartedPartition(),
-                               lambda d,p: d._setPartedPartition(p))
+    parted_partition = property(lambda d: d._get_parted_partition(),
+                               lambda d,p: d._set_parted_partition(p))
 
-    def preCommitFixup(self):
-        """ Re-get self.partedPartition from the original disklabel. """
+    def pre_commit_fixup(self):
+        """ Re-get self.parted_partition from the original disklabel. """
         log_method_call(self, self.name)
         if not self.exists:
             return
 
         # find the correct partition on the original parted.Disk since the
         # name/number we're now using may no longer match
-        _disklabel = self.disk.originalFormat
+        _disklabel = self.disk.original_format
 
-        if self.isExtended:
+        if self.is_extended:
             # getPartitionBySector doesn't work on extended partitions
-            _partition = _disklabel.extendedPartition
+            _partition = _disklabel.extended_partition
             log.debug("extended lookup found partition %s",
-                        devicePathToName(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.partedPartition.geometry.start
-            _partition = _disklabel.partedDisk.getPartitionBySector(_sector)
+            _sector = self.parted_partition.geometry.start
+            _partition = _disklabel.parted_disk.getPartitionBySector(_sector)
             log.debug("sector-based lookup found partition %s",
-                        devicePathToName(getattr(_partition, "path", None) or "(none)"))
+                        device_path_to_name(getattr(_partition, "path", None) or "(none)"))
 
-        self.partedPartition = _partition
+        self.parted_partition = _partition
 
-    def _getWeight(self):
+    def _get_weight(self):
         return self.req_base_weight
 
-    def _setWeight(self, weight):
+    def _set_weight(self, weight):
         self.req_base_weight = weight
 
-    weight = property(lambda d: d._getWeight(),
-                      lambda d,w: d._setWeight(w))
+    weight = property(lambda d: d._get_weight(),
+                      lambda d,w: d._set_weight(w))
 
-    def _setName(self, value):
+    def _set_name(self, value):
         self._name = value  # actual name setting is done by parted
 
-    def updateName(self):
-        if self.partedPartition is None:
+    def update_name(self):
+        if self.parted_partition is None:
             self.name = self.req_name
         else:
-            self.name = devicePathToName(self.partedPartition.path)
+            self.name = device_path_to_name(self.parted_partition.path)
 
-    def dependsOn(self, dep):
+    def depends_on(self, dep):
         """ Return True if this device depends on dep. """
-        if isinstance(dep, PartitionDevice) and dep.isExtended and \
-           self.isLogical and self.disk == dep.disk:
+        if isinstance(dep, PartitionDevice) and dep.is_extended and \
+           self.is_logical and self.disk == dep.disk:
             return True
 
-        return Device.dependsOn(self, dep)
+        return Device.depends_on(self, dep)
 
     @property
     def isleaf(self):
@@ -403,32 +403,32 @@ def isleaf(self):
         # it is possible that the disk that originally contained this partition
         # no longer contains a disklabel, in which case we can assume that this
         # device is a leaf
-        if self.disk and self.partedPartition and \
+        if self.disk and self.parted_partition and \
            self.disk.format.type == "disklabel" and \
-           self.partedPartition in self.disk.format.partitions:
+           self.parted_partition in self.disk.format.partitions:
             disklabel = self.disk.format
         else:
             disklabel = None
 
-        extended_has_logical = (self.isExtended and
-                                (disklabel and disklabel.logicalPartitions))
+        extended_has_logical = (self.is_extended and
+                                (disklabel and disklabel.logical_partitions))
         return (no_kids and not extended_has_logical)
 
     @property
     def direct(self):
         """ Is this device directly accessible? """
-        return self.isleaf and not self.isExtended
+        return self.isleaf and not self.is_extended
 
-    def _setBootable(self, bootable):
+    def _set_bootable(self, bootable):
         """ Set the bootable flag for this partition. """
-        if self.partedPartition:
-            if arch.isS390():
+        if self.parted_partition:
+            if arch.is_s390():
                 return
-            if self.flagAvailable(parted.PARTITION_BOOT):
+            if self.flag_available(parted.PARTITION_BOOT):
                 if bootable:
-                    self.setFlag(parted.PARTITION_BOOT)
+                    self.set_flag(parted.PARTITION_BOOT)
                 else:
-                    self.unsetFlag(parted.PARTITION_BOOT)
+                    self.unset_flag(parted.PARTITION_BOOT)
             else:
                 raise errors.DeviceError("boot flag not available for this partition", self.name)
 
@@ -436,85 +436,85 @@ def _setBootable(self, bootable):
         else:
             self.req_bootable = bootable
 
-    def _getBootable(self):
+    def _get_bootable(self):
         return self._bootable or self.req_bootable
 
-    bootable = property(_getBootable, _setBootable)
+    bootable = property(_get_bootable, _set_bootable)
 
-    def flagAvailable(self, flag):
-        if not self.partedPartition:
+    def flag_available(self, flag):
+        if not self.parted_partition:
             return
 
-        return self.partedPartition.isFlagAvailable(flag)
+        return self.parted_partition.isFlagAvailable(flag)
 
-    def getFlag(self, flag):
+    def get_flag(self, flag):
         log_method_call(self, path=self.path, flag=flag)
-        if not self.partedPartition or not self.flagAvailable(flag):
+        if not self.parted_partition or not self.flag_available(flag):
             return
 
-        return self.partedPartition.getFlag(flag)
+        return self.parted_partition.getFlag(flag)
 
-    def setFlag(self, flag):
+    def set_flag(self, flag):
         log_method_call(self, path=self.path, flag=flag)
-        if not self.partedPartition or not self.flagAvailable(flag):
+        if not self.parted_partition or not self.flag_available(flag):
             return
 
-        self.partedPartition.setFlag(flag)
+        self.parted_partition.setFlag(flag)
 
-    def unsetFlag(self, flag):
+    def unset_flag(self, flag):
         log_method_call(self, path=self.path, flag=flag)
-        if not self.partedPartition or not self.flagAvailable(flag):
+        if not self.parted_partition or not self.flag_available(flag):
             return
 
-        self.partedPartition.unsetFlag(flag)
+        self.parted_partition.unsetFlag(flag)
 
     @property
-    def isMagic(self):
+    def is_magic(self):
         if not self.disk:
             return False
 
-        number = getattr(self.partedPartition, "number", -1)
-        magic = self.disk.format.magicPartitionNumber
+        number = getattr(self.parted_partition, "number", -1)
+        magic = self.disk.format.magic_partition_number
         return (number == magic)
 
-    def removeHook(self, modparent=True):
+    def remove_hook(self, modparent=True):
         if modparent:
             # if this partition hasn't been allocated it could not have
             # a disk attribute
             if not self.disk:
                 return
 
-            if self.partedPartition.type == parted.PARTITION_EXTENDED and \
-                    len(self.disk.format.logicalPartitions) > 0:
+            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)
 
-            self.disk.format.removePartition(self.partedPartition)
+            self.disk.format.remove_partition(self.parted_partition)
 
-        super(PartitionDevice, self).removeHook(modparent=modparent)
+        super(PartitionDevice, self).remove_hook(modparent=modparent)
 
-    def addHook(self, new=True):
-        super(PartitionDevice, self).addHook(new=new)
+    def add_hook(self, new=True):
+        super(PartitionDevice, self).add_hook(new=new)
         if new:
             return
 
-        if not self.disk or not self.partedPartition or \
-           self.partedPartition in self.disk.format.partitions:
+        if not self.disk or not self.parted_partition or \
+           self.parted_partition in self.disk.format.partitions:
             return
 
-        self.disk.format.addPartition(self.partedPartition.geometry.start,
-                                      self.partedPartition.geometry.end,
-                                      self.partedPartition.type)
+        self.disk.format.add_partition(self.parted_partition.geometry.start,
+                                      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.
-        if self.isExtended:
-            partition = self.disk.format.extendedPartition
+        if self.is_extended:
+            partition = self.disk.format.extended_partition
         else:
-            start = self.partedPartition.geometry.start
-            partition = self.disk.format.partedDisk.getPartitionBySector(start)
+            start = self.parted_partition.geometry.start
+            partition = self.disk.format.parted_disk.getPartitionBySector(start)
 
-        self.partedPartition = partition
+        self.parted_partition = partition
 
     def probe(self):
         """ Probe for any missing information about this device.
@@ -525,12 +525,12 @@ def probe(self):
         if not self.exists:
             return
 
-        self._size = Size(self.partedPartition.getLength(unit="B"))
-        self.targetSize = self._size
+        self._size = Size(self.parted_partition.getLength(unit="B"))
+        self.target_size = self._size
 
-        self._partType = self.partedPartition.type
+        self._part_type = self.parted_partition.type
 
-        self._bootable = self.getFlag(parted.PARTITION_BOOT)
+        self._bootable = self.get_flag(parted.PARTITION_BOOT)
 
     def _wipe(self):
         """ Wipe the partition metadata.
@@ -544,9 +544,9 @@ def _wipe(self):
         """
         log_method_call(self, self.name, status=self.status)
 
-        start = self.partedPartition.geometry.start
-        part_len = self.partedPartition.geometry.end - start
-        bs = Size(self.partedPartition.geometry.device.sectorSize)
+        start = self.parted_partition.geometry.start
+        part_len = self.parted_partition.geometry.end - start
+        bs = Size(self.parted_partition.geometry.device.sectorSize)
 
         # Ensure that count is smallest value such that count * bs >= 1 MiB
         (count, rem) = divmod(Size("1 MiB"), bs)
@@ -556,7 +556,7 @@ def _wipe(self):
         # Ensure that count <= part_len
         count = min(count, part_len)
 
-        device = self.partedPartition.geometry.device.path
+        device = self.parted_partition.geometry.device.path
         cmd = ["dd", "if=/dev/zero", "of=%s" % device, "bs=%d" % bs,
                "seek=%d" % start, "count=%d" % count]
         try:
@@ -572,36 +572,36 @@ def _wipe(self):
     def _create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
-        self.disk.format.addPartition(self.partedPartition.geometry.start,
-                                      self.partedPartition.geometry.end,
-                                      self.partedPartition.type)
+        self.disk.format.add_partition(self.parted_partition.geometry.start,
+                                      self.parted_partition.geometry.end,
+                                      self.parted_partition.type)
 
         self._wipe()
         try:
             self.disk.format.commit()
         except errors.DiskLabelCommitError:
-            part = self.disk.format.partedDisk.getPartitionByPath(self.path)
-            self.disk.format.removePartition(part)
+            part = self.disk.format.parted_disk.getPartitionByPath(self.path)
+            self.disk.format.remove_partition(part)
             raise
 
-    def _postCreate(self):
-        if self.isExtended:
-            partition = self.disk.format.extendedPartition
+    def _post_create(self):
+        if self.is_extended:
+            partition = self.disk.format.extended_partition
         else:
-            start = self.partedPartition.geometry.start
-            partition = self.disk.format.partedDisk.getPartitionBySector(start)
+            start = self.parted_partition.geometry.start
+            partition = self.disk.format.parted_disk.getPartitionBySector(start)
 
         log.debug("post-commit partition path is %s", getattr(partition,
                                                              "path", None))
-        self.partedPartition = partition
-        if not self.isExtended:
+        self.parted_partition = partition
+        if not self.is_extended:
             # Ensure old metadata which lived in freespace so did not get
             # explictly destroyed by a destroyformat action gets wiped
             DeviceFormat(device=self.path, exists=True).destroy()
 
-        StorageDevice._postCreate(self)
+        StorageDevice._post_create(self)
 
-    def _computeResize(self, partition, newsize=None):
+    def _compute_resize(self, partition, newsize=None):
         """ Return a new constraint and end-aligned geometry for new size.
 
             :param :class:`parted.Partition` partition: the current partition
@@ -616,95 +616,95 @@ def _computeResize(self, partition, newsize=None):
         log_method_call(self, self.name, status=self.status)
 
         if newsize is None:
-            newsize = self.targetSize
+            newsize = self.target_size
 
         # compute new size for partition
-        currentGeom = partition.geometry
-        currentDev = currentGeom.device
-        newLen = int(newsize // Size(currentDev.sectorSize))
-        newGeometry = parted.Geometry(device=currentDev,
-                                      start=currentGeom.start,
-                                      length=newLen)
+        current_geom = partition.geometry
+        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)
         # and align the end sector
-        if newGeometry.length < currentGeom.length:
-            align = self.disk.format.endAlignment.alignUp
-            alignGeom = currentGeom # we can align up into the old geometry
+        if new_geometry.length < current_geom.length:
+            align = self.disk.format.end_alignment.alignUp
+            align_geom = current_geom # we can align up into the old geometry
         else:
-            align = self.disk.format.endAlignment.alignDown
-            alignGeom = newGeometry
+            align = self.disk.format.end_alignment.alignDown
+            align_geom = new_geometry
 
-        newGeometry.end = align(alignGeom, newGeometry.end)
-        constraint = parted.Constraint(exactGeom=newGeometry)
+        new_geometry.end = align(align_geom, new_geometry.end)
+        constraint = parted.Constraint(exactGeom=new_geometry)
 
-        return (constraint, newGeometry)
+        return (constraint, new_geometry)
 
     def resize(self):
         log_method_call(self, self.name, status=self.status)
-        self._preResize()
+        self._pre_resize()
 
-        # partedDisk has been restored to _origPartedDisk, so
+        # parted_disk has been restored to _orig_parted_disk, so
         # recalculate resize geometry because we may have new
         # partitions on the disk, which could change constraints
-        partedDisk = self.disk.format.partedDisk
-        partition = partedDisk.getPartitionByPath(self.path)
-        (constraint, geometry) = self._computeResize(partition)
+        parted_disk = self.disk.format.parted_disk
+        partition = parted_disk.getPartitionByPath(self.path)
+        (constraint, geometry) = self._compute_resize(partition)
 
-        partedDisk.setPartitionGeometry(partition=partition,
+        parted_disk.setPartitionGeometry(partition=partition,
                                         constraint=constraint,
                                         start=geometry.start,
                                         end=geometry.end)
 
         self.disk.format.commit()
-        self.updateSize()
+        self.update_size()
 
-    def _preResize(self):
+    def _pre_resize(self):
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
 
-        if not self.isleaf and not self.isExtended:
+        if not self.isleaf and not self.is_extended:
             raise errors.DeviceError("Cannot destroy non-leaf device", self.name)
 
         self.teardown()
 
-        if not self.sysfsPath:
+        if not self.sysfs_path:
             return
 
-        self.setupParents(orig=True)
+        self.setup_parents(orig=True)
 
-    def _preDestroy(self):
-        StorageDevice._preDestroy(self)
-        if not self.sysfsPath:
+    def _pre_destroy(self):
+        StorageDevice._pre_destroy(self)
+        if not self.sysfs_path:
             return
 
-        self.setupParents(orig=True)
+        self.setup_parents(orig=True)
 
     def _destroy(self):
         """ Destroy the device. """
         log_method_call(self, self.name, status=self.status)
-        # we should have already set self.partedPartition to point to the
+        # we should have already set self.parted_partition to point to the
         # partition on the original disklabel
-        self.disk.originalFormat.removePartition(self.partedPartition)
+        self.disk.original_format.remove_partition(self.parted_partition)
         try:
-            self.disk.originalFormat.commit()
+            self.disk.original_format.commit()
         except errors.DiskLabelCommitError:
-            self.disk.originalFormat.addPartition(
-                                        self.partedPartition.geometry.start,
-                                        self.partedPartition.geometry.end,
-                                        self.partedPartition.type)
-            self.partedPartition = self.disk.originalFormat.partedDisk.getPartitionByPath(self.path)
+            self.disk.original_format.add_partition(
+                                        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
 
         if self.disk.format.exists and \
            self.disk.format.type == "disklabel" and \
-           self.disk.format.partedDisk != self.disk.originalFormat.partedDisk:
+           self.disk.format.parted_disk != self.disk.original_format.parted_disk:
             # If the new/current disklabel is the same as the original one, we
             # have to duplicate the removal on the other copy of the DiskLabel.
-            part = self.disk.format.partedDisk.getPartitionByPath(self.path)
-            self.disk.format.removePartition(part)
+            part = self.disk.format.parted_disk.getPartitionByPath(self.path)
+            self.disk.format.remove_partition(part)
             self.disk.format.commit()
 
-    def _postDestroy(self):
-        super(PartitionDevice, self)._postDestroy()
+    def _post_destroy(self):
+        super(PartitionDevice, self)._post_destroy()
         if isinstance(self.disk, DMDevice):
             udev.settle()
             # self.exists has been unset, so don't use self.status
@@ -714,20 +714,20 @@ def _postDestroy(self):
                 except blockdev.DMError:
                     pass
 
-    def _getSize(self):
+    def _get_size(self):
         """ Get the device's size. """
         size = self._size
-        if self.partedPartition:
-            size = Size(self.partedPartition.getLength(unit="B"))
+        if self.parted_partition:
+            size = Size(self.parted_partition.getLength(unit="B"))
         return size
 
-    def _setSize(self, newsize):
+    def _set_size(self, newsize):
         """ Set the device's size.
 
             .. note::
 
                 If you change the size of an allocated-but-not-existing
-                partition, you are responsible for calling doPartitioning to
+                partition, you are responsible for calling do_partitioning to
                 reallocate it with the new size.
 
         """
@@ -736,13 +736,13 @@ def _setSize(self, newsize):
         if not isinstance(newsize, Size):
             raise ValueError("new size must of type Size")
 
-        super(PartitionDevice, self)._setSize(newsize)
+        super(PartitionDevice, self)._set_size(newsize)
         if not self.exists:
             # also update size fields used for partition allocation
             self.req_size = newsize
             self.req_base_size = newsize
 
-    def _getDisk(self):
+    def _get_disk(self):
         """ The disk that contains this partition."""
         try:
             disk = self.parents[0]
@@ -750,7 +750,7 @@ def _getDisk(self):
             disk = None
         return disk
 
-    def _setDisk(self, disk):
+    def _set_disk(self, disk):
         """Change the parent.
 
         Setting up a disk is not trivial.  It has the potential to change
@@ -762,10 +762,10 @@ def _setDisk(self, disk):
         if disk:
             self.parents.append(disk)
 
-    disk = property(lambda p: p._getDisk(), lambda p,d: p._setDisk(d))
+    disk = property(lambda p: p._get_disk(), lambda p,d: p._set_disk(d))
 
     @property
-    def _unalignedMaxPartSize(self):
+    def _unaligned_max_part_size(self):
         """ Maximum size partition can grow to with unchanged start sector.
 
             :rtype: :class:`~.size.Size`
@@ -774,84 +774,84 @@ def _unalignedMaxPartSize(self):
         #     partition on disk. We don't care about leading free space --
         #     a filesystem cannot be relocated, so if you want to use space
         #     before and after your partition, remove it and create a new one.
-        maxPartSize = self.size
+        max_part_size = self.size
 
-        if self.isLogical:
+        if self.is_logical:
             # logical partition is at the very end of the extended partition
-            extended = self.partedPartition.disk.getExtendedPartition()
-            if self.partedPartition.geometry.end == extended.geometry.end:
-                return maxPartSize
+            extended = self.parted_partition.disk.getExtendedPartition()
+            if self.parted_partition.geometry.end == extended.geometry.end:
+                return max_part_size
 
-        sector = self.partedPartition.geometry.end + 1
+        sector = self.parted_partition.geometry.end + 1
         try:
-            partition = self.partedPartition.disk.getPartitionBySector(sector)
+            partition = self.parted_partition.disk.getPartitionBySector(sector)
         except _ped.PartitionException:
             pass
         else:
             # next partition is free space or 'logical' free space
             if partition.type & parted.PARTITION_FREESPACE:
-                maxPartSize += Size(partition.getLength(unit="B"))
+                max_part_size += Size(partition.getLength(unit="B"))
 
-        return maxPartSize
+        return max_part_size
 
-    def readCurrentSize(self):
+    def read_current_size(self):
         # sys reports wrong size for extended partitions (1 KiB)
-        if self.isExtended:
+        if self.is_extended:
             log_method_call(self, exists=self.exists, path=self.path,
-                            sysfsPath=self.sysfsPath)
+                            sysfs_path=self.sysfs_path)
             size = Size(0)
             if self.exists and os.path.exists(self.path) and \
-               os.path.isdir(self.sysfsPath):
-                blocks = udev.device_get_part_size(udev.get_device(self.sysfsPath))
+               os.path.isdir(self.sysfs_path):
+                blocks = udev.device_get_part_size(udev.get_device(self.sysfs_path))
                 if blocks:
                     size = Size(int(blocks) * LINUX_SECTOR_SIZE)
 
         else:
-            size = super(PartitionDevice, self).readCurrentSize()
+            size = super(PartitionDevice, self).read_current_size()
 
         return size
 
     @property
-    def minSize(self):
-        if self.isExtended:
-            logicals = self.disk.format.logicalPartitions
+    def min_size(self):
+        if self.is_extended:
+            logicals = self.disk.format.logical_partitions
             if logicals:
-                end_free = Size((self.partedPartition.geometry.end - logicals[-1].geometry.end) * \
-                                self.disk.format.sectorSize)
-                min_size = self.alignTargetSize(self.currentSize - end_free)
+                end_free = Size((self.parted_partition.geometry.end - logicals[-1].geometry.end) * \
+                                self.disk.format.sector_size)
+                min_size = self.align_target_size(self.current_size - end_free)
             else:
-                min_size = self.alignTargetSize(max(Size("1 KiB"), self.disk.format.alignment.grainSize))
+                min_size = self.align_target_size(max(Size("1 KiB"), self.disk.format.alignment.grainSize))
 
         else:
-            min_size = super(PartitionDevice, self).minSize
+            min_size = super(PartitionDevice, self).min_size
 
         if self.resizable and min_size:
             # Adjust the min size as needed so that aligning the end sector
             # won't drive the actual size below the formatting's minimum.
             # align the end sector (up, if possible)
-            aligned = self.alignTargetSize(min_size)
+            aligned = self.align_target_size(min_size)
             if aligned < min_size:
                 # If it aligned down, that must mean it cannot align up. Just
                 # return our current size.
                 log.debug("failed to align min size up; returning current size")
-                min_size = self.currentSize
+                min_size = self.current_size
 
         return min_size
 
     @property
-    def maxSize(self):
+    def max_size(self):
         """ The maximum size this partition can be. """
-        maxPartSize = self._unalignedMaxPartSize
-        maxFormatSize = self.format.maxSize
-        unalignedMax = min(maxFormatSize, maxPartSize) if maxFormatSize else maxPartSize
-        return self.alignTargetSize(unalignedMax)
+        max_part_size = self._unaligned_max_part_size
+        max_format_size = self.format.max_size
+        unaligned_max = min(max_format_size, max_part_size) if max_format_size else max_part_size
+        return self.align_target_size(unaligned_max)
 
     @property
     def resizable(self):
         return super(PartitionDevice, self).resizable and \
                self.disk.type != 'dasd'
 
-    def checkSize(self):
+    def check_size(self):
         """ Check to make sure the size of the device is allowed by the
             format used.
 
@@ -860,32 +860,32 @@ def checkSize(self):
             1  - Too large
             -1 - Too small
         """
-        if self.format.maxSize and self.size > self.format.maxSize:
+        if self.format.max_size and self.size > self.format.max_size:
             return 1
-        elif (self.format.minSize and
+        elif (self.format.min_size and
               (not self.req_grow and
-               self.size < self.format.minSize) or
+               self.size < self.format.min_size) or
               (self.req_grow and self.req_max_size and
-               self.req_max_size < self.format.minSize)):
+               self.req_max_size < self.format.min_size)):
             return -1
         return 0
 
-    def populateKSData(self, data):
-        super(PartitionDevice, self).populateKSData(data)
-        data.resize = (self.exists and self.targetSize and
-                       self.targetSize != self.currentSize)
+    def populate_ksdata(self, data):
+        super(PartitionDevice, self).populate_ksdata(data)
+        data.resize = (self.exists and self.target_size and
+                       self.target_size != self.current_size)
         if not self.exists:
-            data.size = self.req_base_size.convertTo(MiB)
+            data.size = self.req_base_size.convert_to(MiB)
             data.grow = self.req_grow
             if self.req_grow:
-                data.maxSizeMB = self.req_max_size.convertTo(MiB)
+                data.max_size_mb = self.req_max_size.convert_to(MiB)
 
             ##data.disk = self.disk.name                      # by-id
             if self.req_disks and len(self.req_disks) == 1:
                 data.disk = self.disk.name
-            data.primOnly = self.req_primary
+            data.prim_only = self.req_primary
         else:
-            data.onPart = self.name                     # by-id
+            data.on_part = self.name                     # by-id
 
             if data.resize:
-                data.size = self.size.convertTo(MiB)
+                data.size = self.size.convert_to(MiB)
diff --git a/blivet/devices/raid.py b/blivet/devices/raid.py
index 85e1ece..a2e73e0 100644
--- a/blivet/devices/raid.py
+++ b/blivet/devices/raid.py
@@ -34,7 +34,7 @@ class RaidDevice(StorageDevice):
     members = abc.abstractproperty(lambda s: [],
                                    doc="A list of the member device instances")
 
-    def _validateRaidLevel(self, level, parent_diff=0):
+    def _validate_raid_level(self, level, parent_diff=0):
         """ Returns an error message if the RAID level is invalid for this
             device, otherwise None.
 
@@ -52,14 +52,14 @@ def _validateRaidLevel(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 %(raidLevel)s requires that device have at least %(minMembers)d member.",
-               "RAID level %(raidLevel)s requires that device have at least %(minMembers)d 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 % {"raidLevel": level, "minMembers" : level.min_members}
+            return message % {"raid_level": level, "min_members" : level.min_members}
         return None
 
-    def _getLevel(self, value, levels):
+    def _get_level(self, value, levels):
         """ Obtains a valid level for the allowed set of levels.
 
             :param value: a RAID level
@@ -71,19 +71,19 @@ def _getLevel(self, value, levels):
             :raises ValueError: if invalid RAID level
         """
         try:
-            level = levels.raidLevel(value)
+            level = levels.raid_level(value)
         except errors.RaidError:
-            message = _("RAID level %(raidLevel)s is an invalid value. Must be one of (%(levels)s).")
+            message = _("RAID level %(raid_level)s is an invalid value. Must be one of (%(levels)s).")
             choices = ", ".join([str(l) for l in levels])
-            raise ValueError(message % {"raidLevel": value, "levels" : choices})
+            raise ValueError(message % {"raid_level": value, "levels" : choices})
 
-        error_msg = self._validateRaidLevel(level)
+        error_msg = self._validate_raid_level(level)
         if error_msg:
             raise ValueError(error_msg)
 
         return level
 
-    def _validateParentRemoval(self, level, parent):
+    def _validate_parent_removal(self, level, parent):
         """ Check if it is possible to remove a parent from this device.
 
             :param level: a RAID level
@@ -105,4 +105,4 @@ def _validateParentRemoval(self, level, parent):
             pass
 
         # Removing a member may invalidate the RAID level
-        return self._validateRaidLevel(level, -1)
+        return self._validate_raid_level(level, -1)
diff --git a/blivet/devices/storage.py b/blivet/devices/storage.py
index f7a735f..7e0136a 100644
--- a/blivet/devices/storage.py
+++ b/blivet/devices/storage.py
@@ -29,7 +29,7 @@
 from ..flags import flags
 from ..storage_log import log_method_call
 from .. import udev
-from ..formats import getFormat, DeviceFormat
+from ..formats import get_format, DeviceFormat
 from ..size import Size
 from ..util import open # pylint: disable=redefined-builtin
 
@@ -52,16 +52,16 @@ class StorageDevice(Device):
     """Whether this type of device is inherently resizable."""
 
     _type = "blivet"
-    _devDir = "/dev"
-    _formatImmutable = False
+    _dev_dir = "/dev"
+    _format_immutable = False
     _partitionable = False
-    _isDisk = False
+    _is_disk = False
     _encrypted = False
     _external_dependencies = []
 
     def __init__(self, name, fmt=None, uuid=None,
                  size=None, major=None, minor=None,
-                 sysfsPath='', parents=None, exists=False, serial=None,
+                 sysfs_path='', parents=None, exists=False, serial=None,
                  vendor="", model="", bus=""):
         """
             :param name: the device name (generally a device node's basename)
@@ -76,8 +76,8 @@ def __init__(self, name, fmt=None, uuid=None,
             :type fmt: :class:`~.formats.DeviceFormat` or a subclass of it
             :keyword uuid: universally unique identifier (device -- not fs)
             :type uuid: str
-            :keyword sysfsPath: sysfs device path
-            :type sysfsPath: str
+            :keyword sysfs_path: sysfs device path
+            :type sysfs_path: str
             :keyword major: the device major
             :type major: int
             :keyword minor: the device minor
@@ -99,28 +99,27 @@ def __init__(self, name, fmt=None, uuid=None,
         self.exists = exists
         self.uuid = uuid
 
-        # Set these fields before super call as MDRaidArrayDevice._addParent()
-        # reads them, through calls to status() and partedDevice().
-        self.sysfsPath = sysfsPath
-        self._partedDevice = None
+        # Set sysfs path before super call as MDRaidArrayDevice._add_parent()
+        # reads it via status().
+        self.sysfs_path = sysfs_path
 
-        self._format = getFormat(None)
+        self._format = get_format(None)
 
         # For non-existent devices, make sure the initial size is enough for
         # the format's metadata. This is mostly relevant for growable
         # partitions and lvs with thoughtless initial sizes.
-        if not self.exists and fmt and fmt.minSize:
-            min_size = max(util.numeric_type(size), fmt.minSize)
+        if not self.exists and fmt and fmt.min_size:
+            min_size = max(util.numeric_type(size), fmt.min_size)
             if min_size > util.numeric_type(size):
                 log.info("%s: using size %s instead of %s to accommodate "
                          "format minimum size", name, min_size, size)
                 size = min_size
 
-        # The size will be overridden by a call to updateSize at the end of this
+        # The size will be overridden by a call to update_size at the end of this
         # method for existing and active devices.
         self._size = Size(util.numeric_type(size))
-        self._targetSize = self._size
-        self._currentSize = self._size if self.exists else Size(0)
+        self._target_size = self._size
+        self._current_size = self._size if self.exists else Size(0)
         self.major = util.numeric_type(major)
         self.minor = util.numeric_type(minor)
         self._serial = serial
@@ -135,13 +134,13 @@ def __init__(self, name, fmt=None, uuid=None,
         super(StorageDevice, self).__init__(name, parents=parents)
 
         self.format = fmt
-        self.originalFormat = copy.deepcopy(self.format)
-        self.fstabComment = ""
+        self.original_format = copy.deepcopy(self.format)
+        self.fstab_comment = ""
 
-        self.deviceLinks = []
+        self.device_links = []
 
         if self.exists and self.status:
-            self.updateSize()
+            self.update_size()
 
     def __str__(self):
         exist = "existing"
@@ -166,7 +165,7 @@ def disks(self):
         for parent in self.parents:
             _disks.extend(d for d in parent.disks if d not in _disks)
 
-        if self.isDisk and not self.format.hidden:
+        if self.is_disk and not self.format.hidden:
             _disks.append(self)
 
         return _disks
@@ -181,7 +180,7 @@ def raw_device(self):
         """ The device itself, or when encrypted, the backing device. """
         return self
 
-    def _setName(self, value):
+    def _set_name(self, value):
         """Set the device's name.
 
         :param value: the new device name
@@ -191,7 +190,7 @@ def _setName(self, value):
         if value == self._name:
             return
 
-        super(StorageDevice, self)._setName(value)
+        super(StorageDevice, self)._set_name(value)
 
         # update our format's path
         # First, check that self._format has been defined in case this is
@@ -199,7 +198,7 @@ def _setName(self, value):
         if hasattr(self, "_format") and self.format.device:
             self.format.device = self.path
 
-    def alignTargetSize(self, newsize):
+    def align_target_size(self, newsize):
         """ Return a proposed target size adjusted for device specifics.
 
             :param :class:`~.Size` newsize: the proposed/unaligned target size
@@ -209,29 +208,29 @@ def alignTargetSize(self, newsize):
 
         return newsize
 
-    def _getTargetSize(self):
-        return self._targetSize
+    def _get_target_size(self):
+        return self._target_size
 
-    def _setTargetSize(self, newsize):
+    def _set_target_size(self, newsize):
         if not isinstance(newsize, Size):
             raise ValueError("new size must of type Size")
 
-        if self.maxSize and newsize > self.maxSize:
+        if self.max_size and newsize > self.max_size:
             log.error("requested size %s is larger than maximum %s",
-                      newsize, self.maxSize)
+                      newsize, self.max_size)
             raise ValueError("size is larger than the maximum for this device")
-        elif self.minSize and newsize < self.minSize:
+        elif self.min_size and newsize < self.min_size:
             log.error("requested size %s is smaller than minimum %s",
-                      newsize, self.minSize)
+                      newsize, self.min_size)
             raise ValueError("size is smaller than the minimum for this device")
 
-        if self.alignTargetSize(newsize) != newsize:
+        if self.align_target_size(newsize) != newsize:
             raise ValueError("new size would violate alignment requirements")
 
-        self._targetSize = newsize
+        self._target_size = newsize
 
-    targetSize = property(lambda s: s._getTargetSize(),
-                          lambda s, v: s._setTargetSize(v),
+    target_size = property(lambda s: s._get_target_size(),
+                          lambda s, v: s._set_target_size(v),
                           doc="Target size of this device")
 
     def __repr__(self):
@@ -241,14 +240,14 @@ def __repr__(self):
               "  major = %(major)s  minor = %(minor)s  exists = %(exists)s"
               "  protected = %(protected)s\n"
               "  sysfs path = %(sysfs)s\n"
-              "  target size = %(targetSize)s  path = %(path)s\n"
-              "  format args = %(formatArgs)s  originalFormat = %(origFmt)s" %
+              "  target size = %(target_size)s  path = %(path)s\n"
+              "  format args = %(format_args)s  original_format = %(orig_fmt)s" %
               {"uuid": self.uuid, "format": self.format, "size": self.size,
                "major": self.major, "minor": self.minor, "exists": self.exists,
-               "sysfs": self.sysfsPath,
-               "targetSize": self.targetSize, "path": self.path,
+               "sysfs": self.sysfs_path,
+               "target_size": self.target_size, "path": self.path,
                "protected": self.protected,
-               "formatArgs": self.formatArgs, "origFmt": self.originalFormat.type})
+               "format_args": self.format_args, "orig_fmt": self.original_format.type})
         return s
 
     @property
@@ -257,16 +256,16 @@ def dict(self):
         d.update({"uuid": self.uuid, "size": self.size,
                   "format": self.format.dict, "removable": self.removable,
                   "major": self.major, "minor": self.minor,
-                  "exists": self.exists, "sysfs": self.sysfsPath,
-                  "targetSize": self.targetSize, "path": self.path})
+                  "exists": self.exists, "sysfs": self.sysfs_path,
+                  "target_size": self.target_size, "path": self.path})
         return d
 
     @property
     def path(self):
         """ Device node representing this device. """
-        return "%s/%s" % (self._devDir, self.name)
+        return "%s/%s" % (self._dev_dir, self.name)
 
-    def updateSysfsPath(self):
+    def update_sysfs_path(self):
         """ Update this device's sysfs path. """
         # We're using os.path.exists as a stand-in for status. We can't use
         # the status property directly because MDRaidArrayDevice.status calls
@@ -283,13 +282,13 @@ def updateSysfsPath(self):
         # any errors that are raised.
         except (pyudev.DeviceNotFoundError, EnvironmentError, ValueError, OSError) as e:
             log.error("failed to update sysfs path for %s: %s", self.name, e)
-            self.sysfsPath = ''
+            self.sysfs_path = ''
         else:
-            self.sysfsPath = udev_device.sys_path
-            log.debug("%s sysfsPath set to %s", self.name, self.sysfsPath)
+            self.sysfs_path = udev_device.sys_path
+            log.debug("%s sysfs_path set to %s", self.name, self.sysfs_path)
 
     @property
-    def formatArgs(self):
+    def format_args(self):
         """ Device-specific arguments to format creation program. """
         return []
 
@@ -300,7 +299,7 @@ def resizable(self):
                 (self.format.type is None or self.format.resizable or
                  not self.format.exists))
 
-    def notifyKernel(self):
+    def notify_kernel(self):
         """ Send a 'change' uevent to the kernel for this device. """
         log_method_call(self, self.name, status=self.status)
         if not self.exists:
@@ -311,21 +310,21 @@ def notifyKernel(self):
             log.debug("not sending change uevent for inactive device")
             return
 
-        path = os.path.normpath(self.sysfsPath)
+        path = os.path.normpath(self.sysfs_path)
         try:
             util.notify_kernel(path, action="change")
         except (ValueError, IOError) as e:
             log.warning("failed to notify kernel of change: %s", e)
 
     @property
-    def fstabSpec(self):
+    def fstab_spec(self):
         spec = self.path
         if self.format and self.format.uuid:
             spec = "UUID=%s" % self.format.uuid
         return spec
 
     def resize(self):
-        """ Resize a device to self.targetSize.
+        """ Resize a device to self.target_size.
 
             This method should only be invoked via the
             ActionResizeDevice.execute method. All the pre-conditions
@@ -358,7 +357,7 @@ def protected(self, value):
     #
     # setup
     #
-    def _preSetup(self, orig=False):
+    def _pre_setup(self, orig=False):
         """ Preparation and pre-condition checking for device setup.
 
             Return True if setup should proceed or False if not.
@@ -369,7 +368,7 @@ def _preSetup(self, orig=False):
         if self.status or not self.controllable:
             return False
 
-        self.setupParents(orig=orig)
+        self.setup_parents(orig=orig)
         return True
 
     def _setup(self, orig=False):
@@ -380,24 +379,24 @@ def setup(self, orig=False):
         """ Open, or set up, a device. """
         log_method_call(self, self.name, orig=orig, status=self.status,
                         controllable=self.controllable)
-        if not self._preSetup(orig=orig):
+        if not self._pre_setup(orig=orig):
             return
 
         self._setup(orig=orig)
-        self._postSetup()
+        self._post_setup()
 
-    def _postSetup(self):
+    def _post_setup(self):
         """ Perform post-setup operations. """
         udev.settle()
-        self.updateSysfsPath()
+        self.update_sysfs_path()
         # the device may not be set up when we want information about it
         if self._size == Size(0):
-            self.updateSize()
+            self.update_size()
 
     #
     # teardown
     #
-    def _preTeardown(self, recursive=None):
+    def _pre_teardown(self, recursive=None):
         """ Preparation and pre-condition checking for device teardown.
 
             Return True if teardown should proceed or False if not.
@@ -408,8 +407,8 @@ def _preTeardown(self, recursive=None):
         if not self.status or not self.controllable or self.protected:
             return False
 
-        if self.originalFormat.exists:
-            self.originalFormat.teardown()
+        if self.original_format.exists:
+            self.original_format.teardown()
         if self.format.exists:
             self.format.teardown()
         udev.settle()
@@ -423,28 +422,28 @@ def teardown(self, recursive=None):
         """ Close, or tear down, a device. """
         log_method_call(self, self.name, status=self.status,
                         controllable=self.controllable)
-        if not self._preTeardown(recursive=recursive):
+        if not self._pre_teardown(recursive=recursive):
             if recursive:
-                self.teardownParents(recursive=recursive)
+                self.teardown_parents(recursive=recursive)
             return
 
         self._teardown(recursive=recursive)
-        self._postTeardown(recursive=recursive)
+        self._post_teardown(recursive=recursive)
 
-    def _postTeardown(self, recursive=None):
+    def _post_teardown(self, recursive=None):
         """ Perform post-teardown operations. """
         if recursive:
-            self.teardownParents(recursive=recursive)
+            self.teardown_parents(recursive=recursive)
 
     #
     # create
     #
-    def _preCreate(self):
+    def _pre_create(self):
         """ Preparation and pre-condition checking for device creation. """
         if self.exists:
             raise errors.DeviceError("device has already been created", self.name)
 
-        self.setupParents()
+        self.setup_parents()
 
     def _create(self):
         """ Perform device-specific create operations. """
@@ -453,26 +452,26 @@ def _create(self):
     def create(self):
         """ Create the device. """
         log_method_call(self, self.name, status=self.status)
-        self._preCreate()
+        self._pre_create()
         self._create()
-        self._postCreate()
+        self._post_create()
 
-    def _postCreate(self):
+    def _post_create(self):
         """ Perform post-create operations. """
         self.exists = True
         self.setup()
-        self.updateSysfsPath()
+        self.update_sysfs_path()
         udev.settle()
 
-        # make sure that targetSize is updated to reflect the actual size
-        self.updateSize()
+        # make sure that target_size is updated to reflect the actual size
+        self.update_size()
 
-        self._updateNetDevMountOption()
+        self._update_netdev_mount_option()
 
     #
     # destroy
     #
-    def _preDestroy(self):
+    def _pre_destroy(self):
         """ Preparation and precondition checking for device destruction. """
         if not self.exists:
             raise errors.DeviceError("device has not been created", self.name)
@@ -489,24 +488,24 @@ def _destroy(self):
     def destroy(self):
         """ Destroy the device. """
         log_method_call(self, self.name, status=self.status)
-        self._preDestroy()
+        self._pre_destroy()
         self._destroy()
-        self._postDestroy()
+        self._post_destroy()
 
-    def _postDestroy(self):
+    def _post_destroy(self):
         """ Perform post-destruction operations. """
         self.exists = False
 
     #
     # parents' modifications/notifications
     #
-    def setupParents(self, orig=False):
+    def setup_parents(self, orig=False):
         """ Run setup method of all parent devices. """
         log_method_call(self, name=self.name, orig=orig, kids=self.kids)
         for parent in self.parents:
             parent.setup(orig=orig)
             if orig:
-                _format = parent.originalFormat
+                _format = parent.original_format
             else:
                 _format = parent.format
 
@@ -515,7 +514,7 @@ def setupParents(self, orig=False):
                 _format.setup()
 
     # pylint: disable=unused-argument
-    def removeHook(self, modparent=True):
+    def remove_hook(self, modparent=True):
         """ Perform actions related to removing a device from the devicetree.
 
             :keyword bool modparent: whether to account for removal in parents
@@ -527,9 +526,9 @@ def removeHook(self, modparent=True):
             override the default value of modparent in new code.
         """
         for parent in self.parents:
-            parent.removeChild()
+            parent.remove_child()
 
-    def addHook(self, new=True):
+    def add_hook(self, new=True):
         """ Perform actions related to adding a device to the devicetree.
 
             :keyword bool new: whether this device is new to the devicetree
@@ -540,20 +539,20 @@ def addHook(self, new=True):
         """
         if not new:
             for p in self.parents:
-                p.addChild()
+                p.add_child()
 
     #
     # size manipulations
     #
-    def _getSize(self):
+    def _get_size(self):
         """ Get the device's size, accounting for pending changes. """
         size = self._size
-        if self.exists and self.resizable and self.targetSize != Size(0):
-            size = self.targetSize
+        if self.exists and self.resizable and self.target_size != Size(0):
+            size = self.target_size
 
         return size
 
-    def _setSize(self, newsize):
+    def _set_size(self, newsize):
         """ Set the device's size to a new value.
 
             This is not adequate to set up a resize as it does not set a new
@@ -567,8 +566,8 @@ def _setSize(self, newsize):
         # to this setter for an existing device should be to reflect existing
         # state.
         if not self.exists:
-            max_size = self.format.maxSize
-            min_size = self.format.minSize
+            max_size = self.format.max_size
+            min_size = self.format.min_size
             if max_size and newsize > max_size:
                 raise errors.DeviceError("device cannot be larger than %s" %
                                          max_size, self.name)
@@ -578,57 +577,57 @@ def _setSize(self, newsize):
 
         self._size = newsize
 
-    size = property(lambda x: x._getSize(),
-                    lambda x, y: x._setSize(y),
+    size = property(lambda x: x._get_size(),
+                    lambda x, y: x._set_size(y),
                     doc="The device's size, accounting for pending changes")
 
-    def readCurrentSize(self):
+    def read_current_size(self):
         log_method_call(self, exists=self.exists, path=self.path,
-                        sysfsPath=self.sysfsPath)
+                        sysfs_path=self.sysfs_path)
         size = Size(0)
         if self.exists and os.path.exists(self.path) and \
-           os.path.isdir(self.sysfsPath):
-            blocks = int(util.get_sysfs_attr(self.sysfsPath, "size") or '0')
+           os.path.isdir(self.sysfs_path):
+            blocks = int(util.get_sysfs_attr(self.sysfs_path, "size") or '0')
             size = Size(blocks * LINUX_SECTOR_SIZE)
 
         return size
 
     @property
-    def currentSize(self):
+    def current_size(self):
         """ The device's actual size, generally the size discovered by using
             system tools. May use a cached value if the information is
             currently unavailable.
 
             If the device does not exist, then the actual size is 0.
         """
-        if self._currentSize == Size(0):
-            self._currentSize = self.readCurrentSize()
-        return self._currentSize
-
-    def updateSize(self):
-        """ Update size, currentSize, and targetSize to actual size. """
-        self._currentSize = Size(0)
-        new_size = self.currentSize
+        if self._current_size == Size(0):
+            self._current_size = self.read_current_size()
+        return self._current_size
+
+    def update_size(self):
+        """ Update size, current_size, and target_size to actual size. """
+        self._current_size = Size(0)
+        new_size = self.current_size
         self._size = new_size
-        self._targetSize = new_size # bypass setter checks
+        self._target_size = new_size # bypass setter checks
         log.debug("updated %s size to %s (%s)", self.name, self.size, new_size)
 
     @property
-    def minSize(self):
+    def min_size(self):
         """ The minimum size this device can be. """
-        return self.alignTargetSize(self.format.minSize) if self.resizable else self.currentSize
+        return self.align_target_size(self.format.min_size) if self.resizable else self.current_size
 
     @property
-    def maxSize(self):
+    def max_size(self):
         """ The maximum size this device can be. """
-        return self.alignTargetSize(self.format.maxSize) if self.resizable else self.currentSize
+        return self.align_target_size(self.format.max_size) if self.resizable else self.current_size
 
     @property
     def growable(self):
         """ True if this device or its component devices are growable. """
         return getattr(self, "req_grow", False) or any(p.growable for p in self.parents)
 
-    def checkSize(self):
+    def check_size(self):
         """ Check to make sure the size of the device is allowed by the
             format used.
 
@@ -637,9 +636,9 @@ def checkSize(self):
             1  - Too large
             -1 - Too small
         """
-        if self.format.maxSize and self.size > self.format.maxSize:
+        if self.format.max_size and self.size > self.format.max_size:
             return 1
-        elif self.format.minSize and self.size < self.format.minSize:
+        elif self.format.min_size and self.size < self.format.min_size:
             return -1
         return 0
 
@@ -647,7 +646,7 @@ def checkSize(self):
     # status
     #
     @property
-    def mediaPresent(self):
+    def media_present(self):
         """ True if this device contains usable media. """
         return True
 
@@ -666,7 +665,7 @@ def status(self):
     #
     # format manipulations
     #
-    def _setFormat(self, fmt):
+    def _set_format(self, fmt):
         """ Set the Device's format.
 
             :param fmt: the new format or None
@@ -680,12 +679,12 @@ def _setFormat(self, fmt):
                 :attr:`format` should always be an instance of
                 :class:`~.formats.DeviceFormat`. To ensure this continues to be
                 the case, all subclasses that define their own :attr:`format`
-                setter should call :meth:`StorageDevice._setFormat` from their
+                setter should call :meth:`StorageDevice._set_format` from their
                 setter.
 
         """
         if not fmt:
-            fmt = getFormat(None, device=self.path, exists=self.exists)
+            fmt = get_format(None, device=self.path, exists=self.exists)
 
         if not isinstance(fmt, DeviceFormat):
             raise ValueError("format must be a DeviceFormat instance")
@@ -698,16 +697,16 @@ def _setFormat(self, fmt):
 
         # check device size against format limits
         if not fmt.exists:
-            if fmt.maxSize and fmt.maxSize < self.size:
+            if fmt.max_size and fmt.max_size < self.size:
                 raise errors.DeviceError("device is too large for new format")
-            elif fmt.minSize and fmt.minSize > self.size:
+            elif fmt.min_size and fmt.min_size > self.size:
                 raise errors.DeviceError("device is too small for new format")
 
         self._format = fmt
         self._format.device = self.path
-        self._updateNetDevMountOption()
+        self._update_netdev_mount_option()
 
-    def _updateNetDevMountOption(self):
+    def _update_netdev_mount_option(self):
         """ Fix mount options to include or exclude _netdev as appropriate. """
         if not hasattr(self._format, "mountpoint"):
             return
@@ -724,7 +723,7 @@ def _updateNetDevMountOption(self):
             option_list.append(netdev_option)
             self._format.options = ",".join(option_list)
 
-    def _getFormat(self):
+    def _get_format(self):
         """ Get the device's format instance.
 
             :returns: this device's format instance
@@ -738,27 +737,27 @@ def _getFormat(self):
         """
         return self._format
 
-    format = property(lambda d: d._getFormat(),
-                      lambda d,f: d._setFormat(f),
+    format = property(lambda d: d._get_format(),
+                      lambda d,f: d._set_format(f),
                       doc="The device's formatting.")
 
-    def preCommitFixup(self):
+    def pre_commit_fixup(self):
         """ Do any necessary pre-commit fixups."""
         pass
 
     @property
-    def formatImmutable(self):
+    def format_immutable(self):
         """ Is it possible to execute format actions on this device? """
-        return self._formatImmutable or self.protected
+        return self._format_immutable or self.protected
 
     #
     # misc properties
     #
     @property
     def removable(self):
-        devpath = os.path.normpath(self.sysfsPath)
+        devpath = os.path.normpath(self.sysfs_path)
         remfile = os.path.normpath("%s/removable" % devpath)
-        return (self.sysfsPath and os.path.exists(devpath) and
+        return (self.sysfs_path and os.path.exists(devpath) and
                 os.access(remfile, os.R_OK) and
                 open(remfile).readline().strip() == "1")
 
@@ -768,8 +767,8 @@ def direct(self):
         return self.isleaf
 
     @property
-    def isDisk(self):
-        return self._isDisk
+    def is_disk(self):
+        return self._is_disk
 
     @property
     def partitionable(self):
@@ -791,9 +790,9 @@ def model(self):
     def vendor(self):
         return self._vendor
 
-    def populateKSData(self, data):
+    def populate_ksdata(self, data):
         # the common pieces are basically the formatting
-        self.format.populateKSData(data)
+        self.format.populate_ksdata(data)
 
         # this is a little bit of a hack for container member devices that
         # need aliases, but even more of a hack for btrfs since you cannot tell
@@ -806,7 +805,7 @@ def populateKSData(self, data):
             data.mountpoint += str(self.id)
 
     @classmethod
-    def isNameValid(cls, name):
+    def is_name_valid(cls, name):
         # This device corresponds to a file in /dev, so no /'s or nulls,
         # and the name cannot be . or ..
 
@@ -814,7 +813,7 @@ def isNameValid(cls, name):
         # is an imperfect world of joy and sorrow mingled. For cciss, split
         # the path into its components and do the real check on each piece
         if name.startswith("cciss/"):
-            return all(cls.isNameValid(n) for n in name.split('/'))
+            return all(cls.is_name_valid(n) for n in name.split('/'))
 
         badchars = any(c in ('\x00', '/') for c in name)
         return not(badchars or name == '.' or name == '..')
@@ -823,7 +822,7 @@ def isNameValid(cls, name):
     # dependencies
     #
     @classmethod
-    def typeExternalDependencies(cls):
+    def type_external_dependencies(cls):
         """ A list of external dependencies of this device type.
 
             :returns: a set of external dependencies
@@ -837,29 +836,29 @@ def typeExternalDependencies(cls):
         )
 
     @classmethod
-    def unavailableTypeDependencies(cls):
+    def unavailable_type_dependencies(cls):
         """ A set of unavailable dependencies for this type.
 
             :return: the unavailable external dependencies for this type
             :rtype: set of availability.ExternalResource
         """
-        return set(e for e in cls.typeExternalDependencies() if not e.available)
+        return set(e for e in cls.type_external_dependencies() if not e.available)
 
     @property
-    def externalDependencies(self):
+    def external_dependencies(self):
         """ A list of external dependencies of this device and its parents.
 
             :returns: the external dependencies of this device and all parents.
             :rtype: set of availability.ExternalResource
         """
-        return set(d for p in self.ancestors for d in p.typeExternalDependencies())
+        return set(d for p in self.ancestors for d in p.type_external_dependencies())
 
     @property
-    def unavailableDependencies(self):
+    def unavailable_dependencies(self):
         """ Any unavailable external dependencies of this device or its
             parents.
 
             :returns: A list of unavailable external dependencies.
-            :rtype: set of availability.externalResource
+            :rtype: set of availability.external_resource
         """
-        return set(e for e in self.externalDependencies if not e.available)
+        return set(e for e in self.external_dependencies if not e.available)
diff --git a/blivet/devicetree.py b/blivet/devicetree.py
index dbb0e76..ed3f00d 100644
--- a/blivet/devicetree.py
+++ b/blivet/devicetree.py
@@ -67,24 +67,24 @@ class DeviceTree(object):
         for leaf devices, except for resize actions.
     """
 
-    def __init__(self, conf=None, passphrase=None, luksDict=None,
+    def __init__(self, conf=None, passphrase=None, luks_dict=None,
                  iscsi=None, dasd=None):
         """
 
             :keyword conf: storage discovery configuration
             :type conf: :class:`~.StorageDiscoveryConfig`
             :keyword passphrase: default LUKS passphrase
-            :keyword luksDict: a dict with UUID keys and passphrase values
-            :type luksDict: dict
+            :keyword luks_dict: a dict with UUID keys and passphrase values
+            :type luks_dict: dict
             :keyword iscsi: ISCSI control object
             :type iscsi: :class:`~.iscsi.iscsi`
             :keyword dasd: DASD control object
             :type dasd: :class:`~.dasd.DASD`
 
         """
-        self.reset(conf, passphrase, luksDict, iscsi, dasd)
+        self.reset(conf, passphrase, luks_dict, iscsi, dasd)
 
-    def reset(self, conf=None, passphrase=None, luksDict=None,
+    def reset(self, conf=None, passphrase=None, luks_dict=None,
               iscsi=None, dasd=None):
         """ Reset the instance to its initial state. """
         # internal data members
@@ -97,16 +97,16 @@ def reset(self, conf=None, passphrase=None, luksDict=None,
         self._hidden = []
 
         # initialize attributes that may later hold cached lvm info
-        self.dropLVMCache()
+        self.drop_lvm_cache()
 
         lvm.lvm_cc_resetFilter()
 
-        self.eddDict = {}
+        self.edd_dict = {}
 
         self._populator = Populator(self,
                                     conf=conf,
                                     passphrase=passphrase,
-                                    luksDict=luksDict,
+                                    luks_dict=luks_dict,
                                     iscsi=iscsi,
                                     dasd=dasd)
 
@@ -114,8 +114,8 @@ def reset(self, conf=None, passphrase=None, luksDict=None,
     def actions(self):
         return self._actions
 
-    def setDiskImages(self, images):
-        """ Set the disk images and reflect them in exclusiveDisks.
+    def set_disk_images(self, images):
+        """ Set the disk images and reflect them in exclusive_disks.
 
             :param images: dict with image name keys and filename values
             :type images: dict
@@ -126,15 +126,15 @@ def setDiskImages(self, images):
                 presence of disk images, any local storage not associated with
                 the disk images is ignored.
         """
-        self._populator.setDiskImages(images)
+        self._populator.set_disk_images(images)
 
     @property
-    def exclusiveDisks(self):
-        return self._populator.exclusiveDisks
+    def exclusive_disks(self):
+        return self._populator.exclusive_disks
 
     @property
-    def ignoredDisks(self):
-        return self._populator.ignoredDisks
+    def ignored_disks(self):
+        return self._populator.ignored_disks
 
     @property
     def dasd(self):
@@ -145,15 +145,15 @@ def dasd(self, dasd):
         self._populator.dasd = dasd
 
     @property
-    def protectedDevNames(self):
-        return self._populator.protectedDevNames
+    def protected_dev_names(self):
+        return self._populator.protected_dev_names
 
     @property
-    def diskImages(self):
-        return self._populator.diskImages
+    def disk_images(self):
+        return self._populator.disk_images
 
     @property
-    def pvInfo(self):
+    def pv_info(self):
         if self._pvs_cache is None:
             pvs = blockdev.lvm.pvs()
             self._pvs_cache = dict((pv.pv_name, pv) for pv in pvs) # pylint: disable=attribute-defined-outside-init
@@ -161,19 +161,19 @@ def pvInfo(self):
         return self._pvs_cache
 
     @property
-    def lvInfo(self):
+    def lv_info(self):
         if self._lvs_cache is None:
             lvs = blockdev.lvm.lvs()
             self._lvs_cache = dict(("%s-%s" % (lv.vg_name, lv.lv_name), lv) for lv in lvs) # pylint: disable=attribute-defined-outside-init
 
         return self._lvs_cache
 
-    def dropLVMCache(self):
+    def drop_lvm_cache(self):
         """ Drop cached lvm information. """
         self._pvs_cache = None # pylint: disable=attribute-defined-outside-init
         self._lvs_cache = None # pylint: disable=attribute-defined-outside-init
 
-    def _addDevice(self, newdev, new=True):
+    def _add_device(self, newdev, new=True):
         """ Add a device to the tree.
 
             :param newdev: the device to add
@@ -191,7 +191,7 @@ def _addDevice(self, newdev, new=True):
             if parent not in self._devices:
                 raise DeviceTreeError("parent device not in tree")
 
-        newdev.addHook(new=new)
+        newdev.add_hook(new=new)
         self._devices.append(newdev)
 
         # don't include "req%d" partition names
@@ -204,7 +204,7 @@ def _addDevice(self, newdev, new=True):
                                                        newdev.name,
                                                        newdev.id)
 
-    def _removeDevice(self, dev, force=None, modparent=True):
+    def _remove_device(self, dev, force=None, modparent=True):
         """ Remove a device from the tree.
 
             :param dev: the device to remove
@@ -225,7 +225,7 @@ def _removeDevice(self, dev, force=None, modparent=True):
             log.debug("%s has %d kids", dev.name, dev.kids)
             raise ValueError("Cannot remove non-leaf device '%s'" % dev.name)
 
-        dev.removeHook(modparent=modparent)
+        dev.remove_hook(modparent=modparent)
         if modparent:
             # if this is a partition we need to remove it from the parted.Disk
             if isinstance(dev, PartitionDevice) and dev.disk is not None:
@@ -235,7 +235,7 @@ def _removeDevice(self, dev, force=None, modparent=True):
                 for device in self._devices:
                     if isinstance(device, PartitionDevice) and \
                        device.disk == dev.disk:
-                        device.updateName()
+                        device.update_name()
 
         self._devices.remove(dev)
         if dev.name in self.names and getattr(dev, "complete", True):
@@ -244,7 +244,7 @@ def _removeDevice(self, dev, force=None, modparent=True):
                                                            dev.name,
                                                            dev.id)
 
-    def recursiveRemove(self, device, actions=True):
+    def recursive_remove(self, device, actions=True):
         """ Remove a device after removing its dependent devices.
 
             :param :class:`~.devices.StorageDevice` device: the device to remove
@@ -257,7 +257,7 @@ def recursiveRemove(self, device, actions=True):
             disk device.
         """
         log.debug("removing %s", device.name)
-        devices = self.getDependentDevices(device)
+        devices = self.get_dependent_devices(device)
 
         # this isn't strictly necessary, but it makes the action list easier to
         # read when removing logical partitions because of the automatic
@@ -272,30 +272,30 @@ def recursiveRemove(self, device, actions=True):
             for leaf in leaves:
                 if actions:
                     if leaf.format.exists and not leaf.protected and \
-                       not leaf.formatImmutable:
-                        self.registerAction(ActionDestroyFormat(leaf))
+                       not leaf.format_immutable:
+                        self.register_action(ActionDestroyFormat(leaf))
 
-                    self.registerAction(ActionDestroyDevice(leaf))
+                    self.register_action(ActionDestroyDevice(leaf))
                 else:
-                    if not leaf.formatImmutable:
+                    if not leaf.format_immutable:
                         leaf.format = None
-                    self._removeDevice(leaf)
+                    self._remove_device(leaf)
 
                 devices.remove(leaf)
 
-        if not device.formatImmutable:
+        if not device.format_immutable:
             if actions:
-                self.registerAction(ActionDestroyFormat(device))
+                self.register_action(ActionDestroyFormat(device))
             else:
                 device.format = None
 
-        if not device.isDisk:
+        if not device.is_disk:
             if actions:
-                self.registerAction(ActionDestroyDevice(device))
+                self.register_action(ActionDestroyDevice(device))
             else:
-                self._removeDevice(device)
+                self._remove_device(device)
 
-    def registerAction(self, action):
+    def register_action(self, action):
         """ Register an action to be performed at a later time.
 
             :param action: the action
@@ -304,18 +304,18 @@ def registerAction(self, action):
             Modifications to the Device instance are handled before we
             get here.
         """
-        if not (action.isCreate and action.isDevice) and \
+        if not (action.is_create and action.is_device) and \
            action.device not in self._devices:
             raise DeviceTreeError("device is not in the tree")
-        elif (action.isCreate and action.isDevice):
+        elif (action.is_create and action.is_device):
             if action.device in self._devices:
                 raise DeviceTreeError("device is already in the tree")
 
-        if action.isCreate and action.isDevice:
-            self._addDevice(action.device)
-        elif action.isDestroy and action.isDevice:
-            self._removeDevice(action.device)
-        elif action.isCreate and action.isFormat:
+        if action.is_create and action.is_device:
+            self._add_device(action.device)
+        elif action.is_destroy and action.is_device:
+            self._remove_device(action.device)
+        elif action.is_create and action.is_format:
             if isinstance(action.device.format, formats.fs.FS) and \
                action.device.format.mountpoint in self.filesystems:
                 raise DeviceTreeError("mountpoint already in use")
@@ -325,7 +325,7 @@ def registerAction(self, action):
         log.info("registered action: %s", action)
         self._actions.append(action)
 
-    def cancelAction(self, action):
+    def cancel_action(self, action):
         """ Cancel a registered action.
 
             :param action: the action
@@ -337,18 +337,18 @@ def cancelAction(self, action):
             Actions all operate on a Device, so we can use the devices
             to determine dependencies.
         """
-        if action.isCreate and action.isDevice:
+        if action.is_create and action.is_device:
             # remove the device from the tree
-            self._removeDevice(action.device)
-        elif action.isDestroy and action.isDevice:
+            self._remove_device(action.device)
+        elif action.is_destroy and action.is_device:
             # add the device back into the tree
-            self._addDevice(action.device, new=False)
+            self._add_device(action.device, new=False)
 
         action.cancel()
         self._actions.remove(action)
         log.info("canceled action %s", action)
 
-    def findActions(self, device=None, action_type=None, object_type=None,
+    def find_actions(self, device=None, action_type=None, object_type=None,
                     path=None, devid=None):
         """ Find all actions that match all specified parameters.
 
@@ -375,12 +375,12 @@ def findActions(self, device=None, action_type=None, object_type=None,
                                   path=path,
                                   devid=devid)
 
-    def processActions(self, callbacks=None, dryRun=False):
+    def process_actions(self, callbacks=None, dry_run=False):
         self.actions.process(devices=self.devices,
-                             dryRun=dryRun,
+                             dry_run=dry_run,
                              callbacks=callbacks)
 
-    def getDependentDevices(self, dep, hidden=False):
+    def get_dependent_devices(self, dep, hidden=False):
         """ Return a list of devices that depend on dep.
 
             The list includes both direct and indirect dependents.
@@ -404,12 +404,12 @@ def getDependentDevices(self, dep, hidden=False):
 
         for device in devices:
             log.debug("checking if %s depends on %s", device.name, dep.name)
-            if device.dependsOn(dep):
+            if device.depends_on(dep):
                 dependents.append(device)
 
         return dependents
 
-    def getRelatedDisks(self, disk):
+    def get_related_disks(self, disk):
         """ Return disks related to disk by container membership.
 
             :param :class:`~.devices.StorageDevice` disk: the disk
@@ -421,7 +421,7 @@ def getRelatedDisks(self, disk):
                 The disk may be hidden.
 
         """
-        return set(d for dep in self.getDependentDevices(disk, hidden=True)
+        return set(d for dep in self.get_dependent_devices(disk, hidden=True)
                         for d in dep.disks)
 
     def hide(self, device):
@@ -444,7 +444,7 @@ def hide(self, device):
             in every case except the first base case that is reached,
             where all actions are removed. This means that when a device
             is removed explicitly in this function by means of a direct call to
-            _removeDevices it is guaranteed that all actions have already
+            _remove_devices it is guaranteed that all actions have already
             been canceled.
 
             If a device does not exist then it must have been removed by the
@@ -453,23 +453,23 @@ def hide(self, device):
 
             Most devices are considered leaf devices if they have no children,
             however, some devices must satisfy more stringent requirements.
-            _removeDevice() will raise an exception if the device it is
+            _remove_device() will raise an exception if the device it is
             removing is not a leaf device. hide() guarantees that any
             device that it removes will have no children, but it does not
             guarantee that the more stringent requirements will be enforced.
-            Therefore, _removeDevice() is invoked with the force parameter
+            Therefore, _remove_device() is invoked with the force parameter
             set to True, to skip the isleaf check.
         """
         if device in self._hidden:
             return
 
         # cancel actions first thing so that we hide the correct set of devices
-        if device.isDisk:
+        if device.is_disk:
             # Cancel all actions on this disk and any disk related by way of an
             # aggregate/container device (eg: lvm volume group).
             disks = [device]
             related_actions = [a for a in self._actions
-                                    if a.device.dependsOn(device)]
+                                    if a.device.depends_on(device)]
             for related_device in (a.device for a in related_actions):
                 disks.extend(related_device.disks)
 
@@ -477,9 +477,9 @@ def hide(self, device):
             cancel = [a for a in self._actions
                             if set(a.device.disks).intersection(disks)]
             for action in reversed(cancel):
-                self.cancelAction(action)
+                self.cancel_action(action)
 
-        for d in self.getChildren(device):
+        for d in self.get_children(device):
             self.hide(d)
 
         log.info("hiding device %s", device)
@@ -487,7 +487,7 @@ def hide(self, device):
         if not device.exists:
             return
 
-        self._removeDevice(device, force=True, modparent=False)
+        self._remove_device(device, force=True, modparent=False)
 
         self._hidden.append(device)
         lvm.lvm_cc_addFilterRejectRegexp(device.name)
@@ -513,7 +513,7 @@ def unhide(self, device):
 
         # the hidden list should be in leaves-first order
         for hidden in reversed(self._hidden):
-            if hidden == device or hidden.dependsOn(device) and \
+            if hidden == device or hidden.depends_on(device) and \
                not any(parent in self._hidden for parent in hidden.parents):
 
                 log.info("unhiding device %s %s (id %d)", hidden.type,
@@ -521,25 +521,25 @@ def unhide(self, device):
                                                           hidden.id)
                 self._hidden.remove(hidden)
                 self._devices.append(hidden)
-                hidden.addHook(new=False)
+                hidden.add_hook(new=False)
                 lvm.lvm_cc_removeFilterRejectRegexp(hidden.name)
                 if isinstance(device, DASDDevice):
                     self.dasd.append(device)
 
-    def setupDiskImages(self):
+    def setup_disk_images(self):
         """ Set up devices to represent the disk image files. """
-        self._populator.setupDiskImages()
+        self._populator.setup_disk_images()
 
-    def updateDeviceFormat(self, device):
-        return self._populator.updateDeviceFormat(device)
+    def update_device_format(self, device):
+        return self._populator.update_device_format(device)
 
-    def pruneActions(self):
+    def prune_actions(self):
         return self._actions.prune()
 
-    def sortActions(self):
+    def sort_actions(self):
         return self._actions.sort()
 
-    def populate(self, cleanupOnly=False):
+    def populate(self, cleanup_only=False):
         """ Locate all storage devices.
 
             Everything should already be active. We just go through and gather
@@ -550,38 +550,38 @@ def populate(self, cleanupOnly=False):
             process.
         """
         udev.settle()
-        self.dropLVMCache()
+        self.drop_lvm_cache()
         try:
-            self._populator.populate(cleanupOnly=cleanupOnly)
+            self._populator.populate(cleanup_only=cleanup_only)
         except Exception:
             raise
         finally:
-            self._hideIgnoredDisks()
+            self._hide_ignored_disks()
 
         if flags.installer_mode:
-            self.teardownAll()
+            self.teardown_all()
 
-    def _isIgnoredDisk(self, disk):
-        return ((self.ignoredDisks and disk.name in self.ignoredDisks) or
-                (self.exclusiveDisks and
-                 disk.name not in self.exclusiveDisks))
+    def _is_ignored_disk(self, disk):
+        return ((self.ignored_disks and disk.name in self.ignored_disks) or
+                (self.exclusive_disks and
+                 disk.name not in self.exclusive_disks))
 
-    def _hideIgnoredDisks(self):
+    def _hide_ignored_disks(self):
         # hide any subtrees that begin with an ignored disk
-        for disk in [d for d in self._devices if d.isDisk]:
-            if self._isIgnoredDisk(disk):
+        for disk in [d for d in self._devices if d.is_disk]:
+            if self._is_ignored_disk(disk):
                 ignored = True
                 # If the filter allows all members of a fwraid or mpath, the
                 # fwraid or mpath itself is implicitly allowed as well. I don't
                 # like this very much but we have supported this usage in the
                 # past, so I guess we will support it forever.
                 if disk.parents and all(p.format.hidden for p in disk.parents):
-                    ignored = any(self._isIgnoredDisk(d) for d in disk.parents)
+                    ignored = any(self._is_ignored_disk(d) for d in disk.parents)
 
                 if ignored:
                     self.hide(disk)
 
-    def teardownAll(self):
+    def teardown_all(self):
         """ Run teardown methods on all devices. """
         for device in self.leaves:
             if device.protected:
@@ -592,11 +592,11 @@ def teardownAll(self):
             except (StorageError, blockdev.BlockDevError) as e:
                 log.info("teardown of %s failed: %s", device.name, e)
 
-    def teardownDiskImages(self):
+    def teardown_disk_images(self):
         """ Tear down any disk image stacks. """
-        self._populator.teardownDiskImages()
+        self._populator.teardown_disk_images()
 
-    def setupAll(self):
+    def setup_all(self):
         """ Run setup methods on all devices. """
         for device in self.leaves:
             try:
@@ -604,7 +604,7 @@ def setupAll(self):
             except DeviceError as e:
                 log.error("setup of %s failed: %s", device.name, e)
 
-    def _filterDevices(self, incomplete=False, hidden=False):
+    def _filter_devices(self, incomplete=False, hidden=False):
         """ Return list of devices modified according to parameters.
 
             :param bool incomplete: include incomplete devices in result
@@ -630,7 +630,7 @@ def make_dasd_list(self, dasds, disks):
             :returns: a list of DASD devices identified on the system
             :rtype: list of :class:
         """
-        if not arch.isS390():
+        if not arch.is_s390():
             return
 
         log.info("Generating DASD list....")
@@ -647,7 +647,7 @@ def make_unformatted_dasd_list(self, dasds):
             :returns: a list of DASDs which need dasdfmt in order to be used
             :rtype: list of :class:
         """
-        if not arch.isS390():
+        if not arch.is_s390():
             return
 
         unformatted = []
@@ -658,7 +658,7 @@ def make_unformatted_dasd_list(self, dasds):
 
         return unformatted
 
-    def getDeviceBySysfsPath(self, path, incomplete=False, hidden=False):
+    def get_device_by_sysfs_path(self, path, incomplete=False, hidden=False):
         """ Return a list of devices with a matching sysfs path.
 
             :param str path: the sysfs path to match
@@ -670,12 +670,12 @@ def getDeviceBySysfsPath(self, path, incomplete=False, hidden=False):
         log_method_call(self, path=path, incomplete=incomplete, hidden=hidden)
         result = None
         if path:
-            devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
-            result = next((d for d in devices if d.sysfsPath == path), None)
+            devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
+            result = next((d for d in devices if d.sysfs_path == path), None)
         log_method_return(self, result)
         return result
 
-    def getDeviceByUuid(self, uuid, incomplete=False, hidden=False):
+    def get_device_by_uuid(self, uuid, incomplete=False, hidden=False):
         """ Return a list of devices with a matching UUID.
 
             :param str uuid: the UUID to match
@@ -687,13 +687,13 @@ def getDeviceByUuid(self, uuid, incomplete=False, hidden=False):
         log_method_call(self, uuid=uuid, incomplete=incomplete, hidden=hidden)
         result = None
         if uuid:
-            devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+            devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
             result = next((d for d in devices if d.uuid == uuid or d.format.uuid == uuid), None)
         log_method_return(self, result)
         return result
 
     @util.deprecated('1.7', '')
-    def getDevicesBySerial(self, serial, incomplete=False, hidden=False):
+    def get_devices_by_serial(self, serial, incomplete=False, hidden=False):
         """ Return a list of devices with a matching serial.
 
             :param str serial: the serial to match
@@ -703,7 +703,7 @@ def getDevicesBySerial(self, serial, incomplete=False, hidden=False):
             :rtype: list of :class:`~.devices.Device`
         """
         log_method_call(self, serial=serial, incomplete=incomplete, hidden=hidden)
-        devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+        devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
         retval = []
         for device in devices:
             if not hasattr(device, "serial"):
@@ -714,7 +714,7 @@ def getDevicesBySerial(self, serial, incomplete=False, hidden=False):
         log_method_return(self, [r.name for r in retval])
         return retval
 
-    def getDeviceByLabel(self, label, incomplete=False, hidden=False):
+    def get_device_by_label(self, label, incomplete=False, hidden=False):
         """ Return a device with a matching filesystem label.
 
             :param str label: the filesystem label to match
@@ -726,12 +726,12 @@ def getDeviceByLabel(self, label, incomplete=False, hidden=False):
         log_method_call(self, label=label, incomplete=incomplete, hidden=hidden)
         result = None
         if label:
-            devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+            devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
             result = next((d for d in devices if getattr(d.format, "label", None) == label), None)
         log_method_return(self, result)
         return result
 
-    def getDeviceByName(self, name, incomplete=False, hidden=False):
+    def get_device_by_name(self, name, incomplete=False, hidden=False):
         """ Return a device with a matching name.
 
             :param str name: the name to look for
@@ -743,14 +743,14 @@ def getDeviceByName(self, name, incomplete=False, hidden=False):
         log_method_call(self, name=name, incomplete=incomplete, hidden=hidden)
         result = None
         if name:
-            devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+            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)
         log_method_return(self, result)
         return result
 
-    def getDeviceByPath(self, path, incomplete=False, hidden=False):
+    def get_device_by_path(self, path, incomplete=False, hidden=False):
         """ Return a device with a matching path.
 
             If there is more than one device with a matching path,
@@ -765,7 +765,7 @@ def getDeviceByPath(self, path, incomplete=False, hidden=False):
         log_method_call(self, path=path, incomplete=incomplete, hidden=hidden)
         result = None
         if path:
-            devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+            devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
 
             # The usual order of the devices list is one where leaves are at
             # the end. So that the search can prefer leaves to interior nodes
@@ -778,7 +778,7 @@ def getDeviceByPath(self, path, incomplete=False, hidden=False):
         return result
 
     @util.deprecated('1.7', '')
-    def getDevicesByType(self, device_type, incomplete=False, hidden=False):
+    def get_devices_by_type(self, device_type, incomplete=False, hidden=False):
         """ Return a list of devices with a matching device type.
 
             :param str device_type: the type to match
@@ -788,13 +788,13 @@ def getDevicesByType(self, device_type, incomplete=False, hidden=False):
             :rtype: list of :class:`~.devices.Device`
         """
         log_method_call(self, device_type=device_type, incomplete=incomplete, hidden=hidden)
-        devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+        devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
         result = [d for d in devices if d.type == device_type]
         log_method_return(self, [r.name for r in result])
         return result
 
     @util.deprecated('1.7', '')
-    def getDevicesByInstance(self, device_class, incomplete=False, hidden=False):
+    def get_devices_by_instance(self, device_class, incomplete=False, hidden=False):
         """ Return a list of devices with a matching device class.
 
             :param class device_class: the device class to match
@@ -804,12 +804,12 @@ def getDevicesByInstance(self, device_class, incomplete=False, hidden=False):
             :rtype: list of :class:`~.devices.Device`
         """
         log_method_call(self, device_class=device_class, incomplete=incomplete, hidden=hidden)
-        devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+        devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
         result = [d for d in devices if isinstance(d, device_class)]
         log_method_return(self, [r.name for r in result])
         return result
 
-    def getDeviceByID(self, id_num, incomplete=False, hidden=False):
+    def get_device_by_id(self, id_num, incomplete=False, hidden=False):
         """ Return a device with specified device id.
 
             :param int id_num: the id to look for
@@ -819,7 +819,7 @@ def getDeviceByID(self, id_num, incomplete=False, hidden=False):
             :rtype: :class:`~.devices.Device`
         """
         log_method_call(self, id_num=id_num, incomplete=incomplete, hidden=hidden)
-        devices = self._filterDevices(incomplete=incomplete, hidden=hidden)
+        devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
         result = next((d for d in devices if d.id == id_num), None)
         log_method_return(self, result)
         return result
@@ -895,11 +895,11 @@ def leaves(self):
         leaves = [d for d in self._devices if d.isleaf]
         return leaves
 
-    def getChildren(self, device):
+    def get_children(self, device):
         """ Return a list of a device's children. """
         return [c for c in self._devices if device in c.parents]
 
-    def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
+    def resolve_device(self, devspec, blkid_tab=None, crypt_tab=None, options=None):
         """ Return the device matching the provided device specification.
 
             The spec can be anything from a device name (eg: 'sda3') to a device
@@ -908,10 +908,10 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
 
             :param devspec: a string describing a block device
             :type devspec: str
-            :keyword blkidTab: blkid info
-            :type blkidTab: :class:`~.BlkidTab`
-            :keyword cryptTab: crypto info
-            :type cryptTab: :class:`~.CryptTab`
+            :keyword blkid_tab: blkid info
+            :type blkid_tab: :class:`~.BlkidTab`
+            :keyword crypt_tab: crypto info
+            :type crypt_tab: :class:`~.CryptTab`
             :keyword options: mount options
             :type options: str
             :returns: the device
@@ -937,17 +937,17 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
             # BIOS drive number
             (drive, _p, partnum) = devspec.partition("p")
             spec = int(drive, 16)
-            for (edd_name, edd_number) in self.eddDict.items():
+            for (edd_name, edd_number) in self.edd_dict.items():
                 if edd_number == spec:
-                    device = self.getDeviceByName(edd_name + partnum)
+                    device = self.get_device_by_name(edd_name + partnum)
                     break
         elif options and "nodev" in options.split(","):
-            device = self.getDeviceByName(devspec)
+            device = self.get_device_by_name(devspec)
             if not device:
-                device = self.getDeviceByPath(devspec)
+                device = self.get_device_by_path(devspec)
         else:
             if not devspec.startswith("/dev/"):
-                device = self.getDeviceByName(devspec)
+                device = self.get_device_by_name(devspec)
                 if not device:
                     devspec = "/dev/" + devspec
 
@@ -976,18 +976,18 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
                         devspec = "/dev/md/" + md_name
 
                 # device path
-                device = self.getDeviceByPath(devspec)
+                device = self.get_device_by_path(devspec)
 
             if device is None:
-                if blkidTab:
+                if blkid_tab:
                     # try to use the blkid.tab to correlate the device
                     # path with a UUID
-                    blkidTabEnt = blkidTab.get(devspec)
-                    if blkidTabEnt:
+                    blkid_tab_ent = blkid_tab.get(devspec)
+                    if blkid_tab_ent:
                         log.debug("found blkid.tab entry for '%s'", devspec)
-                        uuid = blkidTabEnt.get("UUID")
+                        uuid = blkid_tab_ent.get("UUID")
                         if uuid:
-                            device = self.getDeviceByUuid(uuid)
+                            device = self.get_device_by_uuid(uuid)
                             if device:
                                 devstr = device.name
                             else:
@@ -995,22 +995,22 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
                             log.debug("found device '%s' in tree", devstr)
                         if device and device.format and \
                            device.format.type == "luks":
-                            map_name = device.format.mapName
+                            map_name = device.format.map_name
                             log.debug("luks device; map name is '%s'", map_name)
-                            mapped_dev = self.getDeviceByName(map_name)
+                            mapped_dev = self.get_device_by_name(map_name)
                             if mapped_dev:
                                 device = mapped_dev
 
-                if device is None and cryptTab and \
+                if device is None and crypt_tab and \
                    devspec.startswith("/dev/mapper/"):
                     # try to use a dm-crypt mapping name to
                     # obtain the underlying device, possibly
                     # using blkid.tab
-                    cryptTabEnt = cryptTab.get(devspec.split("/")[-1])
-                    if cryptTabEnt:
-                        luks_dev = cryptTabEnt['device']
+                    crypt_tab_ent = crypt_tab.get(devspec.split("/")[-1])
+                    if crypt_tab_ent:
+                        luks_dev = crypt_tab_ent['device']
                         try:
-                            device = self.getChildren(luks_dev)[0]
+                            device = self.get_children(luks_dev)[0]
                         except IndexError as e:
                             pass
                 elif device is None:
@@ -1023,7 +1023,7 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
                     if lv_name and not "/" in lv_name:
                         # looks like we may have one
                         lv = "%s-%s" % (vg_name, lv_name)
-                        device = self.getDeviceByName(lv)
+                        device = self.get_device_by_name(lv)
 
         # check mount options for btrfs volumes in case it's a subvol
         if device and device.type.startswith("btrfs") and options:
@@ -1037,9 +1037,9 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
             elif "subvolid=" in options:
                 attr = "vol_id"
                 val = util.get_option_value("subvolid", options)
-            elif device.defaultSubVolume:
+            elif device.default_subvolume:
                 # default subvolume
-                device = device.defaultSubVolume
+                device = device.default_subvolume
 
             if attr and val:
                 for subvol in device.subvolumes:
@@ -1053,7 +1053,7 @@ def resolveDevice(self, devspec, blkidTab=None, cryptTab=None, options=None):
             log.debug("failed to resolve '%s'", devspec)
         return device
 
-    def handleNodevFilesystems(self):
+    def handle_nodev_filesystems(self):
         for line in open("/proc/mounts").readlines():
             try:
                 (_devspec, mountpoint, fstype, _options, _rest) = line.split(None, 4)
@@ -1072,7 +1072,7 @@ def handleNodevFilesystems(self):
                 # of nodev filesystem. Based on that idea, we just instantiate
                 # NoDevFS directly and then hack in the fstype as the device
                 # attribute.
-                fmt = formats.getFormat("nodev")
+                fmt = formats.get_format("nodev")
                 fmt.device = fstype
 
                 # NoDevice also needs some special works since they don't have
@@ -1080,12 +1080,12 @@ def handleNodevFilesystems(self):
                 device = NoDevice(fmt=fmt)
                 n = len([d for d in self.devices if d.format.type == fstype])
                 device._name += ".%d" % n
-                self._addDevice(device)
+                self._add_device(device)
 
-    def saveLUKSpassphrase(self, device):
+    def save_luks_passphrase(self, device):
         """ Save a device's LUKS passphrase in case of reset. """
 
-        self._populator.saveLUKSpassphrase(device)
+        self._populator.save_luks_passphrase(device)
 
     def __str__(self):
         done = []
@@ -1096,7 +1096,7 @@ def show_subtree(root, depth):
             if abbreviate_subtree:
                 s += "%s...\n" % ("  " * (depth+1),)
             else:
-                for child in self.getChildren(root):
+                for child in self.get_children(root):
                     s += show_subtree(child, depth + 1)
             return s
 
diff --git a/blivet/fcoe.py b/blivet/fcoe.py
index 861e412..4862723 100644
--- a/blivet/fcoe.py
+++ b/blivet/fcoe.py
@@ -44,7 +44,7 @@ class fcoe(object):
 
         This class will automatically discover and connect to EDD configured
         FCoE SAN's when the startup() method gets called. It can also be
-        used to manually configure FCoE SAN's through the addSan() method.
+        used to manually configure FCoE SAN's through the add_san() method.
 
         As this class needs to make sure certain things like starting fcoe
         daemons and connecting to firmware discovered SAN's only happens once
@@ -54,7 +54,7 @@ class fcoe(object):
 
     def __init__(self):
         self.started = False
-        self.lldpadStarted = False
+        self.lldpad_started = False
         self.nics = []
         self.added_nics = []
 
@@ -67,7 +67,7 @@ def _stabilize(self):
         time.sleep(10)
         udev.settle()
 
-    def _startEDD(self):
+    def _start_edd(self):
         try:
             buf = util.capture_output(["/usr/libexec/fcoe/fcoe_edd.sh", "-i"])
         except OSError as e:
@@ -80,7 +80,7 @@ def _startEDD(self):
             return
 
         log.info("FCoE NIC found in EDD: %s", val)
-        self.addSan(val, dcb=True, auto_vlan=True)
+        self.add_san(val, dcb=True, auto_vlan=True)
 
     def startup(self):
         if self.started:
@@ -89,17 +89,17 @@ def startup(self):
         if not has_fcoe():
             return
 
-        self._startEDD()
+        self._start_edd()
         self.started = True
 
-    def _startLldpad(self):
-        if self.lldpadStarted:
+    def _start_lldpad(self):
+        if self.lldpad_started:
             return
 
         util.run_program(["lldpad", "-d"])
-        self.lldpadStarted = True
+        self.lldpad_started = True
 
-    def addSan(self, nic, dcb=False, auto_vlan=True):
+    def add_san(self, nic, dcb=False, auto_vlan=True):
         """Activates FCoE SANs attached to interface specified by nic.
 
            Returns error message, or empty string if succeeded.
@@ -115,7 +115,7 @@ def addSan(self, nic, dcb=False, auto_vlan=True):
         rc = 0
         error_msg = ""
         if dcb:
-            self._startLldpad()
+            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"])
diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py
index 4751d88..8c238ed 100644
--- a/blivet/formats/__init__.py
+++ b/blivet/formats/__init__.py
@@ -64,7 +64,7 @@ def get_default_filesystem_type():
 
     raise DeviceFormatError("None of %s is supported by your kernel" % ",".join(default_fstypes))
 
-def getFormat(fmt_type, *args, **kwargs):
+def get_format(fmt_type, *args, **kwargs):
     """ Return an instance of the appropriate DeviceFormat class.
 
         :param fmt_type: The name of the formatting type
@@ -135,7 +135,7 @@ def get_device_format_class(fmt_type):
             if fmt_type and fmt_type == fmt_class._name:
                 fmt = fmt_class
                 break
-            elif fmt_type in fmt_class._udevTypes:
+            elif fmt_type in fmt_class._udev_types:
                 fmt = fmt_class
                 break
 
@@ -150,20 +150,20 @@ class DeviceFormat(ObjectID):
     """
     _type = None
     _name = N_("Unknown")
-    _udevTypes = []
-    partedFlag = None
-    partedSystem = None
+    _udev_types = []
+    parted_flag = None
+    parted_system = None
     _formattable = False                # can be formatted
     _supported = False                  # is supported
-    _linuxNative = False                # for clearpart
+    _linux_native = False                # for clearpart
     _packages = []                      # required packages
     _resizable = False                  # can be resized
-    _maxSize = Size(0)                  # maximum size
-    _minSize = Size(0)                  # minimum size
+    _max_size = Size(0)                  # maximum size
+    _min_size = Size(0)                  # minimum size
     _dump = False
     _check = False
     _hidden = False                     # hide devices with this formatting?
-    _ksMountpoint = None
+    _ks_mountpoint = None
 
     def __init__(self, **kwargs):
         """
@@ -191,14 +191,14 @@ def __init__(self, **kwargs):
         self.uuid = kwargs.get("uuid")
         self.exists = kwargs.get("exists", False)
         self.options = kwargs.get("options")
-        self._createOptions = kwargs.get("createOptions")
+        self._create_options = kwargs.get("create_options")
 
     def __repr__(self):
         s = ("%(classname)s instance (%(id)s) object id %(object_id)d--\n"
              "  type = %(type)s  name = %(name)s  status = %(status)s\n"
              "  device = %(device)s  uuid = %(uuid)s  exists = %(exists)s\n"
              "  options = %(options)s\n"
-             "  createOptions = %(createOptions)s  supported = %(supported)s"
+             "  create_options = %(create_options)s  supported = %(supported)s"
              "  formattable = %(format)s  resizable = %(resize)s\n" %
              {"classname": self.__class__.__name__, "id": "%#x" % id(self),
               "object_id": self.id,
@@ -206,7 +206,7 @@ def __repr__(self):
               "device": self.device, "uuid": self.uuid, "exists": self.exists,
               "options": self.options, "supported": self.supported,
               "format": self.formattable, "resize": self.resizable,
-              "createOptions": self.createOptions})
+              "create_options": self.create_options})
         return s
 
     @property
@@ -225,14 +225,15 @@ def dict(self):
         d = {"type": self.type, "name": self.name, "device": self.device,
              "uuid": self.uuid, "exists": self.exists,
              "options": self.options, "supported": self.supported,
-             "resizable": self.resizable, "createOptions": self.createOptions}
+             "resizable": self.resizable, "create_options": self.create_options}
+
         return d
 
     def labeling(self):
         """Returns False by default since most formats are non-labeling."""
         return False
 
-    def labelFormatOK(self, label):
+    def label_format_ok(self, label):
         """Checks whether the format of the label is OK for whatever
            application is used by blivet to write a label for this format.
            If there is no application that blivet uses to write a label,
@@ -246,7 +247,7 @@ def labelFormatOK(self, label):
         # pylint: disable=unused-argument
         return self.labeling()
 
-    def _setLabel(self, label):
+    def _set_label(self, label):
         """Sets the label for this format.
 
            :param label: the label for this format
@@ -275,7 +276,7 @@ def _setLabel(self, label):
         """
         self._label = label
 
-    def _getLabel(self):
+    def _get_label(self):
         """The label for this filesystem.
 
            :return: the label for this device
@@ -285,31 +286,31 @@ def _getLabel(self):
         """
         return self._label
 
-    def _setOptions(self, options):
+    def _set_options(self, options):
         self._options = options
 
-    def _getOptions(self):
+    def _get_options(self):
         return self._options
 
     options = property(
-       lambda s: s._getOptions(),
-       lambda s,v: s._setOptions(v),
+       lambda s: s._get_options(),
+       lambda s,v: s._set_options(v),
        doc="fstab entry option string"
     )
 
-    def _setCreateOptions(self, options):
-        self._createOptions = options
+    def _set_create_options(self, options):
+        self._create_options = options
 
-    def _getCreateOptions(self):
-        return self._createOptions
+    def _get_create_options(self):
+        return self._create_options
 
-    createOptions = property(
-        lambda s: s._getCreateOptions(),
-        lambda s,v: s._setCreateOptions(v),
+    create_options = property(
+        lambda s: s._get_create_options(),
+        lambda s,v: s._set_create_options(v),
         doc="options to be used when running mkfs"
     )
 
-    def _deviceCheck(self, devspec):
+    def _device_check(self, devspec):
         """ Verifies that device spec has a proper format.
 
             :param devspec: the device spec
@@ -321,17 +322,17 @@ def _deviceCheck(self, devspec):
             return "device must be a fully qualified path"
         return None
 
-    def _setDevice(self, devspec):
-        error_msg = self._deviceCheck(devspec)
+    def _set_device(self, devspec):
+        error_msg = self._device_check(devspec)
         if error_msg:
             raise ValueError(error_msg)
         self._device = devspec
 
-    def _getDevice(self):
+    def _get_device(self):
         return self._device
 
-    device = property(lambda f: f._getDevice(),
-                      lambda f,d: f._setDevice(d),
+    device = property(lambda f: f._get_device(),
+                      lambda f,d: f._set_device(d),
                       doc="Full path the device this format occupies")
 
     @property
@@ -342,7 +343,7 @@ def name(self):
     def type(self):
         return self._type
 
-    def notifyKernel(self):
+    def notify_kernel(self):
         log_method_call(self, device=self.device,
                         type=self.type)
         if not self.device:
@@ -384,11 +385,11 @@ def create(self, **kwargs):
         """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        self._preCreate(**kwargs)
+        self._pre_create(**kwargs)
         self._create(**kwargs)
-        self._postCreate(**kwargs)
+        self._post_create(**kwargs)
 
-    def _preCreate(self, **kwargs):
+    def _pre_create(self, **kwargs):
         """ Perform checks and setup prior to creating the format. """
         # allow late specification of device path
         device = kwargs.get("device")
@@ -410,9 +411,9 @@ def _create(self, **kwargs):
         pass
 
     # pylint: disable=unused-argument
-    def _postCreate(self, **kwargs):
+    def _post_create(self, **kwargs):
         self.exists = True
-        self.notifyKernel()
+        self.notify_kernel()
 
     def destroy(self, **kwargs):
         """ Remove the formatting from the associated block device.
@@ -422,12 +423,12 @@ def destroy(self, **kwargs):
         """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        self._preDestroy(**kwargs)
+        self._pre_destroy(**kwargs)
         self._destroy(**kwargs)
-        self._postDestroy(**kwargs)
+        self._post_destroy(**kwargs)
 
     # pylint: disable=unused-argument
-    def _preDestroy(self, **kwargs):
+    def _pre_destroy(self, **kwargs):
         if not self.exists:
             raise DeviceFormatError("format has not been created")
 
@@ -452,9 +453,9 @@ def _destroy(self, **kwargs):
             msg = "error wiping old signatures from %s: %s" % (self.device, err)
             raise FormatDestroyError(msg)
 
-    def _postDestroy(self, **kwargs):
+    def _post_destroy(self, **kwargs):
         self.exists = False
-        self.notifyKernel()
+        self.notify_kernel()
 
     @property
     def destroyable(self):
@@ -477,11 +478,11 @@ def setup(self, **kwargs):
         """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        if not self._preSetup(**kwargs):
+        if not self._pre_setup(**kwargs):
             return
 
         self._setup(**kwargs)
-        self._postSetup(**kwargs)
+        self._post_setup(**kwargs)
 
     @property
     def controllable(self):
@@ -493,7 +494,7 @@ def controllable(self):
         """
         return True
 
-    def _preSetup(self, **kwargs):
+    def _pre_setup(self, **kwargs):
         """ Return True if setup should proceed. """
         if not self.exists:
             raise FormatSetupError("format has not been created")
@@ -513,20 +514,20 @@ def _setup(self, **kwargs):
         pass
 
     # pylint: disable=unused-argument
-    def _postSetup(self, **kwargs):
+    def _post_setup(self, **kwargs):
         pass
 
     def teardown(self, **kwargs):
         """ Deactivate the formatting. """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        if not self._preTeardown(**kwargs):
+        if not self._pre_teardown(**kwargs):
             return
 
         self._teardown(**kwargs)
-        self._postTeardown(**kwargs)
+        self._post_teardown(**kwargs)
 
-    def _preTeardown(self, **kwargs):
+    def _pre_teardown(self, **kwargs):
         """ Return True if teardown should proceed. """
         if not self.exists:
             raise DeviceFormatError("format has not been created")
@@ -536,7 +537,7 @@ def _preTeardown(self, **kwargs):
     def _teardown(self, **kwargs):
         pass
 
-    def _postTeardown(self, **kwargs):
+    def _post_teardown(self, **kwargs):
         pass
 
     @property
@@ -573,9 +574,9 @@ def resizable(self):
         return self._resizable and self.exists
 
     @property
-    def linuxNative(self):
+    def linux_native(self):
         """ Is this format type native to linux? """
-        return self._linuxNative
+        return self._linux_native
 
     @property
     def mountable(self):
@@ -593,12 +594,12 @@ def check(self):
         return self._check
 
     @property
-    def maxSize(self):
+    def max_size(self):
         """ Maximum size for this format type. """
-        return self._maxSize
+        return self._max_size
 
     @property
-    def minSize(self):
+    def min_size(self):
         """ Minimum size for this format instance.
 
             :returns: the minimum size for this format instance
@@ -606,7 +607,7 @@ def minSize(self):
 
             A value of 0 indicates an unknown size.
         """
-        return self._minSize
+        return self._min_size
 
     @property
     def hidden(self):
@@ -614,13 +615,13 @@ def hidden(self):
         return self._hidden
 
     @property
-    def ksMountpoint(self):
-        return (self._ksMountpoint or self.type or "")
+    def ks_mountpoint(self):
+        return (self._ks_mountpoint or self.type or "")
 
-    def populateKSData(self, data):
+    def populate_ksdata(self, data):
         data.format = not self.exists
         data.fstype = self.type
-        data.mountpoint = self.ksMountpoint
+        data.mountpoint = self.ks_mountpoint
 
 register_device_format(DeviceFormat)
 
diff --git a/blivet/formats/biosboot.py b/blivet/formats/biosboot.py
index 9fbcdd2..653a436 100644
--- a/blivet/formats/biosboot.py
+++ b/blivet/formats/biosboot.py
@@ -31,11 +31,11 @@ class BIOSBoot(DeviceFormat):
     """ BIOS boot partition for GPT disklabels. """
     _type = "biosboot"
     _name = N_("BIOS Boot")
-    partedFlag = PARTITION_BIOS_GRUB
+    parted_flag = PARTITION_BIOS_GRUB
     _formattable = True                 # can be formatted
-    _linuxNative = True                 # for clearpart
-    _maxSize = Size("2 MiB")
-    _minSize = Size("512 KiB")
+    _linux_native = True                 # for clearpart
+    _max_size = Size("2 MiB")
+    _min_size = Size("512 KiB")
     _supported = True
 
     def __init__(self, **kwargs):
diff --git a/blivet/formats/disklabel.py b/blivet/formats/disklabel.py
index 133d5f6..f060dbd 100644
--- a/blivet/formats/disklabel.py
+++ b/blivet/formats/disklabel.py
@@ -48,8 +48,8 @@ def __init__(self, **kwargs):
         """
             :keyword device: full path to the block device node
             :type device: str
-            :keyword labelType: type of disklabel to create
-            :type labelType: str
+            :keyword label_type: type of disklabel to create
+            :type label_type: str
             :keyword exists: whether the formatting exists
             :type exists: bool
         """
@@ -57,23 +57,23 @@ def __init__(self, **kwargs):
         DeviceFormat.__init__(self, **kwargs)
 
         if not self.exists:
-            self._labelType = kwargs.get("labelType", "msdos")
+            self._label_type = kwargs.get("label_type", "msdos")
         else:
-            self._labelType = ""
+            self._label_type = ""
 
         self._size = Size(0)
 
-        self._partedDevice = None
-        self._partedDisk = None
-        self._origPartedDisk = None
+        self._parted_device = None
+        self._parted_disk = None
+        self._orig_parted_disk = None
 
-        self._diskLabelAlignment = None
-        self._minimalAlignment = None
-        self._optimalAlignment = None
+        self._disk_label_alignment = None
+        self._minimal_alignment = None
+        self._optimal_alignment = None
 
-        if self.partedDevice:
+        if self.parted_device:
             # set up the parted objects and raise exception on failure
-            self.updateOrigPartedDisk()
+            self.update_orig_parted_disk()
 
     def __deepcopy__(self, memo):
         """ Create a deep copy of a Disklabel instance.
@@ -81,30 +81,30 @@ def __deepcopy__(self, memo):
             We can't do copy.deepcopy on parted objects, which is okay.
         """
         return util.variable_copy(self, memo,
-           shallow=('_partedDevice', '_optimalAlignment', '_minimalAlignment',),
-           duplicate=('_partedDisk', '_origPartedDisk'))
+           shallow=('_parted_device', '_optimal_alignment', '_minimal_alignment',),
+           duplicate=('_parted_disk', '_orig_parted_disk'))
 
     def __repr__(self):
         s = DeviceFormat.__repr__(self)
         if flags.testing:
             return s
         s += ("  type = %(type)s  partition count = %(count)s"
-              "  sectorSize = %(sectorSize)s\n"
+              "  sector_size = %(sector_size)s\n"
               "  align_offset = %(offset)s  align_grain = %(grain)s\n"
-              "  partedDisk = %(disk)s\n"
-              "  origPartedDisk = %(orig_disk)r\n"
-              "  partedDevice = %(dev)s\n" %
-              {"type": self.labelType, "count": len(self.partitions),
-               "sectorSize": self.sectorSize,
-               "offset": self.getAlignment().offset,
-               "grain": self.getAlignment().grainSize,
-               "disk": self.partedDisk, "orig_disk": self._origPartedDisk,
-               "dev": self.partedDevice})
+              "  parted_disk = %(disk)s\n"
+              "  orig_parted_disk = %(orig_disk)r\n"
+              "  parted_device = %(dev)s\n" %
+              {"type": self.label_type, "count": len(self.partitions),
+               "sector_size": self.sector_size,
+               "offset": self.get_alignment().offset,
+               "grain": self.get_alignment().grainSize,
+               "disk": self.parted_disk, "orig_disk": self._orig_parted_disk,
+               "dev": self.parted_device})
         return s
 
     @property
     def desc(self):
-        return "%s %s" % (self.labelType, self.type)
+        return "%s %s" % (self.label_type, self.type)
 
     @property
     def dict(self):
@@ -112,37 +112,37 @@ def dict(self):
         if flags.testing:
             return d
 
-        d.update({"labelType": self.labelType,
-                  "partitionCount": len(self.partitions),
-                  "sectorSize": self.sectorSize,
-                  "offset": self.getAlignment().offset,
-                  "grainSize": self.getAlignment().grainSize})
+        d.update({"label_type": self.label_type,
+                  "partition_count": len(self.partitions),
+                  "sector_size": self.sector_size,
+                  "offset": self.get_alignment().offset,
+                  "grain_size": self.get_alignment().grainSize})
         return d
 
-    def updateOrigPartedDisk(self):
-        self._origPartedDisk = self.partedDisk.duplicate()
+    def update_orig_parted_disk(self):
+        self._orig_parted_disk = self.parted_disk.duplicate()
 
-    def resetPartedDisk(self):
-        """ Set this instance's partedDisk to reflect the disk's contents. """
+    def reset_parted_disk(self):
+        """ Set this instance's parted_disk to reflect the disk's contents. """
         log_method_call(self, device=self.device)
-        self._partedDisk = self._origPartedDisk
+        self._parted_disk = self._orig_parted_disk
 
-    def freshPartedDisk(self):
+    def fresh_parted_disk(self):
         """ Return a new, empty parted.Disk instance for this device. """
-        log_method_call(self, device=self.device, labelType=self._labelType)
-        return parted.freshDisk(device=self.partedDevice, ty=self._labelType)
+        log_method_call(self, device=self.device, label_type=self._label_type)
+        return parted.freshDisk(device=self.parted_device, ty=self._label_type)
 
     @property
-    def partedDisk(self):
-        if not self._partedDisk:
+    def parted_disk(self):
+        if not self._parted_disk:
             if self.exists:
                 try:
-                    self._partedDisk = parted.Disk(device=self.partedDevice)
+                    self._parted_disk = parted.Disk(device=self.parted_device)
                 except (_ped.DiskLabelException, _ped.IOException,
                         NotImplementedError) as e:
                     raise InvalidDiskLabelError(e)
 
-                if self._partedDisk.type == "loop":
+                if self._parted_disk.type == "loop":
                     # When the device has no partition table but it has a FS,
                     # it will be created with label type loop.  Treat the
                     # same as if the device had no label (cause it really
@@ -151,76 +151,76 @@ def partedDisk(self):
 
                 # here's where we correct the ctor-supplied disklabel type for
                 # preexisting disklabels if the passed type was wrong
-                self._labelType = self._partedDisk.type
+                self._label_type = self._parted_disk.type
             else:
-                self._partedDisk = self.freshPartedDisk()
+                self._parted_disk = self.fresh_parted_disk()
 
             # turn off cylinder alignment
-            if self._partedDisk.isFlagAvailable(parted.DISK_CYLINDER_ALIGNMENT):
-                self._partedDisk.unsetFlag(parted.DISK_CYLINDER_ALIGNMENT)
+            if self._parted_disk.isFlagAvailable(parted.DISK_CYLINDER_ALIGNMENT):
+                self._parted_disk.unsetFlag(parted.DISK_CYLINDER_ALIGNMENT)
 
             # Set the boot flag on the GPT PMBR, this helps some BIOS systems boot
-            if self._partedDisk.isFlagAvailable(parted.DISK_GPT_PMBR_BOOT):
+            if self._parted_disk.isFlagAvailable(parted.DISK_GPT_PMBR_BOOT):
                 # MAC can boot as EFI or as BIOS, neither should have PMBR boot set
-                if arch.isEfi() or arch.isMactel():
-                    self._partedDisk.unsetFlag(parted.DISK_GPT_PMBR_BOOT)
-                    log.debug("Clear pmbr_boot on %s", self._partedDisk)
+                if arch.is_efi() or arch.is_mactel():
+                    self._parted_disk.unsetFlag(parted.DISK_GPT_PMBR_BOOT)
+                    log.debug("Clear pmbr_boot on %s", self._parted_disk)
                 else:
-                    self._partedDisk.setFlag(parted.DISK_GPT_PMBR_BOOT)
-                    log.debug("Set pmbr_boot on %s", self._partedDisk)
+                    self._parted_disk.setFlag(parted.DISK_GPT_PMBR_BOOT)
+                    log.debug("Set pmbr_boot on %s", self._parted_disk)
             else:
-                log.debug("Did not change pmbr_boot on %s", self._partedDisk)
+                log.debug("Did not change pmbr_boot on %s", self._parted_disk)
 
         udev.settle(quiet=True)
-        return self._partedDisk
+        return self._parted_disk
 
     @property
-    def partedDevice(self):
-        if not self._partedDevice and self.device:
+    def parted_device(self):
+        if not self._parted_device and self.device:
             if os.path.exists(self.device):
                 # We aren't guaranteed to be able to get a device.  In
                 # particular, built-in USB flash readers show up as devices but
                 # do not always have any media present, so parted won't be able
                 # to find a device.
                 try:
-                    self._partedDevice = parted.Device(path=self.device)
+                    self._parted_device = parted.Device(path=self.device)
                 except (_ped.IOException, _ped.DeviceException) as e:
-                    log.error("DiskLabel.partedDevice: Parted exception: %s", e)
+                    log.error("DiskLabel.parted_device: Parted exception: %s", e)
             else:
-                log.info("DiskLabel.partedDevice: %s does not exist", self.device)
+                log.info("DiskLabel.parted_device: %s does not exist", self.device)
 
-        if not self._partedDevice:
-            log.info("DiskLabel.partedDevice returning None")
-        return self._partedDevice
+        if not self._parted_device:
+            log.info("DiskLabel.parted_device returning None")
+        return self._parted_device
 
     @property
-    def labelType(self):
+    def label_type(self):
         """ The disklabel type (eg: 'gpt', 'msdos') """
         try:
-            lt = self.partedDisk.type
+            lt = self.parted_disk.type
         except Exception: # pylint: disable=broad-except
             log_exception_info()
-            lt = self._labelType
+            lt = self._label_type
         return lt
 
     @property
-    def sectorSize(self):
+    def sector_size(self):
         try:
-            return Size(self.partedDevice.sectorSize)
+            return Size(self.parted_device.sectorSize)
         except AttributeError:
             log_exception_info()
             return None
 
     @property
     def name(self):
-        return "%s (%s)" % (_(self._name), self.labelType.upper())
+        return "%s (%s)" % (_(self._name), self.label_type.upper())
 
     @property
     def size(self):
         size = self._size
         if not size:
             try:
-                size = Size(self.partedDevice.getLength(unit="B"))
+                size = Size(self.parted_device.getLength(unit="B"))
             except Exception: # pylint: disable=broad-except
                 log_exception_info()
                 size = Size(0)
@@ -236,8 +236,8 @@ def _create(self, **kwargs):
         """ Create the device. """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        # We're relying on someone having called resetPartedDisk -- we
-        # could ensure a fresh disklabel by setting self._partedDisk to
+        # We're relying on someone having called reset_parted_disk -- we
+        # could ensure a fresh disklabel by setting self._parted_disk to
         # None right before calling self.commit(), but that might hide
         # other problems.
         self.commit()
@@ -246,32 +246,32 @@ def _destroy(self, **kwargs):
         """ Wipe the disklabel from the device. """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        self.partedDevice.clobber()
+        self.parted_device.clobber()
 
     def commit(self):
         """ Commit the current partition table to disk and notify the OS. """
         log_method_call(self, device=self.device,
                         numparts=len(self.partitions))
         try:
-            self.partedDisk.commit()
+            self.parted_disk.commit()
         except parted.DiskException as msg:
             raise DiskLabelCommitError(msg)
         else:
-            self.updateOrigPartedDisk()
+            self.update_orig_parted_disk()
             udev.settle()
 
-    def commitToDisk(self):
+    def commit_to_disk(self):
         """ Commit the current partition table to disk. """
         log_method_call(self, device=self.device,
                         numparts=len(self.partitions))
         try:
-            self.partedDisk.commitToDevice()
+            self.parted_disk.commitToDevice()
         except parted.DiskException as msg:
             raise DiskLabelCommitError(msg)
         else:
-            self.updateOrigPartedDisk()
+            self.update_orig_parted_disk()
 
-    def addPartition(self, start, end, ptype=None):
+    def add_partition(self, start, end, ptype=None):
         """ Add a partition to the disklabel.
 
             :param int start: start sector
@@ -284,61 +284,61 @@ def addPartition(self, start, end, ptype=None):
             an extended partition.
         """
         if ptype is None:
-            extended = self.extendedPartition
+            extended = self.extended_partition
             if extended and extended.geometry.contains(start):
                 ptype = parted.PARTITION_LOGICAL
             else:
                 ptype = parted.PARTITION_NORMAL
 
-        geometry = parted.Geometry(device=self.partedDevice,
+        geometry = parted.Geometry(device=self.parted_device,
                                    start=start, end=end)
-        new_partition = parted.Partition(disk=self.partedDisk,
+        new_partition = parted.Partition(disk=self.parted_disk,
                                          type=ptype,
                                          geometry=geometry)
 
         constraint = parted.Constraint(exactGeom=geometry)
-        self.partedDisk.addPartition(partition=new_partition,
+        self.parted_disk.addPartition(partition=new_partition,
                                      constraint=constraint)
 
-    def removePartition(self, partition):
+    def remove_partition(self, partition):
         """ Remove a partition from the disklabel.
 
             :param partition: the partition to remove
             :type partition: :class:`parted.Partition`
         """
-        self.partedDisk.removePartition(partition)
+        self.parted_disk.removePartition(partition)
 
     @property
-    def extendedPartition(self):
+    def extended_partition(self):
         try:
-            extended = self.partedDisk.getExtendedPartition()
+            extended = self.parted_disk.getExtendedPartition()
         except Exception: # pylint: disable=broad-except
             log_exception_info()
             extended = None
         return extended
 
     @property
-    def logicalPartitions(self):
+    def logical_partitions(self):
         try:
-            logicals = self.partedDisk.getLogicalPartitions()
+            logicals = self.parted_disk.getLogicalPartitions()
         except Exception: # pylint: disable=broad-except
             log_exception_info()
             logicals = []
         return logicals
 
     @property
-    def primaryPartitions(self):
+    def primary_partitions(self):
         try:
-            primaries = self.partedDisk.getPrimaryPartitions()
+            primaries = self.parted_disk.getPrimaryPartitions()
         except Exception: # pylint: disable=broad-except
             log_exception_info()
             primaries = []
         return primaries
 
     @property
-    def firstPartition(self):
+    def first_partition(self):
         try:
-            part = self.partedDisk.getFirstPartition()
+            part = self.parted_disk.getFirstPartition()
         except Exception: # pylint: disable=broad-except
             log_exception_info()
             part = None
@@ -346,31 +346,31 @@ def firstPartition(self):
 
     @property
     def partitions(self):
-        return self.partedDisk.partitions
+        return self.parted_disk.partitions
 
-    def _getDiskLabelAlignment(self):
+    def _get_disk_label_alignment(self):
         """ Return the disklabel's required alignment for new partitions.
 
             :rtype: :class:`parted.Alignment`
         """
-        if not self._diskLabelAlignment:
+        if not self._disk_label_alignment:
             try:
-                self._diskLabelAlignment = self.partedDisk.partitionAlignment
+                self._disk_label_alignment = self.parted_disk.partitionAlignment
             except _ped.CreateException:
-                self._diskLabelAlignment = parted.Alignment(offset=0,
+                self._disk_label_alignment = parted.Alignment(offset=0,
                                                             grainSize=1)
 
-        return self._diskLabelAlignment
+        return self._disk_label_alignment
 
-    def _getMinimalAlignment(self):
+    def _get_minimal_alignment(self):
         """ Return the device's minimal alignment for new partitions.
 
             :rtype: :class:`parted.Alignment`
         """
-        if not self._minimalAlignment:
-            disklabel_alignment = self._getDiskLabelAlignment()
+        if not self._minimal_alignment:
+            disklabel_alignment = self._get_disk_label_alignment()
             try:
-                minimal_alignment = self.partedDevice.minimumAlignment
+                minimal_alignment = self.parted_device.minimumAlignment
             except _ped.CreateException:
                 # handle this in the same place we'd handle an ArithmeticError
                 minimal_alignment = None
@@ -380,11 +380,11 @@ def _getMinimalAlignment(self):
             except (ArithmeticError, AttributeError):
                 alignment = disklabel_alignment
 
-            self._minimalAlignment = alignment
+            self._minimal_alignment = alignment
 
-        return self._minimalAlignment
+        return self._minimal_alignment
 
-    def _getOptimalAlignment(self):
+    def _get_optimal_alignment(self):
         """ Return the device's optimal alignment for new partitions.
 
             :rtype: :class:`parted.Alignment`
@@ -394,26 +394,26 @@ def _getOptimalAlignment(self):
                 If there is no device-supplied optimal alignment this method
                 returns the minimal device alignment.
         """
-        if not self._optimalAlignment:
-            disklabel_alignment = self._getDiskLabelAlignment()
+        if not self._optimal_alignment:
+            disklabel_alignment = self._get_disk_label_alignment()
             try:
-                optimal_alignment = self.partedDevice.optimumAlignment
+                optimal_alignment = self.parted_device.optimumAlignment
             except _ped.CreateException:
                 # if there is no optimal alignment, use the minimal alignment,
                 # which has already been intersected with the disklabel
                 # alignment
-                alignment = self._getMinimalAlignment()
+                alignment = self._get_minimal_alignment()
             else:
                 try:
                     alignment = optimal_alignment.intersect(disklabel_alignment)
                 except ArithmeticError:
                     alignment = disklabel_alignment
 
-            self._optimalAlignment = alignment
+            self._optimal_alignment = alignment
 
-        return self._optimalAlignment
+        return self._optimal_alignment
 
-    def getAlignment(self, size=None):
+    def get_alignment(self, size=None):
         """ Return an appropriate alignment for a new partition.
 
             :keyword size: proposed partition size (optional)
@@ -424,15 +424,15 @@ def getAlignment(self, size=None):
                                                          small to be aligned
         """
         # default to the optimal alignment
-        alignment = self._getOptimalAlignment()
+        alignment = self._get_optimal_alignment()
         if size is None:
             return alignment
 
         # use the minimal alignment if the requested size is smaller than the
         # optimal io size
-        minimal_alignment = self._getMinimalAlignment()
-        optimal_grain_size = Size(alignment.grainSize * self.sectorSize)
-        minimal_grain_size = Size(minimal_alignment.grainSize * self.sectorSize)
+        minimal_alignment = self._get_minimal_alignment()
+        optimal_grain_size = Size(alignment.grainSize * self.sector_size)
+        minimal_grain_size = Size(minimal_alignment.grainSize * self.sector_size)
         if size < minimal_grain_size:
             raise AlignmentError("requested size cannot be aligned")
         elif size < optimal_grain_size:
@@ -440,7 +440,7 @@ def getAlignment(self, size=None):
 
         return alignment
 
-    def getEndAlignment(self, size=None, alignment=None):
+    def get_end_alignment(self, size=None, alignment=None):
         """ Return an appropriate end-alignment for a new partition.
 
             :keyword size: proposed partition size (optional)
@@ -453,29 +453,29 @@ def getEndAlignment(self, size=None, alignment=None):
                                                          small to be aligned
         """
         if alignment is None:
-            alignment = self.getAlignment(size=size)
+            alignment = self.get_alignment(size=size)
 
         return parted.Alignment(offset=alignment.offset - 1,
                             grainSize=alignment.grainSize)
 
     @property
     def alignment(self):
-        return self.getAlignment()
+        return self.get_alignment()
 
     @property
-    def endAlignment(self):
-        return self.getEndAlignment()
+    def end_alignment(self):
+        return self.get_end_alignment()
 
     @property
     def free(self):
-        return sum((Size(f.getLength(unit="B")) for f in self.partedDisk.getFreeSpacePartitions()), Size(0))
+        return sum((Size(f.getLength(unit="B")) for f in self.parted_disk.getFreeSpacePartitions()), Size(0))
 
     @property
-    def magicPartitionNumber(self):
+    def magic_partition_number(self):
         """ Number of disklabel-type-specific special partition. """
-        if self.labelType == "mac":
+        if self.label_type == "mac":
             return 1
-        elif self.labelType == "sun":
+        elif self.label_type == "sun":
             return 3
         else:
             return 0
diff --git a/blivet/formats/dmraid.py b/blivet/formats/dmraid.py
index a44967a..a2892ce 100644
--- a/blivet/formats/dmraid.py
+++ b/blivet/formats/dmraid.py
@@ -42,7 +42,7 @@ class DMRaidMember(DeviceFormat):
     #
     #     One problem that presents is the possibility of someone passing
     #     a dmraid member to the MDRaidArrayDevice constructor.
-    _udevTypes = ["adaptec_raid_member", "ddf_raid_member",
+    _udev_types = ["adaptec_raid_member", "ddf_raid_member",
                  "hpt37x_raid_member", "hpt45x_raid_member",
                  "isw_raid_member",
                  "jmicron_raid_member", "lsi_mega_raid_member",
@@ -73,14 +73,14 @@ def __repr__(self):
         s += ("  raidmem = %(raidmem)r" % {"raidmem": self.raidmem})
         return s
 
-    def _getRaidmem(self):
+    def _get_raidmem(self):
         return self._raidmem
 
-    def _setRaidmem(self, raidmem):
+    def _set_raidmem(self, raidmem):
         self._raidmem = raidmem
 
-    raidmem = property(lambda d: d._getRaidmem(),
-                       lambda d,r: d._setRaidmem(r))
+    raidmem = property(lambda d: d._get_raidmem(),
+                       lambda d,r: d._set_raidmem(r))
 
     def create(self, **kwargs):
         log_method_call(self, device=self.device,
@@ -94,12 +94,12 @@ def destroy(self, **kwargs):
 
 
 if not flags.noiswmd:
-    DMRaidMember._udevTypes.remove("isw_raid_member")
+    DMRaidMember._udev_types.remove("isw_raid_member")
 
 # The anaconda cmdline has not been parsed yet when we're first imported,
 # so we can not use flags.dmraid here
 if not flags.dmraid:
-    DMRaidMember._udevTypes = []
+    DMRaidMember._udev_types = []
 
 register_device_format(DMRaidMember)
 
diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py
index 955a613..869f35b 100644
--- a/blivet/formats/fs.py
+++ b/blivet/formats/fs.py
@@ -26,6 +26,8 @@
 import os
 import tempfile
 
+from parted import fileSystemType
+
 from ..tasks import fsck
 from ..tasks import fsinfo
 from ..tasks import fslabeling
@@ -43,13 +45,12 @@
 from .. import util
 from .. import platform
 from ..flags import flags
-from parted import fileSystemType
 from ..storage_log import log_exception_info, log_method_call
 from .. import arch
-from ..size import Size, ROUND_UP, ROUND_DOWN, unitStr
+from ..size import Size, ROUND_UP, ROUND_DOWN, unit_str
 from ..i18n import N_
 from .. import udev
-from ..mounts import mountsCache
+from ..mounts import mounts_cache
 
 from .fslib import kernel_filesystems, update_kernel_filesystems
 
@@ -62,16 +63,16 @@ class FS(DeviceFormat):
     _name = None
     _modules = []                        # kernel modules required for support
     _labelfs = None                      # labeling functionality
-    _fsckClass = fsck.UnimplementedFSCK
-    _infoClass = fsinfo.UnimplementedFSInfo
-    _minsizeClass = fsminsize.UnimplementedFSMinSize
-    _mkfsClass = fsmkfs.UnimplementedFSMkfs
-    _mountClass = fsmount.FSMount
-    _readlabelClass = fsreadlabel.UnimplementedFSReadLabel
-    _resizeClass = fsresize.UnimplementedFSResize
-    _sizeinfoClass = fssize.UnimplementedFSSize
-    _syncClass = fssync.UnimplementedFSSync
-    _writelabelClass = fswritelabel.UnimplementedFSWriteLabel
+    _fsck_class = fsck.UnimplementedFSCK
+    _info_class = fsinfo.UnimplementedFSInfo
+    _minsize_class = fsminsize.UnimplementedFSMinSize
+    _mkfs_class = fsmkfs.UnimplementedFSMkfs
+    _mount_class = fsmount.FSMount
+    _readlabel_class = fsreadlabel.UnimplementedFSReadLabel
+    _resize_class = fsresize.UnimplementedFSResize
+    _size_info_class = fssize.UnimplementedFSSize
+    _sync_class = fssync.UnimplementedFSSync
+    _writelabel_class = fswritelabel.UnimplementedFSWriteLabel
     # This constant is aquired by testing some filesystems
     # and it's giving us percentage of space left after the format.
     # This number is more guess then precise number because this
@@ -106,18 +107,18 @@ def __init__(self, **kwargs):
         DeviceFormat.__init__(self, **kwargs)
 
         # Create task objects
-        self._info = self._infoClass(self)
-        self._fsck = self._fsckClass(self)
-        self._mkfs = self._mkfsClass(self)
-        self._mount = self._mountClass(self)
-        self._readlabel = self._readlabelClass(self)
-        self._resize = self._resizeClass(self)
-        self._sync = self._syncClass(self)
-        self._writelabel = self._writelabelClass(self)
+        self._info = self._info_class(self)
+        self._fsck = self._fsck_class(self)
+        self._mkfs = self._mkfs_class(self)
+        self._mount = self._mount_class(self)
+        self._readlabel = self._readlabel_class(self)
+        self._resize = self._resize_class(self)
+        self._sync = self._sync_class(self)
+        self._writelabel = self._writelabel_class(self)
 
         # These two may depend on info class, so create them after
-        self._minsize = self._minsizeClass(self)
-        self._sizeinfo = self._sizeinfoClass(self)
+        self._minsize = self._minsize_class(self)
+        self._size_info = self._size_info_class(self)
 
         self._current_info = None # info obtained by _info task
 
@@ -128,34 +129,34 @@ def __init__(self, **kwargs):
 
         # filesystem size does not necessarily equal device size
         self._size = kwargs.get("size", Size(0))
-        self._minInstanceSize = Size(0)    # min size of this FS instance
+        self._min_instance_size = Size(0)    # min size of this FS instance
 
         # Resize operations are limited to error-free filesystems whose current
         # size is known.
         self._resizable = False
         if flags.installer_mode and self._resize.available:
-            # if you want current/min size you have to call updateSizeInfo
+            # if you want current/min size you have to call update_size_info
             try:
-                self.updateSizeInfo()
+                self.update_size_info()
             except FSError:
                 log.warning("%s filesystem on %s needs repair", self.type,
                                                                 self.device)
 
-        self._targetSize = self._size
+        self._target_size = self._size
 
-        self._chrootedMountpoint = None
+        self._chrooted_mountpoint = None
 
         if self.supported:
-            self.loadModule()
+            self.load_module()
 
     def __repr__(self):
         s = DeviceFormat.__repr__(self)
         s += ("  mountpoint = %(mountpoint)s  mountopts = %(mountopts)s\n"
               "  label = %(label)s  size = %(size)s"
-              "  targetSize = %(targetSize)s\n" %
+              "  target_size = %(target_size)s\n" %
               {"mountpoint": self.mountpoint, "mountopts": self.mountopts,
                "label": self.label, "size": self._size,
-               "targetSize": self.targetSize})
+               "target_size": self.target_size})
         return s
 
     @property
@@ -169,12 +170,12 @@ def desc(self):
     def dict(self):
         d = super(FS, self).dict
         d.update({"mountpoint": self.mountpoint, "size": self._size,
-                  "label": self.label, "targetSize": self.targetSize,
+                  "label": self.label, "targetSize": self.target_size,
                   "mountable": self.mountable})
         return d
 
     @classmethod
-    def freeSpaceEstimate(cls, device_size):
+    def free_space_estimate(cls, device_size):
         """ Get estimated free space when format will be done on device
             with size ``device_size``.
             This is more guess then precise number.
@@ -190,7 +191,7 @@ def labeling(self):
 
            :rtype: bool
         """
-        return (self._mkfs.canLabel and self._mkfs.available) or self._writelabel.available
+        return (self._mkfs.can_label and self._mkfs.available) or self._writelabel.available
 
     def relabels(self):
         """Returns True if it is possible to relabel this filesystem
@@ -200,7 +201,7 @@ def relabels(self):
         """
         return self._writelabel.available
 
-    def labelFormatOK(self, label):
+    def label_format_ok(self, label):
         """Return True if the label has an acceptable format for this
            filesystem. None, which represents accepting the default for this
            device, is always acceptable.
@@ -208,12 +209,12 @@ def labelFormatOK(self, label):
            :param label: A possible label
            :type label: str or None
         """
-        return label is None or (self._labelfs is not None and self._labelfs.labelFormatOK(label))
+        return label is None or (self._labelfs is not None and self._labelfs.label_format_ok(label))
 
-    label = property(lambda s: s._getLabel(), lambda s,l: s._setLabel(l),
+    label = property(lambda s: s._get_label(), lambda s,l: s._set_label(l),
        doc="this filesystem's label")
 
-    def _setTargetSize(self, newsize):
+    def _set_target_size(self, newsize):
         """ Set the target size for this filesystem.
 
             :param :class:`~.size.Size` newsize: the newsize
@@ -227,29 +228,29 @@ def _setTargetSize(self, newsize):
         if not self.resizable:
             raise FSError("filesystem is not resizable")
 
-        if newsize < self.minSize:
-            raise ValueError("requested size %s must be at least minimum size %s" % (newsize, self.minSize))
+        if newsize < self.min_size:
+            raise ValueError("requested size %s must be at least minimum size %s" % (newsize, self.min_size))
 
-        if self.maxSize and newsize >= self.maxSize:
-            raise ValueError("requested size %s must be less than maximum size %s" % (newsize, self.maxSize))
+        if self.max_size and newsize >= self.max_size:
+            raise ValueError("requested size %s must be less than maximum size %s" % (newsize, self.max_size))
 
-        self._targetSize = newsize
+        self._target_size = newsize
 
-    def _getTargetSize(self):
+    def _get_target_size(self):
         """ Get this filesystem's target size. """
-        return self._targetSize
+        return self._target_size
 
-    targetSize = property(_getTargetSize, _setTargetSize,
+    target_size = property(_get_target_size, _set_target_size,
                           doc="Target size for this filesystem")
 
-    def _getSize(self):
+    def _get_size(self):
         """ Get this filesystem's size. """
-        return self.targetSize if self.resizable else self._size
+        return self.target_size if self.resizable else self._size
 
-    size = property(_getSize, doc="This filesystem's size, accounting "
+    size = property(_get_size, doc="This filesystem's size, accounting "
                                   "for pending changes")
 
-    def updateSizeInfo(self):
+    def update_size_info(self):
         """ Update this filesystem's current and minimum size (for resize). """
 
         #   This method ensures:
@@ -258,25 +259,25 @@ def updateSizeInfo(self):
         #   * If it is not possible to obtain the current size of the
         #       filesystem by interrogating the filesystem, self._resizable
         #       is False (and self._size is 0).
-        #   * _minInstanceSize is obtained or it is set to _size. Effectively
+        #   * _min_instance_size is obtained or it is set to _size. Effectively
         #     this means that it is the actual minimum size, or if that
         #     cannot be obtained the actual current size of the device.
         #     If it was not possible to obtain the current size of the device
-        #     then _minInstanceSize is 0, but since _resizable is False
+        #     then _min_instance_size is 0, but since _resizable is False
         #     that information can not be used to shrink the filesystem below
         #     its unknown actual minimum size.
-        #   * self._getMinSize() is only run if fsck succeeds and a current
+        #   * self._get_min_size() is only run if fsck succeeds and a current
         #     existing size can be obtained.
         if not self.exists:
             return
 
         self._current_info = None
-        self._minInstanceSize = Size(0)
+        self._min_instance_size = Size(0)
         self._resizable = self.__class__._resizable
 
         # We can't allow resize if the filesystem has errors.
         try:
-            self.doCheck()
+            self.do_check()
         except FSError:
             self._resizable = False
             raise
@@ -285,12 +286,12 @@ def updateSizeInfo(self):
             self._size = Size(0)
             try:
                 if self._info.available:
-                    self._current_info = self._info.doTask()
+                    self._current_info = self._info.do_task()
             except FSError as e:
                 log.info("Failed to obtain info for device %s: %s", self.device, e)
             try:
-                self._size = self._sizeinfo.doTask()
-                self._minInstanceSize = self._size
+                self._size = self._size_info.do_task()
+                self._min_instance_size = self._size
             except (FSError, NotImplementedError) as e:
                 log.warning("Failed to obtain current size for device %s: %s", self.device, e)
 
@@ -302,27 +303,27 @@ def updateSizeInfo(self):
                 self._resizable = False
 
         try:
-            result = self._minsize.doTask()
-            size = self._padSize(result)
+            result = self._minsize.do_task()
+            size = self._pad_size(result)
             if result < size:
                 log.debug("padding min size from %s up to %s", result, size)
             else:
                 log.debug("using current size %s as min size", size)
-            self._minInstanceSize = size
+            self._min_instance_size = size
         except (FSError, NotImplementedError) as e:
             log.warning("Failed to obtain minimum size for device %s: %s", self.device, e)
 
     @property
-    def minSize(self):
-        # If self._minInstanceSize is not 0, then it should be no less than
-        # self._minSize, by definition, and since a non-zero value indicates
+    def min_size(self):
+        # If self._min_instance_size is not 0, then it should be no less than
+        # self._min_size, by definition, and since a non-zero value indicates
         # that it was obtained, it is the preferred value.
-        # If self._minInstanceSize is less than self._minSize,
+        # If self._min_instance_size is less than self._min_size,
         # but not 0, then there must be some mistake, so better to use
-        # self._minSize.
-        return max(self._minInstanceSize, self._minSize)
+        # self._min_size.
+        return max(self._min_instance_size, self._min_size)
 
-    def _padSize(self, size):
+    def _pad_size(self, size):
         """ Return a size padded according to some inflating rules.
 
             This method was originally designed solely for minimum sizes,
@@ -338,12 +339,12 @@ def _padSize(self, size):
 
         # make sure the padded and rounded min size is not larger than
         # the current size
-        padded = min(padded.roundToNearest(self._resize.unit, rounding=ROUND_UP), self.currentSize)
+        padded = min(padded.round_to_nearest(self._resize.unit, rounding=ROUND_UP), self.current_size)
 
         return padded
 
     @property
-    def currentSize(self):
+    def current_size(self):
         """ The filesystem's current actual size. """
         return self._size if self.exists else Size(0)
 
@@ -352,10 +353,10 @@ def free(self):
         """ The amount of space that can be gained by resizing this
             filesystem to its minimum size.
         """
-        return max(Size(0), self.currentSize - self.minSize)
+        return max(Size(0), self.current_size - self.min_size)
 
-    def _preCreate(self, **kwargs):
-        super(FS, self)._preCreate(**kwargs)
+    def _pre_create(self, **kwargs):
+        super(FS, self)._pre_create(**kwargs)
         if not self._mkfs.available:
             return
 
@@ -366,29 +367,29 @@ def _create(self, **kwargs):
             :type options: list of strings
             :raises: FormatCreateError, FSError
         """
-        log_method_call(self, type=self.mountType, device=self.device,
+        log_method_call(self, type=self.mount_type, device=self.device,
                         mountpoint=self.mountpoint)
         if not self.formattable:
             return
 
         super(FS, self)._create()
         try:
-            self._mkfs.doTask(options=kwargs.get("options"), label=not self.relabels())
+            self._mkfs.do_task(options=kwargs.get("options"), label=not self.relabels())
         except FSWriteLabelError as e:
             log.warning("Choosing not to apply label (%s) during creation of filesystem %s. Label format is unacceptable for this filesystem.", self.label, self.type)
         except FSError as e:
             raise FormatCreateError(e, self.device)
 
-    def _postCreate(self, **kwargs):
-        super(FS, self)._postCreate(**kwargs)
+    def _post_create(self, **kwargs):
+        super(FS, self)._post_create(**kwargs)
         if self.label is not None and self.relabels():
             try:
-                self.writeLabel()
+                self.write_label()
             except FSError as e:
                 log.warning("Failed to write label (%s) for filesystem %s: %s", self.label, self.type, e)
 
-    def doResize(self):
-        """ Resize this filesystem based on this instance's targetSize attr.
+    def do_resize(self):
+        """ Resize this filesystem based on this instance's target_size attr.
 
             :raises: FSResizeError, FSError
         """
@@ -398,7 +399,7 @@ def doResize(self):
         if not self.resizable:
             raise FSResizeError("filesystem not resizable", self.device)
 
-        if self.targetSize == self.currentSize:
+        if self.target_size == self.current_size:
             return
 
         if not self._resize.available:
@@ -409,34 +410,34 @@ def doResize(self):
             raise FSResizeError("device does not exist", self.device)
 
         # The first minimum size can be incorrect if the fs was not
-        # properly unmounted. After doCheck the minimum size will be correct
+        # properly unmounted. After do_check the minimum size will be correct
         # so run the check one last time and bump up the size if it was too
         # small.
-        self.updateSizeInfo()
+        self.update_size_info()
 
-        # Check again if resizable is True, as updateSizeInfo() can change that
+        # Check again if resizable is True, as update_size_info() can change that
         if not self.resizable:
             raise FSResizeError("filesystem not resizable", self.device)
 
-        if self.targetSize < self.minSize:
-            self.targetSize = self.minSize
-            log.info("Minimum size changed, setting targetSize on %s to %s",
-                     self.device, self.targetSize)
+        if self.target_size < self.min_size:
+            self.target_size = self.min_size
+            log.info("Minimum size changed, setting target_size on %s to %s",
+                     self.device, self.target_size)
 
         # Bump target size to nearest whole number of the resize tool's units.
         # We always round down because the fs has to fit on whatever device
         # contains it. To round up would risk quietly setting a target size too
         # large for the device to hold.
-        rounded = self.targetSize.roundToNearest(self._resize.unit,
+        rounded = self.target_size.round_to_nearest(self._resize.unit,
                                                  rounding=ROUND_DOWN)
 
         # 1. target size was between the min size and max size values prior to
-        #    rounding (see _setTargetSize)
+        #    rounding (see _set_target_size)
         # 2. we've just rounded the target size down (or not at all)
-        # 3. the minimum size is already either rounded (see _getMinSize) or is
-        #    equal to the current size (see updateSizeInfo)
+        # 3. the minimum size is already either rounded (see _get_min_size) or is
+        #    equal to the current size (see update_size_info)
         # 5. the minimum size is less than or equal to the current size (see
-        #    _getMinSize)
+        #    _get_min_size)
         #
         # This, I think, is sufficient to guarantee that the rounded target size
         # is greater than or equal to the minimum size.
@@ -446,25 +447,25 @@ def doResize(self):
         # direction of the resize. That means the target size was less than one
         # unit larger than the current size, and we should do nothing and return
         # early.
-        if self.targetSize > self.currentSize and rounded < self.currentSize:
+        if self.target_size > self.current_size and rounded < self.current_size:
             log.info("rounding target size down to next %s obviated resize of "
-                     "filesystem on %s", unitStr(self._resize.unit), self.device)
+                     "filesystem on %s", unit_str(self._resize.unit), self.device)
             return
         else:
-            self.targetSize = rounded
+            self.target_size = rounded
 
         try:
-            self._resize.doTask()
+            self._resize.do_task()
         except FSError as e:
             raise FSResizeError(e, self.device)
 
-        self.doCheck()
+        self.do_check()
 
         # XXX must be a smarter way to do this
-        self._size = self.targetSize
-        self.notifyKernel()
+        self._size = self.target_size
+        self.notify_kernel()
 
-    def doCheck(self):
+    def do_check(self):
         """ Run a filesystem check.
 
             :raises: FSError
@@ -478,11 +479,11 @@ def doCheck(self):
         if not os.path.exists(self.device):
             raise FSError("device does not exist")
 
-        self._fsck.doTask()
+        self._fsck.do_task()
 
-    def loadModule(self):
+    def load_module(self):
         """Load whatever kernel module is required to support this filesystem."""
-        if not self._modules or self.mountType in kernel_filesystems:
+        if not self._modules or self.mount_type in kernel_filesystems:
             return
 
         for module in self._modules:
@@ -503,7 +504,7 @@ def loadModule(self):
         update_kernel_filesystems()
 
     @property
-    def systemMountpoint(self):
+    def system_mountpoint(self):
         """ Get current mountpoint
 
             returns: mountpoint
@@ -515,17 +516,17 @@ def systemMountpoint(self):
         if not self.exists:
             return None
 
-        if self._chrootedMountpoint:
-            return self._chrootedMountpoint
+        if self._chrooted_mountpoint:
+            return self._chrooted_mountpoint
 
         # It is possible to have multiple mountpoints, return the last one
         try:
-            return mountsCache.getMountpoints(self.device,
+            return mounts_cache.get_mountpoints(self.device,
                                               getattr(self, "subvolspec", None))[-1]
         except IndexError:
             return None
 
-    def testMount(self):
+    def test_mount(self):
         """ Try to mount the fs and return True if successful. """
         ret = False
 
@@ -550,7 +551,7 @@ def testMount(self):
 
         return ret
 
-    def _preSetup(self, **kwargs):
+    def _pre_setup(self, **kwargs):
         """ Check to see if the filesystem should be mounted.
 
             :keyword chroot: prefix to apply to mountpoint
@@ -570,8 +571,8 @@ def _preSetup(self, **kwargs):
         if not isinstance(self, NoDevFS) and not os.path.exists(self.device):
             raise FSError("device %s does not exist" % self.device)
 
-        chrootedMountpoint = os.path.normpath("%s/%s" % (chroot, mountpoint))
-        return self.systemMountpoint != chrootedMountpoint
+        chrooted_mountpoint = os.path.normpath("%s/%s" % (chroot, mountpoint))
+        return self.system_mountpoint != chrooted_mountpoint
 
     def _setup(self, **kwargs):
         """ Mount this filesystem.
@@ -591,18 +592,18 @@ def _setup(self, **kwargs):
         #         os.path.join("/mnt/foo", "/") -> "/"
         #
         #mountpoint = os.path.join(chroot, mountpoint)
-        chrootedMountpoint = os.path.normpath("%s/%s" % (chroot, mountpoint))
-        self._mount.doTask(chrootedMountpoint, options=options)
+        chrooted_mountpoint = os.path.normpath("%s/%s" % (chroot, mountpoint))
+        self._mount.do_task(chrooted_mountpoint, options=options)
 
         if chroot != "/":
-            self._chrootedMountpoint = chrootedMountpoint
+            self._chrooted_mountpoint = chrooted_mountpoint
 
-    def _postSetup(self, **kwargs):
+    def _post_setup(self, **kwargs):
         options = kwargs.get("options", "")
         chroot = kwargs.get("chroot", "/")
         mountpoint = kwargs.get("mountpoint") or self.mountpoint
 
-        if flags.selinux and "ro" not in self._mount.mountOptions(options).split(",") and flags.installer_mode:
+        if flags.selinux and "ro" not in self._mount.mount_options(options).split(",") and flags.installer_mode:
             ret = util.reset_file_context(mountpoint, chroot)
             if not ret:
                 log.warning("Failed to reset SElinux context for newly mounted filesystem root directory to default.")
@@ -612,12 +613,12 @@ def _postSetup(self, **kwargs):
             if not ret:
                 log.warning("Failed to set SELinux context for newly mounted filesystem lost+found directory at %s to %s", lost_and_found_path, lost_and_found_context)
 
-    def _preTeardown(self, **kwargs):
-        if not super(FS, self)._preTeardown(**kwargs):
+    def _pre_teardown(self, **kwargs):
+        if not super(FS, self)._pre_teardown(**kwargs):
             return False
 
         # Prefer the explicit mountpoint path, fall back to most recent mountpoint
-        mountpoint = kwargs.get("mountpoint") or self.systemMountpoint
+        mountpoint = kwargs.get("mountpoint") or self.system_mountpoint
 
         if not mountpoint:
             # not mounted
@@ -640,17 +641,17 @@ def _teardown(self, **kwargs):
             will be raised in either case if the path doesn't exist.
         """
 
-        mountpoint = kwargs.get("mountpoint") or self.systemMountpoint
+        mountpoint = kwargs.get("mountpoint") or self.system_mountpoint
         rc = util.umount(mountpoint)
         if rc:
             # try and catch whatever is causing the umount problem
             util.run_program(["lsof", mountpoint])
             raise FSError("umount of %s failed (%d)" % (mountpoint, rc))
 
-        if mountpoint == self._chrootedMountpoint:
-            self._chrootedMountpoint = None
+        if mountpoint == self._chrooted_mountpoint:
+            self._chrooted_mountpoint = None
 
-    def readLabel(self):
+    def read_label(self):
         """Read this filesystem's label.
 
            :return: the filesystem's label
@@ -666,9 +667,9 @@ def readLabel(self):
 
         if not self._readlabel.available:
             raise FSReadLabelError("can not read label for filesystem %s" % self.type)
-        return self._readlabel.doTask()
+        return self._readlabel.do_task()
 
-    def writeLabel(self):
+    def write_label(self):
         """ Create a label for this filesystem.
 
             :raises: FSError
@@ -687,17 +688,17 @@ def writeLabel(self):
         if not self._writelabel.available:
             raise FSError("no application to set label for filesystem %s" % self.type)
 
-        if not self.labelFormatOK(self.label):
+        if not self.label_format_ok(self.label):
             raise FSError("bad label format for labelling application %s" % self._writelabel)
 
         if not os.path.exists(self.device):
             raise FSError("device does not exist")
 
-        self._writelabel.doTask()
-        self.notifyKernel()
+        self._writelabel.do_task()
+        self.notify_kernel()
 
     @property
-    def utilsAvailable(self):
+    def utils_available(self):
         # we aren't checking for fsck because we shouldn't need it
         tasks = (self._mkfs, self._resize, self._writelabel, self._info)
         return all(not t.implemented or t.available for t in tasks)
@@ -705,7 +706,7 @@ def utilsAvailable(self):
     @property
     def supported(self):
         log_method_call(self, supported=self._supported)
-        return super(FS, self).supported and self.utilsAvailable
+        return super(FS, self).supported and self.utils_available
 
     @property
     def controllable(self):
@@ -724,15 +725,15 @@ def resizable(self):
         """ Can formats of this filesystem type be resized? """
         return super(FS, self).resizable and self._resize.available
 
-    def _getOptions(self):
+    def _get_options(self):
         return self.mountopts or ",".join(self._mount.options)
 
-    def _setOptions(self, options):
+    def _set_options(self, options):
         self.mountopts = options
 
     @property
-    def mountType(self):
-        return self._mount.mountType
+    def mount_type(self):
+        return self._mount.mount_type
 
     # These methods just wrap filesystem-specific methods in more
     # generically named methods so filesystems and formatted devices
@@ -769,7 +770,7 @@ def unmount(self, **kwargs):
     def status(self):
         if not self.exists:
             return False
-        return self.systemMountpoint is not None
+        return self.system_mountpoint is not None
 
     def sync(self, root='/'):
         """ Ensure that data we've written is at least in the journal.
@@ -779,18 +780,18 @@ def sync(self, root='/'):
             This is a little odd because xfs_freeze will only be
             available under the install root.
         """
-        if not self.status or not self.systemMountpoint or \
-            not self.systemMountpoint.startswith(root) or \
+        if not self.status or not self.system_mountpoint or \
+            not self.system_mountpoint.startswith(root) or \
             not self._sync.available:
             return
 
         try:
-            self._sync.doTask(root)
+            self._sync.do_task(root)
         except FSError as e:
             log.error(e)
 
-    def populateKSData(self, data):
-        super(FS, self).populateKSData(data)
+    def populate_ksdata(self, data):
+        super(FS, self).populate_ksdata(data)
         data.mountpoint = self.mountpoint or "none"
         data.label = self.label or ""
         if self.options != "defaults":
@@ -798,7 +799,7 @@ def populateKSData(self, data):
         else:
             data.fsopts = ""
 
-        data.mkfsopts = self.createOptions or ""
+        data.mkfsopts = self.create_options or ""
         data.fsprofile = self.fsprofile or ""
 
 class Ext2FS(FS):
@@ -810,19 +811,19 @@ class Ext2FS(FS):
     _formattable = True
     _supported = True
     _resizable = True
-    _linuxNative = True
-    _maxSize = Size("8 TiB")
+    _linux_native = True
+    _max_size = Size("8 TiB")
     _dump = True
     _check = True
-    _fsckClass = fsck.Ext2FSCK
-    _infoClass = fsinfo.Ext2FSInfo
-    _minsizeClass = fsminsize.Ext2FSMinSize
-    _mkfsClass = fsmkfs.Ext2FSMkfs
-    _readlabelClass = fsreadlabel.Ext2FSReadLabel
-    _resizeClass = fsresize.Ext2FSResize
-    _sizeinfoClass = fssize.Ext2FSSize
-    _writelabelClass = fswritelabel.Ext2FSWriteLabel
-    partedSystem = fileSystemType["ext2"]
+    _fsck_class = fsck.Ext2FSCK
+    _info_class = fsinfo.Ext2FSInfo
+    _minsize_class = fsminsize.Ext2FSMinSize
+    _mkfs_class = fsmkfs.Ext2FSMkfs
+    _readlabel_class = fsreadlabel.Ext2FSReadLabel
+    _resize_class = fsresize.Ext2FSResize
+    _size_info_class = fssize.Ext2FSSize
+    _writelabel_class = fswritelabel.Ext2FSWriteLabel
+    parted_system = fileSystemType["ext2"]
     _MetadataSizeFactor = 0.93 # ext2 metadata may take 7% of space
 
 register_device_format(Ext2FS)
@@ -832,14 +833,14 @@ class Ext3FS(Ext2FS):
     """ ext3 filesystem. """
     _type = "ext3"
     _modules = ["ext3"]
-    partedSystem = fileSystemType["ext3"]
-    _mkfsClass = fsmkfs.Ext3FSMkfs
+    parted_system = fileSystemType["ext3"]
+    _mkfs_class = fsmkfs.Ext3FSMkfs
 
     # It is possible for a user to specify an fsprofile that defines a blocksize
     # smaller than the default of 4096 bytes and therefore to make liars of us
     # with regard to this maximum filesystem size, but if they're doing such
     # things they should know the implications of their chosen block size.
-    _maxSize = Size("16 TiB")
+    _max_size = Size("16 TiB")
     _MetadataSizeFactor = 0.90 # ext3 metadata may take 10% of space
 
 register_device_format(Ext3FS)
@@ -849,9 +850,9 @@ class Ext4FS(Ext3FS):
     """ ext4 filesystem. """
     _type = "ext4"
     _modules = ["ext4"]
-    _mkfsClass = fsmkfs.Ext4FSMkfs
-    partedSystem = fileSystemType["ext4"]
-    _maxSize = Size("1 EiB")
+    _mkfs_class = fsmkfs.Ext4FSMkfs
+    parted_system = fileSystemType["ext4"]
+    _max_size = Size("1 EiB")
     _MetadataSizeFactor = 0.85 # ext4 metadata may take 15% of space
 
 register_device_format(Ext4FS)
@@ -864,16 +865,16 @@ class FATFS(FS):
     _labelfs = fslabeling.FATFSLabeling()
     _supported = True
     _formattable = True
-    _maxSize = Size("1 TiB")
+    _max_size = Size("1 TiB")
     _packages = [ "dosfstools" ]
-    _fsckClass = fsck.DosFSCK
-    _mkfsClass = fsmkfs.FATFSMkfs
-    _mountClass = fsmount.FATFSMount
-    _readlabelClass = fsreadlabel.DosFSReadLabel
-    _writelabelClass = fswritelabel.DosFSWriteLabel
+    _fsck_class = fsck.DosFSCK
+    _mkfs_class = fsmkfs.FATFSMkfs
+    _mount_class = fsmount.FATFSMount
+    _readlabel_class = fsreadlabel.DosFSReadLabel
+    _writelabel_class = fswritelabel.DosFSWriteLabel
     _MetadataSizeFactor = 0.99 # fat metadata may take 1% of space
     # FIXME this should be fat32 in some cases
-    partedSystem = fileSystemType["fat16"]
+    parted_system = fileSystemType["fat16"]
 
 register_device_format(FATFS)
 
@@ -881,9 +882,9 @@ class FATFS(FS):
 class EFIFS(FATFS):
     _type = "efi"
     _name = N_("EFI System Partition")
-    _minSize = Size("50 MiB")
+    _min_size = Size("50 MiB")
     _check = True
-    _mountClass = fsmount.EFIFSMount
+    _mount_class = fsmount.EFIFSMount
 
     @property
     def supported(self):
@@ -897,20 +898,20 @@ class BTRFS(FS):
     _type = "btrfs"
     _modules = ["btrfs"]
     _formattable = True
-    _linuxNative = True
+    _linux_native = True
     _supported = True
     _packages = ["btrfs-progs"]
-    _minSize = Size("256 MiB")
-    _maxSize = Size("16 EiB")
-    _mkfsClass = fsmkfs.BTRFSMkfs
+    _min_size = Size("256 MiB")
+    _max_size = Size("16 EiB")
+    _mkfs_class = fsmkfs.BTRFSMkfs
     _MetadataSizeFactor = 0.80 # btrfs metadata may take 20% of space
     # FIXME parted needs to be taught about btrfs so that we can set the
     # partition table type correctly for btrfs partitions
-    # partedSystem = fileSystemType["btrfs"]
+    # parted_system = fileSystemType["btrfs"]
 
     def __init__(self, **kwargs):
         super(BTRFS, self).__init__(**kwargs)
-        self.volUUID = kwargs.pop("volUUID", None)
+        self.vol_uuid = kwargs.pop("vol_uuid", None)
         self.subvolspec = kwargs.pop("subvolspec", None)
 
     def create(self, **kwargs):
@@ -921,8 +922,8 @@ def destroy(self, **kwargs):
         # filesystem deletion is done in blockdev.btrfs.delete_volume
         self.exists = False
 
-    def _preSetup(self, **kwargs):
-        log_method_call(self, type=self.mountType, device=self.device,
+    def _pre_setup(self, **kwargs):
+        log_method_call(self, type=self.mount_type, device=self.device,
                         mountpoint=self.mountpoint or kwargs.get("mountpoint"))
         # Since btrfs vols have subvols the format setup is automatic.
         # Don't try to mount it if there's no mountpoint.
@@ -936,19 +937,19 @@ class GFS2(FS):
     _type = "gfs2"
     _modules = ["dlm", "gfs2"]
     _formattable = True
-    _linuxNative = True
+    _linux_native = True
     _dump = True
     _check = True
     _packages = ["gfs2-utils"]
-    _mkfsClass = fsmkfs.GFS2Mkfs
+    _mkfs_class = fsmkfs.GFS2Mkfs
     # FIXME parted needs to be thaught about btrfs so that we can set the
     # partition table type correctly for btrfs partitions
-    # partedSystem = fileSystemType["gfs2"]
+    # parted_system = fileSystemType["gfs2"]
 
     @property
     def supported(self):
         """ Is this filesystem a supported type? """
-        return self.utilsAvailable if flags.gfs2 else self._supported
+        return self.utils_available if flags.gfs2 else self._supported
 
 register_device_format(GFS2)
 
@@ -958,22 +959,22 @@ class JFS(FS):
     _type = "jfs"
     _modules = ["jfs"]
     _labelfs = fslabeling.JFSLabeling()
-    _maxSize = Size("8 TiB")
+    _max_size = Size("8 TiB")
     _formattable = True
-    _linuxNative = True
+    _linux_native = True
     _dump = True
     _check = True
-    _infoClass = fsinfo.JFSInfo
-    _mkfsClass = fsmkfs.JFSMkfs
-    _sizeinfoClass = fssize.JFSSize
-    _writelabelClass = fswritelabel.JFSWriteLabel
+    _info_class = fsinfo.JFSInfo
+    _mkfs_class = fsmkfs.JFSMkfs
+    _size_info_class = fssize.JFSSize
+    _writelabel_class = fswritelabel.JFSWriteLabel
     _MetadataSizeFactor = 0.99 # jfs metadata may take 1% of space
-    partedSystem = fileSystemType["jfs"]
+    parted_system = fileSystemType["jfs"]
 
     @property
     def supported(self):
         """ Is this filesystem a supported type? """
-        return self.utilsAvailable if flags.jfs else self._supported
+        return self.utils_available if flags.jfs else self._supported
 
 register_device_format(JFS)
 
@@ -983,23 +984,23 @@ class ReiserFS(FS):
     _type = "reiserfs"
     _labelfs = fslabeling.ReiserFSLabeling()
     _modules = ["reiserfs"]
-    _maxSize = Size("16 TiB")
+    _max_size = Size("16 TiB")
     _formattable = True
-    _linuxNative = True
+    _linux_native = True
     _dump = True
     _check = True
     _packages = ["reiserfs-utils"]
-    _infoClass = fsinfo.ReiserFSInfo
-    _mkfsClass = fsmkfs.ReiserFSMkfs
-    _sizeinfoClass = fssize.ReiserFSSize
-    _writelabelClass = fswritelabel.ReiserFSWriteLabel
+    _info_class = fsinfo.ReiserFSInfo
+    _mkfs_class = fsmkfs.ReiserFSMkfs
+    _size_info_class = fssize.ReiserFSSize
+    _writelabel_class = fswritelabel.ReiserFSWriteLabel
     _MetadataSizeFactor = 0.98 # reiserfs metadata may take 2% of space
-    partedSystem = fileSystemType["reiserfs"]
+    parted_system = fileSystemType["reiserfs"]
 
     @property
     def supported(self):
         """ Is this filesystem a supported type? """
-        return self.utilsAvailable if flags.reiserfs else self._supported
+        return self.utils_available if flags.reiserfs else self._supported
 
 register_device_format(ReiserFS)
 
@@ -1009,19 +1010,19 @@ class XFS(FS):
     _type = "xfs"
     _modules = ["xfs"]
     _labelfs = fslabeling.XFSLabeling()
-    _maxSize = Size("16 EiB")
+    _max_size = Size("16 EiB")
     _formattable = True
-    _linuxNative = True
+    _linux_native = True
     _supported = True
     _packages = ["xfsprogs"]
-    _infoClass = fsinfo.XFSInfo
-    _mkfsClass = fsmkfs.XFSMkfs
-    _readlabelClass = fsreadlabel.XFSReadLabel
-    _sizeinfoClass = fssize.XFSSize
-    _syncClass = fssync.XFSSync
-    _writelabelClass = fswritelabel.XFSWriteLabel
+    _info_class = fsinfo.XFSInfo
+    _mkfs_class = fsmkfs.XFSMkfs
+    _readlabel_class = fsreadlabel.XFSReadLabel
+    _size_info_class = fssize.XFSSize
+    _sync_class = fssync.XFSSync
+    _writelabel_class = fswritelabel.XFSWriteLabel
     _MetadataSizeFactor = 0.97 # xfs metadata may take 3% of space
-    partedSystem = fileSystemType["xfs"]
+    parted_system = fileSystemType["xfs"]
 
 
 register_device_format(XFS)
@@ -1031,8 +1032,8 @@ class HFS(FS):
     _modules = ["hfs"]
     _labelfs = fslabeling.HFSLabeling()
     _formattable = True
-    _mkfsClass = fsmkfs.HFSMkfs
-    partedSystem = fileSystemType["hfs"]
+    _mkfs_class = fsmkfs.HFSMkfs
+    parted_system = fileSystemType["hfs"]
 
 register_device_format(HFS)
 
@@ -1040,10 +1041,10 @@ class HFS(FS):
 class AppleBootstrapFS(HFS):
     _type = "appleboot"
     _name = N_("Apple Bootstrap")
-    _minSize = Size("768 KiB")
-    _maxSize = Size("1 MiB")
+    _min_size = Size("768 KiB")
+    _max_size = Size("1 MiB")
     _supported = True
-    _mountClass = fsmount.AppleBootstrapFSMount
+    _mount_class = fsmount.AppleBootstrapFSMount
 
     @property
     def supported(self):
@@ -1055,17 +1056,17 @@ def supported(self):
 class HFSPlus(FS):
     _type = "hfs+"
     _modules = ["hfsplus"]
-    _udevTypes = ["hfsplus"]
+    _udev_types = ["hfsplus"]
     _packages = ["hfsplus-tools"]
     _labelfs = fslabeling.HFSPlusLabeling()
     _formattable = True
-    _minSize = Size("1 MiB")
-    _maxSize = Size("2 TiB")
+    _min_size = Size("1 MiB")
+    _max_size = Size("2 TiB")
     _check = True
-    partedSystem = fileSystemType["hfs+"]
-    _fsckClass = fsck.HFSPlusFSCK
-    _mkfsClass = fsmkfs.HFSPlusMkfs
-    _mountClass = fsmount.HFSPlusMount
+    parted_system = fileSystemType["hfs+"]
+    _fsck_class = fsck.HFSPlusFSCK
+    _mkfs_class = fsmkfs.HFSPlusMkfs
+    _mount_class = fsmount.HFSPlusMount
 
 register_device_format(HFSPlus)
 
@@ -1073,8 +1074,8 @@ class HFSPlus(FS):
 class MacEFIFS(HFSPlus):
     _type = "macefi"
     _name = N_("Linux HFS+ ESP")
-    _udevTypes = []
-    _minSize = Size("50 MiB")
+    _udev_types = []
+    _min_size = Size("50 MiB")
     _supported = True
 
     @property
@@ -1094,19 +1095,19 @@ class NTFS(FS):
     _type = "ntfs"
     _labelfs = fslabeling.NTFSLabeling()
     _resizable = True
-    _minSize = Size("1 MiB")
-    _maxSize = Size("16 TiB")
+    _min_size = Size("1 MiB")
+    _max_size = Size("16 TiB")
     _packages = ["ntfsprogs"]
-    _fsckClass = fsck.NTFSFSCK
-    _infoClass = fsinfo.NTFSInfo
-    _minsizeClass = fsminsize.NTFSMinSize
-    _mkfsClass = fsmkfs.NTFSMkfs
-    _mountClass = fsmount.NTFSMount
-    _readlabelClass = fsreadlabel.NTFSReadLabel
-    _resizeClass = fsresize.NTFSResize
-    _sizeinfoClass = fssize.NTFSSize
-    _writelabelClass = fswritelabel.NTFSWriteLabel
-    partedSystem = fileSystemType["ntfs"]
+    _fsck_class = fsck.NTFSFSCK
+    _info_class = fsinfo.NTFSInfo
+    _minsize_class = fsminsize.NTFSMinSize
+    _mkfs_class = fsmkfs.NTFSMkfs
+    _mount_class = fsmount.NTFSMount
+    _readlabel_class = fsreadlabel.NTFSReadLabel
+    _resize_class = fsresize.NTFSResize
+    _size_info_class = fssize.NTFSSize
+    _writelabel_class = fswritelabel.NTFSWriteLabel
+    parted_system = fileSystemType["ntfs"]
 
 register_device_format(NTFS)
 
@@ -1116,9 +1117,9 @@ class NFS(FS):
     """ NFS filesystem. """
     _type = "nfs"
     _modules = ["nfs"]
-    _mountClass = fsmount.NFSMount
+    _mount_class = fsmount.NFSMount
 
-    def _deviceCheck(self, devspec):
+    def _device_check(self, devspec):
         if devspec is not None and ":" not in devspec:
             return "device must be of the form <host>:<path>"
         return None
@@ -1138,7 +1139,7 @@ class Iso9660FS(FS):
     """ ISO9660 filesystem. """
     _type = "iso9660"
     _supported = True
-    _mountClass = fsmount.Iso9660FSMount
+    _mount_class = fsmount.Iso9660FSMount
 
 register_device_format(Iso9660FS)
 
@@ -1146,21 +1147,21 @@ class Iso9660FS(FS):
 class NoDevFS(FS):
     """ nodev filesystem base class """
     _type = "nodev"
-    _mountClass = fsmount.NoDevFSMount
+    _mount_class = fsmount.NoDevFSMount
 
     def __init__(self, **kwargs):
         FS.__init__(self, **kwargs)
         self.exists = True
         self.device = self._type
 
-    def _deviceCheck(self, devspec):
+    def _device_check(self, devspec):
         return None
 
     @property
     def type(self):
         return self.device
 
-    def notifyKernel(self):
+    def notify_kernel(self):
         # NoDevFS should not need to tell the kernel anything.
         pass
 
@@ -1170,7 +1171,7 @@ def notifyKernel(self):
 class DevPtsFS(NoDevFS):
     """ devpts filesystem. """
     _type = "devpts"
-    _mountClass = fsmount.DevPtsFSMount
+    _mount_class = fsmount.DevPtsFSMount
 
 register_device_format(DevPtsFS)
 
@@ -1195,14 +1196,14 @@ class TmpFS(NoDevFS):
     # the size of a live tmpfs mount
     # as tmpfs is part of the Linux kernel,
     # it is Linux-native
-    _linuxNative = True
+    _linux_native = True
     # in a sense, I guess tmpfs is formattable
     # in the regard that the format is automatically created
     # once mounted
     _formattable = True
-    _sizeinfoClass = fssize.TmpFSSize
-    _mountClass = fsmount.TmpFSMount
-    _resizeClass = fsresize.TmpFSResize
+    _size_info_class = fssize.TmpFSSize
+    _mount_class = fsmount.TmpFSMount
+    _resize_class = fsresize.TmpFSResize
 
     def __init__(self, **kwargs):
         NoDevFS.__init__(self, **kwargs)
@@ -1212,11 +1213,11 @@ def __init__(self, **kwargs):
         # http://www.gossamer-threads.com/lists/linux/kernel/875278
         # maximum tmpfs mount size is 16TB on 32 bit systems
         # and 16EB on 64 bit systems
-        bits = arch.numBits()
+        bits = arch.num_bits()
         if bits == 32:
-            self._maxSize = Size("16TiB")
+            self._max_size = Size("16TiB")
         elif bits == 64:
-            self._maxSize = Size("16EiB")
+            self._max_size = Size("16EiB")
         # if the architecture is other than 32 or 64 bit or unknown
         # just use the default maxsize, which is 0, this disables
         # resizing but other operations such as mounting should work fine
@@ -1235,7 +1236,7 @@ def destroy(self, *args, **kwargs):
         """
         pass
 
-    def _sizeOption(self, size):
+    def _size_option(self, size):
         """ Returns a size option string appropriate for mounting tmpfs.
 
             :param Size size: any size
@@ -1247,31 +1248,31 @@ def _sizeOption(self, size):
             This is not impossible, since a special option for mounting
             is size=<percentage>%.
         """
-        return "size=%s" % (self._resize.size_fmt % size.convertTo(self._resize.unit))
+        return "size=%s" % (self._resize.size_fmt % size.convert_to(self._resize.unit))
 
-    def _getOptions(self):
+    def _get_options(self):
         # Returns the regular mount options with the special size option,
         # if any, appended.
         # The size option should be last, as the regular mount options may
         # also contain a size option, but the later size option supercedes
         # the earlier one.
-        opts = super(TmpFS, self)._getOptions()
+        opts = super(TmpFS, self)._get_options()
         if self._accept_default_size:
             size_opt = None
         else:
-            size_opt = self._sizeOption(self._size)
+            size_opt = self._size_option(self._size)
         return ",".join(o for o in (opts, size_opt) if o)
 
     @property
     def free(self):
-        if self.systemMountpoint:
-            # If self.systemMountpoint is defined, it means this tmpfs mount
+        if self.system_mountpoint:
+            # If self.system_mountpoint is defined, it means this tmpfs mount
             # has been mounted and there is a path we can use as a handle to
             # look-up the free space on the filesystem.
             # When running with changeroot, such as during installation,
-            # self.systemMountpoint is set to the full changeroot path once
+            # self.system_mountpoint is set to the full changeroot path once
             # mounted so even with changeroot, statvfs should still work fine.
-            st = util.eintr_retry_call(os.statvfs, self.systemMountpoint)
+            st = util.eintr_retry_call(os.statvfs, self.system_mountpoint)
             free_space = Size(st.f_bavail*st.f_frsize)
         else:
             # Free might be called even if the tmpfs mount has not been
@@ -1281,11 +1282,11 @@ def free(self):
             free_space = self._size
         return free_space
 
-    def _getDevice(self):
+    def _get_device(self):
         """ All the tmpfs mounts use the same "tmpfs" device. """
         return self._type
 
-    def _setDevice(self, value):
+    def _set_device(self, value):
         # the DeviceFormat parent class does a
         # self.device = kwargs["device"]
         # assignment, so we need a setter for the
@@ -1293,11 +1294,11 @@ def _setDevice(self, value):
         # same, nothing actually needs to be set
         pass
 
-    def doResize(self):
+    def do_resize(self):
         # Override superclass method to record whether mount options
         # should include an explicit size specification.
         original_size = self._size
-        FS.doResize(self)
+        FS.do_resize(self)
         self._accept_default_size = self._accept_default_size and original_size == self._size
 
 register_device_format(TmpFS)
@@ -1305,14 +1306,14 @@ def doResize(self):
 
 class BindFS(FS):
     _type = "bind"
-    _mountClass = fsmount.BindFSMount
+    _mount_class = fsmount.BindFSMount
 
 register_device_format(BindFS)
 
 
 class SELinuxFS(NoDevFS):
     _type = "selinuxfs"
-    _mountClass = fsmount.SELinuxFSMount
+    _mount_class = fsmount.SELinuxFSMount
 
 register_device_format(SELinuxFS)
 
diff --git a/blivet/formats/luks.py b/blivet/formats/luks.py
index fae61f5..743faa4 100644
--- a/blivet/formats/luks.py
+++ b/blivet/formats/luks.py
@@ -43,12 +43,12 @@ class LUKS(DeviceFormat):
     """ LUKS """
     _type = "luks"
     _name = N_("LUKS")
-    _lockedName = N_("Encrypted")
-    _udevTypes = ["crypto_LUKS"]
+    _locked_name = N_("Encrypted")
+    _udev_types = ["crypto_LUKS"]
     _formattable = True                 # can be formatted
-    _linuxNative = True                 # for clearpart
+    _linux_native = True                 # for clearpart
     _packages = ["cryptsetup"]          # required packages
-    _minSize = crypto.LUKS_METADATA_SIZE
+    _min_size = crypto.LUKS_METADATA_SIZE
     _plugin = availability.BLOCKDEV_CRYPTO_PLUGIN
 
     def __init__(self, **kwargs):
@@ -86,7 +86,7 @@ def __init__(self, **kwargs):
         DeviceFormat.__init__(self, **kwargs)
         self.cipher = kwargs.get("cipher")
         self.key_size = kwargs.get("key_size")
-        self.mapName = kwargs.get("name")
+        self.map_name = kwargs.get("name")
 
         if not self.exists and not self.cipher:
             self.cipher = "aes-xts-plain64"
@@ -105,10 +105,10 @@ def __init__(self, **kwargs):
             msg = "Invalid value for minimum required entropy: %s" % self.min_luks_entropy
             raise ValueError(msg)
 
-        if not self.mapName and self.exists and self.uuid:
-            self.mapName = "luks-%s" % self.uuid
-        elif not self.mapName and self.device:
-            self.mapName = "luks-%s" % os.path.basename(self.device)
+        if not self.map_name and self.exists and self.uuid:
+            self.map_name = "luks-%s" % self.uuid
+        elif not self.map_name and self.device:
+            self.map_name = "luks-%s" % os.path.basename(self.device)
 
     def __repr__(self):
         s = DeviceFormat.__repr__(self)
@@ -116,42 +116,42 @@ def __repr__(self):
             passphrase = "(set)"
         else:
             passphrase = "(not set)"
-        s += ("  cipher = %(cipher)s  keySize = %(keySize)s"
-              "  mapName = %(mapName)s\n"
-              "  keyFile = %(keyFile)s  passphrase = %(passphrase)s\n"
-              "  escrowCert = %(escrowCert)s  addBackup = %(backup)s" %
-              {"cipher": self.cipher, "keySize": self.key_size,
-               "mapName": self.mapName, "keyFile": self._key_file,
-               "passphrase": passphrase, "escrowCert": self.escrow_cert,
+        s += ("  cipher = %(cipher)s  key_size = %(key_size)s"
+              "  map_name = %(map_name)s\n"
+              "  key_file = %(key_file)s  passphrase = %(passphrase)s\n"
+              "  escrow_cert = %(escrow_cert)s  add_backup = %(backup)s" %
+              {"cipher": self.cipher, "key_size": self.key_size,
+               "map_name": self.map_name, "key_file": self._key_file,
+               "passphrase": passphrase, "escrow_cert": self.escrow_cert,
                "backup": self.add_backup_passphrase})
         return s
 
     @property
     def dict(self):
         d = super(LUKS, self).dict
-        d.update({"cipher": self.cipher, "keySize": self.key_size,
-                  "mapName": self.mapName, "hasKey": self.hasKey,
-                  "escrowCert": self.escrow_cert,
+        d.update({"cipher": self.cipher, "key_size": self.key_size,
+                  "map_name": self.map_name, "has_key": self.has_key,
+                  "escrow_cert": self.escrow_cert,
                   "backup": self.add_backup_passphrase})
         return d
 
     @property
     def name(self):
         # for existing locked devices, show "Encrypted" instead of LUKS
-        if self.hasKey or not self.exists:
+        if self.has_key or not self.exists:
             name = _(self._name)
         else:
-            name = "%s (%s)" % (_(self._lockedName), _(self._name))
+            name = "%s (%s)" % (_(self._locked_name), _(self._name))
         return name
 
-    def _setPassphrase(self, passphrase):
+    def _set_passphrase(self, passphrase):
         """ Set the passphrase used to access this device. """
         self.__passphrase = passphrase
 
-    passphrase = property(fset=_setPassphrase)
+    passphrase = property(fset=_set_passphrase)
 
     @property
-    def hasKey(self):
+    def has_key(self):
         return ((self.__passphrase not in ["", None]) or
                 (self._key_file and os.access(self._key_file, os.R_OK)))
 
@@ -170,25 +170,25 @@ def controllable(self):
     @property
     def configured(self):
         """ To be ready we need a key or passphrase and a map name. """
-        return self.hasKey and self.mapName
+        return self.has_key and self.map_name
 
     @property
     def status(self):
-        if not self.exists or not self.mapName:
+        if not self.exists or not self.map_name:
             return False
-        return os.path.exists("/dev/mapper/%s" % self.mapName)
+        return os.path.exists("/dev/mapper/%s" % self.map_name)
 
-    def _preSetup(self, **kwargs):
+    def _pre_setup(self, **kwargs):
         if not self.configured:
             raise LUKSError("luks device not configured")
 
-        return super(LUKS, self)._preSetup(**kwargs)
+        return super(LUKS, self)._pre_setup(**kwargs)
 
     def _setup(self, **kwargs):
-        log_method_call(self, device=self.device, mapName=self.mapName,
+        log_method_call(self, device=self.device, map_name=self.map_name,
                         type=self.type, status=self.status)
         try:
-            blockdev.crypto.luks_open(self.device, self.mapName,
+            blockdev.crypto.luks_open(self.device, self.map_name,
                                       passphrase=self.__passphrase,
                                       key_file=self._key_file)
         except blockdev.CryptoError as e:
@@ -198,12 +198,12 @@ def _teardown(self, **kwargs):
         """ Close, or tear down, the format. """
         log_method_call(self, device=self.device,
                         type=self.type, status=self.status)
-        log.debug("unmapping %s", self.mapName)
-        blockdev.crypto.luks_close(self.mapName)
+        log.debug("unmapping %s", self.map_name)
+        blockdev.crypto.luks_close(self.map_name)
 
-    def _preCreate(self, **kwargs):
-        super(LUKS, self)._preCreate(**kwargs)
-        if not self.hasKey:
+    def _pre_create(self, **kwargs):
+        super(LUKS, self)._pre_create(**kwargs)
+        if not self.has_key:
             raise LUKSError("luks device has no key/passphrase")
 
     def _create(self, **kwargs):
@@ -217,22 +217,22 @@ def _create(self, **kwargs):
                                     key_size=self.key_size,
                                     min_entropy=self.min_luks_entropy)
 
-    def _postCreate(self, **kwargs):
-        super(LUKS, self)._postCreate(**kwargs)
+    def _post_create(self, **kwargs):
+        super(LUKS, self)._post_create(**kwargs)
         self.uuid = blockdev.crypto.luks_uuid(self.device)
-        if flags.installer_mode or not self.mapName:
-            self.mapName = "luks-%s" % self.uuid
+        if flags.installer_mode or not self.map_name:
+            self.map_name = "luks-%s" % self.uuid
 
     @property
     def destroyable(self):
         return self._plugin.available
 
     @property
-    def keyFile(self):
+    def key_file(self):
         """ Path to key file to be used in /etc/crypttab """
         return self._key_file
 
-    def addPassphrase(self, passphrase):
+    def add_passphrase(self, passphrase):
         """ Add a new passphrase.
 
             Add the specified passphrase to an available key slot in the
@@ -248,7 +248,7 @@ def addPassphrase(self, passphrase):
                                      key_file=self._key_file,
                                      npass=passphrase)
 
-    def removePassphrase(self):
+    def remove_passphrase(self):
         """
         Remove the saved passphrase (and possibly key file) from the LUKS
         header.
@@ -264,11 +264,11 @@ def removePassphrase(self):
                                         pass_=self.__passphrase,
                                         key_file=self._key_file)
 
-    def escrow(self, directory, backupPassphrase):
-        log.debug("escrow: escrowVolume start for %s", self.device)
+    def escrow(self, directory, backup_passphrase):
+        log.debug("escrow: escrow_volume start for %s", self.device)
         blockdev.crypto.escrow_device(self.device, self.__passphrase, self.escrow_cert,
-                                      directory, backupPassphrase)
-        log.debug("escrow: escrowVolume done for %s", repr(self.device))
+                                      directory, backup_passphrase)
+        log.debug("escrow: escrow_volume done for %s", repr(self.device))
 
 
 register_device_format(LUKS)
diff --git a/blivet/formats/lvmpv.py b/blivet/formats/lvmpv.py
index ee3e29e..b3fdc14 100644
--- a/blivet/formats/lvmpv.py
+++ b/blivet/formats/lvmpv.py
@@ -43,14 +43,14 @@ class LVMPhysicalVolume(DeviceFormat):
     """ An LVM physical volume. """
     _type = "lvmpv"
     _name = N_("physical volume (LVM)")
-    _udevTypes = ["LVM2_member"]
-    partedFlag = PARTITION_LVM
+    _udev_types = ["LVM2_member"]
+    parted_flag = PARTITION_LVM
     _formattable = True                 # can be formatted
     _supported = True                   # is supported
-    _linuxNative = True                 # for clearpart
-    _minSize = lvm.LVM_PE_SIZE * 2      # one for metadata and one for data
+    _linux_native = True                 # for clearpart
+    _min_size = lvm.LVM_PE_SIZE * 2      # one for metadata and one for data
     _packages = ["lvm2"]                # required packages
-    _ksMountpoint = "pv."
+    _ks_mountpoint = "pv."
     _plugin = availability.BLOCKDEV_LVM_PLUGIN
 
     def __init__(self, **kwargs):
@@ -59,12 +59,12 @@ def __init__(self, **kwargs):
             :keyword uuid: this PV's uuid (not the VG uuid)
             :keyword exists: indicates whether this is an existing format
             :type exists: bool
-            :keyword vgName: the name of the VG this PV belongs to
-            :keyword vgUuid: the UUID of the VG this PV belongs to
-            :keyword peStart: offset of first physical extent
-            :type peStart: :class:`~.size.Size`
-            :keyword dataAlignment: data alignment (for non-existent PVs)
-            :type dataAlignment: :class:`~.size.Size`
+            :keyword vg_name: the name of the VG this PV belongs to
+            :keyword vg_uuid: the UUID of the VG this PV belongs to
+            :keyword pe_start: offset of first physical extent
+            :type pe_start: :class:`~.size.Size`
+            :keyword data_alignment: data alignment (for non-existent PVs)
+            :type data_alignment: :class:`~.size.Size`
 
             .. note::
 
@@ -76,26 +76,26 @@ def __init__(self, **kwargs):
         """
         log_method_call(self, **kwargs)
         DeviceFormat.__init__(self, **kwargs)
-        self.vgName = kwargs.get("vgName")
-        self.vgUuid = kwargs.get("vgUuid")
-        self.peStart = kwargs.get("peStart", lvm.LVM_PE_START)
-        self.dataAlignment = kwargs.get("dataAlignment", Size(0))
+        self.vg_name = kwargs.get("vg_name")
+        self.vg_uuid = kwargs.get("vg_uuid")
+        self.pe_start = kwargs.get("pe_start", lvm.LVM_PE_START)
+        self.data_alignment = kwargs.get("data_alignment", Size(0))
 
-        self.inconsistentVG = False
+        self.inconsistent_vg = False
 
     def __repr__(self):
         s = DeviceFormat.__repr__(self)
-        s += ("  vgName = %(vgName)s  vgUUID = %(vgUUID)s"
-              "  peStart = %(peStart)s  dataAlignment = %(dataAlignment)s" %
-              {"vgName": self.vgName, "vgUUID": self.vgUuid,
-               "peStart": self.peStart, "dataAlignment": self.dataAlignment})
+        s += ("  vg_name = %(vg_name)s  vg_uuid = %(vg_uuid)s"
+              "  pe_start = %(pe_start)s  data_alignment = %(data_alignment)s" %
+              {"vg_name": self.vg_name, "vg_uuid": self.vg_uuid,
+               "pe_start": self.pe_start, "data_alignment": self.data_alignment})
         return s
 
     @property
     def dict(self):
         d = super(LVMPhysicalVolume, self).dict
-        d.update({"vgName": self.vgName, "vgUUID": self.vgUuid,
-                  "peStart": self.peStart, "dataAlignment": self.dataAlignment})
+        d.update({"vg_name": self.vg_name, "vg_uuid": self.vg_uuid,
+                  "pe_start": self.pe_start, "data_alignment": self.data_alignment})
         return d
 
     @property
@@ -119,7 +119,7 @@ def _create(self, **kwargs):
         #     for destroy by calling _destroy directly.
         DeviceFormat._destroy(self, **kwargs)
         blockdev.lvm.pvscan(self.device)
-        blockdev.lvm.pvcreate(self.device, data_alignment=self.dataAlignment)
+        blockdev.lvm.pvcreate(self.device, data_alignment=self.data_alignment)
         blockdev.lvm.pvscan(self.device)
 
     def _destroy(self, **kwargs):
@@ -139,8 +139,8 @@ def destroyable(self):
     @property
     def status(self):
         # XXX hack
-        return (self.exists and self.vgName and
-                os.path.isdir("/dev/%s" % self.vgName))
+        return (self.exists and self.vg_name and
+                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 ea5da1f..edd33a8 100644
--- a/blivet/formats/mdraid.py
+++ b/blivet/formats/mdraid.py
@@ -40,13 +40,13 @@ class MDRaidMember(DeviceFormat):
     """ An mdraid member disk. """
     _type = "mdmember"
     _name = N_("software RAID")
-    _udevTypes = ["linux_raid_member"]
-    partedFlag = PARTITION_RAID
+    _udev_types = ["linux_raid_member"]
+    parted_flag = PARTITION_RAID
     _formattable = True                 # can be formatted
     _supported = True                   # is supported
-    _linuxNative = True                 # for clearpart
+    _linux_native = True                 # for clearpart
     _packages = ["mdadm"]               # required packages
-    _ksMountpoint = "raid."
+    _ks_mountpoint = "raid."
     _plugin = availability.BLOCKDEV_MDRAID_PLUGIN
 
     def __init__(self, **kwargs):
@@ -55,7 +55,7 @@ def __init__(self, **kwargs):
             :keyword uuid: this member device's uuid
             :keyword exists: whether this is an existing format
             :type exists: bool
-            :keyword mdUuid: the uuid of the array this device belongs to
+            :keyword md_uuid: the uuid of the array this device belongs to
 
             .. note::
 
@@ -63,20 +63,20 @@ def __init__(self, **kwargs):
         """
         log_method_call(self, **kwargs)
         DeviceFormat.__init__(self, **kwargs)
-        self.mdUuid = kwargs.get("mdUuid")
+        self.md_uuid = kwargs.get("md_uuid")
 
         self.biosraid = kwargs.get("biosraid")
 
     def __repr__(self):
         s = DeviceFormat.__repr__(self)
-        s += ("  mdUUID = %(mdUUID)s  biosraid = %(biosraid)s" %
-              {"mdUUID": self.mdUuid, "biosraid": self.biosraid})
+        s += ("  md_uuid = %(md_uuid)s  biosraid = %(biosraid)s" %
+              {"md_uuid": self.md_uuid, "biosraid": self.biosraid})
         return s
 
     @property
     def dict(self):
         d = super(MDRaidMember, self).dict
-        d.update({"mdUUID": self.mdUuid, "biosraid": self.biosraid})
+        d.update({"md_uuid": self.md_uuid, "biosraid": self.biosraid})
         return d
 
     @property
@@ -107,7 +107,7 @@ def hidden(self):
 # Note the anaconda cmdline has not been parsed yet when we're first imported,
 # so we can not use flags.dmraid here
 if not flags.noiswmd and flags.dmraid:
-    MDRaidMember._udevTypes.append("isw_raid_member")
+    MDRaidMember._udev_types.append("isw_raid_member")
 
 register_device_format(MDRaidMember)
 
diff --git a/blivet/formats/multipath.py b/blivet/formats/multipath.py
index 2c93176..ce87e0f 100644
--- a/blivet/formats/multipath.py
+++ b/blivet/formats/multipath.py
@@ -59,14 +59,14 @@ def __repr__(self):
         s += ("  member = %(member)r" % {"member": self.member})
         return s
 
-    def _getMember(self):
+    def _get_member(self):
         return self._member
 
-    def _setMember(self, member):
+    def _set_member(self, member):
         self._member = member
 
-    member = property(lambda s: s._getMember(),
-                      lambda s,m: s._setMember(m))
+    member = property(lambda s: s._get_member(),
+                      lambda s,m: s._set_member(m))
 
     def create(self, **kwargs):
         log_method_call(self, device=self.device,
diff --git a/blivet/formats/prepboot.py b/blivet/formats/prepboot.py
index 16bd95b..cea119a 100644
--- a/blivet/formats/prepboot.py
+++ b/blivet/formats/prepboot.py
@@ -34,11 +34,11 @@ class PPCPRePBoot(DeviceFormat):
     """ Generic device format. """
     _type = "prepboot"
     _name = N_("PPC PReP Boot")
-    partedFlag = PARTITION_PREP
+    parted_flag = PARTITION_PREP
     _formattable = True                 # can be formatted
-    _linuxNative = True                 # for clearpart
-    _maxSize = Size("10 MiB")
-    _minSize = Size("4 MiB")
+    _linux_native = True                 # for clearpart
+    _max_size = Size("10 MiB")
+    _min_size = Size("4 MiB")
     _supported = True
 
     def __init__(self, **kwargs):
diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py
index 4b243b0..b766eaf 100644
--- a/blivet/formats/swap.py
+++ b/blivet/formats/swap.py
@@ -39,16 +39,16 @@ class SwapSpace(DeviceFormat):
     """ Swap space """
     _type = "swap"
     _name = None
-    _udevTypes = ["swap"]
-    partedFlag = PARTITION_SWAP
-    partedSystem = fileSystemType["linux-swap(v1)"]
+    _udev_types = ["swap"]
+    parted_flag = PARTITION_SWAP
+    parted_system = fileSystemType["linux-swap(v1)"]
     _formattable = True                # can be formatted
     _supported = True                  # is supported
-    _linuxNative = True                # for clearpart
+    _linux_native = True                # for clearpart
     _plugin = availability.BLOCKDEV_SWAP_PLUGIN
 
     #see rhbz#744129 for details
-    _maxSize = Size("128 GiB")
+    _max_size = Size("128 GiB")
 
     def __init__(self, **kwargs):
         """
@@ -102,14 +102,14 @@ def labeling(self):
         """Returns True as mkswap can write a label to the swap space."""
         return True
 
-    def labelFormatOK(self, label):
+    def label_format_ok(self, label):
         """Returns True since no known restrictions on the label."""
         return True
 
-    label = property(lambda s: s._getLabel(), lambda s,l: s._setLabel(l),
+    label = property(lambda s: s._get_label(), lambda s,l: s._set_label(l),
        doc="the label for this swap space")
 
-    def _setPriority(self, priority):
+    def _set_priority(self, priority):
         # pylint: disable=attribute-defined-outside-init
         if priority is None:
             self._priority = -1
@@ -121,20 +121,20 @@ def _setPriority(self, priority):
 
         self._priority = priority
 
-    def _getPriority(self):
+    def _get_priority(self):
         return self._priority
 
-    priority = property(_getPriority, _setPriority,
+    priority = property(_get_priority, _set_priority,
                         doc="The priority of the swap device")
 
-    def _getOptions(self):
+    def _get_options(self):
         opts = ""
         if self.priority is not None and self.priority != -1:
             opts += "pri=%d" % self.priority
 
         return opts
 
-    def _setOptions(self, opts):
+    def _set_options(self, opts):
         if not opts:
             self.priority = None
             return
diff --git a/blivet/iscsi.py b/blivet/iscsi.py
index ccb31b5..2914b82 100644
--- a/blivet/iscsi.py
+++ b/blivet/iscsi.py
@@ -125,7 +125,7 @@ class iscsi(object):
         This class will automatically discover and login to iBFT (or
         other firmware) configured iscsi devices when the startup() method
         gets called. It can also be used to manually configure iscsi devices
-        through the addTarget() method.
+        through the add_target() method.
 
         As this class needs to make sure certain things like starting iscsid
         and logging in to firmware discovered disks only happens once
@@ -138,9 +138,9 @@ def __init__(self):
         # logged_in) tuples.
         self.discovered_targets = {}
         # This list contains nodes discovered through iBFT (or other firmware)
-        self.ibftNodes = []
+        self.ibft_nodes = []
         self._initiator = ""
-        self.initiatorSet = False
+        self.initiator_set = False
         self.started = False
         self.ifaces = {}
 
@@ -148,7 +148,7 @@ def __init__(self):
             try:
                 initiatorname = libiscsi.get_firmware_initiator_name()
                 self._initiator = initiatorname
-                self.initiatorSet = True
+                self.initiator_set = True
             except Exception: # pylint: disable=broad-except
                 log_exception_info(fmt_str="failed to get initiator name from iscsi firmware")
 
@@ -156,20 +156,20 @@ def __init__(self):
     def __call__(self):
         return self
 
-    def _getInitiator(self):
+    def _get_initiator(self):
         if self._initiator != "":
             return self._initiator
 
         return util.capture_output(["iscsi-iname"]).strip()
 
-    def _setInitiator(self, val):
-        if self.initiatorSet and val != self._initiator:
+    def _set_initiator(self, val):
+        if self.initiator_set and val != self._initiator:
             raise ValueError(_("Unable to change iSCSI initiator name once set"))
         if len(val) == 0:
             raise ValueError(_("Must provide an iSCSI initiator name"))
         self._initiator = val
 
-    initiator = property(_getInitiator, _setInitiator)
+    initiator = property(_get_initiator, _set_initiator)
 
     def active_nodes(self, target=None):
         """Nodes logged in to"""
@@ -180,9 +180,9 @@ def active_nodes(self, target=None):
         else:
             return [node for (node, logged_in) in
                     itertools.chain(*list(self.discovered_targets.values()))
-                    if logged_in] + self.ibftNodes
+                    if logged_in] + self.ibft_nodes
 
-    def _getMode(self):
+    def _get_mode(self):
         if not self.active_nodes():
             return "none"
         if self.ifaces:
@@ -190,7 +190,7 @@ def _getMode(self):
         else:
             return "default"
 
-    mode = property(_getMode)
+    mode = property(_get_mode)
 
     def _mark_node_active(self, node, active=True):
         """Mark node as one logged in to
@@ -205,7 +205,7 @@ def _mark_node_active(self, node, active=True):
         return False
 
 
-    def _startIBFT(self):
+    def _start_ibft(self):
         if not flags.ibft:
             return
 
@@ -221,7 +221,7 @@ def _startIBFT(self):
                 node.login()
                 log.info("iscsi IBFT: logged into %s at %s:%s through %s",
                     node.name, node.address, node.port, node.iface)
-                self.ibftNodes.append(node)
+                self.ibft_nodes.append(node)
             except IOError as e:
                 log.error("Could not log into ibft iscsi target %s: %s",
                           node.name, str(e))
@@ -280,7 +280,7 @@ def startup(self):
         initiator_name = "InitiatorName=%s\n" % self.initiator
         util.eintr_retry_call(os.write, fd, initiator_name.encode("utf-8"))
         util.eintr_ignore(os.close, fd)
-        self.initiatorSet = True
+        self.initiator_set = True
 
         for fulldir in (os.path.join("/var/lib/iscsi", d) for d in \
            ['ifaces','isns','nodes','send_targets','slp','static']):
@@ -303,7 +303,7 @@ def startup(self):
         util.run_program([ISCSID])
         time.sleep(1)
 
-        self._startIBFT()
+        self._start_ibft()
         self.started = True
 
     def discover(self, ipaddr, port="3260", username=None, password=None,
@@ -313,7 +313,7 @@ def discover(self, ipaddr, port="3260", username=None, password=None,
 
         If we are logged in a node discovered for specified target
         do not do the discovery again as it can corrupt credentials
-        stored for the node (setAuth and getAuth are using database
+        stored for the node (set_auth and get_auth are using database
         in /var/lib/iscsi/nodes which is filled by discovery). Just
         return nodes obtained and stored in the first discovery
         instead.
@@ -401,7 +401,7 @@ def log_into_node(self, node, username=None, password=None,
                                                  password=password,
                                                  reverse_username=r_username,
                                                  reverse_password=r_password)
-            node.setAuth(authinfo)
+            node.set_auth(authinfo)
             node.login()
             rc = True
             log.info("iSCSI: logged into %s at %s:%s through %s",
@@ -414,7 +414,7 @@ def log_into_node(self, node, username=None, password=None,
 
         return (rc, msg)
 
-    def addTarget(self, ipaddr, port="3260", user=None, pw=None,
+    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):
@@ -484,21 +484,21 @@ def addTarget(self, ipaddr, port="3260", user=None, pw=None,
         self.stabilize()
 
     def write(self, root, storage):
-        if not self.initiatorSet:
+        if not self.initiator_set:
             return
 
         # set iscsi nodes to autostart
-        rootdev = storage.rootDevice
+        rootdev = storage.root_device
         for node in self.active_nodes():
             autostart = True
-            disks = self.getNodeDisks(node, storage)
+            disks = self.get_node_disks(node, storage)
             for disk in disks:
                 # nodes used for root get started by the initrd
-                if rootdev.dependsOn(disk):
+                if rootdev.depends_on(disk):
                     autostart = False
 
             if autostart:
-                node.setParameter("node.startup", "automatic")
+                node.set_parameter("node.startup", "automatic")
 
         if not os.path.isdir(root + "/etc/iscsi"):
             os.makedirs(root + "/etc/iscsi", 0o755)
@@ -514,7 +514,7 @@ def write(self, root, storage):
             shutil.copytree("/var/lib/iscsi", root + "/var/lib/iscsi",
                             symlinks=True)
 
-    def getNode(self, name, address, port, iface):
+    def get_node(self, name, address, port, iface):
         for node in self.active_nodes():
             if node.name == name and node.address == address and \
                node.port == int(port) and node.iface == iface:
@@ -522,14 +522,14 @@ def getNode(self, name, address, port, iface):
 
         return None
 
-    def getNodeDisks(self, node, storage):
-        nodeDisks = []
-        iscsiDisks = storage.devicetree.getDevicesByType("iscsi")
-        for disk in iscsiDisks:
+    def get_node_disks(self, node, storage):
+        node_disks = []
+        iscsi_disks = storage.devicetree.get_devices_by_type("iscsi")
+        for disk in iscsi_disks:
             if disk.node == node:
-                nodeDisks.append(disk)
+                node_disks.append(disk)
 
-        return nodeDisks
+        return node_disks
 
 # Create iscsi singleton
 iscsi = iscsi()
diff --git a/blivet/mounts.py b/blivet/mounts.py
index 5c9462a..ebd4806 100644
--- a/blivet/mounts.py
+++ b/blivet/mounts.py
@@ -43,7 +43,7 @@ class _MountinfoCache(object):
     def __init__(self):
         self._cache = None
 
-    def _getCache(self):
+    def _get_cache(self):
         """ Reads lines in /proc/self/mountinfo and builds a table. """
         cache = {}
 
@@ -64,7 +64,7 @@ def _getCache(self):
 
         return cache
 
-    def getRoot(self, devspec, mountpoint):
+    def get_root(self, devspec, mountpoint):
         """ Retrieves the root of the mount within the filesystem
             that corresponds to devspec and mountpoint.
 
@@ -74,7 +74,7 @@ def getRoot(self, devspec, mountpoint):
             :returns: the root of the mount within the filesystem, if available
         """
         if self._cache is None:
-            self._cache = self._getCache()
+            self._cache = self._get_cache()
 
         # get the canonical device path
         devspec = resolve_devspec(devspec, sysname=True)
@@ -86,10 +86,10 @@ class MountsCache(object):
     """
 
     def __init__(self):
-        self.mountsHash = 0
+        self.mounts_hash = 0
         self.mountpoints = defaultdict(list)
 
-    def getMountpoints(self, devspec, subvolspec=None):
+    def get_mountpoints(self, devspec, subvolspec=None):
         """ Get mountpoints for selected device
 
             :param devscpec: device specification, eg. "/dev/vda1"
@@ -103,7 +103,7 @@ def getMountpoints(self, devspec, subvolspec=None):
                 Devices can be mounted on multiple paths, and paths can have multiple
                 devices mounted to them (hiding previous mounts). Callers should take this into account.
         """
-        self._cacheCheck()
+        self._cache_check()
 
         if subvolspec is not None:
             subvolspec = str(subvolspec)
@@ -121,16 +121,16 @@ def getMountpoints(self, devspec, subvolspec=None):
 
         return self.mountpoints[(devspec, subvolspec)]
 
-    def isMountpoint(self, path):
+    def is_mountpoint(self, path):
         """ Check to see if a path is already mounted
 
             :param str path: Path to check
         """
-        self._cacheCheck()
+        self._cache_check()
 
         return any(path in p for p in self.mountpoints.values())
 
-    def _getActiveMounts(self):
+    def _get_active_mounts(self):
         """ Get information about mounted devices from /proc/mounts and
             /proc/self/mountinfo
 
@@ -151,7 +151,7 @@ def _getActiveMounts(self):
                 devspec = resolve_devspec(devspec, sysname=True) or devspec
 
                 if fstype == "btrfs":
-                    root = mountinfo.getRoot(devspec, mountpoint)
+                    root = mountinfo.get_root(devspec, mountpoint)
                     if root is not None:
                         subvolspec = root[1:] or str(btrfs.MAIN_VOLUME_ID)
                         self.mountpoints[(devspec, subvolspec)].append(mountpoint)
@@ -160,14 +160,14 @@ def _getActiveMounts(self):
                 else:
                     self.mountpoints[(devspec, None)].append(mountpoint)
 
-    def _cacheCheck(self):
+    def _cache_check(self):
         """ Computes the MD5 hash on /proc/mounts and updates the cache on change
         """
 
         md5hash = util.md5_file("/proc/mounts")
 
-        if md5hash != self.mountsHash:
-            self.mountsHash = md5hash
-            self._getActiveMounts()
+        if md5hash != self.mounts_hash:
+            self.mounts_hash = md5hash
+            self._get_active_mounts()
 
-mountsCache = MountsCache()
+mounts_cache = MountsCache()
diff --git a/blivet/osinstall.py b/blivet/osinstall.py
index affa870..125edb9 100644
--- a/blivet/osinstall.py
+++ b/blivet/osinstall.py
@@ -31,14 +31,14 @@
 from gi.repository import BlockDev as blockdev
 
 from . import util
-from . import getSysroot, getTargetPhysicalRoot, errorHandler, ERROR_RAISE
+from . import get_sysroot, get_target_physical_root, error_handler, ERROR_RAISE
 from .util import open  # pylint: disable=redefined-builtin
 
 from .storage_log import log_exception_info
 from .devices import FileDevice, NFSDevice, NoDevice, OpticalDevice, NetworkStorageDevice, DirectoryDevice
 from .errors import FSTabTypeMismatchError, UnrecognizedFSTabEntryError, StorageError, FSResizeError, UnknownSourceDeviceError
 from .formats import get_device_format_class
-from .formats import getFormat
+from .formats import get_format
 from .flags import flags
 from .platform import platform as _platform
 from .platform import EFI
@@ -48,7 +48,7 @@
 import logging
 log = logging.getLogger("blivet")
 
-def releaseFromRedhatRelease(fn):
+def release_from_redhat_release(fn):
     """
     Attempt to identify the installation of a Linux distribution via
     /etc/redhat-release.  This file must already have been verified to exist
@@ -60,8 +60,8 @@ def releaseFromRedhatRelease(fn):
     if they cannot be determined
     :rtype: (string, string)
     """
-    relName = None
-    relVer = None
+    rel_name = None
+    rel_ver = None
 
     with open(fn) as f:
         try:
@@ -74,12 +74,12 @@ def releaseFromRedhatRelease(fn):
     # like "Red Hat Linux release 6.2 (Zoot)"
     (product, sep, version) = relstr.partition(" release ")
     if sep:
-        relName = product
-        relVer = version.split()[0]
+        rel_name = product
+        rel_ver = version.split()[0]
 
-    return (relName, relVer)
+    return (rel_name, rel_ver)
 
-def releaseFromOsRelease(fn):
+def release_from_os_release(fn):
     """
     Attempt to identify the installation of a Linux distribution via
     /etc/os-release.  This file must already have been verified to exist
@@ -91,8 +91,8 @@ def releaseFromOsRelease(fn):
     if they cannot be determined
     :rtype: (string, string)
     """
-    relName = None
-    relVer = None
+    rel_name = None
+    rel_ver = None
 
     with open(fn, "r") as f:
         parser = shlex.shlex(f)
@@ -104,15 +104,15 @@ def releaseFromOsRelease(fn):
             elif key == "NAME":
                 # Throw away the "=".
                 parser.get_token()
-                relName = parser.get_token().strip("'\"")
+                rel_name = parser.get_token().strip("'\"")
             elif key == "VERSION_ID":
                 # Throw away the "=".
                 parser.get_token()
-                relVer = parser.get_token().strip("'\"")
+                rel_ver = parser.get_token().strip("'\"")
 
-    return (relName, relVer)
+    return (rel_name, rel_ver)
 
-def getReleaseString():
+def get_release_string():
     """
     Attempt to identify the installation of a Linux distribution by checking
     a previously mounted filesystem for several files.  The filesystem must
@@ -122,28 +122,28 @@ def getReleaseString():
     or None for any parts that cannot be determined
     :rtype: (string, string, string)
     """
-    relName = None
-    relVer = None
+    rel_name = None
+    rel_ver = None
 
     try:
-        relArch = util.capture_output(["arch"], root=getSysroot()).strip()
+        rel_arch = util.capture_output(["arch"], root=get_sysroot()).strip()
     except OSError:
-        relArch = None
+        rel_arch = None
 
-    filename = "%s/etc/redhat-release" % getSysroot()
+    filename = "%s/etc/redhat-release" % get_sysroot()
     if os.access(filename, os.R_OK):
-        (relName, relVer) = releaseFromRedhatRelease(filename)
+        (rel_name, rel_ver) = release_from_redhat_release(filename)
     else:
-        filename = "%s/etc/os-release" % getSysroot()
+        filename = "%s/etc/os-release" % get_sysroot()
         if os.access(filename, os.R_OK):
-            (relName, relVer) = releaseFromOsRelease(filename)
+            (rel_name, rel_ver) = release_from_os_release(filename)
 
-    return (relArch, relName, relVer)
+    return (rel_arch, rel_name, rel_ver)
 
-def parseFSTab(devicetree, chroot=None):
+def parse_fstab(devicetree, chroot=None):
     """ parse /etc/fstab and return a tuple of a mount dict and swap list """
     if not chroot or not os.path.isdir(chroot):
-        chroot = getSysroot()
+        chroot = get_sysroot()
 
     mounts = {}
     swaps = []
@@ -153,21 +153,21 @@ def parseFSTab(devicetree, chroot=None):
         log.info("cannot open %s for read", path)
         return (mounts, swaps)
 
-    blkidTab = BlkidTab(chroot=chroot)
+    blkid_tab = BlkidTab(chroot=chroot)
     try:
-        blkidTab.parse()
-        log.debug("blkid.tab devs: %s", list(blkidTab.devices.keys()))
+        blkid_tab.parse()
+        log.debug("blkid.tab devs: %s", list(blkid_tab.devices.keys()))
     except Exception: # pylint: disable=broad-except
         log_exception_info(log.info, "error parsing blkid.tab")
-        blkidTab = None
+        blkid_tab = None
 
-    cryptTab = CryptTab(devicetree, blkidTab=blkidTab, chroot=chroot)
+    crypt_tab = CryptTab(devicetree, blkid_tab=blkid_tab, chroot=chroot)
     try:
-        cryptTab.parse(chroot=chroot)
-        log.debug("crypttab maps: %s", list(cryptTab.mappings.keys()))
+        crypt_tab.parse(chroot=chroot)
+        log.debug("crypttab maps: %s", list(crypt_tab.mappings.keys()))
     except Exception: # pylint: disable=broad-except
         log_exception_info(log.info, "error parsing crypttab")
-        cryptTab = None
+        crypt_tab = None
 
     with open(path) as f:
         log.debug("parsing %s", path)
@@ -182,9 +182,9 @@ def parseFSTab(devicetree, chroot=None):
             (devspec, mountpoint, fstype, options, _rest) = fields
 
             # find device in the tree
-            device = devicetree.resolveDevice(devspec,
-                                              cryptTab=cryptTab,
-                                              blkidTab=blkidTab,
+            device = devicetree.resolve_device(devspec,
+                                              crypt_tab=crypt_tab,
+                                              blkid_tab=blkid_tab,
                                               options=options)
 
             if device is None:
@@ -197,7 +197,7 @@ def parseFSTab(devicetree, chroot=None):
 
     return (mounts, swaps)
 
-def findExistingInstallations(devicetree, teardown_all=True):
+def find_existing_installations(devicetree, teardown_all=True):
     """Find existing GNU/Linux installations on devices from the devicetree.
     :param devicetree: devicetree to find existing installations in
     :type devicetree: :class:`~.devicetree.DeviceTree`
@@ -208,23 +208,23 @@ def findExistingInstallations(devicetree, teardown_all=True):
 
     """
     try:
-        roots = _findExistingInstallations(devicetree)
+        roots = _find_existing_installations(devicetree)
         return roots
     except Exception: # pylint: disable=broad-except
         log_exception_info(log.info, "failure detecting existing installations")
     finally:
         if teardown_all:
-            devicetree.teardownAll()
+            devicetree.teardown_all()
 
     return []
 
-def _findExistingInstallations(devicetree):
-    if not os.path.exists(getTargetPhysicalRoot()):
-        util.makedirs(getTargetPhysicalRoot())
+def _find_existing_installations(devicetree):
+    if not os.path.exists(get_target_physical_root()):
+        util.makedirs(get_target_physical_root())
 
     roots = []
     for device in devicetree.leaves:
-        if not device.format.linuxNative or not device.format.mountable or \
+        if not device.format.linux_native or not device.format.mountable or \
            not device.controllable:
             continue
 
@@ -236,19 +236,19 @@ def _findExistingInstallations(devicetree):
 
         options = device.format.options + ",ro"
         try:
-            device.format.mount(options=options, mountpoint=getSysroot())
+            device.format.mount(options=options, mountpoint=get_sysroot())
         except Exception: # pylint: disable=broad-except
             log_exception_info(log.warning, "mount of %s as %s failed", [device.name, device.format.type])
-            util.umount(mountpoint=getSysroot())
+            util.umount(mountpoint=get_sysroot())
             continue
 
-        if not os.access(getSysroot() + "/etc/fstab", os.R_OK):
-            util.umount(mountpoint=getSysroot())
+        if not os.access(get_sysroot() + "/etc/fstab", os.R_OK):
+            util.umount(mountpoint=get_sysroot())
             device.teardown(recursive=True)
             continue
 
         try:
-            (architecture, product, version) = getReleaseString()
+            (architecture, product, version) = get_release_string()
         except ValueError:
             name = _("Linux on %s") % device.name
         else:
@@ -263,8 +263,8 @@ def _findExistingInstallations(devicetree):
                 name = _("%(product)s Linux %(version)s for %(arch)s") % \
                         {"product": product, "version": version, "arch": architecture}
 
-        (mounts, swaps) = parseFSTab(devicetree, chroot=getSysroot())
-        util.umount(mountpoint=getSysroot())
+        (mounts, swaps) = parse_fstab(devicetree, chroot=get_sysroot())
+        util.umount(mountpoint=get_sysroot())
         if not mounts and not swaps:
             # empty /etc/fstab. weird, but I've seen it happen.
             continue
@@ -276,9 +276,9 @@ class FSSet(object):
     """ A class to represent a set of filesystems. """
     def __init__(self, devicetree):
         self.devicetree = devicetree
-        self.cryptTab = None
-        self.blkidTab = None
-        self.origFStab = None
+        self.crypt_tab = None
+        self.blkid_tab = None
+        self.orig_fstab = None
         self.active = False
         self._dev = None
         self._devpts = None
@@ -290,19 +290,19 @@ def __init__(self, devicetree):
         self._run = None
         self._efivars = None
         self._fstab_swaps = set()
-        self.preserveLines = []     # lines we just ignore and preserve
+        self.preserve_lines = []     # lines we just ignore and preserve
 
     @property
     def sysfs(self):
         if not self._sysfs:
-            self._sysfs = NoDevice(fmt=getFormat("sysfs", device="sysfs", mountpoint="/sys"))
+            self._sysfs = NoDevice(fmt=get_format("sysfs", device="sysfs", mountpoint="/sys"))
         return self._sysfs
 
     @property
     def dev(self):
         if not self._dev:
             self._dev = DirectoryDevice("/dev",
-               fmt=getFormat("bind", device="/dev", mountpoint="/dev", exists=True),
+               fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True),
                exists=True)
 
         return self._dev
@@ -310,44 +310,44 @@ def dev(self):
     @property
     def devpts(self):
         if not self._devpts:
-            self._devpts = NoDevice(fmt=getFormat("devpts", device="devpts", mountpoint="/dev/pts"))
+            self._devpts = NoDevice(fmt=get_format("devpts", device="devpts", mountpoint="/dev/pts"))
         return self._devpts
 
     @property
     def proc(self):
         if not self._proc:
-            self._proc = NoDevice(fmt=getFormat("proc", device="proc", mountpoint="/proc"))
+            self._proc = NoDevice(fmt=get_format("proc", device="proc", mountpoint="/proc"))
         return self._proc
 
     @property
     def devshm(self):
         if not self._devshm:
-            self._devshm = NoDevice(fmt=getFormat("tmpfs", device="tmpfs", mountpoint="/dev/shm"))
+            self._devshm = NoDevice(fmt=get_format("tmpfs", device="tmpfs", mountpoint="/dev/shm"))
         return self._devshm
 
     @property
     def usb(self):
         if not self._usb:
-            self._usb = NoDevice(fmt=getFormat("usbfs", device="usbfs", mountpoint="/proc/bus/usb"))
+            self._usb = NoDevice(fmt=get_format("usbfs", device="usbfs", mountpoint="/proc/bus/usb"))
         return self._usb
 
     @property
     def selinux(self):
         if not self._selinux:
-            self._selinux = NoDevice(fmt=getFormat("selinuxfs", device="selinuxfs", mountpoint="/sys/fs/selinux"))
+            self._selinux = NoDevice(fmt=get_format("selinuxfs", device="selinuxfs", mountpoint="/sys/fs/selinux"))
         return self._selinux
 
     @property
     def efivars(self):
         if not self._efivars:
-            self._efivars = NoDevice(fmt=getFormat("efivarfs", device="efivarfs", mountpoint="/sys/firmware/efi/efivars"))
+            self._efivars = NoDevice(fmt=get_format("efivarfs", device="efivarfs", mountpoint="/sys/firmware/efi/efivars"))
         return self._efivars
 
     @property
     def run(self):
         if not self._run:
             self._run = DirectoryDevice("/run",
-               fmt=getFormat("bind", device="/run", mountpoint="/run", exists=True),
+               fmt=get_format("bind", device="/run", mountpoint="/run", exists=True),
                exists=True)
 
         return self._run
@@ -364,7 +364,7 @@ def mountpoints(self):
                 filesystems[device.format.mountpoint] = device
         return filesystems
 
-    def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno="0"):
+    def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _passno="0"):
         """Parse an fstab entry for a device, return the corresponding device.
 
            The parameters correspond to the items in a single entry in the
@@ -380,9 +380,9 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
             raise UnrecognizedFSTabEntryError()
 
         # find device in the tree
-        device = self.devicetree.resolveDevice(devspec,
-                                               cryptTab=self.cryptTab,
-                                               blkidTab=self.blkidTab,
+        device = self.devicetree.resolve_device(devspec,
+                                               crypt_tab=self.crypt_tab,
+                                               blkid_tab=self.blkid_tab,
                                                options=options)
 
         if device:
@@ -394,14 +394,14 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
         elif ":" in devspec and fstype.startswith("nfs"):
             # NFS -- preserve but otherwise ignore
             device = NFSDevice(devspec,
-                               fmt=getFormat(fstype,
+                               fmt=get_format(fstype,
                                                 exists=True,
                                                 device=devspec))
         elif devspec.startswith("/") and fstype == "swap":
             # swap file
             device = FileDevice(devspec,
                                 parents=get_containing_device(devspec, self.devicetree),
-                                fmt=getFormat(fstype,
+                                fmt=get_format(fstype,
                                                  device=devspec,
                                                  exists=True),
                                 exists=True)
@@ -411,12 +411,12 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
             fstype = "bind"
 
             # This is probably not going to do anything useful, so we'll
-            # make sure to try again from FSSet.mountFilesystems. The bind
+            # make sure to try again from FSSet.mount_filesystems. The bind
             # mount targets should be accessible by the time we try to do
             # the bind mount from there.
             parents = get_containing_device(devspec, self.devicetree)
             device = DirectoryDevice(devspec, parents=parents, exists=True)
-            device.format = getFormat("bind",
+            device.format = get_format("bind",
                                       device=device.path,
                                       exists=True)
         elif mountpoint in ("/proc", "/sys", "/dev/shm", "/dev/pts",
@@ -425,7 +425,7 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
             return None
         else:
             # nodev filesystem -- preserve or drop completely?
-            fmt = getFormat(fstype)
+            fmt = get_format(fstype)
             fmt_class = get_device_format_class("nodev")
             if devspec == "none" or \
                (fmt_class and isinstance(fmt, fmt_class)):
@@ -437,7 +437,7 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
             raise UnrecognizedFSTabEntryError()
 
         device.setup()
-        fmt = getFormat(fstype, device=device.path, exists=True)
+        fmt = get_format(fstype, device=device.path, exists=True)
         if fstype != "auto" and None in (device.format.type, fmt.type):
             log.info("Unrecognized filesystem type for %s (%s)",
                      device.name, fstype)
@@ -450,7 +450,7 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
         dtype = getattr(device.format, "mountType", device.format.type)
         if hasattr(fmt, "testMount") and fstype != "auto" and ftype != dtype:
             log.info("fstab says %s at %s is %s", dtype, mountpoint, ftype)
-            if fmt.testMount():     # pylint: disable=no-member
+            if fmt.test_mount():     # pylint: disable=no-member
                 device.format = fmt
             else:
                 device.teardown()
@@ -466,7 +466,7 @@ def _parseOneLine(self, devspec, mountpoint, fstype, options, _dump="0", _passno
 
         return device
 
-    def parseFSTab(self, chroot=None):
+    def parse_fstab(self, chroot=None):
         """ parse /etc/fstab
 
             preconditions:
@@ -480,7 +480,7 @@ def parseFSTab(self, chroot=None):
                 loop mounts?
         """
         if not chroot or not os.path.isdir(chroot):
-            chroot = getSysroot()
+            chroot = get_sysroot()
 
         path = "%s/etc/fstab" % chroot
         if not os.access(path, os.R_OK):
@@ -488,24 +488,24 @@ def parseFSTab(self, chroot=None):
             log.info("cannot open %s for read", path)
             return
 
-        blkidTab = BlkidTab(chroot=chroot)
+        blkid_tab = BlkidTab(chroot=chroot)
         try:
-            blkidTab.parse()
-            log.debug("blkid.tab devs: %s", list(blkidTab.devices.keys()))
+            blkid_tab.parse()
+            log.debug("blkid.tab devs: %s", list(blkid_tab.devices.keys()))
         except Exception: # pylint: disable=broad-except
             log_exception_info(log.info, "error parsing blkid.tab")
-            blkidTab = None
+            blkid_tab = None
 
-        cryptTab = CryptTab(self.devicetree, blkidTab=blkidTab, chroot=chroot)
+        crypt_tab = CryptTab(self.devicetree, blkid_tab=blkid_tab, chroot=chroot)
         try:
-            cryptTab.parse(chroot=chroot)
-            log.debug("crypttab maps: %s", list(cryptTab.mappings.keys()))
+            crypt_tab.parse(chroot=chroot)
+            log.debug("crypttab maps: %s", list(crypt_tab.mappings.keys()))
         except Exception: # pylint: disable=broad-except
             log_exception_info(log.info, "error parsing crypttab")
-            cryptTab = None
+            crypt_tab = None
 
-        self.blkidTab = blkidTab
-        self.cryptTab = cryptTab
+        self.blkid_tab = blkid_tab
+        self.crypt_tab = crypt_tab
 
         with open(path) as f:
             log.debug("parsing %s", path)
@@ -513,7 +513,7 @@ def parseFSTab(self, chroot=None):
             lines = f.readlines()
 
             # save the original file
-            self.origFStab = ''.join(lines)
+            self.orig_fstab = ''.join(lines)
 
             for line in lines:
 
@@ -524,10 +524,10 @@ def parseFSTab(self, chroot=None):
                     continue
 
                 try:
-                    device = self._parseOneLine(*fields)
+                    device = self._parse_one_line(*fields)
                 except UnrecognizedFSTabEntryError:
                     # just write the line back out as-is after upgrade
-                    self.preserveLines.append(line)
+                    self.preserve_lines.append(line)
                     continue
 
                 if not device:
@@ -535,26 +535,26 @@ def parseFSTab(self, chroot=None):
 
                 if device not in self.devicetree.devices:
                     try:
-                        self.devicetree._addDevice(device)
+                        self.devicetree._add_device(device)
                     except ValueError:
                         # just write duplicates back out post-install
-                        self.preserveLines.append(line)
+                        self.preserve_lines.append(line)
 
-    def turnOnSwap(self, rootPath=""):
+    def turn_on_swap(self, root_path=""):
         """ Activate the system's swap space. """
         if not flags.installer_mode:
             return
 
-        for device in self.swapDevices:
+        for device in self.swap_devices:
             if isinstance(device, FileDevice):
                 # set up FileDevices' parents now that they are accessible
-                targetDir = "%s/%s" % (rootPath, device.path)
-                parent = get_containing_device(targetDir, self.devicetree)
+                target_dir = "%s/%s" % (root_path, device.path)
+                parent = get_containing_device(target_dir, self.devicetree)
                 if not parent:
                     log.error("cannot determine which device contains "
                               "directory %s", device.path)
                     device.parents = []
-                    self.devicetree._removeDevice(device)
+                    self.devicetree._remove_device(device)
                     continue
                 else:
                     device.parents = [parent]
@@ -564,23 +564,23 @@ def turnOnSwap(self, rootPath=""):
                     device.setup()
                     device.format.setup()
                 except (StorageError, blockdev.BlockDevError) as e:
-                    if errorHandler.cb(e) == ERROR_RAISE:
+                    if error_handler.cb(e) == ERROR_RAISE:
                         raise
                 else:
                     break
 
-    def mountFilesystems(self, rootPath="", readOnly=None, skipRoot=False):
+    def mount_filesystems(self, root_path="", read_only=None, skip_root=False):
         """ Mount the system's filesystems.
 
-            :param str rootPath: the root directory for this filesystem
-            :param readOnly: read only option str for this filesystem
-            :type readOnly: str or None
-            :param bool skipRoot: whether to skip mounting the root filesystem
+            :param str root_path: the root directory for this filesystem
+            :param read_only: read only option str for this filesystem
+            :type read_only: str or None
+            :param bool skip_root: whether to skip mounting the root filesystem
         """
         if not flags.installer_mode:
             return
 
-        devices = list(self.mountpoints.values()) + self.swapDevices
+        devices = list(self.mountpoints.values()) + self.swap_devices
         devices.extend([self.dev, self.devshm, self.devpts, self.sysfs,
                         self.proc, self.selinux, self.usb, self.run])
         if isinstance(_platform, EFI):
@@ -591,7 +591,7 @@ def mountFilesystems(self, rootPath="", readOnly=None, skipRoot=False):
             if not device.format.mountable or not device.format.mountpoint:
                 continue
 
-            if skipRoot and device.format.mountpoint == "/":
+            if skip_root and device.format.mountpoint == "/":
                 continue
 
             options = device.format.options
@@ -604,13 +604,13 @@ def mountFilesystems(self, rootPath="", readOnly=None, skipRoot=False):
                 #
                 # -- bind formats' device and mountpoint are always both
                 #    under the chroot. no exceptions. none, damn it.
-                targetDir = "%s/%s" % (rootPath, device.path)
-                parent = get_containing_device(targetDir, self.devicetree)
+                target_dir = "%s/%s" % (root_path, device.path)
+                parent = get_containing_device(target_dir, self.devicetree)
                 if not parent:
                     log.error("cannot determine which device contains "
                               "directory %s", device.path)
                     device.parents = []
-                    self.devicetree._removeDevice(device)
+                    self.devicetree._remove_device(device)
                     continue
                 else:
                     device.parents = [parent]
@@ -619,27 +619,27 @@ def mountFilesystems(self, rootPath="", readOnly=None, skipRoot=False):
                 device.setup()
             except Exception as e: # pylint: disable=broad-except
                 log_exception_info(fmt_str="unable to set up device %s", fmt_args=[device])
-                if errorHandler.cb(e) == ERROR_RAISE:
+                if error_handler.cb(e) == ERROR_RAISE:
                     raise
                 else:
                     continue
 
-            if readOnly:
-                options = "%s,%s" % (options, readOnly)
+            if read_only:
+                options = "%s,%s" % (options, read_only)
 
             try:
                 device.format.setup(options=options,
-                                    chroot=rootPath)
+                                    chroot=root_path)
             except Exception as e: # pylint: disable=broad-except
                 log_exception_info(log.error, "error mounting %s on %s", [device.path, device.format.mountpoint])
-                if errorHandler.cb(e) == ERROR_RAISE:
+                if error_handler.cb(e) == ERROR_RAISE:
                     raise
 
         self.active = True
 
-    def umountFilesystems(self, swapoff=True):
+    def umount_filesystems(self, swapoff=True):
         """ unmount filesystems, except swap if swapoff == False """
-        devices = list(self.mountpoints.values()) + self.swapDevices
+        devices = list(self.mountpoints.values()) + self.swap_devices
         devices.extend([self.dev, self.devshm, self.devpts, self.sysfs,
                         self.proc, self.usb, self.selinux, self.run])
         if isinstance(_platform, EFI):
@@ -656,37 +656,37 @@ def umountFilesystems(self, swapoff=True):
 
         self.active = False
 
-    def createSwapFile(self, device, size):
+    def create_swap_file(self, device, size):
         """ Create and activate a swap file under storage root. """
         filename = "/SWAP"
         count = 0
-        basedir = os.path.normpath("%s/%s" % (getTargetPhysicalRoot(),
+        basedir = os.path.normpath("%s/%s" % (get_target_physical_root(),
                                               device.format.mountpoint))
         while os.path.exists("%s/%s" % (basedir, filename)) or \
-              self.devicetree.getDeviceByName(filename):
+              self.devicetree.get_device_by_name(filename):
             count += 1
             filename = "/SWAP-%d" % count
 
         dev = FileDevice(filename,
                          size=size,
                          parents=[device],
-                         fmt=getFormat("swap", device=filename))
+                         fmt=get_format("swap", device=filename))
         dev.create()
         dev.setup()
         dev.format.create()
         dev.format.setup()
         # nasty, nasty
-        self.devicetree._addDevice(dev)
+        self.devicetree._add_device(dev)
 
-    def mkDevRoot(self):
-        root = self.rootDevice
-        dev = "%s/%s" % (getSysroot(), root.path)
-        if not os.path.exists("%s/dev/root" %(getSysroot(),)) and os.path.exists(dev):
+    def mk_dev_root(self):
+        root = self.root_device
+        dev = "%s/%s" % (get_sysroot(), root.path)
+        if not os.path.exists("%s/dev/root" %(get_sysroot(),)) and os.path.exists(dev):
             rdev = os.stat(dev).st_rdev
-            util.eintr_retry_call(os.mknod, "%s/dev/root" % (getSysroot(),), stat.S_IFBLK | 0o600, rdev)
+            util.eintr_retry_call(os.mknod, "%s/dev/root" % (get_sysroot(),), stat.S_IFBLK | 0o600, rdev)
 
     @property
-    def swapDevices(self):
+    def swap_devices(self):
         swaps = []
         for device in self.devices:
             if device.format.type == "swap":
@@ -694,8 +694,8 @@ def swapDevices(self):
         return swaps
 
     @property
-    def rootDevice(self):
-        for path in ["/", getTargetPhysicalRoot()]:
+    def root_device(self):
+        for path in ["/", get_target_physical_root()]:
             for device in self.devices:
                 try:
                     mountpoint = device.format.mountpoint
@@ -708,25 +708,25 @@ def rootDevice(self):
     def write(self):
         """ write out all config files based on the set of filesystems """
         # /etc/fstab
-        fstab_path = os.path.normpath("%s/etc/fstab" % getSysroot())
+        fstab_path = os.path.normpath("%s/etc/fstab" % get_sysroot())
         fstab = self.fstab()
         open(fstab_path, "w").write(fstab)
 
         # /etc/crypttab
-        crypttab_path = os.path.normpath("%s/etc/crypttab" % getSysroot())
+        crypttab_path = os.path.normpath("%s/etc/crypttab" % get_sysroot())
         crypttab = self.crypttab()
         origmask = os.umask(0o077)
         open(crypttab_path, "w").write(crypttab)
         os.umask(origmask)
 
         # /etc/mdadm.conf
-        mdadm_path = os.path.normpath("%s/etc/mdadm.conf" % getSysroot())
-        mdadm_conf = self.mdadmConf()
+        mdadm_path = os.path.normpath("%s/etc/mdadm.conf" % get_sysroot())
+        mdadm_conf = self.mdadm_conf()
         if mdadm_conf:
             open(mdadm_path, "w").write(mdadm_conf)
 
         # /etc/multipath.conf
-        if self.devicetree.getDevicesByType("dm-multipath"):
+        if self.devicetree.get_devices_by_type("dm-multipath"):
             util.copy_to_system("/etc/multipath.conf")
             util.copy_to_system("/etc/multipath/wwids")
             util.copy_to_system("/etc/multipath/bindings")
@@ -737,32 +737,32 @@ def crypttab(self):
         # if we are upgrading, do we want to update crypttab?
         # gut reaction says no, but plymouth needs the names to be very
         # specific for passphrase prompting
-        if not self.cryptTab:
-            self.cryptTab = CryptTab(self.devicetree)
-            self.cryptTab.populate()
+        if not self.crypt_tab:
+            self.crypt_tab = CryptTab(self.devicetree)
+            self.crypt_tab.populate()
 
-        devices = list(self.mountpoints.values()) + self.swapDevices
+        devices = list(self.mountpoints.values()) + self.swap_devices
 
         # prune crypttab -- only mappings required by one or more entries
-        for name in list(self.cryptTab.mappings.keys()):
+        for name in list(self.crypt_tab.mappings.keys()):
             keep = False
-            mapInfo = self.cryptTab[name]
-            cryptoDev = mapInfo['device']
+            map_info = self.crypt_tab[name]
+            crypto_dev = map_info['device']
             for device in devices:
-                if device == cryptoDev or device.dependsOn(cryptoDev):
+                if device == crypto_dev or device.depends_on(crypto_dev):
                     keep = True
                     break
 
             if not keep:
-                del self.cryptTab.mappings[name]
+                del self.crypt_tab.mappings[name]
 
-        return self.cryptTab.crypttab()
+        return self.crypt_tab.crypttab()
 
-    def mdadmConf(self):
+    def mdadm_conf(self):
         """ Return the contents of mdadm.conf. """
-        arrays = self.devicetree.getDevicesByType("mdarray")
-        arrays.extend(self.devicetree.getDevicesByType("mdbiosraidarray"))
-        arrays.extend(self.devicetree.getDevicesByType("mdcontainer"))
+        arrays = self.devicetree.get_devices_by_type("mdarray")
+        arrays.extend(self.devicetree.get_devices_by_type("mdbiosraidarray"))
+        arrays.extend(self.devicetree.get_devices_by_type("mdcontainer"))
         # Sort it, this not only looks nicer, but this will also put
         # containers (which get md0, md1, etc.) before their members
         # (which get md127, md126, etc.). and lame as it is mdadm will not
@@ -775,11 +775,11 @@ def mdadmConf(self):
         conf = "# mdadm.conf written out by anaconda\n"
         conf += "MAILADDR root\n"
         conf += "AUTO +imsm +1.x -all\n"
-        devices = list(self.mountpoints.values()) + self.swapDevices
+        devices = list(self.mountpoints.values()) + self.swap_devices
         for array in arrays:
             for device in devices:
-                if device == array or device.dependsOn(array):
-                    conf += array.mdadmConfEntry
+                if device == array or device.depends_on(array):
+                    conf += array.mdadm_conf_entry
                     break
 
         return conf
@@ -801,15 +801,15 @@ def fstab (self):
 
         # filter swaps only in installer mode
         if flags.installer_mode:
-            devices += [dev for dev in self.swapDevices
+            devices += [dev for dev in self.swap_devices
                         if dev in self._fstab_swaps]
         else:
-            devices += self.swapDevices
+            devices += self.swap_devices
 
-        netdevs = self.devicetree.getDevicesByInstance(NetworkStorageDevice)
+        netdevs = self.devicetree.get_devices_by_instance(NetworkStorageDevice)
 
         rootdev = devices[0]
-        root_on_netdev = any(rootdev.dependsOn(netdev) for netdev in netdevs)
+        root_on_netdev = any(rootdev.depends_on(netdev) for netdev in netdevs)
 
         for device in devices:
             # why the hell do we put swap in the fstab, anyway?
@@ -835,13 +835,13 @@ def fstab (self):
 
             options = options or "defaults"
             for netdev in netdevs:
-                if device.dependsOn(netdev):
+                if device.depends_on(netdev):
                     if root_on_netdev and mountpoint == "/var":
                         options = options + ",x-initrd.mount"
                     break
             if device.encrypted:
                 options += ",x-systemd.device-timeout=0"
-            devspec = device.fstabSpec
+            devspec = device.fstab_spec
             dump = device.format.dump
             if device.format.check and mountpoint == "/":
                 passno = 1
@@ -849,18 +849,18 @@ def fstab (self):
                 passno = 2
             else:
                 passno = 0
-            fstab = fstab + device.fstabComment
+            fstab = fstab + device.fstab_comment
             fstab = fstab + fmt_str % (devspec, mountpoint, fstype,
                                        options, dump, passno)
 
         # now, write out any lines we were unable to process because of
         # unrecognized filesystems or unresolveable device specifications
-        for line in self.preserveLines:
+        for line in self.preserve_lines:
             fstab += line
 
         return fstab
 
-    def addFstabSwap(self, device):
+    def add_fstab_swap(self, device):
         """
         Add swap device to the list of swaps that should appear in the fstab.
 
@@ -871,7 +871,7 @@ def addFstabSwap(self, device):
 
         self._fstab_swaps.add(device)
 
-    def removeFstabSwap(self, device):
+    def remove_fstab_swap(self, device):
         """
         Remove swap device from the list of swaps that should appear in the fstab.
 
@@ -885,7 +885,7 @@ def removeFstabSwap(self, device):
         except KeyError:
             pass
 
-    def setFstabSwaps(self, devices):
+    def set_fstab_swaps(self, devices):
         """
         Set swap devices that should appear in the fstab.
 
@@ -970,9 +970,9 @@ def get(self, key, default=None):
 
 class CryptTab(object):
     """ Dictionary-like interface to crypttab entries with map name keys """
-    def __init__(self, devicetree, blkidTab=None, chroot=""):
+    def __init__(self, devicetree, blkid_tab=None, chroot=""):
         self.devicetree = devicetree
-        self.blkidTab = blkidTab
+        self.blkid_tab = blkid_tab
         self.chroot = chroot
         self.mappings = {}
 
@@ -984,13 +984,13 @@ def parse(self, chroot=""):
         path = "%s/etc/crypttab" % chroot
         log.debug("parsing %s", path)
         with open(path) as f:
-            if not self.blkidTab:
+            if not self.blkid_tab:
                 try:
-                    self.blkidTab = BlkidTab(chroot=chroot)
-                    self.blkidTab.parse()
+                    self.blkid_tab = BlkidTab(chroot=chroot)
+                    self.blkid_tab.parse()
                 except Exception: # pylint: disable=broad-except
                     log_exception_info(fmt_str="failed to parse blkid.tab")
-                    self.blkidTab = None
+                    self.blkid_tab = None
 
             for line in f.readlines():
                 (line, _pound, _comment) = line.partition("#")
@@ -1005,8 +1005,8 @@ def parse(self, chroot=""):
                 (name, devspec, keyfile, options) = fields
 
                 # resolve devspec to a device in the tree
-                device = self.devicetree.resolveDevice(devspec,
-                                                       blkidTab=self.blkidTab)
+                device = self.devicetree.resolve_device(devspec,
+                                                       blkid_tab=self.blkid_tab)
                 if device:
                     self.mappings[name] = {"device": device,
                                            "keyfile": keyfile,
@@ -1022,13 +1022,13 @@ def populate(self):
             if device.format.type != "luks":
                 continue
 
-            key_file = device.format.keyFile
+            key_file = device.format.key_file
             if not key_file:
                 key_file = "none"
 
             options = device.format.options or ""
 
-            self.mappings[device.format.mapName] = {"device": device,
+            self.mappings[device.format.map_name] = {"device": device,
                                                     "keyfile": key_file,
                                                     "options": options}
 
@@ -1071,9 +1071,9 @@ def get_containing_device(path, devicetree):
         # have I told you lately that I love you, device-mapper?
         device_name = blockdev.dm.name_from_node(device_name)
 
-    return devicetree.getDeviceByName(device_name)
+    return devicetree.get_device_by_name(device_name)
 
-def turnOnFilesystems(storage, mountOnly=False, callbacks=None):
+def turn_on_filesystems(storage, mount_only=False, callbacks=None):
     """
     Perform installer-specific activation of storage configuration.
 
@@ -1085,56 +1085,56 @@ def turnOnFilesystems(storage, mountOnly=False, callbacks=None):
     if not flags.installer_mode:
         return
 
-    if not mountOnly:
+    if not mount_only:
         if (flags.live_install and not flags.image_install and not storage.fsset.active):
             # turn off any swaps that we didn't turn on
             # needed for live installs
             util.run_program(["swapoff", "-a"])
-        storage.devicetree.teardownAll()
+        storage.devicetree.teardown_all()
 
         try:
-            storage.doIt(callbacks)
+            storage.do_it(callbacks)
         except FSResizeError as e:
-            if errorHandler.cb(e) == ERROR_RAISE:
+            if error_handler.cb(e) == ERROR_RAISE:
                 raise
         except Exception as e:
             raise
 
-        storage.turnOnSwap()
-    # FIXME:  For livecd, skipRoot needs to be True.
-    storage.mountFilesystems()
+        storage.turn_on_swap()
+    # FIXME:  For livecd, skip_root needs to be True.
+    storage.mount_filesystems()
 
-    if not mountOnly:
-        writeEscrowPackets(storage)
+    if not mount_only:
+        write_escrow_packets(storage)
 
-def writeEscrowPackets(storage):
-    escrowDevices = [d for d in storage.devices if d.format.type == 'luks' and
+def write_escrow_packets(storage):
+    escrow_devices = [d for d in storage.devices if d.format.type == 'luks' and
                      d.format.escrow_cert]
 
-    if not escrowDevices:
+    if not escrow_devices:
         return
 
-    log.debug("escrow: writeEscrowPackets start")
+    log.debug("escrow: write_escrow_packets start")
 
-    backupPassphrase = blockdev.crypto.generate_backup_passphrase()
+    backup_passphrase = blockdev.crypto.generate_backup_passphrase()
 
     try:
-        escrowDir = getSysroot() + "/root"
-        log.debug("escrow: writing escrow packets to %s", escrowDir)
-        util.makedirs(escrowDir)
-        for device in escrowDevices:
+        escrow_dir = get_sysroot() + "/root"
+        log.debug("escrow: writing escrow packets to %s", escrow_dir)
+        util.makedirs(escrow_dir)
+        for device in escrow_devices:
             log.debug("escrow: device %s: %s",
                       repr(device.path), repr(device.format.type))
-            device.format.escrow(escrowDir,
-                                 backupPassphrase)
+            device.format.escrow(escrow_dir,
+                                 backup_passphrase)
 
     except (IOError, RuntimeError) as e:
         # TODO: real error handling
         log.error("failed to store encryption key: %s", e)
 
-    log.debug("escrow: writeEscrowPackets done")
+    log.debug("escrow: write_escrow_packets done")
 
-def storageInitialize(storage, ksdata, protected):
+def storage_initialize(storage, ksdata, protected):
     """ Perform installer-specific storage initialization. """
     from pyanaconda.flags import flags as anaconda_flags
     flags.update_from_anaconda_flags(anaconda_flags)
@@ -1150,13 +1150,13 @@ def storageInitialize(storage, ksdata, protected):
 
     # Set up the protected partitions list now.
     if protected:
-        storage.config.protectedDevSpecs.extend(protected)
+        storage.config.protected_dev_specs.extend(protected)
 
     while True:
         try:
             storage.reset()
         except StorageError as e:
-            if errorHandler.cb(e) == ERROR_RAISE:
+            if error_handler.cb(e) == ERROR_RAISE:
                 raise
             else:
                 continue
@@ -1174,22 +1174,22 @@ def storageInitialize(storage, ksdata, protected):
                                          if d.name not in ksdata.ignoredisk.ignoredisk]
             log.debug("onlyuse is now: %s", ",".join(ksdata.ignoredisk.onlyuse))
 
-def mountExistingSystem(fsset, rootDevice, readOnly=None):
-    """ Mount filesystems specified in rootDevice's /etc/fstab file. """
-    rootPath = getSysroot()
+def mount_existing_system(fsset, root_device, read_only=None):
+    """ Mount filesystems specified in root_device's /etc/fstab file. """
+    root_path = get_sysroot()
 
-    readOnly = "ro" if readOnly else ""
+    read_only = "ro" if read_only else ""
 
-    if rootDevice.protected and os.path.ismount("/mnt/install/isodir"):
+    if root_device.protected and os.path.ismount("/mnt/install/isodir"):
         util.mount("/mnt/install/isodir",
-                   rootPath,
-                   fstype=rootDevice.format.type,
+                   root_path,
+                   fstype=root_device.format.type,
                    options="bind")
     else:
-        rootDevice.setup()
-        rootDevice.format.mount(chroot=rootPath,
+        root_device.setup()
+        root_device.format.mount(chroot=root_path,
                                 mountpoint="/",
-                                options=readOnly)
+                                options=read_only)
 
-    fsset.parseFSTab()
-    fsset.mountFilesystems(rootPath=rootPath, readOnly=readOnly, skipRoot=True)
+    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 e48fc66..2153cd5 100644
--- a/blivet/partitioning.py
+++ b/blivet/partitioning.py
@@ -33,7 +33,7 @@
 
 from .errors import DeviceError, PartitioningError, AlignmentError
 from .flags import flags
-from .devices import Device, PartitionDevice, LUKSDevice, devicePathToName
+from .devices import Device, PartitionDevice, LUKSDevice, device_path_to_name
 from .size import Size
 from .i18n import _
 from .util import stringize, unicodeize, compare
@@ -41,7 +41,7 @@
 import logging
 log = logging.getLogger("blivet")
 
-def partitionCompare(part1, part2):
+def partition_compare(part1, part2):
     """ More specifically defined partitions come first.
 
         < 1 => x < y
@@ -112,9 +112,9 @@ def partitionCompare(part1, part2):
 
     return ret
 
-_partitionCompareKey = functools.cmp_to_key(partitionCompare)
+_partition_compare_key = functools.cmp_to_key(partition_compare)
 
-def getNextPartitionType(disk, no_primary=None):
+def get_next_partition_type(disk, no_primary=None):
     """ Return the type of partition to create next on a disk.
 
         Return a parted partition type value representing the type of the
@@ -168,7 +168,7 @@ def getNextPartitionType(disk, no_primary=None):
 
     return part_type
 
-def getBestFreeSpaceRegion(disk, part_type, req_size, start=None,
+def get_best_free_space_region(disk, part_type, req_size, start=None,
                            boot=None, best_free=None, grow=None,
                            alignment=None):
     """ Return the "best" free region on the specified disk.
@@ -285,31 +285,31 @@ def getBestFreeSpaceRegion(disk, part_type, req_size, start=None,
 
     return best_free
 
-def sectorsToSize(sectors, sectorSize):
+def sectors_to_size(sectors, sector_size):
     """ Convert length in sectors to size.
 
         :param sectors: sector count
         :type sectors: int
-        :param sectorSize: sector size
-        :type sectorSize: :class:`~.size.Size`
+        :param sector_size: sector size
+        :type sector_size: :class:`~.size.Size`
         :returns: the size
         :rtype: :class:`~.size.Size`
     """
-    return Size(sectors * sectorSize)
+    return Size(sectors * sector_size)
 
-def sizeToSectors(size, sectorSize):
+def size_to_sectors(size, sector_size):
     """ Convert size to length in sectors.
 
         :param size: size
         :type size: :class:`~.size.Size`
-        :param sectorSize: sector size in bytes
-        :type sectorSize: :class:`~.size.Size`
+        :param sector_size: sector size in bytes
+        :type sector_size: :class:`~.size.Size`
         :returns: sector count
         :rtype: int
     """
-    return int(size // sectorSize)
+    return int(size // sector_size)
 
-def removeNewPartitions(disks, remove, all_partitions):
+def remove_new_partitions(disks, remove, all_partitions):
     """ Remove newly added partitions from disks.
 
         Remove all non-existent partitions from the disks in blivet's model.
@@ -327,29 +327,29 @@ def removeNewPartitions(disks, remove, all_partitions):
                 ["%s(id %d)" % (p.name, p.id) for p in remove],
                 [d.name for d in disks])
     for part in remove:
-        if part.partedPartition and part.disk in disks:
+        if part.parted_partition and part.disk in disks:
             if part.exists:
                 # we're only removing partitions that don't physically exist
                 continue
 
-            if part.isExtended:
+            if part.is_extended:
                 # these get removed last
                 continue
 
-            part.disk.format.partedDisk.removePartition(part.partedPartition)
-            part.partedPartition = None
+            part.disk.format.parted_disk.removePartition(part.parted_partition)
+            part.parted_partition = None
             part.disk = None
 
     for disk in disks:
         # remove empty extended so it doesn't interfere
-        extended = disk.format.extendedPartition
-        if extended and not disk.format.logicalPartitions and \
+        extended = disk.format.extended_partition
+        if extended and not disk.format.logical_partitions and \
            (flags.installer_mode or
-            extended not in (p.partedPartition 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.partedDisk.removePartition(extended)
+            disk.format.parted_disk.removePartition(extended)
 
-def addPartition(disklabel, free, part_type, size, start=None, end=None):
+def add_partition(disklabel, free, part_type, size, start=None, end=None):
     """ Add a new partition to a disk.
 
         :param disklabel: the disklabel to add the partition to
@@ -378,28 +378,28 @@ def addPartition(disklabel, free, part_type, size, start=None, end=None):
     if start is None:
         if size is None:
             # implicit request for extended partition (will use full free area)
-            _size = sectorsToSize(free.length, disklabel.sectorSize)
+            _size = sectors_to_size(free.length, disklabel.sector_size)
         else:
             _size = size
 
-        alignment = disklabel.getAlignment(size=_size)
-        end_alignment = disklabel.getEndAlignment(alignment=alignment)
+        alignment = disklabel.get_alignment(size=_size)
+        end_alignment = disklabel.get_end_alignment(alignment=alignment)
     else:
         alignment = parted.Alignment(grainSize=1, offset=0)
         end_alignment = parted.Alignment(grainSize=1, offset=-1)
     log.debug("using alignment: %s", alignment)
 
-    sectorSize = Size(disklabel.partedDevice.sectorSize)
+    sector_size = Size(disklabel.sector_size)
     if start is not None:
         if end is None:
-            end = start + sizeToSectors(size, sectorSize) - 1
+            end = start + size_to_sectors(size, sector_size) - 1
     else:
         start = free.start
 
         if not alignment.isAligned(free, start):
             start = alignment.alignNearest(free, start)
 
-        if disklabel.labelType == "sun" and start == 0:
+        if disklabel.label_type == "sun" and start == 0:
             start = alignment.alignUp(free, start)
 
         if part_type == parted.PARTITION_LOGICAL:
@@ -413,7 +413,7 @@ def addPartition(disklabel, free, part_type, size, start=None, end=None):
             end = free.end
             length = end - start + 1
         else:
-            length = sizeToSectors(size, sectorSize)
+            length = size_to_sectors(size, sector_size)
             end = start + length - 1
 
         if not end_alignment.isAligned(free, end):
@@ -422,29 +422,29 @@ def addPartition(disklabel, free, part_type, size, start=None, end=None):
             if start > end:
                 raise PartitioningError(_("unable to allocate aligned partition"))
 
-    new_geom = parted.Geometry(device=disklabel.partedDevice,
+    new_geom = parted.Geometry(device=disklabel.parted_device,
                                start=start,
                                end=end)
 
-    max_length = disklabel.partedDisk.maxPartitionLength
+    max_length = disklabel.parted_disk.maxPartitionLength
     if max_length and new_geom.length > max_length:
         raise PartitioningError(_("requested size exceeds maximum allowed"))
 
     # create the partition and add it to the disk
-    partition = parted.Partition(disk=disklabel.partedDisk,
+    partition = parted.Partition(disk=disklabel.parted_disk,
                                  type=part_type,
                                  geometry=new_geom)
     constraint = parted.Constraint(exactGeom=new_geom)
-    disklabel.partedDisk.addPartition(partition=partition,
+    disklabel.parted_disk.addPartition(partition=partition,
                                       constraint=constraint)
     return partition
 
-def getFreeRegions(disks, align=False):
+def get_free_regions(disks, align=False):
     """ Return a list of free regions on the specified disks.
 
         :param disks: list of disks
         :type disks: list of :class:`~.devices.Disk`
-        :param align: align the region length to disk grainSize
+        :param align: align the region length to disk grain_size
         :type align: bool
         :returns: list of free regions
         :rtype: list of :class:`parted.Geometry`
@@ -455,7 +455,7 @@ def getFreeRegions(disks, align=False):
     """
     free = []
     for disk in disks:
-        for f in disk.format.partedDisk.getFreeSpaceRegions():
+        for f in disk.format.parted_disk.getFreeSpaceRegions():
             grain_size = disk.format.alignment.grainSize
             if f.length >= grain_size:
                 if align:
@@ -467,7 +467,7 @@ def getFreeRegions(disks, align=False):
 
     return free
 
-def updateExtendedPartitions(storage, disks):
+def update_extended_partitions(storage, disks):
     """ Reconcile extended partition changes with the DeviceTree.
 
         :param storage: the Blivet instance
@@ -480,32 +480,32 @@ def updateExtendedPartitions(storage, disks):
     # XXX hack -- if we created any extended partitions we need to add
     #             them to the tree now
     for disk in disks:
-        extended = disk.format.extendedPartition
+        extended = disk.format.extended_partition
         if not extended:
             # remove any obsolete extended partitions
             for part in storage.partitions:
-                if part.disk == disk and part.isExtended:
+                if part.disk == disk and part.is_extended:
                     if part.exists:
-                        storage.destroyDevice(part)
+                        storage.destroy_device(part)
                     else:
-                        storage.devicetree._removeDevice(part, modparent=False)
+                        storage.devicetree._remove_device(part, modparent=False)
             continue
 
-        extendedName = devicePathToName(extended.getDeviceNodeName())
-        device = storage.devicetree.getDeviceByName(extendedName)
+        extended_name = device_path_to_name(extended.getDeviceNodeName())
+        device = storage.devicetree.get_device_by_name(extended_name)
         if device:
             if not device.exists:
-                # created by us, update partedPartition
-                device.partedPartition = extended
+                # created by us, update parted_partition
+                device.parted_partition = extended
 
         # remove any obsolete extended partitions
         for part in storage.partitions:
-            if part.disk == disk and part.isExtended and \
-               part.partedPartition not in disk.format.partitions:
+            if part.disk == disk and part.is_extended and \
+               part.parted_partition not in disk.format.partitions:
                 if part.exists:
-                    storage.destroyDevice(part)
+                    storage.destroy_device(part)
                 else:
-                    storage.devicetree._removeDevice(part, modparent=False)
+                    storage.devicetree._remove_device(part, modparent=False)
 
         if device:
             continue
@@ -514,19 +514,19 @@ def updateExtendedPartitions(storage, disks):
         # that does not exist means leaving self.parents empty and instead
         # populating self.req_disks. In this case, we need to skip past
         # that since this partition is already defined.
-        device = PartitionDevice(extendedName, parents=disk)
+        device = PartitionDevice(extended_name, parents=disk)
         device.parents = [disk]
-        device.partedPartition = extended
+        device.parted_partition = extended
         # just add the device for now -- we'll handle actions at the last
         # moment to simplify things
-        storage.devicetree._addDevice(device)
+        storage.devicetree._add_device(device)
 
-def doPartitioning(storage):
+def do_partitioning(storage):
     """ Allocate and grow partitions.
 
         When this function returns without error, all PartitionDevice
         instances must have their parents set to the disk they are
-        allocated on, and their partedPartition attribute set to the
+        allocated on, and their parted_partition attribute set to the
         appropriate parted.Partition instance from their containing
         disk. All req_xxxx attributes must be unchanged.
 
@@ -546,12 +546,12 @@ def doPartitioning(storage):
     # Remove any extended partition that does not have an action associated.
     #
     # XXX This does not remove the extended from the parted.Disk, but it should
-    #     cause removeNewPartitions to remove it since there will no longer be
+    #     cause remove_new_partitions to remove it since there will no longer be
     #     a PartitionDevice for it.
     for partition in storage.partitions:
-        if not partition.exists and partition.isExtended and \
-           not storage.devicetree.findActions(device=partition, action_type="create"):
-            storage.devicetree._removeDevice(partition, modparent=False, force=True)
+        if not partition.exists and partition.is_extended and \
+           not storage.devicetree.find_actions(device=partition, action_type="create"):
+            storage.devicetree._remove_device(partition, modparent=False, force=True)
 
     partitions = storage.partitions[:]
     for part in storage.partitions:
@@ -561,16 +561,16 @@ def doPartitioning(storage):
             part.req_size = part.req_base_size
 
     try:
-        storage.bootDevice.req_bootable = True
+        storage.boot_device.req_bootable = True
     except AttributeError:
         # there's no stage2 device. hopefully it's temporary.
         pass
 
-    removeNewPartitions(disks, partitions, partitions)
-    free = getFreeRegions(disks)
+    remove_new_partitions(disks, partitions, partitions)
+    free = get_free_regions(disks)
     try:
-        allocatePartitions(storage, disks, partitions, free)
-        growPartitions(disks, partitions, free, size_sets=storage.size_sets)
+        allocate_partitions(storage, disks, partitions, free)
+        grow_partitions(disks, partitions, free, size_sets=storage.size_sets)
     except Exception:
         raise
     else:
@@ -585,28 +585,28 @@ def doPartitioning(storage):
         storage.size_sets = []
 
         # The number and thus the name of partitions may have changed now,
-        # allocatePartitions() takes care of this for new partitions, but not
+        # allocate_partitions() takes care of this for new partitions, but not
         # for pre-existing ones, so we update the name of all partitions here
         for part in storage.partitions:
             # leave extended partitions as-is -- we'll handle them separately
-            if part.isExtended:
+            if part.is_extended:
                 continue
-            part.updateName()
+            part.update_name()
 
-        updateExtendedPartitions(storage, disks)
+        update_extended_partitions(storage, disks)
 
         for part in [p for p in storage.partitions if not p.exists]:
-            problem = part.checkSize()
+            problem = part.check_size()
             if problem < 0:
                 raise PartitioningError(_("partition is too small for %(format)s formatting "
-                                        "(allowable size is %(minSize)s to %(maxSize)s)")
-                                        % {"format": part.format.name, "minSize": part.format.minSize,
-                                            "maxSize": part.format.maxSize})
+                                        "(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 %(minSize)s to %(maxSize)s)")
-                                        % {"format": part.format.name, "minSize": part.format.minSize,
-                                            "maxSize": part.format.maxSize})
+                                        "(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})
 
 def align_size_for_disklabel(size, disklabel):
     # Align the base size to the disk's grain size.
@@ -614,7 +614,7 @@ def align_size_for_disklabel(size, disklabel):
     grains, rem = divmod(size, grain_size)
     return (grains * grain_size) + (grain_size if rem else Size(0))
 
-def allocatePartitions(storage, disks, partitions, freespace):
+def allocate_partitions(storage, disks, partitions, freespace):
     """ Allocate partitions based on requested features.
 
         :param storage: a Blivet instance
@@ -643,7 +643,7 @@ def allocatePartitions(storage, disks, partitions, freespace):
                 ["%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=_partitionCompareKey)
+    new_partitions.sort(key=_partition_compare_key)
 
     # the following dicts all use device path strings as keys
     disklabels = {}     # DiskLabel instances for each disk
@@ -653,10 +653,10 @@ def allocatePartitions(storage, disks, partitions, freespace):
             disklabels[disk.path] = disk.format
             all_disks[disk.path] = disk
 
-    removeNewPartitions(disks, new_partitions, partitions)
+    remove_new_partitions(disks, new_partitions, partitions)
 
     for _part in new_partitions:
-        if _part.partedPartition and _part.isExtended:
+        if _part.parted_partition and _part.is_extended:
             # ignore new extendeds as they are implicit requests
             continue
 
@@ -670,9 +670,9 @@ def allocatePartitions(storage, disks, partitions, freespace):
             req_disks = disks
 
         # sort the disks, making sure the boot disk is first
-        req_disks.sort(key=storage.compareDisksKey)
+        req_disks.sort(key=storage.compare_disks_key)
         for disk in req_disks:
-            if storage.bootDisk and disk == storage.bootDisk:
+            if storage.boot_disk and disk == storage.boot_disk:
                 boot_index = req_disks.index(disk)
                 req_disks.insert(0, req_disks.pop(boot_index))
 
@@ -695,10 +695,10 @@ def allocatePartitions(storage, disks, partitions, freespace):
             disklabel = disklabels[_disk.path]
             best = None
             current_free = free
-            alignment = disklabel.getAlignment(size=_part.req_size)
+            alignment = disklabel.get_alignment(size=_part.req_size)
 
             # for growable requests, we don't want to pass the current free
-            # geometry to getBestFreeRegion -- this allows us to try the
+            # geometry to get_best_free_region -- this allows us to try the
             # best region from each disk and choose one based on the total
             # growth it allows
             if _part.req_grow:
@@ -716,15 +716,15 @@ def allocatePartitions(storage, disks, partitions, freespace):
                 log.debug("size %s rounded up to %s for disk %s",
                           _part.req_size, req_size, _disk.name)
 
-            new_part_type = getNextPartitionType(disklabel.partedDisk)
+            new_part_type = get_next_partition_type(disklabel.parted_disk)
             if new_part_type is None:
                 # can't allocate any more partitions on this disk
                 log.debug("no free partition slots on %s", _disk.name)
                 continue
 
             if _part.req_primary and new_part_type != parted.PARTITION_NORMAL:
-                if (disklabel.partedDisk.primaryPartitionCount <
-                    disklabel.partedDisk.maxPrimaryPartitionCount):
+                if (disklabel.parted_disk.primaryPartitionCount <
+                    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
@@ -732,11 +732,11 @@ def allocatePartitions(storage, disks, partitions, freespace):
                     # we need a primary slot and none are free on this disk
                     log.debug("no primary slots available on %s", _disk.name)
                     continue
-            elif _part.req_partType is not None and \
-                 new_part_type != _part.req_partType:
-                new_part_type = _part.req_partType
+            elif _part.req_part_type is not None and \
+                 new_part_type != _part.req_part_type:
+                new_part_type = _part.req_part_type
 
-            best = getBestFreeSpaceRegion(disklabel.partedDisk,
+            best = get_best_free_space_region(disklabel.parted_disk,
                                           new_part_type,
                                           req_size,
                                           start=_part.req_start_sector,
@@ -749,10 +749,10 @@ def allocatePartitions(storage, disks, partitions, freespace):
                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 = getNextPartitionType(disklabel.partedDisk,
+                new_part_type = get_next_partition_type(disklabel.parted_disk,
                                                      no_primary=True)
                 if new_part_type:
-                    best = getBestFreeSpaceRegion(disklabel.partedDisk,
+                    best = get_best_free_space_region(disklabel.parted_disk,
                                                   new_part_type,
                                                   req_size,
                                                   start=_part.req_start_sector,
@@ -779,18 +779,18 @@ def allocatePartitions(storage, disks, partitions, freespace):
                                 temp_parts.append(_p)
 
                         # add the current request to the temp disk to set up
-                        # its partedPartition attribute with a base geometry
+                        # its parted_partition attribute with a base geometry
                         if disk_path == _disk.path:
                             _part_type = new_part_type
                             _free = best
                             if new_part_type == parted.PARTITION_EXTENDED and \
-                               new_part_type != _part.req_partType:
-                                addPartition(disklabel, best, new_part_type,
+                               new_part_type != _part.req_part_type:
+                                add_partition(disklabel, best, new_part_type,
                                              None)
 
                                 _part_type = parted.PARTITION_LOGICAL
 
-                                _free = getBestFreeSpaceRegion(disklabel.partedDisk,
+                                _free = get_best_free_space_region(disklabel.parted_disk,
                                                                _part_type,
                                                                req_size,
                                                                start=_part.req_start_sector,
@@ -801,14 +801,14 @@ def allocatePartitions(storage, disks, partitions, freespace):
                                     log.info("not enough space after adding "
                                              "extended partition for growth test")
                                     if new_part_type == parted.PARTITION_EXTENDED:
-                                        e = disklabel.extendedPartition
-                                        disklabel.partedDisk.removePartition(e)
+                                        e = disklabel.extended_partition
+                                        disklabel.parted_disk.removePartition(e)
 
                                     continue
 
                             temp_part = None
                             try:
-                                temp_part = addPartition(disklabel,
+                                temp_part = add_partition(disklabel,
                                                          _free,
                                                          _part_type,
                                                          req_size,
@@ -819,18 +819,18 @@ def allocatePartitions(storage, disks, partitions, freespace):
                                          "for growth test")
                                 continue
 
-                            _part.partedPartition = temp_part
+                            _part.parted_partition = temp_part
                             _part.disk = _disk
                             temp_parts.append(_part)
 
-                        chunks = getDiskChunks(all_disks[disk_path],
+                        chunks = get_disk_chunks(all_disks[disk_path],
                                                temp_parts, freespace)
 
                         # grow all growable requests
                         disk_growth = 0 # in sectors
-                        disk_sector_size = Size(disklabels[disk_path].partedDevice.sectorSize)
+                        disk_sector_size = Size(disklabels[disk_path].sector_size)
                         for chunk in chunks:
-                            chunk.growRequests()
+                            chunk.grow_requests()
                             # record the growth for this layout
                             new_growth += chunk.growth
                             disk_growth += chunk.growth
@@ -840,23 +840,23 @@ def allocatePartitions(storage, disks, partitions, freespace):
                                           req.device.id,
                                           req.device.name,
                                           req.growth,
-                                          sectorsToSize(req.growth,
+                                          sectors_to_size(req.growth,
                                                         disk_sector_size),
-                                          sectorsToSize(req.growth + req.base,
+                                          sectors_to_size(req.growth + req.base,
                                                         disk_sector_size))
                         log.debug("disk %s growth: %d (%s)",
                                         disk_path, disk_growth,
-                                        sectorsToSize(disk_growth,
+                                        sectors_to_size(disk_growth,
                                                       disk_sector_size))
 
                     if temp_part:
-                        disklabel.partedDisk.removePartition(temp_part)
-                    _part.partedPartition = None
+                        disklabel.parted_disk.removePartition(temp_part)
+                    _part.parted_partition = None
                     _part.disk = None
 
                     if new_part_type == parted.PARTITION_EXTENDED:
-                        e = disklabel.extendedPartition
-                        disklabel.partedDisk.removePartition(e)
+                        e = disklabel.extended_partition
+                        disklabel.parted_disk.removePartition(e)
 
                     log.debug("total growth: %d sectors", new_growth)
 
@@ -902,16 +902,16 @@ def allocatePartitions(storage, disks, partitions, freespace):
 
         # create the extended partition if needed
         if part_type == parted.PARTITION_EXTENDED and \
-           part_type != _part.req_partType:
+           part_type != _part.req_part_type:
             log.debug("creating extended partition")
-            addPartition(disklabel, free, part_type, None)
+            add_partition(disklabel, free, part_type, None)
 
             # now the extended partition exists, so set type to logical
             part_type = parted.PARTITION_LOGICAL
 
             # recalculate freespace
             log.debug("recalculating free space")
-            free = getBestFreeSpaceRegion(disklabel.partedDisk,
+            free = get_best_free_space_region(disklabel.parted_disk,
                                           part_type,
                                           aligned_size,
                                           start=_part.req_start_sector,
@@ -923,7 +923,7 @@ def allocatePartitions(storage, disks, partitions, freespace):
                                         "creating extended partition"))
 
         try:
-            partition = addPartition(disklabel, free, part_type, aligned_size,
+            partition = add_partition(disklabel, free, part_type, aligned_size,
                                 _part.req_start_sector, _part.req_end_sector)
         except ArithmeticError:
             raise PartitioningError(_("failed to allocate aligned partition"))
@@ -934,12 +934,12 @@ def allocatePartitions(storage, disks, partitions, freespace):
                 disklabel.device)
 
         # this one sets the name
-        _part.partedPartition = partition
+        _part.parted_partition = partition
         _part.disk = _disk
 
         # parted modifies the partition in the process of adding it to
         # the disk, so we need to grab the latest version...
-        _part.partedPartition = disklabel.partedDisk.getPartitionByPath(_part.path)
+        _part.parted_partition = disklabel.parted_disk.getPartitionByPath(_part.path)
 
 
 class Request(object):
@@ -961,7 +961,7 @@ def __init__(self, device):
         self.base = 0                       # base sectors
 
     @property
-    def reserveRequest(self):
+    def reserve_request(self):
         """ Requested reserved fixed extra space for the request (in sectors) """
 
         # generic requests don't need any such extra space
@@ -996,14 +996,14 @@ def __init__(self, partition):
             :type partition: :class:`~.devices.PartitionDevice`
         """
         super(PartitionRequest, self).__init__(partition)
-        self.base = partition.partedPartition.geometry.length   # base sectors
+        self.base = partition.parted_partition.geometry.length   # base sectors
 
-        sector_size = Size(partition.partedPartition.disk.device.sectorSize)
+        sector_size = Size(partition.parted_partition.disk.device.sectorSize)
 
         if partition.req_grow:
-            limits = [l for l in [sizeToSectors(partition.req_max_size, sector_size),
-                         sizeToSectors(partition.format.maxSize, sector_size),
-                         partition.partedPartition.disk.maxPartitionLength] if l > 0]
+            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]
 
             if limits:
                 max_sectors = min(limits)
@@ -1023,12 +1023,12 @@ def __init__(self, lv):
 
         # Round up to nearest pe. For growable requests this will mean that
         # first growth is to fill the remainder of any unused extent.
-        self.base = int(lv.vg.align(lv.req_size, roundup=True) // lv.vg.peSize)
+        self.base = int(lv.vg.align(lv.req_size, roundup=True) // lv.vg.pe_size)
 
         if lv.req_grow:
-            limits = [int(l // lv.vg.peSize) for l in
+            limits = [int(l // lv.vg.pe_size) for l in
                         (lv.vg.align(lv.req_max_size),
-                         lv.vg.align(lv.format.maxSize)) if l > Size(0)]
+                         lv.vg.align(lv.format.max_size)) if l > Size(0)]
 
             if limits:
                 max_units = min(limits)
@@ -1038,11 +1038,11 @@ def __init__(self, lv):
                     self.done = True
 
     @property
-    def reserveRequest(self):
-        reserve = super(LVRequest, self).reserveRequest
+    def reserve_request(self):
+        reserve = super(LVRequest, self).reserve_request
         if self.device.cached:
             total_cache_size = self.device.cache.size + self.device.cache.md_size
-            reserve += int(self.device.vg.align(total_cache_size, roundup=True) / self.device.vg.peSize)
+            reserve += int(self.device.vg.align(total_cache_size, roundup=True) / self.device.vg.pe_size)
 
         return reserve
 
@@ -1064,7 +1064,7 @@ def __init__(self, length, requests=None):
         self.requests = []                  # list of Request instances
         if isinstance(requests, list):
             for req in requests:
-                self.addRequest(req)
+                self.add_request(req)
 
         self.skip_list = []
 
@@ -1073,23 +1073,23 @@ def __repr__(self):
              "device = %(device)s  length = %(length)d  size = %(size)s\n"
              "remaining = %(rem)d  pool = %(pool)d" %
              {"type": self.__class__.__name__, "device": self.path,
-              "length": self.length, "size": self.lengthToSize(self.length),
+              "length": self.length, "size": self.length_to_size(self.length),
               "pool": self.pool, "rem": self.remaining})
 
         return s
 
     # Force str and unicode types in case path is unicode
-    def _toString(self):
+    def _to_string(self):
         s = "%d on %s" % (self.length, self.path)
         return s
 
     def __str__(self):
-        return stringize(self._toString())
+        return stringize(self._to_string())
 
     def __unicode__(self):
-        return unicodeize(self._toString())
+        return unicodeize(self._to_string())
 
-    def addRequest(self, req):
+    def add_request(self, req):
         """ Add a request to this chunk.
 
             :param req: the request to add
@@ -1099,7 +1099,7 @@ def addRequest(self, req):
 
         self.requests.append(req)
         self.pool -= req.base
-        self.pool -= req.reserveRequest
+        self.pool -= req.reserve_request
 
         if not req.done:
             self.base += req.base
@@ -1114,7 +1114,7 @@ def reclaim(self, request, amount):
             :raises: ValueError
             :returns: None
         """
-        log.debug("reclaim: %s %d (%s)", request, amount, self.lengthToSize(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)
@@ -1124,7 +1124,7 @@ def reclaim(self, request, amount):
         self.pool += amount
 
         # put this request in the skip list so we don't try to grow it the
-        # next time we call growRequests to allocate the newly re-acquired pool
+        # next time we call grow_requests to allocate the newly re-acquired pool
         if request not in self.skip_list:
             self.skip_list.append(request)
 
@@ -1134,7 +1134,7 @@ def growth(self):
         return sum(r.growth for r in self.requests)
 
     @property
-    def hasGrowable(self):
+    def has_growable(self):
         """ True if this chunk contains at least one growable request. """
         for req in self.requests:
             if req.growable:
@@ -1151,16 +1151,16 @@ def done(self):
         """ True if we are finished growing all requests in this chunk. """
         return self.remaining == 0 or self.pool == 0
 
-    def maxGrowth(self, req):
+    def max_growth(self, req):
         return req.max_growth
 
-    def lengthToSize(self, length):
+    def length_to_size(self, length):
         return length
 
-    def sizeToLength(self, size):
+    def size_to_length(self, size):
         return size
 
-    def trimOverGrownRequest(self, req, base=None):
+    def trim_over_grown_request(self, req, base=None):
         """ Enforce max growth and return extra units to the pool.
 
             :param req: the request to trim
@@ -1170,13 +1170,13 @@ def trimOverGrownRequest(self, req, base=None):
             :returns: the new base or None if no base was given
             :rtype: int or None
         """
-        max_growth = self.maxGrowth(req)
+        max_growth = self.max_growth(req)
         if max_growth and req.growth >= max_growth:
             if req.growth > max_growth:
                 # 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.lengthToSize(extra),
+                            extra, self.length_to_size(extra),
                             req.device.id, req.device.name)
                 self.pool += extra
                 req.growth = max_growth
@@ -1190,10 +1190,10 @@ def trimOverGrownRequest(self, req, base=None):
 
         return base
 
-    def sortRequests(self):
+    def sort_requests(self):
         pass
 
-    def growRequests(self, uniform=False):
+    def grow_requests(self, uniform=False):
         """ Calculate growth amounts for requests in this chunk.
 
             :keyword uniform: grow requests uniformly instead of proportionally
@@ -1207,9 +1207,9 @@ def growRequests(self, uniform=False):
             Under uniform growth, all requests receive an equal portion of the
             free units.
         """
-        log.debug("Chunk.growRequests: %r", self)
+        log.debug("Chunk.grow_requests: %r", self)
 
-        self.sortRequests()
+        self.sort_requests()
         for req in self.requests:
             log.debug("req: %r", req)
 
@@ -1225,7 +1225,7 @@ def growRequests(self, uniform=False):
                 growth = int(last_pool / self.remaining)
 
             log.debug("%d requests and %s (%s) left in chunk",
-                        self.remaining, self.pool, self.lengthToSize(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
@@ -1240,14 +1240,14 @@ def growRequests(self, uniform=False):
                 p.growth += growth
                 self.pool -= growth
                 log.debug("adding %s (%s) to %d (%s)",
-                            growth, self.lengthToSize(growth),
+                            growth, self.length_to_size(growth),
                             p.device.id, p.device.name)
 
-                new_base = self.trimOverGrownRequest(p, base=new_base)
+                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.lengthToSize(p.growth))
+                            self.length_to_size(p.growth))
 
         if self.pool:
             # allocate any leftovers in pool to the first partition
@@ -1260,14 +1260,14 @@ def growRequests(self, uniform=False):
                 p.growth += growth
                 self.pool = 0
                 log.debug("adding %s (%s) to %d (%s)",
-                            growth, self.lengthToSize(growth),
+                            growth, self.length_to_size(growth),
                             p.device.id, p.device.name)
 
-                self.trimOverGrownRequest(p)
+                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.lengthToSize(p.growth))
+                            self.length_to_size(p.growth))
 
                 if self.pool == 0:
                     break
@@ -1299,31 +1299,31 @@ def __init__(self, geometry, requests=None):
 
         """
         self.geometry = geometry            # parted.Geometry
-        self.sectorSize = Size(self.geometry.device.sectorSize)
+        self.sector_size = Size(self.geometry.device.sectorSize)
         self.path = self.geometry.device.path
         super(DiskChunk, self).__init__(self.geometry.length, requests=requests)
 
     def __repr__(self):
         s = super(DiskChunk, self).__str__()
         s += (" start = %(start)d  end = %(end)d\n"
-              "sectorSize = %(sectorSize)s\n" %
+              "sector_size = %(sector_size)s\n" %
               {"start": self.geometry.start, "end": self.geometry.end,
-               "sectorSize": self.sectorSize})
+               "sector_size": self.sector_size})
         return s
 
     # Force str and unicode types in case path is unicode
-    def _toString(self):
+    def _to_string(self):
         s = "%d (%d-%d) on %s" % (self.length, self.geometry.start,
                                   self.geometry.end, self.path)
         return s
 
     def __str__(self):
-        return stringize(self._toString())
+        return stringize(self._to_string())
 
     def __unicode__(self):
-        return unicodeize(self._toString())
+        return unicodeize(self._to_string())
 
-    def addRequest(self, req):
+    def add_request(self, req):
         """ Add a request to this chunk.
 
             :param req: the request to add
@@ -1336,7 +1336,7 @@ def addRequest(self, req):
         if not self.requests:
             # when adding the first request to the chunk, adjust the pool
             # size to reflect any disklabel-specific limits on end sector
-            max_sector = req.device.partedPartition.disk.maxPartitionStartSector
+            max_sector = req.device.parted_partition.disk.maxPartitionStartSector
             chunk_end = min(max_sector, self.geometry.end)
             if chunk_end <= self.geometry.start:
                 # this should clearly never be possible, but if the chunk's
@@ -1351,16 +1351,16 @@ def addRequest(self, req):
                 log.debug("adjusting pool to %d based on disklabel limits", new_pool)
                 self.pool = new_pool
 
-        super(DiskChunk, self).addRequest(req)
+        super(DiskChunk, self).add_request(req)
 
-    def maxGrowth(self, req):
+    def max_growth(self, req):
         """ Return the maximum possible growth for a request.
 
             :param req: the request
             :type req: :class:`PartitionRequest`
         """
-        req_end = req.device.partedPartition.geometry.end
-        req_start = req.device.partedPartition.geometry.start
+        req_end = req.device.parted_partition.geometry.end
+        req_start = req.device.parted_partition.geometry.start
 
         # Establish the current total number of sectors of growth for requests
         # that lie before this one within this chunk. We add the total count
@@ -1370,7 +1370,7 @@ def maxGrowth(self, req):
         # this end sector and various values for maximum end sector.
         growth = 0
         for request in self.requests:
-            if request.device.partedPartition.geometry.start < req_start:
+            if request.device.parted_partition.geometry.start < req_start:
                 growth += request.growth
         req_end += growth
 
@@ -1379,12 +1379,12 @@ def maxGrowth(self, req):
         limits = []
 
         # disklabel-specific maximum sector
-        max_sector = req.device.partedPartition.disk.maxPartitionStartSector
+        max_sector = req.device.parted_partition.disk.maxPartitionStartSector
         limits.append(max_sector - req_end)
 
         # 2TB limit on bootable partitions, regardless of disklabel
         if req.device.req_bootable:
-            max_boot = sizeToSectors(Size("2 TiB"), self.sectorSize)
+            max_boot = size_to_sectors(Size("2 TiB"), self.sector_size)
             limits.append(max_boot - req_end)
 
         # request-specific maximum (see Request.__init__, above, for details)
@@ -1394,15 +1394,15 @@ def maxGrowth(self, req):
         max_growth = min(limits)
         return max_growth
 
-    def lengthToSize(self, length):
-        return sectorsToSize(length, self.sectorSize)
+    def length_to_size(self, length):
+        return sectors_to_size(length, self.sector_size)
 
-    def sizeToLength(self, size):
-        return sizeToSectors(size, self.sectorSize)
+    def size_to_length(self, size):
+        return size_to_sectors(size, self.sector_size)
 
-    def sortRequests(self):
+    def sort_requests(self):
         # sort the partitions by start sector
-        self.requests.sort(key=lambda r: r.device.partedPartition.geometry.start)
+        self.requests.sort(key=lambda r: r.device.parted_partition.geometry.start)
 
 
 class VGChunk(Chunk):
@@ -1416,10 +1416,10 @@ def __init__(self, vg, requests=None):
         """
         self.vg = vg
         self.path = vg.path
-        usable_extents = vg.extents - int(vg.align(vg.reservedSpace, roundup=True) / vg.peSize)
+        usable_extents = vg.extents - int(vg.align(vg.reserved_space, roundup=True) / vg.pe_size)
         super(VGChunk, self).__init__(usable_extents, requests=requests)
 
-    def addRequest(self, req):
+    def add_request(self, req):
         """ Add a request to this chunk.
 
             :param req: the request to add
@@ -1429,17 +1429,17 @@ def addRequest(self, req):
             raise ValueError(_("VGChunk requests must be of type "
                              "LVRequest"))
 
-        super(VGChunk, self).addRequest(req)
+        super(VGChunk, self).add_request(req)
 
-    def lengthToSize(self, length):
-        return self.vg.peSize * length
+    def length_to_size(self, length):
+        return self.vg.pe_size * length
 
-    def sizeToLength(self, size):
-        return int(size / self.vg.peSize)
+    def size_to_length(self, size):
+        return int(size / self.vg.pe_size)
 
-    def sortRequests(self):
+    def sort_requests(self):
         # sort the partitions by start sector
-        self.requests.sort(key=_lvCompareKey)
+        self.requests.sort(key=_lv_compare_key)
 
 
 class ThinPoolChunk(VGChunk):
@@ -1453,10 +1453,10 @@ def __init__(self, pool, requests=None):
         """
         self.vg = pool.vg   # only used for align, &c
         self.path = pool.path
-        usable_extents = (pool.size / pool.vg.peSize)
+        usable_extents = (pool.size / pool.vg.pe_size)
         super(VGChunk, self).__init__(usable_extents, requests=requests) # pylint: disable=bad-super-call
 
-def getDiskChunks(disk, partitions, free):
+def get_disk_chunks(disk, partitions, free):
     """ Return a list of Chunk instances representing a disk.
 
         :param disk: the disk
@@ -1485,9 +1485,9 @@ def getDiskChunks(disk, partitions, free):
         # (It is possible that both will align to the same sector in a small
         #  enough region.)
         try:
-            size = sectorsToSize(f.length, disk.format.sectorSize)
-            alignment = disk.format.getAlignment(size=size)
-            end_alignment = disk.format.getEndAlignment(alignment=alignment)
+            size = sectors_to_size(f.length, disk.format.sector_size)
+            alignment = disk.format.get_alignment(size=size)
+            end_alignment = disk.format.get_end_alignment(alignment=alignment)
         except AlignmentError:
             disk_free.remove(f)
             continue
@@ -1507,14 +1507,14 @@ def getDiskChunks(disk, partitions, free):
         chunks.append(DiskChunk(geom))
 
     for p in disk_parts:
-        if p.isExtended:
+        if p.is_extended:
             # handle extended partitions specially since they are
             # indeed very special
             continue
 
         for i, f in enumerate(disk_free):
-            if f.contains(p.partedPartition.geometry):
-                chunks[i].addRequest(PartitionRequest(p))
+            if f.contains(p.parted_partition.geometry):
+                chunks[i].add_request(PartitionRequest(p))
                 break
 
     return chunks
@@ -1590,7 +1590,7 @@ def __init__(self, devices, size, grow=False, max_size=None):
 
         self.requests = []
 
-def manageSizeSets(size_sets, chunks):
+def manage_size_sets(size_sets, chunks):
     growth_by_request = {}
     requests_by_device = {}
     chunks_by_request = {}
@@ -1613,7 +1613,7 @@ def manageSizeSets(size_sets, chunks):
                     request = requests_by_device[device]
                     chunk = chunks_by_request[request]
                     new_growth = request.growth - growth_by_request[request]
-                    ss.allocate(chunk.lengthToSize(new_growth))
+                    ss.allocate(chunk.length_to_size(new_growth))
 
                 # decide how much to take back from each request
                 # We may assume that all requests have the same base size.
@@ -1630,7 +1630,7 @@ def manageSizeSets(size_sets, chunks):
                     if ss.needed < 0:
                         # it would be good to take back some from each device
                         # instead of taking all from the last one(s)
-                        extra = -chunk.sizeToLength(needed) // len(ss.devices)
+                        extra = -chunk.size_to_length(needed) // len(ss.devices)
                         if extra > request.growth and i == 0:
                             log.debug("not reclaiming from this request")
                             continue
@@ -1639,7 +1639,7 @@ def manageSizeSets(size_sets, chunks):
 
                         reclaimed[chunk] += extra
                         chunk.reclaim(request, extra)
-                        ss.deallocate(chunk.lengthToSize(extra))
+                        ss.deallocate(chunk.length_to_size(extra))
 
                     if ss.needed <= 0:
                         request.done = True
@@ -1653,7 +1653,7 @@ def manageSizeSets(size_sets, chunks):
                 log.debug("min growth is %d", _min_growth)
                 for request in requests:
                     chunk = chunks_by_request[request]
-                    _max_growth = chunk.sizeToLength(ss.size) - request.base
+                    _max_growth = chunk.size_to_length(ss.size) - request.base
                     log.debug("max growth for %s is %d", request, _max_growth)
                     min_growth = max(min(_min_growth, _max_growth), 0)
                     if request.growth > min_growth:
@@ -1665,15 +1665,15 @@ def manageSizeSets(size_sets, chunks):
                         request.done = True
 
         # store previous growth amounts so we know how much was allocated in
-        # the latest growRequests call
+        # the latest grow_requests call
         for request in growth_by_request.keys():
             growth_by_request[request] = request.growth
 
         for chunk in chunks:
             if reclaimed[chunk] and not chunk.done:
-                chunk.growRequests()
+                chunk.grow_requests()
 
-def growPartitions(disks, partitions, free, size_sets=None):
+def grow_partitions(disks, partitions, free, size_sets=None):
     """ Grow all growable partition requests.
 
         Partitions have already been allocated from chunks of free space on
@@ -1719,7 +1719,7 @@ def growPartitions(disks, partitions, free, size_sets=None):
             log.debug("no free space on %s", disk.name)
             continue
 
-        disk_chunks = getDiskChunks(disk, partitions, disk_free)
+        disk_chunks = get_disk_chunks(disk, partitions, disk_free)
         log.debug("disk %s has %d chunks", disk.name, len(disk_chunks))
         chunks.extend(disk_chunks)
 
@@ -1727,14 +1727,14 @@ def growPartitions(disks, partitions, free, size_sets=None):
     # grow the partitions in each chunk as a group
     #
     for chunk in chunks:
-        if not chunk.hasGrowable:
+        if not chunk.has_growable:
             # no growable partitions in this chunk
             continue
 
-        chunk.growRequests()
+        chunk.grow_requests()
 
     # adjust set members' growth amounts as needed
-    manageSizeSets(size_sets, chunks)
+    manage_size_sets(size_sets, chunks)
 
     for disk in disks:
         log.debug("growing partitions on %s", disk.name)
@@ -1742,17 +1742,17 @@ def growPartitions(disks, partitions, free, size_sets=None):
             if chunk.path != disk.path:
                 continue
 
-            if not chunk.hasGrowable:
+            if not chunk.has_growable:
                 # no growable partitions in this chunk
                 continue
 
             # recalculate partition geometries
             disklabel = disk.format
             start = chunk.geometry.start
-            default_alignment = disklabel.getAlignment()
+            default_alignment = disklabel.get_alignment()
 
             # find any extended partition on this disk
-            extended_geometry = getattr(disklabel.extendedPartition,
+            extended_geometry = getattr(disklabel.extended_partition,
                                         "geometry",
                                         None)  # parted.Geometry
 
@@ -1761,15 +1761,15 @@ def growPartitions(disks, partitions, free, size_sets=None):
                 start = default_alignment.alignUp(chunk.geometry, start)
             new_partitions = []
             for p in chunk.requests:
-                ptype = p.device.partedPartition.type
+                ptype = p.device.parted_partition.type
                 log.debug("partition %s (%d): %s", p.device.name,
                                                    p.device.id, ptype)
                 if ptype == parted.PARTITION_EXTENDED:
                     continue
 
                 new_length = p.base + p.growth
-                alignment = disklabel.getAlignment(size=chunk.lengthToSize(new_length))
-                end_alignment = disklabel.getEndAlignment(alignment=alignment)
+                alignment = disklabel.get_alignment(size=chunk.length_to_size(new_length))
+                end_alignment = disklabel.get_end_alignment(alignment=alignment)
                 # XXX since we need one metadata sector before each
                 #     logical partition we burn one logical block to
                 #     safely align the start of each logical partition
@@ -1780,21 +1780,21 @@ def growPartitions(disks, partitions, free, size_sets=None):
                 # align end sector as needed
                 if not end_alignment.isAligned(chunk.geometry, end):
                     end = end_alignment.alignDown(chunk.geometry, end)
-                new_geometry = parted.Geometry(device=disklabel.partedDevice,
+                new_geometry = parted.Geometry(device=disklabel.parted_device,
                                                start=start,
                                                end=end)
                 log.debug("new geometry for %s: %s", p.device.name,
                                                      new_geometry)
                 start = end + 1
-                new_partition = parted.Partition(disk=disklabel.partedDisk,
+                new_partition = parted.Partition(disk=disklabel.parted_disk,
                                                  type=ptype,
                                                  geometry=new_geometry)
                 new_partitions.append((new_partition, p.device))
 
             # remove all new partitions from this chunk
-            removeNewPartitions([disk], [r.device for r in chunk.requests],
+            remove_new_partitions([disk], [r.device for r in chunk.requests],
                                 partitions)
-            log.debug("back from removeNewPartitions")
+            log.debug("back from remove_new_partitions")
 
             # adjust the extended partition as needed
             # we will ony resize an extended partition that we created
@@ -1813,11 +1813,11 @@ def growPartitions(disks, partitions, free, size_sets=None):
                         # (partition.geometry.start is already aligned)
                         ext_start = partition.geometry.start - default_alignment.grainSize
 
-                new_geometry = parted.Geometry(device=disklabel.partedDevice,
+                new_geometry = parted.Geometry(device=disklabel.parted_device,
                                                start=ext_start,
                                                end=chunk.geometry.end)
                 log.debug("new geometry for extended: %s", new_geometry)
-                new_extended = parted.Partition(disk=disklabel.partedDisk,
+                new_extended = parted.Partition(disk=disklabel.parted_disk,
                                                 type=parted.PARTITION_EXTENDED,
                                                 geometry=new_geometry)
                 ptypes = [p.type for (p, d) in new_partitions]
@@ -1832,28 +1832,28 @@ def growPartitions(disks, partitions, free, size_sets=None):
                     name = device.name
                 else:
                     # If there was no extended partition on this disk when
-                    # doPartitioning was called we won't have a
+                    # do_partitioning was called we won't have a
                     # PartitionDevice instance for it.
                     name = partition.getDeviceNodeName()
 
                 log.debug("setting %s new geometry: %s", name,
                                                          partition.geometry)
                 constraint = parted.Constraint(exactGeom=partition.geometry)
-                disklabel.partedDisk.addPartition(partition=partition,
+                disklabel.parted_disk.addPartition(partition=partition,
                                                   constraint=constraint)
                 path = partition.path
                 if device:
                     # set the device's name
-                    device.partedPartition = partition
+                    device.parted_partition = partition
                     # without this, the path attr will be a basename. eek.
                     device.disk = disk
 
                     # make sure we store the disk's version of the partition
-                    newpart = disklabel.partedDisk.getPartitionByPath(path)
-                    device.partedPartition = newpart
+                    newpart = disklabel.parted_disk.getPartitionByPath(path)
+                    device.parted_partition = newpart
 
 
-def lvCompare(lv1, lv2):
+def lv_compare(lv1, lv2):
     """ More specifically defined lvs come first.
 
         < 1 => x < y
@@ -1889,7 +1889,7 @@ def lvCompare(lv1, lv2):
 
     return ret
 
-_lvCompareKey = functools.cmp_to_key(lvCompare)
+_lv_compare_key = functools.cmp_to_key(lv_compare)
 
 def _apply_chunk_growth(chunk):
     """ grow the lvs by the amounts the VGChunk calculated """
@@ -1897,18 +1897,18 @@ def _apply_chunk_growth(chunk):
         if not req.device.req_grow:
             continue
 
-        size = chunk.lengthToSize(req.base + req.growth)
+        size = chunk.length_to_size(req.base + req.growth)
 
         # reduce the size of thin pools by the pad size
         if hasattr(req.device, "lvs"):
-            size -= Size(blockdev.lvm.get_thpool_padding(size, req.device.vg.peSize, included=True))
+            size -= Size(blockdev.lvm.get_thpool_padding(size, req.device.vg.pe_size, included=True))
 
         # Base is pe, which means potentially rounded up by as much as
         # pesize-1. As a result, you can't just add the growth to the
         # initial size.
         req.device.size = size
 
-def growLVM(storage):
+def grow_lvm(storage):
     """ Grow LVs according to the sizes of the PVs.
 
         Strategy for growth involving thin pools:
@@ -1920,7 +1920,7 @@ def growLVM(storage):
               ThinPoolChunk class.
     """
     for vg in storage.vgs:
-        total_free = vg.freeSpace
+        total_free = vg.free_space
         if total_free < 0:
             # by now we have allocated the PVs so if there isn't enough
             # space in the VG we have a real problem
@@ -1938,32 +1938,32 @@ def growLVM(storage):
         for lv in fatlvs:
             if lv in vg.thinpools:
                 # make sure the pool's base size is at least the sum of its lvs'
-                lv.req_size = max(lv.req_size, lv.usedSpace)
+                lv.req_size = max(lv.req_size, lv.used_space)
 
                 # add the required padding to the requested pool size
-                lv.req_size += Size(blockdev.lvm.get_thpool_padding(lv.req_size, vg.peSize))
+                lv.req_size += Size(blockdev.lvm.get_thpool_padding(lv.req_size, vg.pe_size))
 
         # establish sizes for the percentage-based requests (which are fixed)
         percentage_based_lvs = [lv for lv in vg.lvs if lv.req_percent]
         if sum(lv.req_percent for lv in percentage_based_lvs) > 100:
             raise ValueError("sum of percentages within a vg cannot exceed 100")
 
-        percent_base = sum(vg.align(lv.req_size, roundup=False) / vg.peSize
+        percent_base = sum(vg.align(lv.req_size, roundup=False) / vg.pe_size
                             for lv in percentage_based_lvs)
-        percentage_basis = vg.freeExtents + percent_base
+        percentage_basis = vg.free_extents + percent_base
         for lv in percentage_based_lvs:
             new_extents = int(lv.req_percent * Decimal('0.01') * percentage_basis)
             # set req_size also so the request can also be growable if desired
-            lv.size = lv.req_size = vg.peSize * new_extents
+            lv.size = lv.req_size = vg.pe_size * new_extents
 
         # grow regular lvs
         chunk = VGChunk(vg, requests=[LVRequest(l) for l in fatlvs])
-        chunk.growRequests()
+        chunk.grow_requests()
         _apply_chunk_growth(chunk)
 
         # now, grow thin lv requests within their respective pools
         for pool in vg.thinpools:
             requests = [LVRequest(l) for l in pool.lvs]
             thin_chunk = ThinPoolChunk(pool, requests)
-            thin_chunk.growRequests()
+            thin_chunk.grow_requests()
             _apply_chunk_growth(thin_chunk)
diff --git a/blivet/partspec.py b/blivet/partspec.py
index 164496b..3fc00ce 100644
--- a/blivet/partspec.py
+++ b/blivet/partspec.py
@@ -22,9 +22,9 @@
 from .util import stringize, unicodeize
 
 class PartSpec(object):
-    def __init__(self, mountpoint=None, fstype=None, size=None, maxSize=None,
+    def __init__(self, mountpoint=None, fstype=None, size=None, max_size=None,
                  grow=False, btr=False, lv=False, thin=False, weight=0,
-                 requiredSpace=0, encrypted=False):
+                 required_space=0, encrypted=False):
         """ Create a new storage specification.  These are used to specify
             the default partitioning layout as an object before we have the
             storage system up and running.  The attributes are obvious
@@ -42,7 +42,7 @@ def __init__(self, mountpoint=None, fstype=None, size=None, maxSize=None,
                       make sure /boot ends up in front, and any special (PReP,
                       appleboot, etc.) partitions end up in front of /boot.
                       This value means nothing unless lv and btr are both False.
-            requiredSpace -- This value is only taken into account if
+            required_space -- This value is only taken into account if
                              lv=True, and specifies the size in MiB that the
                              containing VG must be for this PartSpec to even
                              get used.  The VG's size is calculated before any
@@ -57,32 +57,32 @@ def __init__(self, mountpoint=None, fstype=None, size=None, maxSize=None,
         self.mountpoint = mountpoint
         self.fstype = fstype
         self.size = size
-        self.maxSize = maxSize
+        self.max_size = max_size
         self.grow = grow
         self.lv = lv
         self.btr = btr
         self.thin = thin
         self.weight = weight
-        self.requiredSpace = requiredSpace
+        self.required_space = required_space
         self.encrypted = encrypted
 
     # Force str and unicode types in case any of the properties are unicode
-    def _toString(self):
+    def _to_string(self):
         s = ("%(type)s instance (%(id)s) -- \n"
              "  mountpoint = %(mountpoint)s  lv = %(lv)s"
              "  thin = %(thin)s  btrfs = %(btrfs)s\n"
              "  weight = %(weight)s  fstype = %(fstype)s  encrypted = %(enc)s\n"
-             "  size = %(size)s  maxSize = %(maxSize)s  grow = %(grow)s\n" %
+             "  size = %(size)s  max_size = %(max_size)s  grow = %(grow)s\n" %
              {"type": self.__class__.__name__, "id": "%#x" % id(self),
               "mountpoint": self.mountpoint, "lv": self.lv, "btrfs": self.btr,
               "weight": self.weight, "fstype": self.fstype, "size": self.size,
-              "enc": self.encrypted, "maxSize": self.maxSize, "grow": self.grow,
+              "enc": self.encrypted, "max_size": self.max_size, "grow": self.grow,
               "thin": self.thin})
 
         return s
 
     def __str__(self):
-        return stringize(self._toString())
+        return stringize(self._to_string())
 
     def __unicode__(self):
-        return unicodeize(self._toString())
+        return unicodeize(self._to_string())
diff --git a/blivet/platform.py b/blivet/platform.py
index 934669e..613a042 100644
--- a/blivet/platform.py
+++ b/blivet/platform.py
@@ -60,31 +60,31 @@ class Platform(object):
     def __init__(self):
         """Creates a new Platform object.  This is basically an abstract class.
            You should instead use one of the platform-specific classes as
-           returned by getPlatform below.  Not all subclasses need to provide
+           returned by get_platform below.  Not all subclasses need to provide
            all the methods in this class."""
 
         self.update_from_flags()
 
     def update_from_flags(self):
         if flags.gpt:
-            if not self.setDefaultDiskLabelType("gpt"):
+            if not self.set_default_disklabel_type("gpt"):
                 log.warn("GPT is not a supported disklabel on this platform. Using default "
-                         "disklabel %s instead.", self.defaultDiskLabelType)
+                         "disklabel %s instead.", self.default_disklabel_type)
 
     def __call__(self):
         return self
 
     @property
-    def diskLabelTypes(self):
+    def disklabel_types(self):
         """A list of valid disklabel types for this architecture."""
         return self._disklabel_types
 
     @property
-    def defaultDiskLabelType(self):
+    def default_disklabel_type(self):
         """The default disklabel type for this architecture."""
-        return self.diskLabelTypes[0]
+        return self.disklabel_types[0]
 
-    def setDefaultDiskLabelType(self, disklabel):
+    def set_default_disklabel_type(self, disklabel):
         """Make the disklabel the default
 
            :param str disklabel: The disklabel type to set as default
@@ -105,7 +105,7 @@ def setDefaultDiskLabelType(self, disklabel):
         return True
 
     @property
-    def bootStage1ConstraintDict(self):
+    def boot_stage1_constraint_dict(self):
         d = {"device_types": self._boot_stage1_device_types,
              "format_types": self._boot_stage1_format_types,
              "mountpoints": self._boot_stage1_mountpoints,
@@ -116,36 +116,36 @@ def bootStage1ConstraintDict(self):
              "descriptions": dict((k, _(v)) for k, v in self._boot_descriptions.items())}
         return d
 
-    def requiredDiskLabelType(self, device_type):
+    def required_disklabel_type(self, device_type):
         # pylint: disable=unused-argument
         return None
 
-    def bestDiskLabelType(self, device):
+    def best_disklabel_type(self, device):
         """The best disklabel type for the specified device."""
         if flags.testing:
-            return self.defaultDiskLabelType
+            return self.default_disklabel_type
 
         parted_device = parted.Device(path=device.path)
 
         # if there's a required type for this device type, use that
-        labelType = self.requiredDiskLabelType(parted_device.type)
+        label_type = self.required_disklabel_type(parted_device.type)
         log.debug("required disklabel type for %s (%s) is %s",
-                  device.name, parted_device.type, labelType)
-        if not labelType:
+                  device.name, parted_device.type, label_type)
+        if not label_type:
             # otherwise, use the first supported type for this platform
             # that is large enough to address the whole device
-            labelType = self.defaultDiskLabelType
+            label_type = self.default_disklabel_type
             log.debug("default disklabel type for %s is %s", device.name,
-                                                             labelType)
-            for lt in self.diskLabelTypes:
+                                                             label_type)
+            for lt in self.disklabel_types:
                 l = parted.freshDisk(device=parted_device, ty=lt)
                 if l.maxPartitionStartSector > parted_device.length:
-                    labelType = lt
+                    label_type = lt
                     log.debug("selecting %s disklabel for %s based on size",
-                              labelType, device.name)
+                              label_type, device.name)
                     break
 
-        return labelType
+        return label_type
 
     @property
     def packages (self):
@@ -154,21 +154,21 @@ def packages (self):
             _packages.append('dracut-fips')
         return _packages
 
-    def setPlatformBootloaderReqs(self):
+    def set_platform_bootloader_reqs(self):
         """Return the required platform-specific bootloader partition
            information.  These are typically partitions that do not get mounted,
            like biosboot or prepboot, but may also include the /boot/efi
            partition."""
         return []
 
-    def setPlatformBootPartition(self):
+    def set_platform_boot_partition(self):
         """Return the default /boot partition for this platform."""
         return [PartSpec(mountpoint="/boot", size=Size("500MiB"),
                          weight=self.weight(mountpoint="/boot"))]
 
-    def setDefaultPartitioning(self):
+    def set_default_partitioning(self):
         """Return the default platform-specific partitioning information."""
-        return self.setPlatformBootloaderReqs() + self.setPlatformBootPartition()
+        return self.set_platform_bootloader_reqs() + self.set_platform_boot_partition()
 
     def weight(self, fstype=None, mountpoint=None):
         """ Given an fstype (as a string) or a mountpoint, return an integer
@@ -203,9 +203,9 @@ class X86(Platform):
     def __init__(self):
         super(X86, self).__init__()
 
-    def setPlatformBootloaderReqs(self):
+    def set_platform_bootloader_reqs(self):
         """Return the default platform-specific partitioning information."""
-        ret = Platform.setPlatformBootloaderReqs(self)
+        ret = Platform.set_platform_bootloader_reqs(self)
         ret.append(PartSpec(fstype="biosboot", size=Size("1MiB"),
                             weight=self.weight(fstype="biosboot")))
         return ret
@@ -237,10 +237,10 @@ class EFI(Platform):
                                     "an EFI System Partition on a GPT-formatted "
                                     "disk, mounted at /boot/efi.")
 
-    def setPlatformBootloaderReqs(self):
-        ret = Platform.setPlatformBootloaderReqs(self)
+    def set_platform_bootloader_reqs(self):
+        ret = Platform.set_platform_bootloader_reqs(self)
         ret.append(PartSpec(mountpoint="/boot/efi", fstype="efi",
-                            size=Size("20MiB"), maxSize=Size("200MiB"),
+                            size=Size("20MiB"), max_size=Size("200MiB"),
                             grow=True, weight=self.weight(fstype="efi")))
         return ret
 
@@ -259,10 +259,10 @@ class MacEFI(EFI):
     _non_linux_format_types = ["macefi"]
     _packages = ["mactel-boot"]
 
-    def setPlatformBootloaderReqs(self):
-        ret = Platform.setPlatformBootloaderReqs(self)
+    def set_platform_bootloader_reqs(self):
+        ret = Platform.set_platform_bootloader_reqs(self)
         ret.append(PartSpec(mountpoint="/boot/efi", fstype="macefi",
-                            size=Size("20MiB"), maxSize=Size("200MiB"),
+                            size=Size("20MiB"), max_size=Size("200MiB"),
                             grow=True, weight=self.weight(mountpoint="/boot/efi")))
         return ret
 
@@ -270,12 +270,12 @@ class Aarch64EFI(EFI):
     _non_linux_format_types = ["vfat", "ntfs"]
 
 class PPC(Platform):
-    _ppcMachine = arch.getPPCMachine()
+    _ppc_machine = arch.get_ppc_machine()
     _boot_stage1_device_types = ["partition"]
 
     @property
-    def ppcMachine(self):
-        return self._ppcMachine
+    def ppc_machine(self):
+        return self._ppc_machine
 
 class IPSeriesPPC(PPC):
     _boot_stage1_format_types = ["prepboot"]
@@ -287,8 +287,8 @@ class IPSeriesPPC(PPC):
                                     "within the first 4GiB of an MBR- "
                                     "or GPT-formatted disk.")
 
-    def setPlatformBootloaderReqs(self):
-        ret = PPC.setPlatformBootloaderReqs(self)
+    def set_platform_bootloader_reqs(self):
+        ret = PPC.set_platform_bootloader_reqs(self)
         ret.append(PartSpec(fstype="prepboot", size=Size("4MiB"),
                             weight=self.weight(fstype="prepboot")))
         return ret
@@ -312,8 +312,8 @@ class NewWorldPPC(PPC):
                                     "Partition on an Apple Partition Map-"
                                     "formatted disk.")
 
-    def setPlatformBootloaderReqs(self):
-        ret = Platform.setPlatformBootloaderReqs(self)
+    def set_platform_bootloader_reqs(self):
+        ret = Platform.set_platform_bootloader_reqs(self)
         ret.append(PartSpec(fstype="appleboot", size=Size("1MiB"),
                             weight=self.weight(fstype="appleboot")))
         return ret
@@ -347,20 +347,20 @@ class S390(Platform):
     def __init__(self):
         Platform.__init__(self)
 
-    def setPlatformBootPartition(self):
+    def set_platform_boot_partition(self):
         """Return the default platform-specific partitioning information."""
         return [PartSpec(mountpoint="/boot", size=Size("500MiB"),
                          weight=self.weight(mountpoint="/boot"), lv=False)]
 
-    def requiredDiskLabelType(self, device_type):
+    def required_disklabel_type(self, device_type):
         """The required disklabel type for the specified device type."""
         if device_type == parted.DEVICE_DASD:
             return "dasd"
 
-        return super(S390, self).requiredDiskLabelType(device_type)
+        return super(S390, self).required_disklabel_type(device_type)
 
 class ARM(Platform):
-    _armMachine = None
+    _arm_machine = None
     _boot_stage1_device_types = ["disk"]
     _boot_mbr_description = N_("Master Boot Record")
     _boot_descriptions = {"disk": _boot_mbr_description,
@@ -371,10 +371,10 @@ class ARM(Platform):
                                     "disk as an install target.")
 
     @property
-    def armMachine(self):
-        if not self._armMachine:
-            self._armMachine = arch.getARMMachine()
-        return self._armMachine
+    def arm_machine(self):
+        if not self._arm_machine:
+            self._arm_machine = arch.get_arm_machine()
+        return self._arm_machine
 
     def weight(self, fstype=None, mountpoint=None):
         """Return the ARM platform-specific weight for the / partition.
@@ -394,18 +394,18 @@ class omapARM(ARM):
     _boot_stage1_missing_error = N_("You must include a U-Boot Partition on a "
                                     "FAT-formatted disk, mounted at /boot/uboot.")
 
-    def setPlatformBootloaderReqs(self):
+    def set_platform_bootloader_reqs(self):
         """Return the ARM-OMAP platform-specific partitioning information."""
         ret = [PartSpec(mountpoint="/boot/uboot", fstype="vfat",
-                        size=Size("20MiB"), maxSize=Size("200MiB"),
+                        size=Size("20MiB"), max_size=Size("200MiB"),
                         grow=True,
                         weight=self.weight(fstype="vfat", mountpoint="/boot/uboot"))]
         return ret
 
-    def setDefaultPartitioning(self):
-        ret = ARM.setDefaultPartitioning(self)
+    def set_default_partitioning(self):
+        ret = ARM.set_default_partitioning(self)
         ret.append(PartSpec(mountpoint="/", fstype="ext4",
-                            size=Size("2GiB"), maxSize=Size("3GiB"),
+                            size=Size("2GiB"), max_size=Size("3GiB"),
                             weight=self.weight(mountpoint="/")))
         return ret
 
@@ -421,39 +421,39 @@ def weight(self, fstype=None, mountpoint=None):
         else:
             return Platform.weight(self, fstype=fstype, mountpoint=mountpoint)
 
-def getPlatform():
+def get_platform():
     """Check the architecture of the system and return an instance of a
        Platform subclass to match.  If the architecture could not be determined,
        raise an exception."""
-    if arch.isPPC():
-        ppcMachine = arch.getPPCMachine()
+    if arch.is_ppc():
+        ppc_machine = arch.get_ppc_machine()
 
-        if (ppcMachine == "PMac" and arch.getPPCMacGen() == "NewWorld"):
+        if (ppc_machine == "PMac" and arch.get_ppc_mac_gen() == "NewWorld"):
             return NewWorldPPC()
-        elif ppcMachine in ["iSeries", "pSeries"]:
+        elif ppc_machine in ["iSeries", "pSeries"]:
             return IPSeriesPPC()
-        elif ppcMachine == "PS3":
+        elif ppc_machine == "PS3":
             return PS3()
         else:
-            raise SystemError("Unsupported PPC machine type: %s" % ppcMachine)
-    elif arch.isS390():
+            raise SystemError("Unsupported PPC machine type: %s" % ppc_machine)
+    elif arch.is_s390():
         return S390()
-    elif arch.isEfi():
-        if arch.isMactel():
+    elif arch.is_efi():
+        if arch.is_mactel():
             return MacEFI()
-        elif arch.isAARCH64():
+        elif arch.is_aarch64():
             return Aarch64EFI()
         else:
             return EFI()
-    elif arch.isX86():
+    elif arch.is_x86():
         return X86()
-    elif arch.isARM():
-        armMachine = arch.getARMMachine()
-        if armMachine == "omap":
+    elif arch.is_arm():
+        arm_machine = arch.get_arm_machine()
+        if arm_machine == "omap":
             return omapARM()
         else:
             return ARM()
     else:
         raise SystemError("Could not determine system architecture.")
 
-platform = getPlatform()
+platform = get_platform()
diff --git a/blivet/populator.py b/blivet/populator.py
index 733c593..0d041fe 100644
--- a/blivet/populator.py
+++ b/blivet/populator.py
@@ -43,7 +43,7 @@
 from .devices import MDContainerDevice
 from .devices import MultipathDevice, OpticalDevice
 from .devices import PartitionDevice, ZFCPDiskDevice, iScsiDiskDevice
-from .devices import devicePathToName
+from .devices import device_path_to_name
 from .devices.lvm import get_internal_lv_class
 from . import formats
 from .devicelibs import lvm
@@ -73,13 +73,13 @@ def parted_exn_handler(exn_type, exn_options, exn_msg):
 
 class Populator(object):
     def __init__(self, devicetree=None, conf=None, passphrase=None,
-                 luksDict=None, iscsi=None, dasd=None):
+                 luks_dict=None, iscsi=None, dasd=None):
         """
             :keyword conf: storage discovery configuration
             :type conf: :class:`~.StorageDiscoveryConfig`
             :keyword passphrase: default LUKS passphrase
-            :keyword luksDict: a dict with UUID keys and passphrase values
-            :type luksDict: dict
+            :keyword luks_dict: a dict with UUID keys and passphrase values
+            :type luks_dict: dict
             :keyword iscsi: ISCSI control object
             :type iscsi: :class:`~.iscsi.iscsi`
             :keyword dasd: DASD control object
@@ -91,39 +91,39 @@ def __init__(self, devicetree=None, conf=None, passphrase=None,
         # indicates whether or not the tree has been fully populated
         self.populated = False
 
-        self.exclusiveDisks = getattr(conf, "exclusiveDisks", [])
-        self.ignoredDisks = getattr(conf, "ignoredDisks", [])
+        self.exclusive_disks = getattr(conf, "exclusiveDisks", [])
+        self.ignored_disks = getattr(conf, "ignoredDisks", [])
         self.iscsi = iscsi
         self.dasd = dasd
 
-        self.diskImages = {}
+        self.disk_images = {}
         images = getattr(conf, "diskImages", {})
         if images:
-            # this will overwrite self.exclusiveDisks
-            self.setDiskImages(images)
+            # this will overwrite self.exclusive_disks
+            self.set_disk_images(images)
 
         # protected device specs as provided by the user
-        self.protectedDevSpecs = getattr(conf, "protectedDevSpecs", [])
-        self.liveBackingDevice = None
+        self.protected_dev_specs = getattr(conf, "protectedDevSpecs", [])
+        self.live_backing_device = None
 
         # names of protected devices at the time of tree population
-        self.protectedDevNames = []
+        self.protected_dev_names = []
 
-        self.unusedRaidMembers = []
+        self.unused_raid_members = []
 
         self.__passphrases = []
         if passphrase:
             self.__passphrases.append(passphrase)
 
-        self.__luksDevs = {}
-        if luksDict and isinstance(luksDict, dict):
-            self.__luksDevs = luksDict
-            self.__passphrases.extend([p for p in luksDict.values() if p])
+        self.__luks_devs = {}
+        if luks_dict and isinstance(luks_dict, dict):
+            self.__luks_devs = luks_dict
+            self.__passphrases.extend([p for p in luks_dict.values() if p])
 
         self._cleanup = False
 
-    def setDiskImages(self, images):
-        """ Set the disk images and reflect them in exclusiveDisks.
+    def set_disk_images(self, images):
+        """ Set the disk images and reflect them in exclusive_disks.
 
             :param images: dict with image name keys and filename values
             :type images: dict
@@ -134,15 +134,15 @@ def setDiskImages(self, images):
                 presence of disk images, any local storage not associated with
                 the disk images is ignored.
         """
-        self.diskImages = images
+        self.disk_images = images
         # disk image files are automatically exclusive
-        self.exclusiveDisks = list(self.diskImages.keys())
+        self.exclusive_disks = list(self.disk_images.keys())
 
-    def addIgnoredDisk(self, disk):
-        self.ignoredDisks.append(disk)
+    def add_ignored_disk(self, disk):
+        self.ignored_disks.append(disk)
         lvm.lvm_cc_addFilterRejectRegexp(disk)
 
-    def isIgnored(self, info):
+    def is_ignored(self, info):
         """ Return True if info is a device we should ignore.
 
             :param info: udevdb device entry
@@ -158,7 +158,7 @@ def isIgnored(self, info):
 
         # Special handling for mdraid external metadata sets (mdraid BIOSRAID):
         # 1) The containers are intermediate devices which will never be
-        # in exclusiveDisks
+        # in exclusive_disks
         # 2) Sets get added to exclusive disks with their dmraid set name by
         # the filter ui.  Note that making the ui use md names instead is not
         # possible as the md names are simpy md# and we cannot predict the #
@@ -175,10 +175,10 @@ def isIgnored(self, info):
             alt_name = re.sub(r"_\d+$", "", md_name)
             raw_pattern = "isw_[a-z]*_%s"
             # XXX FIXME: This is completely insane.
-            for i in range(0, len(self.exclusiveDisks)):
-                if re.match(raw_pattern % md_name, self.exclusiveDisks[i]) or \
-                   re.match(raw_pattern % alt_name, self.exclusiveDisks[i]):
-                    self.exclusiveDisks[i] = name
+            for i in range(0, len(self.exclusive_disks)):
+                if re.match(raw_pattern % md_name, self.exclusive_disks[i]) or \
+                   re.match(raw_pattern % alt_name, self.exclusive_disks[i]):
+                    self.exclusive_disks[i] = name
                     return False
 
         # never ignore mapped disk images. if you don't want to use them,
@@ -199,10 +199,10 @@ def isIgnored(self, info):
 
         # FIXME: check for virtual devices whose slaves are on the ignore list
 
-    def _isIgnoredDisk(self, disk):
-        return self.devicetree._isIgnoredDisk(disk)
+    def _is_ignored_disk(self, disk):
+        return self.devicetree._is_ignored_disk(disk)
 
-    def udevDeviceIsDisk(self, info):
+    def udev_device_is_disk(self, info):
         """ Return True if the udev device looks like a disk.
 
             :param info: udevdb device entry
@@ -210,7 +210,7 @@ def udevDeviceIsDisk(self, info):
             :returns: whether the device is a disk
             :rtype: bool
 
-            We want exclusiveDisks to operate on anything that could be
+            We want exclusive_disks to operate on anything that could be
             considered a directly usable disk, ie: fwraid array, mpath, or disk.
 
             Unfortunately, since so many things are represented as disks by
@@ -226,7 +226,7 @@ def udevDeviceIsDisk(self, info):
                      (udev.device_is_md(info) and
                       not udev.device_get_md_container(info))))
 
-    def _addSlaveDevices(self, info):
+    def _add_slave_devices(self, info):
         """ Add all slaves of a device, raising DeviceTreeError on failure.
 
             :param :class:`pyudev.Device` info: the device's udev info
@@ -254,14 +254,14 @@ def _addSlaveDevices(self, info):
             if not slave_info:
                 log.warning("unable to get udev info for %s", slave_name)
 
-            slave_dev = self.getDeviceByName(slave_name)
+            slave_dev = self.get_device_by_name(slave_name)
             if not slave_dev and slave_info:
                 # we haven't scanned the slave yet, so do it now
-                self.addUdevDevice(slave_info)
-                slave_dev = self.getDeviceByName(slave_name)
+                self.add_udev_device(slave_info)
+                slave_dev = self.get_device_by_name(slave_name)
                 if slave_dev is None:
                     if udev.device_is_dm_lvm(info):
-                        if slave_name not in self.devicetree.lvInfo:
+                        if slave_name not in self.devicetree.lv_info:
                             # we do not expect hidden lvs to be in the tree
                             continue
 
@@ -276,33 +276,33 @@ def _addSlaveDevices(self, info):
 
         return slave_devices
 
-    def addUdevLVDevice(self, info):
+    def add_udev_lv_device(self, info):
         name = udev.device_get_name(info)
         log_method_call(self, name=name)
 
         vg_name = udev.device_get_lv_vg_name(info)
-        device = self.getDeviceByName(vg_name, hidden=True)
+        device = self.get_device_by_name(vg_name, hidden=True)
         if device and not isinstance(device, LVMVolumeGroupDevice):
             log.warning("found non-vg device with name %s", vg_name)
             device = None
 
-        self._addSlaveDevices(info)
+        self._add_slave_devices(info)
 
         # LVM provides no means to resolve conflicts caused by duplicated VG
         # names, so we're just being optimistic here. Woo!
         vg_name = udev.device_get_lv_vg_name(info)
-        vg_device = self.getDeviceByName(vg_name)
+        vg_device = self.get_device_by_name(vg_name)
         if not vg_device:
             log.error("failed to find vg '%s' after scanning pvs", vg_name)
 
-        return self.getDeviceByName(name)
+        return self.get_device_by_name(name)
 
-    def addUdevDMDevice(self, info):
+    def add_udev_dm_device(self, info):
         name = udev.device_get_name(info)
         log_method_call(self, name=name)
         sysfs_path = udev.device_get_sysfs_path(info)
-        slave_devices = self._addSlaveDevices(info)
-        device = self.getDeviceByName(name)
+        slave_devices = self._add_slave_devices(info)
+        device = self.get_device_by_name(name)
 
         # 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
@@ -310,21 +310,21 @@ def addUdevDMDevice(self, info):
                         (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.mapName = name
-            slave_info = udev.get_device(slave_dev.sysfsPath)
-            self.handleUdevLUKSFormat(slave_info, slave_dev)
+            slave_dev.format.map_name = name
+            slave_info = udev.get_device(slave_dev.sysfs_path)
+            self.handle_udev_luks_format(slave_info, slave_dev)
 
             # try once more to get the device
-            device = self.getDeviceByName(name)
+            device = self.get_device_by_name(name)
 
         # create a device for the livecd OS image(s)
         if device is None and udev.device_is_dm_livecd(info):
-            device = DMDevice(name, dmUuid=info.get('DM_UUID'),
-                              sysfsPath=sysfs_path, exists=True,
+            device = DMDevice(name, dm_uuid=info.get('DM_UUID'),
+                              sysfs_path=sysfs_path, exists=True,
                               parents=[slave_devices[0]])
             device.protected = True
             device.controllable = False
-            self.devicetree._addDevice(device)
+            self.devicetree._add_device(device)
 
         # if we get here, we found all of the slave devices and
         # something must be wrong -- if all of the slaves are in
@@ -335,11 +335,11 @@ def addUdevDMDevice(self, info):
 
         return device
 
-    def addUdevMultiPathDevice(self, info):
+    def add_udev_multipath_device(self, info):
         name = udev.device_get_name(info)
         log_method_call(self, name=name)
 
-        slave_devices = self._addSlaveDevices(info)
+        slave_devices = self._add_slave_devices(info)
 
         device = None
         if slave_devices:
@@ -350,20 +350,20 @@ def addUdevMultiPathDevice(self, info):
                 raise DeviceTreeError("multipath %s has no DM_UUID" % name)
 
             device = MultipathDevice(name, parents=slave_devices,
-                                     sysfsPath=udev.device_get_sysfs_path(info),
+                                     sysfs_path=udev.device_get_sysfs_path(info),
                                      serial=serial)
-            self.devicetree._addDevice(device)
+            self.devicetree._add_device(device)
 
         return device
 
-    def addUdevMDDevice(self, info):
+    def add_udev_md_device(self, info):
         name = udev.device_get_md_name(info)
         log_method_call(self, name=name)
 
-        self._addSlaveDevices(info)
+        self._add_slave_devices(info)
 
         # try to get the device again now that we've got all the slaves
-        device = self.getDeviceByName(name, incomplete=flags.allow_imperfect_devices)
+        device = self.get_device_by_name(name, incomplete=flags.allow_imperfect_devices)
 
         if device is None:
             try:
@@ -371,7 +371,7 @@ def addUdevMDDevice(self, info):
             except KeyError:
                 log.warning("failed to obtain uuid for mdraid device")
             else:
-                device = self.getDeviceByUuid(uuid, incomplete=flags.allow_imperfect_devices)
+                device = self.get_device_by_uuid(uuid, incomplete=flags.allow_imperfect_devices)
 
         if device and name:
             # update the device instance with the real name in case we had to
@@ -396,14 +396,14 @@ def addUdevMDDevice(self, info):
 
         return device
 
-    def addUdevPartitionDevice(self, info, disk=None):
+    def add_udev_partition_device(self, info, disk=None):
         name = udev.device_get_name(info)
         log_method_call(self, name=name)
         sysfs_path = udev.device_get_sysfs_path(info)
 
         if name.startswith("md"):
             name = blockdev.md.name_from_node(name)
-            device = self.getDeviceByName(name)
+            device = self.get_device_by_name(name)
             if device:
                 return device
 
@@ -413,14 +413,14 @@ def addUdevPartitionDevice(self, info, disk=None):
             if disk_name.startswith("md"):
                 disk_name = blockdev.md.name_from_node(disk_name)
 
-            disk = self.getDeviceByName(disk_name)
+            disk = self.get_device_by_name(disk_name)
 
         if disk is None:
             # create a device instance for the disk
             new_info = udev.get_device(os.path.dirname(sysfs_path))
             if new_info:
-                self.addUdevDevice(new_info)
-                disk = self.getDeviceByName(disk_name)
+                self.add_udev_device(new_info)
+                disk = self.get_device_by_name(disk_name)
 
             if disk is None:
                 # if the current device is still not in
@@ -438,7 +438,7 @@ def addUdevPartitionDevice(self, info, disk=None):
             if disk.partitionable and \
                disk.format.type != "iso9660" and \
                not disk.format.hidden and \
-               not self._isIgnoredDisk(disk):
+               not self._is_ignored_disk(disk):
                 if info.get("ID_PART_TABLE_TYPE") == "gpt":
                     msg = "corrupt gpt disklabel on disk %s" % disk.name
                     cls = CorruptGPTError
@@ -459,7 +459,7 @@ def addUdevPartitionDevice(self, info, disk=None):
 
         device = None
         try:
-            device = PartitionDevice(name, sysfsPath=sysfs_path,
+            device = PartitionDevice(name, sysfs_path=sysfs_path,
                                      major=udev.device_get_major(info),
                                      minor=udev.device_get_minor(info),
                                      exists=True, parents=[disk])
@@ -472,10 +472,10 @@ def addUdevPartitionDevice(self, info, disk=None):
             log.error("Failed to instantiate PartitionDevice: %s", e)
             return
 
-        self.devicetree._addDevice(device)
+        self.devicetree._add_device(device)
         return device
 
-    def addUdevDiskDevice(self, info):
+    def add_udev_disk_device(self, info):
         name = udev.device_get_name(info)
         log_method_call(self, name=name)
         sysfs_path = udev.device_get_sysfs_path(info)
@@ -487,7 +487,7 @@ def addUdevDiskDevice(self, info):
 
         kwargs = { "serial": serial, "vendor": vendor, "model": model, "bus": bus }
         if udev.device_is_iscsi(info) and not self._cleanup:
-            diskType = iScsiDiskDevice
+            disk_type = iScsiDiskDevice
             initiator = udev.device_get_iscsi_initiator(info)
             target = udev.device_get_iscsi_name(info)
             address = udev.device_get_iscsi_address(info)
@@ -495,9 +495,9 @@ def addUdevDiskDevice(self, info):
             nic = udev.device_get_iscsi_nic(info)
             kwargs["initiator"] = initiator
             if initiator == self.iscsi.initiator:
-                node = self.iscsi.getNode(target, address, port, nic)
+                node = self.iscsi.get_node(target, address, port, nic)
                 kwargs["node"] = node
-                kwargs["ibft"] = node in self.iscsi.ibftNodes
+                kwargs["ibft"] = node in self.iscsi.ibft_nodes
                 kwargs["nic"] = self.iscsi.ifaces.get(node.iface, node.iface)
                 log.info("%s is an iscsi disk", name)
             else:
@@ -509,34 +509,34 @@ def addUdevDiskDevice(self, info):
                 kwargs["fw_port"] = port
                 kwargs["fw_name"] = name
         elif udev.device_is_fcoe(info):
-            diskType = FcoeDiskDevice
+            disk_type = FcoeDiskDevice
             kwargs["nic"]        = udev.device_get_fcoe_nic(info)
             kwargs["identifier"] = udev.device_get_fcoe_identifier(info)
             log.info("%s is an fcoe disk", name)
         elif udev.device_get_md_container(info):
             name = udev.device_get_md_name(info)
-            diskType = MDBiosRaidArrayDevice
-            parentPath = udev.device_get_md_container(info)
-            parentName = devicePathToName(parentPath)
-            container = self.getDeviceByName(parentName)
+            disk_type = MDBiosRaidArrayDevice
+            parent_path = udev.device_get_md_container(info)
+            parent_name = device_path_to_name(parent_path)
+            container = self.get_device_by_name(parent_name)
             if not container:
-                parentSysName = blockdev.md.node_from_name(parentName)
-                container_sysfs = "/sys/class/block/" + parentSysName
+                parent_sys_name = blockdev.md.node_from_name(parent_name)
+                container_sysfs = "/sys/class/block/" + parent_sys_name
                 container_info = udev.get_device(container_sysfs)
                 if not container_info:
                     log.error("failed to find md container %s at %s",
-                                parentName, container_sysfs)
+                                parent_name, container_sysfs)
                     return
 
-                self.addUdevDevice(container_info)
-                container = self.getDeviceByName(parentName)
+                self.add_udev_device(container_info)
+                container = self.get_device_by_name(parent_name)
                 if not container:
-                    log.error("failed to scan md container %s", parentName)
+                    log.error("failed to scan md container %s", parent_name)
                     return
 
             kwargs["parents"] = [container]
             kwargs["level"]  = udev.device_get_md_level(info)
-            kwargs["memberDevices"] = udev.device_get_md_devices(info)
+            kwargs["member_devices"] = udev.device_get_md_devices(info)
             kwargs["uuid"] = udev.device_get_md_uuid(info)
             kwargs["exists"]  = True
             del kwargs["model"]
@@ -544,7 +544,7 @@ def addUdevDiskDevice(self, info):
             del kwargs["vendor"]
             del kwargs["bus"]
         elif udev.device_is_dasd(info) and not self._cleanup:
-            diskType = DASDDevice
+            disk_type = DASDDevice
             kwargs["busid"] = udev.device_get_dasd_bus_id(info)
             kwargs["opts"] = {}
 
@@ -553,28 +553,28 @@ def addUdevDiskDevice(self, info):
 
             log.info("%s is a dasd device", name)
         elif udev.device_is_zfcp(info):
-            diskType = ZFCPDiskDevice
+            disk_type = ZFCPDiskDevice
 
             for attr in ['hba_id', 'wwpn', 'fcp_lun']:
                 kwargs[attr] = udev.device_get_zfcp_attribute(info, attr=attr)
 
             log.info("%s is a zfcp device", name)
         else:
-            diskType = DiskDevice
+            disk_type = DiskDevice
             log.info("%s is a disk", name)
 
-        device = diskType(name,
+        device = disk_type(name,
                           major=udev.device_get_major(info),
                           minor=udev.device_get_minor(info),
-                          sysfsPath=sysfs_path, **kwargs)
+                          sysfs_path=sysfs_path, **kwargs)
 
-        if diskType == DASDDevice:
+        if disk_type == DASDDevice:
             self.dasd.append(device)
 
-        self.devicetree._addDevice(device)
+        self.devicetree._add_device(device)
         return device
 
-    def addUdevOpticalDevice(self, info):
+    def add_udev_optical_device(self, info):
         log_method_call(self)
         # XXX should this be RemovableDevice instead?
         #
@@ -582,43 +582,43 @@ def addUdevOpticalDevice(self, info):
         device = OpticalDevice(udev.device_get_name(info),
                                major=udev.device_get_major(info),
                                minor=udev.device_get_minor(info),
-                               sysfsPath=udev.device_get_sysfs_path(info),
+                               sysfs_path=udev.device_get_sysfs_path(info),
                                vendor=udev.device_get_vendor(info),
                                model=udev.device_get_model(info))
-        self.devicetree._addDevice(device)
+        self.devicetree._add_device(device)
         return device
 
-    def addUdevLoopDevice(self, info):
+    def add_udev_loop_device(self, info):
         name = udev.device_get_name(info)
         log_method_call(self, name=name)
         sysfs_path = udev.device_get_sysfs_path(info)
         sys_file = "%s/loop/backing_file" % sysfs_path
         backing_file = open(sys_file).read().strip()
-        file_device = self.getDeviceByName(backing_file)
+        file_device = self.get_device_by_name(backing_file)
         if not file_device:
             file_device = FileDevice(backing_file, exists=True)
-            self.devicetree._addDevice(file_device)
+            self.devicetree._add_device(file_device)
         device = LoopDevice(name,
                             parents=[file_device],
-                            sysfsPath=sysfs_path,
+                            sysfs_path=sysfs_path,
                             exists=True)
-        if not self._cleanup or file_device not in self.diskImages.values():
+        if not self._cleanup or file_device not in self.disk_images.values():
             # don't allow manipulation of loop devices other than those
             # associated with disk images, and then only during cleanup
             file_device.controllable = False
             device.controllable = False
-        self.devicetree._addDevice(device)
+        self.devicetree._add_device(device)
         return device
 
-    def addUdevDevice(self, info, updateOrigFmt=False):
+    def add_udev_device(self, info, update_orig_fmt=False):
         """
             :param :class:`pyudev.Device` info: udev info for the device
-            :keyword bool updateOrigFmt: update original format unconditionally
+            :keyword bool update_orig_fmt: update original format unconditionally
 
             If a device is added to the tree based on info its original format
             will be saved after the format has been detected. If the device
             that corresponds to info is already in the tree, its original format
-            will not be updated unless updateOrigFmt is True.
+            will not be updated unless update_orig_fmt is True.
         """
         name = udev.device_get_name(info)
         log_method_call(self, name=name, info=pprint.pformat(dict(info)))
@@ -631,7 +631,7 @@ def addUdevDevice(self, info, updateOrigFmt=False):
                                                         action_type="destroy",
                                                         object_type="device")]
         for ignored in removed + self.devicetree._hidden:
-            if (sysfs_path and ignored.sysfsPath == sysfs_path) or \
+            if (sysfs_path and ignored.sysfs_path == sysfs_path) or \
                (uuid and uuid in (ignored.uuid, ignored.format.uuid)):
                 if ignored in removed:
                     reason = "removed"
@@ -645,15 +645,15 @@ def addUdevDevice(self, info, updateOrigFmt=False):
         if name not in self.names:
             self.names.append(name)
 
-        if self.isIgnored(info):
+        if self.is_ignored(info):
             log.info("ignoring %s (%s)", name, sysfs_path)
-            if name not in self.ignoredDisks:
-                self.addIgnoredDisk(name)
+            if name not in self.ignored_disks:
+                self.add_ignored_disk(name)
 
             return
 
         log.info("scanning %s (%s)...", name, sysfs_path)
-        device = self.getDeviceByName(name)
+        device = self.get_device_by_name(name)
         if device is None and udev.device_is_md(info):
 
             # If the md name is None, then some udev info is missing. Likely,
@@ -676,20 +676,20 @@ def addUdevDevice(self, info, updateOrigFmt=False):
             if md_name is None:
                 log.warning("No name for possibly degraded md array.")
             else:
-                device = self.getDeviceByName(md_name, incomplete=flags.allow_imperfect_devices)
+                device = self.get_device_by_name(md_name, incomplete=flags.allow_imperfect_devices)
 
             if device and not isinstance(device, MDRaidArrayDevice):
                 log.warning("Found device %s, but it turns out not be an md array device after all.", device.name)
                 device = None
 
-        if device and device.isDisk and \
+        if device and device.is_disk and \
            blockdev.mpath.is_mpath_member(device.path):
             # newly added device (eg iSCSI) could make this one a multipath member
             if device.format and device.format.type != "multipath_member":
                 log.debug("%s newly detected as multipath member, dropping old format and removing kids", device.name)
                 # remove children from tree so that we don't stumble upon them later
-                for child in self.devicetree.getChildren(device):
-                    self.devicetree.recursiveRemove(child, actions=False)
+                for child in self.devicetree.get_children(device):
+                    self.devicetree.recursive_remove(child, actions=False)
 
                 device.format = None
 
@@ -701,28 +701,28 @@ def addUdevDevice(self, info, updateOrigFmt=False):
             device_added = False
         elif udev.device_is_loop(info):
             log.info("%s is a loop device", name)
-            device = self.addUdevLoopDevice(info)
+            device = self.add_udev_loop_device(info)
         elif udev.device_is_dm_mpath(info) and \
              not udev.device_is_dm_partition(info):
             log.info("%s is a multipath device", name)
-            device = self.addUdevMultiPathDevice(info)
+            device = self.add_udev_multipath_device(info)
         elif udev.device_is_dm_lvm(info):
             log.info("%s is an lvm logical volume", name)
-            device = self.addUdevLVDevice(info)
+            device = self.add_udev_lv_device(info)
         elif udev.device_is_dm(info):
             log.info("%s is a device-mapper device", name)
-            device = self.addUdevDMDevice(info)
+            device = self.add_udev_dm_device(info)
         elif udev.device_is_md(info) and not udev.device_get_md_container(info):
             log.info("%s is an md device", name)
-            device = self.addUdevMDDevice(info)
+            device = self.add_udev_md_device(info)
         elif udev.device_is_cdrom(info):
             log.info("%s is a cdrom", name)
-            device = self.addUdevOpticalDevice(info)
+            device = self.add_udev_optical_device(info)
         elif udev.device_is_disk(info):
-            device = self.addUdevDiskDevice(info)
+            device = self.add_udev_disk_device(info)
         elif udev.device_is_partition(info):
             log.info("%s is a partition", name)
-            device = self.addUdevPartitionDevice(info)
+            device = self.add_udev_partition_device(info)
         else:
             log.error("Unknown block device type for: %s", name)
             return
@@ -732,45 +732,45 @@ def addUdevDevice(self, info, updateOrigFmt=False):
             return
 
         # If this device is read-only, mark it as such now.
-        if self.udevDeviceIsDisk(info) and \
+        if self.udev_device_is_disk(info) and \
                 util.get_sysfs_attr(udev.device_get_sysfs_path(info), 'ro') == '1':
             device.readonly = True
 
         # If this device is protected, mark it as such now. Once the tree
         # has been populated, devices' protected attribute is how we will
         # identify protected devices.
-        if device.name in self.protectedDevNames:
+        if device.name in self.protected_dev_names:
             device.protected = True
             # if this is the live backing device we want to mark its parents
             # as protected also
-            if device.name == self.liveBackingDevice:
+            if device.name == self.live_backing_device:
                 for parent in device.parents:
                     parent.protected = True
 
-        # If we just added a multipath or fwraid disk that is in exclusiveDisks
+        # If we just added a multipath or fwraid disk that is in exclusive_disks
         # we have to make sure all of its members are in the list too.
         mdclasses = (DMRaidArrayDevice, MDRaidArrayDevice, MultipathDevice)
-        if device.isDisk and isinstance(device, mdclasses):
-            if device.name in self.exclusiveDisks:
+        if device.is_disk and isinstance(device, mdclasses):
+            if device.name in self.exclusive_disks:
                 for parent in device.parents:
-                    if parent.name not in self.exclusiveDisks:
-                        self.exclusiveDisks.append(parent.name)
+                    if parent.name not in self.exclusive_disks:
+                        self.exclusive_disks.append(parent.name)
 
         log.info("got device: %r", device)
 
         # now handle the device's formatting
-        self.handleUdevDeviceFormat(info, device)
-        if device_added or updateOrigFmt:
-            device.originalFormat = copy.deepcopy(device.format)
-        device.deviceLinks = udev.device_get_symlinks(info)
+        self.handle_udev_device_format(info, device)
+        if device_added or update_orig_fmt:
+            device.original_format = copy.deepcopy(device.format)
+        device.device_links = udev.device_get_symlinks(info)
 
-    def handleUdevDiskLabelFormat(self, info, device):
+    def handle_udev_disk_label_format(self, info, device):
         disklabel_type = udev.device_get_disklabel_type(info)
         log_method_call(self, device=device.name, label_type=disklabel_type)
         # if there is no disklabel on the device
         # blkid doesn't understand dasd disklabels, so bypass for dasd
         if disklabel_type is None and not \
-           (device.isDisk and udev.device_is_dasd(info)):
+           (device.is_disk and udev.device_is_dasd(info)):
             log.debug("device %s does not contain a disklabel", device.name)
             return
 
@@ -788,9 +788,9 @@ def handleUdevDiskLabelFormat(self, info, device):
         # special handling for unsupported partitioned devices
         if not device.partitionable:
             try:
-                fmt = formats.getFormat("disklabel",
+                fmt = formats.get_format("disklabel",
                                         device=device.path,
-                                        labelType=disklabel_type,
+                                        label_type=disklabel_type,
                                         exists=True)
             except InvalidDiskLabelError:
                 log.warning("disklabel detected but not usable on %s",
@@ -800,18 +800,18 @@ def handleUdevDiskLabelFormat(self, info, device):
             return
 
         try:
-            fmt = formats.getFormat("disklabel",
+            fmt = formats.get_format("disklabel",
                                     device=device.path,
                                     exists=True)
         except InvalidDiskLabelError as e:
             log.info("no usable disklabel on %s", device.name)
             if disklabel_type == "gpt":
                 log.debug(e)
-                device.format = formats.getFormat(_("Invalid Disk Label"))
+                device.format = formats.get_format(_("Invalid Disk Label"))
         else:
             device.format = fmt
 
-    def handleUdevLUKSFormat(self, info, device):
+    def handle_udev_luks_format(self, info, device):
         # pylint: disable=unused-argument
         log_method_call(self, name=device.name, type=device.format.type)
         if not device.format.uuid:
@@ -819,13 +819,13 @@ def handleUdevLUKSFormat(self, info, device):
             return
 
         # look up or create the mapped device
-        if not self.getDeviceByName(device.format.mapName):
-            passphrase = self.__luksDevs.get(device.format.uuid)
+        if not self.get_device_by_name(device.format.map_name):
+            passphrase = self.__luks_devs.get(device.format.uuid)
             if device.format.configured:
                 pass
             elif passphrase:
                 device.format.passphrase = passphrase
-            elif device.format.uuid in self.__luksDevs:
+            elif device.format.uuid in self.__luks_devs:
                 log.info("skipping previously-skipped luks device %s",
                             device.name)
             elif self._cleanup or flags.testing:
@@ -835,11 +835,11 @@ def handleUdevLUKSFormat(self, info, device):
                     # this makes device.configured return True
                     device.format.passphrase = 'yabbadabbadoo'
             else:
-                # Try each known passphrase. Include luksDevs values in case a
+                # Try each known passphrase. Include luks_devs values in case a
                 # passphrase has been set for a specific device without a full
                 # reset/populate, in which case the new passphrase would not be
                 # in self.__passphrases.
-                for passphrase in self.__passphrases + list(self.__luksDevs.values()):
+                for passphrase in self.__passphrases + list(self.__luks_devs.values()):
                     device.format.passphrase = passphrase
                     try:
                         device.format.setup()
@@ -848,31 +848,31 @@ def handleUdevLUKSFormat(self, info, device):
                     else:
                         break
 
-            luks_device = LUKSDevice(device.format.mapName,
+            luks_device = LUKSDevice(device.format.map_name,
                                      parents=[device],
                                      exists=True)
             try:
                 luks_device.setup()
             except (LUKSError, blockdev.CryptoError, DeviceError) as e:
-                log.info("setup of %s failed: %s", device.format.mapName, e)
-                device.removeChild()
+                log.info("setup of %s failed: %s", device.format.map_name, e)
+                device.remove_child()
             else:
-                luks_device.updateSysfsPath()
-                self.devicetree._addDevice(luks_device)
-                luks_info = udev.get_device(luks_device.sysfsPath)
+                luks_device.update_sysfs_path()
+                self.devicetree._add_device(luks_device)
+                luks_info = udev.get_device(luks_device.sysfs_path)
                 if not luks_info:
                     log.error("failed to get udev data for %s", luks_device.name)
                     return
 
-                self.addUdevDevice(luks_info, updateOrigFmt=True)
+                self.add_udev_device(luks_info, update_orig_fmt=True)
         else:
             log.warning("luks device %s already in the tree",
-                        device.format.mapName)
+                        device.format.map_name)
 
-    def handleVgLvs(self, vg_device):
+    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.lvInfo.items())
+        lv_info = dict((k, v) for (k, v) in iter(self.devicetree.lv_info.items())
                                 if v.vg_name == vg_name)
 
         self.names.extend(n for n in lv_info.keys() if n not in self.names)
@@ -888,7 +888,7 @@ def handleVgLvs(self, vg_device):
         all_lvs = []
         internal_lvs = []
 
-        def addRequiredLV(name, msg):
+        def add_required_lv(name, msg):
             """ Add a prerequisite/parent LV.
 
                 The parent is strictly required in order to be able to add
@@ -902,18 +902,18 @@ def addRequiredLV(name, msg):
                 :raises: :class:`~.errors.DeviceTreeError` on failure
 
             """
-            vol = self.getDeviceByName(name)
+            vol = self.get_device_by_name(name)
             if vol is None:
-                new_lv = addLV(lv_info[name])
+                new_lv = add_lv(lv_info[name])
                 if new_lv:
                     all_lvs.append(new_lv)
-                vol = self.getDeviceByName(name)
+                vol = self.get_device_by_name(name)
 
                 if vol is None:
                     log.error("%s: %s", msg, name)
                     raise DeviceTreeError(msg)
 
-        def addLV(lv):
+        def add_lv(lv):
             """ Instantiate and add an LV based on data from the VG. """
             lv_name = lv.lv_name
             lv_uuid = lv.uuid
@@ -926,7 +926,7 @@ def addLV(lv):
             lv_kwargs = {}
             name = "%s-%s" % (vg_name, lv_name)
 
-            if self.getDeviceByName(name):
+            if self.get_device_by_name(name):
                 # some lvs may have been added on demand below
                 log.debug("already added %s", name)
                 return
@@ -944,9 +944,9 @@ def addLV(lv):
                     origin = None
                 else:
                     origin_device_name = "%s-%s" % (vg_name, origin_name)
-                    addRequiredLV(origin_device_name,
+                    add_required_lv(origin_device_name,
                                   "failed to locate origin lv")
-                    origin = self.getDeviceByName(origin_device_name)
+                    origin = self.get_device_by_name(origin_device_name)
 
                 lv_kwargs["origin"] = origin
                 lv_class = LVMSnapShotDevice
@@ -966,19 +966,19 @@ def addLV(lv):
                 # thin volume
                 pool_name = blockdev.lvm.thlvpoolname(vg_name, lv_name)
                 pool_device_name = "%s-%s" % (vg_name, pool_name)
-                addRequiredLV(pool_device_name, "failed to look up thin pool")
+                add_required_lv(pool_device_name, "failed to look up thin pool")
 
                 origin_name = blockdev.lvm.lvorigin(vg_name, lv_name)
                 if origin_name:
                     origin_device_name = "%s-%s" % (vg_name, origin_name)
-                    addRequiredLV(origin_device_name, "failed to locate origin lv")
-                    origin = self.getDeviceByName(origin_device_name)
+                    add_required_lv(origin_device_name, "failed to locate origin lv")
+                    origin = self.get_device_by_name(origin_device_name)
                     lv_kwargs["origin"] = origin
                     lv_class = LVMThinSnapShotDevice
                 else:
                     lv_class = LVMThinLogicalVolumeDevice
 
-                lv_parents = [self.getDeviceByName(pool_device_name)]
+                lv_parents = [self.get_device_by_name(pool_device_name)]
             elif lv_name.endswith(']'):
                 # unrecognized Internal LVM2 device
                 return
@@ -994,31 +994,31 @@ def addLV(lv):
                 #   C cached LV
                 return
 
-            lv_dev = self.getDeviceByUuid(lv_uuid)
+            lv_dev = self.get_device_by_uuid(lv_uuid)
             if lv_dev is None:
                 lv_device = lv_class(lv_name, parents=lv_parents,
-                                     uuid=lv_uuid, size=lv_size,segType=lv_type,
+                                     uuid=lv_uuid, size=lv_size,seg_type=lv_type,
                                      exists=True, **lv_kwargs)
-                self.devicetree._addDevice(lv_device)
+                self.devicetree._add_device(lv_device)
                 if flags.installer_mode:
                     lv_device.setup()
 
                 if lv_device.status:
-                    lv_device.updateSysfsPath()
-                    lv_device.updateSize()
-                    lv_info = udev.get_device(lv_device.sysfsPath)
+                    lv_device.update_sysfs_path()
+                    lv_device.update_size()
+                    lv_info = udev.get_device(lv_device.sysfs_path)
                     if not lv_info:
                         log.error("failed to get udev data for lv %s", lv_device.name)
                         return lv_device
 
                     # do format handling now
-                    self.addUdevDevice(lv_info, updateOrigFmt=True)
+                    self.add_udev_device(lv_info, update_orig_fmt=True)
 
                 return lv_device
 
             return None
 
-        def createInternalLV(lv):
+        def create_internal_lv(lv):
             lv_name = lv.lv_name
             lv_uuid = lv.uuid
             lv_attr = lv.attr
@@ -1033,12 +1033,12 @@ def createInternalLV(lv):
             lv_name = lv_name.strip("[]")
 
             # don't know the parent LV yet, will be set later
-            new_lv = matching_cls(lv_name, vg_device, parent_lv=None, size=lv_size, uuid=lv_uuid, exists=True, segType=lv_type)
+            new_lv = matching_cls(lv_name, vg_device, parent_lv=None, size=lv_size, uuid=lv_uuid, exists=True, seg_type=lv_type)
             if new_lv.status:
-                new_lv.updateSysfsPath()
-                new_lv.updateSize()
+                new_lv.update_sysfs_path()
+                new_lv.update_size()
 
-                lv_info = udev.get_device(new_lv.sysfsPath)
+                lv_info = udev.get_device(new_lv.sysfs_path)
                 if not lv_info:
                     log.error("failed to get udev data for lv %s", new_lv.name)
                     return new_lv
@@ -1048,7 +1048,7 @@ def createInternalLV(lv):
         # add LVs
         for lv in lv_info.values():
             # add the LV to the DeviceTree
-            new_lv = addLV(lv)
+            new_lv = add_lv(lv)
 
             if new_lv:
                 # save the reference for later use
@@ -1066,7 +1066,7 @@ def createInternalLV(lv):
         for lv_name in internal_lvs:
             full_name = "%s-%s" % (vg_name, lv_name)
             try:
-                new_lv = createInternalLV(lv_info[full_name])
+                new_lv = create_internal_lv(lv_info[full_name])
             except DeviceTreeError as e:
                 log.warning("Failed to process an internal LV '%s': %s", full_name, e)
             else:
@@ -1082,10 +1082,10 @@ def createInternalLV(lv):
             else:
                 log.warning("Failed to determine parent LV for an internal LV '%s'", lv.name)
 
-    def handleUdevLVMPVFormat(self, info, device):
+    def handle_udev_lvm_pv_format(self, info, device):
         # pylint: disable=unused-argument
         log_method_call(self, name=device.name, type=device.format.type)
-        pv_info = self.devicetree.pvInfo.get(device.path, None)
+        pv_info = self.devicetree.pv_info.get(device.path, None)
         if pv_info:
             vg_name = pv_info.vg_name
             vg_uuid = pv_info.vg_uuid
@@ -1097,11 +1097,11 @@ def handleUdevLVMPVFormat(self, info, device):
             log.info("lvm pv %s has no vg", device.name)
             return
 
-        vg_device = self.getDeviceByUuid(vg_uuid, incomplete=True)
+        vg_device = self.get_device_by_uuid(vg_uuid, incomplete=True)
         if vg_device:
             vg_device.parents.append(device)
         else:
-            same_name = self.getDeviceByName(vg_name)
+            same_name = self.get_device_by_name(vg_name)
             if isinstance(same_name, LVMVolumeGroupDevice):
                 raise DuplicateVGError("multiple LVM volume groups with the same name (%s)" % vg_name)
 
@@ -1121,24 +1121,24 @@ def handleUdevLVMPVFormat(self, info, device):
                                              uuid=vg_uuid,
                                              size=vg_size,
                                              free=vg_free,
-                                             peSize=pe_size,
-                                             peCount=pe_count,
-                                             peFree=pe_free,
-                                             pvCount=pv_count,
+                                             pe_size=pe_size,
+                                             pe_count=pe_count,
+                                             pe_free=pe_free,
+                                             pv_count=pv_count,
                                              exists=True)
-            self.devicetree._addDevice(vg_device)
+            self.devicetree._add_device(vg_device)
 
-        self.handleVgLvs(vg_device)
+        self.handle_vg_lvs(vg_device)
 
-    def handleUdevMDMemberFormat(self, info, device):
+    def handle_udev_md_member_format(self, info, device):
         # pylint: disable=unused-argument
         log_method_call(self, name=device.name, type=device.format.type)
         md_info = blockdev.md.examine(device.path)
 
         # Use mdadm info if udev info is missing
         md_uuid = md_info.uuid
-        device.format.mdUuid = device.format.mdUuid or md_uuid
-        md_array = self.getDeviceByUuid(device.format.mdUuid, incomplete=True)
+        device.format.md_uuid = device.format.md_uuid or md_uuid
+        md_array = self.get_device_by_uuid(device.format.md_uuid, incomplete=True)
 
         if md_array:
             md_array.parents.append(device)
@@ -1180,13 +1180,13 @@ def handleUdevMDMemberFormat(self, info, device):
 
             md_path = md_info.device or ""
             if md_path and not md_name:
-                md_name = devicePathToName(md_path)
+                md_name = device_path_to_name(md_path)
                 if re.match(r'md\d+$', md_name):
                     # md0 -> 0
                     md_name = md_name[2:]
 
                 if md_name:
-                    array = self.getDeviceByName(md_name, incomplete=True)
+                    array = self.get_device_by_name(md_name, incomplete=True)
                     if array and array.uuid != md_uuid:
                         log.error("found multiple devices with the name %s", md_name)
 
@@ -1199,7 +1199,7 @@ def handleUdevMDMemberFormat(self, info, device):
 
             array_type = MDRaidArrayDevice
             try:
-                if raid.getRaidLevel(md_level) is raid.Container and \
+                if raid.get_raid_level(md_level) is raid.Container and \
                    getattr(device.format, "biosraid", False):
                     array_type = MDContainerDevice
             except raid.RaidError as e:
@@ -1210,27 +1210,27 @@ def handleUdevMDMemberFormat(self, info, device):
                 md_array = array_type(
                    md_name,
                    level=md_level,
-                   memberDevices=md_devices,
+                   member_devices=md_devices,
                    uuid=md_uuid,
-                   metadataVersion=md_metadata,
+                   metadata_version=md_metadata,
                    exists=True
                 )
             except (ValueError, DeviceError) as e:
                 log.error("failed to create md array: %s", e)
                 return
 
-            md_array.updateSysfsPath()
+            md_array.update_sysfs_path()
             md_array.parents.append(device)
-            self.devicetree._addDevice(md_array)
+            self.devicetree._add_device(md_array)
             if md_array.status:
-                array_info = udev.get_device(md_array.sysfsPath)
+                array_info = udev.get_device(md_array.sysfs_path)
                 if not array_info:
                     log.error("failed to get udev data for %s", md_array.name)
                     return
 
-                self.addUdevDevice(array_info, updateOrigFmt=True)
+                self.add_udev_device(array_info, update_orig_fmt=True)
 
-    def handleUdevDMRaidMemberFormat(self, info, device):
+    def handle_udev_dmraid_member_format(self, info, device):
         # if dmraid usage is disabled skip any dmraid set activation
         if not flags.dmraid:
             return
@@ -1249,7 +1249,7 @@ def handleUdevDMRaidMemberFormat(self, info, device):
             return
 
         for rs_name in rs_names:
-            dm_array = self.getDeviceByName(rs_name, incomplete=True)
+            dm_array = self.get_device_by_name(rs_name, incomplete=True)
             if dm_array is not None:
                 # We add the new device.
                 dm_array.parents.append(device)
@@ -1259,7 +1259,7 @@ def handleUdevDMRaidMemberFormat(self, info, device):
                 dm_array = DMRaidArrayDevice(rs_name,
                                              parents=[device])
 
-                self.devicetree._addDevice(dm_array)
+                self.devicetree._add_device(dm_array)
 
                 # Wait for udev to scan the just created nodes, to avoid a race
                 # with the udev.get_device() call below.
@@ -1267,9 +1267,9 @@ def handleUdevDMRaidMemberFormat(self, info, device):
 
                 # Get the DMRaidArrayDevice a DiskLabel format *now*, in case
                 # its partitions get scanned before it does.
-                dm_array.updateSysfsPath()
-                dm_array_info = udev.get_device(dm_array.sysfsPath)
-                self.handleUdevDiskLabelFormat(dm_array_info, dm_array)
+                dm_array.update_sysfs_path()
+                dm_array_info = udev.get_device(dm_array.sysfs_path)
+                self.handle_udev_disk_label_format(dm_array_info, dm_array)
 
                 # Use the rs's object on the device.
                 # pyblock can return the memebers of a set and the
@@ -1279,7 +1279,7 @@ def handleUdevDMRaidMemberFormat(self, info, device):
                 #device.format.raidmem = block.getMemFromRaidSet(dm_array,
                 #        major=major, minor=minor, uuid=uuid, name=name)
 
-    def handleBTRFSFormat(self, info, device):
+    def handle_btrfs_format(self, info, device):
         log_method_call(self, name=device.name)
         uuid = udev.device_get_uuid(info)
 
@@ -1297,12 +1297,12 @@ def handleBTRFSFormat(self, info, device):
             log.info("creating btrfs volume btrfs.%s", label)
             btrfs_dev = BTRFSVolumeDevice(label, parents=[device], uuid=uuid,
                                           exists=True)
-            self.devicetree._addDevice(btrfs_dev)
+            self.devicetree._add_device(btrfs_dev)
 
         if not btrfs_dev.subvolumes:
-            snapshots = btrfs_dev.listSubVolumes(snapshotsOnly=True)
+            snapshots = btrfs_dev.list_subvolumes(snapshots_only=True)
             snapshot_ids = [s.id for s in snapshots]
-            for subvol_dict in btrfs_dev.listSubVolumes():
+            for subvol_dict in btrfs_dev.list_subvolumes():
                 vol_id = subvol_dict.id
                 vol_path = subvol_dict.path
                 parent_id = subvol_dict.parent_id
@@ -1322,10 +1322,10 @@ def handleBTRFSFormat(self, info, device):
                               parent_id, vol_path)
                     raise DeviceTreeError("could not find parent for subvol")
 
-                fmt = formats.getFormat("btrfs",
+                fmt = formats.get_format("btrfs",
                                         device=btrfs_dev.path,
                                         exists=True,
-                                        volUUID=btrfs_dev.format.volUUID,
+                                        vol_uuid=btrfs_dev.format.vol_uuid,
                                         subvolspec=vol_path,
                                         mountopts="subvol=%s" % vol_path)
                 if vol_id in snapshot_ids:
@@ -1338,15 +1338,15 @@ def handleBTRFSFormat(self, info, device):
                                       fmt=fmt,
                                       parents=[parent],
                                       exists=True)
-                self.devicetree._addDevice(subvol)
+                self.devicetree._add_device(subvol)
 
-    def handleUdevDeviceFormat(self, info, device):
+    def handle_udev_device_format(self, info, device):
         log_method_call(self, name=getattr(device, "name", None))
 
         if not info:
             log.debug("no information for device %s", device.name)
             return
-        if not device.mediaPresent:
+        if not device.media_present:
             log.debug("no media present for device %s", device.name)
             return
 
@@ -1356,7 +1356,7 @@ def handleUdevDeviceFormat(self, info, device):
         format_type = udev.device_get_format(info)
         serial = udev.device_get_serial(info)
 
-        is_multipath_member = (device.isDisk and
+        is_multipath_member = (device.is_disk and
                                blockdev.mpath_is_mpath_member(device.path))
         if is_multipath_member:
             format_type = "multipath_member"
@@ -1367,8 +1367,8 @@ def handleUdevDeviceFormat(self, info, device):
         if not udev.device_is_biosraid_member(info) and \
            not is_multipath_member and \
            format_type != "iso9660":
-            self.handleUdevDiskLabelFormat(info, device)
-            if device.partitioned or self.isIgnored(info) or \
+            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"):
                 # If the device has a disklabel, or the user chose not to
@@ -1395,7 +1395,7 @@ def handleUdevDeviceFormat(self, info, device):
         if format_type == "crypto_LUKS":
             # luks/dmcrypt
             kwargs["name"] = "luks-%s" % uuid
-        elif format_type in formats.mdraid.MDRaidMember._udevTypes:
+        elif format_type in formats.mdraid.MDRaidMember._udev_types:
             # mdraid
             try:
                 # ID_FS_UUID contains the array UUID
@@ -1410,7 +1410,7 @@ def handleUdevDeviceFormat(self, info, device):
             kwargs["biosraid"] = udev.device_is_biosraid_member(info)
         elif format_type == "LVM2_member":
             # lvm
-            pv_info = self.devicetree.pvInfo.get(device.path, None)
+            pv_info = self.devicetree.pv_info.get(device.path, None)
             if pv_info:
                 if pv_info.vg_name:
                     kwargs["vgName"] = pv_info.vg_name
@@ -1427,24 +1427,24 @@ def handleUdevDeviceFormat(self, info, device):
         elif format_type == "vfat":
             # efi magic
             if isinstance(device, PartitionDevice) and device.bootable:
-                efi = formats.getFormat("efi")
-                if efi.minSize <= device.size <= efi.maxSize:
+                efi = formats.get_format("efi")
+                if efi.min_size <= device.size <= efi.max_size:
                     format_designator = "efi"
         elif format_type == "hfsplus":
             if isinstance(device, PartitionDevice):
-                macefi = formats.getFormat("macefi")
-                if macefi.minSize <= device.size <= macefi.maxSize and \
-                   device.partedPartition.name == macefi.name:
+                macefi = formats.get_format("macefi")
+                if macefi.min_size <= device.size <= macefi.max_size and \
+                   device.parted_partition.name == macefi.name:
                     format_designator = "macefi"
         elif format_type == "hfs":
             # apple bootstrap magic
             if isinstance(device, PartitionDevice) and device.bootable:
-                apple = formats.getFormat("appleboot")
-                if apple.minSize <= device.size <= apple.maxSize:
+                apple = formats.get_format("appleboot")
+                if apple.min_size <= device.size <= apple.max_size:
                     format_designator = "appleboot"
         elif format_type == "btrfs":
             # the format's uuid attr will contain the UUID_SUB, while the
-            # overarching volume UUID will be stored as volUUID
+            # overarching volume UUID will be stored as vol_uuid
             kwargs["uuid"] = info["ID_FS_UUID_SUB"]
             kwargs["volUUID"] = uuid
         elif format_type == "multipath_member":
@@ -1456,7 +1456,7 @@ def handleUdevDeviceFormat(self, info, device):
 
         try:
             log.info("type detected on '%s' is '%s'", name, format_designator)
-            device.format = formats.getFormat(format_designator, **kwargs)
+            device.format = formats.get_format(format_designator, **kwargs)
             if device.format.type:
                 log.info("got format: %s", device.format)
         except FSError:
@@ -1469,29 +1469,29 @@ def handleUdevDeviceFormat(self, info, device):
         # now do any special handling required for the device's format
         #
         if device.format.type == "luks":
-            self.handleUdevLUKSFormat(info, device)
+            self.handle_udev_luks_format(info, device)
         elif device.format.type == "mdmember":
-            self.handleUdevMDMemberFormat(info, device)
+            self.handle_udev_md_member_format(info, device)
         elif device.format.type == "dmraidmember":
-            self.handleUdevDMRaidMemberFormat(info, device)
+            self.handle_udev_dmraid_member_format(info, device)
         elif device.format.type == "lvmpv":
-            self.handleUdevLVMPVFormat(info, device)
+            self.handle_udev_lvm_pv_format(info, device)
         elif device.format.type == "btrfs":
-            self.handleBTRFSFormat(info, device)
+            self.handle_btrfs_format(info, device)
 
-    def updateDeviceFormat(self, device):
+    def update_device_format(self, device):
         log.info("updating format of device: %s", device)
         try:
-            util.notify_kernel(device.sysfsPath)
+            util.notify_kernel(device.sysfs_path)
         except (ValueError, IOError) as e:
             log.warning("failed to notify kernel of change: %s", e)
 
         udev.settle()
-        info = udev.get_device(device.sysfsPath)
+        info = udev.get_device(device.sysfs_path)
 
-        self.handleUdevDeviceFormat(info, device)
+        self.handle_udev_device_format(info, device)
 
-    def _handleInconsistencies(self):
+    def _handle_inconsistencies(self):
         for vg in [d for d in self.devicetree.devices if d.type == "lvmvg"]:
             if vg.complete:
                 continue
@@ -1502,11 +1502,11 @@ def _handleInconsistencies(self):
             for pv in vg.pvs:
                 lvm.lvm_cc_addFilterRejectRegexp(pv.name)
 
-    def setupDiskImages(self):
+    def setup_disk_images(self):
         """ Set up devices to represent the disk image files. """
-        for (name, path) in self.diskImages.items():
+        for (name, path) in self.disk_images.items():
             log.info("setting up disk image file '%s' as '%s'", path, name)
-            dmdev = self.getDeviceByName(name)
+            dmdev = self.get_device_by_name(name)
             if dmdev and isinstance(dmdev, DMLinearDevice) and \
                path in (d.path for d in dmdev.ancestors):
                 log.debug("using %s", dmdev)
@@ -1524,30 +1524,30 @@ def setupDiskImages(self):
                     loop_sysfs = "/class/block/%s" % loop_name
                 loopdev = LoopDevice(name=loop_name,
                                      parents=[filedev],
-                                     sysfsPath=loop_sysfs,
+                                     sysfs_path=loop_sysfs,
                                      exists=True)
                 loopdev.setup()
                 log.debug("%s", loopdev)
                 dmdev = DMLinearDevice(name,
-                                       dmUuid="ANACONDA-%s" % name,
+                                       dm_uuid="ANACONDA-%s" % name,
                                        parents=[loopdev],
                                        exists=True)
                 dmdev.setup()
-                dmdev.updateSysfsPath()
+                dmdev.update_sysfs_path()
                 log.debug("%s", dmdev)
             except (ValueError, DeviceError) as e:
                 log.error("failed to set up disk image: %s", e)
             else:
-                self.devicetree._addDevice(filedev)
-                self.devicetree._addDevice(loopdev)
-                self.devicetree._addDevice(dmdev)
-                info = udev.get_device(dmdev.sysfsPath)
-                self.addUdevDevice(info, updateOrigFmt=True)
+                self.devicetree._add_device(filedev)
+                self.devicetree._add_device(loopdev)
+                self.devicetree._add_device(dmdev)
+                info = udev.get_device(dmdev.sysfs_path)
+                self.add_udev_device(info, update_orig_fmt=True)
 
-    def teardownDiskImages(self):
+    def teardown_disk_images(self):
         """ Tear down any disk image stacks. """
-        for (name, _path) in self.diskImages.items():
-            dm_device = self.getDeviceByName(name)
+        for (name, _path) in self.disk_images.items():
+            dm_device = self.get_device_by_name(name)
             if not dm_device:
                 continue
 
@@ -1555,7 +1555,7 @@ def teardownDiskImages(self):
             loop_device = dm_device.parents[0]
             loop_device.teardown()
 
-    def backupConfigs(self, restore=False):
+    def backup_configs(self, restore=False):
         """ Create a backup copies of some storage config files. """
         configs = ["/etc/mdadm.conf"]
         for cfg in configs:
@@ -1596,18 +1596,18 @@ def backupConfigs(self, restore=False):
                 # don't try to backup non-existent configs
                 log.info("not going to %s of non-existent %s", op, cfg)
 
-    def restoreConfigs(self):
-        self.backupConfigs(restore=True)
+    def restore_configs(self):
+        self.backup_configs(restore=True)
 
-    def saveLUKSpassphrase(self, device):
+    def save_luks_passphrase(self, device):
         """ Save a device's LUKS passphrase in case of reset. """
 
         passphrase = device.format._LUKS__passphrase
         if passphrase:
-            self.__luksDevs[device.format.uuid] = passphrase
+            self.__luks_devs[device.format.uuid] = passphrase
             self.__passphrases.append(passphrase)
 
-    def populate(self, cleanupOnly=False):
+    def populate(self, cleanup_only=False):
         """ Locate all storage devices.
 
             Everything should already be active. We just go through and gather
@@ -1617,8 +1617,8 @@ def populate(self, cleanupOnly=False):
             scanned just the rest, but then they are hidden at the end of this
             process.
         """
-        self.backupConfigs()
-        if cleanupOnly:
+        self.backup_configs()
+        if cleanup_only:
             self._cleanup = True
 
         parted.register_exn_handler(parted_exn_handler)
@@ -1628,29 +1628,29 @@ def populate(self, cleanupOnly=False):
             raise
         finally:
             parted.clear_exn_handler()
-            self.restoreConfigs()
+            self.restore_configs()
 
     def _populate(self):
-        log.info("DeviceTree.populate: ignoredDisks is %s ; exclusiveDisks is %s",
-                    self.ignoredDisks, self.exclusiveDisks)
+        log.info("DeviceTree.populate: ignored_disks is %s ; exclusive_disks is %s",
+                    self.ignored_disks, self.exclusive_disks)
 
-        self.devicetree.dropLVMCache()
+        self.devicetree.drop_lvm_cache()
 
         if flags.installer_mode and not flags.image_install:
             blockdev.mpath.set_friendly_names(flags.multipath_friendly_names)
 
-        self.setupDiskImages()
+        self.setup_disk_images()
 
         # mark the tree as unpopulated so exception handlers can tell the
         # exception originated while finding storage devices
         self.populated = False
 
         # resolve the protected device specs to device names
-        for spec in self.protectedDevSpecs:
+        for spec in self.protected_dev_specs:
             name = udev.resolve_devspec(spec)
             log.debug("protected device spec %s resolved to %s", spec, name)
             if name:
-                self.protectedDevNames.append(name)
+                self.protected_dev_names.append(name)
 
         # FIXME: the backing dev for the live image can't be used as an
         # install target.  note that this is a little bit of a hack
@@ -1662,8 +1662,8 @@ def _populate(self):
             live_device_name = mnt.split()[0].split("/")[-1]
             log.info("%s looks to be the live device; marking as protected",
                      live_device_name)
-            self.protectedDevNames.append(live_device_name)
-            self.liveBackingDevice = live_device_name
+            self.protected_dev_names.append(live_device_name)
+            self.live_backing_device = live_device_name
             break
 
         old_devices = {}
@@ -1686,20 +1686,20 @@ def _populate(self):
 
             log.info("devices to scan: %s", [udev.device_get_name(d) for d in devices])
             for dev in devices:
-                self.addUdevDevice(dev)
+                self.add_udev_device(dev)
 
         self.populated = True
 
         # After having the complete tree we make sure that the system
         # inconsistencies are ignored or resolved.
-        self._handleInconsistencies()
+        self._handle_inconsistencies()
 
     @property
     def names(self):
         return self.devicetree.names
 
-    def getDeviceByName(self, *args, **kwargs):
-        return self.devicetree.getDeviceByName(*args, **kwargs)
+    def get_device_by_name(self, *args, **kwargs):
+        return self.devicetree.get_device_by_name(*args, **kwargs)
 
-    def getDeviceByUuid(self, *args, **kwargs):
-        return self.devicetree.getDeviceByUuid(*args, **kwargs)
+    def get_device_by_uuid(self, *args, **kwargs):
+        return self.devicetree.get_device_by_uuid(*args, **kwargs)
diff --git a/blivet/size.py b/blivet/size.py
index ba66dc2..303f38e 100644
--- a/blivet/size.py
+++ b/blivet/size.py
@@ -76,7 +76,7 @@
 else:
     _ASCIIlower_table = str.maketrans(string.ascii_uppercase, string.ascii_lowercase) # pylint: disable=no-member
 
-def _lowerASCII(s):
+def _lower_ascii(s):
     """Convert a string to lowercase using only ASCII character definitions.
 
        :param s: string instance to convert
@@ -92,7 +92,7 @@ def _lowerASCII(s):
         s = s.decode(sys.getdefaultencoding())
     return s.translate(_ASCIIlower_table) # pylint: disable=no-member
 
-def _makeSpec(prefix, suffix, xlate, lowercase=True):
+def _make_spec(prefix, suffix, xlate, lowercase=True):
     """ Synthesizes a whole word from prefix and suffix.
 
         :param str prefix: a prefix
@@ -108,9 +108,9 @@ def _makeSpec(prefix, suffix, xlate, lowercase=True):
         return word.lower() if lowercase else word
     else:
         word = prefix + suffix
-        return _lowerASCII(word) if lowercase else word
+        return _lower_ascii(word) if lowercase else word
 
-def unitStr(unit, xlate=False):
+def unit_str(unit, xlate=False):
     """ Return a string representation of unit.
 
         :param unit: a named unit, e.g., KiB
@@ -118,9 +118,9 @@ def unitStr(unit, xlate=False):
         :rtype: some kind of string type
         :returns: string representation of unit
     """
-    return _makeSpec(unit.abbr, _BYTES_SYMBOL, xlate, lowercase=False)
+    return _make_spec(unit.abbr, _BYTES_SYMBOL, xlate, lowercase=False)
 
-def parseUnits(spec, xlate):
+def parse_units(spec, xlate):
     """ Parse a unit specification and return corresponding factor.
 
         :param spec: a units specifier
@@ -141,22 +141,22 @@ def parseUnits(spec, xlate):
     if xlate:
         spec = spec.lower()
     else:
-        spec = _lowerASCII(spec)
+        spec = _lower_ascii(spec)
 
     # Search for complete matches
     for unit in [_EMPTY_PREFIX] + _BINARY_PREFIXES + _DECIMAL_PREFIXES:
-        if spec == _makeSpec(unit.abbr, _BYTES_SYMBOL, xlate) or \
-           spec in (_makeSpec(unit.prefix, s, xlate) for s in _BYTES_WORDS):
+        if spec == _make_spec(unit.abbr, _BYTES_SYMBOL, xlate) or \
+           spec in (_make_spec(unit.prefix, s, xlate) for s in _BYTES_WORDS):
             return unit
 
     # Search for unambiguous partial match among binary abbreviations
-    matches = [p for p in _BINARY_PREFIXES if _makeSpec(p.abbr, "", xlate).startswith(spec)]
+    matches = [p for p in _BINARY_PREFIXES if _make_spec(p.abbr, "", xlate).startswith(spec)]
     if len(matches) == 1:
         return matches[0]
 
     return None
 
-def parseSpec(spec):
+def parse_spec(spec):
     """ Parse string representation of size.
 
         :param spec: the specification of a size with, optionally, units
@@ -221,7 +221,7 @@ def parseSpec(spec):
         # String contains non-ascii characters, so can not be English.
         pass
     else:
-        unit = parseUnits(spec_ascii, False)
+        unit = parse_units(spec_ascii, False)
         if unit is not None:
             return size * unit.factor
 
@@ -235,7 +235,7 @@ def parseSpec(spec):
     else:
         spec_local = specifier
 
-    unit = parseUnits(spec_local, True)
+    unit = parse_units(spec_local, True)
     if unit is not None:
         return size * unit.factor
 
@@ -268,11 +268,11 @@ def __new__(cls, value=0, context=None):
             you can use the letter 'b' or 'B' or omit the size specifier.
         """
         if isinstance(value, (six.string_types, bytes)):
-            size = parseSpec(value)
+            size = parse_spec(value)
         elif isinstance(value, (six.integer_types, float, Decimal)):
             size = Decimal(value)
         elif isinstance(value, Size):
-            size = Decimal(value.convertTo())
+            size = Decimal(value.convert_to())
         else:
             raise ValueError("invalid value %s for size" % value)
 
@@ -282,25 +282,25 @@ def __new__(cls, value=0, context=None):
         return self
 
     # Force str and unicode types since the translated sizespec may be unicode
-    def _toString(self):
-        return self.humanReadable()
+    def _to_string(self):
+        return self.human_readable()
 
     def __str__(self, eng=False, context=None):
-        return stringize(self._toString())
+        return stringize(self._to_string())
 
     def __unicode__(self):
-        return unicodeize(self._toString())
+        return unicodeize(self._to_string())
 
     def __repr__(self):
         return "Size('%s')" % self
 
     def __deepcopy__(self, memo):
-        return Size(self.convertTo())
+        return Size(self.convert_to())
 
     # pickling support for Size
     # see https://docs.python.org/3/library/pickle.html#object.__reduce__
     def __reduce__(self):
-        return (self.__class__, (self.convertTo(),))
+        return (self.__class__, (self.convert_to(),))
 
     def __add__(self, other, context=None):
         # because float is not automatically converted to Decimal type
@@ -342,7 +342,7 @@ def __floordiv__(self, other, context=None):
     def __mod__(self, other, context=None):
         return Size(Decimal.__mod__(self, other))
 
-    def convertTo(self, spec=None):
+    def convert_to(self, spec=None):
         """ Return the size in the units indicated by the specifier.
 
             :param spec: a units specifier
@@ -362,7 +362,7 @@ def convertTo(self, spec=None):
 
         return Decimal(self) / factor
 
-    def humanReadable(self, max_places=2, strip=True, min_value=1, xlate=True):
+    def human_readable(self, max_places=2, strip=True, min_value=1, xlate=True):
         """ Return a string representation of this size with appropriate
             size specifier and in the specified number of decimal places.
             Values are always represented using binary not decimal units.
@@ -393,10 +393,10 @@ def humanReadable(self, max_places=2, strip=True, min_value=1, xlate=True):
             If min_value is 0.1, then 0.75 GiB is preferred to 768 MiB,
             but 0.05 GiB is still displayed as 51.2 MiB.
 
-            humanReadable() is a function that evaluates to a number which
+            human_readable() is a function that evaluates to a number which
             represents a range of values. For a constant choice of max_places,
             all ranges are of equal size, and are bisected by the result. So,
-            if n.humanReadable() == x U and b is the number of bytes in 1 U,
+            if n.human_readable() == x U and b is the number of bytes in 1 U,
             and e = 1/2 * 1/(10^max_places) * b, then x - e < n < x + e.
         """
         if max_places is not None and (max_places < 0 or not isinstance(max_places, six.integer_types)):
@@ -411,7 +411,7 @@ def humanReadable(self, max_places=2, strip=True, min_value=1, xlate=True):
         # requirement use the largest prefix.
         limit = _BINARY_FACTOR * min_value
         for unit in [_EMPTY_PREFIX] + _BINARY_PREFIXES:
-            newcheck = self.convertTo(unit)
+            newcheck = self.convert_to(unit)
 
             if abs(newcheck) < limit:
                 break
@@ -430,9 +430,9 @@ def humanReadable(self, max_places=2, strip=True, min_value=1, xlate=True):
                 retval_str = retval_str.replace('.', radix)
 
         # pylint: disable=undefined-loop-variable
-        return retval_str + " " + _makeSpec(unit.abbr, _BYTES_SYMBOL, xlate, lowercase=False)
+        return retval_str + " " + _make_spec(unit.abbr, _BYTES_SYMBOL, xlate, lowercase=False)
 
-    def roundToNearest(self, unit, rounding=ROUND_DEFAULT):
+    def round_to_nearest(self, unit, rounding=ROUND_DEFAULT):
         """ Rounds to nearest unit specified as a named constant or a Size.
 
             :param unit: a unit specifier
diff --git a/blivet/tasks/availability.py b/blivet/tasks/availability.py
index 9682fc6..fe356d8 100644
--- a/blivet/tasks/availability.py
+++ b/blivet/tasks/availability.py
@@ -50,21 +50,21 @@ def __init__(self, method, name):
         """
         self._method = method
         self.name = name
-        self._availabilityErrors = None
+        self._availability_errors = None
 
     def __str__(self):
         return self.name
 
     @property
-    def availabilityErrors(self):
+    def availability_errors(self):
         """ Whether the resource has any availability errors.
 
             :returns: [] if the resource is available
             :rtype: list of str
         """
-        if self._availabilityErrors is None or not CACHE_AVAILABILITY:
-            self._availabilityErrors = self._method.availabilityErrors(self)
-        return self._availabilityErrors[:]
+        if self._availability_errors is None or not CACHE_AVAILABILITY:
+            self._availability_errors = self._method.availability_errors(self)
+        return self._availability_errors[:]
 
     @property
     def available(self):
@@ -73,14 +73,14 @@ def available(self):
             :returns: True if the resource is available
             :rtype: bool
         """
-        return self.availabilityErrors == []
+        return self.availability_errors == []
 
 @add_metaclass(abc.ABCMeta)
 class Method(object):
     """ Method for determining if external resource is available."""
 
     @abc.abstractmethod
-    def availabilityErrors(self, resource):
+    def availability_errors(self, resource):
         """ Returns [] if the resource is available.
 
             :param resource: any external resource
@@ -94,7 +94,7 @@ def availabilityErrors(self, resource):
 class Path(Method):
     """ Methods for when application is found in  PATH. """
 
-    def availabilityErrors(self, resource):
+    def availability_errors(self, resource):
         """ Returns [] if the name of the application is in the path.
 
             :param resource: any application
@@ -134,10 +134,10 @@ def __init__(self, package=None):
             :param :class:`PackageInfo` package:
         """
         self.package = package
-        self._availabilityErrors = None
+        self._availability_errors = None
 
     @property
-    def packageVersion(self):
+    def package_version(self):
         """ Returns the version of the installed package.
 
             :returns: the package version
@@ -161,29 +161,29 @@ def packageVersion(self):
 
         return LooseVersion(packages[0].version)
 
-    def availabilityErrors(self, resource):
-        if self._availabilityErrors is not None and CACHE_AVAILABILITY:
-            return self._availabilityErrors[:]
+    def availability_errors(self, resource):
+        if self._availability_errors is not None and CACHE_AVAILABILITY:
+            return self._availability_errors[:]
 
-        self._availabilityErrors = Path.availabilityErrors(resource)
+        self._availability_errors = Path.availability_errors(resource)
 
         if self.package.required_version is None:
-            return self._availabilityErrors[:]
+            return self._availability_errors[:]
 
         try:
-            if self.packageVersion < self.package.required_version:
-                self._availabilityErrors.append("installed version %s for package %s is less than required version %s" % (self.packageVersion, self.package.package_name, self.package.required_version))
+            if self.package_version < self.package.required_version:
+                self._availability_errors.append("installed version %s for package %s is less than required version %s" % (self.package_version, self.package.package_name, self.package.required_version))
         except AvailabilityError as e:
             # In contexts like the installer, a package may not be available,
             # but the version of the tools is likely to be correct.
             log.warning(str(e))
 
-        return self._availabilityErrors[:]
+        return self._availability_errors[:]
 
 class BlockDevMethod(Method):
     """ Methods for when application is actually a libblockdev plugin. """
 
-    def availabilityErrors(self, resource):
+    def availability_errors(self, resource):
         """ Returns [] if the plugin is loaded.
 
             :param resource: a libblockdev plugin
@@ -202,7 +202,7 @@ def availabilityErrors(self, resource):
 class UnavailableMethod(Method):
     """ Method that indicates a resource is unavailable. """
 
-    def availabilityErrors(self, resource):
+    def availability_errors(self, resource):
         return ["always unavailable"]
 
 UnavailableMethod = UnavailableMethod()
@@ -210,7 +210,7 @@ def availabilityErrors(self, resource):
 class AvailableMethod(Method):
     """ Method that indicates a resource is available. """
 
-    def availabilityErrors(self, resource):
+    def availability_errors(self, resource):
         return []
 
 AvailableMethod = AvailableMethod()
diff --git a/blivet/tasks/fsck.py b/blivet/tasks/fsck.py
index ec97c96..f3d1946 100644
--- a/blivet/tasks/fsck.py
+++ b/blivet/tasks/fsck.py
@@ -45,7 +45,7 @@ class FSCK(task.BasicApplication, fstask.FSTask):
     # IMPLEMENTATION methods
 
     @abc.abstractmethod
-    def _errorMessage(self, rc):
+    def _error_message(self, rc):
         """ Error message corresponding to rc.
 
             :param int rc: the fsck program return code
@@ -57,7 +57,7 @@ def _errorMessage(self, rc):
         raise NotImplementedError()
 
     @property
-    def _fsckCommand(self):
+    def _fsck_command(self):
         """The command to check the filesystem.
 
            :return: the command
@@ -65,21 +65,21 @@ def _fsckCommand(self):
         """
         return [str(self.ext)] + self.options + [self.fs.device]
 
-    def doTask(self):
+    def do_task(self):
         """ Check the filesystem.
 
            :raises FSError: on failure
         """
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         try:
-            rc = util.run_program(self._fsckCommand)
+            rc = util.run_program(self._fsck_command)
         except OSError as e:
             raise FSError("filesystem check failed: %s" % e)
 
-        error_msg = self._errorMessage(rc)
+        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}
@@ -88,24 +88,24 @@ def doTask(self):
 
 
 class DosFSCK(FSCK):
-    _fsckErrors = {1: "Recoverable errors have been detected or dosfsck has "
+    _fsck_errors = {1: "Recoverable errors have been detected or dosfsck has "
                       "discovered an internal inconsistency.",
                    2: "Usage error."}
 
     ext = availability.DOSFSCK_APP
     options = ["-n"]
 
-    def _errorMessage(self, rc):
+    def _error_message(self, rc):
         if rc < 1:
             return None
         try:
-            return self._fsckErrors[rc]
+            return self._fsck_errors[rc]
         except KeyError:
             return _UNKNOWN_RC_MSG % rc
 
 
 class Ext2FSCK(FSCK):
-    _fsckErrors = {4: "File system errors left uncorrected.",
+    _fsck_errors = {4: "File system errors left uncorrected.",
                    8: "Operational error.",
                    16: "Usage or syntax error.",
                    32: "e2fsck cancelled by user request.",
@@ -114,23 +114,23 @@ class Ext2FSCK(FSCK):
     ext = availability.E2FSCK_APP
     options = ["-f", "-p", "-C", "0"]
 
-    def _errorMessage(self, rc):
-        msgs = (self._fsckErrors[c] for c in self._fsckErrors.keys() if rc & c)
+    def _error_message(self, rc):
+        msgs = (self._fsck_errors[c] for c in self._fsck_errors.keys() if rc & c)
         return "\n".join(msgs) or None
 
 class HFSPlusFSCK(FSCK):
-    _fsckErrors = {3: "Quick check found a dirty filesystem; no repairs done.",
+    _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."}
     ext = availability.FSCK_HFSPLUS_APP
     options = []
 
-    def _errorMessage(self, rc):
+    def _error_message(self, rc):
         if rc < 1:
             return None
         try:
-            return self._fsckErrors[rc]
+            return self._fsck_errors[rc]
         except KeyError:
             return _UNKNOWN_RC_MSG % rc
 
@@ -138,7 +138,7 @@ class NTFSFSCK(FSCK):
     ext = availability.NTFSRESIZE_APP
     options = ["-c"]
 
-    def _errorMessage(self, rc):
+    def _error_message(self, rc):
         return _UNKNOWN_RC_MSG % (rc,) if rc != 0 else None
 
 class UnimplementedFSCK(fstask.UnimplementedFSTask):
diff --git a/blivet/tasks/fsinfo.py b/blivet/tasks/fsinfo.py
index 5962cb7..b89b726 100644
--- a/blivet/tasks/fsinfo.py
+++ b/blivet/tasks/fsinfo.py
@@ -40,7 +40,7 @@ class FSInfo(task.BasicApplication, fstask.FSTask):
        doc="Options for invoking the application.")
 
     @property
-    def _infoCommand(self):
+    def _info_command(self):
         """ Returns the command for reading filesystem information.
 
             :returns: a list of appropriate options
@@ -48,20 +48,20 @@ def _infoCommand(self):
         """
         return [str(self.ext)] + self.options + [self.fs.device]
 
-    def doTask(self):
+    def do_task(self):
         """ Returns information from the command.
 
             :returns: a string representing the output of the command
             :rtype: str
             :raises FSError: if info cannot be obtained
         """
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         error_msg = None
         try:
-            (rc, out) = util.run_program_and_capture_output(self._infoCommand)
+            (rc, out) = util.run_program_and_capture_output(self._info_command)
             if rc:
                 error_msg = "failed to gather fs info: %s" % rc
         except OSError as e:
diff --git a/blivet/tasks/fslabeling.py b/blivet/tasks/fslabeling.py
index 96894e8..ed6a8ad 100644
--- a/blivet/tasks/fslabeling.py
+++ b/blivet/tasks/fslabeling.py
@@ -32,7 +32,7 @@ class FSLabeling(object):
        doc="Default label set on this filesystem at creation.")
 
     @abc.abstractmethod
-    def labelFormatOK(self, label):
+    def label_format_ok(self, label):
         """Returns True if this label is correctly formatted for this
            filesystem, otherwise False.
 
@@ -46,7 +46,7 @@ class Ext2FSLabeling(FSLabeling):
     default_label = ""
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return len(label) < 17
 
 class FATFSLabeling(FSLabeling):
@@ -54,7 +54,7 @@ class FATFSLabeling(FSLabeling):
     default_label = "NO NAME"
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return len(label) < 12
 
 class JFSLabeling(FSLabeling):
@@ -62,7 +62,7 @@ class JFSLabeling(FSLabeling):
     default_label = ""
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return len(label) < 17
 
 class ReiserFSLabeling(FSLabeling):
@@ -70,7 +70,7 @@ class ReiserFSLabeling(FSLabeling):
     default_label = ""
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return len(label) < 17
 
 class XFSLabeling(FSLabeling):
@@ -78,7 +78,7 @@ class XFSLabeling(FSLabeling):
     default_label = ""
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return ' ' not in label and len(label) < 13
 
 class HFSLabeling(FSLabeling):
@@ -86,7 +86,7 @@ class HFSLabeling(FSLabeling):
     default_label = "Untitled"
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return ':' not in label and len(label) < 28 and len(label) > 0
 
 class HFSPlusLabeling(FSLabeling):
@@ -94,7 +94,7 @@ class HFSPlusLabeling(FSLabeling):
     default_label = "Untitled"
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return ':' not in label and 0 < len(label) < 129
 
 class NTFSLabeling(FSLabeling):
@@ -102,5 +102,5 @@ class NTFSLabeling(FSLabeling):
     default_label = ""
 
     @classmethod
-    def labelFormatOK(cls, label):
+    def label_format_ok(cls, label):
         return len(label) < 129
diff --git a/blivet/tasks/fsminsize.py b/blivet/tasks/fsminsize.py
index 8a64611..3028764 100644
--- a/blivet/tasks/fsminsize.py
+++ b/blivet/tasks/fsminsize.py
@@ -39,10 +39,10 @@ class FSMinSize(task.BasicApplication, fstask.FSTask):
 
     options = abc.abstractproperty(doc="Options for use with app.")
 
-    def _resizeCommand(self):
+    def _resize_command(self):
         return [str(self.ext)] + self.options + [self.fs.device]
 
-    def _getResizeInfo(self):
+    def _get_resize_info(self):
         """ Get info from fsresize program.
 
             :rtype: str
@@ -50,7 +50,7 @@ def _getResizeInfo(self):
         """
         error_msg = None
         try:
-            (rc, out) = util.run_program_and_capture_output(self._resizeCommand())
+            (rc, out) = util.run_program_and_capture_output(self._resize_command())
             if rc:
                 error_msg = "failed to gather info from resize program: %d" % rc
         except OSError as e:
@@ -61,7 +61,7 @@ def _getResizeInfo(self):
         return out
 
     @abc.abstractmethod
-    def doTask(self):
+    def do_task(self):
         """ Returns the minimum size for this filesystem object.
 
             :rtype: :class:`~.size.Size`
@@ -76,10 +76,10 @@ class Ext2FSMinSize(FSMinSize):
     options = ["-P"]
 
     @property
-    def dependsOn(self):
+    def depends_on(self):
         return [self.fs._info]
 
-    def _extractBlockSize(self):
+    def _extract_block_size(self):
         """ Extract block size from filesystem info.
 
             :returns: block size of fileystem or None
@@ -88,88 +88,88 @@ def _extractBlockSize(self):
         if self.fs._current_info is None:
             return None
 
-        blockSize = None
+        block_size = None
         for line in (l.strip() for l in self.fs._current_info.splitlines() if l.startswith("Block size:")):
             try:
-                blockSize = int(line.split(" ")[-1])
+                block_size = int(line.split(" ")[-1])
                 break
             except ValueError:
                 continue
 
-        return Size(blockSize) if blockSize else None
+        return Size(block_size) if block_size else None
 
-    def _extractNumBlocks(self, info):
+    def _extract_num_blocks(self, info):
         """ Extract the number of blocks from the resizefs info.
 
            :returns: the number of blocks or None
            :rtype: int or NoneType
         """
-        numBlocks = None
+        num_blocks = None
         for line in info.splitlines():
             (text, _sep, value) = line.partition(":")
             if "minimum size of the filesystem" not in text:
                 continue
 
             try:
-                numBlocks = int(value.strip())
+                num_blocks = int(value.strip())
                 break
             except ValueError:
                 break
 
-        return numBlocks
+        return num_blocks
 
-    def doTask(self):
-        error_msgs = self.availabilityErrors
+    def do_task(self):
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
-        blockSize = self._extractBlockSize()
-        if blockSize is None:
-            raise FSError("failed to get block size for %s filesystem on %s" % (self.fs.mountType, self.fs.device.name))
+        block_size = self._extract_block_size()
+        if block_size is None:
+            raise FSError("failed to get block size for %s filesystem on %s" % (self.fs.mount_type, self.fs.device.name))
 
-        resize_info = self._getResizeInfo()
-        numBlocks = self._extractNumBlocks(resize_info)
-        if numBlocks is None:
-            raise FSError("failed to get minimum block number for %s filesystem on %s" % (self.fs.mountType, self.fs.device.name))
+        resize_info = self._get_resize_info()
+        num_blocks = self._extract_num_blocks(resize_info)
+        if num_blocks is None:
+            raise FSError("failed to get minimum block number for %s filesystem on %s" % (self.fs.mount_type, self.fs.device.name))
 
-        return blockSize * numBlocks
+        return block_size * num_blocks
 
 class NTFSMinSize(FSMinSize):
 
     ext = availability.NTFSRESIZE_APP
     options = ["-m"]
 
-    def _extractMinSize(self, info):
+    def _extract_min_size(self, info):
         """ Extract the minimum size from the resizefs info.
 
             :param str info: info obtained from resizefs prog
             :rtype: :class:`~.size.Size` or NoneType
             :returns: the minimum size, or None
         """
-        minSize = None
+        min_size = None
         for line in info.splitlines():
             (text, _sep, value) = line.partition(":")
             if "Minsize" not in text:
                 continue
 
             try:
-                minSize = Size("%d MB" % int(value.strip()))
+                min_size = Size("%d MB" % int(value.strip()))
             except ValueError:
                 break
 
-        return minSize
+        return min_size
 
 
-    def doTask(self):
-        error_msgs = self.availabilityErrors
+    def do_task(self):
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
-        resize_info = self._getResizeInfo()
-        minSize = self._extractMinSize(resize_info)
-        if minSize is None:
+        resize_info = self._get_resize_info()
+        min_size = self._extract_min_size(resize_info)
+        if min_size is None:
             raise FSError("Unable to discover minimum size of filesystem on %s" % self.fs.device)
-        return minSize
+        return min_size
 
 class UnimplementedFSMinSize(fstask.UnimplementedFSTask):
     pass
diff --git a/blivet/tasks/fsmkfs.py b/blivet/tasks/fsmkfs.py
index 15138ae..2a281c1 100644
--- a/blivet/tasks/fsmkfs.py
+++ b/blivet/tasks/fsmkfs.py
@@ -34,7 +34,7 @@
 @add_metaclass(abc.ABCMeta)
 class FSMkfsTask(fstask.FSTask):
 
-    canLabel = abc.abstractproperty(doc="whether this task labels")
+    can_label = abc.abstractproperty(doc="whether this task labels")
 
 @add_metaclass(abc.ABCMeta)
 class FSMkfs(task.BasicApplication, FSMkfsTask):
@@ -49,7 +49,7 @@ class FSMkfs(task.BasicApplication, FSMkfsTask):
     # IMPLEMENTATION methods
 
     @property
-    def canLabel(self):
+    def can_label(self):
         """ Whether this task can label the filesystem.
 
             :returns: True if this task can label the filesystem
@@ -58,7 +58,7 @@ def canLabel(self):
         return self.label_option is not None
 
     @property
-    def _labelOptions(self):
+    def _label_options(self):
         """ Any labeling options that a particular filesystem may use.
 
             :returns: labeling options
@@ -72,12 +72,12 @@ def _labelOptions(self):
         if self.fs.label is None:
             return []
 
-        if self.fs.labelFormatOK(self.fs.label):
+        if self.fs.label_format_ok(self.fs.label):
             return [self.label_option, self.fs.label]
         else:
             raise FSWriteLabelError("Choosing not to apply label (%s) during creation of filesystem %s. Label format is unacceptable for this filesystem." % (self.fs.label, self.fs.type))
 
-    def _formatOptions(self, options=None, label=False):
+    def _format_options(self, options=None, label=False):
         """Get a list of format options to be used when creating the
            filesystem.
 
@@ -90,11 +90,11 @@ def _formatOptions(self, options=None, label=False):
         if not isinstance(options, list):
             raise FSError("options parameter must be a list.")
 
-        label_options = self._labelOptions if label else []
-        create_options = shlex.split(self.fs.createOptions or "")
+        label_options = self._label_options if label else []
+        create_options = shlex.split(self.fs.create_options or "")
         return options + self.args + label_options + create_options + [self.fs.device]
 
-    def _mkfsCommand(self, options, label):
+    def _mkfs_command(self, options, label):
         """Return the command to make the filesystem.
 
            :param options: any special options
@@ -102,9 +102,9 @@ def _mkfsCommand(self, options, label):
            :returns: the mkfs command
            :rtype: list of str
         """
-        return [str(self.ext)] + self._formatOptions(options, label)
+        return [str(self.ext)] + self._format_options(options, label)
 
-    def doTask(self, options=None, label=False):
+    def do_task(self, options=None, label=False):
         """Create the format on the device and label if possible and desired.
 
            :param options: any special options, may be None
@@ -112,13 +112,13 @@ def doTask(self, options=None, label=False):
            :param bool label: whether to label while creating, default is False
         """
         # pylint: disable=arguments-differ
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         options = options or []
         try:
-            ret = util.run_program(self._mkfsCommand(options, label))
+            ret = util.run_program(self._mkfs_command(options, label))
         except OSError as e:
             raise FSError(e)
 
@@ -216,5 +216,5 @@ def args(self):
 class UnimplementedFSMkfs(task.UnimplementedTask, FSMkfsTask):
 
     @property
-    def canLabel(self):
+    def can_label(self):
         return False
diff --git a/blivet/tasks/fsmount.py b/blivet/tasks/fsmount.py
index 9b674d5..90bb3c7 100644
--- a/blivet/tasks/fsmount.py
+++ b/blivet/tasks/fsmount.py
@@ -43,34 +43,34 @@ class FSMount(task.BasicApplication, fstask.FSTask):
     # TASK methods
 
     @property
-    def _hasDriver(self):
+    def _has_driver(self):
         """ Is there a filesystem driver in the kernel modules directory. """
         modpath = os.path.realpath(os.path.join("/lib/modules", os.uname()[2]))
         if os.path.isdir(modpath):
-            modname = "%s.ko" % self.mountType
+            modname = "%s.ko" % self.mount_type
             for _root, _dirs, files in os.walk(modpath):
                 if any(x.startswith(modname) for x in files):
                     return True
         return False
 
     @property
-    def _canMount(self):
-        return (self.mountType in fslib.kernel_filesystems) or \
-           (os.access("/sbin/mount.%s" % (self.mountType,), os.X_OK)) or \
-           self._hasDriver
+    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
 
     @property
-    def _availabilityErrors(self):
-        errors = super(FSMount, self)._availabilityErrors
+    def _availability_errors(self):
+        errors = super(FSMount, self)._availability_errors
 
-        if not self._canMount:
-            errors.append("mounting filesystem %s is not supported" % self.mountType)
+        if not self._can_mount:
+            errors.append("mounting filesystem %s is not supported" % self.mount_type)
         return errors
 
     # IMPLEMENTATION methods
 
     @property
-    def mountType(self):
+    def mount_type(self):
         """ Mount type string to pass to mount command.
 
             :returns: mount type string
@@ -78,7 +78,7 @@ def mountType(self):
         """
         return self.fstype or self.fs._type
 
-    def _modifyOptions(self, options):
+    def _modify_options(self, options):
         """ Any mandatory options can be added in this method.
 
             :param str options: an option string
@@ -87,7 +87,7 @@ def _modifyOptions(self, options):
         """
         return options
 
-    def mountOptions(self, options):
+    def mount_options(self, options):
         """ The options used for mounting.
 
            :param options: mount options
@@ -98,9 +98,9 @@ def mountOptions(self, options):
         if not options or not isinstance(options, str):
             options = self.fs.mountopts or ",".join(self.options)
 
-        return self._modifyOptions(options)
+        return self._modify_options(options)
 
-    def doTask(self, mountpoint, options=None):
+    def do_task(self, mountpoint, options=None):
         """Create the format on the device and label if possible and desired.
 
            :param str mountpoint: mountpoint that overrides self.mountpoint
@@ -108,14 +108,14 @@ def doTask(self, mountpoint, options=None):
            :type options: str or None
         """
         # pylint: disable=arguments-differ
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         try:
             rc = util.mount(self.fs.device, mountpoint,
-                            fstype=self.mountType,
-                            options=self.mountOptions(options))
+                            fstype=self.mount_type,
+                            options=self.mount_options(options))
         except OSError as e:
             raise FSError("mount failed: %s" % e)
 
@@ -128,14 +128,14 @@ class AppleBootstrapFSMount(FSMount):
 class BindFSMount(FSMount):
 
     @property
-    def _availabilityErrors(self):
+    def _availability_errors(self):
         errors = []
         if not self.ext.available:
             errors.append("application %s is not available" % self.ext)
 
         return errors
 
-    def _modifyOptions(self, options):
+    def _modify_options(self, options):
         return ",".join(["bind", options])
 
 class DevPtsFSMount(FSMount):
@@ -156,12 +156,12 @@ class Iso9660FSMount(FSMount):
 class NoDevFSMount(FSMount):
 
     @property
-    def mountType(self):
+    def mount_type(self):
         return self.fs.device
 
 class NFSMount(FSMount):
 
-    def _availabilityErrors(self):
+    def _availability_errors(self):
         return ["nfs filesystem can't be mounted"]
 
 class NTFSMount(FSMount):
@@ -170,25 +170,25 @@ class NTFSMount(FSMount):
 class SELinuxFSMount(NoDevFSMount):
 
     @property
-    def _availabilityErrors(self):
-        errors = super(SELinuxFSMount, self)._availabilityErrors
+    def _availability_errors(self):
+        errors = super(SELinuxFSMount, self)._availability_errors
         if not flags.selinux:
             errors.append("selinux not enabled")
         return errors
 
 class TmpFSMount(NoDevFSMount):
 
-    def _modifyOptions(self, options):
-        # This duplicates some code in fs.TmpFS._getOptions.
+    def _modify_options(self, options):
+        # This duplicates some code in fs.TmpFS._get_options.
         # There seems to be no way around that.
         if self.fs._accept_default_size:
             size_opt = None
         else:
-            size_opt = self.fs._sizeOption(self.fs._size)
+            size_opt = self.fs._size_option(self.fs._size)
         return ",".join(o for o in (options, size_opt) if o)
 
     @property
-    def _availabilityErrors(self):
+    def _availability_errors(self):
         errors = []
         if not self.ext.available:
             errors.append("application %s is not available" % self.ext)
diff --git a/blivet/tasks/fsreadlabel.py b/blivet/tasks/fsreadlabel.py
index ec00f73..58350f7 100644
--- a/blivet/tasks/fsreadlabel.py
+++ b/blivet/tasks/fsreadlabel.py
@@ -44,7 +44,7 @@ class FSReadLabel(task.BasicApplication, fstask.FSTask):
     # IMPLEMENTATION methods
 
     @property
-    def _readCommand(self):
+    def _read_command(self):
         """Get the command to read the filesystem label.
 
            :return: the command
@@ -52,7 +52,7 @@ def _readCommand(self):
         """
         return [str(self.ext)] + self.args
 
-    def _extractLabel(self, labelstr):
+    def _extract_label(self, labelstr):
         """Extract the label from an output string.
 
            :param str labelstr: the string containing the label information
@@ -67,23 +67,23 @@ def _extractLabel(self, labelstr):
             raise FSReadLabelError("Unknown format for application %s" % self.ext)
         return match.group('label')
 
-    def doTask(self):
+    def do_task(self):
         """ Get the label.
 
             :returns: the filesystem label
             :rtype: str
         """
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSReadLabelError("\n".join(error_msgs))
 
-        (rc, out) = util.run_program_and_capture_output(self._readCommand)
+        (rc, out) = util.run_program_and_capture_output(self._read_command)
         if rc != 0:
             raise FSReadLabelError("read label failed")
 
         label = out.strip()
 
-        return label if label == "" else self._extractLabel(label)
+        return label if label == "" else self._extract_label(label)
 
 class DosFSReadLabel(FSReadLabel):
     ext = availability.DOSFSLABEL_APP
diff --git a/blivet/tasks/fsresize.py b/blivet/tasks/fsresize.py
index 6fb5e0e..89e6e15 100644
--- a/blivet/tasks/fsresize.py
+++ b/blivet/tasks/fsresize.py
@@ -49,27 +49,27 @@ class FSResize(task.BasicApplication, FSResizeTask):
     # IMPLEMENTATION methods
 
     @abc.abstractmethod
-    def sizeSpec(self):
+    def size_spec(self):
         """ Returns a string specification for the target size of the command.
             :returns: size specification
             :rtype: str
         """
         raise NotImplementedError()
 
-    def _resizeCommand(self):
+    def _resize_command(self):
         return [str(self.ext)] + self.args
 
-    def doTask(self):
+    def do_task(self):
         """ Resize the device.
 
             :raises FSError: on failure
         """
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         try:
-            ret = util.run_program(self._resizeCommand())
+            ret = util.run_program(self._resize_command())
         except OSError as e:
             raise FSError(e)
 
@@ -86,26 +86,26 @@ class Ext2FSResize(FSResize):
     # the lookup is only by standard binary units.
     size_fmt = {KiB: "%dK", MiB: "%dM", GiB: "%dG"}[unit]
 
-    def sizeSpec(self):
-        return self.size_fmt % self.fs.targetSize.convertTo(self.unit)
+    def size_spec(self):
+        return self.size_fmt % self.fs.target_size.convert_to(self.unit)
 
     @property
     def args(self):
-        return ["-p", self.fs.device, self.sizeSpec()]
+        return ["-p", self.fs.device, self.size_spec()]
 
 class NTFSResize(FSResize):
     ext = availability.NTFSRESIZE_APP
     unit = B
     size_fmt = {B: "%d", KB: "%dK", MB: "%dM", GB: "%dG"}[unit]
 
-    def sizeSpec(self):
-        return self.size_fmt % self.fs.targetSize.convertTo(self.unit)
+    def size_spec(self):
+        return self.size_fmt % self.fs.target_size.convert_to(self.unit)
 
     @property
     def args(self):
         return [
            "-ff", # need at least two 'f's to fully suppress interaction
-           "-s", self.sizeSpec(),
+           "-s", self.size_spec(),
            self.fs.device
         ]
 
@@ -115,8 +115,8 @@ class TmpFSResize(FSResize):
     unit = MiB
     size_fmt = {KiB: "%dk", MiB: "%dm", GiB: "%dg"}[unit]
 
-    def sizeSpec(self):
-        return "size=%s" % (self.size_fmt % self.fs.targetSize.convertTo(self.unit))
+    def size_spec(self):
+        return "size=%s" % (self.size_fmt % self.fs.target_size.convert_to(self.unit))
 
     @property
     def args(self):
@@ -124,8 +124,8 @@ def args(self):
         # fact that resizing is done by mounting and that the options are
         # therefore mount options. The situation is hard to avoid, though.
         opts = self.fs.mountopts or ",".join(self.fs._mount.options)
-        options = ("remount", opts, self.sizeSpec())
-        return ['-o', ",".join(options), self.fs._type, self.fs.systemMountpoint]
+        options = ("remount", opts, self.size_spec())
+        return ['-o', ",".join(options), self.fs._type, self.fs.system_mountpoint]
 
 class UnimplementedFSResize(task.UnimplementedTask, FSResizeTask):
 
diff --git a/blivet/tasks/fssize.py b/blivet/tasks/fssize.py
index aa82ac0..71057f0 100644
--- a/blivet/tasks/fssize.py
+++ b/blivet/tasks/fssize.py
@@ -46,23 +46,23 @@ class FSSize(fstask.FSTask):
     # TASK methods
 
     @property
-    def _availabilityErrors(self):
+    def _availability_errors(self):
         return []
 
     @property
-    def dependsOn(self):
+    def depends_on(self):
         return [self.fs._info]
 
     # IMPLEMENTATION methods
 
-    def doTask(self):
+    def do_task(self):
         """ Returns the size of the filesystem.
 
             :returns: the size of the filesystem
             :rtype: :class:`~.size.Size`
             :raises FSError: on failure
         """
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
@@ -121,24 +121,24 @@ class TmpFSSize(task.BasicApplication, fstask.FSTask):
     ext = availability.DF_APP
 
     @property
-    def _sizeCommand(self):
-        return [str(self.ext), self.fs.systemMountpoint, "--output=size"]
+    def _size_command(self):
+        return [str(self.ext), self.fs.system_mountpoint, "--output=size"]
 
-    def doTask(self):
-        error_msgs = self.availabilityErrors
+    def do_task(self):
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         try:
-            (ret, out) = util.run_program_and_capture_output(self._sizeCommand)
+            (ret, out) = util.run_program_and_capture_output(self._size_command)
             if ret:
-                raise FSError("Failed to execute command %s." % self._sizeCommand)
+                raise FSError("Failed to execute command %s." % self._size_command)
         except OSError:
-            raise FSError("Failed to execute command %s." % self._sizeCommand)
+            raise FSError("Failed to execute command %s." % self._size_command)
 
         lines = out.splitlines()
         if len(lines) != 2 or lines[0].strip() != "1K-blocks":
-            raise FSError("Failed to parse output of command %s." % self._sizeCommand)
+            raise FSError("Failed to parse output of command %s." % self._size_command)
 
         return Size("%s KiB" % lines[1])
 
diff --git a/blivet/tasks/fssync.py b/blivet/tasks/fssync.py
index e08288d..33e2113 100644
--- a/blivet/tasks/fssync.py
+++ b/blivet/tasks/fssync.py
@@ -37,7 +37,7 @@ class FSSync(task.BasicApplication, fstask.FSTask):
     description = "filesystem syncing"
 
     @abc.abstractmethod
-    def doTask(self):
+    def do_task(self):
         raise NotImplementedError()
 
 class XFSSync(FSSync):
@@ -45,27 +45,27 @@ class XFSSync(FSSync):
 
     ext = availability.XFSFREEZE_APP
 
-    def _freezeCommand(self):
-        return [str(self.ext), "-f", self.fs.systemMountpoint]
+    def _freeze_command(self):
+        return [str(self.ext), "-f", self.fs.system_mountpoint]
 
-    def _unfreezeCommand(self):
-        return [str(self.ext), "-u", self.fs.systemMountpoint]
+    def _unfreeze_command(self):
+        return [str(self.ext), "-u", self.fs.system_mountpoint]
 
-    def doTask(self, root="/"):
+    def do_task(self, root="/"):
         # pylint: disable=arguments-differ
-        error_msgs = self.availabilityErrors
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSError("\n".join(error_msgs))
 
         error_msg = None
         try:
-            rc = util.run_program(self._freezeCommand(), root=root)
+            rc = util.run_program(self._freeze_command(), root=root)
         except OSError as e:
             error_msg = "failed to sync filesytem: %s" % e
         error_msg = error_msg or rc
 
         try:
-            rc = util.run_program(self._unfreezeCommand(), root=root)
+            rc = util.run_program(self._unfreeze_command(), root=root)
         except OSError as e:
             error_msg = error_msg or "failed to sync filesystem: %s" % e
         error_msg = error_msg or rc
diff --git a/blivet/tasks/fswritelabel.py b/blivet/tasks/fswritelabel.py
index 50eacdf..4bfc285 100644
--- a/blivet/tasks/fswritelabel.py
+++ b/blivet/tasks/fswritelabel.py
@@ -41,7 +41,7 @@ class FSWriteLabel(task.BasicApplication, fstask.FSTask):
     # IMPLEMENTATION methods
 
     @property
-    def _setCommand(self):
+    def _set_command(self):
         """Get the command to label the filesystem.
 
            :return: the command
@@ -49,12 +49,12 @@ def _setCommand(self):
         """
         return [str(self.ext)] + self.args
 
-    def doTask(self):
-        error_msgs = self.availabilityErrors
+    def do_task(self):
+        error_msgs = self.availability_errors
         if error_msgs:
             raise FSWriteLabelError("\n".join(error_msgs))
 
-        rc = util.run_program(self._setCommand)
+        rc = util.run_program(self._set_command)
         if rc:
             raise FSWriteLabelError("label failed")
 
diff --git a/blivet/tasks/task.py b/blivet/tasks/task.py
index 61a8ae2..ae41542 100644
--- a/blivet/tasks/task.py
+++ b/blivet/tasks/task.py
@@ -35,10 +35,10 @@ class Task(object):
     description = abc.abstractproperty(doc="Brief description for this task.")
 
     @property
-    def availabilityErrors(self):
+    def availability_errors(self):
         """ Reasons if this task or the tasks it depends on are unavailable. """
-        return self._availabilityErrors + \
-           [e for t in self.dependsOn for e in t.availabilityErrors]
+        return self._availability_errors + \
+           [e for t in self.depends_on for e in t.availability_errors]
 
     @property
     def available(self):
@@ -47,15 +47,15 @@ def available(self):
             :returns: True if the task is available
             :rtype: bool
         """
-        return self.availabilityErrors == []
+        return self.availability_errors == []
 
-    _availabilityErrors = abc.abstractproperty(
+    _availability_errors = abc.abstractproperty(
        doc="Reasons if the necessary external tools are unavailable.")
 
-    dependsOn = abc.abstractproperty(doc="tasks that this task depends on")
+    depends_on = abc.abstractproperty(doc="tasks that this task depends on")
 
     @abc.abstractmethod
-    def doTask(self, *args, **kwargs):
+    def do_task(self, *args, **kwargs):
         """ Do the task for this class. """
         raise NotImplementedError()
 
@@ -66,15 +66,15 @@ class UnimplementedTask(Task):
     implemented = False
 
     @property
-    def _availabilityErrors(self):
+    def _availability_errors(self):
         return ["Not implemented task can not succeed."]
 
-    dependsOn = []
+    depends_on = []
 
     def __str__(self):
         return "unimplemented task"
 
-    def doTask(self, *args, **kwargs):
+    def do_task(self, *args, **kwargs):
         raise NotImplementedError()
 
 @add_metaclass(abc.ABCMeta)
@@ -89,13 +89,13 @@ def __str__(self):
         return str(self.ext)
 
     @property
-    def _availabilityErrors(self):
-        errors = self.ext.availabilityErrors
+    def _availability_errors(self):
+        errors = self.ext.availability_errors
         if errors:
             return ["application %s is not available: %s" % (self.ext, " and ".join(errors))]
         else:
             return []
 
     @property
-    def dependsOn(self):
+    def depends_on(self):
         return []
diff --git a/blivet/udev.py b/blivet/udev.py
index bb7907c..af89835 100644
--- a/blivet/udev.py
+++ b/blivet/udev.py
@@ -84,7 +84,7 @@ def resolve_devspec(devspec, sysname=False):
     # import devices locally to avoid cyclic import (devices <-> udev)
     from . import devices
 
-    devname = devices.devicePathToName(devspec)
+    devname = devices.device_path_to_name(devspec)
 
     ret = None
     for dev in get_devices():
@@ -269,7 +269,7 @@ def device_get_dasd_flag(info, flag=None):
 def device_is_cdrom(info):
     """ Return True if the device is an optical drive. """
     # FIXME: how can we differentiate USB drives from CD-ROM drives?
-    #         -- USB drives also generate a sdX device.
+    #         -- USB drives also generate a sd_x device.
     return info.get("ID_CDROM") == "1"
 
 def device_is_disk(info):
@@ -539,8 +539,8 @@ def device_is_biosraid_member(info):
     from .formats.dmraid import DMRaidMember
     from .formats.mdraid import MDRaidMember
     if 'ID_FS_TYPE' in info and \
-            (info["ID_FS_TYPE"] in DMRaidMember._udevTypes or \
-             info["ID_FS_TYPE"] in MDRaidMember._udevTypes) and \
+            (info["ID_FS_TYPE"] in DMRaidMember._udev_types or \
+             info["ID_FS_TYPE"] in MDRaidMember._udev_types) and \
             info["ID_FS_TYPE"] != "linux_raid_member":
         return True
 
diff --git a/blivet/util.py b/blivet/util.py
index 302861e..cb3d1bc 100644
--- a/blivet/util.py
+++ b/blivet/util.py
@@ -130,9 +130,9 @@ def get_mount_paths(dev):
         :returns: A list of mountpoints or []
         :rtype: list
     """
-    from .mounts import mountsCache
+    from .mounts import mounts_cache
 
-    mount_paths = mountsCache.getMountpoints(dev)
+    mount_paths = mounts_cache.get_mountpoints(dev)
     if mount_paths:
         log.debug("%s is mounted on %s", dev, ', '.join(mount_paths))
     return mount_paths
@@ -241,8 +241,8 @@ def get_cow_sysfs_path(dev_path, dev_sysfsPath):
                             (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 sysfsPath (e.g. /sys/devices/virtual/block/dm-X)
-    # where first part is the same as in sysfsPath of the original device
+    # we need the 'dm-X' name for sysfs_path (e.g. /sys/devices/virtual/block/dm-X)
+    # where first part is the same as in sysfs_path of the original device
     dm_name = os.path.basename(os.path.realpath(cow_path))
     cow_sysfsPath = os.path.join(os.path.split(dev_sysfsPath)[0], dm_name)
 
@@ -330,13 +330,13 @@ def makedirs(path):
 
 def copy_to_system(source):
     # do the import now because enable_installer_mode() has finally been called.
-    from . import getSysroot
+    from . import get_sysroot
 
     if not os.access(source, os.R_OK):
         log.info("copy_to_system: source '%s' does not exist.", source)
         return False
 
-    target = getSysroot() + source
+    target = get_sysroot() + source
     target_dir = os.path.dirname(target)
     log.debug("copy_to_system: '%s' -> '%s'.", source, target)
     if not os.path.isdir(target_dir):
diff --git a/blivet/zfcp.py b/blivet/zfcp.py
index 4410a9d..71b2cee 100644
--- a/blivet/zfcp.py
+++ b/blivet/zfcp.py
@@ -34,7 +34,7 @@
 import logging
 log = logging.getLogger("blivet")
 
-def loggedWriteLineToFile(fn, value):
+def logged_write_line_to_file(fn, value):
     f = open(fn, "w")
     log.debug("echo %s > %s", value, fn)
     f.write("%s\n" % (value))
@@ -58,16 +58,16 @@ def __init__(self, devnum, wwpn, fcplun):
             raise ValueError(_("You have not specified a FCP LUN or the number is invalid."))
 
     # Force str and unicode types in case any of the properties are unicode
-    def _toString(self):
+    def _to_string(self):
         return "%s %s %s" %(self.devnum, self.wwpn, self.fcplun)
 
     def __str__(self):
-        return stringize(self._toString())
+        return stringize(self._to_string())
 
     def __unicode__(self):
-        return unicodeize(self._toString())
+        return unicodeize(self._to_string())
 
-    def onlineDevice(self):
+    def online_device(self):
         online = "%s/%s/online" %(zfcpsysfs, self.devnum)
         portadd = "%s/%s/port_add" %(zfcpsysfs, self.devnum)
         portdir = "%s/%s/%s" %(zfcpsysfs, self.devnum, self.wwpn)
@@ -88,7 +88,7 @@ def onlineDevice(self):
             devonline = f.readline().strip()
             f.close()
             if devonline != "1":
-                loggedWriteLineToFile(online, "1")
+                logged_write_line_to_file(online, "1")
         except IOError as e:
             raise ValueError(_("Could not set zFCP device %(devnum)s "
                                 "online (%(e)s).") \
@@ -98,7 +98,7 @@ def onlineDevice(self):
             if os.path.exists(portadd):
                 # older zfcp sysfs interface
                 try:
-                    loggedWriteLineToFile(portadd, self.wwpn)
+                    logged_write_line_to_file(portadd, self.wwpn)
                     udev.settle()
                 except IOError as e:
                     raise ValueError(_("Could not add WWPN %(wwpn)s to zFCP "
@@ -120,7 +120,7 @@ def onlineDevice(self):
 
         if not os.path.exists(unitdir):
             try:
-                loggedWriteLineToFile(unitadd, self.fcplun)
+                logged_write_line_to_file(unitadd, self.fcplun)
                 udev.settle()
             except IOError as e:
                 raise ValueError(_("Could not add LUN %(fcplun)s to WWPN "
@@ -149,7 +149,7 @@ def onlineDevice(self):
                                  'devnum': self.devnum,
                                  'e': e})
         if fail != "0":
-            self.offlineDevice()
+            self.offline_device()
             raise ValueError(_("Failed LUN %(fcplun)s at WWPN %(wwpn)s on "
                                 "zFCP device %(devnum)s removed again.") \
                               % {'fcplun': self.fcplun,
@@ -158,7 +158,7 @@ def onlineDevice(self):
 
         return True
 
-    def offlineSCSIDevice(self):
+    def offline_scsi_device(self):
         f = open("/proc/scsi/scsi", "r")
         lines = f.readlines()
         f.close()
@@ -189,14 +189,14 @@ def offlineSCSIDevice(self):
             if fcphbasysfs == self.devnum \
                     and fcpwwpnsysfs == self.wwpn \
                     and fcplunsysfs == self.fcplun:
-                loggedWriteLineToFile(scsidel, "1")
+                logged_write_line_to_file(scsidel, "1")
                 udev.settle()
                 return
 
         log.warn("no scsi device found to delete for zfcp %s %s %s",
                  self.devnum, self.wwpn, self.fcplun)
 
-    def offlineDevice(self):
+    def offline_device(self):
         offline = "%s/%s/online" %(zfcpsysfs, self.devnum)
         portadd = "%s/%s/port_add" %(zfcpsysfs, self.devnum)
         portremove = "%s/%s/port_remove" %(zfcpsysfs, self.devnum)
@@ -205,7 +205,7 @@ def offlineDevice(self):
         devdir = "%s/%s" %(zfcpsysfs, self.devnum)
 
         try:
-            self.offlineSCSIDevice()
+            self.offline_scsi_device()
         except IOError as e:
             raise ValueError(_("Could not correctly delete SCSI device of "
                                 "zFCP %(devnum)s %(wwpn)s %(fcplun)s "
@@ -214,7 +214,7 @@ def offlineDevice(self):
                                  'fcplun': self.fcplun, 'e': e})
 
         try:
-            loggedWriteLineToFile(unitremove, self.fcplun)
+            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 "
@@ -232,7 +232,7 @@ def offlineDevice(self):
                     return True
 
             try:
-                loggedWriteLineToFile(portremove, self.wwpn)
+                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).") \
@@ -258,7 +258,7 @@ def offlineDevice(self):
                 return True
 
         try:
-            loggedWriteLineToFile(offline, "0")
+            logged_write_line_to_file(offline, "0")
         except IOError as e:
             raise ValueError(_("Could not set zFCP device %(devnum)s "
                                 "offline (%(e)s).") \
@@ -271,7 +271,7 @@ class ZFCP:
 
         This class will automatically online to ZFCP drives configured in
         /tmp/fcpconfig when the startup() method gets called. It can also be
-        used to manually configure ZFCP devices through the addFCP() method.
+        used to manually configure ZFCP devices through the add_fcp() method.
 
         As this class needs to make sure that /tmp/fcpconfig configured
         drives are only onlined once and as it keeps a global list of all ZFCP
@@ -279,16 +279,15 @@ class ZFCP:
     """
 
     def __init__(self):
-        self.intf = None
         self.fcpdevs = set()
-        self.hasReadConfig = False
+        self.has_read_config = False
         self.down = True
 
     # So that users can write zfcp() to get the singleton instance
     def __call__(self):
         return self
 
-    def readConfig(self):
+    def read_config(self):
         try:
             f = open(zfcpconf, "r")
         except IOError:
@@ -319,16 +318,13 @@ def readConfig(self):
                 continue
 
             try:
-                self.addFCP(devnum, wwpn, fcplun)
+                self.add_fcp(devnum, wwpn, fcplun)
             except ValueError as e:
-                if self.intf:
-                    self.intf.messageWindow(_("Error"), str(e))
-                else:
-                    log.warning("%s", str(e))
+                log.warning("%s", str(e))
 
-    def addFCP(self, devnum, wwpn, fcplun):
+    def add_fcp(self, devnum, wwpn, fcplun):
         d = ZFCPDevice(devnum, wwpn, fcplun)
-        if d.onlineDevice():
+        if d.online_device():
             self.fcpdevs.add(d)
 
     def shutdown(self):
@@ -339,7 +335,7 @@ def shutdown(self):
             return
         for d in self.fcpdevs:
             try:
-                d.offlineDevice()
+                d.offline_device()
             except ValueError as e:
                 log.warn("%s", str(e))
 
@@ -347,17 +343,17 @@ def startup(self):
         if not self.down:
             return
         self.down = False
-        if not self.hasReadConfig:
-            self.readConfig()
-            self.hasReadConfig = True
-            # readConfig calls addFCP which calls onlineDevice already
+        if not self.has_read_config:
+            self.read_config()
+            self.has_read_config = True
+            # read_config calls add_fcp which calls online_device already
             return
 
         if len(self.fcpdevs) == 0:
             return
         for d in self.fcpdevs:
             try:
-                d.onlineDevice()
+                d.online_device()
             except ValueError as e:
                 log.warn("%s", str(e))
 
diff --git a/doc/conf.py b/doc/conf.py
index 8df2d22..23dc2de 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -66,7 +66,7 @@
 # directories to ignore when looking for source files.
 exclude_patterns = ['_build']
 
-# The reST default role (used for this markup: `text`) to use for all documents.
+# The re_st default role (used for this markup: `text`) to use for all documents.
 #default_role = None
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
@@ -148,7 +148,7 @@
 # If true, the index is split into individual pages for each letter.
 #html_split_index = False
 
-# If true, links to the reST sources are added to the pages.
+# If true, links to the re_st sources are added to the pages.
 #html_show_sourcelink = True
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
@@ -314,9 +314,9 @@ def __getattr__(cls, name):
         if name in ('__file__', '__path__'):
             return '/dev/null'
         elif name[0] == name[0].upper():
-            mockType = type(name, (), {})
-            mockType.__module__ = __name__
-            return mockType
+            mock_type = type(name, (), {})
+            mock_type.__module__ = __name__
+            return mock_type
         else:
             return Mock()
 
diff --git a/examples/factory.py b/examples/factory.py
index acfb0f7..1f92fba 100644
--- a/examples/factory.py
+++ b/examples/factory.py
@@ -11,35 +11,35 @@
 
 # create two disk image files on which to create new devices
 disk1_file = create_sparse_tempfile("disk1", Size("100GiB"))
-b.config.diskImages["disk1"] = disk1_file
+b.config.disk_images["disk1"] = disk1_file
 disk2_file = create_sparse_tempfile("disk2", Size("100GiB"))
-b.config.diskImages["disk2"] = disk2_file
+b.config.disk_images["disk2"] = disk2_file
 
 b.reset()
 
 try:
-    disk1 = b.devicetree.getDeviceByName("disk1")
-    disk2 = b.devicetree.getDeviceByName("disk2")
-    disk1.format = blivet.formats.getFormat("disklabel", device=disk1.path)
-    disk2.format = blivet.formats.getFormat("disklabel", device=disk2.path)
+    disk1 = b.devicetree.get_device_by_name("disk1")
+    disk2 = b.devicetree.get_device_by_name("disk2")
+    disk1.format = blivet.formats.get_format("disklabel", device=disk1.path)
+    disk2.format = blivet.formats.get_format("disklabel", device=disk2.path)
 
     # create an lv named data in a vg named testvg
-    device = b.factoryDevice(blivet.devicefactory.DEVICE_TYPE_LVM,
+    device = b.factory_device(blivet.devicefactory.DEVICE_TYPE_LVM,
                              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.factoryDevice(blivet.devicefactory.DEVICE_TYPE_LVM,
+    device = b.factory_device(blivet.devicefactory.DEVICE_TYPE_LVM,
                              Size("50GiB"), disks=[disk1, disk2],
                              fstype="xfs", mountpoint="/data",
                              container_raid_level="raid1",
                              device=device)
     print_devices(b)
 
-    b.devicetree.processActions()
+    b.devicetree.process_actions()
     print_devices(b)
 finally:
-    b.devicetree.teardownDiskImages()
+    b.devicetree.teardown_disk_images()
     os.unlink(disk1_file)
     os.unlink(disk2_file)
diff --git a/examples/lvm.py b/examples/lvm.py
index 90208be..7621925 100644
--- a/examples/lvm.py
+++ b/examples/lvm.py
@@ -11,45 +11,45 @@
 
 # create a disk image file on which to create new devices
 disk1_file = create_sparse_tempfile("disk1", Size("100GiB"))
-b.config.diskImages["disk1"] = disk1_file
+b.config.disk_images["disk1"] = disk1_file
 
 b.reset()
 
 try:
-    disk1 = b.devicetree.getDeviceByName("disk1")
+    disk1 = b.devicetree.get_device_by_name("disk1")
 
-    b.initializeDisk(disk1)
+    b.initialize_disk(disk1)
 
-    pv = b.newPartition(size=Size("50GiB"), fmt_type="lvmpv")
-    b.createDevice(pv)
+    pv = b.new_partition(size=Size("50GiB"), fmt_type="lvmpv")
+    b.create_device(pv)
 
     # allocate the partitions (decide where and on which disks they'll reside)
-    blivet.partitioning.doPartitioning(b)
+    blivet.partitioning.do_partitioning(b)
 
-    vg = b.newVG(parents=[pv])
-    b.createDevice(vg)
+    vg = b.new_vg(parents=[pv])
+    b.create_device(vg)
 
     # new lv with base size 5GiB and unbounded growth and an ext4 filesystem
-    dev = b.newLV(fmt_type="ext4", size=Size("5GiB"), grow=True,
+    dev = b.new_lv(fmt_type="ext4", size=Size("5GiB"), grow=True,
                   parents=[vg], name="unbounded")
-    b.createDevice(dev)
+    b.create_device(dev)
 
     # new lv with base size 5GiB and growth up to 15GiB and an ext4 filesystem
-    dev = b.newLV(fmt_type="ext4", size=Size("5GiB"), grow=True,
+    dev = b.new_lv(fmt_type="ext4", size=Size("5GiB"), grow=True,
                   maxsize=Size("15GiB"), parents=[vg], name="bounded")
-    b.createDevice(dev)
+    b.create_device(dev)
 
     # new lv with a fixed size of 2GiB formatted as swap space
-    dev = b.newLV(fmt_type="swap", size=Size("2GiB"), parents=[vg])
-    b.createDevice(dev)
+    dev = b.new_lv(fmt_type="swap", size=Size("2GiB"), parents=[vg])
+    b.create_device(dev)
 
     # allocate the growable lvs
-    blivet.partitioning.growLVM(b)
+    blivet.partitioning.grow_lvm(b)
     print_devices(b)
 
     # write the new partitions to disk and format them as specified
-    b.doIt()
+    b.do_it()
     print_devices(b)
 finally:
-    b.devicetree.teardownDiskImages()
+    b.devicetree.teardown_disk_images()
     os.unlink(disk1_file)
diff --git a/examples/partitioning.py b/examples/partitioning.py
index 1e4f0db..7c362f1 100644
--- a/examples/partitioning.py
+++ b/examples/partitioning.py
@@ -11,44 +11,44 @@
 
 # create two disk image files on which to create new devices
 disk1_file = create_sparse_tempfile("disk1", Size("100GiB"))
-b.config.diskImages["disk1"] = disk1_file
+b.config.disk_images["disk1"] = disk1_file
 disk2_file = create_sparse_tempfile("disk2", Size("100GiB"))
-b.config.diskImages["disk2"] = disk2_file
+b.config.disk_images["disk2"] = disk2_file
 
 b.reset()
 
 try:
-    disk1 = b.devicetree.getDeviceByName("disk1")
-    disk2 = b.devicetree.getDeviceByName("disk2")
+    disk1 = b.devicetree.get_device_by_name("disk1")
+    disk2 = b.devicetree.get_device_by_name("disk2")
 
-    b.initializeDisk(disk1)
-    b.initializeDisk(disk2)
+    b.initialize_disk(disk1)
+    b.initialize_disk(disk2)
 
     # new partition on either disk1 or disk2 with base size 10GiB and growth
     # up to a maximum size of 50GiB
-    dev = b.newPartition(size=Size("10MiB"), maxsize=Size("50GiB"),
+    dev = b.new_partition(size=Size("10MiB"), maxsize=Size("50GiB"),
                          grow=True, parents=[disk1, disk2])
-    b.createDevice(dev)
+    b.create_device(dev)
 
     # new partition on disk1 with base size 5GiB and unbounded growth and an
     # ext4 filesystem
-    dev = b.newPartition(fmt_type="ext4", size=Size("5GiB"), grow=True,
+    dev = b.new_partition(fmt_type="ext4", size=Size("5GiB"), grow=True,
                          parents=[disk1])
-    b.createDevice(dev)
+    b.create_device(dev)
 
     # new partition on any suitable disk with a fixed size of 2GiB formatted
     # as swap space
-    dev = b.newPartition(fmt_type="swap", size=Size("2GiB"))
-    b.createDevice(dev)
+    dev = b.new_partition(fmt_type="swap", size=Size("2GiB"))
+    b.create_device(dev)
 
     # allocate the partitions (decide where and on which disks they'll reside)
-    blivet.partitioning.doPartitioning(b)
+    blivet.partitioning.do_partitioning(b)
     print_devices(b)
 
     # write the new partitions to disk and format them as specified
-    b.doIt()
+    b.do_it()
     print_devices(b)
 finally:
-    b.devicetree.teardownDiskImages()
+    b.devicetree.teardown_disk_images()
     os.unlink(disk1_file)
     os.unlink(disk2_file)
diff --git a/tests/action_test.py b/tests/action_test.py
index 48e362d..0ec1a5d 100644
--- a/tests/action_test.py
+++ b/tests/action_test.py
@@ -3,7 +3,7 @@
 
 from tests.storagetestcase import StorageTestCase
 import blivet
-from blivet.formats import getFormat
+from blivet.formats import get_format
 from blivet.size import Size
 
 # device classes for brevity's sake -- later on, that is
@@ -31,7 +31,7 @@
    LVMLogicalVolumeDevice
 ]
 
- at unittest.skipUnless(not any(x.unavailableTypeDependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test")
+ at unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test")
 class DeviceActionTestCase(StorageTestCase):
     """ DeviceActionTestSuite """
 
@@ -43,58 +43,58 @@ def setUp(self):
         super(DeviceActionTestCase, self).setUp()
 
         for name in ["sda", "sdb", "sdc", "sdd"]:
-            disk = self.newDevice(device_class=DiskDevice,
+            disk = self.new_device(device_class=DiskDevice,
                                   name=name, size=Size("100 GiB"))
-            disk.format = self.newFormat("disklabel", path=disk.path,
+            disk.format = self.new_format("disklabel", path=disk.path,
                                          exists=True)
-            self.storage.devicetree._addDevice(disk)
+            self.storage.devicetree._add_device(disk)
 
         # create a layout similar to autopart as a starting point
-        sda = self.storage.devicetree.getDeviceByName("sda")
-        sdb = self.storage.devicetree.getDeviceByName("sdb")
+        sda = self.storage.devicetree.get_device_by_name("sda")
+        sdb = self.storage.devicetree.get_device_by_name("sdb")
 
-        sda1 = self.newDevice(device_class=PartitionDevice,
+        sda1 = self.new_device(device_class=PartitionDevice,
                               exists=True, name="sda1", parents=[sda],
                               size=Size("500 MiB"))
-        sda1.format = self.newFormat("ext4", mountpoint="/boot",
+        sda1.format = self.new_format("ext4", mountpoint="/boot",
                                      device_instance=sda1,
                                      device=sda1.path, exists=True)
-        self.storage.devicetree._addDevice(sda1)
+        self.storage.devicetree._add_device(sda1)
 
-        sda2 = self.newDevice(device_class=PartitionDevice,
+        sda2 = self.new_device(device_class=PartitionDevice,
                               size=Size("99.5 GiB"), name="sda2",
                               parents=[sda], exists=True)
-        sda2.format = self.newFormat("lvmpv", device=sda2.path, exists=True)
-        self.storage.devicetree._addDevice(sda2)
+        sda2.format = self.new_format("lvmpv", device=sda2.path, exists=True)
+        self.storage.devicetree._add_device(sda2)
 
-        sdb1 = self.newDevice(device_class=PartitionDevice,
+        sdb1 = self.new_device(device_class=PartitionDevice,
                               size=Size("99.999 GiB"), name="sdb1",
                               parents=[sdb], exists=True)
-        sdb1.format = self.newFormat("lvmpv", device=sdb1.path, exists=True)
-        self.storage.devicetree._addDevice(sdb1)
+        sdb1.format = self.new_format("lvmpv", device=sdb1.path, exists=True)
+        self.storage.devicetree._add_device(sdb1)
 
-        vg = self.newDevice(device_class=LVMVolumeGroupDevice,
+        vg = self.new_device(device_class=LVMVolumeGroupDevice,
                             name="VolGroup", parents=[sda2, sdb1],
                             exists=True)
-        self.storage.devicetree._addDevice(vg)
+        self.storage.devicetree._add_device(vg)
 
-        lv_root = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_root", parents=[vg],
                                  size=Size("160 GiB"), exists=True)
-        lv_root.format = self.newFormat("ext4", mountpoint="/",
+        lv_root.format = self.new_format("ext4", mountpoint="/",
                                         device_instance=lv_root,
                                         device=lv_root.path, exists=True)
-        self.storage.devicetree._addDevice(lv_root)
+        self.storage.devicetree._add_device(lv_root)
 
-        lv_swap = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_swap", parents=[vg],
                                  size=Size("4000 MiB"), exists=True)
-        lv_swap.format = self.newFormat("swap", device=lv_swap.path,
+        lv_swap.format = self.new_format("swap", device=lv_swap.path,
                                         device_instance=lv_swap,
                                         exists=True)
-        self.storage.devicetree._addDevice(lv_swap)
+        self.storage.devicetree._add_device(lv_swap)
 
-    def testActions(self):
+    def test_actions(self):
         """ Verify correct management of actions.
 
             - action creation/registration/cancellation
@@ -125,101 +125,101 @@ def testActions(self):
         devicetree = self.storage.devicetree
 
         # clear the disks
-        self.destroyAllDevices()
-        self.assertEqual(devicetree.getDevicesByType("lvmlv"), [])
-        self.assertEqual(devicetree.getDevicesByType("lvmvg"), [])
-        self.assertEqual(devicetree.getDevicesByType("partition"), [])
+        self.destroy_all_devices()
+        self.assertEqual(devicetree.get_devices_by_type("lvmlv"), [])
+        self.assertEqual(devicetree.get_devices_by_type("lvmvg"), [])
+        self.assertEqual(devicetree.get_devices_by_type("partition"), [])
 
-        sda = devicetree.getDeviceByName("sda")
+        sda = devicetree.get_device_by_name("sda")
         self.assertNotEqual(sda, None, "failed to find disk 'sda'")
 
-        sda1 = self.newDevice(device_class=PartitionDevice,
+        sda1 = self.new_device(device_class=PartitionDevice,
                               name="sda1", size=Size("500 MiB"),
                               parents=[sda])
-        self.scheduleCreateDevice(sda1)
+        self.schedule_create_device(sda1)
 
-        sda2 = self.newDevice(device_class=PartitionDevice,
+        sda2 = self.new_device(device_class=PartitionDevice,
                               name="sda2", size=Size("100 GiB"),
                               parents=[sda])
-        self.scheduleCreateDevice(sda2)
-        fmt = self.newFormat("lvmpv", device=sda2.path)
-        self.scheduleCreateFormat(device=sda2, fmt=fmt)
+        self.schedule_create_device(sda2)
+        fmt = self.new_format("lvmpv", device=sda2.path)
+        self.schedule_create_format(device=sda2, fmt=fmt)
 
-        vg = self.newDevice(device_class=LVMVolumeGroupDevice,
+        vg = self.new_device(device_class=LVMVolumeGroupDevice,
                             name="vg", parents=[sda2])
-        self.scheduleCreateDevice(vg)
+        self.schedule_create_device(vg)
 
-        lv_root = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_root", parents=[vg],
                                  size=Size("60 GiB"))
-        self.scheduleCreateDevice(lv_root)
-        fmt = self.newFormat("ext4", device=lv_root.path, mountpoint="/")
-        self.scheduleCreateFormat(device=lv_root, fmt=fmt)
+        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.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_swap", parents=[vg],
                                  size=Size("4000 MiB"))
-        self.scheduleCreateDevice(lv_swap)
-        fmt = self.newFormat("swap", device=lv_swap.path)
-        self.scheduleCreateFormat(device=lv_swap, fmt=fmt)
+        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.newDevice(device_class=PartitionDevice,
+        sda3 = self.new_device(device_class=PartitionDevice,
                               name="sda3", parents=[sda],
                               size=Size("40 GiB"))
-        self.scheduleCreateDevice(sda3)
-        fmt = self.newFormat("mdmember", device=sda3.path)
-        self.scheduleCreateFormat(device=sda3, fmt=fmt)
+        self.schedule_create_device(sda3)
+        fmt = self.new_format("mdmember", device=sda3.path)
+        self.schedule_create_format(device=sda3, fmt=fmt)
 
-        sdb = devicetree.getDeviceByName("sdb")
+        sdb = devicetree.get_device_by_name("sdb")
         self.assertNotEqual(sdb, None, "failed to find disk 'sdb'")
 
-        sdb1 = self.newDevice(device_class=PartitionDevice,
+        sdb1 = self.new_device(device_class=PartitionDevice,
                               name="sdb1", parents=[sdb],
                               size=Size("40 GiB"))
-        self.scheduleCreateDevice(sdb1)
-        fmt = self.newFormat("mdmember", device=sdb1.path,)
-        self.scheduleCreateFormat(device=sdb1, fmt=fmt)
+        self.schedule_create_device(sdb1)
+        fmt = self.new_format("mdmember", device=sdb1.path,)
+        self.schedule_create_format(device=sdb1, fmt=fmt)
 
-        md0 = self.newDevice(device_class=MDRaidArrayDevice,
+        md0 = self.new_device(device_class=MDRaidArrayDevice,
                              name="md0", level="raid0", minor=0,
-                             memberDevices=2, totalDevices=2,
+                             member_devices=2, total_devices=2,
                              parents=[sdb1, sda3])
-        self.scheduleCreateDevice(md0)
+        self.schedule_create_device(md0)
 
-        fmt = self.newFormat("ext4", device=md0.path, mountpoint="/home")
-        self.scheduleCreateFormat(device=md0, fmt=fmt)
+        fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
+        self.schedule_create_format(device=md0, fmt=fmt)
 
-        fmt = self.newFormat("ext4", mountpoint="/boot", device=sda1.path)
-        self.scheduleCreateFormat(device=sda1, fmt=fmt)
+        fmt = self.new_format("ext4", mountpoint="/boot", device=sda1.path)
+        self.schedule_create_format(device=sda1, fmt=fmt)
 
-    def testActionCreation(self):
+    def test_action_creation(self):
         """ Verify correct operation of action class constructors. """
         # instantiation of device resize action for non-existent device should
         # fail
         # XXX resizable depends on existence, so this is covered implicitly
-        sdd = self.storage.devicetree.getDeviceByName("sdd")
-        p = self.newDevice(device_class=PartitionDevice,
+        sdd = self.storage.devicetree.get_device_by_name("sdd")
+        p = self.new_device(device_class=PartitionDevice,
                            name="sdd1", size=Size("32 GiB"), parents=[sdd])
         with self.assertRaises(ValueError):
             ActionResizeDevice(p, p.size + Size("7232 MiB"))
 
         # instantiation of device resize action for non-resizable device
         # should fail
-        vg = self.storage.devicetree.getDeviceByName("VolGroup")
+        vg = self.storage.devicetree.get_device_by_name("VolGroup")
         self.assertNotEqual(vg, None)
         with self.assertRaises(ValueError):
             ActionResizeDevice(vg, vg.size + Size("32 MiB"))
 
         # instantiation of format resize action for non-resizable format type
         # should fail
-        lv_swap = self.storage.devicetree.getDeviceByName("VolGroup-lv_swap")
+        lv_swap = self.storage.devicetree.get_device_by_name("VolGroup-lv_swap")
         self.assertNotEqual(lv_swap, None)
         with self.assertRaises(ValueError):
             ActionResizeFormat(lv_swap, lv_swap.size + Size("32 MiB"))
 
         # instantiation of format resize action for non-existent format
         # should fail
-        lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root")
+        lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
         self.assertNotEqual(lv_root, None)
         lv_root.format.exists = False
         with self.assertRaises(ValueError):
@@ -228,7 +228,7 @@ def testActionCreation(self):
 
         # instantiation of device create action for existing device should
         # fail
-        lv_swap = self.storage.devicetree.getDeviceByName("VolGroup-lv_swap")
+        lv_swap = self.storage.devicetree.get_device_by_name("VolGroup-lv_swap")
         self.assertNotEqual(lv_swap, None)
         self.assertEqual(lv_swap.exists, True)
         with self.assertRaises(ValueError):
@@ -236,7 +236,7 @@ def testActionCreation(self):
 
         # instantiation of format destroy action for device causes device's
         # format attribute to be a DeviceFormat instance
-        lv_swap = self.storage.devicetree.getDeviceByName("VolGroup-lv_swap")
+        lv_swap = self.storage.devicetree.get_device_by_name("VolGroup-lv_swap")
         self.assertNotEqual(lv_swap, None)
         orig_format = lv_swap.format
         self.assertEqual(lv_swap.format.type, "swap")
@@ -247,39 +247,39 @@ def testActionCreation(self):
 
         # instantiation of format create action for device causes new format
         # to be accessible via device's format attribute
-        new_format = getFormat("vfat", device=lv_swap.path)
+        new_format = get_format("vfat", device=lv_swap.path)
         create_swap = ActionCreateFormat(lv_swap, new_format)
         self.assertEqual(lv_swap.format.type, None)
         create_swap.apply()
         self.assertEqual(lv_swap.format, new_format)
         lv_swap.format = orig_format
 
-    def testActionRegistration(self):
+    def test_action_registration(self):
         """ Verify correct operation of action registration and cancelling. """
         # self.setUp has just been run, so we should have something like
         # a preexisting autopart config in the devicetree.
 
         # registering a destroy action for a non-leaf device should fail
-        vg = self.storage.devicetree.getDeviceByName("VolGroup")
+        vg = self.storage.devicetree.get_device_by_name("VolGroup")
         self.assertNotEqual(vg, None)
         self.assertEqual(vg.isleaf, False)
         a = ActionDestroyDevice(vg)
         with self.assertRaises(ValueError):
-            self.storage.devicetree.registerAction(a)
+            self.storage.devicetree.register_action(a)
 
         # registering any action other than create for a device that's not in
         # the devicetree should fail
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
         self.assertNotEqual(sdc, None)
-        sdc1 = self.newDevice(device_class=PartitionDevice,
+        sdc1 = self.new_device(device_class=PartitionDevice,
                               name="sdc1", size=Size("100 GiB"),
                               parents=[sdc], exists=True)
 
-        sdc1_format = self.newFormat("ext2", device=sdc1.path, mountpoint="/")
+        sdc1_format = self.new_format("ext2", device=sdc1.path, mountpoint="/")
         create_sdc1_format = ActionCreateFormat(sdc1, sdc1_format)
         create_sdc1_format.apply()
         with self.assertRaises(blivet.errors.DeviceTreeError):
-            self.storage.devicetree.registerAction(create_sdc1_format)
+            self.storage.devicetree.register_action(create_sdc1_format)
 
         sdc1_format.exists = True
         sdc1_format._resizable = True
@@ -287,56 +287,56 @@ def testActionRegistration(self):
                                                 sdc1.size - Size("10 GiB"))
         resize_sdc1_format.apply()
         with self.assertRaises(blivet.errors.DeviceTreeError):
-            self.storage.devicetree.registerAction(resize_sdc1_format)
+            self.storage.devicetree.register_action(resize_sdc1_format)
 
         resize_sdc1 = ActionResizeDevice(sdc1, sdc1.size - Size("10 GiB"))
         resize_sdc1.apply()
         with self.assertRaises(blivet.errors.DeviceTreeError):
-            self.storage.devicetree.registerAction(resize_sdc1)
+            self.storage.devicetree.register_action(resize_sdc1)
 
         resize_sdc1.cancel()
         resize_sdc1_format.cancel()
 
         destroy_sdc1_format = ActionDestroyFormat(sdc1)
         with self.assertRaises(blivet.errors.DeviceTreeError):
-            self.storage.devicetree.registerAction(destroy_sdc1_format)
+            self.storage.devicetree.register_action(destroy_sdc1_format)
 
 
         destroy_sdc1 = ActionDestroyDevice(sdc1)
         with self.assertRaises(blivet.errors.DeviceTreeError):
-            self.storage.devicetree.registerAction(destroy_sdc1)
+            self.storage.devicetree.register_action(destroy_sdc1)
 
         # registering a device destroy action should cause the device to be
         # removed from the devicetree
-        lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root")
+        lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
         self.assertNotEqual(lv_root, None)
         a = ActionDestroyDevice(lv_root)
-        self.storage.devicetree.registerAction(a)
-        lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root")
+        self.storage.devicetree.register_action(a)
+        lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
         self.assertEqual(lv_root, None)
-        self.storage.devicetree.cancelAction(a)
+        self.storage.devicetree.cancel_action(a)
 
         # registering a device create action should cause the device to be
         # added to the devicetree
-        sdd = self.storage.devicetree.getDeviceByName("sdd")
+        sdd = self.storage.devicetree.get_device_by_name("sdd")
         self.assertNotEqual(sdd, None)
-        sdd1 = self.storage.devicetree.getDeviceByName("sdd1")
+        sdd1 = self.storage.devicetree.get_device_by_name("sdd1")
         self.assertEqual(sdd1, None)
-        sdd1 = self.newDevice(device_class=PartitionDevice,
+        sdd1 = self.new_device(device_class=PartitionDevice,
                               name="sdd1", size=Size("100 GiB"),
                               parents=[sdd])
         a = ActionCreateDevice(sdd1)
-        self.storage.devicetree.registerAction(a)
-        sdd1 = self.storage.devicetree.getDeviceByName("sdd1")
+        self.storage.devicetree.register_action(a)
+        sdd1 = self.storage.devicetree.get_device_by_name("sdd1")
         self.assertNotEqual(sdd1, None)
 
-    def testActionObsoletes(self):
+    def test_action_obsoletes(self):
         """ Verify correct operation of DeviceAction.obsoletes. """
-        self.destroyAllDevices(disks=["sdc"])
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
+        self.destroy_all_devices(disks=["sdc"])
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
         self.assertNotEqual(sdc, None)
 
-        sdc1 = self.newDevice(device_class=PartitionDevice,
+        sdc1 = self.new_device(device_class=PartitionDevice,
                               name="sdc1", parents=[sdc], size=Size("40 GiB"))
 
         # ActionCreateDevice
@@ -354,8 +354,8 @@ def testActionObsoletes(self):
         #
         # - obsoletes other ActionCreateFormat instances w/ lower id and same
         #   device
-        format_1 = self.newFormat("ext3", mountpoint="/home", device=sdc1.path)
-        format_2 = self.newFormat("ext3", mountpoint="/opt", device=sdc1.path)
+        format_1 = self.new_format("ext3", mountpoint="/home", device=sdc1.path)
+        format_2 = self.new_format("ext3", mountpoint="/opt", device=sdc1.path)
         create_format_1 = ActionCreateFormat(sdc1, format_1)
         create_format_1.apply()
         create_format_2 = ActionCreateFormat(sdc1, format_2)
@@ -382,7 +382,7 @@ def testActionObsoletes(self):
         # ActionCreateFormat
         #
         # - obsoletes resize format actions w/ lower id on same device
-        new_format = self.newFormat("ext4", mountpoint="/foo", device=sdc1.path)
+        new_format = self.new_format("ext4", mountpoint="/foo", device=sdc1.path)
         create_format_3 = ActionCreateFormat(sdc1, new_format)
         create_format_3.apply()
         self.assertEqual(create_format_3.obsoletes(resize_format_1), True)
@@ -438,7 +438,7 @@ def testActionObsoletes(self):
         # - obsoletes all but ActionDestroyFormat actions w/ lower id on the
         #   same existing device
         # sda1 exists
-        sda1 = self.storage.devicetree.getDeviceByName("sda1")
+        sda1 = self.storage.devicetree.get_device_by_name("sda1")
         self.assertNotEqual(sda1, None)
         #sda1.format._resizable = True
         resize_sda1_format = ActionResizeFormat(sda1,
@@ -455,79 +455,79 @@ def testActionObsoletes(self):
         self.assertEqual(destroy_sda1.obsoletes(destroy_sda1), False)
         self.assertEqual(destroy_sda1.obsoletes(destroy_sda1_format), False)
 
-    def testActionPruning(self):
+    def test_action_pruning(self):
         """ Verify correct functioning of action pruning. """
-        self.destroyAllDevices()
+        self.destroy_all_devices()
 
-        sda = self.storage.devicetree.getDeviceByName("sda")
+        sda = self.storage.devicetree.get_device_by_name("sda")
         self.assertNotEqual(sda, None, "failed to find disk 'sda'")
 
-        sda1 = self.newDevice(device_class=PartitionDevice,
+        sda1 = self.new_device(device_class=PartitionDevice,
                               name="sda1", size=Size("500 MiB"),
                               parents=[sda])
-        self.scheduleCreateDevice(sda1)
+        self.schedule_create_device(sda1)
 
-        sda2 = self.newDevice(device_class=PartitionDevice,
+        sda2 = self.new_device(device_class=PartitionDevice,
                               name="sda2", size=Size("100 GiB"),
                               parents=[sda])
-        self.scheduleCreateDevice(sda2)
-        fmt = self.newFormat("lvmpv", device=sda2.path)
-        self.scheduleCreateFormat(device=sda2, fmt=fmt)
+        self.schedule_create_device(sda2)
+        fmt = self.new_format("lvmpv", device=sda2.path)
+        self.schedule_create_format(device=sda2, fmt=fmt)
 
-        vg = self.newDevice(device_class=LVMVolumeGroupDevice,
+        vg = self.new_device(device_class=LVMVolumeGroupDevice,
                             name="vg", parents=[sda2])
-        self.scheduleCreateDevice(vg)
+        self.schedule_create_device(vg)
 
-        lv_root = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_root", parents=[vg],
                                  size=Size("60 GiB"))
-        self.scheduleCreateDevice(lv_root)
-        fmt = self.newFormat("ext4", device=lv_root.path, mountpoint="/")
-        self.scheduleCreateFormat(device=lv_root, fmt=fmt)
+        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.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_swap", parents=[vg],
                                  size=Size("4 GiB"))
-        self.scheduleCreateDevice(lv_swap)
-        fmt = self.newFormat("swap", device=lv_swap.path)
-        self.scheduleCreateFormat(device=lv_swap, fmt=fmt)
+        self.schedule_create_device(lv_swap)
+        fmt = self.new_format("swap", device=lv_swap.path)
+        self.schedule_create_format(device=lv_swap, fmt=fmt)
 
         # 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.newDevice(device_class=PartitionDevice,
+        sda3 = self.new_device(device_class=PartitionDevice,
                               name="sda3", parents=[sda],
                               size=Size("40 GiB"))
-        self.scheduleCreateDevice(sda3)
-        fmt = self.newFormat("mdmember", device=sda3.path)
-        self.scheduleCreateFormat(device=sda3, fmt=fmt)
+        self.schedule_create_device(sda3)
+        fmt = self.new_format("mdmember", device=sda3.path)
+        self.schedule_create_format(device=sda3, fmt=fmt)
 
-        sdb = self.storage.devicetree.getDeviceByName("sdb")
+        sdb = self.storage.devicetree.get_device_by_name("sdb")
         self.assertNotEqual(sdb, None, "failed to find disk 'sdb'")
 
-        sdb1 = self.newDevice(device_class=PartitionDevice,
+        sdb1 = self.new_device(device_class=PartitionDevice,
                               name="sdb1", parents=[sdb],
                               size=Size("40 GiB"))
-        self.scheduleCreateDevice(sdb1)
-        fmt = self.newFormat("mdmember", device=sdb1.path,)
-        self.scheduleCreateFormat(device=sdb1, fmt=fmt)
+        self.schedule_create_device(sdb1)
+        fmt = self.new_format("mdmember", device=sdb1.path,)
+        self.schedule_create_format(device=sdb1, fmt=fmt)
 
-        md0 = self.newDevice(device_class=MDRaidArrayDevice,
+        md0 = self.new_device(device_class=MDRaidArrayDevice,
                              name="md0", level="raid0", minor=0,
-                             memberDevices=2, totalDevices=2,
+                             member_devices=2, total_devices=2,
                              parents=[sdb1, sda3])
-        self.scheduleCreateDevice(md0)
+        self.schedule_create_device(md0)
 
-        fmt = self.newFormat("ext4", device=md0.path, mountpoint="/home")
-        self.scheduleCreateFormat(device=md0, fmt=fmt)
+        fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
+        self.schedule_create_format(device=md0, fmt=fmt)
 
         # now destroy the md and its components
-        self.scheduleDestroyFormat(md0)
-        self.scheduleDestroyDevice(md0)
-        self.scheduleDestroyDevice(sdb1)
-        self.scheduleDestroyDevice(sda3)
+        self.schedule_destroy_format(md0)
+        self.schedule_destroy_device(md0)
+        self.schedule_destroy_device(sdb1)
+        self.schedule_destroy_device(sda3)
 
-        fmt = self.newFormat("ext4", mountpoint="/boot", device=sda1.path)
-        self.scheduleCreateFormat(device=sda1, fmt=fmt)
+        fmt = self.new_format("ext4", mountpoint="/boot", device=sda1.path)
+        self.schedule_create_format(device=sda1, fmt=fmt)
 
         # verify the md actions are present prior to pruning
         md0_actions = self.storage.devicetree.actions.find(devid=md0.id)
@@ -551,15 +551,15 @@ def testActionPruning(self):
         sda3_actions = self.storage.devicetree.actions.find(sda3.id)
         self.assertEqual(len(sda3_actions), 0)
 
-    def testActionDependencies(self):
+    def test_action_dependencies(self):
         """ Verify correct functioning of action dependencies. """
         # ActionResizeDevice
         # an action that shrinks a device should require the action that
         # shrinks the device's format
-        lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root")
+        lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
         self.assertNotEqual(lv_root, None)
-        lv_root.format._minInstanceSize = Size("10 MiB")
-        lv_root.format._targetSize = lv_root.format._minInstanceSize
+        lv_root.format._min_instance_size = Size("10 MiB")
+        lv_root.format._target_size = lv_root.format._min_instance_size
         #lv_root.format._resizable = True
         shrink_format = ActionResizeFormat(lv_root,
                                            lv_root.size - Size("5 GiB"))
@@ -575,7 +575,7 @@ def testActionDependencies(self):
         # ActionResizeDevice
         # an action that grows a format should require the action that
         # grows the device
-        orig_size = lv_root.currentSize
+        orig_size = lv_root.current_size
         grow_device = ActionResizeDevice(lv_root,
                                          orig_size + Size("100 MiB"))
         grow_device.apply()
@@ -586,50 +586,50 @@ def testActionDependencies(self):
         self.assertEqual(grow_device.requires(grow_format), False)
 
         # create something like uncommitted autopart
-        self.destroyAllDevices()
-        sda = self.storage.devicetree.getDeviceByName("sda")
-        sdb = self.storage.devicetree.getDeviceByName("sdb")
-        sda1 = self.newDevice(device_class=PartitionDevice, name="sda1",
+        self.destroy_all_devices()
+        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])
-        sda1_format = self.newFormat("ext4", mountpoint="/boot",
+        sda1_format = self.new_format("ext4", mountpoint="/boot",
                                      device=sda1.path)
-        self.scheduleCreateDevice(sda1)
-        self.scheduleCreateFormat(device=sda1, fmt=sda1_format)
+        self.schedule_create_device(sda1)
+        self.schedule_create_format(device=sda1, fmt=sda1_format)
 
-        sda2 = self.newDevice(device_class=PartitionDevice, name="sda2",
+        sda2 = self.new_device(device_class=PartitionDevice, name="sda2",
                               size=Size("99.5 GiB"), parents=[sda])
-        sda2_format = self.newFormat("lvmpv", device=sda2.path)
-        self.scheduleCreateDevice(sda2)
-        self.scheduleCreateFormat(device=sda2, fmt=sda2_format)
+        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.newDevice(device_class=PartitionDevice, name="sdb1",
+        sdb1 = self.new_device(device_class=PartitionDevice, name="sdb1",
                               size=Size("100 GiB"), parents=[sdb])
-        sdb1_format = self.newFormat("lvmpv", device=sdb1.path)
-        self.scheduleCreateDevice(sdb1)
-        self.scheduleCreateFormat(device=sdb1, fmt=sdb1_format)
+        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.newDevice(device_class=LVMVolumeGroupDevice,
+        vg = self.new_device(device_class=LVMVolumeGroupDevice,
                             name="VolGroup", parents=[sda2, sdb1])
-        self.scheduleCreateDevice(vg)
+        self.schedule_create_device(vg)
 
-        lv_root = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_root", parents=[vg],
                                  size=Size("160 GiB"))
-        self.scheduleCreateDevice(lv_root)
-        fmt = self.newFormat("ext4", device=lv_root.path, mountpoint="/")
-        self.scheduleCreateFormat(device=lv_root, fmt=fmt)
+        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.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_swap", parents=[vg],
                                  size=Size("4 GiB"))
-        self.scheduleCreateDevice(lv_swap)
-        fmt = self.newFormat("swap", device=lv_swap.path)
-        self.scheduleCreateFormat(device=lv_swap, fmt=fmt)
+        self.schedule_create_device(lv_swap)
+        fmt = self.new_format("swap", device=lv_swap.path)
+        self.schedule_create_format(device=lv_swap, fmt=fmt)
 
         # ActionCreateDevice
         # creation of an LV should require the actions that create the VG,
         # its PVs, and the devices that contain the PVs
-        lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root")
+        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",
@@ -672,17 +672,17 @@ def testActionDependencies(self):
         # the higher numbered partition of two that are scheduled to be
         # created on a single disk should require the action that creates the
         # lower numbered of the two, eg: create sda2 before creating sda3
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
         self.assertNotEqual(sdc, None)
 
-        sdc1 = self.newDevice(device_class=PartitionDevice, name="sdc1",
+        sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
                               parents=[sdc], size=Size("50 GiB"))
-        create_sdc1 = self.scheduleCreateDevice(sdc1)
+        create_sdc1 = self.schedule_create_device(sdc1)
         self.assertEqual(isinstance(create_sdc1, ActionCreateDevice), True)
 
-        sdc2 = self.newDevice(device_class=PartitionDevice, name="sdc2",
+        sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
                               parents=[sdc], size=Size("50 GiB"))
-        create_sdc2 = self.scheduleCreateDevice(sdc2)
+        create_sdc2 = self.schedule_create_device(sdc2)
         self.assertEqual(isinstance(create_sdc2, ActionCreateDevice), True)
 
         self.assertEqual(create_sdc2.requires(create_sdc1), True)
@@ -691,7 +691,7 @@ def testActionDependencies(self):
         # ActionCreateDevice
         # actions that create partitions on two separate disks should not
         # require each other, regardless of the partitions' numbers
-        sda1 = self.storage.devicetree.getDeviceByName("sda1")
+        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",
@@ -706,36 +706,36 @@ def testActionDependencies(self):
         # an action that destroys a device containing an mdmember format
         # should require the action that destroys the md array it is a
         # member of if an array is defined
-        self.destroyAllDevices(disks=["sdc", "sdd"])
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
+        self.destroy_all_devices(disks=["sdc", "sdd"])
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
         self.assertNotEqual(sdc, None)
-        sdd = self.storage.devicetree.getDeviceByName("sdd")
+        sdd = self.storage.devicetree.get_device_by_name("sdd")
         self.assertNotEqual(sdd, None)
 
-        sdc1 = self.newDevice(device_class=PartitionDevice, name="sdc1",
+        sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
                               parents=[sdc], size=Size("40 GiB"))
-        self.scheduleCreateDevice(sdc1)
-        fmt = self.newFormat("mdmember", device=sdc1.path)
-        self.scheduleCreateFormat(device=sdc1, fmt=fmt)
+        self.schedule_create_device(sdc1)
+        fmt = self.new_format("mdmember", device=sdc1.path)
+        self.schedule_create_format(device=sdc1, fmt=fmt)
 
-        sdd1 = self.newDevice(device_class=PartitionDevice, name="sdd1",
+        sdd1 = self.new_device(device_class=PartitionDevice, name="sdd1",
                               parents=[sdd], size=Size("40 GiB"))
-        self.scheduleCreateDevice(sdd1)
-        fmt = self.newFormat("mdmember", device=sdd1.path,)
-        self.scheduleCreateFormat(device=sdd1, fmt=fmt)
+        self.schedule_create_device(sdd1)
+        fmt = self.new_format("mdmember", device=sdd1.path,)
+        self.schedule_create_format(device=sdd1, fmt=fmt)
 
-        md0 = self.newDevice(device_class=MDRaidArrayDevice,
+        md0 = self.new_device(device_class=MDRaidArrayDevice,
                              name="md0", level="raid0", minor=0,
-                             memberDevices=2, totalDevices=2,
+                             member_devices=2, total_devices=2,
                              parents=[sdc1, sdd1])
-        self.scheduleCreateDevice(md0)
-        fmt = self.newFormat("ext4", device=md0.path, mountpoint="/home")
-        self.scheduleCreateFormat(device=md0, fmt=fmt)
+        self.schedule_create_device(md0)
+        fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
+        self.schedule_create_format(device=md0, fmt=fmt)
 
-        destroy_md0_format = self.scheduleDestroyFormat(md0)
-        destroy_md0 = self.scheduleDestroyDevice(md0)
-        destroy_members = [self.scheduleDestroyDevice(sdc1)]
-        destroy_members.append(self.scheduleDestroyDevice(sdd1))
+        destroy_md0_format = self.schedule_destroy_format(md0)
+        destroy_md0 = self.schedule_destroy_device(md0)
+        destroy_members = [self.schedule_destroy_device(sdc1)]
+        destroy_members.append(self.schedule_destroy_device(sdd1))
 
         for member in destroy_members:
             # device and format destroy actions for md members should require
@@ -748,41 +748,41 @@ def testActionDependencies(self):
         # same disk, the action that will destroy the lower-numbered
         # partition should require the action that will destroy the higher-
         # numbered partition, eg: destroy sda2 before destroying sda1
-        self.destroyAllDevices(disks=["sdc", "sdd"])
-        sdc1 = self.newDevice(device_class=PartitionDevice, name="sdc1",
+        self.destroy_all_devices(disks=["sdc", "sdd"])
+        sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
                               parents=[sdc], size=Size("50 GiB"))
-        self.scheduleCreateDevice(sdc1)
+        self.schedule_create_device(sdc1)
 
-        sdc2 = self.newDevice(device_class=PartitionDevice, name="sdc2",
+        sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
                               parents=[sdc], size=Size("40 GiB"))
-        self.scheduleCreateDevice(sdc2)
+        self.schedule_create_device(sdc2)
 
-        destroy_sdc1 = self.scheduleDestroyDevice(sdc1)
-        destroy_sdc2 = self.scheduleDestroyDevice(sdc2)
+        destroy_sdc1 = self.schedule_destroy_device(sdc1)
+        destroy_sdc2 = self.schedule_destroy_device(sdc2)
         self.assertEqual(destroy_sdc1.requires(destroy_sdc2), True)
         self.assertEqual(destroy_sdc2.requires(destroy_sdc1), False)
 
-        self.destroyAllDevices(disks=["sdc", "sdd"])
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
+        self.destroy_all_devices(disks=["sdc", "sdd"])
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
         self.assertNotEqual(sdc, None)
-        sdd = self.storage.devicetree.getDeviceByName("sdd")
+        sdd = self.storage.devicetree.get_device_by_name("sdd")
         self.assertNotEqual(sdd, None)
 
-        sdc1 = self.newDevice(device_class=PartitionDevice, name="sdc1",
+        sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
                               parents=[sdc], size=Size("50 GiB"))
-        create_pv = self.scheduleCreateDevice(sdc1)
-        fmt = self.newFormat("lvmpv", device=sdc1.path)
-        create_pv_format = self.scheduleCreateFormat(device=sdc1, fmt=fmt)
+        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.newDevice(device_class=LVMVolumeGroupDevice,
+        testvg = self.new_device(device_class=LVMVolumeGroupDevice,
                                 name="testvg", parents=[sdc1])
-        create_vg = self.scheduleCreateDevice(testvg)
-        testlv = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        create_vg = self.schedule_create_device(testvg)
+        testlv = self.new_device(device_class=LVMLogicalVolumeDevice,
                                 name="testlv", parents=[testvg],
                                 size=Size("30 GiB"))
-        create_lv = self.scheduleCreateDevice(testlv)
-        fmt = self.newFormat("ext4", device=testlv.path)
-        create_lv_format = self.scheduleCreateFormat(device=testlv, fmt=fmt)
+        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)
 
         # ActionCreateFormat
         # creation of a format on a non-existent device should require the
@@ -802,19 +802,19 @@ def testActionDependencies(self):
 
         # XXX from here on, the devices are existing but not in the tree, so
         #     we instantiate and use actions directly
-        self.destroyAllDevices(disks=["sdc", "sdd"])
-        sdc1 = self.newDevice(device_class=PartitionDevice, exists=True,
+        self.destroy_all_devices(disks=["sdc", "sdd"])
+        sdc1 = self.new_device(device_class=PartitionDevice, exists=True,
                               name="sdc1", parents=[sdc],
                               size=Size("50 GiB"))
-        sdc1.format = self.newFormat("lvmpv", device=sdc1.path, exists=True,
+        sdc1.format = self.new_format("lvmpv", device=sdc1.path, exists=True,
                                      device_instance=sdc1)
-        testvg = self.newDevice(device_class=LVMVolumeGroupDevice, exists=True,
+        testvg = self.new_device(device_class=LVMVolumeGroupDevice, exists=True,
                                 name="testvg", parents=[sdc1],
                                 size=Size("50 GiB"))
-        testlv = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        testlv = self.new_device(device_class=LVMLogicalVolumeDevice,
                                 exists=True, size=Size("30 GiB"),
                                 name="testlv", parents=[testvg])
-        testlv.format = self.newFormat("ext4", device=testlv.path,
+        testlv.format = self.new_format("ext4", device=testlv.path,
                                        exists=True, device_instance=testlv)
 
         # ActionResizeDevice
@@ -870,8 +870,8 @@ def testActionDependencies(self):
         # an action that resizes a device should require an action that
         # shrinks a device that depends on the first action's device, eg:
         # shrink LV before resizing VG or PV devices
-        testlv.format._minInstanceSize = Size("10 MiB")
-        testlv.format._targetSize = testlv.format._minInstanceSize
+        testlv.format._min_instance_size = Size("10 MiB")
+        testlv.format._target_size = testlv.format._min_instance_size
         shrink_lv = ActionResizeDevice(testlv,
                                        testlv.size - Size("10 GiB"))
         shrink_lv.apply()
@@ -924,7 +924,7 @@ def testActionDependencies(self):
         # an action that creates a format on a device should require an action
         # that resizes the device that will contain the format
         grow_lv = ActionResizeDevice(testlv, testlv.size + Size("1 GiB"))
-        fmt = self.newFormat("disklabel", device=testlv.path)
+        fmt = self.new_format("disklabel", device=testlv.path)
         format_lv = ActionCreateFormat(testlv, fmt)
         self.assertEqual(format_lv.requires(grow_lv), True)
         self.assertEqual(grow_lv.requires(format_lv), False)
@@ -945,9 +945,9 @@ def testActionDependencies(self):
         self.assertEqual(destroy_pv_format.requires(destroy_lv_format), True)
         self.assertEqual(destroy_lv_format.requires(destroy_pv_format), False)
 
-        sdc2 = self.newDevice(device_class=PartitionDevice, name="sdc2",
+        sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
                               size=Size("5 GiB"), parents=[sdc])
-        create_sdc2 = self.scheduleCreateDevice(sdc2)
+        create_sdc2 = self.schedule_create_device(sdc2)
 
         # create actions should always require destroy actions -- even for
         # unrelated devices -- since, after pruning, it should always be the
@@ -958,14 +958,14 @@ def testActionDependencies(self):
         # similarly, create actions should also require resize actions
         self.assertEqual(create_sdc2.requires(grow_lv), True)
 
-    def testActionApplyCancel(self):
-        lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root")
+    def test_action_apply_cancel(self):
+        lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
 
         # ActionResizeFormat
-        lv_root.format._minInstanceSize = Size("10 MiB")
+        lv_root.format._min_instance_size = Size("10 MiB")
         lv_root.format._size = lv_root.size
-        lv_root.format._targetSize = lv_root.size
-        original_format_size = lv_root.format.currentSize
+        lv_root.format._target_size = lv_root.size
+        original_format_size = lv_root.format.current_size
         target_size = lv_root.size - Size("1 GiB")
         #lv_root.format._resizable = True
         action = ActionResizeFormat(lv_root, target_size)
@@ -976,7 +976,7 @@ def testActionApplyCancel(self):
         self.assertEqual(lv_root.format.size, original_format_size)
 
         # ActionResizeDevice
-        original_device_size = lv_root.currentSize
+        original_device_size = lv_root.current_size
         action = ActionResizeDevice(lv_root, target_size)
         self.assertEqual(lv_root.size, original_device_size)
         action.apply()
@@ -995,11 +995,11 @@ def testActionApplyCancel(self):
         self.assertEqual(lv_root.format, original_format)
 
 
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
         sdc.format = None
-        pv_fmt = self.newFormat("lvmpv", device_instance=sdc, device=sdc.path)
-        self.scheduleCreateFormat(device=sdc, fmt=pv_fmt)
-        vg = self.storage.devicetree.getDeviceByName("VolGroup")
+        pv_fmt = self.new_format("lvmpv", device_instance=sdc, device=sdc.path)
+        self.schedule_create_format(device=sdc, fmt=pv_fmt)
+        vg = self.storage.devicetree.get_device_by_name("VolGroup")
         original_pvs = vg.parents[:]
 
         # ActionAddMember
@@ -1018,7 +1018,7 @@ def testActionApplyCancel(self):
 
         # ActionRemoveMember
         pvs = original_pvs[:]
-        sdb1 = self.storage.devicetree.getDeviceByName("sdb1")
+        sdb1 = self.storage.devicetree.get_device_by_name("sdb1")
         action = ActionRemoveMember(vg, sdb1)
         self.assertEqual(list(vg.parents), original_pvs)
         action.apply()
@@ -1027,64 +1027,64 @@ def testActionApplyCancel(self):
         action.cancel()
         self.assertEqual(list(vg.parents), original_pvs)
 
-    def testContainerActions(self):
-        self.destroyAllDevices()
-        sda = self.storage.devicetree.getDeviceByName("sda")
-        sdb = self.storage.devicetree.getDeviceByName("sdb")
+    def test_container_actions(self):
+        self.destroy_all_devices()
+        sda = self.storage.devicetree.get_device_by_name("sda")
+        sdb = self.storage.devicetree.get_device_by_name("sdb")
 
         #
         # create something like an existing lvm autopart layout across two disks
         #
-        sda1 = self.newDevice(device_class=PartitionDevice,
+        sda1 = self.new_device(device_class=PartitionDevice,
                               exists=True, name="sda1", parents=[sda],
                               size=Size("500 MiB"))
-        sda1.format = self.newFormat("ext4", mountpoint="/boot",
+        sda1.format = self.new_format("ext4", mountpoint="/boot",
                                      device_instance=sda1,
                                      device=sda1.path, exists=True)
-        self.storage.devicetree._addDevice(sda1)
+        self.storage.devicetree._add_device(sda1)
 
-        sda2 = self.newDevice(device_class=PartitionDevice,
+        sda2 = self.new_device(device_class=PartitionDevice,
                               size=Size("99.5 GiB"), name="sda2",
                               parents=[sda], exists=True)
-        sda2.format = self.newFormat("lvmpv", device=sda2.path, exists=True)
-        self.storage.devicetree._addDevice(sda2)
+        sda2.format = self.new_format("lvmpv", device=sda2.path, exists=True)
+        self.storage.devicetree._add_device(sda2)
 
-        sdb1 = self.newDevice(device_class=PartitionDevice,
+        sdb1 = self.new_device(device_class=PartitionDevice,
                               size=Size("99.999 GiB"), name="sdb1",
                               parents=[sdb], exists=True)
-        sdb1.format = self.newFormat("lvmpv", device=sdb1.path, exists=True)
-        self.storage.devicetree._addDevice(sdb1)
+        sdb1.format = self.new_format("lvmpv", device=sdb1.path, exists=True)
+        self.storage.devicetree._add_device(sdb1)
 
-        vg = self.newDevice(device_class=LVMVolumeGroupDevice,
+        vg = self.new_device(device_class=LVMVolumeGroupDevice,
                             name="VolGroup", parents=[sda2, sdb1],
                             exists=True)
-        self.storage.devicetree._addDevice(vg)
+        self.storage.devicetree._add_device(vg)
 
-        lv_root = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_root", parents=[vg],
                                  size=Size("160 GiB"), exists=True)
-        lv_root.format = self.newFormat("ext4", mountpoint="/",
+        lv_root.format = self.new_format("ext4", mountpoint="/",
                                         device_instance=lv_root,
                                         device=lv_root.path, exists=True)
-        self.storage.devicetree._addDevice(lv_root)
+        self.storage.devicetree._add_device(lv_root)
 
-        lv_swap = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
                                  name="lv_swap", parents=[vg],
                                  size=Size("4000 MiB"), exists=True)
-        lv_swap.format = self.newFormat("swap", device=lv_swap.path,
+        lv_swap.format = self.new_format("swap", device=lv_swap.path,
                                         device_instance=lv_swap,
                                         exists=True)
-        self.storage.devicetree._addDevice(lv_swap)
+        self.storage.devicetree._add_device(lv_swap)
 
         #
         # test some modifications to the VG
         #
-        sdc = self.storage.devicetree.getDeviceByName("sdc")
-        sdc1 = self.newDevice(device_class=PartitionDevice, name="sdc1",
+        sdc = self.storage.devicetree.get_device_by_name("sdc")
+        sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
                               size=Size("50 GiB"), parents=[sdc])
-        sdc1_format = self.newFormat("lvmpv", device=sdc1.path)
-        create_sdc1 = self.scheduleCreateDevice(sdc1)
-        create_sdc1_format = self.scheduleCreateFormat(device=sdc1,
+        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)
 
         self.assertEqual(len(vg.parents), 2)
@@ -1097,19 +1097,19 @@ def testContainerActions(self):
         self.assertEqual(add_sdc1.requires(create_sdc1), True)
         self.assertEqual(add_sdc1.requires(create_sdc1_format), True)
 
-        new_lv = self.newDevice(device_class=LVMLogicalVolumeDevice,
+        new_lv = self.new_device(device_class=LVMLogicalVolumeDevice,
                                 name="newlv", parents=[vg],
                                 size=Size("20 GiB"))
-        create_new_lv = self.scheduleCreateDevice(new_lv)
-        new_lv_format = self.newFormat("xfs", device=new_lv.path)
-        create_new_lv_format = self.scheduleCreateFormat(device=new_lv,
+        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)
 
         self.assertEqual(create_new_lv.requires(add_sdc1), True)
         self.assertEqual(create_new_lv_format.requires(add_sdc1), False)
 
-        self.storage.devicetree.cancelAction(create_new_lv_format)
-        self.storage.devicetree.cancelAction(create_new_lv)
+        self.storage.devicetree.cancel_action(create_new_lv_format)
+        self.storage.devicetree.cancel_action(create_new_lv)
 
         remove_sdb1 = ActionRemoveMember(vg, sdb1)
         self.assertEqual(len(vg.parents), 3)
@@ -1135,14 +1135,14 @@ def testContainerActions(self):
         self.assertEqual(add_sdb1.obsoletes(remove_sdb1), True)
         self.assertEqual(remove_sdb1.obsoletes(add_sdb1), True)
 
-        sdc2 = self.newDevice(device_class=PartitionDevice, name="sdc2",
+        sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
                               size=Size("5 GiB"), parents=[sdc])
-        create_sdc2 = self.scheduleCreateDevice(sdc2)
+        create_sdc2 = self.schedule_create_device(sdc2)
 
         # destroy/resize/create sequencing does not apply to container actions
         self.assertEqual(create_sdc2.requires(remove_sdc1), False)
         self.assertEqual(remove_sdc1.requires(create_sdc2), False)
 
-    def testActionSorting(self, *args, **kwargs):
+    def test_action_sorting(self, *args, **kwargs):
         """ Verify correct functioning of action sorting. """
         pass
diff --git a/tests/clearpart_test.py b/tests/clearpart_test.py
index de10186..ae96577 100644
--- a/tests/clearpart_test.py
+++ b/tests/clearpart_test.py
@@ -11,13 +11,13 @@
     blivet.devices.PartitionDevice
 ]
 
- at unittest.skipUnless(not any(x.unavailableTypeDependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test")
+ at unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test")
 class ClearPartTestCase(unittest.TestCase):
     def setUp(self):
         flags.testing = True
 
-    def testShouldClear(self):
-        """ Test the Blivet.shouldClear method. """
+    def test_should_clear(self):
+        """ Test the Blivet.should_clear method. """
         b = blivet.Blivet()
 
         DiskDevice = blivet.devices.DiskDevice
@@ -25,127 +25,127 @@ def testShouldClear(self):
 
         # sda is a disk with an existing disklabel containing two partitions
         sda = DiskDevice("sda", size=100000, exists=True)
-        sda.format = blivet.formats.getFormat("disklabel", device=sda.path,
+        sda.format = blivet.formats.get_format("disklabel", device=sda.path,
                                               exists=True)
-        sda.format._partedDisk = mock.Mock()
-        sda.format._partedDevice = mock.Mock()
-        sda.format._partedDisk.configure_mock(partitions=[])
-        b.devicetree._addDevice(sda)
+        sda.format._parted_disk = mock.Mock()
+        sda.format._parted_device = mock.Mock()
+        sda.format._parted_disk.configure_mock(partitions=[])
+        b.devicetree._add_device(sda)
 
         # sda1 is a partition containing an existing ext4 filesystem
         sda1 = PartitionDevice("sda1", size=500, exists=True,
                                parents=[sda])
-        sda1._partedPartition = mock.Mock(**{'type': PARTITION_NORMAL,
+        sda1._parted_partition = mock.Mock(**{'type': PARTITION_NORMAL,
                                              'getFlag.return_value': 0})
-        sda1.format = blivet.formats.getFormat("ext4", mountpoint="/boot",
+        sda1.format = blivet.formats.get_format("ext4", mountpoint="/boot",
                                                device=sda1.path,
                                                exists=True)
-        b.devicetree._addDevice(sda1)
+        b.devicetree._add_device(sda1)
 
         # sda2 is a partition containing an existing vfat filesystem
         sda2 = PartitionDevice("sda2", size=10000, exists=True,
                                parents=[sda])
-        sda2._partedPartition = mock.Mock(**{'type': PARTITION_NORMAL,
+        sda2._parted_partition = mock.Mock(**{'type': PARTITION_NORMAL,
                                              'getFlag.return_value': 0})
-        sda2.format = blivet.formats.getFormat("vfat", mountpoint="/foo",
+        sda2.format = blivet.formats.get_format("vfat", mountpoint="/foo",
                                                device=sda2.path,
                                                exists=True)
-        b.devicetree._addDevice(sda2)
+        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.getFormat("xfs", device=sdb.path,
+        sdb.format = blivet.formats.get_format("xfs", device=sdb.path,
                                               exists=True)
-        b.devicetree._addDevice(sdb)
+        b.devicetree._add_device(sdb)
 
         # sdc is an unformatted/uninitialized/empty disk
         sdc = DiskDevice("sdc", size=100000, exists=True)
-        b.devicetree._addDevice(sdc)
+        b.devicetree._add_device(sdc)
 
         # sdd is a disk containing an existing disklabel with no partitions
         sdd = DiskDevice("sdd", size=100000, exists=True)
-        sdd.format = blivet.formats.getFormat("disklabel", device=sdd.path,
+        sdd.format = blivet.formats.get_format("disklabel", device=sdd.path,
                                               exists=True)
-        b.devicetree._addDevice(sdd)
+        b.devicetree._add_device(sdd)
 
         #
         # clearpart type none
         #
-        b.config.clearPartType = CLEARPART_TYPE_NONE
-        self.assertFalse(b.shouldClear(sda1),
+        b.config.clear_part_type = CLEARPART_TYPE_NONE
+        self.assertFalse(b.should_clear(sda1),
                          msg="type none should not clear any partitions")
-        self.assertFalse(b.shouldClear(sda2),
+        self.assertFalse(b.should_clear(sda2),
                          msg="type none should not clear any partitions")
 
-        b.config.initializeDisks = False
-        self.assertFalse(b.shouldClear(sda),
+        b.config.initialize_disks = False
+        self.assertFalse(b.should_clear(sda),
                          msg="type none should not clear non-empty disks")
-        self.assertFalse(b.shouldClear(sdb),
+        self.assertFalse(b.should_clear(sdb),
                          msg="type none should not clear formatting from "
                              "unpartitioned disks")
 
-        self.assertFalse(b.shouldClear(sdc),
+        self.assertFalse(b.should_clear(sdc),
                          msg="type none should not clear empty disk without "
                              "initlabel")
-        self.assertFalse(b.shouldClear(sdd),
+        self.assertFalse(b.should_clear(sdd),
                          msg="type none should not clear empty partition table "
                              "without initlabel")
 
-        b.config.initializeDisks = True
-        self.assertFalse(b.shouldClear(sda),
+        b.config.initialize_disks = True
+        self.assertFalse(b.should_clear(sda),
                          msg="type none should not clear non-empty disks even "
                              "with initlabel")
-        self.assertFalse(b.shouldClear(sdb),
+        self.assertFalse(b.should_clear(sdb),
                          msg="type non should not clear formatting from "
                              "unpartitioned disks even with initlabel")
-        self.assertTrue(b.shouldClear(sdc),
+        self.assertTrue(b.should_clear(sdc),
                         msg="type none should clear empty disks when initlabel "
                             "is set")
-        self.assertTrue(b.shouldClear(sdd),
+        self.assertTrue(b.should_clear(sdd),
                         msg="type none should clear empty partition table when "
                             "initlabel is set")
 
         #
         # clearpart type linux
         #
-        b.config.clearPartType = CLEARPART_TYPE_LINUX
-        self.assertTrue(b.shouldClear(sda1),
+        b.config.clear_part_type = CLEARPART_TYPE_LINUX
+        self.assertTrue(b.should_clear(sda1),
                         msg="type linux should clear partitions containing "
                             "ext4 filesystems")
-        self.assertFalse(b.shouldClear(sda2),
+        self.assertFalse(b.should_clear(sda2),
                          msg="type linux should not clear partitions "
                              "containing vfat filesystems")
 
-        b.config.initializeDisks = False
-        self.assertFalse(b.shouldClear(sda),
+        b.config.initialize_disks = False
+        self.assertFalse(b.should_clear(sda),
                          msg="type linux should not clear non-empty disklabels")
-        self.assertTrue(b.shouldClear(sdb),
+        self.assertTrue(b.should_clear(sdb),
                         msg="type linux should clear linux-native whole-disk "
                             "formatting regardless of initlabel setting")
-        self.assertFalse(b.shouldClear(sdc),
+        self.assertFalse(b.should_clear(sdc),
                          msg="type linux should not clear unformatted disks "
                              "unless initlabel is set")
-        self.assertFalse(b.shouldClear(sdd),
+        self.assertFalse(b.should_clear(sdd),
                          msg="type linux should not clear disks with empty "
                              "partition tables unless initlabel is set")
 
-        b.config.initializeDisks = True
-        self.assertFalse(b.shouldClear(sda),
+        b.config.initialize_disks = True
+        self.assertFalse(b.should_clear(sda),
                          msg="type linux should not clear non-empty disklabels")
-        self.assertTrue(b.shouldClear(sdb),
+        self.assertTrue(b.should_clear(sdb),
                         msg="type linux should clear linux-native whole-disk "
                             "formatting regardless of initlabel setting")
-        self.assertTrue(b.shouldClear(sdc),
+        self.assertTrue(b.should_clear(sdc),
                          msg="type linux should clear unformatted disks when "
                              "initlabel is set")
-        self.assertTrue(b.shouldClear(sdd),
+        self.assertTrue(b.should_clear(sdd),
                          msg="type linux should clear disks with empty "
                              "partition tables when initlabel is set")
 
         sda1.protected = True
-        self.assertFalse(b.shouldClear(sda1),
+        self.assertFalse(b.should_clear(sda1),
                          msg="protected devices should never be cleared")
-        self.assertFalse(b.shouldClear(sda),
+        self.assertFalse(b.should_clear(sda),
                          msg="disks containing protected devices should never "
                              "be cleared")
         sda1.protected = False
@@ -153,36 +153,36 @@ def testShouldClear(self):
         #
         # clearpart type all
         #
-        b.config.clearPartType = CLEARPART_TYPE_ALL
-        self.assertTrue(b.shouldClear(sda1),
+        b.config.clear_part_type = CLEARPART_TYPE_ALL
+        self.assertTrue(b.should_clear(sda1),
                         msg="type all should clear all partitions")
-        self.assertTrue(b.shouldClear(sda2),
+        self.assertTrue(b.should_clear(sda2),
                         msg="type all should clear all partitions")
 
-        b.config.initializeDisks = False
-        self.assertTrue(b.shouldClear(sda),
+        b.config.initialize_disks = False
+        self.assertTrue(b.should_clear(sda),
                         msg="type all should initialize all disks")
-        self.assertTrue(b.shouldClear(sdb),
+        self.assertTrue(b.should_clear(sdb),
                         msg="type all should initialize all disks")
-        self.assertTrue(b.shouldClear(sdc),
+        self.assertTrue(b.should_clear(sdc),
                         msg="type all should initialize all disks")
-        self.assertTrue(b.shouldClear(sdd),
+        self.assertTrue(b.should_clear(sdd),
                         msg="type all should initialize all disks")
 
-        b.config.initializeDisks = True
-        self.assertTrue(b.shouldClear(sda),
+        b.config.initialize_disks = True
+        self.assertTrue(b.should_clear(sda),
                         msg="type all should initialize all disks")
-        self.assertTrue(b.shouldClear(sdb),
+        self.assertTrue(b.should_clear(sdb),
                         msg="type all should initialize all disks")
-        self.assertTrue(b.shouldClear(sdc),
+        self.assertTrue(b.should_clear(sdc),
                         msg="type all should initialize all disks")
-        self.assertTrue(b.shouldClear(sdd),
+        self.assertTrue(b.should_clear(sdd),
                         msg="type all should initialize all disks")
 
         sda1.protected = True
-        self.assertFalse(b.shouldClear(sda1),
+        self.assertFalse(b.should_clear(sda1),
                          msg="protected devices should never be cleared")
-        self.assertFalse(b.shouldClear(sda),
+        self.assertFalse(b.should_clear(sda),
                          msg="disks containing protected devices should never "
                              "be cleared")
         sda1.protected = False
@@ -195,14 +195,14 @@ def testShouldClear(self):
     def tearDown(self):
         flags.testing = False
 
-    def testInitializeDisk(self):
+    def test_initialize_disk(self):
         """
             magic partitions
             non-empty partition table
         """
         pass
 
-    def testRecursiveRemove(self):
+    def test_recursive_remove(self):
         """
             protected device at various points in stack
         """
diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py
index 8c0dc16..c3f6e3a 100644
--- a/tests/devicefactory_test.py
+++ b/tests/devicefactory_test.py
@@ -15,7 +15,7 @@
 from blivet.devices import MDRaidArrayDevice
 from blivet.devices import PartitionDevice
 from blivet.errors import RaidError
-from blivet.formats import getFormat
+from blivet.formats import get_format
 from blivet.size import Size
 from blivet.util import create_sparse_tempfile
 
@@ -52,23 +52,23 @@ def setUp(self):
                            create_sparse_tempfile("factorytest", Size("1 GiB"))]
         for filename in self.disk_files:
             disk = DiskFile(filename)
-            self.b.devicetree._addDevice(disk)
-            self.b.initializeDisk(disk)
+            self.b.devicetree._add_device(disk)
+            self.b.initialize_disk(disk)
 
-        self.addCleanup(self._cleanUpDiskFiles)
+        self.addCleanup(self._clean_up_disk_files)
 
-    def _cleanUpDiskFiles(self):
+    def _clean_up_disk_files(self):
         for fn in self.disk_files:
             os.unlink(fn)
 
-    def _factoryDevice(self, *args, **kwargs):
+    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)
         factory.configure()
         return factory.device
 
-    def _validateFactoryDevice(self, *args, **kwargs):
+    def _validate_factory_device(self, *args, **kwargs):
         """ Validate the factory device against the factory args. """
         device = args[0]
         device_type = args[1]
@@ -92,9 +92,9 @@ def _validateFactoryDevice(self, *args, **kwargs):
                              kwargs.get('label'))
 
         self.assertLessEqual(device.size, size)
-        self.assertGreaterEqual(device.size, device.format.minSize)
-        if device.format.maxSize:
-            self.assertLessEqual(device.size, device.format.maxSize)
+        self.assertGreaterEqual(device.size, device.format.min_size)
+        if device.format.max_size:
+            self.assertLessEqual(device.size, device.format.max_size)
 
         self.assertEqual(device.encrypted,
                          kwargs.get("encrypted", False) or
@@ -102,23 +102,23 @@ def _validateFactoryDevice(self, *args, **kwargs):
 
         self.assertTrue(set(device.disks).issubset(kwargs["disks"]))
 
-    def testDeviceFactory(self):
+    def test_device_factory(self):
         device_type = self.device_type
         size = Size('400 MiB')
         kwargs = {"disks": self.b.disks,
                   "fstype": 'ext4',
                   "mountpoint": '/factorytest'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
-        self.b.recursiveRemove(device)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
+        self.b.recursive_remove(device)
 
         if self.encryption_supported:
             ## Encrypt the leaf device
             kwargs["encrypted"] = True
-            device = self._factoryDevice(device_type, size, **kwargs)
-            self._validateFactoryDevice(device, device_type, size, **kwargs)
+            device = self._factory_device(device_type, size, **kwargs)
+            self._validate_factory_device(device, device_type, size, **kwargs)
             for partition in self.b.partitions:
-                self.b.recursiveRemove(partition)
+                self.b.recursive_remove(partition)
 
         ##
         ## Reconfigure device
@@ -129,35 +129,35 @@ def testDeviceFactory(self):
         kwargs = {"disks": self.b.disks,
                   "fstype": 'ext4',
                   "mountpoint": '/factorytest'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         if self.encryption_supported:
             ## Encrypt the leaf device
             kwargs["encrypted"] = True
             kwargs["device"] = device
-            device = self._factoryDevice(device_type, size, **kwargs)
-            self._validateFactoryDevice(device, device_type, size, **kwargs)
+            device = self._factory_device(device_type, size, **kwargs)
+            self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## Change the mountpoint
         kwargs["mountpoint"] = "/a/different/dir"
         kwargs["device"] = device
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## Change the fstype and size.
         kwargs["fstype"] = "xfs"
         kwargs["device"] = device
         size = Size("650 MiB")
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
-    def _getTestFactoryArgs(self):
+    def _get_test_factory_args(self):
         """ Return kwarg dict of type-specific factory ctor args. """
         return dict()
 
     # pylint: disable=unused-argument
-    def _getSizeDelta(self, devices=None):
+    def _get_size_delta(self, devices=None):
         """ Return size delta for a specific factory type.
 
             :keyword devices: list of factory-managed devices or None
@@ -165,9 +165,9 @@ def _getSizeDelta(self, devices=None):
         """
         return Size("1 MiB")
 
-    def testGetFreeDiskSpace(self):
+    def test_get_free_disk_space(self):
         ## get_free_disk_space should return the total free space on disks
-        kwargs = self._getTestFactoryArgs()
+        kwargs = self._get_test_factory_args()
         size = Size("500 MiB")
         factory = devicefactory.get_device_factory(self.b,
                                                    self.device_type,
@@ -177,7 +177,7 @@ def testGetFreeDiskSpace(self):
         ## disks contain empty disklabels, so free space is sum of disk sizes
         self.assertAlmostEqual(factory._get_free_disk_space(),
                                sum(d.size for d in self.b.disks),
-                               delta=self._getSizeDelta())
+                               delta=self._get_size_delta())
 
         factory.configure()
         device = factory.device
@@ -192,17 +192,17 @@ def testGetFreeDiskSpace(self):
         ## metadata and space lost to partition alignment.
         self.assertAlmostEqual(factory._get_free_disk_space(),
                                sum(d.size for d in self.b.disks) - device_space,
-                               delta=self._getSizeDelta(devices=[device]))
+                               delta=self._get_size_delta(devices=[device]))
 
-    def testNormalizeSize(self):
+    def test_normalize_size(self):
         ## _normalize_size should adjust target size to within the format limits
         fstype = "ext2"
-        ext2 = getFormat(fstype)
-        self.assertTrue(ext2.maxSize > Size(0))
+        ext2 = get_format(fstype)
+        self.assertTrue(ext2.max_size > Size(0))
         size = Size("9 TiB")
-        self.assertTrue(size > ext2.maxSize)
+        self.assertTrue(size > ext2.max_size)
 
-        kwargs = self._getTestFactoryArgs()
+        kwargs = self._get_test_factory_args()
         factory = devicefactory.get_device_factory(self.b,
                                                    self.device_type,
                                                    size,
@@ -210,43 +210,43 @@ def testNormalizeSize(self):
                                                    fstype=fstype,
                                                    **kwargs)
         factory._normalize_size()
-        self.assertTrue(factory.size <= ext2.maxSize)
+        self.assertTrue(factory.size <= ext2.max_size)
 
         ## _normalize_size should convert a size of None to a reasonable guess
         ## at the largest possible size based on disk free space
         factory.size = None
         factory._normalize_size()
         self.assertIsInstance(factory.size, blivet.size.Size)
-        self.assertTrue(factory.size <= ext2.maxSize)
+        self.assertTrue(factory.size <= ext2.max_size)
         # Allow some variation in size for metadata, alignment, &c.
         self.assertAlmostEqual(factory.size, sum(d.size for d in self.b.disks),
-                               delta=self._getSizeDelta())
+                               delta=self._get_size_delta())
 
         ## _handle_no_size should also take into account any specified factory
         ## device, in case the factory is to be modifying a defined device
         # must be a couple MiB smaller than the disk to accommodate
         # PartitionFactory
         size = self.b.disks[0].size - Size("4 MiB")
-        device = self._factoryDevice(self.device_type, size,
+        device = self._factory_device(self.device_type, size,
                                      disks=self.b.disks, **kwargs)
-        self.assertAlmostEqual(device.size, size, delta=self._getSizeDelta())
+        self.assertAlmostEqual(device.size, size, delta=self._get_size_delta())
 
         factory.size = None
         factory.device = device
         factory._normalize_size()
         self.assertIsInstance(factory.size, blivet.size.Size)
-        self.assertTrue(factory.size <= ext2.maxSize)
+        self.assertTrue(factory.size <= ext2.max_size)
         ## factory size should be total disk space plus current device space
         # Allow some variation in size for metadata, alignment, &c.
         self.assertAlmostEqual(factory.size,
                                sum(d.size for d in self.b.disks),
-                               delta=self._getSizeDelta(devices=[device]))
+                               delta=self._get_size_delta(devices=[device]))
 
 class PartitionFactoryTestCase(DeviceFactoryTestCase):
     device_class = PartitionDevice
     device_type = devicefactory.DEVICE_TYPE_PARTITION
 
-    def testBug1178884(self):
+    def test_bug1178884(self):
         ## Test a change of format and size where old size is too large for the
         ## new format but not for the old one.
         device_type = self.device_type
@@ -254,15 +254,15 @@ def testBug1178884(self):
         kwargs = {"disks": self.b.disks,
                   "fstype": 'ext4',
                   "mountpoint": '/factorytest'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         kwargs["device"] = device
         kwargs["fstype"] = "prepboot"
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
-    def _getSizeDelta(self, devices=None):
+    def _get_size_delta(self, devices=None):
         delta = Size("2 MiB")
         if devices:
             delta += Size("2 MiB") * len(devices)
@@ -273,8 +273,8 @@ class LVMFactoryTestCase(DeviceFactoryTestCase):
     device_class = LVMLogicalVolumeDevice
     device_type = devicefactory.DEVICE_TYPE_LVM
 
-    def _validateFactoryDevice(self, *args, **kwargs):
-        super(LVMFactoryTestCase, self)._validateFactoryDevice(*args, **kwargs)
+    def _validate_factory_device(self, *args, **kwargs):
+        super(LVMFactoryTestCase, self)._validate_factory_device(*args, **kwargs)
 
         device = args[0]
 
@@ -297,8 +297,8 @@ def _validateFactoryDevice(self, *args, **kwargs):
             self.assertEqual(pv.encrypted, kwargs.get("container_encrypted", False))
             self.assertIsInstance(pv, member_class)
 
-    def testDeviceFactory(self):
-        super(LVMFactoryTestCase, self).testDeviceFactory()
+    def test_device_factory(self):
+        super(LVMFactoryTestCase, self).test_device_factory()
 
         ##
         ## New device
@@ -313,18 +313,18 @@ def testDeviceFactory(self):
             ## encrypt the PVs
             kwargs["encrypted"] = False
             kwargs["container_encrypted"] = True
-            device = self._factoryDevice(device_type, size, **kwargs)
-            self._validateFactoryDevice(device, device_type, size, **kwargs)
+            device = self._factory_device(device_type, size, **kwargs)
+            self._validate_factory_device(device, device_type, size, **kwargs)
             for partition in self.b.partitions:
-                self.b.recursiveRemove(partition)
+                self.b.recursive_remove(partition)
 
         ## Add mirroring of PV using MD
         kwargs["container_encrypted"] = False
         kwargs["container_raid_level"] = "raid1"
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
         for partition in self.b.partitions:
-            self.b.recursiveRemove(partition)
+            self.b.recursive_remove(partition)
 
         ##
         ## Reconfigure device
@@ -336,8 +336,8 @@ def testDeviceFactory(self):
         kwargs = {"disks": self.b.disks,
                   "fstype": 'ext4',
                   "mountpoint": '/factorytest'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         if self.encryption_supported:
             ## Encrypt the LV
@@ -346,37 +346,37 @@ def testDeviceFactory(self):
             # members in the next test.
             kwargs["encrypted"] = True
             kwargs["device"] = device
-            device = self._factoryDevice(device_type, size, **kwargs)
-            self._validateFactoryDevice(device, device_type, size, **kwargs)
+            device = self._factory_device(device_type, size, **kwargs)
+            self._validate_factory_device(device, device_type, size, **kwargs)
 
             ## Decrypt the LV, but encrypt the PVs
             kwargs["encrypted"] = False
             kwargs["container_encrypted"] = True
             kwargs["device"] = device
-            device = self._factoryDevice(device_type, size, **kwargs)
-            self._validateFactoryDevice(device, device_type, size, **kwargs)
+            device = self._factory_device(device_type, size, **kwargs)
+            self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## Switch to an encrypted raid0 md pv
         kwargs["container_raid_level"] = "raid0"
         kwargs["device"] = device
         size = Size("400 MiB")
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## remove encryption from the md pv
         kwargs["container_encrypted"] = False
         kwargs["device"] = device
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## switch back to normal partition pvs
         kwargs["container_raid_level"] = None
         kwargs["device"] = device
         size = Size("750 MiB")
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
-    def _getSizeDelta(self, devices=None):
+    def _get_size_delta(self, devices=None):
         if not devices:
             delta = Size("2 MiB") * len(self.b.disks)
         else:
@@ -384,12 +384,12 @@ def _getSizeDelta(self, devices=None):
 
         return delta
 
-    def testGetContainer(self):
+    def test_get_container(self):
         for disk in self.b.disks:
-            self.b.formatDevice(disk, getFormat("lvmpv"))
+            self.b.format_device(disk, get_format("lvmpv"))
 
-        vg = self.b.newVG(parents=self.b.disks, name="newvg")
-        self.b.createDevice(vg)
+        vg = self.b.new_vg(parents=self.b.disks, name="newvg")
+        self.b.create_device(vg)
         self.assertEqual(self.b.vgs, [vg])
 
         factory = devicefactory.get_device_factory(self.b,
@@ -411,8 +411,8 @@ class LVMThinPFactoryTestCase(LVMFactoryTestCase):
     device_type = devicefactory.DEVICE_TYPE_LVM_THINP
     encryption_supported = False
 
-    def _validateFactoryDevice(self, *args, **kwargs):
-        super(LVMThinPFactoryTestCase, self)._validateFactoryDevice(*args,
+    def _validate_factory_device(self, *args, **kwargs):
+        super(LVMThinPFactoryTestCase, self)._validate_factory_device(*args,
                                                                     **kwargs)
         device = args[0]
 
@@ -425,8 +425,8 @@ def _validateFactoryDevice(self, *args, **kwargs):
 
         return device
 
-    def _getSizeDelta(self, devices=None):
-        delta = super(LVMThinPFactoryTestCase, self)._getSizeDelta(devices=devices)
+    def _get_size_delta(self, devices=None):
+        delta = super(LVMThinPFactoryTestCase, self)._get_size_delta(devices=devices)
         if devices:
             # we reserve 20% of thin pool size in VG for pool metadata
             delta += sum(d.size for d in devices) * Decimal('0.20')
@@ -437,7 +437,7 @@ class MDFactoryTestCase(DeviceFactoryTestCase):
     device_type = devicefactory.DEVICE_TYPE_MD
     device_class = MDRaidArrayDevice
 
-    def testDeviceFactory(self):
+    def test_device_factory(self):
         ## RAID0 across two disks
         device_type = self.device_type
         size = Size('1 GiB')
@@ -445,16 +445,16 @@ def testDeviceFactory(self):
                   "fstype": 'ext4',
                   "raid_level": "raid0",
                   "mountpoint": '/factorytest'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
-        self.b.recursiveRemove(device)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
+        self.b.recursive_remove(device)
 
         ## Encrypt the leaf device
         kwargs["encrypted"] = True
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
         for partition in self.b.partitions:
-            self.b.recursiveRemove(partition)
+            self.b.recursive_remove(partition)
 
         # RAID1 across two disks
         size = Size('500 MiB')
@@ -462,10 +462,10 @@ def testDeviceFactory(self):
                   "fstype": 'ext4',
                   "raid_level": "raid1",
                   "mountpoint": '/factorytest'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
         for partition in self.b.partitions:
-            self.b.recursiveRemove(partition)
+            self.b.recursive_remove(partition)
 
         ##
         ## Reconfigure device
@@ -477,14 +477,14 @@ def testDeviceFactory(self):
                   "fstype": 'swap',
                   "raid_level": "raid0",
                   "label": 'SWAP00'}
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## Encrypt the leaf device
         kwargs["encrypted"] = True
         kwargs["device"] = device
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
         ## Change the mountpoint
         size = Size('400 MiB')
@@ -494,13 +494,13 @@ def testDeviceFactory(self):
         kwargs["fstype"] = "xfs"
         kwargs["device"] = device
         #kwargs["encrypted"] = False
-        device = self._factoryDevice(device_type, size, **kwargs)
-        self._validateFactoryDevice(device, device_type, size, **kwargs)
+        device = self._factory_device(device_type, size, **kwargs)
+        self._validate_factory_device(device, device_type, size, **kwargs)
 
-    def _getSizeDelta(self, devices=None):
+    def _get_size_delta(self, devices=None):
         return Size("2 MiB") * len(self.b.disks)
 
-    def _getTestFactoryArgs(self):
+    def _get_test_factory_args(self):
         return {"raid_level": "raid0"}
 
     """Note that the following tests postdate the code that they test.
@@ -508,7 +508,7 @@ def _getTestFactoryArgs(self):
        not necessarily its intended or its correct behavior. See the
        initial commit message for this file for further details.
     """
-    def testMDFactory(self):
+    def test_mdfactory(self):
         factory1 = devicefactory.get_device_factory(self.b,
            devicefactory.DEVICE_TYPE_MD,
            Size("1 GiB"),
@@ -536,8 +536,8 @@ def testMDFactory(self):
         self.assertIsNone(factory1.get_container())
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("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 3be3795..5778af6 100644
--- a/tests/devicelibs_test/edd_test.py
+++ b/tests/devicelibs_test/edd_test.py
@@ -35,7 +35,7 @@ def __eq__(self, other):
 
 class EddTestCase(unittest.TestCase):
     _edd_logger = None
-    maxDiff = None
+    max_diff = None
 
     def setUp(self):
         super(EddTestCase, self).setUp()
@@ -69,7 +69,7 @@ def tearDown(self):
         edd.log.removeHandler(self.handler)
         super(EddTestCase, self).tearDown()
 
-    def checkLogs(self, debugs=None, infos=None, warnings=None, errors=None):
+    def check_logs(self, debugs=None, infos=None, warnings=None, errors=None):
         def check(left, right_object):
             left = [mock.call(*x) for x in left or []]
             left.sort()
@@ -128,7 +128,7 @@ def test_collect_edd_data_sata_usb(self):
         self.assertEqual(len(edd_dict), 2)
         self.assertEqual(fakeedd[0x80], edd_dict[0x80])
         self.assertEqual(fakeedd[0x81], edd_dict[0x81])
-        self.checkLogs(debugs=debugs)
+        self.check_logs(debugs=debugs)
 
     def test_get_edd_dict_sata_usb(self):
         # test with sata sda, usb sdb
@@ -176,4 +176,4 @@ def test_get_edd_dict_sata_usb(self):
                 "/sys/firmware/edd/int13_dev81"),
             ("edd: interface details: %s", "USB     \tserial_number: 30302e31"),
             ]
-        self.checkLogs(debugs=debugs, infos=infos, warnings=warnings)
+        self.check_logs(debugs=debugs, infos=infos, warnings=warnings)
diff --git a/tests/devicelibs_test/mdraid_test.py b/tests/devicelibs_test/mdraid_test.py
index 56c2ed1..e212f5c 100644
--- a/tests/devicelibs_test/mdraid_test.py
+++ b/tests/devicelibs_test/mdraid_test.py
@@ -4,14 +4,14 @@
 
 class MDRaidTestCase(unittest.TestCase):
 
-    def testMDRaid(self):
+    def test_mdraid(self):
 
         ##
         ## level lookup
         ##
-        self.assertEqual(mdraid.RAID_levels.raidLevel("stripe").name, "raid0")
-        self.assertEqual(mdraid.RAID_levels.raidLevel("mirror").name, "raid1")
-        self.assertEqual(mdraid.RAID_levels.raidLevel("4").name, "raid4")
-        self.assertEqual(mdraid.RAID_levels.raidLevel(5).name, "raid5")
-        self.assertEqual(mdraid.RAID_levels.raidLevel("RAID6").name, "raid6")
-        self.assertEqual(mdraid.RAID_levels.raidLevel("raid10").name, "raid10")
+        self.assertEqual(mdraid.RAID_levels.raid_level("stripe").name, "raid0")
+        self.assertEqual(mdraid.RAID_levels.raid_level("mirror").name, "raid1")
+        self.assertEqual(mdraid.RAID_levels.raid_level("4").name, "raid4")
+        self.assertEqual(mdraid.RAID_levels.raid_level(5).name, "raid5")
+        self.assertEqual(mdraid.RAID_levels.raid_level("RAID6").name, "raid6")
+        self.assertEqual(mdraid.RAID_levels.raid_level("raid10").name, "raid10")
diff --git a/tests/devicelibs_test/raid_test.py b/tests/devicelibs_test/raid_test.py
index 2eeb344..25a9f90 100644
--- a/tests/devicelibs_test/raid_test.py
+++ b/tests/devicelibs_test/raid_test.py
@@ -11,7 +11,7 @@ def setUp(self):
         self.levels_none = raid.RAIDLevels([])
         self.levels_some = raid.RAIDLevels(["mirror", 6])
 
-    def testRaid(self):
+    def test_raid(self):
 
         with self.assertRaisesRegex(TypeError, "Can't instantiate abstract class"):
             raid.ErsatzRAID()
@@ -40,21 +40,21 @@ def testRaid(self):
         self.assertEqual(raid.Single.get_max_spares(5), 4)
 
         ##
-        ## raidLevel
+        ## raid_level
         ##
         # pass
-        self.assertIs(self.levels.raidLevel(10), raid.RAID10)
-        self.assertIs(self.levels.raidLevel("6"), raid.RAID6)
-        self.assertIs(self.levels.raidLevel("RAID5"), raid.RAID5)
-        self.assertIs(self.levels.raidLevel("raid4"), raid.RAID4)
-        self.assertIs(self.levels.raidLevel("mirror"), raid.RAID1)
-        self.assertIs(self.levels.raidLevel("stripe"), raid.RAID0)
-        self.assertIs(self.levels.raidLevel(raid.RAID0), raid.RAID0)
+        self.assertIs(self.levels.raid_level(10), raid.RAID10)
+        self.assertIs(self.levels.raid_level("6"), raid.RAID6)
+        self.assertIs(self.levels.raid_level("RAID5"), raid.RAID5)
+        self.assertIs(self.levels.raid_level("raid4"), raid.RAID4)
+        self.assertIs(self.levels.raid_level("mirror"), raid.RAID1)
+        self.assertIs(self.levels.raid_level("stripe"), raid.RAID0)
+        self.assertIs(self.levels.raid_level(raid.RAID0), raid.RAID0)
 
         with self.assertRaises(errors.RaidError):
-            self.levels.raidLevel("bogus")
+            self.levels.raid_level("bogus")
         with self.assertRaises(errors.RaidError):
-            self.levels.raidLevel(None)
+            self.levels.raid_level(None)
 
         ##
         ## get_max_spares
@@ -146,10 +146,10 @@ def testRaid(self):
         ## __init__
         ##
         with self.assertRaisesRegex(errors.RaidError, "invalid RAID level"):
-            self.levels_none.raidLevel(10)
+            self.levels_none.raid_level(10)
 
         with self.assertRaisesRegex(errors.RaidError, "invalid RAID level"):
-            self.levels_some.raidLevel(10)
+            self.levels_some.raid_level(10)
 
         with self.assertRaisesRegex(errors.RaidError, "invalid standard RAID level descriptor"):
             raid.RAIDLevels(["raid3.1415"])
diff --git a/tests/devices_test/dependencies_test.py b/tests/devices_test/dependencies_test.py
index 1547d28..888b256 100644
--- a/tests/devices_test/dependencies_test.py
+++ b/tests/devices_test/dependencies_test.py
@@ -13,7 +13,7 @@
 from blivet.devices import MDRaidArrayDevice
 from blivet.devices import PartitionDevice
 
-from blivet.formats import getFormat
+from blivet.formats import get_format
 
 from blivet.size import Size
 
@@ -22,52 +22,52 @@
 class DeviceDependenciesTestCase(unittest.TestCase):
     """Test external device dependencies. """
 
-    def testDependencies(self):
-        dev1 = DiskDevice("name", fmt=getFormat("mdmember"))
-        dev2 = DiskDevice("other", fmt=getFormat("mdmember"))
+    def test_dependencies(self):
+        dev1 = DiskDevice("name", fmt=get_format("mdmember"))
+        dev2 = DiskDevice("other", fmt=get_format("mdmember"))
         dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1,dev2])
         luks = LUKSDevice("luks", parents=[dev])
 
         # a parent's dependencies are a subset of its child's.
-        for d in dev.externalDependencies:
-            self.assertIn(d, luks.externalDependencies)
+        for d in dev.external_dependencies:
+            self.assertIn(d, luks.external_dependencies)
 
         # make sure that there's at least something in these dependencies
-        self.assertGreater(len(luks.externalDependencies), 0)
+        self.assertGreater(len(luks.external_dependencies), 0)
 
 class MockingDeviceDependenciesTestCase(unittest.TestCase):
     """Test availability of external device dependencies. """
 
     def setUp(self):
-        dev1 = DiskDevice("name", fmt=getFormat("mdmember"), size=Size("1 GiB"))
+        dev1 = DiskDevice("name", fmt=get_format("mdmember"), size=Size("1 GiB"))
         dev2 = DiskDevice("other")
-        self.part = PartitionDevice("part", fmt=getFormat("mdmember"), parents=[dev2])
-        self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=getFormat("luks"), totalDevices=2, memberDevices=2)
-        self.luks = LUKSDevice("luks", parents=[self.dev], fmt=getFormat("ext4"))
+        self.part = PartitionDevice("part", fmt=get_format("mdmember"), parents=[dev2])
+        self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=get_format("luks"), total_devices=2, member_devices=2)
+        self.luks = LUKSDevice("luks", parents=[self.dev], fmt=get_format("ext4"))
 
         self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method
         self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method
         self.cache_availability = availability.CACHE_AVAILABILITY
 
-    def testAvailabilityMDRAIDplugin(self):
+    def test_availability_mdraidplugin(self):
 
         availability.CACHE_AVAILABILITY = False
         availability.BLOCKDEV_DM_PLUGIN._method = availability.AvailableMethod
 
         # if the plugin is not in, there's nothing to test
-        self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.externalDependencies)
+        self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.external_dependencies)
 
         # dev is not among its unavailable dependencies
         availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.AvailableMethod
-        self.assertNotIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailableDependencies)
+        self.assertNotIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailable_dependencies)
         self.assertIsNotNone(ActionCreateDevice(self.luks))
         self.assertIsNotNone(ActionDestroyDevice(self.luks))
-        self.assertIsNotNone(ActionCreateFormat(self.luks, fmt=getFormat("macefi")))
+        self.assertIsNotNone(ActionCreateFormat(self.luks, fmt=get_format("macefi")))
         self.assertIsNotNone(ActionDestroyFormat(self.luks))
 
         # dev is among the unavailable dependencies
         availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.UnavailableMethod
-        self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailableDependencies)
+        self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailable_dependencies)
         with self.assertRaises(ValueError):
             ActionCreateDevice(self.luks)
         with self.assertRaises(ValueError):
diff --git a/tests/devices_test/device_names_test.py b/tests/devices_test/device_names_test.py
index 3e91343..d5d2a75 100644
--- a/tests/devices_test/device_names_test.py
+++ b/tests/devices_test/device_names_test.py
@@ -9,34 +9,34 @@
 class DeviceNameTestCase(unittest.TestCase):
     """Test device name validation"""
 
-    def testStorageDevice(self):
+    def test_storage_device(self):
         # Check that / and NUL are rejected along with . and ..
         good_names = ['sda1', '1sda', 'good-name', 'cciss/c0d0']
         bad_names = ['sda/1', 'sda\x00', '.', '..', 'cciss/..']
 
         for name in good_names:
-            self.assertTrue(StorageDevice.isNameValid(name))
+            self.assertTrue(StorageDevice.is_name_valid(name))
 
         for name in bad_names:
-            self.assertFalse(StorageDevice.isNameValid(name))
+            self.assertFalse(StorageDevice.is_name_valid(name))
 
-    def testVolumeGroup(self):
+    def test_volume_group(self):
         good_names = ['vg00', 'group-name', 'groupname-']
         bad_names = ['-leading-hyphen', 'únicode', 'sp aces']
 
         for name in good_names:
-            self.assertTrue(LVMVolumeGroupDevice.isNameValid(name))
+            self.assertTrue(LVMVolumeGroupDevice.is_name_valid(name))
 
         for name in bad_names:
-            self.assertFalse(LVMVolumeGroupDevice.isNameValid(name))
+            self.assertFalse(LVMVolumeGroupDevice.is_name_valid(name))
 
-    def testLogicalVolume(self):
+    def test_logical_volume(self):
         good_names = ['lv00', 'volume-name', 'volumename-']
         bad_names = ['-leading-hyphen', 'únicode', 'sp aces',
                      'snapshot47', 'pvmove0', 'sub_tmetastring']
 
         for name in good_names:
-            self.assertTrue(LVMLogicalVolumeDevice.isNameValid(name))
+            self.assertTrue(LVMLogicalVolumeDevice.is_name_valid(name))
 
         for name in bad_names:
-            self.assertFalse(LVMLogicalVolumeDevice.isNameValid(name))
+            self.assertFalse(LVMLogicalVolumeDevice.is_name_valid(name))
diff --git a/tests/devices_test/device_packages_test.py b/tests/devices_test/device_packages_test.py
index c613800..593d03b 100644
--- a/tests/devices_test/device_packages_test.py
+++ b/tests/devices_test/device_packages_test.py
@@ -6,15 +6,15 @@
 from blivet.devices import LUKSDevice
 from blivet.devices import MDRaidArrayDevice
 
-from blivet.formats import getFormat
+from blivet.formats import get_format
 
 class DevicePackagesTestCase(unittest.TestCase):
     """Test device name validation"""
 
-    def testPackages(self):
-        dev1 = DiskDevice("name", fmt=getFormat("mdmember"))
+    def test_packages(self):
+        dev1 = DiskDevice("name", fmt=get_format("mdmember"))
 
-        dev2 = DiskDevice("other", fmt=getFormat("mdmember"))
+        dev2 = DiskDevice("other", fmt=get_format("mdmember"))
         dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1,dev2])
         luks = LUKSDevice("luks", parents=[dev])
         packages = luks.packages
diff --git a/tests/devices_test/device_properties_test.py b/tests/devices_test/device_properties_test.py
index d07f7e5..696bf57 100644
--- a/tests/devices_test/device_properties_test.py
+++ b/tests/devices_test/device_properties_test.py
@@ -30,9 +30,9 @@
 from blivet.devicelibs import mdraid
 from blivet.size import Size
 
-from blivet.formats import getFormat
+from blivet.formats import get_format
 
-BTRFS_MIN_MEMBER_SIZE = getFormat("btrfs").minSize
+BTRFS_MIN_MEMBER_SIZE = get_format("btrfs").min_size
 
 # pylint: disable=unnecessary-lambda
 
@@ -55,18 +55,18 @@ class DeviceStateTestCase(unittest.TestCase):
        of a device object.
     """
 
-    def __init__(self, methodName='runTest'):
+    def __init__(self, methodName='run_test'):
         self._state_functions = {
-           "currentSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+           "current_size" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
            "direct" : xform(self.assertTrue),
            "exists" : xform(self.assertFalse),
            "format" : xform(self.assertIsNotNone),
-           "formatArgs" : xform(lambda x, m: self.assertEqual(x, [], m)),
-           "isDisk" : xform(self.assertFalse),
+           "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)),
-           "maxSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
-           "mediaPresent" : xform(self.assertTrue),
+           "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)),
@@ -76,14 +76,14 @@ def __init__(self, methodName='runTest'):
            "resizable" : xform(self.assertFalse),
            "size" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
            "status" : xform(self.assertFalse),
-           "sysfsPath" : xform(lambda x, m: self.assertEqual(x, "", m)),
-           "targetSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+           "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)
 
-    def stateCheck(self, device, **kwargs):
+    def state_check(self, device, **kwargs):
         """Checks the current state of a device by means of its
            fields or properties.
 
@@ -114,74 +114,74 @@ class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
        commit message for this file for further details.
     """
 
-    def __init__(self, methodName='runTest'):
+    def __init__(self, methodName='run_test'):
         super(MDRaidArrayDeviceTestCase, self).__init__(methodName=methodName)
         state_functions = {
-           "createBitmap" : xform(lambda d, a: self.assertFalse),
+           "create_bitmap" : xform(lambda d, a: self.assertFalse),
            "description" : xform(self.assertIsNotNone),
-           "formatClass" : xform(self.assertIsNotNone),
+           "format_class" : xform(self.assertIsNotNone),
            "level" : xform(self.assertIsNone),
-           "mdadmFormatUUID" : xform(self.assertIsNone),
-           "memberDevices" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+           "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)),
-           "metadataVersion" : xform(lambda x, m: self.assertEqual(x, "default", m)),
+           "metadata_version" : xform(lambda x, m: self.assertEqual(x, "default", m)),
            "spares" : xform(lambda x, m: self.assertEqual(x, 0, m)),
-           "totalDevices" : 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)
 
     def setUp(self):
         self.md_chunk_size = mdraid.MD_CHUNK_SIZE
         mdraid.MD_CHUNK_SIZE = Size("1 MiB")
-        self.get_super_block_size = MDRaidArrayDevice.getSuperBlockSize
-        MDRaidArrayDevice.getSuperBlockSize = lambda a, s: Size(0)
+        self.get_superblock_size = MDRaidArrayDevice.get_superblock_size
+        MDRaidArrayDevice.get_superblock_size = lambda a, s: Size(0)
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=get_format("mdmember"))
         ]
-        self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, totalDevices=1, memberDevices=1)
+        self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, total_devices=1, member_devices=1)
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember"), size=Size("1 GiB")),
-           DiskDevice("name2", fmt=getFormat("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,
-                                      totalDevices=2, memberDevices=2)
+                                      total_devices=2, member_devices=2)
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("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=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember")),
-           DiskDevice("name3", fmt=getFormat("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=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember")),
-           DiskDevice("name3", fmt=getFormat("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=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember")),
-           DiskDevice("name3", fmt=getFormat("mdmember")),
-           DiskDevice("name4", fmt=getFormat("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=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember")),
-           DiskDevice("name3", fmt=getFormat("mdmember")),
-           DiskDevice("name4", fmt=getFormat("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)
 
@@ -189,29 +189,29 @@ def setUp(self):
 
 
         parents_1 = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=get_format("mdmember")),
+           DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         dev_1 = MDContainerDevice(
            "parent",
            level="container",
            parents=parents_1,
-           totalDevices=2,
-           memberDevices=2,
+           total_devices=2,
+           member_devices=2,
            exists=True
         )
         self.dev9 = MDBiosRaidArrayDevice(
            "dev9",
            level="raid0",
-           memberDevices=1,
+           member_devices=1,
            parents=[dev_1],
-           totalDevices=1,
+           total_devices=1,
            exists=True
         )
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=get_format("mdmember")),
+           DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev10 = MDRaidArrayDevice(
            "dev10",
@@ -220,15 +220,15 @@ def setUp(self):
            size=Size("32 MiB"))
 
         parents_1 = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=get_format("mdmember")),
+           DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         dev_1 = MDContainerDevice(
            "parent",
            level="container",
            parents=parents,
-           totalDevices=2,
-           memberDevices=2
+           total_devices=2,
+           member_devices=2
         )
         self.dev11 = MDBiosRaidArrayDevice(
            "dev11",
@@ -240,89 +240,89 @@ def setUp(self):
         self.dev13 = MDRaidArrayDevice(
            "dev13",
            level=0,
-           memberDevices=2,
+           member_devices=2,
            parents=[
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
+                      "format": get_format("mdmember")})],
            size=Size("32 MiB"),
-           totalDevices=2)
+           total_devices=2)
 
         self.dev14 = MDRaidArrayDevice(
            "dev14",
            level=4,
-           memberDevices=3,
+           member_devices=3,
            parents=[
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
-           totalDevices=3)
+                      "format": get_format("mdmember")})],
+           total_devices=3)
 
         self.dev15 = MDRaidArrayDevice(
            "dev15",
            level=5,
-           memberDevices=3,
+           member_devices=3,
            parents=[
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
-           totalDevices=3)
+                      "format": get_format("mdmember")})],
+           total_devices=3)
 
         self.dev16 = MDRaidArrayDevice(
            "dev16",
            level=6,
-           memberDevices=4,
+           member_devices=4,
            parents=[
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
-           totalDevices=4)
+                      "format": get_format("mdmember")})],
+           total_devices=4)
 
         self.dev17 = MDRaidArrayDevice(
            "dev17",
            level=10,
-           memberDevices=4,
+           member_devices=4,
            parents=[
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
-           totalDevices=4)
+                      "format": get_format("mdmember")})],
+           total_devices=4)
 
         self.dev18 = MDRaidArrayDevice(
            "dev18",
            level=10,
-           memberDevices=4,
+           member_devices=4,
            parents=[
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("4 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")}),
+                      "format": get_format("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
-           totalDevices=5)
+                      "format": get_format("mdmember")})],
+           total_devices=5)
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=get_format("mdmember")),
+           DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev19 = MDRaidArrayDevice(
            "dev19",
@@ -332,8 +332,8 @@ def setUp(self):
         )
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=get_format("mdmember")),
+           DiskDevice("name2", fmt=get_format("mdmember"))
         ]
         self.dev20 = MDRaidArrayDevice(
            "dev20",
@@ -344,9 +344,9 @@ def setUp(self):
 
     def tearDown(self):
         mdraid.MD_CHUNK_SIZE = self.md_chunk_size
-        MDRaidArrayDevice.getSuperBlockSize = self.get_super_block_size
+        MDRaidArrayDevice.get_superblock_size = self.get_superblock_size
 
-    def testMDRaidArrayDeviceInit(self):
+    def test_mdraid_array_device_init(self):
         """Tests the state of a MDRaidArrayDevice after initialization.
            For some combinations of arguments the initializer will throw
            an exception.
@@ -355,39 +355,39 @@ def testMDRaidArrayDeviceInit(self):
         ##
         ## level tests
         ##
-        self.stateCheck(self.dev1,
+        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)),
-           memberDevices=xform(lambda x, m: self.assertEqual(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)),
-           mediaPresent=xform(self.assertFalse),
-           totalDevices=xform(lambda x, m: self.assertEqual(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.stateCheck(self.dev2,
-           createBitmap=xform(self.assertFalse),
+        self.state_check(self.dev2,
+           create_bitmap=xform(self.assertFalse),
            level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, 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)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)))
-        self.stateCheck(self.dev3,
+           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)))
-        self.stateCheck(self.dev4,
+        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)))
-        self.stateCheck(self.dev5,
+        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)))
-        self.stateCheck(self.dev6,
+        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)))
-        self.stateCheck(self.dev7,
+        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)))
@@ -395,138 +395,138 @@ def testMDRaidArrayDeviceInit(self):
         ##
         ## existing device tests
         ##
-        self.stateCheck(self.dev8,
+        self.state_check(self.dev8,
            exists=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-           metadataVersion=xform(self.assertIsNone))
+           metadata_version=xform(self.assertIsNone))
 
 
         ##
         ## mdbiosraidarray tests
         ##
-        self.stateCheck(self.dev9,
-           createBitmap=xform(self.assertFalse),
-           isDisk=xform(self.assertTrue),
+        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)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+           member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           metadataVersion=xform(lambda x, m: self.assertEqual(x, None, 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),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+           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.stateCheck(dev9_container,
-           createBitmap=xform(self.assertFalse),
+        self.state_check(dev9_container,
+           create_bitmap=xform(self.assertFalse),
            direct=xform(self.assertFalse),
-           isDisk=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)),
-           mediaPresent=xform(self.assertFalse),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, 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)),
-           metadataVersion=xform(lambda x, m: self.assertEqual(x, None, 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),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+           total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
            type = xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
 
         ##
         ## size tests
         ##
-        self.stateCheck(self.dev10,
-           createBitmap=xform(self.assertFalse),
+        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)),
-           targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
+           target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
 
-        self.stateCheck(self.dev11,
-           isDisk=xform(self.assertTrue),
+        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)),
-           currentSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           maxSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, 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)),
-           metadataVersion=xform(lambda x, m: self.assertEqual(x, None, 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)),
-           targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, 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.stateCheck(self.dev13,
-           createBitmap=xform(self.assertFalse),
+        self.state_check(self.dev13,
+           create_bitmap=xform(self.assertFalse),
            level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, 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)),
-           targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, 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.stateCheck(self.dev14,
-           createBitmap=xform(self.assertTrue),
+        self.state_check(self.dev14,
+           create_bitmap=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 3, 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)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+           total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
 
-        self.stateCheck(self.dev15,
-           createBitmap=xform(self.assertTrue),
+        self.state_check(self.dev15,
+           create_bitmap=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 3, 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)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+           total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
 
-        self.stateCheck(self.dev16,
-           createBitmap=xform(self.assertTrue),
+        self.state_check(self.dev16,
+           create_bitmap=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 4, 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)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m)))
+           total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
 
-        self.stateCheck(self.dev17,
-           createBitmap=xform(self.assertTrue),
+        self.state_check(self.dev17,
+           create_bitmap=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 4, 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)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m)))
+           total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
 
-        self.stateCheck(self.dev18,
-           createBitmap=xform(self.assertTrue),
+        self.state_check(self.dev18,
+           create_bitmap=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 4, 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)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 5, m)))
+           total_devices=xform(lambda x, m: self.assertEqual(x, 5, m)))
 
-        self.stateCheck(self.dev19,
+        self.state_check(self.dev19,
                         level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-                        mdadmFormatUUID=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), 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.stateCheck(self.dev20,
+        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)),
@@ -541,21 +541,21 @@ def testMDRaidArrayDeviceInit(self):
         with self.assertRaisesRegex(DeviceError, "invalid"):
             MDRaidArrayDevice(
                "dev",
-               parents=[StorageDevice("parent", fmt=getFormat("mdmember"))])
+               parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
 
         with self.assertRaisesRegex(DeviceError, "at least 2 members"):
             MDRaidArrayDevice(
                "dev",
                level="raid0",
-               parents=[StorageDevice("parent", fmt=getFormat("mdmember"))])
+               parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
 
         with self.assertRaisesRegex(DeviceError, "invalid"):
             MDRaidArrayDevice("dev", level="junk")
 
         with self.assertRaisesRegex(DeviceError, "at least 2 members"):
-            MDRaidArrayDevice("dev", level=0, memberDevices=2)
+            MDRaidArrayDevice("dev", level=0, member_devices=2)
 
-    def testMDRaidArrayDeviceMethods(self):
+    def test_mdraid_array_device_methods(self):
         """Test for method calls on initialized MDRaidDevices."""
         with self.assertRaisesRegex(DeviceError, "invalid" ):
             self.dev7.level = "junk"
@@ -570,13 +570,13 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
        commit message for this file for further details.
     """
 
-    def __init__(self, methodName='runTest'):
+    def __init__(self, methodName='run_test'):
         super(BTRFSDeviceTestCase, self).__init__(methodName=methodName)
         state_functions = {
-           "dataLevel" : lambda d, a: self.assertFalse(hasattr(d,a)),
-           "fstabSpec" : xform(self.assertIsNotNone),
-           "mediaPresent" : xform(self.assertTrue),
-           "metaDataLevel" : lambda d, a: self.assertFalse(hasattr(d, a)),
+           "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)
@@ -584,49 +584,49 @@ def __init__(self, methodName='runTest'):
     def setUp(self):
         self.dev1 = BTRFSVolumeDevice("dev1",
            parents=[StorageDevice("deva",
-              fmt=blivet.formats.getFormat("btrfs"),
+              fmt=blivet.formats.get_format("btrfs"),
               size=BTRFS_MIN_MEMBER_SIZE)])
 
         self.dev2 = BTRFSSubVolumeDevice("dev2",
            parents=[self.dev1],
-           fmt=blivet.formats.getFormat("btrfs"))
+           fmt=blivet.formats.get_format("btrfs"))
 
         dev = StorageDevice("deva",
-           fmt=blivet.formats.getFormat("btrfs"),
+           fmt=blivet.formats.get_format("btrfs"),
            size=Size("500 MiB"))
         self.dev3 = BTRFSVolumeDevice("dev3",
            parents=[dev])
 
-    def testBTRFSDeviceInit(self):
+    def test_btrfsdevice_init(self):
         """Tests the state of a BTRFSDevice after initialization.
            For some combinations of arguments the initializer will throw
            an exception.
         """
 
-        self.stateCheck(self.dev1,
-           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           dataLevel=xform(self.assertIsNone),
+        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),
-           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           metaDataLevel=xform(self.assertIsNone),
+           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.stateCheck(self.dev2,
-           targetSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, 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))
 
-        self.stateCheck(self.dev3,
-           currentSize=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
-           dataLevel=xform(self.assertIsNone),
-           maxSize=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
-           metaDataLevel=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)))
@@ -638,21 +638,21 @@ def testBTRFSDeviceInit(self):
             BTRFSVolumeDevice("dev", parents=[StorageDevice("deva", size=BTRFS_MIN_MEMBER_SIZE)])
 
         with self.assertRaisesRegex(DeviceError, "btrfs subvolume.*must be a btrfs volume"):
-            fmt = blivet.formats.getFormat("btrfs")
+            fmt = blivet.formats.get_format("btrfs")
             device = StorageDevice("deva", fmt=fmt, size=BTRFS_MIN_MEMBER_SIZE)
             BTRFSSubVolumeDevice("dev1", parents=[device])
 
-        deva = OpticalDevice("deva", fmt=blivet.formats.getFormat("btrfs", exists=True),
+        deva = OpticalDevice("deva", fmt=blivet.formats.get_format("btrfs", exists=True),
                              exists=True)
         with self.assertRaisesRegex(BTRFSValueError, "at least"):
-            BTRFSVolumeDevice("dev1", dataLevel="raid1", parents=[deva])
+            BTRFSVolumeDevice("dev1", data_level="raid1", parents=[deva])
 
-        deva = StorageDevice("deva", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)
-        self.assertIsNotNone(BTRFSVolumeDevice("dev1", metaDataLevel="dup", parents=[deva]))
+        deva = StorageDevice("deva", fmt=blivet.formats.get_format("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)
+        self.assertIsNotNone(BTRFSVolumeDevice("dev1", metadata_level="dup", parents=[deva]))
 
-        deva = StorageDevice("deva", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)
+        deva = StorageDevice("deva", fmt=blivet.formats.get_format("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)
         with self.assertRaisesRegex(BTRFSValueError, "invalid"):
-            BTRFSVolumeDevice("dev1", dataLevel="dup", parents=[deva])
+            BTRFSVolumeDevice("dev1", data_level="dup", parents=[deva])
 
         self.assertEqual(self.dev1.isleaf, False)
         self.assertEqual(self.dev1.direct, True)
@@ -663,7 +663,7 @@ def testBTRFSDeviceInit(self):
         self.assertEqual(member.isleaf, False)
         self.assertEqual(member.direct, False)
 
-    def testBTRFSDeviceMethods(self):
+    def test_btrfsdevice_methods(self):
         """Test for method calls on initialized BTRFS Devices."""
         # volumes do not have ancestor volumes
         with self.assertRaises(AttributeError):
@@ -671,7 +671,7 @@ def testBTRFSDeviceMethods(self):
 
         # subvolumes do not have default subvolumes
         with self.assertRaises(AttributeError):
-            self.dev2.defaultSubVolume # pylint: disable=no-member,pointless-statement
+            self.dev2.default_sub_volume # pylint: disable=no-member,pointless-statement
 
         self.assertIsNotNone(self.dev2.volume)
 
@@ -679,8 +679,8 @@ def testBTRFSDeviceMethods(self):
         with self.assertRaisesRegex(RuntimeError, "cannot directly set size of btrfs volume"):
             self.dev1.size = Size("500 MiB")
 
-    def testBTRFSSnapShotDeviceInit(self):
-        parents = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)]
+    def test_btrfssnap_shot_device_init(self):
+        parents = [StorageDevice("p1", fmt=blivet.formats.get_format("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)]
         vol = BTRFSVolumeDevice("test", parents=parents)
         with self.assertRaisesRegex(ValueError, "non-existent btrfs snapshots must have a source"):
             BTRFSSnapShotDevice("snap1", parents=[vol])
@@ -691,31 +691,31 @@ def testBTRFSSnapShotDeviceInit(self):
         with self.assertRaisesRegex(ValueError, "btrfs snapshot source must be a btrfs subvolume"):
             BTRFSSnapShotDevice("snap1", parents=[vol], source=parents[0])
 
-        parents2 = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)]
+        parents2 = [StorageDevice("p1", fmt=blivet.formats.get_format("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)]
         vol2 = BTRFSVolumeDevice("test2", parents=parents2, exists=True)
         with self.assertRaisesRegex(ValueError, ".*snapshot and source must be in the same volume"):
             BTRFSSnapShotDevice("snap1", parents=[vol], source=vol2)
 
         vol.exists = True
         snap = BTRFSSnapShotDevice("snap1",
-           fmt=blivet.formats.getFormat("btrfs"),
+           fmt=blivet.formats.get_format("btrfs"),
            parents=[vol],
            source=vol)
-        self.stateCheck(snap,
-           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           targetSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+        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))
-        self.stateCheck(vol,
-           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           dataLevel=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),
-           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
-           metaDataLevel=xform(self.assertIsNone),
+           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)))
@@ -725,11 +725,11 @@ def testBTRFSSnapShotDeviceInit(self):
         self.assertEqual(vol.isleaf, False)
         self.assertEqual(vol.direct, True)
 
-        self.assertEqual(snap.dependsOn(vol), True)
-        self.assertEqual(vol.dependsOn(snap), False)
+        self.assertEqual(snap.depends_on(vol), True)
+        self.assertEqual(vol.depends_on(snap), False)
 
 class LVMLogicalVolumeDeviceTestCase(DeviceStateTestCase):
-    def __init__(self, methodName="runTest"):
+    def __init__(self, methodName="run_test"):
         super(LVMLogicalVolumeDeviceTestCase, self).__init__(methodName=methodName)
         state_functions = {
             "type": xform(lambda x, m: self.assertEqual(x, "lvmlv", m)),
@@ -741,29 +741,29 @@ def __init__(self, methodName="runTest"):
         self._state_functions.update(state_functions)
 
     def setUp(self):
-        pv = StorageDevice("pv1", fmt=blivet.formats.getFormat("lvmpv"),
+        pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
                            size=Size("1 GiB"))
         vg = LVMVolumeGroupDevice("testvg", parents=[pv])
         self.lv = LVMLogicalVolumeDevice("testlv", parents=[vg],
-                                         fmt=blivet.formats.getFormat("xfs"))
+                                         fmt=blivet.formats.get_format("xfs"))
 
-        pv2 = StorageDevice("pv2", fmt=blivet.formats.getFormat("lvmpv"),
+        pv2 = StorageDevice("pv2", fmt=blivet.formats.get_format("lvmpv"),
                             size=Size("1 GiB"))
-        pv3 = StorageDevice("pv3", fmt=blivet.formats.getFormat("lvmpv"),
+        pv3 = StorageDevice("pv3", fmt=blivet.formats.get_format("lvmpv"),
                             size=Size("1 GiB"))
         vg2 = LVMVolumeGroupDevice("testvg2", parents=[pv2, pv3])
         cache_req = LVMCacheRequest(Size("512 MiB"), [pv3], "writethrough")
         self.cached_lv = LVMLogicalVolumeDevice("testcachedlv", parents=[vg2],
-                                    fmt=blivet.formats.getFormat("xfs"),
-                                    exists=False, cacheRequest=cache_req)
+                                    fmt=blivet.formats.get_format("xfs"),
+                                    exists=False, cache_request=cache_req)
 
-    def testLVMLogicalVolumeDeviceInit(self):
-        self.stateCheck(self.lv,
+    def test_lvmlogical_volume_device_init(self):
+        self.state_check(self.lv,
             # 1 GiB - one extent
-            maxSize=xform(lambda x, m: self.assertEqual(x, Size("1020 MiB"), m) and
+            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)),
-            segType=xform(lambda x, m: self.assertEqual(x, "linear", 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)),
@@ -771,16 +771,16 @@ def testLVMLogicalVolumeDeviceInit(self):
                            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)),
-            logSize=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+            log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
                           self.assertIsInstance(x, Size, m)),
-            metaDataSize=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+            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)),
-            vgSpaceUsed=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+            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)),
-            mapName=xform(lambda x, m: self.assertEqual(x, "testvg-testlv", m)),
+            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)),
@@ -789,14 +789,14 @@ def testLVMLogicalVolumeDeviceInit(self):
             cached=xform(lambda x, m: self.assertFalse(x, m)),
         )
 
-    def testLVMLogicalVolumeDeviceInitCached(self):
-        self.stateCheck(self.cached_lv,
+    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
-            maxSize=xform(lambda x, m: self.assertEqual(x, Size("1520 MiB"), m) and
+            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)),
-            segType=xform(lambda x, m: self.assertEqual(x, "linear", 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)),
@@ -804,16 +804,16 @@ def testLVMLogicalVolumeDeviceInitCached(self):
                            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)),
-            logSize=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+            log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
                           self.assertIsInstance(x, Size, m)),
-            metaDataSize=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+            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)),
-            vgSpaceUsed=xform(lambda x, m: self.assertEqual(x, Size("512 MiB"), m) and
+            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)),
-            mapName=xform(lambda x, m: self.assertEqual(x, "testvg2-testcachedlv", m)),
+            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)),
diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py
index f7b56ad..f945062 100644
--- a/tests/devices_test/lvm_test.py
+++ b/tests/devices_test/lvm_test.py
@@ -24,14 +24,14 @@
    StorageDevice
 ]
 
- at unittest.skipUnless(not any(x.unavailableTypeDependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test")
+ at unittest.skipUnless(not any(x.unavailable_type_dependencies() for x in DEVICE_CLASSES), "some unsupported device classes required for this test")
 class LVMDeviceTest(unittest.TestCase):
-    def testLVMSnapShotDeviceInit(self):
-        pv = StorageDevice("pv1", fmt=blivet.formats.getFormat("lvmpv"),
+    def test_lvmsnap_shot_device_init(self):
+        pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
                            size=Size("1 GiB"))
         vg = LVMVolumeGroupDevice("testvg", parents=[pv])
         lv = LVMLogicalVolumeDevice("testlv", parents=[vg],
-                                    fmt=blivet.formats.getFormat("xfs"))
+                                    fmt=blivet.formats.get_format("xfs"))
 
         with self.assertRaisesRegex(ValueError, "lvm snapshot devices require an origin lv"):
             LVMSnapShotDevice("snap1", parents=[vg])
@@ -49,7 +49,7 @@ def testLVMSnapShotDeviceInit(self):
         snap1 = LVMSnapShotDevice("snap1", parents=[vg], origin=lv)
 
         self.assertEqual(snap1.format.type, lv.format.type)
-        lv.format = blivet.formats.getFormat("DM_snapshot_cow", exists=True)
+        lv.format = blivet.formats.get_format("DM_snapshot_cow", exists=True)
         self.assertEqual(snap1.format.type, lv.format.type)
 
         self.assertEqual(snap1.isleaf, True)
@@ -57,11 +57,11 @@ def testLVMSnapShotDeviceInit(self):
         self.assertEqual(lv.isleaf, False)
         self.assertEqual(lv.direct, True)
 
-        self.assertEqual(snap1.dependsOn(lv), True)
-        self.assertEqual(lv.dependsOn(snap1), False)
+        self.assertEqual(snap1.depends_on(lv), True)
+        self.assertEqual(lv.depends_on(snap1), False)
 
-    def testLVMThinSnapShotDeviceInit(self):
-        pv = StorageDevice("pv1", fmt=blivet.formats.getFormat("lvmpv"),
+    def test_lvmthin_snap_shot_device_init(self):
+        pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
                            size=Size("1 GiB"))
         vg = LVMVolumeGroupDevice("testvg", parents=[pv])
         pool = LVMThinPoolDevice("pool1", parents=[vg], size=Size("500 MiB"))
@@ -85,25 +85,25 @@ def testLVMThinSnapShotDeviceInit(self):
         self.assertEqual(thinlv.isleaf, True)
         self.assertEqual(thinlv.direct, True)
 
-        self.assertEqual(snap1.dependsOn(thinlv), True)
-        self.assertEqual(thinlv.dependsOn(snap1), False)
+        self.assertEqual(snap1.depends_on(thinlv), True)
+        self.assertEqual(thinlv.depends_on(snap1), False)
 
         # existing thin snapshots do not depend on their origin
         snap1.exists = True
-        self.assertEqual(snap1.dependsOn(thinlv), False)
+        self.assertEqual(snap1.depends_on(thinlv), False)
 
-    def testLVMCachedLogicalVolumeInit(self):
-        pv = StorageDevice("pv1", fmt=blivet.formats.getFormat("lvmpv"),
+    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.getFormat("lvmpv"),
+        pv2 = StorageDevice("pv2", fmt=blivet.formats.get_format("lvmpv"),
                            size=Size("512 MiB"))
         vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
 
         cache_req = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
         lv = LVMLogicalVolumeDevice("testlv", parents=[vg],
-                                    fmt=blivet.formats.getFormat("xfs"),
-                                    exists=False, cacheRequest=cache_req)
-        self.assertEqual(lv.vgSpaceUsed, Size("512 MiB"))
+                                    fmt=blivet.formats.get_format("xfs"),
+                                    exists=False, cache_request=cache_req)
+        self.assertEqual(lv.vg_space_used, Size("512 MiB"))
 
         # check that the LV behaves like a cached LV
         self.assertTrue(lv.cached)
@@ -113,10 +113,10 @@ def testLVMCachedLogicalVolumeInit(self):
         # check parameters reported by the (non-existing) cache
         self.assertEqual(cache.size, Size("504 MiB"))
         self.assertEqual(cache.md_size, Size("8 MiB"))
-        self.assertEqual(cache.vgSpaceUsed, Size("512 MiB"))
+        self.assertEqual(cache.vg_space_used, Size("512 MiB"))
         self.assertIsInstance(cache.size, Size)
         self.assertIsInstance(cache.md_size, Size)
-        self.assertIsInstance(cache.vgSpaceUsed, Size)
+        self.assertIsInstance(cache.vg_space_used, Size)
         self.assertFalse(cache.exists)
         self.assertIsNone(cache.stats)
         self.assertEqual(cache.mode, "writethrough")
@@ -124,48 +124,48 @@ def testLVMCachedLogicalVolumeInit(self):
         self.assertIsNone(cache.cache_device_name)
         self.assertEqual(set(cache.fast_pvs), set([pv2]))
 
-    def testTargetSize(self):
-        pv = StorageDevice("pv1", fmt=blivet.formats.getFormat("lvmpv"),
+    def test_target_size(self):
+        pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
                            size=Size("1 GiB"))
         vg = LVMVolumeGroupDevice("testvg", parents=[pv])
         orig_size = Size("800 MiB")
         lv = LVMLogicalVolumeDevice("testlv", parents=[vg], size=orig_size,
-                                    fmt=blivet.formats.getFormat("ext4"),
+                                    fmt=blivet.formats.get_format("ext4"),
                                     exists=True)
 
         min_size = Size("200 MiB")
         lv.format.exists = True
-        lv.format._minInstanceSize = min_size
+        lv.format._min_instance_size = min_size
         lv.format._resizable = True
 
         # Make sure things are as expected to begin with.
-        self.assertEqual(lv.minSize, min_size)
-        self.assertEqual(lv.maxSize, Size("1020 MiB"))
+        self.assertEqual(lv.min_size, min_size)
+        self.assertEqual(lv.max_size, Size("1020 MiB"))
         self.assertEqual(lv.size, orig_size)
 
-        # ValueError if size smaller than minSize
+        # ValueError if size smaller than min_size
         with self.assertRaisesRegex(ValueError,
                                      "size.*smaller than the minimum"):
-            lv.targetSize = Size("1 MiB")
+            lv.target_size = Size("1 MiB")
 
         # target size should be unchanged
-        self.assertEqual(lv.targetSize, orig_size)
+        self.assertEqual(lv.target_size, orig_size)
 
-        # ValueError if size larger than maxSize
+        # ValueError if size larger than max_size
         with self.assertRaisesRegex(ValueError,
                                      "size.*larger than the maximum"):
-            lv.targetSize = Size("1 GiB")
+            lv.target_size = Size("1 GiB")
 
         # target size should be unchanged
-        self.assertEqual(lv.targetSize, orig_size)
+        self.assertEqual(lv.target_size, orig_size)
 
         # successful set of target size should also be reflected in size attr
         new_target = Size("900 MiB")
-        lv.targetSize = new_target
-        self.assertEqual(lv.targetSize, new_target)
+        lv.target_size = new_target
+        self.assertEqual(lv.target_size, new_target)
         self.assertEqual(lv.size, new_target)
 
         # reset target size to original size
-        lv.targetSize = orig_size
-        self.assertEqual(lv.targetSize, orig_size)
+        lv.target_size = orig_size
+        self.assertEqual(lv.target_size, orig_size)
         self.assertEqual(lv.size, orig_size)
diff --git a/tests/devices_test/network_test.py b/tests/devices_test/network_test.py
index 564390a..bbe17bf 100644
--- a/tests/devices_test/network_test.py
+++ b/tests/devices_test/network_test.py
@@ -5,26 +5,26 @@
 from blivet.devices import NetworkStorageDevice
 from blivet.devices import StorageDevice
 
-from blivet.formats import getFormat
+from blivet.formats import get_format
 
 class FakeNetDev(StorageDevice, NetworkStorageDevice):
     _type = "fakenetdev"
 
 class NetDevMountOptionTestCase(unittest.TestCase):
-    def testNetDevSetting(self):
+    def test_net_dev_setting(self):
         """ Verify netdev mount option setting after format assignment. """
         netdev = FakeNetDev("net1")
-        dev = StorageDevice("dev1", fmt=getFormat("ext4"))
+        dev = StorageDevice("dev1", fmt=get_format("ext4"))
         self.assertFalse("_netdev" in dev.format.options.split(","))
 
         dev.parents.append(netdev)
-        dev.format = getFormat("ext4")
+        dev.format = get_format("ext4")
         self.assertTrue("_netdev" in dev.format.options.split(","))
 
-    def testNetDevUpdate(self):
+    def test_net_dev_update(self):
         """ Verify netdev mount option setting after device creation. """
         netdev = FakeNetDev("net1")
-        dev = StorageDevice("dev1", fmt=getFormat("ext4"))
+        dev = StorageDevice("dev1", fmt=get_format("ext4"))
         self.assertFalse("_netdev" in dev.format.options.split(","))
 
         dev.parents.append(netdev)
diff --git a/tests/devices_test/partition_test.py b/tests/devices_test/partition_test.py
index f02dfc5..2035b44 100644
--- a/tests/devices_test/partition_test.py
+++ b/tests/devices_test/partition_test.py
@@ -8,23 +8,23 @@
 
 from blivet.devices import DiskFile
 from blivet.devices import PartitionDevice
-from blivet.formats import getFormat
+from blivet.formats import get_format
 from blivet.size import Size
 from blivet.util import sparsetmpfile
 
 class PartitionDeviceTestCase(unittest.TestCase):
 
-    def testTargetSize(self):
+    def test_target_size(self):
         with sparsetmpfile("targetsizetest", Size("10 MiB")) as disk_file:
             disk = DiskFile(disk_file)
-            disk.format = getFormat("disklabel", device=disk.path)
+            disk.format = get_format("disklabel", device=disk.path)
             grain_size = Size(disk.format.alignment.grainSize)
-            sector_size = Size(disk.format.partedDevice.sectorSize)
+            sector_size = Size(disk.format.parted_device.sectorSize)
             start = int(grain_size)
             orig_size = Size("6 MiB")
             end = start + int(orig_size / sector_size) - 1
-            disk.format.addPartition(start, end)
-            partition = disk.format.partedDisk.getPartitionBySector(start)
+            disk.format.add_partition(start, end)
+            partition = disk.format.parted_disk.getPartitionBySector(start)
             self.assertNotEqual(partition, None)
             self.assertEqual(orig_size, Size(partition.getLength(unit='B')))
 
@@ -32,167 +32,167 @@ def testTargetSize(self):
                                      size=orig_size)
             device.disk = disk
             device.exists = True
-            device.partedPartition = partition
+            device.parted_partition = partition
 
-            device.format = getFormat("ext4", device=device.path)
+            device.format = get_format("ext4", device=device.path)
             device.format.exists = True
             # grain size should be 1 MiB
-            device.format._minInstanceSize = Size("2 MiB") + (grain_size / 2)
+            device.format._min_instance_size = Size("2 MiB") + (grain_size / 2)
             device.format._resizable = True
 
             # Make sure things are as expected to begin with.
             self.assertEqual(device.size, orig_size)
-            self.assertEqual(device.minSize, Size("3 MiB"))
+            self.assertEqual(device.min_size, Size("3 MiB"))
             # start sector's at 1 MiB
-            self.assertEqual(device.maxSize, Size("9 MiB"))
+            self.assertEqual(device.max_size, Size("9 MiB"))
 
             # ValueError if not Size
             with self.assertRaisesRegex(ValueError,
                                          "new size must.*type Size"):
-                device.targetSize = 22
+                device.target_size = 22
 
-            self.assertEqual(device.targetSize, orig_size)
+            self.assertEqual(device.target_size, orig_size)
 
-            # ValueError if size smaller than minSize
+            # ValueError if size smaller than min_size
             with self.assertRaisesRegex(ValueError,
                                          "size.*smaller than the minimum"):
-                device.targetSize = Size("1 MiB")
+                device.target_size = Size("1 MiB")
 
-            self.assertEqual(device.targetSize, orig_size)
+            self.assertEqual(device.target_size, orig_size)
 
-            # ValueError if size larger than maxSize
+            # ValueError if size larger than max_size
             with self.assertRaisesRegex(ValueError,
                                          "size.*larger than the maximum"):
-                device.targetSize = Size("11 MiB")
+                device.target_size = Size("11 MiB")
 
-            self.assertEqual(device.targetSize, orig_size)
+            self.assertEqual(device.target_size, orig_size)
 
             # ValueError if unaligned
             with self.assertRaisesRegex(ValueError, "new size.*not.*aligned"):
-                device.targetSize = Size("3.1 MiB")
+                device.target_size = Size("3.1 MiB")
 
-            self.assertEqual(device.targetSize, orig_size)
+            self.assertEqual(device.target_size, orig_size)
 
             # successfully set a new target size
-            new_target = device.maxSize
-            device.targetSize = new_target
-            self.assertEqual(device.targetSize, new_target)
+            new_target = device.max_size
+            device.target_size = new_target
+            self.assertEqual(device.target_size, new_target)
             self.assertEqual(device.size, new_target)
-            parted_size = Size(device.partedPartition.getLength(unit='B'))
-            self.assertEqual(parted_size, device.targetSize)
+            parted_size = Size(device.parted_partition.getLength(unit='B'))
+            self.assertEqual(parted_size, device.target_size)
 
             # reset target size to original size
-            device.targetSize = orig_size
-            self.assertEqual(device.targetSize, orig_size)
+            device.target_size = orig_size
+            self.assertEqual(device.target_size, orig_size)
             self.assertEqual(device.size, orig_size)
-            parted_size = Size(device.partedPartition.getLength(unit='B'))
-            self.assertEqual(parted_size, device.targetSize)
+            parted_size = Size(device.parted_partition.getLength(unit='B'))
+            self.assertEqual(parted_size, device.target_size)
 
-    def testMinMaxSizeAlignment(self):
+    def test_min_max_size_alignment(self):
         with sparsetmpfile("minsizetest", Size("10 MiB")) as disk_file:
             disk = DiskFile(disk_file)
-            disk.format = getFormat("disklabel", device=disk.path)
+            disk.format = get_format("disklabel", device=disk.path)
             grain_size = Size(disk.format.alignment.grainSize)
-            sector_size = Size(disk.format.partedDevice.sectorSize)
+            sector_size = Size(disk.format.parted_device.sectorSize)
             start = int(grain_size)
             end = start + int(Size("6 MiB") / sector_size)
-            disk.format.addPartition(start, end)
-            partition = disk.format.partedDisk.getPartitionBySector(start)
+            disk.format.add_partition(start, end)
+            partition = disk.format.parted_disk.getPartitionBySector(start)
             self.assertNotEqual(partition, None)
 
             device = PartitionDevice(os.path.basename(partition.path))
             device.disk = disk
             device.exists = True
-            device.partedPartition = partition
+            device.parted_partition = partition
 
             # Typical sector size is 512 B.
             # Default optimum alignment grain size is 2048 sectors, or 1 MiB.
-            device.format = getFormat("ext4", device=device.path)
+            device.format = get_format("ext4", device=device.path)
             device.format.exists = True
-            device.format._minInstanceSize = Size("2 MiB") + (grain_size / 2)
+            device.format._min_instance_size = Size("2 MiB") + (grain_size / 2)
             device.format._resizable = True
 
             ##
-            ## minSize
+            ## min_size
             ##
 
             # The end sector based only on format min size should be unaligned.
-            min_sectors = int(device.format.minSize / sector_size)
+            min_sectors = int(device.format.min_size / sector_size)
             min_end_sector = partition.geometry.start + min_sectors - 1
             self.assertEqual(
-                disk.format.endAlignment.isAligned(partition.geometry,
+                disk.format.end_alignment.isAligned(partition.geometry,
                                                    min_end_sector),
                 False)
 
             # The end sector based on device min size should be aligned.
-            min_sectors = int(device.minSize / sector_size)
+            min_sectors = int(device.min_size / sector_size)
             min_end_sector = partition.geometry.start + min_sectors - 1
             self.assertEqual(
-                disk.format.endAlignment.isAligned(partition.geometry,
+                disk.format.end_alignment.isAligned(partition.geometry,
                                                    min_end_sector),
                 True)
 
             ##
-            ## maxSize
+            ## max_size
             ##
 
             # Add a partition starting three sectors past an aligned sector and
             # extending to the end of the disk so that there's a free region
             # immediately following the first partition with an unaligned end
             # sector.
-            free = disk.format.partedDisk.getFreeSpaceRegions()[-1]
+            free = disk.format.parted_disk.getFreeSpaceRegions()[-1]
             raw_start = int(Size("9 MiB") / sector_size)
             start = disk.format.alignment.alignUp(free, raw_start) + 3
-            disk.format.addPartition(start, disk.format.partedDevice.length - 1)
+            disk.format.add_partition(start, disk.format.parted_device.length - 1)
 
             # Verify the end of the free region immediately following the first
             # partition is unaligned.
-            free = disk.format.partedDisk.getFreeSpaceRegions()[1]
-            self.assertEqual(disk.format.endAlignment.isAligned(free, free.end),
+            free = disk.format.parted_disk.getFreeSpaceRegions()[1]
+            self.assertEqual(disk.format.end_alignment.isAligned(free, free.end),
                              False)
 
             # The end sector based on device min size should be aligned.
-            max_sectors = int(device.maxSize / sector_size)
+            max_sectors = int(device.max_size / sector_size)
             max_end_sector = partition.geometry.start + max_sectors - 1
             self.assertEqual(
-                disk.format.endAlignment.isAligned(free, max_end_sector),
+                disk.format.end_alignment.isAligned(free, max_end_sector),
                 True)
 
-    @patch("blivet.devices.partition.PartitionDevice.readCurrentSize", lambda part: part.size)
-    def testExtendedMinSize(self):
+    @patch("blivet.devices.partition.PartitionDevice.read_current_size", lambda part: part.size)
+    def test_extended_min_size(self):
         with sparsetmpfile("extendedtest", Size("10 MiB")) as disk_file:
             disk = DiskFile(disk_file)
-            disk.format = getFormat("disklabel", device=disk.path)
+            disk.format = get_format("disklabel", device=disk.path)
             grain_size = Size(disk.format.alignment.grainSize)
-            sector_size = Size(disk.format.partedDevice.sectorSize)
+            sector_size = Size(disk.format.parted_device.sectorSize)
 
             extended_start = int(grain_size)
             extended_end = extended_start + int(Size("6 MiB") / sector_size)
-            disk.format.addPartition(extended_start, extended_end, parted.PARTITION_EXTENDED)
-            extended = disk.format.extendedPartition
+            disk.format.add_partition(extended_start, extended_end, parted.PARTITION_EXTENDED)
+            extended = disk.format.extended_partition
             self.assertNotEqual(extended, None)
 
             extended_device = PartitionDevice(os.path.basename(extended.path))
             extended_device.disk = disk
             extended_device.exists = True
-            extended_device.partedPartition = extended
+            extended_device.parted_partition = extended
 
-            # no logical partitions --> min size should be max of 1 KiB and grainSize
-            self.assertEqual(extended_device.minSize,
-                             extended_device.alignTargetSize(max(grain_size, Size("1 KiB"))))
+            # no logical partitions --> min size should be max of 1 KiB and grain_size
+            self.assertEqual(extended_device.min_size,
+                             extended_device.align_target_size(max(grain_size, Size("1 KiB"))))
 
             logical_start = extended_start + 1
             logical_end = extended_end // 2
-            disk.format.addPartition(logical_start, logical_end, parted.PARTITION_LOGICAL)
-            logical = disk.format.partedDisk.getPartitionBySector(logical_start)
+            disk.format.add_partition(logical_start, logical_end, parted.PARTITION_LOGICAL)
+            logical = disk.format.parted_disk.getPartitionBySector(logical_start)
             self.assertNotEqual(logical, None)
 
             logical_device = PartitionDevice(os.path.basename(logical.path))
             logical_device.disk = disk
             logical_device.exists = True
-            logical_device.partedPartition = logical
+            logical_device.parted_partition = logical
 
             # logical partition present --> min size should be based on its end sector
             end_free = (extended_end - logical_end)*sector_size
-            self.assertEqual(extended_device.minSize,
-                             extended_device.alignTargetSize(extended_device.currentSize - end_free))
+            self.assertEqual(extended_device.min_size,
+                             extended_device.align_target_size(extended_device.current_size - end_free))
diff --git a/tests/devices_test/size_test.py b/tests/devices_test/size_test.py
index bb664bb..2a2e6d9 100644
--- a/tests/devices_test/size_test.py
+++ b/tests/devices_test/size_test.py
@@ -3,21 +3,21 @@
 
 from blivet.devices import StorageDevice
 from blivet import errors
-from blivet.formats import getFormat
+from blivet.formats import get_format
 from blivet.size import Size
 
 class StorageDeviceSizeTest(unittest.TestCase):
-    def _getDevice(self, *args, **kwargs):
+    def _get_device(self, *args, **kwargs):
         return StorageDevice(*args, **kwargs)
 
-    def testSizeSetter(self):
+    def test_size_setter(self):
         initial_size = Size('10 GiB')
         new_size = Size('2 GiB')
 
         ##
         ## setter sets the size
         ##
-        dev = self._getDevice('sizetest', size=initial_size)
+        dev = self._get_device('sizetest', size=initial_size)
         self.assertEqual(dev.size, initial_size)
 
         dev.size = new_size
@@ -26,38 +26,38 @@ def testSizeSetter(self):
         ##
         ## setter raises exn if size outside of format limits
         ##
-        dev.format._maxSize = Size("5 GiB")
+        dev.format._max_size = Size("5 GiB")
         with self.assertRaises(errors.DeviceError):
             dev.size = Size("6 GiB")
 
         ##
         ## new formats' min size is checked against device size
         ##
-        fmt = getFormat(None)
-        fmt._minSize = Size("10 GiB")
+        fmt = get_format(None)
+        fmt._min_size = Size("10 GiB")
         with self.assertRaises(errors.DeviceError):
             dev.format = fmt
 
         # the format assignment should succeed without the min size conflict
-        fmt._minSize = Size(0)
+        fmt._min_size = Size(0)
         dev.format = fmt
 
         ##
         ## new formats' max size is checked against device size
         ##
-        fmt = getFormat(None)
-        fmt._maxSize = Size("10 MiB")
+        fmt = get_format(None)
+        fmt._max_size = Size("10 MiB")
         with self.assertRaises(errors.DeviceError):
             dev.format = fmt
 
         # the format assignment should succeed without the min size conflict
-        fmt._maxSize = Size(0)
+        fmt._max_size = Size(0)
         dev.format = fmt
 
-    def testSizeGetter(self):
+    def test_size_getter(self):
         initial_size = Size("10 GiB")
         new_size = Size("5 GiB")
-        dev = self._getDevice('sizetest', size=initial_size)
+        dev = self._get_device('sizetest', size=initial_size)
 
         ##
         ## getter returns the size in the basic case for non-existing devices
@@ -65,7 +65,7 @@ def testSizeGetter(self):
         self.assertEqual(dev.size, initial_size)
 
         # create a new device that exists
-        dev = self._getDevice('sizetest', size=initial_size, exists=True)
+        dev = self._get_device('sizetest', size=initial_size, exists=True)
 
         ##
         ## getter returns the size in the basic case for existing devices
@@ -77,7 +77,7 @@ def testSizeGetter(self):
         ##
         # bypass the setter since the min/max will be the current size for a
         # non-resizable device
-        dev._targetSize = new_size
+        dev._target_size = new_size
         self.assertEqual(dev.size, initial_size)
 
         ##
@@ -85,15 +85,15 @@ def testSizeGetter(self):
         ## is non-zero
         ##
         dev._resizable = True
-        dev.targetSize = new_size # verify that the target size setter works
+        dev.target_size = new_size # verify that the target size setter works
         self.assertEqual(dev.size, new_size)
-        self.assertEqual(dev.size, dev.targetSize)
-        self.assertNotEqual(dev._size, dev.targetSize)
+        self.assertEqual(dev.size, dev.target_size)
+        self.assertNotEqual(dev._size, dev.target_size)
 
         ##
         ## getter returns current size when device is resizable and target size
         ## is zero
         ##
-        dev.targetSize = Size(0)
+        dev.target_size = Size(0)
         self.assertEqual(dev.size, initial_size)
-        self.assertEqual(dev.size, dev.currentSize)
+        self.assertEqual(dev.size, dev.current_size)
diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py
index 278e087..26bff3b 100644
--- a/tests/devicetree_test.py
+++ b/tests/devicetree_test.py
@@ -10,7 +10,7 @@
 from blivet.devices import LVMSnapShotDevice, LVMThinSnapShotDevice
 from blivet.devices import StorageDevice
 from blivet.devicetree import DeviceTree
-from blivet.formats import getFormat
+from blivet.formats import get_format
 
 """
     TODO:
@@ -22,36 +22,36 @@
 """
 
 class DeviceTreeTestCase(unittest.TestCase):
-    def testResolveDevice(self):
+    def test_resolve_device(self):
         dt = DeviceTree()
 
         dev1_label = "dev1_label"
         dev1_uuid = "1234-56-7890"
-        fmt1 = getFormat("ext4", label=dev1_label, uuid=dev1_uuid)
+        fmt1 = get_format("ext4", label=dev1_label, uuid=dev1_uuid)
         dev1 = StorageDevice("dev1", exists=True, fmt=fmt1)
-        dt._addDevice(dev1)
+        dt._add_device(dev1)
 
         dev2_label = "dev2_label"
-        fmt2 = getFormat("swap", label=dev2_label)
+        fmt2 = get_format("swap", label=dev2_label)
         dev2 = StorageDevice("dev2", exists=True, fmt=fmt2)
-        dt._addDevice(dev2)
+        dt._add_device(dev2)
 
         dev3 = StorageDevice("sdp2", exists=True)
-        dt._addDevice(dev3)
+        dt._add_device(dev3)
 
-        dt.eddDict.update({"dev1": 0x81,
+        dt.edd_dict.update({"dev1": 0x81,
                            "dev2": 0x82})
 
-        self.assertEqual(dt.resolveDevice(dev1.name), dev1)
-        self.assertEqual(dt.resolveDevice("LABEL=%s" % dev1_label), dev1)
-        self.assertEqual(dt.resolveDevice("UUID=%s" % dev1_label), None)
-        self.assertEqual(dt.resolveDevice("UUID=%s" % dev1_uuid), dev1)
-        self.assertEqual(dt.resolveDevice("/dev/dev1"), dev1)
+        self.assertEqual(dt.resolve_device(dev1.name), dev1)
+        self.assertEqual(dt.resolve_device("LABEL=%s" % dev1_label), dev1)
+        self.assertEqual(dt.resolve_device("UUID=%s" % dev1_label), None)
+        self.assertEqual(dt.resolve_device("UUID=%s" % dev1_uuid), dev1)
+        self.assertEqual(dt.resolve_device("/dev/dev1"), dev1)
 
-        self.assertEqual(dt.resolveDevice("dev2"), dev2)
-        self.assertEqual(dt.resolveDevice("0x82"), dev2)
+        self.assertEqual(dt.resolve_device("dev2"), dev2)
+        self.assertEqual(dt.resolve_device("0x82"), dev2)
 
-        self.assertEqual(dt.resolveDevice(dev3.name), dev3)
+        self.assertEqual(dt.resolve_device(dev3.name), dev3)
 
 def recursive_getattr(x, attr, default=None):
     """ Resolve a possibly-dot-containing attribute name. """
@@ -86,7 +86,7 @@ def collect_expected_data(self):
                             if d.disks and
                                set(d.disks).issubset(set(self.blivet.disks))):
             attr_dict = {}
-            device._partedDevice = None # force update from disk for size, &c
+            device._parted_device = None # force update from disk for size, &c
             for attr in self._validate_attrs:
                 attr_dict[attr] = recursive_getattr(device, attr)
 
@@ -106,10 +106,10 @@ def tearDown(self):
 
         # XXX The only reason for this may be lvmetad
         for disk in self.blivet.disks:
-            self.blivet.recursiveRemove(disk)
+            self.blivet.recursive_remove(disk)
 
         try:
-            self.blivet.doIt()
+            self.blivet.do_it()
         except Exception:
             self.blivet.reset()
             raise
@@ -131,7 +131,7 @@ def find_device(self, attr_dict):
 
         return device
 
-    def runTest(self):
+    def run_test(self):
         """ Verify that the devices and their attributes match across reset. """
         #
         # populate the devicetree
@@ -163,17 +163,17 @@ class LVMTestCase(BlivetResetTestCase):
     """ Test that the devicetree can populate with the product of autopart. """
     def _set_up_storage(self):
         # This isn't exactly autopart, but it should be plenty close to it.
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                                   Size("500 MiB"),
                                   disks=self.blivet.disks[:],
                                   fstype="swap")
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                                   None,
                                   disks=self.blivet.disks[:])
 
 class LVMSnapShotTestCase(BlivetResetTestCase):
     def _set_up_storage(self):
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                                   Size("1 GiB"),
                                   label="ROOT",
                                   disks=self.blivet.disks[:],
@@ -185,8 +185,8 @@ def setUp(self):
         root = self.blivet.lvs[0]
         snap = LVMSnapShotDevice("rootsnap1", parents=[root.vg], origin=root,
                                  size=Size("768MiB"))
-        self.blivet.createDevice(snap)
-        self.blivet.doIt()
+        self.blivet.create_device(snap)
+        self.blivet.do_it()
 
         self.device_attr_dicts = []
         self.collect_expected_data()
@@ -194,18 +194,18 @@ def setUp(self):
 
 class LVMThinpTestCase(BlivetResetTestCase):
     def _set_up_storage(self):
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                                   Size("500 MiB"),
                                   fstype="swap",
                                   disks=self.blivet.disks[:])
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM_THINP,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_THINP,
                                   None,
                                   label="ROOT",
                                   disks=self.blivet.disks[:])
 
 class LVMThinSnapShotTestCase(LVMThinpTestCase):
     def _set_up_storage(self):
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM_THINP,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_THINP,
                                   Size("1 GiB"),
                                   label="ROOT",
                                   disks=self.blivet.disks[:])
@@ -216,8 +216,8 @@ def setUp(self):
         root = self.blivet.thinlvs[0]
         snap = LVMThinSnapShotDevice("rootsnap1", parents=[root.pool],
                                      origin=root)
-        self.blivet.createDevice(snap)
-        self.blivet.doIt()
+        self.blivet.create_device(snap)
+        self.blivet.do_it()
 
         self.device_attr_dicts = []
         self.collect_expected_data()
@@ -225,7 +225,7 @@ def setUp(self):
 class LVMRaidTestCase(BlivetResetTestCase):
     def _set_up_storage(self):
         # This isn't exactly autopart, but it should be plenty close to it.
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                           Size("500 MiB"),
                           disks=self.blivet.disks[:],
                           container_size=devicefactory.SIZE_POLICY_MAX)
@@ -246,7 +246,7 @@ class MDRaid0TestCase(BlivetResetTestCase):
     _validate_attrs = BlivetResetTestCase._validate_attrs + ["level", "spares"]
 
     def set_up_disks(self):
-        level = devicelibs.mdraid.RAID_levels.raidLevel(self.level)
+        level = devicelibs.mdraid.RAID_levels.raid_level(self.level)
         disk_count = level.min_members
         self.disks = dict()
         for i in range(disk_count):
@@ -258,42 +258,42 @@ def set_up_disks(self):
 
     def skip_attr(self, device, attr):
         return (attr in ["name", "path"] and
-                getattr(device, "metadataVersion", "").startswith("0.9"))
+                getattr(device, "metadata_version", "").startswith("0.9"))
 
     def _set_up_storage(self):
-        device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
+        device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
                                            Size("200 MiB"),
                                            disks=self.blivet.disks[:],
                                            raid_level=self.level,
                                            label="v090",
                                            name="2")
-        device.metadataVersion = "0.90"
+        device.metadata_version = "0.90"
 
-        device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
+        device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
                                            Size("200 MiB"),
                                            disks=self.blivet.disks[:],
                                            raid_level=self.level,
                                            label="v1",
                                            name="one")
-        device.metadataVersion = "1.0"
+        device.metadata_version = "1.0"
 
-        device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
+        device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
                                            Size("200 MiB"),
                                            disks=self.blivet.disks[:],
                                            raid_level=self.level,
                                            label="v11",
                                            name="oneone")
-        device.metadataVersion = "1.1"
+        device.metadata_version = "1.1"
 
-        device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
+        device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
                                            Size("200 MiB"),
                                            disks=self.blivet.disks[:],
                                            raid_level=self.level,
                                            label="v12",
                                            name="onetwo")
-        device.metadataVersion = "1.2"
+        device.metadata_version = "1.2"
 
-        device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
+        device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
                                            Size("200 MiB"),
                                            disks=self.blivet.disks[:],
                                            raid_level=self.level,
@@ -304,12 +304,12 @@ def _set_up_storage(self):
 class LVMOnMDTestCase(BlivetResetTestCase):
     # This also tests raid1 with the default metadata version.
     def _set_up_storage(self):
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                                   Size("200 MiB"),
                                   disks=self.blivet.disks[:],
                                   container_raid_level="raid1",
                                   fstype="swap")
-        self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
+        self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
                                   None,
                                   disks=self.blivet.disks[:],
                                   container_raid_level="raid1")
diff --git a/tests/formats_test/device_test.py b/tests/formats_test/device_test.py
index ea58640..0f4c9d2 100644
--- a/tests/formats_test/device_test.py
+++ b/tests/formats_test/device_test.py
@@ -4,7 +4,7 @@
 
 class DeviceFormatTestCase(unittest.TestCase):
 
-    def testFormats(self):
+    def test_formats(self):
         absolute_path = "/abs/path"
         host_path = "host:path"
         garbage = "abc#<def>"
@@ -52,7 +52,7 @@ def testFormats(self):
 
 class DeviceValueTestCase(unittest.TestCase):
 
-    def testValue(self):
+    def test_value(self):
         for fclass in blivet.formats.device_formats.values():
             an_fs = fclass()
 
diff --git a/tests/formats_test/disklabel_test.py b/tests/formats_test/disklabel_test.py
index 363e952..ef67643 100644
--- a/tests/formats_test/disklabel_test.py
+++ b/tests/formats_test/disklabel_test.py
@@ -13,24 +13,24 @@
 patch = mock.patch
 
 class DiskLabelTestCase(unittest.TestCase):
-    @patch("blivet.formats.disklabel.DiskLabel.freshPartedDisk", None)
-    def testGetAlignment(self):
+    @patch("blivet.formats.disklabel.DiskLabel.fresh_parted_disk", None)
+    def test_get_alignment(self):
         dl = blivet.formats.disklabel.DiskLabel()
-        dl._partedDisk = mock.Mock()
-        dl._partedDevice = mock.Mock()
-        dl._partedDevice.sectorSize = 512
+        dl._parted_disk = mock.Mock()
+        dl._parted_device = mock.Mock()
+        dl._parted_device.sectorSize = 512
 
         # 512 byte grain sze
         disklabel_alignment = parted.Alignment(grainSize=1, offset=0)
-        dl._partedDisk.partitionAlignment = disklabel_alignment
+        dl._parted_disk.partitionAlignment = disklabel_alignment
 
         # 1 MiB grain size
         minimal_alignment = parted.Alignment(grainSize = 2048, offset=0)
-        dl._partedDevice.minimumAlignment = minimal_alignment
+        dl._parted_device.minimumAlignment = minimal_alignment
 
         # 4 MiB grain size
         optimal_alignment = parted.Alignment(grainSize=8192, offset=0)
-        dl._partedDevice.optimumAlignment = optimal_alignment
+        dl._parted_device.optimumAlignment = optimal_alignment
 
         # expected end alignments
         optimal_end_alignment = parted.Alignment(
@@ -41,26 +41,26 @@ def testGetAlignment(self):
                                         offset=-1)
 
         # make sure the private methods all return the expected values
-        self.assertEqual(dl._getDiskLabelAlignment(), disklabel_alignment)
-        self.assertEqual(dl._getMinimalAlignment(), minimal_alignment)
-        self.assertEqual(dl._getOptimalAlignment(), optimal_alignment)
+        self.assertEqual(dl._get_disk_label_alignment(), disklabel_alignment)
+        self.assertEqual(dl._get_minimal_alignment(), minimal_alignment)
+        self.assertEqual(dl._get_optimal_alignment(), optimal_alignment)
 
-        # validate result when passing a start alignment to getEndAlignment
-        self.assertEqual(dl.getEndAlignment(alignment=optimal_alignment),
+        # validate result when passing a start alignment to get_end_alignment
+        self.assertEqual(dl.get_end_alignment(alignment=optimal_alignment),
                                             optimal_end_alignment)
-        self.assertEqual(dl.getEndAlignment(alignment=minimal_alignment),
+        self.assertEqual(dl.get_end_alignment(alignment=minimal_alignment),
                          minimal_end_alignment)
 
         # by default we should return the optimal alignment
-        self.assertEqual(dl.getAlignment(), optimal_alignment)
-        self.assertEqual(dl.getEndAlignment(), optimal_end_alignment)
+        self.assertEqual(dl.get_alignment(), optimal_alignment)
+        self.assertEqual(dl.get_end_alignment(), optimal_end_alignment)
 
         # when passed a size smaller than the optimal io size we should return
         # the minimal alignment
-        self.assertEqual(dl.getAlignment(size=Size("2 MiB")), minimal_alignment)
-        self.assertEqual(dl.getEndAlignment(size=Size("2 MiB")),
+        self.assertEqual(dl.get_alignment(size=Size("2 MiB")), minimal_alignment)
+        self.assertEqual(dl.get_end_alignment(size=Size("2 MiB")),
                          minimal_end_alignment)
 
         # test the old deprecated properties' values
-        self.assertEqual(dl.alignment, dl._getOptimalAlignment())
-        self.assertEqual(dl.endAlignment, dl.getEndAlignment())
+        self.assertEqual(dl.alignment, dl._get_optimal_alignment())
+        self.assertEqual(dl.end_alignment, dl.get_end_alignment())
diff --git a/tests/formats_test/fs_test.py b/tests/formats_test/fs_test.py
index 70216d3..6026216 100644
--- a/tests/formats_test/fs_test.py
+++ b/tests/formats_test/fs_test.py
@@ -56,7 +56,7 @@ class MacEFIFSTestCase(HFSPlusTestCase):
 class NTFSTestCase(fstesting.FSAsRoot):
     _fs_class = fs.NTFS
 
- at unittest.skip("Unable to create because device fails deviceCheck().")
+ at unittest.skip("Unable to create because device fails device_check().")
 class NFSTestCase(fstesting.FSAsRoot):
     _fs_class = fs.NFS
 
@@ -93,20 +93,20 @@ class BindFSTestCase(fstesting.FSAsRoot):
 
 class SimpleTmpFSTestCase(loopbackedtestcase.LoopBackedTestCase):
 
-    def __init__(self, methodName='runTest'):
+    def __init__(self, methodName='run_test'):
         super(SimpleTmpFSTestCase, self).__init__(methodName=methodName)
 
-    def testSimple(self):
+    def test_simple(self):
         an_fs = fs.TmpFS()
 
         # a nodev fs need not have been created to exist
         self.assertTrue(an_fs.exists)
         self.assertEqual(an_fs.device, "tmpfs")
-        self.assertTrue(an_fs.testMount())
+        self.assertTrue(an_fs.test_mount())
 
 class ResizeTmpFSTestCase(loopbackedtestcase.LoopBackedTestCase):
 
-    def __init__(self, methodName='runTest'):
+    def __init__(self, methodName='run_test'):
         super(ResizeTmpFSTestCase, self).__init__(methodName=methodName)
         self.an_fs = fs.TmpFS()
         self.an_fs.__class__._resizable = True
@@ -117,20 +117,20 @@ def setUp(self):
         self.an_fs.mountpoint = self.mountpoint
         self.an_fs.mount()
 
-    def testResize(self):
-        self.an_fs.updateSizeInfo()
-        newsize = self.an_fs.currentSize * 2
-        self.an_fs.targetSize = newsize
-        self.assertIsNone(self.an_fs.doResize())
-        self.assertEqual(self.an_fs.size, newsize.roundToNearest(self.an_fs._resize.unit, rounding=ROUND_DOWN))
+    def test_resize(self):
+        self.an_fs.update_size_info()
+        newsize = self.an_fs.current_size * 2
+        self.an_fs.target_size = newsize
+        self.assertIsNone(self.an_fs.do_resize())
+        self.assertEqual(self.an_fs.size, newsize.round_to_nearest(self.an_fs._resize.unit, rounding=ROUND_DOWN))
 
-    def testShrink(self):
+    def test_shrink(self):
         # Can not shrink tmpfs, because its minimum size is its current size
-        self.an_fs.updateSizeInfo()
+        self.an_fs.update_size_info()
         newsize = Size("2 MiB")
-        self.assertTrue(newsize < self.an_fs.currentSize)
+        self.assertTrue(newsize < self.an_fs.current_size)
         with self.assertRaises(ValueError):
-            self.an_fs.targetSize = newsize
+            self.an_fs.target_size = newsize
 
     def tearDown(self):
         try:
diff --git a/tests/formats_test/fslabeling.py b/tests/formats_test/fslabeling.py
index 890afe1..ccf23f9 100644
--- a/tests/formats_test/fslabeling.py
+++ b/tests/formats_test/fslabeling.py
@@ -20,8 +20,8 @@ class LabelingAsRoot(loopbackedtestcase.LoopBackedTestCase):
     _invalid_label = abc.abstractproperty(
        doc="A label which is invalid for this filesystem.")
 
-    def __init__(self, methodName='runTest'):
-        super(LabelingAsRoot, self).__init__(methodName=methodName, deviceSpec=[Size("100 MiB")])
+    def __init__(self, methodName='run_test'):
+        super(LabelingAsRoot, self).__init__(methodName=methodName, device_spec=[Size("100 MiB")])
 
     def setUp(self):
         an_fs = self._fs_class()
@@ -31,47 +31,47 @@ def setUp(self):
             self.skipTest("can not label filesystem %s" % an_fs.name)
         super(LabelingAsRoot, self).setUp()
 
-    def testLabeling(self):
+    def test_labeling(self):
         """A sequence of tests of filesystem labeling.
 
            * create the filesystem when passing an invalid label
            * raise an exception when reading the filesystem
            * raise an exception when relabeling the filesystem
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label=self._invalid_label)
-        if an_fs._readlabel.availabilityErrors or not an_fs.relabels():
+        an_fs = self._fs_class(device=self.loop_devices[0], label=self._invalid_label)
+        if an_fs._readlabel.availability_errors or not an_fs.relabels():
             self.skipTest("can not read or write label for filesystem %s" % an_fs.name)
         self.assertIsNone(an_fs.create())
 
         with self.assertRaises(FSReadLabelError):
-            an_fs.readLabel()
+            an_fs.read_label()
 
         an_fs.label = "an fs"
         with self.assertRaises(FSError):
-            an_fs.writeLabel()
+            an_fs.write_label()
 
-    def testCreating(self):
+    def test_creating(self):
         """Create the filesystem when passing a valid label """
-        an_fs = self._fs_class(device=self.loopDevices[0], label="start")
+        an_fs = self._fs_class(device=self.loop_devices[0], label="start")
         self.assertIsNone(an_fs.create())
 
-    def testCreatingNone(self):
+    def test_creating_none(self):
         """Create the filesystem when passing None
            (indicates filesystem default)
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label=None)
+        an_fs = self._fs_class(device=self.loop_devices[0], label=None)
         self.assertIsNone(an_fs.create())
 
-    def testCreatingEmpty(self):
+    def test_creating_empty(self):
         """Create the filesystem when passing the empty label."""
-        an_fs = self._fs_class(device=self.loopDevices[0], label="")
+        an_fs = self._fs_class(device=self.loop_devices[0], label="")
         self.assertIsNone(an_fs.create())
 
 class LabelingWithRelabeling(LabelingAsRoot):
     """Tests labeling where it is possible to relabel.
     """
 
-    def testLabeling(self):
+    def test_labeling(self):
         """A sequence of tests of filesystem labeling.
 
            * create the filesystem when passing an invalid label
@@ -81,34 +81,34 @@ def testLabeling(self):
            * raise an exception when relabeling when None is specified
            * raise an exception when relabeling with an invalid label
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label=self._invalid_label)
-        if an_fs._readlabel.availabilityErrors or not an_fs.relabels():
+        an_fs = self._fs_class(device=self.loop_devices[0], label=self._invalid_label)
+        if an_fs._readlabel.availability_errors or not an_fs.relabels():
             self.skipTest("can not read or write label for filesystem %s" % an_fs.name)
         self.assertIsNone(an_fs.create())
 
         with self.assertRaises(FSReadLabelError):
-            an_fs.readLabel()
+            an_fs.read_label()
 
         an_fs.label = "an fs"
-        self.assertIsNone(an_fs.writeLabel())
+        self.assertIsNone(an_fs.write_label())
 
         an_fs.label = ""
-        self.assertIsNone(an_fs.writeLabel())
+        self.assertIsNone(an_fs.write_label())
 
         an_fs.label = None
         with self.assertRaisesRegex(FSError, "default label"):
-            an_fs.writeLabel()
+            an_fs.write_label()
 
         an_fs.label = self._invalid_label
         with self.assertRaisesRegex(FSError, "bad label format"):
-            an_fs.writeLabel()
+            an_fs.write_label()
 
 class CompleteLabelingAsRoot(LabelingAsRoot):
     """Tests where it is possible to read the label and to relabel
        an existing filesystem.
     """
 
-    def testLabeling(self):
+    def test_labeling(self):
         """A sequence of tests of filesystem labeling.
 
            * create the filesystem when passing an invalid label
@@ -120,54 +120,54 @@ def testLabeling(self):
            * raise an exception when relabeling when None is specified
            * raise an exception when relabeling with an invalid label
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label=self._invalid_label)
-        if an_fs._readlabel.availabilityErrors or not an_fs.relabels():
+        an_fs = self._fs_class(device=self.loop_devices[0], label=self._invalid_label)
+        if an_fs._readlabel.availability_errors or not an_fs.relabels():
             self.skipTest("can not read or write label for filesystem %s" % an_fs.name)
         self.assertIsNone(an_fs.create())
-        self.assertEqual(an_fs.readLabel(), an_fs._labelfs.default_label)
+        self.assertEqual(an_fs.read_label(), an_fs._labelfs.default_label)
 
         an_fs.label = "an_fs"
-        self.assertIsNone(an_fs.writeLabel())
-        self.assertEqual(an_fs.readLabel(), an_fs.label)
+        self.assertIsNone(an_fs.write_label())
+        self.assertEqual(an_fs.read_label(), an_fs.label)
 
         an_fs.label = ""
-        self.assertIsNone(an_fs.writeLabel())
-        self.assertEqual(an_fs.readLabel(), an_fs.label)
+        self.assertIsNone(an_fs.write_label())
+        self.assertEqual(an_fs.read_label(), an_fs.label)
 
         an_fs.label = None
         with self.assertRaisesRegex(FSError, "default label"):
-            an_fs.writeLabel()
+            an_fs.write_label()
 
         an_fs.label = "n" * 129
         with self.assertRaisesRegex(FSError, "bad label format"):
-            an_fs.writeLabel()
+            an_fs.write_label()
 
-    def testCreating(self):
+    def test_creating(self):
         """Create the filesystem when passing a valid label.
            Verify that the filesystem has that label.
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label="start")
-        if an_fs._readlabel.availabilityErrors:
+        an_fs = self._fs_class(device=self.loop_devices[0], label="start")
+        if an_fs._readlabel.availability_errors:
             self.skipTest("can not read label for filesystem %s" % an_fs.name)
         self.assertIsNone(an_fs.create())
-        self.assertEqual(an_fs.readLabel(), "start")
+        self.assertEqual(an_fs.read_label(), "start")
 
-    def testCreatingNone(self):
+    def test_creating_none(self):
         """Create a filesystem with the label None.
            Verify that the filesystem has the default label.
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label=None)
-        if an_fs._readlabel.availabilityErrors:
+        an_fs = self._fs_class(device=self.loop_devices[0], label=None)
+        if an_fs._readlabel.availability_errors:
             self.skipTest("can not read label for filesystem %s" % an_fs.name)
         self.assertIsNone(an_fs.create())
-        self.assertEqual(an_fs.readLabel(), an_fs._labelfs.default_label)
+        self.assertEqual(an_fs.read_label(), an_fs._labelfs.default_label)
 
-    def testCreatingEmpty(self):
+    def test_creating_empty(self):
         """Create a filesystem with an empty label.
            Verify that the filesystem has the empty label.
         """
-        an_fs = self._fs_class(device=self.loopDevices[0], label="")
-        if an_fs._readlabel.availabilityErrors:
+        an_fs = self._fs_class(device=self.loop_devices[0], label="")
+        if an_fs._readlabel.availability_errors:
             self.skipTest("can not read label for filesystem %s" % an_fs.name)
         self.assertIsNone(an_fs.create())
-        self.assertEqual(an_fs.readLabel(), "")
+        self.assertEqual(an_fs.read_label(), "")
diff --git a/tests/formats_test/fstesting.py b/tests/formats_test/fstesting.py
index 32c85af..f4dc563 100644
--- a/tests/formats_test/fstesting.py
+++ b/tests/formats_test/fstesting.py
@@ -17,7 +17,7 @@ def can_resize(an_fs):
         :param an_fs: a filesystem object
     """
     resize_tasks = (an_fs._resize, an_fs._sizeinfo, an_fs._minsize)
-    return not any(t.availabilityErrors for t in resize_tasks)
+    return not any(t.availability_errors for t in resize_tasks)
 
 @add_metaclass(abc.ABCMeta)
 class FSAsRoot(loopbackedtestcase.LoopBackedTestCase):
@@ -27,8 +27,8 @@ class FSAsRoot(loopbackedtestcase.LoopBackedTestCase):
 
     _DEVICE_SIZE = Size("100 MiB")
 
-    def __init__(self, methodName='runTest'):
-        super(FSAsRoot, self).__init__(methodName=methodName, deviceSpec=[self._DEVICE_SIZE])
+    def __init__(self, methodName='run_test'):
+        super(FSAsRoot, self).__init__(methodName=methodName, device_spec=[self._DEVICE_SIZE])
 
     def _test_sizes(self, an_fs):
         """ Test relationships between different size values.
@@ -37,16 +37,16 @@ def _test_sizes(self, an_fs):
             the size and minimum size information has been updated.
         """
         _size = an_fs._size
-        min_size = an_fs.minSize
+        min_size = an_fs.min_size
 
-        # If resizable, size is targetSize
+        # If resizable, size is target_size
         if an_fs.resizable:
-            expected_size = an_fs._targetSize
+            expected_size = an_fs._target_size
         # If not resizable
         else:
             expected_size = _size
             # If the size can be obtained it will not be 0
-            if not an_fs._sizeinfo.availabilityErrors:
+            if not an_fs._sizeinfo.availability_errors:
                 self.assertNotEqual(expected_size, Size(0))
                 self.assertTrue(expected_size <= self._DEVICE_SIZE)
             # Otherwise it will be 0, assuming the device was not initialized
@@ -56,26 +56,26 @@ def _test_sizes(self, an_fs):
         self.assertEqual(an_fs.size, expected_size)
 
         # Only the resizable filesystems can figure out their current min size
-        if not an_fs._sizeinfo.availabilityErrors:
+        if not an_fs._sizeinfo.availability_errors:
             expected_min_size = min_size
         else:
-            expected_min_size = an_fs._minSize
-        self.assertEqual(an_fs.minSize, expected_min_size)
+            expected_min_size = an_fs._min_size
+        self.assertEqual(an_fs.min_size, expected_min_size)
 
-        # maxSize is a nice simple constant because it is just about
+        # max_size is a nice simple constant because it is just about
         # what the filesystem can represent
-        self.assertEqual(an_fs.maxSize, an_fs._maxSize)
+        self.assertEqual(an_fs.max_size, an_fs._max_size)
 
-        # Since the device exists, currentSize will always be the real size
-        self.assertEqual(an_fs.currentSize, _size)
+        # Since the device exists, current_size will always be the real size
+        self.assertEqual(an_fs.current_size, _size)
 
         # Free is the actual size - the minimum size
         self.assertEqual(an_fs.free, max(Size(0), _size - expected_min_size))
 
         # target size is set by side-effect
-        self.assertEqual(an_fs.targetSize, an_fs._targetSize)
+        self.assertEqual(an_fs.target_size, an_fs._target_size)
 
-    def testInstantiation(self):
+    def test_instantiation(self):
         # Accept default size
         an_fs = self._fs_class()
         self.assertFalse(an_fs.exists)
@@ -85,142 +85,142 @@ def testInstantiation(self):
         self.assertEqual(an_fs.resizable, False)
 
         # sizes
-        expected_min_size = Size(0) if can_resize(an_fs) else an_fs._minSize
-        self.assertEqual(an_fs.minSize, expected_min_size)
+        expected_min_size = Size(0) if can_resize(an_fs) else an_fs._min_size
+        self.assertEqual(an_fs.min_size, expected_min_size)
 
-        self.assertEqual(an_fs.maxSize, an_fs._maxSize)
+        self.assertEqual(an_fs.max_size, an_fs._max_size)
         self.assertEqual(an_fs.size, Size(0))
-        self.assertEqual(an_fs.currentSize, Size(0))
+        self.assertEqual(an_fs.current_size, Size(0))
         self.assertEqual(an_fs.free, Size(0))
-        self.assertEqual(an_fs.targetSize, Size(0))
+        self.assertEqual(an_fs.target_size, Size(0))
 
         # Choose a size
         NEW_SIZE = Size("32 MiB")
         an_fs = self._fs_class(size=NEW_SIZE)
 
         # sizes
-        expected_min_size = Size(0) if can_resize(an_fs) else an_fs._minSize
-        self.assertEqual(an_fs.minSize, expected_min_size)
+        expected_min_size = Size(0) if can_resize(an_fs) else an_fs._min_size
+        self.assertEqual(an_fs.min_size, expected_min_size)
 
-        self.assertEqual(an_fs.maxSize, an_fs._maxSize)
+        self.assertEqual(an_fs.max_size, an_fs._max_size)
         self.assertEqual(an_fs.size, NEW_SIZE)
-        self.assertEqual(an_fs.currentSize, Size(0))
+        self.assertEqual(an_fs.current_size, Size(0))
         self.assertEqual(an_fs.free, Size(0))
-        self.assertEqual(an_fs.targetSize, NEW_SIZE)
+        self.assertEqual(an_fs.target_size, NEW_SIZE)
 
-    def testCreation(self):
+    def test_creation(self):
         an_fs = self._fs_class()
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
         self.assertEqual(an_fs.resizable, False)
         self.assertTrue(an_fs.exists)
-        self.assertIsNone(an_fs.doCheck())
+        self.assertIsNone(an_fs.do_check())
 
-        expected_min_size = Size(0) if can_resize(an_fs) else an_fs._minSize
-        self.assertEqual(an_fs.minSize, expected_min_size)
+        expected_min_size = Size(0) if can_resize(an_fs) else an_fs._min_size
+        self.assertEqual(an_fs.min_size, expected_min_size)
 
-        self.assertEqual(an_fs.maxSize, an_fs._maxSize)
+        self.assertEqual(an_fs.max_size, an_fs._max_size)
         self.assertEqual(an_fs.size, Size(0))
-        self.assertEqual(an_fs.currentSize, Size(0))
+        self.assertEqual(an_fs.current_size, Size(0))
         self.assertEqual(an_fs.free, Size(0))
-        self.assertEqual(an_fs.targetSize, Size(0))
+        self.assertEqual(an_fs.target_size, Size(0))
 
-    def testLabeling(self):
+    def test_labeling(self):
         an_fs = self._fs_class()
         if not an_fs.formattable or not an_fs.labeling():
             self.skipTest("can not label filesystem %s" % an_fs.name)
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         an_fs.label = "label"
-        self.assertTrue(an_fs.labelFormatOK("label"))
+        self.assertTrue(an_fs.label_format_ok("label"))
         self.assertIsNone(an_fs.create())
         try:
-            label = an_fs.readLabel()
+            label = an_fs.read_label()
             self.assertEqual(label, "label")
         except FSError:
             pass
 
-    def testRelabeling(self):
+    def test_relabeling(self):
         an_fs = self._fs_class()
         if not an_fs.formattable or not an_fs.labeling():
             self.skipTest("can not label filesystem %s" % an_fs.name)
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
         an_fs.label = "label"
-        self.assertTrue(an_fs.labelFormatOK("label"))
+        self.assertTrue(an_fs.label_format_ok("label"))
         if an_fs.relabels():
-            self.assertIsNone(an_fs.writeLabel())
+            self.assertIsNone(an_fs.write_label())
         else:
             with self.assertRaises(FSError):
-                an_fs.writeLabel()
+                an_fs.write_label()
 
-    def testMounting(self):
+    def test_mounting(self):
         an_fs = self._fs_class()
         # FIXME: BTRFS fails to mount
         if isinstance(an_fs, fs.BTRFS):
             self.skipTest("no mounting filesystem %s" % an_fs.name)
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        self.assertTrue(an_fs.testMount())
+        self.assertTrue(an_fs.test_mount())
 
-    def testMountpoint(self):
+    def test_mountpoint(self):
         an_fs = self._fs_class()
         # FIXME: BTRFS fails to mount
         if isinstance(an_fs, fs.BTRFS):
             self.skipTest("no mounting filesystem %s" % an_fs.name)
         if not an_fs.formattable or not an_fs.mountable:
             self.skipTest("can not create or mount filesystem %s" % an_fs.name)
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
         mountpoint = tempfile.mkdtemp()
         an_fs.mount(mountpoint=mountpoint)
-        self.assertEqual(an_fs.systemMountpoint, mountpoint)
+        self.assertEqual(an_fs.system_mountpoint, mountpoint)
         an_fs.unmount()
-        self.assertIsNone(an_fs.systemMountpoint)
+        self.assertIsNone(an_fs.system_mountpoint)
         os.rmdir(mountpoint)
 
-    def testResize(self):
+    def test_resize(self):
         an_fs = self._fs_class()
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
+        an_fs.update_size_info()
 
         self._test_sizes(an_fs)
-        # CHECKME: target size is still 0 after updatedSizeInfo is called.
+        # CHECKME: target size is still 0 after updated_size_info is called.
         self.assertEqual(an_fs.size, Size(0) if an_fs.resizable else an_fs._size)
 
         if not can_resize(an_fs):
             self.assertFalse(an_fs.resizable)
             # Not resizable, so can not do resizing actions.
             with self.assertRaises(FSError):
-                an_fs.targetSize = Size("64 MiB")
+                an_fs.target_size = Size("64 MiB")
             with self.assertRaises(FSError):
-                an_fs.doResize()
+                an_fs.do_resize()
         else:
             self.assertTrue(an_fs.resizable)
             # Try a reasonable target size
             TARGET_SIZE = Size("64 MiB")
-            an_fs.targetSize = TARGET_SIZE
-            self.assertEqual(an_fs.targetSize, TARGET_SIZE)
+            an_fs.target_size = TARGET_SIZE
+            self.assertEqual(an_fs.target_size, TARGET_SIZE)
             self.assertNotEqual(an_fs._size, TARGET_SIZE)
-            self.assertIsNone(an_fs.doResize())
-            ACTUAL_SIZE = TARGET_SIZE.roundToNearest(an_fs._resize.unit, rounding=ROUND_DOWN)
+            self.assertIsNone(an_fs.do_resize())
+            ACTUAL_SIZE = TARGET_SIZE.round_to_nearest(an_fs._resize.unit, rounding=ROUND_DOWN)
             self.assertEqual(an_fs.size, ACTUAL_SIZE)
             self.assertEqual(an_fs._size, ACTUAL_SIZE)
             self._test_sizes(an_fs)
 
         # and no errors should occur when checking
-        self.assertIsNone(an_fs.doCheck())
+        self.assertIsNone(an_fs.do_check())
 
-    def testNoExplicitTargetSize(self):
-        """ Because _targetSize has not been set, resize sets to min size. """
+    def test_no_explicit_target_size(self):
+        """ Because _target_size has not been set, resize sets to min size. """
         # CHECK ME: This is debatable, maybe target size should be set to
-        # _size if it is not set when size is calculated. Note that _targetSize
+        # _size if it is not set when size is calculated. Note that _target_size
         # gets value of _size in constructor, so if _size is set to not-zero
         # in constructor call behavior would be different.
 
@@ -230,20 +230,20 @@ def testNoExplicitTargetSize(self):
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
 
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
-
-        self.assertNotEqual(an_fs.currentSize, an_fs.targetSize)
-        self.assertEqual(an_fs.currentSize, an_fs._size)
-        self.assertEqual(an_fs.targetSize, Size(0))
-        self.assertIsNone(an_fs.doResize())
-        self.assertEqual(an_fs.currentSize, an_fs.minSize)
-        self.assertEqual(an_fs.targetSize, an_fs.minSize)
+        an_fs.update_size_info()
+
+        self.assertNotEqual(an_fs.current_size, an_fs.target_size)
+        self.assertEqual(an_fs.current_size, an_fs._size)
+        self.assertEqual(an_fs.target_size, Size(0))
+        self.assertIsNone(an_fs.do_resize())
+        self.assertEqual(an_fs.current_size, an_fs.min_size)
+        self.assertEqual(an_fs.target_size, an_fs.min_size)
         self._test_sizes(an_fs)
 
-    def testNoExplicitTargetSize2(self):
-        """ Because _targetSize has been set to size in constructor the
+    def test_no_explicit_target_size2(self):
+        """ Because _target_size has been set to size in constructor the
             resize action resizes filesystem to that size.
         """
         SIZE = Size("64 MiB")
@@ -253,112 +253,112 @@ def testNoExplicitTargetSize2(self):
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
 
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
+        an_fs.update_size_info()
 
         # The current size is the actual size, the target size is the size
         # set in the constructor.
-        self.assertNotEqual(an_fs.currentSize, an_fs.targetSize)
-        self.assertEqual(an_fs.targetSize, SIZE)
-        self.assertIsNone(an_fs.doResize())
-        self.assertEqual(an_fs.currentSize, SIZE)
-        self.assertEqual(an_fs.targetSize, SIZE)
+        self.assertNotEqual(an_fs.current_size, an_fs.target_size)
+        self.assertEqual(an_fs.target_size, SIZE)
+        self.assertIsNone(an_fs.do_resize())
+        self.assertEqual(an_fs.current_size, SIZE)
+        self.assertEqual(an_fs.target_size, SIZE)
         self._test_sizes(an_fs)
 
-    def testShrink(self):
+    def test_shrink(self):
         an_fs = self._fs_class()
         if not can_resize(an_fs):
             self.skipTest("Not checking resize for this test category.")
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
 
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
+        an_fs.update_size_info()
 
         TARGET_SIZE = Size("64 MiB")
-        an_fs.targetSize = TARGET_SIZE
-        self.assertIsNone(an_fs.doResize())
+        an_fs.target_size = TARGET_SIZE
+        self.assertIsNone(an_fs.do_resize())
 
         TARGET_SIZE = TARGET_SIZE / 2
-        self.assertTrue(TARGET_SIZE > an_fs.minSize)
-        an_fs.targetSize = TARGET_SIZE
-        self.assertEqual(an_fs.targetSize, TARGET_SIZE)
+        self.assertTrue(TARGET_SIZE > an_fs.min_size)
+        an_fs.target_size = TARGET_SIZE
+        self.assertEqual(an_fs.target_size, TARGET_SIZE)
         self.assertNotEqual(an_fs._size, TARGET_SIZE)
         # FIXME:
-        # doCheck() in updateSizeInfo() in doResize() does not complete tidily
-        # here, so resizable becomes False and self.targetSize can not be
+        # do_check() in update_size_info() in do_resize() does not complete tidily
+        # here, so resizable becomes False and self.target_size can not be
         # assigned to. This alerts us to the fact that now min size
         # and size are both incorrect values.
         if isinstance(an_fs, fs.NTFS):
             return
-        self.assertIsNone(an_fs.doResize())
-        ACTUAL_SIZE = TARGET_SIZE.roundToNearest(an_fs._resize.unit, rounding=ROUND_DOWN)
+        self.assertIsNone(an_fs.do_resize())
+        ACTUAL_SIZE = TARGET_SIZE.round_to_nearest(an_fs._resize.unit, rounding=ROUND_DOWN)
         self.assertEqual(an_fs._size, ACTUAL_SIZE)
         self._test_sizes(an_fs)
 
-    def testTooSmall(self):
+    def test_too_small(self):
         an_fs = self._fs_class()
         if not can_resize(an_fs):
             self.skipTest("Not checking resize for this test category.")
         if not an_fs.formattable:
             self.skipTest("can not create or resize filesystem %s" % an_fs.name)
 
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
+        an_fs.update_size_info()
 
         # can not set target size to less than minimum size
         # CHECKME: Should it raise an FSError instead?
-        TARGET_SIZE = an_fs.minSize - Size(1)
+        TARGET_SIZE = an_fs.min_size - Size(1)
         with self.assertRaises(ValueError):
-            an_fs.targetSize = TARGET_SIZE
-        self.assertEqual(an_fs.targetSize, Size(0))
+            an_fs.target_size = TARGET_SIZE
+        self.assertEqual(an_fs.target_size, Size(0))
         self._test_sizes(an_fs)
 
-    def testTooBig(self):
+    def test_too_big(self):
         an_fs = self._fs_class()
         if not can_resize(an_fs):
             self.skipTest("Not checking resize for this test category.")
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
 
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
+        an_fs.update_size_info()
 
         # can not set target size to maximum size
         # CHECKME: Should it raise an FSError instead?
-        TARGET_SIZE = an_fs.maxSize
+        TARGET_SIZE = an_fs.max_size
         with self.assertRaises(ValueError):
-            an_fs.targetSize = TARGET_SIZE
-        self.assertEqual(an_fs.targetSize, Size(0))
+            an_fs.target_size = TARGET_SIZE
+        self.assertEqual(an_fs.target_size, Size(0))
         self._test_sizes(an_fs)
 
-    def testTooBig2(self):
+    def test_too_big2(self):
         an_fs = self._fs_class()
         if not can_resize(an_fs):
             self.skipTest("Not checking resize for this test category.")
         if not an_fs.formattable:
             self.skipTest("can not create filesystem %s" % an_fs.name)
 
-        an_fs.device = self.loopDevices[0]
+        an_fs.device = self.loop_devices[0]
         self.assertIsNone(an_fs.create())
-        an_fs.updateSizeInfo()
+        an_fs.update_size_info()
 
         # resizing to near the maximum filesystem size ought to fail
         old_size = an_fs._size
-        BIG_SIZE = an_fs.maxSize - Size(1)
-        an_fs.targetSize = BIG_SIZE
-        self.assertEqual(an_fs.targetSize, BIG_SIZE)
+        BIG_SIZE = an_fs.max_size - Size(1)
+        an_fs.target_size = BIG_SIZE
+        self.assertEqual(an_fs.target_size, BIG_SIZE)
         with self.assertRaises(FSResizeError):
-            an_fs.doResize()
+            an_fs.do_resize()
 
         # CHECKME: size and target size will be adjusted attempted values
-        # while currentSize will be actual value
-        TARGET_SIZE = BIG_SIZE.roundToNearest(an_fs._resize.unit, rounding=ROUND_DOWN)
-        self.assertEqual(an_fs.targetSize, TARGET_SIZE)
-        self.assertEqual(an_fs.size, an_fs.targetSize)
-        self.assertEqual(an_fs.currentSize, old_size)
+        # while current_size will be actual value
+        TARGET_SIZE = BIG_SIZE.round_to_nearest(an_fs._resize.unit, rounding=ROUND_DOWN)
+        self.assertEqual(an_fs.target_size, TARGET_SIZE)
+        self.assertEqual(an_fs.size, an_fs.target_size)
+        self.assertEqual(an_fs.current_size, old_size)
         self._test_sizes(an_fs)
diff --git a/tests/formats_test/init_test.py b/tests/formats_test/init_test.py
index d877094..c7d15a2 100644
--- a/tests/formats_test/init_test.py
+++ b/tests/formats_test/init_test.py
@@ -5,7 +5,7 @@
 
 class FormatsTestCase(unittest.TestCase):
 
-    def testFormatsMethods(self):
+    def test_formats_methods(self):
         ##
         ## get_device_format_class
         ##
@@ -25,11 +25,11 @@ def testFormatsMethods(self):
 
         ## A DeviceFormat object is returned if lookup by name fails
         for name in format_names:
-            self.assertIs(formats.getFormat(name).__class__,
+            self.assertIs(formats.get_format(name).__class__,
                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.getFormat(name) for name in names]
+        objs = [formats.get_format(name) for name in names]
         ids = [obj.id for obj in objs]
         self.assertEqual(ids, list(range(ids[0], ids[0] + len(ids))))
 
diff --git a/tests/formats_test/labeling_test.py b/tests/formats_test/labeling_test.py
index 2f53a92..dae3795 100644
--- a/tests/formats_test/labeling_test.py
+++ b/tests/formats_test/labeling_test.py
@@ -10,45 +10,45 @@
 class InitializationTestCase(unittest.TestCase):
     """Test FS object initialization."""
 
-    def testLabels(self):
+    def test_labels(self):
         """Initialize some filesystems with valid and invalid labels."""
 
         # Ext2FS has a maximum length of 16
-        self.assertFalse(fs.Ext2FS().labelFormatOK("root___filesystem"))
-        self.assertTrue(fs.Ext2FS().labelFormatOK("root__filesystem"))
+        self.assertFalse(fs.Ext2FS().label_format_ok("root___filesystem"))
+        self.assertTrue(fs.Ext2FS().label_format_ok("root__filesystem"))
 
         # FATFS has a maximum length of 11
-        self.assertFalse(fs.FATFS().labelFormatOK("rtfilesystem"))
-        self.assertTrue(fs.FATFS().labelFormatOK("rfilesystem"))
+        self.assertFalse(fs.FATFS().label_format_ok("rtfilesystem"))
+        self.assertTrue(fs.FATFS().label_format_ok("rfilesystem"))
 
         # JFS has a maximum length of 16
-        self.assertFalse(fs.JFS().labelFormatOK("root___filesystem"))
-        self.assertTrue(fs.JFS().labelFormatOK("root__filesystem"))
+        self.assertFalse(fs.JFS().label_format_ok("root___filesystem"))
+        self.assertTrue(fs.JFS().label_format_ok("root__filesystem"))
 
         # ReiserFS has a maximum length of 16
-        self.assertFalse(fs.ReiserFS().labelFormatOK("root___filesystem"))
-        self.assertTrue(fs.ReiserFS().labelFormatOK("root__filesystem"))
+        self.assertFalse(fs.ReiserFS().label_format_ok("root___filesystem"))
+        self.assertTrue(fs.ReiserFS().label_format_ok("root__filesystem"))
 
         #XFS has a maximum length 12 and does not allow spaces
-        self.assertFalse(fs.XFS().labelFormatOK("root_filesyst"))
-        self.assertFalse(fs.XFS().labelFormatOK("root file"))
-        self.assertTrue(fs.XFS().labelFormatOK("root_filesys"))
+        self.assertFalse(fs.XFS().label_format_ok("root_filesyst"))
+        self.assertFalse(fs.XFS().label_format_ok("root file"))
+        self.assertTrue(fs.XFS().label_format_ok("root_filesys"))
 
         #HFS has a maximum length of 27, minimum length of 1, and does not allow colons
-        self.assertFalse(fs.HFS().labelFormatOK("n" * 28))
-        self.assertFalse(fs.HFS().labelFormatOK("root:file"))
-        self.assertFalse(fs.HFS().labelFormatOK(""))
-        self.assertTrue(fs.HFS().labelFormatOK("n" * 27))
+        self.assertFalse(fs.HFS().label_format_ok("n" * 28))
+        self.assertFalse(fs.HFS().label_format_ok("root:file"))
+        self.assertFalse(fs.HFS().label_format_ok(""))
+        self.assertTrue(fs.HFS().label_format_ok("n" * 27))
 
         #HFSPlus has a maximum length of 128, minimum length of 1, and does not allow colons
-        self.assertFalse(fs.HFSPlus().labelFormatOK("n" * 129))
-        self.assertFalse(fs.HFSPlus().labelFormatOK("root:file"))
-        self.assertFalse(fs.HFSPlus().labelFormatOK(""))
-        self.assertTrue(fs.HFSPlus().labelFormatOK("n" * 128))
+        self.assertFalse(fs.HFSPlus().label_format_ok("n" * 129))
+        self.assertFalse(fs.HFSPlus().label_format_ok("root:file"))
+        self.assertFalse(fs.HFSPlus().label_format_ok(""))
+        self.assertTrue(fs.HFSPlus().label_format_ok("n" * 128))
 
         # NTFS has a maximum length of 128
-        self.assertFalse(fs.NTFS().labelFormatOK("n" * 129))
-        self.assertTrue(fs.NTFS().labelFormatOK("n" * 128))
+        self.assertFalse(fs.NTFS().label_format_ok("n" * 129))
+        self.assertTrue(fs.NTFS().label_format_ok("n" * 128))
 
         # all devices are permitted to be passed a label argument of None
         # some will ignore it completely
@@ -90,15 +90,15 @@ class NTFSTestCase(fslabeling.CompleteLabelingAsRoot):
 
 class LabelingSwapSpaceTestCase(loopbackedtestcase.LoopBackedTestCase):
 
-    def testLabeling(self):
-        swp = swap.SwapSpace(device=self.loopDevices[0])
+    def test_labeling(self):
+        swp = swap.SwapSpace(device=self.loop_devices[0])
         swp.label = "mkswap is really pretty permissive about labels"
         self.assertIsNone(swp.create())
 
-    def testCreatingSwapSpaceNone(self):
-        swp = swap.SwapSpace(device=self.loopDevices[0], label=None)
+    def test_creating_swap_space_none(self):
+        swp = swap.SwapSpace(device=self.loop_devices[0], label=None)
         self.assertIsNone(swp.create())
 
-    def testCreatingSwapSpaceEmpty(self):
-        swp = swap.SwapSpace(device=self.loopDevices[0], label="")
+    def test_creating_swap_space_empty(self):
+        swp = swap.SwapSpace(device=self.loop_devices[0], label="")
         self.assertIsNone(swp.create())
diff --git a/tests/formats_test/selinux_test.py b/tests/formats_test/selinux_test.py
index 44fe220..403e7f4 100644
--- a/tests/formats_test/selinux_test.py
+++ b/tests/formats_test/selinux_test.py
@@ -13,20 +13,20 @@ class SELinuxContextTestCase(loopbackedtestcase.LoopBackedTestCase):
     """Testing SELinux contexts.
     """
 
-    def __init__(self, methodName='runTest'):
-        super(SELinuxContextTestCase, self).__init__(methodName=methodName, deviceSpec=[Size("100 MiB")])
+    def __init__(self, methodName='run_test'):
+        super(SELinuxContextTestCase, self).__init__(methodName=methodName, device_spec=[Size("100 MiB")])
 
     def setUp(self):
         self.installer_mode = blivet.flags.installer_mode
         super(SELinuxContextTestCase, self).setUp()
 
-    def testMountingExt2FS(self):
+    def test_mounting_ext2fs(self):
         """ Test that lost+found directory gets assigned correct SELinux
             context if installer_mode is True, and retains some random old
             context if installer_mode is False.
         """
         LOST_AND_FOUND_CONTEXT = 'system_u:object_r:lost_found_t:s0'
-        an_fs = fs.Ext2FS(device=self.loopDevices[0], label="test")
+        an_fs = fs.Ext2FS(device=self.loop_devices[0], label="test")
 
         if not an_fs.formattable or not an_fs.mountable:
             self.skipTest("can not create or mount filesystem %s" % an_fs.name)
@@ -61,9 +61,9 @@ def testMountingExt2FS(self):
 
         self.assertEqual(lost_and_found_selinux_context[1], LOST_AND_FOUND_CONTEXT)
 
-    def testMountingXFS(self):
+    def test_mounting_xfs(self):
         """ XFS does not have a lost+found directory. """
-        an_fs = fs.XFS(device=self.loopDevices[0], label="test")
+        an_fs = fs.XFS(device=self.loop_devices[0], label="test")
 
         if not an_fs.formattable or not an_fs.mountable:
             self.skipTest("can not create or mount filesystem %s" % an_fs.name)
diff --git a/tests/imagebackedtestcase.py b/tests/imagebackedtestcase.py
index aa4040b..4436553 100644
--- a/tests/imagebackedtestcase.py
+++ b/tests/imagebackedtestcase.py
@@ -37,17 +37,17 @@ def set_up_disks(self):
         """ Create disk image files to build the test's storage on.
 
             If you are actually creating the disk image files here don't forget
-            to set the initializeDisks flag so they get a fresh disklabel when
-            clearPartitions gets called from create_storage later.
+            to set the initialize_disks flag so they get a fresh disklabel when
+            clear_partitions gets called from create_storage later.
         """
         for (name, size) in iter(self.disks.items()):
             path = util.create_sparse_tempfile(name, size)
-            self.blivet.config.diskImages[name] = path
+            self.blivet.config.disk_images[name] = path
 
         #
         # set up the disk images with a disklabel
         #
-        self.blivet.config.initializeDisks = self.initialize_disks
+        self.blivet.config.initialize_disks = self.initialize_disks
 
     def _set_up_storage(self):
         """ Schedule creation of storage devices on the disk images.
@@ -78,7 +78,7 @@ def set_up_storage(self):
         #
         # clear and/or initialize disks as specified in set_up_disks
         #
-        self.blivet.clearPartitions()
+        self.blivet.clear_partitions()
 
         #
         # create the rest of the stack
@@ -88,21 +88,21 @@ def set_up_storage(self):
         #
         # write configuration to disk images
         #
-        self.blivet.doIt()
+        self.blivet.do_it()
 
     def setUp(self):
         """ Do any setup required prior to running a test. """
         flags.image_install = True
         self.blivet = Blivet()
 
-        self.addCleanup(self._cleanUp)
+        self.addCleanup(self._clean_up)
         self.set_up_storage()
 
-    def _cleanUp(self):
+    def _clean_up(self):
         """ Clean up any resources that may have been set up for a test. """
         self.blivet.reset()
-        self.blivet.devicetree.teardownDiskImages()
-        for fn in self.blivet.config.diskImages.values():
+        self.blivet.devicetree.teardown_disk_images()
+        for fn in self.blivet.config.disk_images.values():
             if os.path.exists(fn):
                 os.unlink(fn)
 
diff --git a/tests/loopbackedtestcase.py b/tests/loopbackedtestcase.py
index b87006b..1c27caf 100644
--- a/tests/loopbackedtestcase.py
+++ b/tests/loopbackedtestcase.py
@@ -5,7 +5,7 @@
 
 from blivet.size import Size
 
-def makeStore(file_name, num_blocks=102400, block_size=1024):
+def make_store(file_name, num_blocks=102400, block_size=1024):
     """ Set up the backing store for a loop device.
 
         :param str file_name: the path of the backing file
@@ -23,7 +23,7 @@ def makeStore(file_name, num_blocks=102400, block_size=1024):
     if rc:
         raise OSError("dd failed creating the file %s" % file_name)
 
-def makeLoopDev(device_name, file_name):
+def make_loop_dev(device_name, file_name):
     """ Set up a loop device with a backing store.
 
         :param str device_name: the path of the loop device
@@ -40,7 +40,7 @@ def makeLoopDev(device_name, file_name):
     if rc:
         raise OSError("losetup failed setting up the loop device %s" % device_name)
 
-def removeLoopDev(device_name):
+def remove_loop_dev(device_name):
     proc = subprocess.Popen(["losetup", "-d", device_name],
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     while True:
@@ -51,7 +51,7 @@ def removeLoopDev(device_name):
     if rc:
         raise OSError("losetup failed removing the loop device %s" % device_name)
 
-def getFreeLoopDev():
+def get_free_loop_dev():
     """ Get the name of the free loop device that losetup reports.
 
         :returns: the name of the free loop device
@@ -84,69 +84,69 @@ class LoopBackedTestCase(unittest.TestCase):
     DEFAULT_STORE_SIZE = Size("100 MiB")
     _DEFAULT_DEVICE_SPEC = [DEFAULT_STORE_SIZE, DEFAULT_STORE_SIZE]
 
-    def __init__(self, methodName='runTest', deviceSpec=None, block_size=None):
+    def __init__(self, methodName='run_test', device_spec=None, block_size=None):
         """ LoopBackedTestCase manages loop devices.
 
-            It constructs loop devices according to loopDeviceSpec,
+            It constructs loop devices according to loop_device_spec,
             sets them up, and tears them down again.
 
-            :param deviceSpec: list containing the size of each loop device
-            :type deviceSpec: list of Size or NoneType
+            :param device_spec: list containing the size of each loop device
+            :type device_spec: list of Size or NoneType
             :param block_size: block size for dd command when making devices
             :type block_size: Size or NoneType
         """
         unittest.TestCase.__init__(self, methodName=methodName)
-        self._deviceSpec = deviceSpec or self._DEFAULT_DEVICE_SPEC
-        self._loopMap = []
-        self.loopDevices = []
+        self._device_spec = device_spec or self._DEFAULT_DEVICE_SPEC
+        self._loop_map = []
+        self.loop_devices = []
         self.block_size = block_size or self.DEFAULT_BLOCK_SIZE
 
-        if any(d % self.block_size != Size(0) for d in self._deviceSpec):
+        if any(d % self.block_size != Size(0) for d in self._device_spec):
             raise ValueError("Every device size must be a multiple of the block size.")
 
     def setUp(self):
-        for index, size in enumerate(self._deviceSpec):
+        for index, size in enumerate(self._device_spec):
             num_blocks = int(size / self.block_size)
             tmpfile = tempfile.NamedTemporaryFile(suffix="-%d" % index, prefix="test-virtdev-", dir="/var/tmp", delete=False)
             tmpfile.close()
 
             store = tmpfile.name
-            makeStore(store, num_blocks, int(self.block_size))
+            make_store(store, num_blocks, int(self.block_size))
 
             dev = None
             try:
-                dev = getFreeLoopDev()
-                makeLoopDev(dev, store)
+                dev = get_free_loop_dev()
+                make_loop_dev(dev, store)
             except OSError:
                 os.unlink(store)
                 raise
 
-            self._loopMap.append((dev, store))
-            self.loopDevices.append(dev)
+            self._loop_map.append((dev, store))
+            self.loop_devices.append(dev)
 
-        self.addCleanup(self._cleanUp)
+        self.addCleanup(self._clean_up)
 
-    def _cleanUp(self):
-        # Guarantees that every item in _loopMap receives a minimum of
+    def _clean_up(self):
+        # Guarantees that every item in _loop_map receives a minimum of
         # three chances to be removed or deleted as appropriate.
-        num_tries = 3 * len(self._loopMap)
+        num_tries = 3 * len(self._loop_map)
         for _ in range(num_tries):
             # If worklist is empty, quit
-            if not self._loopMap:
+            if not self._loop_map:
                 break
 
             # get worklist item from front
-            dev, store = self._loopMap.pop(0)
+            dev, store = self._loop_map.pop(0)
 
             # try to clean up dev, store pair
             # if cleanup fails, push pair onto back
             # dev is None if removal has already succeeded
             if dev is not None:
                 try:
-                    removeLoopDev(dev)
+                    remove_loop_dev(dev)
                     try:
                         os.unlink(store)
                     except OSError:
-                        self._loopMap.append((None, store))
+                        self._loop_map.append((None, store))
                 except OSError:
-                    self._loopMap.append((dev, store))
+                    self._loop_map.append((dev, store))
diff --git a/tests/parentlist_test.py b/tests/parentlist_test.py
index b4295be..5d052a5 100644
--- a/tests/parentlist_test.py
+++ b/tests/parentlist_test.py
@@ -4,7 +4,7 @@
 from blivet.devices import Device
 
 class ParentListTestCase(unittest.TestCase):
-    def testParentList(self):
+    def test_parent_list(self):
         items = list(range(5))
         length = len(items)
         pl = ParentList(items=items)
@@ -56,7 +56,7 @@ def pre_remove(item):
         with self.assertRaises(RuntimeError):
             pl.remove(2)
 
-    def testDeviceParents(self):
+    def test_device_parents(self):
         """ Verify that Device.parents functions as expected. """
         dev1 = Device("dev1", [])
         self.assertEqual(len(dev1.parents), 0)
diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py
index befe79d..30d54ca 100644
--- a/tests/partitioning_test.py
+++ b/tests/partitioning_test.py
@@ -4,11 +4,11 @@
 
 import parted
 
-from blivet.partitioning import addPartition
-from blivet.partitioning import getNextPartitionType
-from blivet.partitioning import doPartitioning
-from blivet.partitioning import allocatePartitions
-from blivet.partitioning import getFreeRegions
+from blivet.partitioning import add_partition
+from blivet.partitioning import get_next_partition_type
+from blivet.partitioning import do_partitioning
+from blivet.partitioning import allocate_partitions
+from blivet.partitioning import get_free_regions
 from blivet.partitioning import Request
 from blivet.partitioning import Chunk
 from blivet.partitioning import LVRequest
@@ -25,7 +25,7 @@
 
 from tests.imagebackedtestcase import ImageBackedTestCase
 from blivet.util import sparsetmpfile
-from blivet.formats import getFormat
+from blivet.formats import get_format
 from blivet.size import Size
 from blivet.flags import flags
 
@@ -37,7 +37,7 @@
                    'mac': (62, False, 0)}
 
 class PartitioningTestCase(unittest.TestCase):
-    def getDisk(self, disk_type, primary_count=0,
+    def get_disk(self, disk_type, primary_count=0,
                 has_extended=False, logical_count=0):
         """ Return a mock representing a parted.Disk. """
         disk = Mock()
@@ -60,98 +60,98 @@ def getDisk(self, disk_type, primary_count=0,
 
         return disk
 
-    def testNextPartitionType(self):
+    def test_next_partition_type(self):
         #
         # DOS
         #
 
         # empty disk, any type
-        disk = self.getDisk(disk_type="dos")
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_NORMAL)
+        disk = self.get_disk(disk_type="dos")
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
 
         # three primaries and no extended -> extended
-        disk = self.getDisk(disk_type="dos", primary_count=3)
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_EXTENDED)
+        disk = self.get_disk(disk_type="dos", primary_count=3)
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_EXTENDED)
 
         # three primaries and an extended -> primary
-        disk = self.getDisk(disk_type="dos", primary_count=3, has_extended=True)
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_NORMAL)
+        disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True)
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
 
         # three primaries and an extended w/ no_primary -> logical
-        disk = self.getDisk(disk_type="dos", primary_count=3, has_extended=True)
-        self.assertEqual(getNextPartitionType(disk, no_primary=True),
+        disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True)
+        self.assertEqual(get_next_partition_type(disk, no_primary=True),
                          parted.PARTITION_LOGICAL)
 
         # four primaries and an extended, available logical -> logical
-        disk = self.getDisk(disk_type="dos", primary_count=4, has_extended=True,
+        disk = self.get_disk(disk_type="dos", primary_count=4, has_extended=True,
                             logical_count=9)
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_LOGICAL)
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_LOGICAL)
 
         # four primaries and an extended, no available logical -> None
-        disk = self.getDisk(disk_type="dos", primary_count=4, has_extended=True,
+        disk = self.get_disk(disk_type="dos", primary_count=4, has_extended=True,
                             logical_count=11)
-        self.assertEqual(getNextPartitionType(disk), None)
+        self.assertEqual(get_next_partition_type(disk), None)
 
         # four primaries and no extended -> None
-        disk = self.getDisk(disk_type="dos", primary_count=4,
+        disk = self.get_disk(disk_type="dos", primary_count=4,
                             has_extended=False)
-        self.assertEqual(getNextPartitionType(disk), None)
+        self.assertEqual(get_next_partition_type(disk), None)
 
         # free primary slot, extended, no free logical slot -> primary
-        disk = self.getDisk(disk_type="dos", primary_count=3, has_extended=True,
+        disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True,
                             logical_count=11)
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_NORMAL)
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
 
         # free primary slot, extended, no free logical slot w/ no_primary
         # -> None
-        disk = self.getDisk(disk_type="dos", primary_count=3, has_extended=True,
+        disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True,
                             logical_count=11)
-        self.assertEqual(getNextPartitionType(disk, no_primary=True), None)
+        self.assertEqual(get_next_partition_type(disk, no_primary=True), None)
 
         #
         # GPT
         #
 
         # empty disk, any partition type
-        disk = self.getDisk(disk_type="gpt")
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_NORMAL)
+        disk = self.get_disk(disk_type="gpt")
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
 
         # no empty slots -> None
-        disk = self.getDisk(disk_type="gpt", primary_count=128)
-        self.assertEqual(getNextPartitionType(disk), None)
+        disk = self.get_disk(disk_type="gpt", primary_count=128)
+        self.assertEqual(get_next_partition_type(disk), None)
 
         # no_primary -> None
-        disk = self.getDisk(disk_type="gpt")
-        self.assertEqual(getNextPartitionType(disk, no_primary=True), None)
+        disk = self.get_disk(disk_type="gpt")
+        self.assertEqual(get_next_partition_type(disk, no_primary=True), None)
 
         #
         # MAC
         #
 
         # empty disk, any partition type
-        disk = self.getDisk(disk_type="mac")
-        self.assertEqual(getNextPartitionType(disk), parted.PARTITION_NORMAL)
+        disk = self.get_disk(disk_type="mac")
+        self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
 
         # no empty slots -> None
-        disk = self.getDisk(disk_type="mac", primary_count=62)
-        self.assertEqual(getNextPartitionType(disk), None)
+        disk = self.get_disk(disk_type="mac", primary_count=62)
+        self.assertEqual(get_next_partition_type(disk), None)
 
         # no_primary -> None
-        disk = self.getDisk(disk_type="mac")
-        self.assertEqual(getNextPartitionType(disk, no_primary=True), None)
+        disk = self.get_disk(disk_type="mac")
+        self.assertEqual(get_next_partition_type(disk, no_primary=True), None)
 
-    def testAddPartition(self):
+    def test_add_partition(self):
         with sparsetmpfile("addparttest", Size("50 MiB")) as disk_file:
             disk = DiskFile(disk_file)
-            disk.format = getFormat("disklabel", device=disk.path, exists=False)
+            disk.format = get_format("disklabel", device=disk.path, exists=False)
 
-            free = disk.format.partedDisk.getFreeSpaceRegions()[0]
+            free = disk.format.parted_disk.getFreeSpaceRegions()[0]
 
             #
             # add a partition with an unaligned size
             #
             self.assertEqual(len(disk.format.partitions), 0)
-            part = addPartition(disk.format, free, parted.PARTITION_NORMAL,
+            part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
                                 Size("10 MiB") - Size(37))
             self.assertEqual(len(disk.format.partitions), 1)
 
@@ -163,7 +163,7 @@ def testAddPartition(self):
             self.assertEqual(alignment.isAligned(free, geom.end + 1), True)
             self.assertEqual(part.geometry.length, int(Size("10 MiB") // sector_size))
 
-            disk.format.removePartition(part)
+            disk.format.remove_partition(part)
             self.assertEqual(len(disk.format.partitions), 0)
 
             #
@@ -175,13 +175,13 @@ def testAddPartition(self):
             opt_al = parted.Alignment(offset=0, grainSize=8192) # 4 MiB
             min_al = parted.Alignment(offset=0, grainSize=2048) # 1 MiB
             with patch(opt_str, opt_al) as optimal, patch(min_str, min_al) as minimal:
-                optimal_end = disk.format.getEndAlignment(alignment=optimal)
-                minimal_end = disk.format.getEndAlignment(alignment=minimal)
+                optimal_end = disk.format.get_end_alignment(alignment=optimal)
+                minimal_end = disk.format.get_end_alignment(alignment=minimal)
 
-                sector_size = Size(disk.format.sectorSize)
+                sector_size = Size(disk.format.sector_size)
                 length = 4096 # 2 MiB
                 size = Size(sector_size * length)
-                part = addPartition(disk.format, free, parted.PARTITION_NORMAL,
+                part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
                                     size)
                 self.assertEqual(part.geometry.length, length)
                 self.assertEqual(optimal.isAligned(free, part.geometry.start),
@@ -193,7 +193,7 @@ def testAddPartition(self):
                 self.assertEqual(minimal_end.isAligned(free, part.geometry.end),
                                  True)
 
-                disk.format.removePartition(part)
+                disk.format.remove_partition(part)
                 self.assertEqual(len(disk.format.partitions), 0)
 
             #
@@ -201,7 +201,7 @@ def testAddPartition(self):
             #
             start_sector = 5003
             end_sector = 15001
-            part = addPartition(disk.format, free, parted.PARTITION_NORMAL,
+            part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
                                 None, start_sector, end_sector)
             self.assertEqual(len(disk.format.partitions), 1)
 
@@ -209,7 +209,7 @@ def testAddPartition(self):
             self.assertEqual(part.geometry.start, start_sector)
             self.assertEqual(part.geometry.end, end_sector)
 
-            disk.format.removePartition(part)
+            disk.format.remove_partition(part)
             self.assertEqual(len(disk.format.partitions), 0)
 
             #
@@ -217,43 +217,43 @@ def testAddPartition(self):
             #
             with self.assertRaisesRegex(parted.PartitionException,
                                          "no extended partition"):
-                part = addPartition(disk.format, free, parted.PARTITION_LOGICAL,
+                part = add_partition(disk.format, free, parted.PARTITION_LOGICAL,
                                     Size("10 MiB"))
 
             ## add an extended partition to the disk
-            placeholder = addPartition(disk.format, free,
+            placeholder = add_partition(disk.format, free,
                                        parted.PARTITION_NORMAL, Size("10 MiB"))
-            all_free = disk.format.partedDisk.getFreeSpaceRegions()
-            addPartition(disk.format, all_free[1],
+            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))
 
-            disk.format.removePartition(placeholder)
+            disk.format.remove_partition(placeholder)
             self.assertEqual(len(disk.format.partitions), 1)
-            all_free = disk.format.partedDisk.getFreeSpaceRegions()
+            all_free = disk.format.parted_disk.getFreeSpaceRegions()
 
             #
             # add a logical partition to an extended free regions
             #
-            part = addPartition(disk.format, all_free[1],
+            part = add_partition(disk.format, all_free[1],
                                 parted.PARTITION_LOGICAL,
                                 Size("10 MiB"), all_free[1].start)
             self.assertEqual(part.type, parted.PARTITION_LOGICAL)
 
-            disk.format.removePartition(part)
+            disk.format.remove_partition(part)
             self.assertEqual(len(disk.format.partitions), 1)
 
             #
             # fail: add a primary partition to an extended free region
             #
             with self.assertRaisesRegex(parted.PartitionException, "overlap"):
-                part = addPartition(disk.format, all_free[1],
+                part = add_partition(disk.format, all_free[1],
                                     parted.PARTITION_NORMAL,
                                     Size("10 MiB"), all_free[1].start)
 
 
-    def testChunk(self):
+    def test_chunk(self):
         dev1 = Mock()
         attrs = {"req_grow": True,
                  "id": 1,
@@ -286,15 +286,15 @@ def testChunk(self):
         req3.base = 20
         req3.max_growth = 35
 
-        chunk.addRequest(req3)
+        chunk.add_request(req3)
         self.assertEqual(chunk.pool, 60)
         self.assertEqual(chunk.base, 30)
 
-        self.assertEqual(chunk.lengthToSize(30), 30)
-        self.assertEqual(chunk.sizeToLength(40), 40)
-        self.assertEqual(chunk.hasGrowable, True)
+        self.assertEqual(chunk.length_to_size(30), 30)
+        self.assertEqual(chunk.size_to_length(40), 40)
+        self.assertEqual(chunk.has_growable, True)
 
-        chunk.growRequests()
+        chunk.grow_requests()
 
         # the chunk is done growing since its pool has been exhausted
         self.assertEqual(chunk.done, True)
@@ -315,23 +315,23 @@ def testChunk(self):
         self.assertEqual(req2.growth, 0)
         self.assertEqual(req3.growth, 35)
 
-    def testDiskChunk1(self):
+    def test_disk_chunk1(self):
         disk_size = Size("100 MiB")
         with sparsetmpfile("chunktest", disk_size) as disk_file:
             disk = DiskFile(disk_file)
-            disk.format = getFormat("disklabel", device=disk.path, exists=False)
+            disk.format = get_format("disklabel", device=disk.path, exists=False)
 
             p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True)
             p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True)
 
             disks = [disk]
             partitions = [p1, p2]
-            free = getFreeRegions([disk])
+            free = get_free_regions([disk])
             self.assertEqual(len(free), 1,
                               "free region count %d not expected" % len(free))
 
             b = Mock()
-            allocatePartitions(b, disks, partitions, free)
+            allocate_partitions(b, disks, partitions, free)
 
             requests = [PartitionRequest(p) for p in partitions]
             chunk = DiskChunk(free[0], requests=requests)
@@ -340,7 +340,7 @@ def testDiskChunk1(self):
             length_expected = 204768
             self.assertEqual(chunk.length, length_expected)
 
-            base_expected = sum(p.partedPartition.geometry.length for p in partitions)
+            base_expected = sum(p.parted_partition.geometry.length for p in partitions)
             self.assertEqual(chunk.base, base_expected)
 
             pool_expected = chunk.length - base_expected
@@ -349,7 +349,7 @@ def testDiskChunk1(self):
             self.assertEqual(chunk.done, False)
             self.assertEqual(chunk.remaining, 2)
 
-            chunk.growRequests()
+            chunk.grow_requests()
 
             self.assertEqual(chunk.done, True)
             self.assertEqual(chunk.pool, 0)
@@ -366,18 +366,18 @@ def testDiskChunk1(self):
             self.assertEqual(requests[0].growth, 30712)
             self.assertEqual(requests[1].growth, 92136)
 
-    def testDiskChunk2(self):
+    def test_disk_chunk2(self):
         disk_size = Size("100 MiB")
         with sparsetmpfile("chunktest", disk_size) as disk_file:
             disk = DiskFile(disk_file)
-            disk.format = getFormat("disklabel", device=disk.path, exists=False)
+            disk.format = get_format("disklabel", device=disk.path, exists=False)
 
             p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True)
             p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True)
 
             # format max size should be reflected in request max growth
-            fmt = getFormat("dummy")
-            fmt._maxSize = Size("12 MiB")
+            fmt = get_format("dummy")
+            fmt._max_size = Size("12 MiB")
             p3 = PartitionDevice("p3", size=Size("10 MiB"), grow=True,
                                  fmt=fmt)
 
@@ -389,12 +389,12 @@ def testDiskChunk2(self):
 
             disks = [disk]
             partitions = [p1, p2, p3, p4, p5]
-            free = getFreeRegions([disk])
+            free = get_free_regions([disk])
             self.assertEqual(len(free), 1,
                               "free region count %d not expected" % len(free))
 
             b = Mock()
-            allocatePartitions(b, disks, partitions, free)
+            allocate_partitions(b, disks, partitions, free)
 
             requests = [PartitionRequest(p) for p in partitions]
             chunk = DiskChunk(free[0], requests=requests)
@@ -407,10 +407,10 @@ def testDiskChunk2(self):
 
             growable = [p for p in partitions if p.req_grow]
             fixed = [p for p in partitions if not p.req_grow]
-            base_expected = sum(p.partedPartition.geometry.length for p in growable)
+            base_expected = sum(p.parted_partition.geometry.length for p in growable)
             self.assertEqual(chunk.base, base_expected)
 
-            base_fixed = sum(p.partedPartition.geometry.length for p in fixed)
+            base_fixed = sum(p.parted_partition.geometry.length for p in fixed)
             pool_expected = chunk.length - base_expected - base_fixed
             self.assertEqual(chunk.pool, pool_expected)
 
@@ -419,7 +419,7 @@ def testDiskChunk2(self):
             # since p5 is not growable it is initially done
             self.assertEqual(chunk.remaining, 4)
 
-            chunk.growRequests()
+            chunk.grow_requests()
 
             #
             # validate the growth (in sectors)
@@ -467,9 +467,9 @@ def testDiskChunk2(self):
             self.assertEqual(requests[3].growth, 0)
             self.assertEqual(requests[4].growth, 2048)
 
-    def testVGChunk(self):
+    def test_vgchunk(self):
         pv = StorageDevice("pv1", size=Size("40 GiB"),
-                           fmt=getFormat("lvmpv"))
+                           fmt=get_format("lvmpv"))
         vg = LVMVolumeGroupDevice("vg", parents=[pv])
         lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg],
                                      size=Size("1 GiB"), grow=True)
@@ -485,20 +485,20 @@ def testVGChunk(self):
         chunk = VGChunk(vg, requests=[req1, req2, req3])
 
         self.assertEqual(chunk.length, vg.extents)
-        self.assertEqual(chunk.pool, vg.freeExtents)
+        self.assertEqual(chunk.pool, vg.free_extents)
         base_size = vg.align(sum((lv.size for lv in vg.lvs), Size(0)), roundup=True)
-        base = base_size / vg.peSize
+        base = base_size / vg.pe_size
         self.assertEqual(chunk.base, base)
 
         # default extent size is 4 MiB
-        self.assertEqual(chunk.lengthToSize(4), Size("16 MiB"))
-        self.assertEqual(chunk.sizeToLength(Size("33 MiB")), 8)
-        self.assertEqual(chunk.hasGrowable, True)
+        self.assertEqual(chunk.length_to_size(4), Size("16 MiB"))
+        self.assertEqual(chunk.size_to_length(Size("33 MiB")), 8)
+        self.assertEqual(chunk.has_growable, True)
 
         self.assertEqual(chunk.remaining, 3)
         self.assertEqual(chunk.done, False)
 
-        chunk.growRequests()
+        chunk.grow_requests()
 
         # the chunk is done growing since its pool has been exhausted
         self.assertEqual(chunk.done, True)
@@ -525,7 +525,7 @@ def testVGChunk(self):
         # The second pass should then split up the remaining 1805 extents
         # between lv1 and lv2 at a ratio of 1:10, which ends up being 164 for
         # lv1 and 1640 for lv2. The remaining extent goes to lv2 because it is
-        # first in the list after sorting with blivet.partitioning.lvCompare.
+        # first in the list after sorting with blivet.partitioning.lv_compare.
         #
         # Grand totals should be as follows:
         # lv1 should grow by 395 extents, or 1.54 GiB
@@ -535,25 +535,25 @@ def testVGChunk(self):
         self.assertEqual(req2.growth, 3956)
         self.assertEqual(req3.growth, 512)
 
-    def testVGChunkWithCache(self):
+    def test_vgchunk_with_cache(self):
         pv = StorageDevice("pv1", size=Size("40 GiB"),
-                           fmt=getFormat("lvmpv"))
+                           fmt=get_format("lvmpv"))
         # 1033 MiB so that the PV provides 1032 MiB of free space (see
         # LVMVolumeGroupDevice.extents) -- 1024 MiB for caches, 8 MiB for the
         # pmspare LV
         pv2 = StorageDevice("pv2", size=Size("1033 MiB"),
-                           fmt=getFormat("lvmpv"))
+                           fmt=get_format("lvmpv"))
         vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
 
         cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
         lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg],
                                      size=Size("1 GiB"), grow=True,
-                                     cacheRequest=cache_req1)
+                                     cache_request=cache_req1)
 
         cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
         lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg],
                                      size=Size("10 GiB"), grow=True,
-                                     cacheRequest=cache_req2)
+                                     cache_request=cache_req2)
 
         lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg],
                                      size=Size("10 GiB"), grow=True,
@@ -564,7 +564,7 @@ def testVGChunkWithCache(self):
         req3 = LVRequest(lv3)
         chunk = VGChunk(vg, requests=[req1, req2, req3])
 
-        chunk.growRequests()
+        chunk.grow_requests()
 
         # the chunk is done growing since its pool has been exhausted
         self.assertEqual(chunk.done, True)
@@ -573,32 +573,32 @@ def testVGChunkWithCache(self):
         self.assertEqual(chunk.remaining, 2)
 
         # All the sizes should be the same as without the caches (see the
-        # testVGChunk test for their "rationales") because the space for the
+        # test_vgchunk test for their "rationales") because the space for the
         # caches should just be reserved.
         self.assertEqual(req1.growth, 395)
         self.assertEqual(req2.growth, 3956)
         self.assertEqual(req3.growth, 512)
 
-    def testVGChunkWithCachePVfree(self):
+    def test_vgchunk_with_cache_pvfree(self):
         pv = StorageDevice("pv1", size=Size("40 GiB"),
-                           fmt=getFormat("lvmpv"))
+                           fmt=get_format("lvmpv"))
         # 1077 MiB so that the PV provides 1076 MiB of free space (see
         # LVMVolumeGroupDevice.extents) which is 44 MiB more than the caches
         # need (including the 8MiB pmspare LV) and which should thus be split
         # into the LVs
         pv2 = StorageDevice("pv2", size=Size("1077 MiB"),
-                           fmt=getFormat("lvmpv"))
+                           fmt=get_format("lvmpv"))
         vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
 
         cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
         lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg],
                                      size=Size("1 GiB"), grow=True,
-                                     cacheRequest=cache_req1)
+                                     cache_request=cache_req1)
 
         cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
         lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg],
                                      size=Size("10 GiB"), grow=True,
-                                     cacheRequest=cache_req2)
+                                     cache_request=cache_req2)
 
         lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg],
                                      size=Size("10 GiB"), grow=True,
@@ -609,7 +609,7 @@ def testVGChunkWithCachePVfree(self):
         req3 = LVRequest(lv3)
         chunk = VGChunk(vg, requests=[req1, req2, req3])
 
-        chunk.growRequests()
+        chunk.grow_requests()
 
         # the chunk is done growing since its pool has been exhausted
         self.assertEqual(chunk.done, True)
@@ -618,7 +618,7 @@ def testVGChunkWithCachePVfree(self):
         self.assertEqual(chunk.remaining, 2)
 
         # All the sizes should be the same as without the caches (see the
-        # testVGChunk test for their "rationales") because the space for the
+        # test_vgchunk test for their "rationales") because the space for the
         # caches should just be reserved.
         # The extra 11 extents available on the pv2 should go in the 1:10 ratio
         # to req1 and req2.
@@ -626,18 +626,18 @@ def testVGChunkWithCachePVfree(self):
         self.assertEqual(req2.growth, 3956 + 10)
         self.assertEqual(req3.growth, 512)
 
-    def testAlignFreeRegions(self):
+    def test_align_free_regions(self):
         # disk with two free regions -- first unaligned, second aligned
         disk = Mock()
         disk.format.alignment.grainSize = 2048
-        disk.format.partedDisk.getFreeSpaceRegions.return_value = [Mock(start=1, end=2049, length=2049),
+        disk.format.parted_disk.getFreeSpaceRegions.return_value = [Mock(start=1, end=2049, length=2049),
                                                                    Mock(start=1, end=2048, length=2048)]
 
-        free = getFreeRegions([disk])
+        free = get_free_regions([disk])
         self.assertEqual(free[0].length, 2049)
         self.assertEqual(free[1].length, 2048)
 
-        free = getFreeRegions([disk], align=True)
+        free = get_free_regions([disk], align=True)
         self.assertEqual(free[0].length, 2048)
         self.assertEqual(free[1].length, 2048)
 
@@ -650,75 +650,75 @@ def _set_up_storage(self):
         # Don't rely on the default being an msdos disklabel since the test
         # could be running on an EFI system.
         for name in self.disks:
-            disk = self.blivet.devicetree.getDeviceByName(name)
-            fmt = getFormat("disklabel", labelType="msdos", device=disk.path)
-            self.blivet.formatDevice(disk, fmt)
+            disk = self.blivet.devicetree.get_device_by_name(name)
+            fmt = get_format("disklabel", label_type="msdos", device=disk.path)
+            self.blivet.format_device(disk, fmt)
 
-    def testImplicitExtendedPartitions(self):
+    def test_implicit_extended_partitions(self):
         """ Verify management of implicitly requested extended partition. """
         # By running partition allocation multiple times with enough partitions
         # to require an extended partition, we exercise the code that manages
         # the implicit extended partition.
-        p1 = self.blivet.newPartition(size=Size("100 MiB"))
-        self.blivet.createDevice(p1)
+        p1 = self.blivet.new_partition(size=Size("100 MiB"))
+        self.blivet.create_device(p1)
 
-        p2 = self.blivet.newPartition(size=Size("200 MiB"))
-        self.blivet.createDevice(p2)
+        p2 = self.blivet.new_partition(size=Size("200 MiB"))
+        self.blivet.create_device(p2)
 
-        p3 = self.blivet.newPartition(size=Size("300 MiB"))
-        self.blivet.createDevice(p3)
+        p3 = self.blivet.new_partition(size=Size("300 MiB"))
+        self.blivet.create_device(p3)
 
-        p4 = self.blivet.newPartition(size=Size("400 MiB"))
-        self.blivet.createDevice(p4)
+        p4 = self.blivet.new_partition(size=Size("400 MiB"))
+        self.blivet.create_device(p4)
 
-        doPartitioning(self.blivet)
+        do_partitioning(self.blivet)
 
         # at this point there should be an extended partition
-        self.assertIsNotNone(self.blivet.disks[0].format.extendedPartition,
+        self.assertIsNotNone(self.blivet.disks[0].format.extended_partition,
                              "no extended partition was created")
 
         # remove the last partition request and verify that the extended goes away as a result
-        self.blivet.destroyDevice(p4)
-        doPartitioning(self.blivet)
-        self.assertIsNone(self.blivet.disks[0].format.extendedPartition,
+        self.blivet.destroy_device(p4)
+        do_partitioning(self.blivet)
+        self.assertIsNone(self.blivet.disks[0].format.extended_partition,
                           "extended partition was not removed with last logical")
 
-        p5 = self.blivet.newPartition(size=Size("500 MiB"))
-        self.blivet.createDevice(p5)
+        p5 = self.blivet.new_partition(size=Size("500 MiB"))
+        self.blivet.create_device(p5)
 
-        doPartitioning(self.blivet)
+        do_partitioning(self.blivet)
 
-        p6 = self.blivet.newPartition(size=Size("450 MiB"))
-        self.blivet.createDevice(p6)
+        p6 = self.blivet.new_partition(size=Size("450 MiB"))
+        self.blivet.create_device(p6)
 
-        doPartitioning(self.blivet)
+        do_partitioning(self.blivet)
 
-        self.assertIsNotNone(self.blivet.disks[0].format.extendedPartition,
+        self.assertIsNotNone(self.blivet.disks[0].format.extended_partition,
                              "no extended partition was created")
 
-        self.blivet.doIt()
+        self.blivet.do_it()
 
-    def testImplicitExtendedPartitionsInstallerMode(self):
+    def test_implicit_extended_partitions_installer_mode(self):
         flags.installer_mode = True
-        self.testImplicitExtendedPartitions()
+        self.test_implicit_extended_partitions()
         flags.installer_mode = False
 
-    def testExplicitExtendedPartitions(self):
+    def test_explicit_extended_partitions(self):
         """ Verify that explicitly requested extended partitions work. """
         disk = self.blivet.disks[0]
-        p1 = self.blivet.newPartition(size=Size("500 MiB"),
-                                      partType=parted.PARTITION_EXTENDED)
-        self.blivet.createDevice(p1)
-        doPartitioning(self.blivet)
+        p1 = self.blivet.new_partition(size=Size("500 MiB"),
+                                      part_type=parted.PARTITION_EXTENDED)
+        self.blivet.create_device(p1)
+        do_partitioning(self.blivet)
 
-        self.assertEqual(p1.partedPartition.type, parted.PARTITION_EXTENDED)
-        self.assertEqual(p1.partedPartition, disk.format.extendedPartition)
+        self.assertEqual(p1.parted_partition.type, parted.PARTITION_EXTENDED)
+        self.assertEqual(p1.parted_partition, disk.format.extended_partition)
 
-        p2 = self.blivet.newPartition(size=Size("1 GiB"))
-        self.blivet.createDevice(p2)
-        doPartitioning(self.blivet)
+        p2 = self.blivet.new_partition(size=Size("1 GiB"))
+        self.blivet.create_device(p2)
+        do_partitioning(self.blivet)
 
-        self.assertEqual(p1.partedPartition, disk.format.extendedPartition,
+        self.assertEqual(p1.parted_partition, disk.format.extended_partition,
                          "user-specified extended partition was removed")
 
-        self.blivet.doIt()
+        self.blivet.do_it()
diff --git a/tests/pylint/runpylint.py b/tests/pylint/runpylint.py
index 558297f..cc3d2fb 100755
--- a/tests/pylint/runpylint.py
+++ b/tests/pylint/runpylint.py
@@ -14,8 +14,8 @@ def __init__(self):
                                 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 'doTask' is abstract in class 'Task' but is not overridden"),
-                                FalsePositive(r"Method 'doTask' is abstract in class 'UnimplementedTask' but is not overridden"),
+                                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$")
                               ]
diff --git a/tests/size_test.py b/tests/size_test.py
index cf076d2..7a1fb9e 100644
--- a/tests/size_test.py
+++ b/tests/size_test.py
@@ -40,17 +40,17 @@
 
 class SizeTestCase(unittest.TestCase):
 
-    def testExceptions(self):
+    def test_exceptions(self):
         zero = Size(0)
         self.assertEqual(zero, Size("0.0"))
 
         s = Size(500)
         with self.assertRaises(SizePlacesError):
-            s.humanReadable(max_places=-1)
+            s.human_readable(max_places=-1)
 
-        self.assertEqual(s.humanReadable(max_places=0), "500 B")
+        self.assertEqual(s.human_readable(max_places=0), "500 B")
 
-    def _prefixTestHelper(self, numunits, unit):
+    def _prefix_test_helper(self, numunits, unit):
         """ Test that units and prefix or abbreviation agree.
 
             :param int numunits: this value times factor yields number of bytes
@@ -61,212 +61,212 @@ def _prefixTestHelper(self, numunits, unit):
         s = Size(c)
         self.assertEqual(s, Size(c))
 
-        u = size._makeSpec(unit.prefix, size._BYTES_WORDS[0], False)
+        u = size._make_spec(unit.prefix, size._BYTES_WORDS[0], False)
         s = Size("%ld %s" % (numunits, u))
         self.assertEqual(s, c)
-        self.assertEqual(s.convertTo(unit), numunits)
+        self.assertEqual(s.convert_to(unit), numunits)
 
-        u = size._makeSpec(unit.abbr, size._BYTES_SYMBOL, False)
+        u = size._make_spec(unit.abbr, size._BYTES_SYMBOL, False)
         s = Size("%ld %s" % (numunits, u))
         self.assertEqual(s, c)
-        self.assertEqual(s.convertTo(unit), numunits)
+        self.assertEqual(s.convert_to(unit), numunits)
 
-    def testPrefixes(self):
+    def test_prefixes(self):
         numbytes = 47
 
         for unit in [_EMPTY_PREFIX] + _BINARY_PREFIXES + _DECIMAL_PREFIXES:
-            self._prefixTestHelper(numbytes, unit)
+            self._prefix_test_helper(numbytes, unit)
 
-    def testHumanReadable(self):
+    def test_human_readable(self):
         s = Size(58929971)
-        self.assertEqual(s.humanReadable(), "56.2 MiB")
+        self.assertEqual(s.human_readable(), "56.2 MiB")
 
         s = Size(478360371)
-        self.assertEqual(s.humanReadable(), "456.2 MiB")
+        self.assertEqual(s.human_readable(), "456.2 MiB")
 
-        # humanReable output should be the same as input for big enough sizes
+        # human_reable output should be the same as input for big enough sizes
         # and enough places and integer values
         s = Size("12.68 TiB")
-        self.assertEqual(s.humanReadable(max_places=2), "12.68 TiB")
+        self.assertEqual(s.human_readable(max_places=2), "12.68 TiB")
         s = Size("26.55 MiB")
-        self.assertEqual(s.humanReadable(max_places=2), "26.55 MiB")
+        self.assertEqual(s.human_readable(max_places=2), "26.55 MiB")
         s = Size("300 MiB")
-        self.assertEqual(s.humanReadable(max_places=2), "300 MiB")
+        self.assertEqual(s.human_readable(max_places=2), "300 MiB")
 
         # when min_value is 10 and single digit on left of decimal, display
         # with smaller unit.
         s = Size("9.68 TiB")
-        self.assertEqual(s.humanReadable(max_places=2, min_value=10), "9912.32 GiB")
+        self.assertEqual(s.human_readable(max_places=2, min_value=10), "9912.32 GiB")
         s = Size("4.29 MiB")
-        self.assertEqual(s.humanReadable(max_places=2, min_value=10), "4392.96 KiB")
+        self.assertEqual(s.human_readable(max_places=2, min_value=10), "4392.96 KiB")
         s = Size("7.18 KiB")
-        self.assertEqual(s.humanReadable(max_places=2, min_value=10), "7352 B")
+        self.assertEqual(s.human_readable(max_places=2, min_value=10), "7352 B")
 
         # rounding should work with max_places limitted
         s = Size("12.687 TiB")
-        self.assertEqual(s.humanReadable(max_places=2), "12.69 TiB")
+        self.assertEqual(s.human_readable(max_places=2), "12.69 TiB")
         s = Size("23.7874 TiB")
-        self.assertEqual(s.humanReadable(max_places=3), "23.787 TiB")
+        self.assertEqual(s.human_readable(max_places=3), "23.787 TiB")
         s = Size("12.6998 TiB")
-        self.assertEqual(s.humanReadable(max_places=2), "12.7 TiB")
+        self.assertEqual(s.human_readable(max_places=2), "12.7 TiB")
 
         # byte values close to multiples of 2 are shown without trailing zeros
         s = Size(0xff)
-        self.assertEqual(s.humanReadable(max_places=2), "255 B")
+        self.assertEqual(s.human_readable(max_places=2), "255 B")
         s = Size(8193)
-        self.assertEqual(s.humanReadable(max_places=2, min_value=10), "8193 B")
+        self.assertEqual(s.human_readable(max_places=2, min_value=10), "8193 B")
 
         # a fractional quantity is shown if the value deviates
         # from the whole number of units by more than 1%
         s = Size(16384 - (1024/100 + 1))
-        self.assertEqual(s.humanReadable(max_places=2), "15.99 KiB")
+        self.assertEqual(s.human_readable(max_places=2), "15.99 KiB")
 
         # if max_places is set to None, all digits are displayed
         s = Size(0xfffffffffffff)
-        self.assertEqual(s.humanReadable(max_places=None), "3.9999999999999991118215803 PiB")
+        self.assertEqual(s.human_readable(max_places=None), "3.9999999999999991118215803 PiB")
         s = Size(0x10000)
-        self.assertEqual(s.humanReadable(max_places=None), "64 KiB")
+        self.assertEqual(s.human_readable(max_places=None), "64 KiB")
         s = Size(0x10001)
-        self.assertEqual(s.humanReadable(max_places=None), "64.0009765625 KiB")
+        self.assertEqual(s.human_readable(max_places=None), "64.0009765625 KiB")
 
         # test a very large quantity with no associated abbreviation or prefix
         s = Size(1024**9)
-        self.assertEqual(s.humanReadable(max_places=2), "1024 YiB")
+        self.assertEqual(s.human_readable(max_places=2), "1024 YiB")
         s = Size(1024**9 - 1)
-        self.assertEqual(s.humanReadable(max_places=2), "1024 YiB")
+        self.assertEqual(s.human_readable(max_places=2), "1024 YiB")
         s = Size(1024**9 + 1)
-        self.assertEqual(s.humanReadable(max_places=2, strip=False), "1024.00 YiB")
+        self.assertEqual(s.human_readable(max_places=2, strip=False), "1024.00 YiB")
         s = Size(1024**10)
-        self.assertEqual(s.humanReadable(max_places=2), "1048576 YiB")
+        self.assertEqual(s.human_readable(max_places=2), "1048576 YiB")
 
-    def testHumanReadableFractionalQuantities(self):
+    def test_human_readable_fractional_quantities(self):
         s = Size(0xfffffffffffff)
-        self.assertEqual(s.humanReadable(max_places=2), "4 PiB")
+        self.assertEqual(s.human_readable(max_places=2), "4 PiB")
         s = Size(0xfffff)
-        self.assertEqual(s.humanReadable(max_places=2, strip=False), "1024.00 KiB")
+        self.assertEqual(s.human_readable(max_places=2, strip=False), "1024.00 KiB")
         s = Size(0xffff)
         # value is not exactly 64 KiB, but w/ 2 places, value is 64.00 KiB
         # so the trailing 0s are stripped.
-        self.assertEqual(s.humanReadable(max_places=2), "64 KiB")
+        self.assertEqual(s.human_readable(max_places=2), "64 KiB")
         # since all significant digits are shown, there are no trailing 0s.
-        self.assertEqual(s.humanReadable(max_places=None), "63.9990234375 KiB")
+        self.assertEqual(s.human_readable(max_places=None), "63.9990234375 KiB")
 
         # deviation is less than 1/2 of 1% of 1024
         s = Size(16384 - (1024/100//2))
-        self.assertEqual(s.humanReadable(max_places=2), "16 KiB")
+        self.assertEqual(s.human_readable(max_places=2), "16 KiB")
         # deviation is greater than 1/2 of 1% of 1024
         s = Size(16384 - ((1024/100//2) + 1))
-        self.assertEqual(s.humanReadable(max_places=2), "15.99 KiB")
+        self.assertEqual(s.human_readable(max_places=2), "15.99 KiB")
 
         s = Size(0x10000000000000)
-        self.assertEqual(s.humanReadable(max_places=2), "4 PiB")
+        self.assertEqual(s.human_readable(max_places=2), "4 PiB")
 
 
-    def testMinValue(self):
+    def test_min_value(self):
         s = Size("9 MiB")
-        self.assertEqual(s.humanReadable(), "9 MiB")
-        self.assertEqual(s.humanReadable(min_value=10), "9216 KiB")
+        self.assertEqual(s.human_readable(), "9 MiB")
+        self.assertEqual(s.human_readable(min_value=10), "9216 KiB")
 
         s = Size("0.5 GiB")
-        self.assertEqual(s.humanReadable(max_places=2, min_value=1), "512 MiB")
-        self.assertEqual(s.humanReadable(max_places=2, min_value=Decimal("0.1")), "0.5 GiB")
-        self.assertEqual(s.humanReadable(max_places=2, min_value=Decimal(1)), "512 MiB")
+        self.assertEqual(s.human_readable(max_places=2, min_value=1), "512 MiB")
+        self.assertEqual(s.human_readable(max_places=2, min_value=Decimal("0.1")), "0.5 GiB")
+        self.assertEqual(s.human_readable(max_places=2, min_value=Decimal(1)), "512 MiB")
 
-    def testConvertToPrecision(self):
+    def test_convert_to_precision(self):
         s = Size(1835008)
-        self.assertEqual(s.convertTo(None), 1835008)
-        self.assertEqual(s.convertTo(B), 1835008)
-        self.assertEqual(s.convertTo(KiB), 1792)
-        self.assertEqual(s.convertTo(MiB), Decimal("1.75"))
+        self.assertEqual(s.convert_to(None), 1835008)
+        self.assertEqual(s.convert_to(B), 1835008)
+        self.assertEqual(s.convert_to(KiB), 1792)
+        self.assertEqual(s.convert_to(MiB), Decimal("1.75"))
 
-    def testConvertToWithSize(self):
+    def test_convert_to_with_size(self):
         s = Size(1835008)
-        self.assertEqual(s.convertTo(Size(1)), s.convertTo(B))
-        self.assertEqual(s.convertTo(Size(1024)), s.convertTo(KiB))
-        self.assertEqual(Size(512).convertTo(Size(1024)), Decimal("0.5"))
-        self.assertEqual(Size(1024).convertTo(Size(512)), Decimal(2))
+        self.assertEqual(s.convert_to(Size(1)), s.convert_to(B))
+        self.assertEqual(s.convert_to(Size(1024)), s.convert_to(KiB))
+        self.assertEqual(Size(512).convert_to(Size(1024)), Decimal("0.5"))
+        self.assertEqual(Size(1024).convert_to(Size(512)), Decimal(2))
 
         with self.assertRaises(ValueError):
-            s.convertTo(Size(0))
+            s.convert_to(Size(0))
 
-    def testNegative(self):
+    def test_negative(self):
         s = Size("-500MiB")
-        self.assertEqual(s.humanReadable(), "-500 MiB")
-        self.assertEqual(s.convertTo(B), -524288000)
+        self.assertEqual(s.human_readable(), "-500 MiB")
+        self.assertEqual(s.convert_to(B), -524288000)
 
-    def testPartialBytes(self):
+    def test_partial_bytes(self):
         self.assertEqual(Size("1024.6"), Size(1024))
         self.assertEqual(Size("%s KiB" % (1/1025.0,)), Size(0))
         self.assertEqual(Size("%s KiB" % (1/1023.0,)), Size(1))
 
-    def testNoUnitsInString(self):
+    def test_no_units_in_string(self):
         self.assertEqual(Size("1024"), Size("1 KiB"))
 
-    def testScientificNotation(self):
-        self.assertEqual(size.parseSpec("1e+0 KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec("1e-0 KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec("1e-1 KB"), Decimal(100))
-        self.assertEqual(size.parseSpec("1E-4KB"), Decimal("0.1"))
+    def test_scientific_notation(self):
+        self.assertEqual(size.parse_spec("1e+0 KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec("1e-0 KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec("1e-1 KB"), Decimal(100))
+        self.assertEqual(size.parse_spec("1E-4KB"), Decimal("0.1"))
         self.assertEqual(Size("1E-10KB"), Size(0))
 
         with self.assertRaises(ValueError):
             # this is an exponent w/out a base
-            size.parseSpec("e+0")
-
-    def testFloatingPointStr(self):
-        self.assertEqual(size.parseSpec("1.5e+0 KiB"), Decimal(1536))
-        self.assertEqual(size.parseSpec("0.0"), Decimal(0))
-        self.assertEqual(size.parseSpec("0.9 KiB"), Decimal("921.6"))
-        self.assertEqual(size.parseSpec("1.5 KiB"), Decimal(1536))
-        self.assertEqual(size.parseSpec("0.5 KiB"), Decimal(512))
-        self.assertEqual(size.parseSpec(".5 KiB"), Decimal(512))
-        self.assertEqual(size.parseSpec("1. KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec("-1. KiB"), Decimal(-1024))
-        self.assertEqual(size.parseSpec("+1. KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec("+1.0000000e+0 KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec("+.5 KiB"), Decimal(512))
+            size.parse_spec("e+0")
+
+    def test_floating_point_str(self):
+        self.assertEqual(size.parse_spec("1.5e+0 KiB"), Decimal(1536))
+        self.assertEqual(size.parse_spec("0.0"), Decimal(0))
+        self.assertEqual(size.parse_spec("0.9 KiB"), Decimal("921.6"))
+        self.assertEqual(size.parse_spec("1.5 KiB"), Decimal(1536))
+        self.assertEqual(size.parse_spec("0.5 KiB"), Decimal(512))
+        self.assertEqual(size.parse_spec(".5 KiB"), Decimal(512))
+        self.assertEqual(size.parse_spec("1. KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec("-1. KiB"), Decimal(-1024))
+        self.assertEqual(size.parse_spec("+1. KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec("+1.0000000e+0 KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec("+.5 KiB"), Decimal(512))
 
         with self.assertRaises(ValueError):
             # this is a fragment of an arithmetic expression
-            size.parseSpec("+ 1 KiB")
+            size.parse_spec("+ 1 KiB")
 
         with self.assertRaises(ValueError):
             # this is a fragment of an arithmetic expression
-            size.parseSpec("- 1 KiB")
+            size.parse_spec("- 1 KiB")
 
         with self.assertRaises(ValueError):
             # this is a lonely .
-            size.parseSpec(". KiB")
+            size.parse_spec(". KiB")
 
         with self.assertRaises(ValueError):
             # this has a fragmentary exponent
-            size.parseSpec("1.0e+ KiB")
+            size.parse_spec("1.0e+ KiB")
 
         with self.assertRaises(ValueError):
             # this is a version string, not a number
-            size.parseSpec("1.0.0")
+            size.parse_spec("1.0.0")
 
-    def testWhiteSpace(self):
-        self.assertEqual(size.parseSpec("1 KiB "), Decimal(1024))
-        self.assertEqual(size.parseSpec(" 1 KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec(" 1KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec(" 1e+0KiB"), Decimal(1024))
+    def test_white_space(self):
+        self.assertEqual(size.parse_spec("1 KiB "), Decimal(1024))
+        self.assertEqual(size.parse_spec(" 1 KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec(" 1KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec(" 1e+0KiB"), Decimal(1024))
         with self.assertRaises(ValueError):
-            size.parseSpec("1 KiB just a lot of stray characters")
+            size.parse_spec("1 KiB just a lot of stray characters")
         with self.assertRaises(ValueError):
-            size.parseSpec("just 1 KiB")
+            size.parse_spec("just 1 KiB")
 
-    def testLeadingZero(self):
-        self.assertEqual(size.parseSpec("001 KiB"), Decimal(1024))
-        self.assertEqual(size.parseSpec("1e+01"), Decimal(10))
+    def test_leading_zero(self):
+        self.assertEqual(size.parse_spec("001 KiB"), Decimal(1024))
+        self.assertEqual(size.parse_spec("1e+01"), Decimal(10))
 
-    def testPickling(self):
+    def test_pickling(self):
         s = Size("10 MiB")
         self.assertEqual(s, cPickle.loads(cPickle.dumps(s)))
 
 class TranslationTestCase(unittest.TestCase):
 
-    def __init__(self, methodName='runTest'):
+    def __init__(self, methodName='run_test'):
         super(TranslationTestCase, self).__init__(methodName=methodName)
 
         # es_ES uses latin-characters but a comma as the radix separator
@@ -283,59 +283,59 @@ def tearDown(self):
         os.environ['LANG'] = self.saved_lang
         locale.setlocale(locale.LC_ALL, '')
 
-    def testMakeSpec(self):
-        """ Tests for _makeSpecs(). """
+    def test_make_spec(self):
+        """ Tests for _make_specs(). """
         for lang in  self.TEST_LANGS:
             os.environ['LANG'] = lang
             locale.setlocale(locale.LC_ALL, '')
 
             # untranslated specs
-            self.assertEqual(size._makeSpec("", "BYTES", False), "bytes")
-            self.assertEqual(size._makeSpec("Mi", "b", False), "mib")
+            self.assertEqual(size._make_spec("", "BYTES", False), "bytes")
+            self.assertEqual(size._make_spec("Mi", "b", False), "mib")
 
             # un-lower-cased specs
-            self.assertEqual(size._makeSpec("", "BYTES", False, False), "BYTES")
-            self.assertEqual(size._makeSpec("Mi", "b", False, False), "Mib")
-            self.assertEqual(size._makeSpec("Mi", "B", False, False), "MiB")
+            self.assertEqual(size._make_spec("", "BYTES", False, False), "BYTES")
+            self.assertEqual(size._make_spec("Mi", "b", False, False), "Mib")
+            self.assertEqual(size._make_spec("Mi", "B", False, False), "MiB")
 
             # translated specs
-            res = size._makeSpec("", "bytes", True)
+            res = size._make_spec("", "bytes", True)
 
             # Note that exp != _("bytes").lower() as one might expect
             exp = (_("") + _("bytes")).lower()
             self.assertEqual(res, exp)
 
-    def testParseSpec(self):
-        """ Tests for parseSpec(). """
+    def test_parse_spec(self):
+        """ Tests for parse_spec(). """
         for lang in  self.TEST_LANGS:
             os.environ['LANG'] = lang
             locale.setlocale(locale.LC_ALL, '')
 
             # Test parsing English spec in foreign locales
-            self.assertEqual(size.parseSpec("1 kibibytes"), Decimal(1024))
-            self.assertEqual(size.parseSpec("2 kibibyte"), Decimal(2048))
-            self.assertEqual(size.parseSpec("2 kilobyte"), Decimal(2000))
-            self.assertEqual(size.parseSpec("2 kilobytes"), Decimal(2000))
-            self.assertEqual(size.parseSpec("2 KB"), Decimal(2000))
-            self.assertEqual(size.parseSpec("2 K"), Decimal(2048))
-            self.assertEqual(size.parseSpec("2 k"), Decimal(2048))
-            self.assertEqual(size.parseSpec("2 Ki"), Decimal(2048))
-            self.assertEqual(size.parseSpec("2 g"), Decimal(2 * 1024 ** 3))
-            self.assertEqual(size.parseSpec("2 G"), Decimal(2 * 1024 ** 3))
+            self.assertEqual(size.parse_spec("1 kibibytes"), Decimal(1024))
+            self.assertEqual(size.parse_spec("2 kibibyte"), Decimal(2048))
+            self.assertEqual(size.parse_spec("2 kilobyte"), Decimal(2000))
+            self.assertEqual(size.parse_spec("2 kilobytes"), Decimal(2000))
+            self.assertEqual(size.parse_spec("2 KB"), Decimal(2000))
+            self.assertEqual(size.parse_spec("2 K"), Decimal(2048))
+            self.assertEqual(size.parse_spec("2 k"), Decimal(2048))
+            self.assertEqual(size.parse_spec("2 Ki"), Decimal(2048))
+            self.assertEqual(size.parse_spec("2 g"), Decimal(2 * 1024 ** 3))
+            self.assertEqual(size.parse_spec("2 G"), Decimal(2 * 1024 ** 3))
 
             # Test parsing foreign spec
-            self.assertEqual(size.parseSpec("1 %s%s" % (_("kibi"), _("bytes"))), Decimal(1024))
+            self.assertEqual(size.parse_spec("1 %s%s" % (_("kibi"), _("bytes"))), Decimal(1024))
 
             # Can't parse a valueless number
             with self.assertRaises(ValueError):
-                size.parseSpec("Ki")
+                size.parse_spec("Ki")
 
-            self.assertEqual(size.parseSpec("2 %s" % _("K")), Decimal(2048))
-            self.assertEqual(size.parseSpec("2 %s" % _("Ki")), Decimal(2048))
-            self.assertEqual(size.parseSpec("2 %s" % _("g")), Decimal(2 * 1024 ** 3))
-            self.assertEqual(size.parseSpec("2 %s" % _("G")), Decimal(2 * 1024 ** 3))
+            self.assertEqual(size.parse_spec("2 %s" % _("K")), Decimal(2048))
+            self.assertEqual(size.parse_spec("2 %s" % _("Ki")), Decimal(2048))
+            self.assertEqual(size.parse_spec("2 %s" % _("g")), Decimal(2 * 1024 ** 3))
+            self.assertEqual(size.parse_spec("2 %s" % _("G")), Decimal(2 * 1024 ** 3))
 
-    def testTranslated(self):
+    def test_translated(self):
         s = Size("56.19 MiB")
         for lang in  self.TEST_LANGS:
             os.environ['LANG'] = lang
@@ -362,75 +362,75 @@ def testTranslated(self):
                 self.assertEqual(s, Size(("56%s19 %s%s" % (radix, _("Mi"), _("B"))).lower()))
                 self.assertEqual(s, Size(("56%s19 %s%s" % (radix, _("Mi"), _("B"))).upper()))
 
-    def testHumanReadableTranslation(self):
+    def test_human_readable_translation(self):
         s = Size("56.19 MiB")
-        size_str = s.humanReadable()
+        size_str = s.human_readable()
         for lang in self.TEST_LANGS:
 
             os.environ['LANG'] = lang
             locale.setlocale(locale.LC_ALL, '')
-            self.assertTrue(s.humanReadable().endswith("%s%s" % (_("Mi"), _("B"))))
-            self.assertEqual(s.humanReadable(xlate=False), size_str)
+            self.assertTrue(s.human_readable().endswith("%s%s" % (_("Mi"), _("B"))))
+            self.assertEqual(s.human_readable(xlate=False), size_str)
 
-    def testRoundToNearest(self):
+    def test_round_to_nearest(self):
         self.assertEqual(size.ROUND_DEFAULT, size.ROUND_HALF_UP)
 
         s = Size("10.3 GiB")
-        self.assertEqual(s.roundToNearest(GiB), Size("10 GiB"))
-        self.assertEqual(s.roundToNearest(GiB, rounding=size.ROUND_DEFAULT),
+        self.assertEqual(s.round_to_nearest(GiB), Size("10 GiB"))
+        self.assertEqual(s.round_to_nearest(GiB, rounding=size.ROUND_DEFAULT),
                          Size("10 GiB"))
-        self.assertEqual(s.roundToNearest(GiB, rounding=size.ROUND_DOWN),
+        self.assertEqual(s.round_to_nearest(GiB, rounding=size.ROUND_DOWN),
                          Size("10 GiB"))
-        self.assertEqual(s.roundToNearest(GiB, rounding=size.ROUND_UP),
+        self.assertEqual(s.round_to_nearest(GiB, rounding=size.ROUND_UP),
                          Size("11 GiB"))
-        # >>> Size("10.3 GiB").convertTo(MiB)
+        # >>> Size("10.3 GiB").convert_to(MiB)
         # Decimal('10547.19999980926513671875')
-        self.assertEqual(s.roundToNearest(MiB), Size("10547 MiB"))
-        self.assertEqual(s.roundToNearest(MiB, rounding=size.ROUND_UP),
+        self.assertEqual(s.round_to_nearest(MiB), Size("10547 MiB"))
+        self.assertEqual(s.round_to_nearest(MiB, rounding=size.ROUND_UP),
                          Size("10548 MiB"))
-        self.assertIsInstance(s.roundToNearest(MiB), Size)
+        self.assertIsInstance(s.round_to_nearest(MiB), Size)
         with self.assertRaises(ValueError):
-            s.roundToNearest(MiB, rounding='abc')
+            s.round_to_nearest(MiB, rounding='abc')
 
         # arbitrary decimal rounding constants are not allowed
         from decimal import ROUND_HALF_DOWN
         with self.assertRaises(ValueError):
-            s.roundToNearest(MiB, rounding=ROUND_HALF_DOWN)
+            s.round_to_nearest(MiB, rounding=ROUND_HALF_DOWN)
 
         s = Size("10.51 GiB")
-        self.assertEqual(s.roundToNearest(GiB), Size("11 GiB"))
-        self.assertEqual(s.roundToNearest(GiB, rounding=size.ROUND_DEFAULT),
+        self.assertEqual(s.round_to_nearest(GiB), Size("11 GiB"))
+        self.assertEqual(s.round_to_nearest(GiB, rounding=size.ROUND_DEFAULT),
                          Size("11 GiB"))
-        self.assertEqual(s.roundToNearest(GiB, rounding=size.ROUND_DOWN),
+        self.assertEqual(s.round_to_nearest(GiB, rounding=size.ROUND_DOWN),
                          Size("10 GiB"))
-        self.assertEqual(s.roundToNearest(GiB, rounding=size.ROUND_UP),
+        self.assertEqual(s.round_to_nearest(GiB, rounding=size.ROUND_UP),
                          Size("11 GiB"))
 
         s = Size("513 GiB")
-        self.assertEqual(s.roundToNearest(GiB), s)
-        self.assertEqual(s.roundToNearest(TiB), Size("1 TiB"))
-        self.assertEqual(s.roundToNearest(TiB, rounding=size.ROUND_DOWN),
+        self.assertEqual(s.round_to_nearest(GiB), s)
+        self.assertEqual(s.round_to_nearest(TiB), Size("1 TiB"))
+        self.assertEqual(s.round_to_nearest(TiB, rounding=size.ROUND_DOWN),
                          Size(0))
 
         # test Size parameters
-        self.assertEqual(s.roundToNearest(Size("128 GiB")), Size("512 GiB"))
-        self.assertEqual(s.roundToNearest(Size("1 KiB")), Size("513 GiB"))
-        self.assertEqual(s.roundToNearest(Size("1 TiB")), Size("1 TiB"))
-        self.assertEqual(s.roundToNearest(Size("1 TiB"), rounding=size.ROUND_DOWN), Size(0))
-        self.assertEqual(s.roundToNearest(Size(0)), Size(0))
-        self.assertEqual(s.roundToNearest(Size("13 GiB")), Size("507 GiB"))
+        self.assertEqual(s.round_to_nearest(Size("128 GiB")), Size("512 GiB"))
+        self.assertEqual(s.round_to_nearest(Size("1 KiB")), Size("513 GiB"))
+        self.assertEqual(s.round_to_nearest(Size("1 TiB")), Size("1 TiB"))
+        self.assertEqual(s.round_to_nearest(Size("1 TiB"), rounding=size.ROUND_DOWN), Size(0))
+        self.assertEqual(s.round_to_nearest(Size(0)), Size(0))
+        self.assertEqual(s.round_to_nearest(Size("13 GiB")), Size("507 GiB"))
 
         with self.assertRaises(ValueError):
-            s.roundToNearest(Size("-1 B"))
+            s.round_to_nearest(Size("-1 B"))
 
 class UtilityMethodsTestCase(unittest.TestCase):
 
-    def testLowerASCII(self):
-        """ Tests for _lowerASCII. """
-        self.assertEqual(size._lowerASCII(""), "")
-        self.assertEqual(size._lowerASCII("B"), "b")
+    def test_lower_ascii(self):
+        """ Tests for _lower_ascii. """
+        self.assertEqual(size._lower_ascii(""), "")
+        self.assertEqual(size._lower_ascii("B"), "b")
 
-    def testArithmetic(self):
+    def test_arithmetic(self):
         s = Size("2GiB")
 
         # Make sure arithmatic operations with Size always result in the expected type
diff --git a/tests/storagetestcase.py b/tests/storagetestcase.py
index 8a2c89a..347acc8 100644
--- a/tests/storagetestcase.py
+++ b/tests/storagetestcase.py
@@ -5,7 +5,7 @@
 import parted
 
 import blivet as blivet
-from blivet.formats import getFormat
+from blivet.formats import get_format
 
 # device classes for brevity's sake -- later on, that is
 from blivet.devices import StorageDevice
@@ -40,19 +40,19 @@ def setUp(self):
 
         # prevent PartitionDevice from trying to dig around in the partition's
         # geometry
-        self.partition_set_target = PartitionDevice._setTargetSize
-        self.partition_align_target = PartitionDevice.alignTargetSize
-        self.partition_max = PartitionDevice.maxSize
-        self.partition_min = PartitionDevice.minSize
-        blivet.devices.PartitionDevice._setTargetSize = StorageDevice._setTargetSize
-        blivet.devices.PartitionDevice.alignTargetSize = StorageDevice.alignTargetSize
-        blivet.devices.PartitionDevice.maxSize = StorageDevice.maxSize
-        blivet.devices.PartitionDevice.minSize = StorageDevice.minSize
+        self.partition_set_target = PartitionDevice._set_target_size
+        self.partition_align_target = PartitionDevice.align_target_size
+        self.partition_max = PartitionDevice.max_size
+        self.partition_min = PartitionDevice.min_size
+        blivet.devices.PartitionDevice._set_target_size = StorageDevice._set_target_size
+        blivet.devices.PartitionDevice.align_target_size = StorageDevice.align_target_size
+        blivet.devices.PartitionDevice.max_size = StorageDevice.max_size
+        blivet.devices.PartitionDevice.min_size = StorageDevice.min_size
 
         def partition_probe(device):
-            if isinstance(device._partedPartition, Mock):
+            if isinstance(device._parted_partition, Mock):
                 # don't clobber a Mock we already set up here
-                part_mock = device._partedPartition
+                part_mock = device._parted_partition
             else:
                 part_mock = Mock()
 
@@ -60,16 +60,16 @@ def partition_probe(device):
                      "getDeviceNodeName.return_value": device.name,
                      "type": parted.PARTITION_NORMAL}
             part_mock.configure_mock(**attrs)
-            device._partedPartition = part_mock
-            device._currentSize = device._size
-            device._partType = parted.PARTITION_NORMAL
+            device._parted_partition = part_mock
+            device._current_size = device._size
+            device._part_type = parted.PARTITION_NORMAL
             device._bootable = False
 
         self.partition_probe = PartitionDevice.probe
         PartitionDevice.probe = partition_probe
 
-        self.get_active_mounts = blivet.formats.fs.mountsCache._getActiveMounts
-        blivet.formats.fs.mountsCache._getActiveMounts = Mock()
+        self.get_active_mounts = blivet.formats.fs.mounts_cache._get_active_mounts
+        blivet.formats.fs.mounts_cache._get_active_mounts = Mock()
 
     def tearDown(self):
         blivet.devices.StorageDevice.status = self.storage_status
@@ -79,16 +79,16 @@ def tearDown(self):
         blivet.devices.MDRaidArrayDevice.status = self.md_status
         blivet.devices.FileDevice.status = self.file_status
 
-        blivet.devices.PartitionDevice._setTargetSize = self.partition_set_target
-        blivet.devices.PartitionDevice.alignTargetSize = self.partition_align_target
-        blivet.devices.PartitionDevice.maxSize = self.partition_max
-        blivet.devices.PartitionDevice.minSize = self.partition_min
+        blivet.devices.PartitionDevice._set_target_size = self.partition_set_target
+        blivet.devices.PartitionDevice.align_target_size = self.partition_align_target
+        blivet.devices.PartitionDevice.max_size = self.partition_max
+        blivet.devices.PartitionDevice.min_size = self.partition_min
 
         blivet.devices.PartitionDevice.probe = self.partition_probe
 
-        blivet.formats.fs.mountsCache._getActiveMounts = self.get_active_mounts
+        blivet.formats.fs.mounts_cache._get_active_mounts = self.get_active_mounts
 
-    def newDevice(self, *args, **kwargs):
+    def new_device(self, *args, **kwargs):
         """ Return a new Device instance suitable for testing. """
         device_class = kwargs.pop("device_class")
         exists = kwargs.pop("exists", False)
@@ -96,31 +96,31 @@ def newDevice(self, *args, **kwargs):
         device = device_class(*args, **kwargs)
 
         if exists:
-            device._currentSize = kwargs.get("size")
+            device._current_size = kwargs.get("size")
 
         if isinstance(device, blivet.devices.PartitionDevice):
             #if exists:
             #    device.parents = device.req_disks
             device.parents = device.req_disks
 
-            partedPartition = Mock()
+            parted_partition = Mock()
 
             if device.disk:
                 part_num = device.name[len(device.disk.name):].split("p")[-1]
-                partedPartition.number = int(part_num)
+                parted_partition.number = int(part_num)
 
-            partedPartition.type = part_type
-            partedPartition.path = device.path
-            partedPartition.getDeviceNodeName = Mock(return_value=device.name)
+            parted_partition.type = part_type
+            parted_partition.path = device.path
+            parted_partition.get_device_node_name = Mock(return_value=device.name)
             if len(device.parents) == 1:
                 disk_name = device.parents[0].name
                 number = device.name.replace(disk_name, "")
                 try:
-                    partedPartition.number = int(number)
+                    parted_partition.number = int(number)
                 except ValueError:
                     pass
 
-            device._partedPartition = partedPartition
+            device._parted_partition = parted_partition
         elif isinstance(device, blivet.devices.LVMVolumeGroupDevice) and exists:
             device._complete = True
 
@@ -133,7 +133,7 @@ def newDevice(self, *args, **kwargs):
 
         return device
 
-    def newFormat(self, *args, **kwargs):
+    def new_format(self, *args, **kwargs):
         """ Return a new DeviceFormat instance suitable for testing.
 
             Keyword Arguments:
@@ -143,34 +143,34 @@ def newFormat(self, *args, **kwargs):
                                   resizable formats.
 
             All other arguments are passed directly to
-            blivet.formats.getFormat.
+            blivet.formats.get_format.
         """
         exists = kwargs.pop("exists", False)
         device_instance = kwargs.pop("device_instance", None)
-        fmt = getFormat(*args, **kwargs)
+        fmt = get_format(*args, **kwargs)
         if isinstance(fmt, blivet.formats.disklabel.DiskLabel):
-            fmt._partedDevice = Mock()
-            fmt._partedDisk = Mock()
+            fmt._parted_device = Mock()
+            fmt._parted_disk = Mock()
             attrs = {"partitions": []}
-            fmt._partedDisk.configure_mock(**attrs)
+            fmt._parted_disk.configure_mock(**attrs)
 
         fmt.exists = exists
         if exists:
             fmt._resizable = fmt.__class__._resizable
 
         if fmt.resizable and device_instance:
-            fmt._size = device_instance.currentSize
+            fmt._size = device_instance.current_size
 
         return fmt
 
-    def destroyAllDevices(self, disks=None):
+    def destroy_all_devices(self, disks=None):
         """ Remove all devices from the devicetree.
 
             Keyword Arguments:
 
                 disks - a list of names of disks to remove partitions from
 
-            Note: this is largely ripped off from partitioning.clearPartitions.
+            Note: this is largely ripped off from partitioning.clear_partitions.
 
         """
         partitions = self.storage.partitions
@@ -179,21 +179,21 @@ def destroyAllDevices(self, disks=None):
         # things like multiple "destroy sda5" actions due to parted renumbering
         # partitions. This can still happen through the UI but it makes sense to
         # avoid it where possible.
-        partitions.sort(key=lambda p: p.partedPartition.number, reverse=True)
+        partitions.sort(key=lambda p: p.parted_partition.number, reverse=True)
         for part in partitions:
             if disks and part.disk.name not in disks:
                 continue
 
-            devices = self.storage.deviceDeps(part)
+            devices = self.storage.device_deps(part)
             while devices:
                 leaves = [d for d in devices if d.isleaf]
                 for leaf in leaves:
-                    self.storage.destroyDevice(leaf)
+                    self.storage.destroy_device(leaf)
                     devices.remove(leaf)
 
-            self.storage.destroyDevice(part)
+            self.storage.destroy_device(part)
 
-    def scheduleCreateDevice(self, device):
+    def schedule_create_device(self, device):
         """ Schedule an action to create the specified device.
 
             Verify that the device is not already in the tree and that the
@@ -209,13 +209,13 @@ def scheduleCreateDevice(self, device):
 
         devicetree = self.storage.devicetree
 
-        self.assertEqual(devicetree.getDeviceByName(device.name), None)
+        self.assertEqual(devicetree.get_device_by_name(device.name), None)
         action = blivet.deviceaction.ActionCreateDevice(device)
-        devicetree.registerAction(action)
-        self.assertEqual(devicetree.getDeviceByName(device.name), device)
+        devicetree.register_action(action)
+        self.assertEqual(devicetree.get_device_by_name(device.name), device)
         return action
 
-    def scheduleDestroyDevice(self, device):
+    def schedule_destroy_device(self, device):
         """ Schedule an action to destroy the specified device.
 
             Verify that the device exists initially and that the act of
@@ -226,13 +226,13 @@ def scheduleDestroyDevice(self, device):
         """
         devicetree = self.storage.devicetree
 
-        self.assertEqual(devicetree.getDeviceByName(device.name), device)
+        self.assertEqual(devicetree.get_device_by_name(device.name), device)
         action = blivet.deviceaction.ActionDestroyDevice(device)
-        devicetree.registerAction(action)
-        self.assertEqual(devicetree.getDeviceByName(device.name), None)
+        devicetree.register_action(action)
+        self.assertEqual(devicetree.get_device_by_name(device.name), None)
         return action
 
-    def scheduleCreateFormat(self, device, fmt):
+    def schedule_create_format(self, device, fmt):
         """ Schedule an action to write a new format to a device.
 
             Verify that the device is already in the tree, that it is not
@@ -245,14 +245,14 @@ def scheduleCreateFormat(self, device, fmt):
         devicetree = self.storage.devicetree
 
         self.assertNotEqual(device.format, fmt)
-        self.assertEqual(devicetree.getDeviceByName(device.name), device)
+        self.assertEqual(devicetree.get_device_by_name(device.name), device)
         action = blivet.deviceaction.ActionCreateFormat(device, fmt)
-        devicetree.registerAction(action)
-        _device = devicetree.getDeviceByName(device.name)
+        devicetree.register_action(action)
+        _device = devicetree.get_device_by_name(device.name)
         self.assertEqual(_device.format, fmt)
         return action
 
-    def scheduleDestroyFormat(self, device):
+    def schedule_destroy_format(self, device):
         """ Schedule an action to remove a format from a device.
 
             Verify that the device is already in the tree and that the act
@@ -263,9 +263,9 @@ def scheduleDestroyFormat(self, device):
         """
         devicetree = self.storage.devicetree
 
-        self.assertEqual(devicetree.getDeviceByName(device.name), device)
+        self.assertEqual(devicetree.get_device_by_name(device.name), device)
         action = blivet.deviceaction.ActionDestroyFormat(device)
-        devicetree.registerAction(action)
-        _device = devicetree.getDeviceByName(device.name)
+        devicetree.register_action(action)
+        _device = devicetree.get_device_by_name(device.name)
         self.assertEqual(_device.format.type, None)
         return action
diff --git a/tests/tasks_test/basic_tests.py b/tests/tasks_test/basic_tests.py
index 3aa5492..c14133e 100644
--- a/tests/tasks_test/basic_tests.py
+++ b/tests/tasks_test/basic_tests.py
@@ -7,39 +7,39 @@ class BasicUnavailableApplication(task.BasicApplication):
     ext = availability.unavailable_resource("unavailable")
     description = "unavailable application"
 
-    def doTask(self):
+    def do_task(self):
         pass
 
 class BasicAvailableApplication(task.BasicApplication):
     ext = availability.available_resource("available")
     description = "available application"
 
-    def doTask(self):
+    def do_task(self):
         pass
 
 class ResourceTestCase(unittest.TestCase):
 
-    def testAvailabililty(self):
+    def test_availabililty(self):
         unavailable_resource = availability.unavailable_resource("unavailable")
-        self.assertNotEqual(unavailable_resource.availabilityErrors, [])
+        self.assertNotEqual(unavailable_resource.availability_errors, [])
         self.assertFalse(unavailable_resource.available)
 
         available_resource = availability.available_resource("available")
-        self.assertEqual(available_resource.availabilityErrors, [])
+        self.assertEqual(available_resource.availability_errors, [])
         self.assertTrue(available_resource.available)
 
 class TasksTestCase(unittest.TestCase):
 
-    def testAvailability(self):
+    def test_availability(self):
         unavailable_app = BasicUnavailableApplication()
         self.assertFalse(unavailable_app.available)
-        self.assertNotEqual(unavailable_app.availabilityErrors, [])
+        self.assertNotEqual(unavailable_app.availability_errors, [])
 
         available_app = BasicAvailableApplication()
         self.assertTrue(available_app.available)
-        self.assertEqual(available_app.availabilityErrors, [])
+        self.assertEqual(available_app.availability_errors, [])
 
-    def testNames(self):
+    def test_names(self):
         # Every basic application takes its string representation from
         # the external resource.
         unavailable_app = BasicUnavailableApplication()
diff --git a/tests/tsort_test.py b/tests/tsort_test.py
index a2a17a9..912cd97 100644
--- a/tests/tsort_test.py
+++ b/tests/tsort_test.py
@@ -3,15 +3,15 @@
 import blivet.tsort
 
 class TopologicalSortTestCase(unittest.TestCase):
-    def runTest(self):
+    def run_test(self):
         items = [1, 2, 3, 4, 5]
         edges = [(5, 4), (4, 3), (3, 2), (2, 1)]
         graph = blivet.tsort.create_graph(items, edges)
-        self._tsortTest(graph)
+        self._tsort_test(graph)
 
         edges = [(5, 4), (2, 3), (1, 5)]
         graph = blivet.tsort.create_graph(items, edges)
-        self._tsortTest(graph)
+        self._tsort_test(graph)
 
         edges = [(5, 4), (4, 3), (3, 2), (2, 1), (3, 5)]
         graph = blivet.tsort.create_graph(items, edges)
@@ -26,9 +26,9 @@ def runTest(self):
         items = ['a', 'b', 'c', 'd']
         edges = [('a', 'c'), ('c', 'b')]
         graph = blivet.tsort.create_graph(items, edges)
-        self._tsortTest(graph)
+        self._tsort_test(graph)
 
-    def _tsortTest(self, graph):
+    def _tsort_test(self, graph):
         def check_order(order, graph):
             # since multiple solutions can potentially exist, just verify
             # that the ordering constraints are satisfied
diff --git a/tests/util_test.py b/tests/util_test.py
index e47e252..2e3cbf5 100644
--- a/tests/util_test.py
+++ b/tests/util_test.py
@@ -8,7 +8,7 @@ class MiscTest(unittest.TestCase):
 
     # Disable this warning, which will only be triggered on python3.  For
     # python2, the default is False.
-    longMessage = True      # pylint: disable=pointless-class-attribute-override
+    long_message = True      # pylint: disable=pointless-class-attribute-override
 
     def test_power_of_two(self):
         self.assertFalse(util.power_of_two(None))


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


More information about the anaconda-patches mailing list