diff --git a/OpenBMCMapper.py b/OpenBMCMapper.py
index 2ed65f7..518e703 100644
--- a/OpenBMCMapper.py
+++ b/OpenBMCMapper.py
@@ -25,331 +25,340 @@
 ENUMERATE_IFACE = 'org.openbmc.Object.Enumerate'
 MAPPER_NOT_FOUND = 'org.openbmc.objectmapper.Error.NotFound'
 
+
 class Path:
-	def __init__(self, path):
-		self.parts = filter(bool, path.split('/'))
+    def __init__(self, path):
+        self.parts = filter(bool, path.split('/'))
 
-	def rel(self, first = None, last = None):
-		# relative
-		return self.get('', first, last)
+    def rel(self, first=None, last=None):
+        # relative
+        return self.get('', first, last)
 
-	def fq(self, first = None, last = None):
-		# fully qualified
-		return self.get('/', first, last)
+    def fq(self, first=None, last=None):
+        # fully qualified
+        return self.get('/', first, last)
 
-	def depth(self):
-		return len(self.parts)
+    def depth(self):
+        return len(self.parts)
 
-	def get(self, prefix = '/', first = None, last = None):
-		if not first:
-			first = 0
-		if not last:
-			last = self.depth()
-		return prefix + '/'.join(self.parts[first:last])
+    def get(self, prefix='/', first=None, last=None):
+        if not first:
+            first = 0
+        if not last:
+            last = self.depth()
+        return prefix + '/'.join(self.parts[first:last])
+
 
 def org_dot_openbmc_match(name):
-	return 'org.openbmc' in name
+    return 'org.openbmc' in name
+
 
 class ListMatch(object):
-	def __init__(self, l):
-		self.l = l
+    def __init__(self, l):
+        self.l = l
 
-	def __call__(self, match):
-		return match in self.l
+    def __call__(self, match):
+        return match in self.l
+
 
 class IntrospectionNodeParser:
-	def __init__(self, data, tag_match = bool, intf_match = bool):
-		self.data = data
-		self.cache = {}
-		self.tag_match = tag_match
-		self.intf_match = intf_match
+    def __init__(self, data, tag_match=bool, intf_match=bool):
+        self.data = data
+        self.cache = {}
+        self.tag_match = tag_match
+        self.intf_match = intf_match
 
-	def parse_args(self):
-		return [ x.attrib for x in self.data.findall('arg') ]
+    def parse_args(self):
+        return [x.attrib for x in self.data.findall('arg')]
 
-	def parse_children(self):
-		return [ x.attrib['name'] for x in self.data.findall('node') ]
+    def parse_children(self):
+        return [x.attrib['name'] for x in self.data.findall('node')]
 
-	def parse_method_or_signal(self):
-		name = self.data.attrib['name']
-		return name, self.parse_args()
+    def parse_method_or_signal(self):
+        name = self.data.attrib['name']
+        return name, self.parse_args()
 
-	def parse_interface(self):
-		iface = {}
-		iface['method'] = {}
-		iface['signal'] = {}
+    def parse_interface(self):
+        iface = {}
+        iface['method'] = {}
+        iface['signal'] = {}
 
-		for node in self.data:
-			if node.tag not in ['method', 'signal']:
-				continue
-			if not self.tag_match(node.tag):
-				continue
-			p = IntrospectionNodeParser(
-					node, self.tag_match, self.intf_match)
-			n, element = p.parse_method_or_signal()
-			iface[node.tag][n] = element
+        for node in self.data:
+            if node.tag not in ['method', 'signal']:
+                continue
+            if not self.tag_match(node.tag):
+                continue
+            p = IntrospectionNodeParser(
+                node, self.tag_match, self.intf_match)
+            n, element = p.parse_method_or_signal()
+            iface[node.tag][n] = element
 
-		return iface
+        return iface
 
-	def parse_node(self):
-		if self.cache:
-			return self.cache
+    def parse_node(self):
+        if self.cache:
+            return self.cache
 
-		self.cache['interfaces'] = {}
-		self.cache['children'] = []
+        self.cache['interfaces'] = {}
+        self.cache['children'] = []
 
-		for node in self.data:
-			if node.tag == 'interface':
-				p = IntrospectionNodeParser(
-						node, self.tag_match, self.intf_match)
-				name = p.data.attrib['name']
-				if not self.intf_match(name):
-					continue
-				self.cache['interfaces'][name] = p.parse_interface()
-			elif node.tag == 'node':
-				self.cache['children'] = self.parse_children()
+        for node in self.data:
+            if node.tag == 'interface':
+                p = IntrospectionNodeParser(
+                    node, self.tag_match, self.intf_match)
+                name = p.data.attrib['name']
+                if not self.intf_match(name):
+                    continue
+                self.cache['interfaces'][name] = p.parse_interface()
+            elif node.tag == 'node':
+                self.cache['children'] = self.parse_children()
 
-		return self.cache
+        return self.cache
 
-	def get_interfaces(self):
-		return self.parse_node()['interfaces']
+    def get_interfaces(self):
+        return self.parse_node()['interfaces']
 
-	def get_children(self):
-		return self.parse_node()['children']
+    def get_children(self):
+        return self.parse_node()['children']
 
-	def recursive_binding(self):
-		return any('/' in s for s in self.get_children())
+    def recursive_binding(self):
+        return any('/' in s for s in self.get_children())
+
 
 class IntrospectionParser:
-	def __init__(self, name, bus, tag_match = bool, intf_match = bool):
-		self.name = name
-		self.bus = bus
-		self.tag_match = tag_match
-		self.intf_match = intf_match
+    def __init__(self, name, bus, tag_match=bool, intf_match=bool):
+        self.name = name
+        self.bus = bus
+        self.tag_match = tag_match
+        self.intf_match = intf_match
 
-	def _introspect(self, path):
-		try:
-			obj = self.bus.get_object(self.name, path, introspect = False)
-			iface = dbus.Interface(obj, dbus.INTROSPECTABLE_IFACE)
-			data = iface.Introspect()
-		except dbus.DBusException:
-			return None
+    def _introspect(self, path):
+        try:
+            obj = self.bus.get_object(self.name, path, introspect=False)
+            iface = dbus.Interface(obj, dbus.INTROSPECTABLE_IFACE)
+            data = iface.Introspect()
+        except dbus.DBusException:
+            return None
 
-		return IntrospectionNodeParser(
-				ElementTree.fromstring(data),
-				self.tag_match,
-				self.intf_match)
+        return IntrospectionNodeParser(
+            ElementTree.fromstring(data),
+            self.tag_match,
+            self.intf_match)
 
-	def _discover_flat(self, path, parser):
-		items = {}
-		interfaces = parser.get_interfaces().keys()
-		if interfaces:
-			items[path] = {}
-			items[path]['interfaces'] = interfaces
+    def _discover_flat(self, path, parser):
+        items = {}
+        interfaces = parser.get_interfaces().keys()
+        if interfaces:
+            items[path] = {}
+            items[path]['interfaces'] = interfaces
 
-		return items
+        return items
 
-	def introspect(self, path = '/', parser = None):
-		items = {}
-		if not parser:
-			parser = self._introspect(path)
-		if not parser:
-			return {}
-		items.update(self._discover_flat(path, parser))
+    def introspect(self, path='/', parser=None):
+        items = {}
+        if not parser:
+            parser = self._introspect(path)
+        if not parser:
+            return {}
+        items.update(self._discover_flat(path, parser))
 
-		if path != '/':
-			path += '/'
+        if path != '/':
+            path += '/'
 
-		if parser.recursive_binding():
-			callback = self._discover_flat
-		else:
-			callback = self.introspect
+        if parser.recursive_binding():
+            callback = self._discover_flat
+        else:
+            callback = self.introspect
 
-		for k in parser.get_children():
-			parser = self._introspect(path + k)
-			if not parser:
-				continue
-			items.update(callback(path + k, parser))
+        for k in parser.get_children():
+            parser = self._introspect(path + k)
+            if not parser:
+                continue
+            items.update(callback(path + k, parser))
 
-		return items
+        return items
+
 
 class PathTreeItemIterator(object):
-	def __init__(self, path_tree, subtree, depth):
-		self.path_tree = path_tree
-		self.path = []
-		self.itlist = []
-		self.subtree = ['/'] + filter(bool, subtree.split('/'))
-		self.depth = depth
-		d = path_tree.root
-		for k in self.subtree:
-			try:
-				d = d[k]['children']
-			except KeyError:
-				raise KeyError(subtree)
-		self.it = d.iteritems()
+    def __init__(self, path_tree, subtree, depth):
+        self.path_tree = path_tree
+        self.path = []
+        self.itlist = []
+        self.subtree = ['/'] + filter(bool, subtree.split('/'))
+        self.depth = depth
+        d = path_tree.root
+        for k in self.subtree:
+            try:
+                d = d[k]['children']
+            except KeyError:
+                raise KeyError(subtree)
+        self.it = d.iteritems()
 
-	def __iter__(self):
-		return self
+    def __iter__(self):
+        return self
 
-	def __next__(self):
-		return super(PathTreeItemIterator, self).next()
+    def __next__(self):
+        return super(PathTreeItemIterator, self).next()
 
-	def next(self):
-		key, value = self._next()
-		path = self.subtree[0] + '/'.join(self.subtree[1:] + self.path)
-		return path, value.get('data')
+    def next(self):
+        key, value = self._next()
+        path = self.subtree[0] + '/'.join(self.subtree[1:] + self.path)
+        return path, value.get('data')
 
-	def _next(self):
-		try:
-			while True:
-				x = self.it.next()
-				depth_exceeded = len(self.path) +1 > self.depth
-				if self.depth and depth_exceeded:
-					continue
-				self.itlist.append(self.it)
-				self.path.append(x[0])
-				self.it = x[1]['children'].iteritems()
-				break;
+    def _next(self):
+        try:
+            while True:
+                x = self.it.next()
+                depth_exceeded = len(self.path) + 1 > self.depth
+                if self.depth and depth_exceeded:
+                    continue
+                self.itlist.append(self.it)
+                self.path.append(x[0])
+                self.it = x[1]['children'].iteritems()
+                break
 
-		except StopIteration:
-			if not self.itlist:
-				raise StopIteration
+        except StopIteration:
+            if not self.itlist:
+                raise StopIteration
 
-			self.it = self.itlist.pop()
-			self.path.pop()
-			x = self._next()
-		
-		return x
+            self.it = self.itlist.pop()
+            self.path.pop()
+            x = self._next()
+
+        return x
+
 
 class PathTreeKeyIterator(PathTreeItemIterator):
-	def __init__(self, path_tree, subtree, depth):
-		super(PathTreeKeyIterator, self).__init__(path_tree, subtree, depth)
+    def __init__(self, path_tree, subtree, depth):
+        super(PathTreeKeyIterator, self).__init__(path_tree, subtree, depth)
 
-	def next(self):
-		return super(PathTreeKeyIterator, self).next()[0]
+    def next(self):
+        return super(PathTreeKeyIterator, self).next()[0]
+
 
 class PathTree:
-	def __init__(self):
-		self.root = {}
+    def __init__(self):
+        self.root = {}
 
-	def _try_delete_parent(self, elements):
-		if len(elements) == 1:
-			return False
+    def _try_delete_parent(self, elements):
+        if len(elements) == 1:
+            return False
 
-		kids = 'children'
-		elements.pop()
-		d = self.root
-		for k in elements[:-1]:
-			d = d[k][kids]
+        kids = 'children'
+        elements.pop()
+        d = self.root
+        for k in elements[:-1]:
+            d = d[k][kids]
 
-		if 'data' not in d[elements[-1]] and not d[elements[-1]][kids]:
-			del d[elements[-1]]
-			self._try_delete_parent(elements)
+        if 'data' not in d[elements[-1]] and not d[elements[-1]][kids]:
+            del d[elements[-1]]
+            self._try_delete_parent(elements)
 
-	def _get_node(self, key):
-		kids = 'children'
-		elements = ['/'] + filter(bool, key.split('/'))
-		d = self.root
-		for k in elements[:-1]:
-			try:
-				d = d[k][kids]
-			except KeyError:
-				raise KeyError(key)
-		
-		return d[elements[-1]]
+    def _get_node(self, key):
+        kids = 'children'
+        elements = ['/'] + filter(bool, key.split('/'))
+        d = self.root
+        for k in elements[:-1]:
+            try:
+                d = d[k][kids]
+            except KeyError:
+                raise KeyError(key)
 
-	def __iter__(self):
-		return self
+        return d[elements[-1]]
 
-	def __missing__(self, key):
-		for x in self.iterkeys():
-			if key == x:
-				return False
-		return True
+    def __iter__(self):
+        return self
 
-	def __delitem__(self, key):
-		kids = 'children'
-		elements = ['/'] + filter(bool, key.split('/'))
-		d = self.root
-		for k in elements[:-1]:
-			try:
-				d = d[k][kids]
-			except KeyError:
-				raise KeyError(key)
+    def __missing__(self, key):
+        for x in self.iterkeys():
+            if key == x:
+                return False
+        return True
 
-		del d[elements[-1]]
-		self._try_delete_parent(elements)
+    def __delitem__(self, key):
+        kids = 'children'
+        elements = ['/'] + filter(bool, key.split('/'))
+        d = self.root
+        for k in elements[:-1]:
+            try:
+                d = d[k][kids]
+            except KeyError:
+                raise KeyError(key)
 
-	def __setitem__(self, key, value):
-		kids = 'children'
-		elements = ['/'] + filter(bool, key.split('/'))
-		d = self.root
-		for k in elements[:-1]:
-			d = d.setdefault(k, {kids: {}})[kids]
+        del d[elements[-1]]
+        self._try_delete_parent(elements)
 
-		children = d.setdefault(elements[-1], {kids: {}})[kids]
-		d[elements[-1]].update({kids: children, 'data': value})
+    def __setitem__(self, key, value):
+        kids = 'children'
+        elements = ['/'] + filter(bool, key.split('/'))
+        d = self.root
+        for k in elements[:-1]:
+            d = d.setdefault(k, {kids: {}})[kids]
 
-	def __getitem__(self, key):
-		return self._get_node(key).get('data')
+        children = d.setdefault(elements[-1], {kids: {}})[kids]
+        d[elements[-1]].update({kids: children, 'data': value})
 
-	def setdefault(self, key, default):
-		if not self.get(key):
-			self.__setitem__(key, default)
+    def __getitem__(self, key):
+        return self._get_node(key).get('data')
 
-		return self.__getitem__(key)
+    def setdefault(self, key, default):
+        if not self.get(key):
+            self.__setitem__(key, default)
 
-	def get(self, key, default = None):
-		try:
-			x = self.__getitem__(key)
-		except KeyError:
-			x = default
+        return self.__getitem__(key)
 
-		return x
+    def get(self, key, default=None):
+        try:
+            x = self.__getitem__(key)
+        except KeyError:
+            x = default
 
-	def get_children(self, key):
-		return [ x for x in self._get_node(key)['children'].iterkeys() ]
+        return x
 
-	def demote(self, key):
-		n = self._get_node(key)
-		if 'data' in n:
-			del n['data']
+    def get_children(self, key):
+        return [x for x in self._get_node(key)['children'].iterkeys()]
 
-	def keys(self, subtree = '/', depth = None):
-		return [ x for x in self.iterkeys(subtree, depth) ]
+    def demote(self, key):
+        n = self._get_node(key)
+        if 'data' in n:
+            del n['data']
 
-	def values(self, subtree = '/', depth = None):
-		return [ x[1] for x in self.iteritems(subtree, depth) ]
+    def keys(self, subtree='/', depth=None):
+        return [x for x in self.iterkeys(subtree, depth)]
 
-	def items(self, subtree = '/', depth = None):
-		return [ x for x in self.iteritems(subtree, depth) ]
+    def values(self, subtree='/', depth=None):
+        return [x[1] for x in self.iteritems(subtree, depth)]
 
-	def dataitems(self, subtree = '/', depth = None):
-		return [ x for x in self.iteritems(subtree, depth) \
-				if x[1] is not None ]
+    def items(self, subtree='/', depth=None):
+        return [x for x in self.iteritems(subtree, depth)]
 
-	def iterkeys(self, subtree = '/', depth = None):
-		if not self.root:
-			return {}.iterkeys()
-		return PathTreeKeyIterator(self, subtree, depth)
+    def dataitems(self, subtree='/', depth=None):
+        return [x for x in self.iteritems(subtree, depth)
+                if x[1] is not None]
 
-	def iteritems(self, subtree = '/', depth = None):
-		if not self.root:
-			return {}.iteritems()
-		return PathTreeItemIterator(self, subtree, depth)
+    def iterkeys(self, subtree='/', depth=None):
+        if not self.root:
+            return {}.iterkeys()
+        return PathTreeKeyIterator(self, subtree, depth)
+
+    def iteritems(self, subtree='/', depth=None):
+        if not self.root:
+            return {}.iteritems()
+        return PathTreeItemIterator(self, subtree, depth)
+
 
 class Mapper:
-	def __init__(self, bus):
-		self.bus = bus
-		obj = bus.get_object(MAPPER_NAME, MAPPER_PATH, introspect = False)
-		self.iface = dbus.Interface(
-				obj, dbus_interface = MAPPER_IFACE)
+    def __init__(self, bus):
+        self.bus = bus
+        obj = bus.get_object(MAPPER_NAME, MAPPER_PATH, introspect=False)
+        self.iface = dbus.Interface(
+            obj, dbus_interface=MAPPER_IFACE)
 
-	def get_object(self, path):
-		return self.iface.GetObject(path)
+    def get_object(self, path):
+        return self.iface.GetObject(path)
 
-	def get_subtree_paths(self, path = '/', depth = 0):
-		return self.iface.GetSubTreePaths(path, depth)
+    def get_subtree_paths(self, path='/', depth=0):
+        return self.iface.GetSubTreePaths(path, depth)
 
-	def get_subtree(self, path = '/', depth = 0):
-		return self.iface.GetSubTree(path, depth)
+    def get_subtree(self, path='/', depth=0):
+        return self.iface.GetSubTree(path, depth)
diff --git a/phosphor-mapper b/phosphor-mapper
index f5b1def..255897f 100644
--- a/phosphor-mapper
+++ b/phosphor-mapper
@@ -24,177 +24,188 @@
 from OpenBMCMapper import IntrospectionParser, PathTree
 import OpenBMCMapper
 
+
 class MapperNotFoundException(dbus.exceptions.DBusException):
-	_dbus_error_name = OpenBMCMapper.MAPPER_NOT_FOUND
-	def __init__(self, path):
-		super(MapperNotFoundException, self).__init__(
-				"path or object not found: %s" %(path))
+    _dbus_error_name = OpenBMCMapper.MAPPER_NOT_FOUND
+
+    def __init__(self, path):
+        super(MapperNotFoundException, self).__init__(
+            "path or object not found: %s" % (path))
+
 
 class ObjectMapper(dbus.service.Object):
-	def __init__(self, bus, path,
-			name_match = OpenBMCMapper.org_dot_openbmc_match,
-			intf_match = OpenBMCMapper.org_dot_openbmc_match):
-		super(ObjectMapper, self).__init__(bus.dbus, path)
-		self.cache = PathTree()
-		self.bus = bus
-		self.name_match = name_match
-		self.intf_match = intf_match
-		self.tag_match = OpenBMCMapper.ListMatch(['children', 'interface'])
-		self.service = None
+    def __init__(self, bus, path,
+                 name_match=OpenBMCMapper.org_dot_openbmc_match,
+                 intf_match=OpenBMCMapper.org_dot_openbmc_match):
+        super(ObjectMapper, self).__init__(bus.dbus, path)
+        self.cache = PathTree()
+        self.bus = bus
+        self.name_match = name_match
+        self.intf_match = intf_match
+        self.tag_match = OpenBMCMapper.ListMatch(['children', 'interface'])
+        self.service = None
 
-		gobject.idle_add(self.discover)
-		self.bus.dbus.add_signal_receiver(self.bus_handler,
-			dbus_interface = dbus.BUS_DAEMON_IFACE,
-			signal_name = 'NameOwnerChanged')
-		self.bus.dbus.add_signal_receiver(self.interfaces_added_handler,
-			dbus_interface = dbus.BUS_DAEMON_IFACE + '.ObjectManager',
-			signal_name = 'InterfacesAdded',
-			sender_keyword = 'sender')
-		self.bus.dbus.add_signal_receiver(self.interfaces_removed_handler,
-			dbus_interface = dbus.BUS_DAEMON_IFACE + '.ObjectManager',
-			signal_name = 'InterfacesRemoved',
-			sender_keyword = 'sender')
+        gobject.idle_add(self.discover)
+        self.bus.dbus.add_signal_receiver(
+            self.bus_handler,
+            dbus_interface=
+            dbus.BUS_DAEMON_IFACE,
+            signal_name='NameOwnerChanged')
+        self.bus.dbus.add_signal_receiver(
+            self.interfaces_added_handler,
+            dbus_interface=
+            dbus.BUS_DAEMON_IFACE + '.ObjectManager',
+            signal_name='InterfacesAdded',
+            sender_keyword='sender')
+        self.bus.dbus.add_signal_receiver(
+            self.interfaces_removed_handler,
+            dbus_interface=dbus.BUS_DAEMON_IFACE + '.ObjectManager',
+            signal_name='InterfacesRemoved',
+            sender_keyword='sender')
 
-	def bus_match(self, name):
-		if name == OpenBMCMapper.MAPPER_NAME:
-			return False
-		return self.name_match(name)
+    def bus_match(self, name):
+        if name == OpenBMCMapper.MAPPER_NAME:
+            return False
+        return self.name_match(name)
 
-	def discovery_pending(self):
-		return not bool(self.service)
+    def discovery_pending(self):
+        return not bool(self.service)
 
-	def interfaces_added_handler(self, path, iprops, **kw):
-		name = self.bus.get_owned_name(self.bus_match, kw['sender'])
-		if self.discovery_pending() or \
-				not self.bus_match(name):
-			return
+    def interfaces_added_handler(self, path, iprops, **kw):
+        name = self.bus.get_owned_name(self.bus_match, kw['sender'])
+        if self.discovery_pending() or \
+                not self.bus_match(name):
+            return
 
-		matches = [ x for x in iprops.iterkeys() if self.intf_match(x) ]
-		d = self.cache.setdefault(path, {})
-		d.setdefault(kw['sender'], []).extend(matches)
-		self.cache[path] = d
+        matches = [x for x in iprops.iterkeys() if self.intf_match(x)]
+        self.add_interfaces(path, kw['sender'], matches)
 
-	def interfaces_removed_handler(self, path, interfaces, **kw):
-		name = self.bus.get_owned_name(self.bus_match, kw['sender'])
-		if self.discovery_pending() or \
-				not self.bus_match(name):
-			return
-		item = self.cache[path]
-		sender = kw['sender']
-		for x in interfaces:
-			if self.intf_match(x):
-				try:
-					item[sender].remove(x)
-				except ValueError:
-					pass
+    def interfaces_removed_handler(self, path, interfaces, **kw):
+        name = self.bus.get_owned_name(self.bus_match, kw['sender'])
+        if self.discovery_pending() or \
+                not self.bus_match(name):
+            return
+        item = self.cache[path]
+        sender = kw['sender']
+        for x in interfaces:
+            if self.intf_match(x):
+                try:
+                    item[sender].remove(x)
+                except ValueError:
+                    pass
 
-		# remove the owner if there aren't any interfaces left
-		if not item[sender]:
-			del item[sender]
+        # remove the owner if there aren't any interfaces left
+        if not item[sender]:
+            del item[sender]
 
-		# update if interfaces remain
-		if item:
-			self.cache[path] = item
-		# mark for removal if no interfaces remain
-		elif self.cache.get_children(path):
-			self.cache.demote(path)
-		# delete the entire path if everything is gone
-		else:
-			del self.cache[path]
+        # update if interfaces remain
+        if item:
+            self.cache[path] = item
+        # mark for removal if no interfaces remain
+        elif self.cache.get_children(path):
+            self.cache.demote(path)
+        # delete the entire path if everything is gone
+        else:
+            del self.cache[path]
 
-	def process_new_owner(self, name):
-		# unique name
-		return self.discover([ IntrospectionParser(name,
-			self.bus.dbus, self.tag_match, self.intf_match) ])
+    def process_new_owner(self, name):
+        # unique name
+        return self.discover([IntrospectionParser(name,
+                             self.bus.dbus,
+                             self.tag_match,
+                             self.intf_match)])
 
-	def process_old_owner(self, name):
-		for x,y in self.cache.dataitems():
-			if name not in y:
-				continue
-			del y[name]
-			if y:
-				self.cache[x] = y
-			elif self.cache.get_children(x):
-				self.cache.demote(x)
-			else:
-				del self.cache[x]
+    def process_old_owner(self, name):
+        for x, y in self.cache.dataitems():
+            if name not in y:
+                continue
+            del y[name]
+            if y:
+                self.cache[x] = y
+            elif self.cache.get_children(x):
+                self.cache.demote(x)
+            else:
+                del self.cache[x]
 
-	def bus_handler(self, service, old, new):
-		if self.discovery_pending() or \
-				not self.bus_match(service):
-			return
+    def bus_handler(self, service, old, new):
+        if self.discovery_pending() or \
+                not self.bus_match(service):
+            return
 
-		if new:
-			self.process_new_owner(new)
-		if old:
-			self.process_old_owner(old)
+        if new:
+            self.process_new_owner(new)
+        if old:
+            self.process_old_owner(old)
 
-	def add_interfaces(self, path, owner, interfaces):
-		d = self.cache.setdefault(path, { })
-		d.setdefault(owner, []).extend(interfaces)
-		self.cache[path] = d
+    def add_interfaces(self, path, owner, interfaces):
+        d = self.cache.setdefault(path, {})
+        d = d.setdefault(owner, [])
+        self.cache[path][owner] = list(set(d + interfaces))
 
-	def add_items(self, owner, bus_items):
-		for x,y in bus_items.iteritems():
-			self.add_interfaces(x, owner, y['interfaces'])
+    def add_items(self, owner, bus_items):
+        for x, y in bus_items.iteritems():
+            self.add_interfaces(x, owner, y['interfaces'])
 
-	def discover(self, owners = None):
-		if not owners:
-			owners = [ IntrospectionParser(x, self.bus.dbus,
-				self.tag_match, self.intf_match) \
-						for x in self.bus.get_owner_names(self.bus_match) ]
-		for o in owners:
-			self.add_items(o.name, o.introspect())
+    def discover(self, owners=None):
+        if not owners:
+            owners = [IntrospectionParser(x, self.bus.dbus,
+                                          self.tag_match,
+                                          self.intf_match)
+                      for x in self.bus.get_owner_names(self.bus_match)]
+        for o in owners:
+            self.add_items(o.name, o.introspect())
 
-		if self.discovery_pending():
-			print "ObjectMapper discovery complete..."
-			self.service = dbus.service.BusName(
-					OpenBMCMapper.MAPPER_NAME, self.bus.dbus)
+        if self.discovery_pending():
+            print "ObjectMapper discovery complete..."
+            self.service = dbus.service.BusName(
+                OpenBMCMapper.MAPPER_NAME, self.bus.dbus)
 
-	@dbus.service.method(OpenBMCMapper.MAPPER_IFACE, 's', 'a{sas}')
-	def GetObject(self, path):
-		o = self.cache.get(path)
-		if not o:
-			raise MapperNotFoundException(path)
-		return o
+    @dbus.service.method(OpenBMCMapper.MAPPER_IFACE, 's', 'a{sas}')
+    def GetObject(self, path):
+        o = self.cache.get(path)
+        if not o:
+            raise MapperNotFoundException(path)
+        return o
 
-	@dbus.service.method(OpenBMCMapper.MAPPER_IFACE, 'si', 'as')
-	def GetSubTreePaths(self, path, depth):
-		try:
-			return self.cache.iterkeys(path, depth)
-		except KeyError:
-			raise MapperNotFoundException(path)
+    @dbus.service.method(OpenBMCMapper.MAPPER_IFACE, 'si', 'as')
+    def GetSubTreePaths(self, path, depth):
+        try:
+            return self.cache.iterkeys(path, depth)
+        except KeyError:
+            raise MapperNotFoundException(path)
 
-	@dbus.service.method(OpenBMCMapper.MAPPER_IFACE, 'si', 'a{sa{sas}}')
-	def GetSubTree(self, path, depth):
-		try:
-			return { x:y for x, y in self.cache.dataitems(path, depth) }
-		except KeyError:
-			raise MapperNotFoundException(path)
+    @dbus.service.method(OpenBMCMapper.MAPPER_IFACE, 'si', 'a{sa{sas}}')
+    def GetSubTree(self, path, depth):
+        try:
+            return {x: y for x, y in self.cache.dataitems(path, depth)}
+        except KeyError:
+            raise MapperNotFoundException(path)
+
 
 class BusWrapper:
-	def __init__(self, bus):
-		self.dbus = bus
+    def __init__(self, bus):
+        self.dbus = bus
 
-	def get_owned_name(self, match, bus):
-		for x in self.get_service_names(match):
-			if self.dbus.get_name_owner(x) == bus:
-				return x
+    def get_owned_name(self, match, bus):
+        for x in self.get_service_names(match):
+            if self.dbus.get_name_owner(x) == bus:
+                return x
 
-	def get_service_names(self, match):
-		# these are well known names
-		return [ x for x in self.dbus.list_names() \
-				if match(x) ]
+    def get_service_names(self, match):
+        # these are well known names
+        return [x for x in self.dbus.list_names()
+                if match(x)]
 
-	def get_owner_names(self, match):
-		# these are unique connection names
-		return list( set( [ self.dbus.get_name_owner(x) \
-				for x in self.get_service_names(match) ] ) )
+    def get_owner_names(self, match):
+        # these are unique connection names
+        return list(set(
+            [self.dbus.get_name_owner(x)
+                for x in self.get_service_names(match)]))
 
 if __name__ == '__main__':
-	dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-	bus = dbus.SystemBus()
-	o = ObjectMapper(BusWrapper(bus), OpenBMCMapper.MAPPER_PATH)
-	loop = gobject.MainLoop()
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    bus = dbus.SystemBus()
+    o = ObjectMapper(BusWrapper(bus), OpenBMCMapper.MAPPER_PATH)
+    loop = gobject.MainLoop()
 
-	loop.run()
+    loop.run()
diff --git a/setup.cfg b/setup.cfg
index ed3bf6e..483ca76 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,2 +1,2 @@
 [install]
-install_scripts=/usr/sbin
+install_scripts = /usr/sbin