Merge pull request #141 from 8r2y5/master

[WIP] 8r2y5 Applied PEP8 standard on all plugins and occasionally did path.join refactorization.

Author: kamilion

base_plugin.py

@@ -1,31 +1,35 @@
+# encoding: utf-8
+
+
 class BasePlugin(object):
     """
-    Defines an interface for all plugins to inherit from. Note that the __init__
-    method should generally not be overrode; all setup work should be done in
-    activate() if possible. If you do override __init__, remember to super()!
+    Defines an interface for all plugins to inherit from. Note that the
+    __init__ method should generally not be overrode; all setup work should be
+    done in activate() if possible. If you do override __init__, remember to
+    super()!
 
     Note that only one instance of each plugin will be instantiated for *all*
     connected clients. self.protocol will be changed by the plugin manager to
     the current protocol.
 
     You may access the factory if necessary via self.factory.protocols
-    to access other clients, but this "Is Not A Very Good Idea" (tm)
+    to access other clients, but this 'Is Not A Very Good Idea' (tm)
 
     `name` *must* be defined in child classes or else the plugin manager will
     complain quite thoroughly.
     """
 
-    name = "Base Plugin"
-    description = "The common class for all plugins to inherit from."
-    version = ".1"
-    depends = [] 
+    name = 'Base Plugin'
+    description = 'The common class for all plugins to inherit from.'
+    version = '.1'
+    depends = []
 
     def activate(self):
         """
         Called when the plugins are activated, do any setup work here.
         """
         self.active = True
-        self.logger.debug("%s plugin object activated.", self.name)
+        self.logger.debug('%s plugin object activated.', self.name)
         return True
 
     def deactivate(self):
@@ -34,7 +38,7 @@ def deactivate(self):
         as it is likely that the plugin will soon be destroyed.
         """
         self.active = False
-        self.logger.debug("%s plugin object deactivated", self.name)
+        self.logger.debug('%s plugin object deactivated', self.name)
         return True
 
     def on_protocol_version(self, data):
@@ -368,7 +372,9 @@ def after_central_structure_update(self, data):
         return True
 
     def __repr__(self):
-        return "<Plugin instance: %s (version %s)>" % (self.name, self.version)
+        return '<Plugin instance: {} (version {})>'.format(
+            self.name, self.version
+        )
 
 
 class CommandNameError(Exception):
@@ -379,10 +385,10 @@ class CommandNameError(Exception):
 
 
 class SimpleCommandPlugin(BasePlugin):
-    name = "simple_command_plugin"
-    description = "Provides a simple parent class to define chat commands."
-    version = "0.1"
-    depends = ["command_plugin"]
+    name = 'simple_command_plugin'
+    description = 'Provides a simple parent class to define chat commands.'
+    version = '0.1'
+    depends = ['command_plugin']
     commands = []
     command_aliases = {}
 
@@ -391,7 +397,9 @@ def activate(self):
         for command in self.commands:
             f = getattr(self, command)
             if not callable(f):
-                raise CommandNameError("Could not find a method called %s" % command)
+                raise CommandNameError(
+                    'Could not find a method called {}'.format(command)
+                )
             self.plugins['command_plugin'].register(f, command)
         for command, alias_list in self.command_aliases.iteritems():
             for alias in alias_list:

config.py

@@ -3,6 +3,8 @@
 import logging
 import inspect
 import sys
+import os
+
 from utility_functions import recursive_dictionary_update, path
 
 
@@ -11,33 +13,47 @@ class Singleton(type):
 
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args,
-                                                                 **kwargs)
+            cls._instances[cls] = super(Singleton, cls).__call__(
+                *args, **kwargs
+            )
         return cls._instances[cls]
 
 
 class ConfigurationManager(object):
     __metaclass__ = Singleton
-    logger = logging.getLogger("starrypy.config.ConfigurationManager")
-    log_format = logging.Formatter('%(asctime)s - %(levelname)s - %(name)s # %(message)s')
-    logfile_handle = logging.FileHandler("config.log")
+    logger = logging.getLogger('starrypy.config.ConfigurationManager')
+    log_format = logging.Formatter(
+        '%(asctime)s - %(levelname)s - %(name)s # %(message)s'
+    )
+    logfile_handle = logging.FileHandler('config.log')
     logfile_handle.setLevel(9)
     logger.addHandler(logfile_handle)
     logfile_handle.setFormatter(log_format)
 
     def __init__(self):
-        default_config_path = path.preauthChild("config/config.json.default")
-        self.config_path = path.preauthChild("config/config.json")
+        default_config_path = path.preauthChild(
+            os.path.join('config', 'config.json.default')
+        )
+        self.config_path = path.preauthChild(
+            os.path.join('config', 'config.json')
+        )
         if default_config_path.exists():
             try:
                 with default_config_path.open() as default_config:
                     default = json.load(default_config)
             except ValueError as e:
-                print "Error: %s" % e
-                self.logger.critical("The configuration defaults file (config.json.default) contains invalid JSON. Please run it against a JSON linter, such as http://jsonlint.com. Shutting down." )
+                print 'Error: %s' % e
+                self.logger.critical(
+                    'The configuration defaults file (config.json.default) '
+                    'contains invalid JSON. Please run it against a JSON '
+                    'linter, such as http://jsonlint.com. Shutting down.'
+                )
                 sys.exit()
         else:
-            self.logger.critical("The configuration defaults file (config.json.default) doesn't exist! Shutting down.")
+            self.logger.critical(
+                'The configuration defaults file (config.json.default)'
+                ' doesn\'t exist! Shutting down.'
+            )
             sys.exit()
 
         if self.config_path.exists():
@@ -46,63 +62,95 @@ def __init__(self):
                     config = json.load(c)
                     self.config = recursive_dictionary_update(default, config)
             except ValueError as e:
-                print "Error: %s" % e
-                self.logger.critical("The configuration file (config.json) contains invalid JSON. Please run it against a JSON linter, such as http://jsonlint.com. Shutting down.")
+                print 'Error: %s' % e
+                self.logger.critical(
+                    'The configuration file (config.json) contains invalid '
+                    'JSON. Please run it against a JSON linter, such as '
+                    'http://jsonlint.com. Shutting down.'
+                )
                 sys.exit()
         else:
-            self.logger.warning("The configuration file (config.json) doesn't exist! Creating one from defaults.")
+            self.logger.warning(
+                'The configuration file (config.json)'
+                ' doesn\'t exist! Creating one from defaults.'
+            )
             try:
-                with self.config_path.open("w") as f:
-                    json.dump(default, f, indent=4, separators=(',', ': '), sort_keys=True, ensure_ascii = False)
+                with self.config_path.open('w') as f:
+                    json.dump(
+                        default,
+                        f,
+                        indent=4,
+                        separators=(',', ': '),
+                        sort_keys=True,
+                        ensure_ascii=False
+                    )
             except IOError:
-                self.logger.critical("Couldn't write a default configuration file. Please check that StarryPy has write access in the config/ directory.")
-                self.logger.critical("Exiting...")
+                self.logger.critical(
+                    'Couldn\'t write a default configuration file. '
+                    'Please check that StarryPy has write access in the '
+                    'config/ directory.'
+                )
+                self.logger.critical('Exiting...')
                 sys.exit()
-            self.logger.warning("StarryPy will now exit. Please examine config.json and adjust the variables appropriately.")
+            self.logger.warning(
+                'StarryPy will now exit. Please examine config.json '
+                'and adjust the variables appropriately.'
+            )
             sys.exit()
 
-        self.logger.debug("Created configuration manager.")
+        self.logger.debug('Created configuration manager.')
         self.save()
 
     def save(self):
         try:
-             with io.open(self.config_path.path, "w", encoding="utf-8") as config:
-                self.logger.debug("Writing configuration file.")
-                config.write(json.dumps(self.config, indent=4, separators=(',', ': '), sort_keys=True, ensure_ascii=False))
+            with io.open(self.config_path.path, 'w') as config:
+                self.logger.debug('Writing configuration file.')
+                config.write(
+                    json.dumps(
+                        self.config,
+                        indent=4,
+                        separators=(',', ': '),
+                        sort_keys=True,
+                        ensure_ascii=False
+                    )
+                )
         except Exception as e:
-            self.logger.critical("Tried to save the configuration file, failed.\n%s", str(e))
+            self.logger.critical(
+                'Tried to save the configuration file, failed.\n%s', str(e)
+            )
             raise
 
     def __getattr__(self, item):
-        if item in ["config", "config_path"]:
+        if item in ['config', 'config_path']:
             return super(ConfigurationManager, self).__getattribute__(item)
 
-
-        elif item == "plugin_config":
-            caller = inspect.stack()[1][0].f_locals["self"].__class__.name
-            if caller in self.config["plugin_config"]:
-                return self.config["plugin_config"][caller]
+        elif item == 'plugin_config':
+            caller = inspect.stack()[1][0].f_locals['self'].__class__.name
+            if caller in self.config['plugin_config']:
+                return self.config['plugin_config'][caller]
             else:
                 return {}
 
         else:
             if item in self.config:
                 return self.config[item]
             else:
-                self.logger.error("Couldn't find configuration option %s in configuration file.", item)
+                self.logger.error(
+                    'Couldn\'t find configuration option %s in '
+                    'configuration file.', item
+                )
                 raise AttributeError
 
-
     def __setattr__(self, key, value):
-        if key == "config":
+        if key == 'config':
             super(ConfigurationManager, self).__setattr__(key, value)
             self.save()
-        elif key == "config_path":
+        elif key == 'config_path':
             super(ConfigurationManager, self).__setattr__(key, value)
-        elif key == "plugin_config":
-            caller = inspect.stack()[1][0].f_locals["self"].__class__.name
-            self.config["plugin_config"][caller] = value
-            self.save
+        elif key == 'plugin_config':
+            caller = inspect.stack()[1][0].f_locals['self'].__class__.name
+            self.config['plugin_config'][caller] = value
+            self.save()
         else:
             self.config[key] = value
             self.save()

config/config.json.default

@@ -1,5 +1,5 @@
 {
-    "backup_db": "backups/backups.db",
+    "backup_db": ["backups", "backups.db"],
     "bind_address": "",
     "bind_port": 21025,
     "chat_prefix": "#",

packet_stream.py

@@ -6,7 +6,15 @@
 
 
 class Packet(object):
-    def __init__(self, packet_id, payload_size, data, original_data, direction, compressed=False):
+    def __init__(
+        self,
+        packet_id,
+        payload_size,
+        data,
+        original_data,
+        direction,
+        compressed=False
+    ):
         self.id = packet_id
         self.payload_size = payload_size
         self.data = data
@@ -19,7 +27,7 @@ class PacketStream(object):
     logger = logging.getLogger('starrypy.packet_stream.PacketStream')
 
     def __init__(self, protocol):
-        self._stream = ""
+        self._stream = ''
         self.id = None
         self.payload_size = None
         self.header_length = None
@@ -52,44 +60,62 @@ def start_packet(self):
                     self.compressed = True
                 else:
                     self.compressed = False
-                self.header_length = 1 + len(packets.SignedVLQ("").build(packet_header.payload_size))
+                self.header_length = 1 + len(packets.SignedVLQ('').build(
+                    packet_header.payload_size)
+                )
                 self.packet_size = self.payload_size + self.header_length
                 return True
         except RuntimeError:
-            self.logger.error("Unknown error in start_packet.")
+            self.logger.error('Unknown error in start_packet.')
             return False
 
     def check_packet(self):
         try:
-            if self.packet_size is not None and len(self._stream) >= self.packet_size:
-                p, self._stream = self._stream[:self.packet_size], self._stream[self.packet_size:]
+            if (
+                    self.packet_size is not None and
+                    len(self._stream) >= self.packet_size
+            ):
+                p = self._stream[:self.packet_size]
+                self._stream = self._stream[self.packet_size:]
                 if not self._stream:
-                    self._stream = ""
+                    self._stream = ''
                 p_parsed = packets.packet().parse(p)
                 if self.compressed:
                     try:
                         z = zlib.decompressobj()
                         p_parsed.data = z.decompress(p_parsed.data)
                     except zlib.error:
-                        self.logger.error("Decompression error in check_packet.")
-                        self.logger.debug("Parsed packet:")
+                        self.logger.error(
+                            'Decompression error in check_packet.'
+                        )
+                        self.logger.debug('Parsed packet:')
                         self.logger.debug(pprint.pformat(p_parsed))
-                        self.logger.debug("Packet data:")
-                        self.logger.debug(pprint.pformat(p_parsed.original_data.encode("hex")))
-                        self.logger.debug("Following packet data:")
-                        self.logger.debug(pprint.pformat(self._stream.encode("hex")))
+                        self.logger.debug('Packet data:')
+                        self.logger.debug(
+                            pprint.pformat(
+                                p_parsed.original_data.encode('hex')
+                            )
+                        )
+                        self.logger.debug('Following packet data:')
+                        self.logger.debug(
+                            pprint.pformat(self._stream.encode('hex'))
+                        )
                         raise
-                packet = Packet(packet_id=p_parsed.id, payload_size=p_parsed.payload_size, data=p_parsed.data,
-                                original_data=p, direction=self.direction)
+                packet = Packet(
+                    packet_id=p_parsed.id,
+                    payload_size=p_parsed.payload_size,
+                    data=p_parsed.data,
+                    original_data=p,
+                    direction=self.direction
+                )
 
                 self.compressed = False
                 self.protocol.string_received(packet)
                 self.reset()
                 if self.start_packet():
                     self.check_packet()
         except RuntimeError:
-            self.logger.error("Unknown error in check_packet")
-            #return False
+            self.logger.error('Unknown error in check_packet')
 
     def reset(self):
         self.id = None