Removed reduntant klass argument from Component.get_instances.

IPython/core/component.py

@@ -1,225 +1,221 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 A lightweight component system for IPython.
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from copy import deepcopy
 from weakref import WeakValueDictionary
 
 from IPython.utils.ipstruct import Struct
 from IPython.utils.traitlets import (
     HasTraitlets, TraitletError, MetaHasTraitlets, Instance, This
 )
 
 
 #-----------------------------------------------------------------------------
 # Helper classes for Components
 #-----------------------------------------------------------------------------
 
 
 class ComponentError(Exception):
     pass
 
 class MetaComponentTracker(type):
     """A metaclass that tracks instances of Components and its subclasses."""
 
     def __init__(cls, name, bases, d):
         super(MetaComponentTracker, cls).__init__(name, bases, d)
         cls.__instance_refs = WeakValueDictionary()
         cls.__numcreated = 0
 
     def __call__(cls, *args, **kw):
         """Called when *class* is called (instantiated)!!!
         
         When a Component or subclass is instantiated, this is called and
         the instance is saved in a WeakValueDictionary for tracking.
         """
 
         instance = super(MetaComponentTracker, cls).__call__(*args, **kw)
         for c in cls.__mro__:
             if issubclass(cls, c) and issubclass(c, Component):
                 c.__numcreated += 1
                 c.__instance_refs[c.__numcreated] = instance
         return instance
 
-    def get_instances(cls, name=None, klass=None, root=None):
+    def get_instances(cls, name=None, root=None):
         """Get all instances of cls and its subclasses.
 
         Parameters
         ----------
         name : str
             Limit to components with this name.
-        klass : class
-            Limit to components having isinstance(component, klass)
         root : Component or subclass
             Limit to components having this root.
         """
         instances = cls.__instance_refs.values()
         if name is not None:
             instances = [i for i in instances if i.name == name]
-        if klass is not None:
-            instances = [i for i in instances if isinstance(i, klass)]
         if root is not None:
             instances = [i for i in instances if i.root == root]
         return instances
 
-    def get_instances_by_condition(cls, call, name=None, klass=None, root=None):
+    def get_instances_by_condition(cls, call, name=None, root=None):
         """Get all instances of cls, i such that call(i)==True.
 
-        This also takes the ``name``, ``klass`` and ``root`` arguments of
+        This also takes the ``name`` and ``root`` arguments of
         :meth:`get_instance`
         """
-        return [i for i in cls.get_instances(name,klass,root) if call(i)]
+        return [i for i in cls.get_instances(name, root) if call(i)]
 
 
 class ComponentNameGenerator(object):
     """A Singleton to generate unique component names."""
 
     def __init__(self, prefix):
         self.prefix = prefix
         self.i = 0
 
     def __call__(self):
         count = self.i
         self.i += 1
         return "%s%s" % (self.prefix, count)
 
 
 ComponentNameGenerator = ComponentNameGenerator('ipython.component')
 
 
 class MetaComponent(MetaHasTraitlets, MetaComponentTracker):
     pass
 
 
 #-----------------------------------------------------------------------------
 # Component implementation
 #-----------------------------------------------------------------------------
 
 
 class Component(HasTraitlets):
 
     __metaclass__ = MetaComponent
 
     # Traitlets are fun!
     config = Instance(Struct,(),{})
     parent = This()
     root = This()
 
     def __init__(self, parent, name=None, config=None):
         """Create a component given a parent and possibly and name and config.
 
         Parameters
         ----------
         parent : Component subclass
             The parent in the component graph.  The parent is used
             to get the root of the component graph.
         name : str
             The unique name of the component.  If empty, then a unique
             one will be autogenerated.
         config : Struct
             If this is empty, self.config = parent.config, otherwise
             self.config = config and root.config is ignored.  This argument
             should only be used to *override* the automatic inheritance of 
             parent.config.  If a caller wants to modify parent.config 
             (not override), the caller should make a copy and change 
             attributes and then pass the copy to this argument.
         
         Notes
         -----
         Subclasses of Component must call the :meth:`__init__` method of
         :class:`Component` *before* doing anything else and using 
         :func:`super`::
         
             class MyComponent(Component):
                 def __init__(self, parent, name=None, config=None):
                     super(MyComponent, self).__init__(parent, name, config)
                     # Then any other code you need to finish initialization.
 
         This ensures that the :attr:`parent`, :attr:`name` and :attr:`config`
         attributes are handled properly.
         """
         super(Component, self).__init__()
         self._children = []
         if name is None:
             self.name = ComponentNameGenerator()
         else:
             self.name = name
         self.root = self # This is the default, it is set when parent is set
         self.parent = parent
         if config is not None:
             self.config = deepcopy(config)
         else:
             if self.parent is not None:
                 self.config = deepcopy(self.parent.config)
 
     #-------------------------------------------------------------------------
     # Static traitlet notifiations
     #-------------------------------------------------------------------------
 
     def _parent_changed(self, name, old, new):
         if old is not None:
             old._remove_child(self)
         if new is not None:
             new._add_child(self)
 
         if new is None:
             self.root = self
         else:
             self.root = new.root
 
     def _root_changed(self, name, old, new):
         if self.parent is None:
             if not (new is self):
                 raise ComponentError("Root not self, but parent is None.")
         else:
             if not self.parent.root is new:
                 raise ComponentError("Error in setting the root attribute: "
                                      "root != parent.root")
 
     def _config_changed(self, name, old, new):
         # Get all traitlets with a config_key metadata entry
         traitlets = self.traitlets('config_key')
         for k, v in traitlets.items():
             try:
                 config_value = new[v.get_metadata('config_key')]
             except KeyError:
                 pass
             else:
                 setattr(self, k, config_value)
 
     @property
     def children(self):
         """A list of all my child components."""
         return self._children
 
     def _remove_child(self, child):
         """A private method for removing children components."""
         if child in self._children:
             index = self._children.index(child)
             del self._children[index]
 
     def _add_child(self, child):
         """A private method for adding children components."""
         if child not in self._children:
             self._children.append(child)
 
     def __repr__(self):
         return "<Component('%s')>" % self.name

IPython/core/tests/test_component.py

@@ -1,194 +1,194 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Tests for IPython.core.component
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from unittest import TestCase
 
 from IPython.core.component import Component, ComponentError
 from IPython.utils.traitlets import (
     TraitletError, Int, Float, Str
 )
 from IPython.utils.ipstruct import Struct
 
 
 #-----------------------------------------------------------------------------
 # Test cases
 #-----------------------------------------------------------------------------
 
 
 class TestComponentMeta(TestCase):
 
     def test_get_instances(self):
         class BaseComponent(Component):
             pass
         c1 = BaseComponent(None)
         c2 = BaseComponent(c1)
         self.assertEquals(BaseComponent.get_instances(),[c1,c2])
 
     def test_get_instances_subclass(self):
         class MyComponent(Component):
             pass
         class MyOtherComponent(MyComponent):
             pass
         c1 = MyComponent(None)
         c2 = MyOtherComponent(c1)
         c3 = MyOtherComponent(c2)
         self.assertEquals(MyComponent.get_instances(), [c1, c2, c3])
-        self.assertEquals(MyComponent.get_instances(klass=MyOtherComponent), [c2, c3])
+        self.assertEquals(MyOtherComponent.get_instances(), [c2, c3])
 
     def test_get_instances_root(self):
         class MyComponent(Component):
             pass
         class MyOtherComponent(MyComponent):
             pass
         c1 = MyComponent(None)
         c2 = MyOtherComponent(c1)
         c3 = MyOtherComponent(c2)
         c4 = MyComponent(None)
         c5 = MyComponent(c4)
         self.assertEquals(MyComponent.get_instances(root=c1), [c1, c2, c3])
         self.assertEquals(MyComponent.get_instances(root=c4), [c4, c5])
 
 
 class TestComponent(TestCase):
 
     def test_parent_child(self):
         c1 = Component(None)
         c2 = Component(c1)
         c3 = Component(c1)
         c4 = Component(c3)
         self.assertEquals(c1.parent, None)
         self.assertEquals(c2.parent, c1)
         self.assertEquals(c3.parent, c1)
         self.assertEquals(c4.parent, c3)
         self.assertEquals(c1.children, [c2, c3])
         self.assertEquals(c2.children, [])
         self.assertEquals(c3.children, [c4])
         self.assertEquals(c4.children, [])
 
     def test_root(self):
         c1 = Component(None)
         c2 = Component(c1)
         c3 = Component(c1)
         c4 = Component(c3)
         self.assertEquals(c1.root, c1.root)
         self.assertEquals(c2.root, c1)
         self.assertEquals(c3.root, c1)
         self.assertEquals(c4.root, c1)
 
     def test_change_parent(self):
         c1 = Component(None)
         c2 = Component(None)
         c3 = Component(c1)
         self.assertEquals(c3.root, c1)
         self.assertEquals(c3.parent, c1)
         self.assertEquals(c1.children,[c3])
         c3.parent = c2
         self.assertEquals(c3.root, c2)
         self.assertEquals(c3.parent, c2)
         self.assertEquals(c2.children,[c3])
         self.assertEquals(c1.children,[])
 
     def test_subclass_parent(self):
         c1 = Component(None)
         self.assertRaises(TraitletError, setattr, c1, 'parent', 10)
 
         class MyComponent(Component):
             pass
         c1 = Component(None)
         c2 = MyComponent(c1)
         self.assertEquals(MyComponent.parent.this_class, Component)
         self.assertEquals(c2.parent, c1)
 
     def test_bad_root(self):
         c1 = Component(None)
         c2 = Component(None)
         c3 = Component(None)
         self.assertRaises(ComponentError, setattr, c1, 'root', c2)
         c1.parent = c2
         self.assertEquals(c1.root, c2)
         self.assertRaises(ComponentError, setattr, c1, 'root', c3)
 
 
 class TestComponentConfig(TestCase):
 
     def test_default(self):
         c1 = Component(None)
         c2 = Component(c1)
         c3 = Component(c2)
         self.assertEquals(c1.config, c2.config)
         self.assertEquals(c2.config, c3.config)
 
     def test_custom(self):
         config = Struct()
         config.FOO = 'foo'
         config.BAR = 'bar'
         c1 = Component(None, config=config)
         c2 = Component(c1)
         c3 = Component(c2)
         self.assertEquals(c1.config, config)
         self.assertEquals(c2.config, config)
         self.assertEquals(c3.config, config)
         # Test that we always make copies
         self.assert_(c1.config is not config)
         self.assert_(c2.config is not config)
         self.assert_(c3.config is not config)
         self.assert_(c1.config is not c2.config)
         self.assert_(c2.config is not c3.config)
         
     def test_inheritance(self):
         class MyComponent(Component):
             a = Int(1, config_key='A')
             b = Float(1.0, config_key='B')
             c = Str('no config')
         config = Struct()
         config.A = 2
         config.B = 2.0
         c1 = MyComponent(None, config=config)
         c2 = MyComponent(c1)
         self.assertEquals(c1.a, config.A)
         self.assertEquals(c1.b, config.B)
         self.assertEquals(c2.a, config.A)
         self.assertEquals(c2.b, config.B)
         c4 = MyComponent(c2, config=Struct())
         self.assertEquals(c4.a, 1)
         self.assertEquals(c4.b, 1.0)
 
 class TestComponentName(TestCase):
 
     def test_default(self):
         class MyComponent(Component):
             pass
         c1 = Component(None)
         c2 = MyComponent(None)
         c3 = Component(c2)
         self.assertNotEquals(c1.name, c2.name)
         self.assertNotEquals(c1.name, c3.name)
 
     def test_manual(self):
         class MyComponent(Component):
             pass
         c1 = Component(None, name='foo')
         c2 = MyComponent(None, name='bar')
         c3 = Component(c2, name='bah')
         self.assertEquals(c1.name, 'foo')
         self.assertEquals(c2.name, 'bar')
         self.assertEquals(c3.name, 'bah')