def list_plugins(lst, verbose=False): from openalea.core.plugin.manager import PluginManager pm = PluginManager() import pkg_resources from openalea.core.plugin import iter_groups if lst in ['summary', 'all']: prefixes = ['openalea', 'oalab', 'vpltk'] else: prefixes = [lst] for group in sorted(iter_groups()): match = False for prefix in prefixes: if group.startswith(prefix): match = True break if match: eps = [ep for ep in pkg_resources.iter_entry_points(group)] if lst == 'summary': print '\n\033[91m%s\033[0m (%d plugins)' % (group, len(eps)) for ep in eps: parts = [str(s) for s in (ep.module_name, ep.name)] identifier = ':'.join(parts) print ' - %s \033[90m%s (%s)\033[0m' % (ep.name, identifier, ep.dist.egg_name()) else: print '\033[44m%s\033[0m' % group UNDEF = 'Not defined' plugin_groups = {UNDEF: []} for plugin in pm.items(group): interface = getattr(plugin, 'implement', None) if interface: plugin_groups.setdefault(interface, []).append(plugin) else: plugin_groups[UNDEF].append(plugin) for group, plugins in plugin_groups.items(): if not plugins: continue print ' implements: \033[91m%s\033[0m' % group plugin_names = {} for plugin in plugins: plugin_names[plugin.name] = plugin for pl_name in sorted(plugin_names): plugin = plugin_names[pl_name] p_class = plugin.__class__ print ' - \033[93m%s \033[90m%s:%s\033[0m' % (plugin_name(plugin), p_class.__module__, p_class.__name__) if verbose: print ' tags: %s' % ', '.join(plugin.tags) print ' plugin: %s, egg: %s\n path: %s' % ( ep.name, ep.dist.egg_name(), ep.dist.location) print ' criteria:' for crit_name in sorted(dir(plugin)): if crit_name in ('implementation', '__call__'): continue crit = getattr(plugin, crit_name) if can_display_criterion(crit_name, crit): print format_criterion(crit_name, crit, 10) print print
def __call__(self, mainwin=None): if mainwin is None: return self.__class__ from openalea.core.plugin.manager import PluginManager pm = PluginManager() # Load, create and place applets in mainwindow for plugin_class in pm.plugins('oalab.applet'): mainwin.add_plugin(name=plugin_class.name) # Initialize all applets mainwin.initialize()
def __call__(self, mainwin=None): if mainwin is None: return self.__class__ from openalea.core.plugin.manager import PluginManager pm = PluginManager() # Load, create and place applets in mainwindow for plugin_class in pm.plugins("oalab.applet"): mainwin.add_plugin(name=plugin_class.name) # Initialize all applets mainwin.initialize()
def test_autoload(self): pm = PluginManager() pm.items('test.c1') assert 'test.c1' in pm._item assert 'tstpkg1.plugin:C1Plugin1' in pm._item['test.c1'] pm = PluginManager(autoload=[]) pm.items('test.c1') assert 'test.c1' in pm._item assert 'tstpkg1.plugin:C1Plugin1' not in pm._item['test.c1']
def test_plugin_proxy(self): from openalea.core.plugin.manager import SimpleClassPluginProxy pm = PluginManager() pm.set_proxy('oalab.modelclass', SimpleClassPluginProxy) clear_plugin_instances() w1 = plugin_instance('oalab.modelclass', 'PythonModel') w2 = plugin_instance('oalab.modelclass', 'PythonModel') w3 = plugin_instance('oalab.modelclass', 'PythonModel') w4 = new_plugin_instance('oalab.modelclass', 'PythonModel') assert w1 assert w1 is w2 is w3 assert w1 is not w4 assert len(plugin_instances('oalab.modelclass', 'PythonModel')) == 2
def __init__(self): import traceback traceback.print_stack(file=sys.__stdout__) self._project = None self._is_proj = False self._debug = False self.gui = True self.tmpdir = path(get_openalea_tmp_dir()) self._config = MainConfig() self.extension = None self.applet = {} self.manager = {} self.package_manager = package_manager self.control_manager = ControlManager() self.project_manager = ProjectManager() self.plugin_manager = PluginManager() self.plugin_instance_manager = PluginInstanceManager() self.manager['control'] = self.control_manager self.manager['package'] = self.package_manager self.manager['project'] = self.project_manager self.manager['plugin'] = self.plugin_manager self.manager['plugin_instance'] = self.plugin_instance_manager self.world = World() self.interpreter = interpreter() # Hack if interpreter is an object from class TerminalInteractiveShell if not hasattr(self.interpreter, "shell"): self.interpreter.shell = self.interpreter if hasattr(self.interpreter.shell, "events"): self.interpreter.shell.events.register("post_execute", self.add_to_history) else: print("You need ipython >= 2.0 to use history.") # self.project_manager.set_shell(self.interpreter.shell) self.interpreter.locals['session'] = self self.old_syspath = sys.path self.load_default() self.__class__.instantiated = True
def test_autoload(self): pm = PluginManager() pm.items("test.c1") assert "test.c1" in pm._item assert "tstpkg1.plugin:C1Plugin1" in pm._item["test.c1"] pm = PluginManager(autoload=[]) pm.items("test.c1") assert "test.c1" in pm._item assert "tstpkg1.plugin:C1Plugin1" not in pm._item["test.c1"]
def __init__(self, plugins=None, proxy_class=None): self._plugin_instances = {} self._debug = [] self.pm = PluginManager()
class PluginInstanceManager(object): __metaclass__ = Singleton def __init__(self, plugins=None, proxy_class=None): self._plugin_instances = {} self._debug = [] self.pm = PluginManager() def clear(self): self._plugin_instances = {} @property def debug(self): return self._debug @debug.setter def debug(self, value): if value in (True, 'all', ['all']): self._debug = [True] elif value is False: self._debug = [] else: self._debug = value def _debug_mode(self, category): return category in self.debug or True in self.debug or 'all' in self.debug def __call__(self, category, func=None, **kwds): """ Use this method to launch a function in debug mode. If debug is enabled for this category, errors are raised, else debug is disable, errors pass silently. """ func_args = kwds.pop('func_args', []) func_kwds = kwds.pop('func_kwds', {}) callback = kwds.pop('callback', None) if self._debug_mode(category): return func(*func_args, **func_kwds) else: try: return func(*func_args, **func_kwds) except: logger.error('%s: error calling %s ' % (category, func)) if callback: callback() def register(self, category, name, instance): """ Add a weakref to instance in dict category -> name -> [list of instances] """ self._plugin_instances.setdefault(category, {}).setdefault(name, []).append(weakref.ref(instance)) def unregister(self, category, name, instance): """ Unregistered instances won't be list by "instances" method """ try: self._plugin_instances[category][name].remove(instance) except KeyError: # No instances have been registered for this plugin or this category pass except ValueError: # Passed instance is not registered for this plugin pass def _new(self, category, name, class_args=None, class_kwds=None): if category not in self.pm._plugin: self.pm._load_plugins(category) try: plugin_class = self.pm._plugin[category][name] except KeyError: pass else: try: plugin = plugin_class() except TypeError, e: raise enhanced_error(e, plugin_class=plugin_class) if class_args is None: class_args = [] if class_kwds is None: class_kwds = {} try: klass = plugin() except TypeError, e: raise enhanced_error(e, plugin=plugin, plugin_class=plugin_class) try: instance = klass(*class_args, **class_kwds) except TypeError, e: raise enhanced_error(e, plugin_class=klass)
for weakref in self._plugin_instances[category][name]: obj = weakref() if obj is None: self._plugin_instances[category][name].remove(weakref) else: valid_instances.append(obj) except KeyError: pass return valid_instances def implementations(self, interface, **kwds): """ Return all instances implementing this interface """ raise NotImplementedError PM = PluginManager() PIM = PluginInstanceManager() plugins = PM.plugins plugin_class = PM.plugin clear_plugin_instances = PIM.clear debug_plugin = PIM.__call__ new_plugin_instance = PIM.new plugin_implementations = PIM.implementations plugin_instance = PIM.instance plugin_instances = PIM.instances plugin_instance_exists = PIM.has_instance
class PluginInstanceManager(object): __metaclass__ = Singleton def __init__(self, plugins=None, proxy_class=None): self._plugin_instances = {} self._debug = [] self.pm = PluginManager() def clear(self): self._plugin_instances = {} @property def debug(self): return self._debug @debug.setter def debug(self, value): if value in (True, 'all', ['all']): self._debug = [True] elif value is False: self._debug = [] else: self._debug = value def _debug_mode(self, category): return category in self.debug or True in self.debug or 'all' in self.debug def __call__(self, category, func=None, **kwds): """ Use this method to launch a function in debug mode. If debug is enabled for this category, errors are raised, else debug is disable, errors pass silently. """ func_args = kwds.pop('func_args', []) func_kwds = kwds.pop('func_kwds', {}) callback = kwds.pop('callback', None) if self._debug_mode(category): return func(*func_args, **func_kwds) else: try: return func(*func_args, **func_kwds) except: logger.error('%s: error calling %s ' % (category, func)) if callback: callback() def register(self, category, name, instance): """ Add a weakref to instance in dict category -> name -> [list of instances] """ self._plugin_instances.setdefault(category, {}).setdefault(name, []).append( weakref.ref(instance)) def unregister(self, category, name, instance): """ Unregistered instances won't be list by "instances" method """ try: self._plugin_instances[category][name].remove(instance) except KeyError: # No instances have been registered for this plugin or this category pass except ValueError: # Passed instance is not registered for this plugin pass def _new(self, category, name, class_args=None, class_kwds=None): if category not in self.pm._plugin: self.pm._load_plugins(category) try: plugin_class = self.pm._plugin[category][name] except KeyError: pass else: try: plugin = plugin_class() except TypeError, e: raise enhanced_error(e, plugin_class=plugin_class) if class_args is None: class_args = [] if class_kwds is None: class_kwds = {} try: klass = plugin() except TypeError, e: raise enhanced_error(e, plugin=plugin, plugin_class=plugin_class) try: instance = klass(*class_args, **class_kwds) except TypeError, e: raise enhanced_error(e, plugin_class=klass)
def setUp(self): self.pm = PluginManager() self.pm.debug = False
return [self.menu_edit] def menu_actions(self): return [self.menu_edit, self.action_menu_1] class TestAppletPlugin(object): name = 'TestApplet' alias = 'Test Applet' def __call__(self): return TestApplet from openalea.core.plugin.manager import PluginManager pm = PluginManager() pm.discover('oalab.applet') pm.add_plugin('oalab.applet', TestAppletPlugin) if __name__ == '__main__': instance = QtGui.QApplication.instance() if instance is None: app = QtGui.QApplication([]) else: app = instance tissuelab_conf = { 'children': {0: [1, 2], 2: [3, 4], 3: [5, 6], 4: [7, 8], 7: [11, 12], 8: [9, 10]}, 'parents': {0: None, 1: 0, 2: 0, 3: 2, 4: 2, 5: 3, 6: 3, 7: 4, 8: 4, 9: 8, 10: 8, 11: 7, 12: 7},
class TestPluginManager(unittest.TestCase): @classmethod def setupClass(cls): cls.tmppath, cls.pythonpath = install_package() import pkg_resources dist = list(pkg_resources.find_distributions(cls.pythonpath))[0] pkg_resources.working_set.add(dist) def setUp(self): self.pm = PluginManager() self.pm.debug = False def test_autoload(self): assert self.pm._plugin == {} self.pm.plugins('test.c1') assert 'test.c1' in self.pm._plugin def test_dynamic_plugin(self): self.pm.add_plugin('test.dynamic3', AlgoPlugin1) self.pm.add_plugin('test.dynamic3', AlgoPlugin2) assert len(self.pm.plugins('test.dynamic3')) == 2 objc3c1 = plugin_instance('test.dynamic3', 'AlgoPlugin1') assert objc3c1 assert isinstance(objc3c1, Algo) objc3c2 = plugin_instance('test.dynamic3', 'MyAlgoPlugin2') assert objc3c2 assert isinstance(objc3c1, Algo) def test_proxy_plugin(self): from openalea.core.plugin.manager import SimpleClassPluginProxy self.pm.add_plugin('test.dynamic4', Algo, plugin_proxy=SimpleClassPluginProxy) objc4c1 = plugin_instance('test.dynamic4', 'Algo') objc4c1_2 = plugin_instance('test.dynamic4', 'Algo') objc4c1_3 = new_plugin_instance('test.dynamic4', 'Algo') assert objc4c1 assert isinstance(objc4c1, Algo) assert objc4c1 is objc4c1_2 assert objc4c1 is not objc4c1_3 def test_plugin_name(self): import tstpkg1.plugin import tstpkg1.impl # Check manager use plugin name attribute if defined (instead of class name) c1plugin1 = self.pm.plugin('test.c1', 'MyPlugin1') assert c1plugin1 is tstpkg1.plugin.C1Plugin1 # Check there is no conflict if two plugins with same alias (in setup.py) but in different categories # Check plugin name use class name if no attribute "name" c2plugin1 = self.pm.plugin('test.c2', 'C2Plugin1') assert c2plugin1 is tstpkg1.plugin.C2Plugin1 def test_new_instance(self): import tstpkg1.impl objc1c1 = plugin_instance('test.c1', 'MyPlugin1') assert objc1c1 assert isinstance(objc1c1, tstpkg1.impl.C1Class1) objc1c2 = plugin_instance('test.c1', 'MyPlugin2') assert objc1c2 assert isinstance(objc1c2, tstpkg1.impl.C1Class2) objc2c1 = plugin_instance('test.c2', 'C2Plugin1') assert objc2c1 assert isinstance(objc2c1, tstpkg1.impl.C2Class1) objc2c2 = plugin_instance('test.c2', 'C2Plugin2') assert objc2c1 assert isinstance(objc2c2, tstpkg1.impl.C2Class2) # Check instance return existing instance objc1c1_2 = plugin_instance('test.c1', 'MyPlugin1') assert objc1c1 is objc1c1_2 assert plugin_instances('test.c1', 'MyPlugin1')[0] is objc1c1_2 def test_multiple_instance(self): # Assert weakref work correctly and plugin instances have been lost assert not plugin_instances('test.c1', 'MyPlugin1') objc1c1_0 = plugin_instance('test.c1', 'MyPlugin1') objc1c1_1 = new_plugin_instance('test.c1', 'MyPlugin1') objc1c1_2 = new_plugin_instance('test.c1', 'MyPlugin1') # Assert all object have been created correctly assert objc1c1_0 assert objc1c1_1 assert objc1c1_2 # Assert all instances are different as we use new instead of instance assert objc1c1_0 is not objc1c1_1 assert objc1c1_1 is not objc1c1_2 objc1c2 = new_plugin_instance('test.c1', 'MyPlugin2') assert len(plugin_instances('test.c1', 'MyPlugin1')) == 3 assert len(plugin_instances('test.c1')) == 4 del objc1c1_2 assert len(plugin_instances('test.c1', 'MyPlugin1')) == 2 assert len(plugin_instances('test.c1')) == 3 del objc1c2 assert len(plugin_instances('test.c1', 'MyPlugin1')) == 2 assert len(plugin_instances('test.c1', 'MyPlugin2')) == 0 assert len(plugin_instances('test.c1')) == 2 def test_debug_ep_load(self): clear_plugin_instances() self.pm.debug = True with self.assertRaises(ImportError): self.pm.plugins('test.err1') self.pm.clear() self.pm.debug = False self.pm.plugins('test.err1') def test_plugin_proxy(self): from openalea.core.plugin.manager import SimpleClassPluginProxy pm = PluginManager() pm.set_proxy('oalab.modelclass', SimpleClassPluginProxy) clear_plugin_instances() w1 = plugin_instance('oalab.modelclass', 'PythonModel') w2 = plugin_instance('oalab.modelclass', 'PythonModel') w3 = plugin_instance('oalab.modelclass', 'PythonModel') w4 = new_plugin_instance('oalab.modelclass', 'PythonModel') assert w1 assert w1 is w2 is w3 assert w1 is not w4 assert len(plugin_instances('oalab.modelclass', 'PythonModel')) == 2 @classmethod def tearDownClass(cls): cls.tmppath.rmtree()
class TestPluginManager(unittest.TestCase): @classmethod def setupClass(cls): cls.tmppath, cls.pythonpath = install_package() import pkg_resources dist = list(pkg_resources.find_distributions(cls.pythonpath))[0] pkg_resources.working_set.add(dist) def setUp(self): self.pm = PluginManager() self.pm.debug = False self.pim = PluginInstanceManager(self.pm) def test_autoload(self): pm = PluginManager() pm.items('test.c1') assert 'test.c1' in pm._item assert 'tstpkg1.plugin:C1Plugin1' in pm._item['test.c1'] pm = PluginManager(autoload=[]) pm.items('test.c1') assert 'test.c1' in pm._item assert 'tstpkg1.plugin:C1Plugin1' not in pm._item['test.c1'] def test_module_plugin_def(self): assert self.pm.items('test.c1') # check if right plugins have been found assert self.pm.item('MyPlugin1', 'test.c1') is not None assert self.pm.item('MyPlugin2', 'test.c1') is not None def test_manual_plugin_def(self): assert self.pm.items('test.c2') # check if right plugins have been found assert self.pm.item('C2Plugin1', 'test.c2') is not None assert self.pm.item('C2Plugin2', 'test.c2') is not None def test_interface_filter(self): plugins = self.pm.items('test.c1') assert len(plugins) == 2 plugins = self.pm.items('test.c1', criteria=dict(implement='IClass1')) assert len(plugins) == 1 assert plugins[0].name == 'MyPlugin1' def test_dynamic_plugin(self): pl = self.pm.add(AlgoPlugin1, 'test.dynamic3') self.pm.add(AlgoPlugin2, 'test.dynamic3') assert len(self.pm.items('test.dynamic3')) == 2 objc3c1 = self.pim.instance('test.dynamic3', 'algo_1') assert objc3c1 assert isinstance(objc3c1, Algo) objc3c2 = self.pim.instance('test.dynamic3', 'algo_2') assert objc3c2 assert isinstance(objc3c1, Algo) def atest_proxy_plugin(self): from openalea.core.plugin.manager import SimpleClassPluginProxy self.pm.add('test.dynamic4', Algo, plugin_proxy=SimpleClassPluginProxy) objc4c1 = self.pim.instance('test.dynamic4', 'Algo') objc4c1_2 = self.pim.instance('test.dynamic4', 'Algo') objc4c1_3 = self.pim.new('test.dynamic4', 'Algo') assert objc4c1 self.assertIsInstance(objc4c1, Algo) assert objc4c1 is objc4c1_2 assert objc4c1 is not objc4c1_3 def test_plugin_name(self): import tstpkg1.plugin import tstpkg1.impl # Check manager use plugin name attribute if defined (instead of class name) c1plugin1 = self.pm.item('MyPlugin1', 'test.c1') self.assertIsInstance(c1plugin1, tstpkg1.plugin.C1Plugin1) # Check there is no conflict if two plugins with same alias (in setup.py) but in different categories # Check plugin name use class name if no attribute "name" c2plugin1 = self.pm.item('C2Plugin1', 'test.c2') self.assertIsInstance(c2plugin1, tstpkg1.plugin.C2Plugin1) def test_new_instance(self): import tstpkg1.impl objc1c1 = self.pim.instance('test.c1', 'MyPlugin1') assert objc1c1 assert isinstance(objc1c1, tstpkg1.impl.C1Class1) objc1c2 = self.pim.instance('test.c1', 'MyPlugin2') assert objc1c2 assert isinstance(objc1c2, tstpkg1.impl.C1Class2) objc2c1 = self.pim.instance('test.c2', 'C2Plugin1') assert objc2c1 assert isinstance(objc2c1, tstpkg1.impl.C2Class1) objc2c2 = self.pim.instance('test.c2', 'C2Plugin2') assert objc2c1 assert isinstance(objc2c2, tstpkg1.impl.C2Class2) # Check instance return existing instance objc1c1_2 = self.pim.instance('test.c1', 'MyPlugin1') assert objc1c1 is objc1c1_2 assert self.pim.instances('test.c1', 'MyPlugin1')[0] is objc1c1_2 def test_multiple_instance(self): # Assert weakref work correctly and plugin instances have been lost assert not self.pim.instances('test.c1', 'MyPlugin1') objc1c1_0 = self.pim.instance('test.c1', 'MyPlugin1') objc1c1_1 = self.pim.new('test.c1', 'MyPlugin1') objc1c1_2 = self.pim.new('test.c1', 'MyPlugin1') # Assert all object have been created correctly assert objc1c1_0 assert objc1c1_1 assert objc1c1_2 # Assert all instances are different as we use new instead of instance assert objc1c1_0 is not objc1c1_1 assert objc1c1_1 is not objc1c1_2 objc1c2 = self.pim.new('test.c1', 'MyPlugin2') assert len(self.pim.instances('test.c1', 'MyPlugin1')) == 3 assert len(self.pim.instances('test.c1')) == 4 del objc1c1_2 assert len(self.pim.instances('test.c1', 'MyPlugin1')) == 2 assert len(self.pim.instances('test.c1')) == 3 del objc1c2 assert len(self.pim.instances('test.c1', 'MyPlugin1')) == 2 assert len(self.pim.instances('test.c1', 'MyPlugin2')) == 0 assert len(self.pim.instances('test.c1')) == 2 def test_debug_ep_load(self): self.pm.debug = True with self.assertRaises(ImportError): self.pm.items('test.err1') self.pm.clear() self.pm.debug = False self.pm.items('test.err1') @classmethod def tearDownClass(cls): cls.tmppath.rmtree()
def setUp(self): self.pm = PluginManager() self.pm.debug = False self.pim = PluginInstanceManager(self.pm)
class TestPluginManager(unittest.TestCase): @classmethod def setupClass(cls): cls.tmppath, cls.pythonpath = install_package() import pkg_resources dist = list(pkg_resources.find_distributions(cls.pythonpath))[0] pkg_resources.working_set.add(dist) def setUp(self): self.pm = PluginManager() self.pm.debug = False self.pim = PluginInstanceManager(self.pm) def test_autoload(self): pm = PluginManager() pm.items("test.c1") assert "test.c1" in pm._item assert "tstpkg1.plugin:C1Plugin1" in pm._item["test.c1"] pm = PluginManager(autoload=[]) pm.items("test.c1") assert "test.c1" in pm._item assert "tstpkg1.plugin:C1Plugin1" not in pm._item["test.c1"] def test_module_plugin_def(self): assert self.pm.items("test.c1") # check if right plugins have been found assert self.pm.item("MyPlugin1", "test.c1") is not None assert self.pm.item("MyPlugin2", "test.c1") is not None def test_manual_plugin_def(self): assert self.pm.items("test.c2") # check if right plugins have been found assert self.pm.item("C2Plugin1", "test.c2") is not None assert self.pm.item("C2Plugin2", "test.c2") is not None def test_interface_filter(self): plugins = self.pm.items("test.c1") assert len(plugins) == 2 plugins = self.pm.items("test.c1", criteria=dict(implement="IClass1")) assert len(plugins) == 1 assert plugins[0].name == "MyPlugin1" def test_dynamic_plugin(self): pl = self.pm.add(AlgoPlugin1, "test.dynamic3") self.pm.add(AlgoPlugin2, "test.dynamic3") assert len(self.pm.items("test.dynamic3")) == 2 objc3c1 = self.pim.instance("test.dynamic3", "algo_1") assert objc3c1 assert isinstance(objc3c1, Algo) objc3c2 = self.pim.instance("test.dynamic3", "algo_2") assert objc3c2 assert isinstance(objc3c1, Algo) def atest_proxy_plugin(self): from openalea.core.plugin.manager import SimpleClassPluginProxy self.pm.add("test.dynamic4", Algo, plugin_proxy=SimpleClassPluginProxy) objc4c1 = self.pim.instance("test.dynamic4", "Algo") objc4c1_2 = self.pim.instance("test.dynamic4", "Algo") objc4c1_3 = self.pim.new("test.dynamic4", "Algo") assert objc4c1 self.assertIsInstance(objc4c1, Algo) assert objc4c1 is objc4c1_2 assert objc4c1 is not objc4c1_3 def test_plugin_name(self): import tstpkg1.plugin import tstpkg1.impl # Check manager use plugin name attribute if defined (instead of class name) c1plugin1 = self.pm.item("MyPlugin1", "test.c1") self.assertIsInstance(c1plugin1, tstpkg1.plugin.C1Plugin1) # Check there is no conflict if two plugins with same alias (in setup.py) but in different categories # Check plugin name use class name if no attribute "name" c2plugin1 = self.pm.item("C2Plugin1", "test.c2") self.assertIsInstance(c2plugin1, tstpkg1.plugin.C2Plugin1) def test_new_instance(self): import tstpkg1.impl objc1c1 = self.pim.instance("test.c1", "MyPlugin1") assert objc1c1 assert isinstance(objc1c1, tstpkg1.impl.C1Class1) objc1c2 = self.pim.instance("test.c1", "MyPlugin2") assert objc1c2 assert isinstance(objc1c2, tstpkg1.impl.C1Class2) objc2c1 = self.pim.instance("test.c2", "C2Plugin1") assert objc2c1 assert isinstance(objc2c1, tstpkg1.impl.C2Class1) objc2c2 = self.pim.instance("test.c2", "C2Plugin2") assert objc2c1 assert isinstance(objc2c2, tstpkg1.impl.C2Class2) # Check instance return existing instance objc1c1_2 = self.pim.instance("test.c1", "MyPlugin1") assert objc1c1 is objc1c1_2 assert self.pim.instances("test.c1", "MyPlugin1")[0] is objc1c1_2 def test_multiple_instance(self): # Assert weakref work correctly and plugin instances have been lost assert not self.pim.instances("test.c1", "MyPlugin1") objc1c1_0 = self.pim.instance("test.c1", "MyPlugin1") objc1c1_1 = self.pim.new("test.c1", "MyPlugin1") objc1c1_2 = self.pim.new("test.c1", "MyPlugin1") # Assert all object have been created correctly assert objc1c1_0 assert objc1c1_1 assert objc1c1_2 # Assert all instances are different as we use new instead of instance assert objc1c1_0 is not objc1c1_1 assert objc1c1_1 is not objc1c1_2 objc1c2 = self.pim.new("test.c1", "MyPlugin2") assert len(self.pim.instances("test.c1", "MyPlugin1")) == 3 assert len(self.pim.instances("test.c1")) == 4 del objc1c1_2 assert len(self.pim.instances("test.c1", "MyPlugin1")) == 2 assert len(self.pim.instances("test.c1")) == 3 del objc1c2 assert len(self.pim.instances("test.c1", "MyPlugin1")) == 2 assert len(self.pim.instances("test.c1", "MyPlugin2")) == 0 assert len(self.pim.instances("test.c1")) == 2 def test_debug_ep_load(self): self.pm.debug = True with self.assertRaises(ImportError): self.pm.items("test.err1") self.pm.clear() self.pm.debug = False self.pm.items("test.err1") @classmethod def tearDownClass(cls): cls.tmppath.rmtree()
def initialize(self): self.pm = PluginManager() for instance in plugin_instances('oalab.applet'): if hasattr(instance, 'initialize'): instance.initialize()