Lint peer classes

peer/peerstore.py

@@ -1,88 +1,82 @@
 from .peerstore_interface import IPeerStore
-import asyncio
+from .peerdata import PeerData
 
 class PeerStore(IPeerStore):
 
     def __init__(self, context):
-        self.context = context
-        self.peerMap = {}
+        IPeerStore.__init__(self, context)
+        self.peer_map = {}
 
-	def peer_info(self, peerID):
-		if peerID in self.peerMap:
-			peer = self.peerMap[peerID]
-			return {
-				"peerID": peerID,
-				"addrs": peer.get_addrs()
-			}
-		else:
-			return None
+    def __create_or_get_peer(self, peer_id):
+        """
+        Returns the peer data for peer_id or creates a new
+        peer data (and stores it in peer_map) if peer
+        data for peer_id does not yet exist
+        :param peer_id: peer ID
+        :return: peer data
+        """
+        if peer_id in self.peer_map:
+            return self.peer_map[peer_id]
+        data = PeerData()
+        self.peer_map[peer_id] = data
+        return self.peer_map[peer_id]
 
-	def get_protocols(self, peerID):
-		if peerID in self.peerMap:
-			return self.peerMap[peerId].get_protocols(), None
-		else:
-			return None, peerID + " not found"
+    def peer_info(self, peer_id):
+        if peer_id in self.peer_map:
+            peer = self.peer_map[peer_id]
+            return {
+                "peer_id": peer_id,
+                "addrs": peer.get_addrs()
+            }
+        return None
 
-	def add_protocols(self, peerID, protocols):
-		peer = __create_or_get_peer(peerID)
-		peer.add_protocols(protocols)
+    def get_protocols(self, peer_id):
+        if peer_id in self.peer_map:
+            return self.peer_map[peer_id].get_protocols(), None
+        return None, peer_id + " not found"
 
-	def peers(self):
-		return self.peerMap.keys()
+    def add_protocols(self, peer_id, protocols):
+        peer = self.__create_or_get_peer(peer_id)
+        peer.add_protocols(protocols)
 
-	def get(self, peerID, key):
-		if peerID in self.peerMap:
-			val, error = self.peerMap[peerID].get_metadata(key)
-			return val, error
-		else:
-			return None, peerID + " not found"
+    def peers(self):
+        return self.peer_map.keys()
 
-	def put(self, peerID, key, val):
-		# <<?>>
-		# This can output an error, not sure what the possible errors are
-		peer = __create_or_get_peer(peerID)
-		self.peerMap[peerID].put_metadata(key, val)
+    def get(self, peer_id, key):
+        if peer_id in self.peer_map:
+            val, error = self.peer_map[peer_id].get_metadata(key)
+            return val, error
+        return None, peer_id + " not found"
 
-	def add_addr(self, peerID, addr, ttl):
-		self.add_addrs(self, peerID, [addr])
+    def put(self, peer_id, key, val):
+        # <<?>>
+        # This can output an error, not sure what the possible errors are
+        peer = self.__create_or_get_peer(peer_id)
+        peer.put_metadata(key, val)
 
-	def add_addrs(self, peerID, addrs, ttl):
-		# Ignore ttl for now
-		peer = __create_or_get_peer(peerID)
-		peer.add_addrs(addrs)
+    def add_addr(self, peer_id, addr, ttl):
+        self.add_addrs(self, peer_id, [addr])
 
-	def addrs(self, peerID):
-		if peerID in self.peerMap:
-			return self.peerMap[peerId].get_addrs(), None
-		else:
-			return None, peerID + " not found"
-		pass
+    def add_addrs(self, peer_id, addrs, ttl):
+        # Ignore ttl for now
+        peer = self.__create_or_get_peer(peer_id)
+        peer.add_addrs(addrs)
 
-	def clear_addrs(self, peerID):
-		# Only clear addresses if the peer is in peer map
-		if peerID in self.peerMap:
-			self.peerMap[peerID].clear_addrs()
+    def addrs(self, peer_id):
+        if peer_id in self.peer_map:
+            return self.peer_map[peer_id].get_addrs(), None
+        return None, peer_id + " not found"
 
-	def peers_with_addrs(self):
-		# Add all peers with addrs at least 1 to output
-		output = []
+    def clear_addrs(self, peer_id):
+        # Only clear addresses if the peer is in peer map
+        if peer_id in self.peer_map:
+            self.peer_map[peer_id].clear_addrs()
 
-		for key in self.peerMap:
-			if len(self.peerMap[key].get_addrs()) >= 1:
-				output.append(key)
-		return output
+    def peers_with_addrs(self):
+        # Add all peers with addrs at least 1 to output
+        output = []
 
-	def __create_or_get_peer(self, peerID):
-		"""
-		Returns the peer data for peerID or creates a new
-		peer data (and stores it in peerMap) if peer 
-		data for peerID does not yet exist
-		:param peerID: peer ID
-		:return: peer data
-		"""
-		if peerId in self.peerMap:
-			return self.peerMap[peerId]
-		else:
-			data = PeerData(self.context)
-			self.peerMap[peerId] = data
-			return self.peerMap[peerId]
+        for key in self.peer_map:
+            if len(self.peer_map[key].get_addrs()) >= 1:
+                output.append(key)
+        return output