[PEP8] PluginManager

Author: 8r2y5

plugin_manager.py

@@ -13,6 +13,7 @@
 from config import ConfigurationManager
 from utility_functions import path
 
+
 class DuplicatePluginError(Exception):
     """
     Raised when there is a plugin of the same name/class already instantiated.
@@ -34,7 +35,8 @@ class MissingDependency(PluginNotFound):
 
 class UnresolvedOrCircularDependencyError(Exception):
     """
-    Raised whenever there is a circular dependency detected in the loading of of plugins.
+    Raised whenever there is a circular dependency detected in the loading
+    of of plugins.
     """
 
 
@@ -61,13 +63,27 @@ def __init__(self, factory, base_class=BasePlugin):
         self.factory = factory
 
         self.plugin_dir = path.child(self.config.plugin_path)
-        sys.path.append( self.plugin_dir.path )
-
-        self.load_plugins( ['core.admin_commands_plugin','core.colored_names','core.command_plugin','core.player_manager_plugin','core.starbound_config_manager'] )
-        self.load_plugins( self.config.config['initial_plugins'] )
-        self.logger.info( "Loaded plugins:\n\n%s\n" % "\n".join(
-            ["\t%s" % (plugin.name) for plugin in self.plugins.itervalues()]) )
-
+        sys.path.append(self.plugin_dir.path)
+
+        self.load_plugins(
+            [
+                'core.admin_commands_plugin',
+                'core.colored_names',
+                'core.command_plugin',
+                'core.player_manager_plugin',
+                'core.starbound_config_manager'
+            ]
+        )
+        self.load_plugins(self.config.config['initial_plugins'])
+        self.logger.info(
+            'Loaded plugins:\n\n%s\n',
+            '\n'.join(
+                [
+                    '\t{}'.format(plugin.name)
+                    for plugin in self.plugins.itervalues()
+                ]
+            )
+        )
 
     def installed_plugins(self):
         """
@@ -76,17 +92,23 @@ def installed_plugins(self):
         :param name: None
         :return: Array of plugin names.
         """
-        installed_plugins = filter(None, [ self.get_plugin_name_from_file(f) for f in  self.plugin_dir.globChildren("*") ])
-        return filter(lambda name: name != 'core', installed_plugins) # don't list core as a plugin
+        installed_plugins = filter(
+            None,
+            (
+                self.get_plugin_name_from_file(f)
+                for f in self.plugin_dir.globChildren('*')
+            )
+        )
 
+        # don't list core as a plugin
+        return filter(lambda name: name != 'core', installed_plugins)
 
     def get_plugin_name_from_file(self, f):
         if f.isdir():
             return f.basename()
         else:
             return
 
-
     def import_plugin(self, name):
         """
         Import plugin that has the given name, and is a subclass of base_class.
@@ -97,18 +119,23 @@ def import_plugin(self, name):
         try:
             mod = __import__(name, globals(), locals(), [], 0)
             for _, plugin in inspect.getmembers(mod, inspect.isclass):
-                if issubclass(plugin, self.base_class) and (plugin is not self.base_class) and (plugin not in self.plugin_classes.keys()):
+                if (
+                        issubclass(plugin, self.base_class) and
+                        (plugin is not self.base_class) and
+                        (plugin not in self.plugin_classes.iterkeys())
+                ):
                     plugin.config = self.config
                     plugin.factory = self.factory
                     plugin.active = False
                     plugin.protocol = None
                     plugin.plugins = {}
-                    plugin.logger = logging.getLogger('starrypy.plugins.%s' % plugin.name)
+                    plugin.logger = logging.getLogger(
+                        'starrypy.plugins.{}'.format(plugin.name)
+                    )
                     self.plugin_classes[plugin.name] = plugin
 
         except ImportError:
-            self.logger.critical("Import error for %s\n" % name)
-
+            self.logger.critical('Import error for %s\n', name)
 
     def resolve_dependencies(self, dependency_hash):
         """
@@ -122,26 +149,41 @@ def resolve_dependencies(self, dependency_hash):
 
         try:
             while len(dependency_hash) > 0:
-                ready = [x for x, d in dependency_hash.iteritems() if len(d) == 0]
-                if len(ready) == 0:
+                ready = [
+                    x for x, d in dependency_hash.iteritems() if len(d) == 0
+                ]
+                if ready:
                     ex = []
                     for n, d in dependency_hash.iteritems():
                         for dep in d:
-                            ex.append("Dependency of %s on %s not met\n" % (n, dep))
+                            ex.append(
+                                'Dependency of {} on {} not met\n'.format(
+                                    n, dep
+                                )
+                            )
                     raise UnresolvedOrCircularDependencyError(
-                        "Unresolved or circular dependencies found:\n%s" % "\n".join(ex))
+                        'Unresolved or circular dependencies'
+                        ' found:\n{}'.format('\n'.join(ex))
+                    )
                 for name in ready:
-                    self.plugins_waiting_to_load[name] = self.plugin_classes[name]
+                    self.plugins_waiting_to_load[name] = (
+                        self.plugin_classes[name]
+                    )
                     self.load_order.append(name)
-                    del( dependency_hash[name] )
+                    del dependency_hash[name]
                 for name, depends in dependency_hash.iteritems():
-                    plugin_set = set(self.plugins.iterkeys()).union( set(self.plugins_waiting_to_load.iterkeys()) )
-                    dependency_hash[name] = dependency_hash[name].difference(plugin_set)
+                    plugin_set = set(
+                        self.plugins.iterkeys()
+                    ).union(
+                        set(self.plugins_waiting_to_load.iterkeys())
+                    )
+                    dependency_hash[name] = dependency_hash[name].difference(
+                        plugin_set
+                    )
 
         except UnresolvedOrCircularDependencyError as e:
             self.logger.critical(str(e))
 
-
     def load_plugins(self, plugins_to_load):
         """
         Loads and instantiates plugins that it is asked to.
@@ -153,40 +195,48 @@ def load_plugins(self, plugins_to_load):
         for plugin in plugins_to_load:
             self.import_plugin(plugin)
 
-        dependencies = { plugin.name: set(plugin.depends) for plugin in self.plugin_classes.itervalues() }
+        dependencies = {
+            plugin.name: set(plugin.depends)
+            for plugin in self.plugin_classes.itervalues()
+        }
 
-        self.resolve_dependencies( dependencies.copy() )
+        self.resolve_dependencies(dependencies.copy())
 
         new_plugins = []
         for plugin_name in self.load_order:
             if not self.plugins.get(plugin_name, False):
                 new_plugins.append(plugin_name)
 
-        self.activate_plugins( new_plugins, dependencies )
-
+        self.activate_plugins(new_plugins, dependencies)
 
     def activate_plugins(self, plugins, dependencies):
-        for plugin in [self.plugins_waiting_to_load[x] for x in plugins]:
+        for plugin in (self.plugins_waiting_to_load[x] for x in plugins):
             try:
                 self.plugins[plugin.name] = plugin()
-                self.logger.debug("Instantiated plugin '%s'" % plugin.name)
+                self.logger.debug('Instantiated plugin "%s"', plugin.name)
                 if len(plugin.depends) > 0:
-                    for p in [ self.plugins[x] for x in dependencies[plugin.name] ]:
+                    plugin_deps = (
+                        self.plugins[x] for x in dependencies[plugin.name]
+                    )
+                    for p in plugin_deps:
                         self.plugin_classes[plugin.name].plugins[p.name] = p
                 self.plugins[plugin.name].activate()
             except FatalPluginError as e:
-                self.logger.critical("A plugin reported a fatal error. Error: %s", str(e))
+                self.logger.critical(
+                    'A plugin reported a fatal error. Error: %s', str(e)
+                )
                 raise
 
     def deactivate_plugins(self):
-        for plugin in [self.plugins[x] for x in reversed(self.load_order)]:
+        for plugin in (self.plugins[x] for x in reversed(self.load_order)):
             try:
                 plugin.deactivate()
             except FatalPluginError as e:
-                self.logger.critical("A plugin reported a fatal error. Error: %s", str(e))
+                self.logger.critical(
+                    'A plugin reported a fatal error. Error: %s', str(e)
+                )
                 raise
 
-
     def do(self, protocol, command, data):
         """
         Runs a command across all currently loaded plugins.
@@ -211,10 +261,12 @@ def do(self, protocol, command, data):
                     res = True
                 return_values.append(res)
             except:
-                self.logger.exception("Error in plugin %s with function %s.", str(plugin), command)
+                self.logger.exception(
+                    'Error in plugin %s with function %s.',
+                    str(plugin), command
+                )
         return all(return_values)
 
-
     def die(self):
         self.deactivate_plugins()
 
@@ -227,17 +279,24 @@ def route(func):
 
     def wrapped_function(self, data):
         name = func.__name__
-        on = "on_%s" % name
-        after = "after_%s" % name
+        on = 'on_%s' % name
+        after = 'after_%s' % name
         res = self.plugin_manager.do(self, on, data)
         if res:
             res = func(self, data)
-            d = deferLater(reactor, .01, self.plugin_manager.do, self, after, data)
+            d = deferLater(
+                reactor,
+                .01,
+                self.plugin_manager.do,
+                self,
+                after,
+                data
+            )
             d.addErrback(print_this_defered_failure)
         return res
 
     def print_this_defered_failure(f):
-        logger.error("Deferred function failure. %s", f)
+        logger.error('Deferred function failure. %s', f)
 
     return wrapped_function