Make the code conform to PEP8

Author: froozen

main.py

@@ -4,14 +4,14 @@
 from pybot.data_container import Data_container
 import time
 
-plugin_manager.load_plugins ()
+plugin_manager.load_plugins()
 
-servers = configuration.get ( "servers" )
+servers = configuration.get("servers")
 for server_config in servers:
-    handle = Data_container ( server_config )
-    server = irc.Irc_server ( handle )
-    server.start ()
+    handle = Data_container(server_config)
+    server = irc.Irc_server(handle)
+    server.start()
 
 while True:
     # Keep thread alive
-    time.sleep ( 1 )
+    time.sleep(1)

pybot/configuration.py

@@ -5,13 +5,15 @@
 
 _config_container = None
 
-class Configuration_data_container ( object ):
-    def __init__ ( self, filename ):
+
+class Configuration_data_container (object):
+
+    def __init__(self, filename):
         """Create a Configuration_data_container from a filename."""
 
-        self._container = Persistent_data_container ( filename )
+        self._container = Persistent_data_container(filename)
 
-    def get ( self, key ):
+    def get(self, key):
         """Return a value or None if not set
 
         Keys:
@@ -21,18 +23,18 @@ def get ( self, key ):
         """
 
         # Simply return value from self._container
-        return self._container.get ( key )
+        return self._container.get(key)
 
-    def get_data ( self ):
+    def get_data(self):
         """Return a deepcopy of the wrapped data.
 
         This method is thread safe.
         """
 
         # Simply return value from self._container
-        return self._container.get_data ()
+        return self._container.get_data()
 
-    def get_data_container ( self, key ):
+    def get_data_container(self, key):
         """Return a Data_container object representing a dict identified by a key.
 
         Keys:
@@ -42,9 +44,10 @@ def get_data_container ( self, key ):
         """
 
         # Simply return value from self._container
-        return self._container.get_data_container ( key )
+        return self._container.get_data_container(key)
 
-def get ( key ):
+
+def get(key):
     """Return a configuration value or None if not set
 
     Keys:
@@ -54,9 +57,10 @@ def get ( key ):
     """
 
     # Simply call the method in _config_container
-    return _config_container.get ( key )
+    return _config_container.get(key)
+
 
-def get_data_container ( key ):
+def get_data_container(key):
     """Return a Data_container object representing a dict identified by a key.
 
     Keys:
@@ -65,8 +69,9 @@ def get_data_container ( key ):
     This method is thread safe.
     """
 
-    return _config_container.get_data_container ( key )
+    return _config_container.get_data_container(key)
 
 # Initialize configuration
 if _config_container == None:
-    _config_container = Configuration_data_container ( os.path.dirname ( __file__ ) + "/../config.json" )
+    _config_container = Configuration_data_container(
+        os.path.dirname(__file__) + "/../config.json")

pybot/data_container.py

@@ -4,20 +4,22 @@
 import log
 import json
 
-class Data_container ( object ):
-    def __init__ ( self, data ):
+
+class Data_container (object):
+
+    def __init__(self, data):
         """Create a Data_container from a dict."""
 
         # Data_container will only represent dicts
-        if not type ( data ) == dict:
-            log.write ( "Error in data_container: data is not a dict" )
-            raise ValueError ( "Error: data is not a dict" )
+        if not type(data) == dict:
+            log.write("Error in data_container: data is not a dict")
+            raise ValueError("Error: data is not a dict")
 
         # Always use deepcopy to make it thread safe
-        self._data = copy.deepcopy ( data )
-        self._lock = threading.Lock ()
+        self._data = copy.deepcopy(data)
+        self._lock = threading.Lock()
 
-    def get ( self, key ):
+    def get(self, key):
         """Return a value or None if not set
 
         Keys:
@@ -27,25 +29,25 @@ def get ( self, key ):
         """
 
         with self._lock:
-            key_levels = key.split ( "." )
+            key_levels = key.split(".")
             position = self._data
 
             for key_level in key_levels:
                 # Check the current type, so the type of the last iteration's position isn't
                 # checked. This will allow getting non-dict values.
-                if type ( position ) == dict:
+                if type(position) == dict:
                     if key_level in position:
                         # Set position to next dict in "tree"
-                        position = position [ key_level ]
+                        position = position[key_level]
                         continue
 
                 # Return None if either one doesn't apply
                 return None
 
             # Always use deepcopy to make it thread safe
-            return copy.deepcopy ( position )
+            return copy.deepcopy(position)
 
-    def append ( self, key, value ):
+    def append(self, key, value):
         """Append a value to a list responding to a key.
 
         Keys:
@@ -55,28 +57,30 @@ def append ( self, key, value ):
         """
 
         with self._lock:
-            key_levels = key.split ( "." )
+            key_levels = key.split(".")
             position = self._data
 
             for key_level in key_levels:
                 # Check the current type, so the type of the last iteration's position isn't
                 # checked. This will allow getting non-dict values.
-                if type ( position ) == dict:
+                if type(position) == dict:
                     if key_level in position:
                         # Set position to next dict in "tree"
-                        position = position [ key_level ]
+                        position = position[key_level]
                         continue
 
-                log.write ( "Error in data_container: Invalid key: %s" % key )
-                raise ValueError ( "Error: Invalid key: %s" % key )
+                log.write("Error in data_container: Invalid key: %s" % key)
+                raise ValueError("Error: Invalid key: %s" % key)
 
-            if not type ( position ) == list:
-                log.write ( "Error in data_container: Cannot append to %s ( %s ), has to be a list" % type ( position ), key )
-                raise ValueError ( "Error: Cannot append to %s ( %s ), has to be a list" % type ( position ), key )
+            if not type(position) == list:
+                log.write("Error in data_container: Cannot append to %s ( %s ), has to be a list" % type(
+                    position), key)
+                raise ValueError(
+                    "Error: Cannot append to %s ( %s ), has to be a list" % type(position), key)
 
-            position.append ( value )
+            position.append(value)
 
-    def pop ( self, key, index ):
+    def pop(self, key, index):
         """Pop the value at an index off a list responding to a key.
 
         Keys:
@@ -86,28 +90,30 @@ def pop ( self, key, index ):
         """
 
         with self._lock:
-            key_levels = key.split ( "." )
+            key_levels = key.split(".")
             position = self._data
 
             for key_level in key_levels:
                 # Check the current type, so the type of the last iteration's position isn't
                 # checked. This will allow getting non-dict values.
-                if type ( position ) == dict:
+                if type(position) == dict:
                     if key_level in position:
                         # Set position to next dict in "tree"
-                        position = position [ key_level ]
+                        position = position[key_level]
                         continue
 
-                log.write ( "Error in data_container: Invalid key: %s" % key )
-                raise ValueError ( "Error: Invalid key: %s" % key )
+                log.write("Error in data_container: Invalid key: %s" % key)
+                raise ValueError("Error: Invalid key: %s" % key)
 
-            if not type ( position ) == list:
-                log.write ( "Error in data_container: Cannot pop from %s ( %s ), has to be a list" % type ( position ), key )
-                raise ValueError ( "Error: Cannot pop from %s ( %s ), has to be a list" % type ( position ), key )
+            if not type(position) == list:
+                log.write("Error in data_container: Cannot pop from %s ( %s ), has to be a list" % type(
+                    position), key)
+                raise ValueError(
+                    "Error: Cannot pop from %s ( %s ), has to be a list" % type(position), key)
 
-            position.pop ( index )
+            position.pop(index)
 
-    def remove ( self, key, value ):
+    def remove(self, key, value):
         """Remove a value from a list responding to a key.
 
         Keys:
@@ -117,28 +123,30 @@ def remove ( self, key, value ):
         """
 
         with self._lock:
-            key_levels = key.split ( "." )
+            key_levels = key.split(".")
             position = self._data
 
             for key_level in key_levels:
                 # Check the current type, so the type of the last iteration's position isn't
                 # checked. This will allow getting non-dict values.
-                if type ( position ) == dict:
+                if type(position) == dict:
                     if key_level in position:
                         # Set position to next dict in "tree"
-                        position = position [ key_level ]
+                        position = position[key_level]
                         continue
 
-                log.write ( "Error in data_container: Invalid key: %s" % key )
-                raise ValueError ( "Error: Invalid key: %s" % key )
+                log.write("Error in data_container: Invalid key: %s" % key)
+                raise ValueError("Error: Invalid key: %s" % key)
 
-            if not type ( position ) == list:
-                log.write ( "Error in data_container: Cannot remove from %s ( %s ), has to be a list" % type ( position ), key )
-                raise ValueError ( "Error: Cannot remove from %s ( %s ), has to be a list" % type ( position ), key )
+            if not type(position) == list:
+                log.write("Error in data_container: Cannot remove from %s ( %s ), has to be a list" % type(
+                    position), key)
+                raise ValueError(
+                    "Error: Cannot remove from %s ( %s ), has to be a list" % type(position), key)
 
-            position.remove ( value )
+            position.remove(value)
 
-    def set ( self, key, value ):
+    def set(self, key, value):
         """Set a value.
 
         Keys:
@@ -148,40 +156,40 @@ def set ( self, key, value ):
         """
 
         with self._lock:
-            key_levels = key.split ( "." )
+            key_levels = key.split(".")
             position = self._data
 
             # Ommit the last key_level from the iteration so position is the dict we want
             # to save the value in.
-            for key_level in key_levels [ : -1 ]:
-                if type ( position ) == dict:
+            for key_level in key_levels[: -1]:
+                if type(position) == dict:
                     if key_level in position:
                         # Set position to the nex position
-                        position = position [ key_level ]
+                        position = position[key_level]
 
                     # Create silently dict if it doesn't exist
                     else:
-                        position [ key_level ] = {}
-                        position = position [ key_level ]
+                        position[key_level] = {}
+                        position = position[key_level]
 
                 else:
-                    log.write ( "Error in data_container: Invalid key: %s" % key )
-                    raise ValueError ( "Error: Invalid key: %s" % key )
+                    log.write("Error in data_container: Invalid key: %s" % key)
+                    raise ValueError("Error: Invalid key: %s" % key)
 
             # Actually set the value
-            position [ key_levels [ -1 ] ] = value
+            position[key_levels[-1]] = value
 
-    def get_data ( self ):
+    def get_data(self):
         """Return a deepcopy of the wrapped data.
 
         This method is thread safe.
         """
 
         with self._lock:
             # Always use deepcopy to make it thread safe
-            return copy.deepcopy ( self._data )
+            return copy.deepcopy(self._data)
 
-    def get_data_container ( self, key ):
+    def get_data_container(self, key):
         """Return a Data_container object representing a dict identified by a key.
 
         Keys:
@@ -192,5 +200,4 @@ def get_data_container ( self, key ):
 
         # The locking is already being done in self.get
         # Locking here as well would only cause a deadlock
-        return Data_container ( self.get ( key ) )
-
+        return Data_container(self.get(key))