Merge lp:~methanal-developers/methanal/enum-object-and-group-choices into lp:methanal

[Jonathan Jacobs]

Implement ObjectEnum for using arbitrary Python objects with ChoiceInputs and enhance ChoiceInput to respect a "group" EnumItem extra value for visually grouping enumeration values.

[lp:~methanal-developers/methanal/enum-object-and-group-choices]

145. By Jonathan Jacobs on 2010-06-29

Make Enum.__iter__ respect EnumItem.hidden.

146. By Jonathan Jacobs on 2010-06-29

Name tweaks.

[Jonathan Jacobs (jjacobs)]

Looking at some of this code now a few things jump out at me, I'd appreciate some thoughts on these:

1. "IEnumeration.asPairs" is basically only used in the tests now, do we actually need this method to be in IEnumeration?

2. "IEnumeration" only specifies a single method, as I've already found out, that is really not all that useful. I think the interface should be expanded.

3. Iterating an Enum yields non-hidden EnumItems, should there be some way to get all EnumItems? I don't really know why you would need this, but if you do it will probably be nicer than relying on a private attribute.

[lp:~methanal-developers/methanal/enum-object-and-group-choices]

147. By Jonathan Jacobs on 2010-06-29

Cosmetic tweaks.

[Tristan Seligmann (mithrandi)]

Regarding your thoughts:

1. It's used several times in Fusion too, so I think let's keep it.

2. The widgets adapt the value passed in to IEnumeration, and then call various methods on that. IEnumeration needs to include all of those methods.

3. If someone needs it later, we can add it then; I'd rather not add a public interface until there's a use case.

Regarding the rest of the branch:

34 + type(theList[0][1]) not in (tuple, list)):

Rather use "not isinstance(theList[0][1]), (tuple, list))". Also, can we deprecate ListEnumeration? It's really awful.

1179 +ObjectRadioGroupInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
1180 + ObjectRadioGroupInput.__init__)

Can't this be done using @decorator syntax instead? I think it might be clearer that way.

review: Needs Fixing

[lp:~methanal-developers/methanal/enum-object-and-group-choices]

148. By Jonathan Jacobs on 2010-07-12

Move more of Enum into IEnumeration.

149. By Jonathan Jacobs on 2010-07-13

Improve Enum.__repr__.

150. By Jonathan Jacobs on 2010-07-13

Deprecate ListEnumeration.

[Jonathan Jacobs (jjacobs)]

> Regarding the rest of the branch:
>
> 34 + type(theList[0][1]) not in (tuple, list)):
>
> Rather use "not isinstance(theList[0][1]), (tuple, list))". Also, can we
> deprecate ListEnumeration? It's really awful.

Done.

There are piles of deprecation warnings now, but I don't think its worth trying to clean them up since in the next version of Methanal we'll be deleting most of the associated code and the tests will have to change (to use Enum instead of lists) in any case.

[lp:~methanal-developers/methanal/enum-object-and-group-choices]

151. By Jonathan Jacobs on 2010-07-13

Merge forward.

[Tristan Seligmann (mithrandi)]

review: Approve

=== modified file 'methanal/enums.py'
--- methanal/enums.py	2009-09-20 18:55:19 +0000
+++ methanal/enums.py	2010-07-13 11:45:57 +0000
@@ -1,24 +1,33 @@
+import textwrap
 from zope.interface import implements
 
+from twisted.python.versions import Version
+from twisted.python.deprecate import deprecated
+
 from methanal.errors import InvalidEnumItem
 from methanal.imethanal import IEnumeration
 
 
 
-class ListEnumeration(object):
-    """
-    An L{IEnumeration} implementation for the C{list} type.
-    """
-    implements(IEnumeration)
-
-
-    def __init__(self, theList):
-        self.theList = theList
-
-
-    # IEnumeration
-    def asPairs(self):
-        return self.theList
+@deprecated(Version('methanal', 0, 2, 1))
+def ListEnumeration(theList):
+    """
+    An L{IEnumeration} adapter for the C{list} type.
+
+    This is deprecated, use L{Enum.fromPairs} instead.
+    """
+    # If this isn't a grouped input, turn it into one with one unnamed group.
+    if (theList and
+        len(theList[0]) > 1 and
+        not isinstance(theList[0][1], (tuple, list))):
+        theList = [(None, theList)]
+
+    items = []
+    for groupName, values in theList:
+        for value, desc in values:
+            items.append(EnumItem(value, desc, group=groupName))
+
+    return Enum('', items)
 
 
 
@@ -26,7 +35,7 @@
     """
     An enumeration.
 
-    @ivar doc: A brief description of the enumeration's intent
+    L{Enum} objects implement the iterator protocol.
 
     @ivar _order: A list of enumeration items, used to preserve the original
         order of the enumeration
@@ -40,20 +49,45 @@
         """
         Initialise an enumeration.
 
-        @param doc: See L{Enum.doc}
-
-        @type  values: C{iterable} of L{EnumItem}
+        @type values: C{iterable} of L{EnumItem}
         """
         self.doc = doc
 
         _order = self._order = []
         _values = self._values = {}
         for value in values:
-            if value.value in _values:
+            key = self._getValueMapping(value)
+            if key in _values:
                 raise ValueError(
-                    '%r is already a value in the enumeration' % (value.value,))
+                    '%r is already a value in the enumeration' % (key,))
             _order.append(value)
-            _values[value.value] = value
+            _values[key] = value
+
+
+    def __iter__(self):
+        for item in self._order:
+            if not item.hidden:
+                yield item
+
+
+    def __repr__(self):
+        lines = textwrap.wrap(textwrap.dedent(self.doc.strip()))
+        line = 'undocumented'
+        if lines:
+            line = lines[0]
+            if len(lines) > 1:
+                line += '...'
+            line = '"""%s"""' % (line,)
+        return '<%s %s>' % (
+            type(self).__name__,
+            line)
+
+
+    def _getValueMapping(self, value):
+        """
+        Determine the key to use when constructing a mapping for C{value}.
+        """
+        return value.value
 
 
     @classmethod
@@ -71,12 +105,9 @@
         return cls(doc=doc, values=values)
 
 
+    # IEnumeration
+
     def get(self, value):
-        """
-        Get an enumeration item for a given enumeration value.
-
-        @rtype: L{EnumItem}
-        """
         item = self._values.get(value)
         if item is None:
             raise InvalidEnumItem(value)
@@ -84,9 +115,6 @@
 
 
     def getDesc(self, value):
-        """
-        Get the description for a given enumeration value.
-        """
         try:
             return self.get(value).desc
         except InvalidEnumItem:
@@ -94,9 +122,6 @@
 
 
     def getExtra(self, value, extraName, default=None):
-        """
-        Get the extra value for C{extraName} or use C{default}.
-        """
         try:
             return self.get(value).get(extraName, default)
         except InvalidEnumItem:
@@ -104,43 +129,52 @@
 
 
     def find(self, **names):
-        """
-        Find the first L{EnumItem} with matching extra values.
-
-        @param **names: Extra values to match
-
-        @rtype:  L{EnumItem}
-        @return: The first matching L{EnumItem} or C{None} if there are no
-            matches
-        """
         for res in self.findAll(**names):
             return res
         return None
 
 
     def findAll(self, **names):
-        """
-        Find all L{EnumItem}s with matching extra values.
-
-        @param **names: Extra values to match
-
-        @rtype:  C{iterable} of L{EnumItem}
-        """
         values = names.items()
         if len(values) != 1:
             raise ValueError('Only one query is allowed at a time')
 
         name, value = values[0]
-        for item in self._order:
+        for item in self:
             if item.get(name) == value:
                 yield item
 
 
+    def asPairs(self):
+        return [(i.value, i.desc) for i in self]
+
+
+
+class ObjectEnum(Enum):
+    """
+    An enumeration for arbitrary Python objects.
+
+    Pass the Python object as the C{value} parameter to L{EnumItem}.
+    C{ObjectEnum} will automatically create an C{'id'} extra value for
+    L{EnumItem}s that do not already have such a value.
+    """
+    def _getValueMapping(self, value):
+        key = unicode(id(value.value))
+        if value.get('id') is None:
+            value._extra['id'] = key
+        return key
+
+
+    def get(self, value):
+        value = unicode(id(value))
+        return super(ObjectEnum, self).get(value)
+
+
     # IEnumeration
+
     def asPairs(self):
-        return [(i.value, i.desc)
-                for i in self._order
-                if not i.hidden]
+        return [(i.id, i.desc)
+                for i in self]
 
 
 
@@ -170,6 +204,14 @@
         self._extra = extra
 
 
+    def __repr__(self):
+        return '<%s value=%r desc=%r hidden=%r>' % (
+            type(self).__name__,
+            self.value,
+            self.desc,
+            self.hidden)
+
+
     def __getattr__(self, name):
         """
         Get an extra value by name.

=== modified file 'methanal/imethanal.py'
--- methanal/imethanal.py	2009-11-03 22:23:50 +0000
+++ methanal/imethanal.py	2010-07-13 11:45:57 +0000
@@ -62,6 +62,10 @@
     """
     An enumeration.
     """
+    doc = Attribute("""
+    A brief description of the enumeration's intent.
+    """)
+
     def asPairs():
         """
         Represent the enumeration as a sequence of pairs.
@@ -69,3 +73,48 @@
         @rtype: C{list} of 2-C{tuple}s
         @return: A sequence of C{(value, description)}
         """
+
+
+    def get(value):
+        """
+        Get an enumeration item for a given enumeration value.
+
+        @raise L{methanal.errors.InvalidEnumItem}: If C{value} does not match
+            any known enumeration value.
+
+        @rtype: L{EnumItem}
+        """
+
+
+    def getDesc(value):
+        """
+        Get the description for a given enumeration value.
+        """
+
+
+    def getExtra(value, extraName, default=None):
+        """
+        Get the extra value for C{extraName} or use C{default}.
+        """
+
+
+    def find(**names):
+        """
+        Find the first L{EnumItem} with matching extra values.
+
+        @param **names: Extra values to match
+
+        @rtype:  L{EnumItem}
+        @return: The first matching L{EnumItem} or C{None} if there are no
+            matches
+        """
+
+
+    def findAll(**names):
+        """
+        Find all L{EnumItem}s with matching extra values.
+
+        @param **names: Extra values to match
+
+        @rtype:  C{iterable} of L{EnumItem}
+        """

=== modified file 'methanal/js/Methanal/View.js'
--- methanal/js/Methanal/View.js	2010-07-08 19:22:54 +0000
+++ methanal/js/Methanal/View.js	2010-07-13 11:45:57 +0000
@@ -1827,7 +1827,7 @@
  */
 Methanal.View.FormInput.subclass(Methanal.View, 'MultiInputBase').methods(
     function getInputNode(self) {
-        return self.getInputNodes()[0];
+        return self.node.getElementsByTagName('input')[0];
     },
 
 

=== modified file 'methanal/static/styles/methanal.css'
--- methanal/static/styles/methanal.css	2010-07-08 18:27:35 +0000
+++ methanal/static/styles/methanal.css	2010-07-13 11:45:57 +0000
@@ -562,6 +562,17 @@
     display: none !important;
 }
 
+.methanal-choice-group {
+    border: solid #ddd;
+    border-width: 0 0 0 1px;
+    margin: 0.5em;
+    padding: 0.3em 0 0.3em 0.5em;
+}
+
+.methanal-choice-group h4 {
+    margin: 0 0 0.25em 0;
+}
+
 .dependancy-parent {
     border-left: 3px solid #6094a4;
     margin-left: -3px;

=== modified file 'methanal/test/test_enums.py'
--- methanal/test/test_enums.py	2009-12-05 16:01:59 +0000
+++ methanal/test/test_enums.py	2010-07-13 11:45:57 +0000
@@ -15,31 +15,46 @@
     """
     def test_list(self):
         """
-        Adapting a C{list} to L{IEnumeration} results in an identical list.
+        Adapting a C{list} to L{IEnumeration} results in an L{Enum} accurately
+        representing the list.
         """
         values = [
             (u'foo', u'Foo'),
             (u'bar', u'Bar')]
-        self.assertEquals(IEnumeration(values).asPairs(), values)
+        enum = IEnumeration(values)
+        self.assertEquals(enum.asPairs(), values)
+        for value, desc in values:
+            item = enum.get(value)
+            self.assertEquals(item.value, value)
+            self.assertEquals(item.desc, desc)
 
 
     def test_groupList(self):
         """
         Adapting a C{list} of nested C{list}s, as used by
-        L{methanal.view.GroupedSelectInput}, results in an identical list.
+        L{methanal.view.GroupedSelectInput}, results in an L{Enum} with
+        L{EnumItems} with a C{'group'} extra value the same as the first
+        element in each C{tuple}. L{IEnumeration.asPairs} returns a flat
+        C{list} for nested C{list}s adapted to L{IEnumeration}.
         """
         values = [
             (u'Group', [
                 (u'foo', u'Foo'),
                 (u'bar', u'Bar')]),
-            (u'Group', [
+            (u'Group 2', [
                 (u'quux', u'Quux'),
                 (u'frob', u'Frob')])]
 
-        pairs = IEnumeration(values).asPairs()
-        for i, (groupName, innerValues) in enumerate(pairs):
-            self.assertEquals(groupName, u'Group')
-            self.assertEquals(pairs[i][1], innerValues)
+        enum = IEnumeration(values)
+        for groupName, innerValues in values:
+            for value, desc in innerValues:
+                item = enum.get(value)
+                self.assertEquals(item.value, value)
+                self.assertEquals(item.desc, desc)
+                self.assertEquals(item.get('group'), groupName)
+
+        pairs = sum(zip(*values)[1], [])
+        self.assertEquals(enum.asPairs(), pairs)
 
 
     def test_notAdapted(self):
@@ -53,18 +68,10 @@
 
 
 
-class EnumTests(unittest.TestCase):
-    """
-    Tests for L{methanal.enums.Enum}.
-    """
-    def setUp(self):
-        self.values = [
-            enums.EnumItem(u'foo', u'Foo', quux=u'hello', frob=u'world'),
-            enums.EnumItem(u'bar', u'Bar', quux=u'goodbye'),
-            enums.EnumItem(u'doh', u'Doh', frob=u'world')]
-        self.enum = enums.Enum('Doc', self.values)
-
-
+class _EnumTestsMixin(object):
+    """
+    Test case mixin for enumerations.
+    """
     def test_duplicateValues(self):
         """
         Constructing an enumeration with duplicate values results in
@@ -96,7 +103,7 @@
         """
         Representing an enumeration as a list of pairs.
         """
-        pairs = [(e.value, e.desc) for e in self.values]
+        pairs = [(e.get('id', e.value), e.desc) for e in self.values]
         self.assertEquals(self.enum.asPairs(), pairs)
 
 
@@ -123,45 +130,6 @@
         self.assertEquals(self.enum.getDesc(u'DOESNOTEXIST'), u'')
 
 
-    def test_getExtra(self):
-        """
-        Getting an enumeration item extra value by enumeration value returns
-        the extra's value or a default value, defaulting to C{None}.
-        """
-        self.assertEquals(self.enum.getExtra(u'foo', 'quux'), u'hello')
-        self.assertEquals(self.enum.getExtra(u'foo', 'frob'), u'world')
-        self.assertEquals(self.enum.getExtra(u'bar', 'quux'), u'goodbye')
-
-        self.assertEquals(self.enum.getExtra(u'bar', 'nope'), None)
-        self.assertEquals(self.enum.getExtra(u'bar', 'nope', u''), u'')
-
-
-    def test_extra(self):
-        """
-        Extra parameters are retrieved by L{methanal.enums.EnumItem.get} if they
-        exist otherwise a default value is returned instead. Extra parameters
-        can also be accessed via attribute access but C{AttributeError} is
-        raised if no such extra parameter exists.
-        """
-        self.assertEquals(self.enum.get(u'foo').get('quux'), u'hello')
-        self.assertEquals(self.enum.get(u'foo').get('frob'), u'world')
-        self.assertEquals(self.enum.get(u'bar').get('quux'), u'goodbye')
-
-        self.assertEquals(self.enum.get(u'bar').get('boop'), None)
-        self.assertEquals(self.enum.get(u'bar').get('beep', 42), 42)
-
-        self.assertEquals(self.enum.get(u'foo').quux, u'hello')
-        self.assertEquals(self.enum.get(u'foo').frob, u'world')
-        self.assertEquals(self.enum.get(u'bar').quux, u'goodbye')
-
-        e = self.assertRaises(AttributeError,
-                              getattr, self.enum.get(u'bar'), 'boop')
-        self.assertIn('boop', str(e))
-        e = self.assertRaises(AttributeError,
-                          getattr, self.enum.get(u'bar'), 'beep')
-        self.assertIn('beep', str(e))
-
-
     def test_hidden(self):
         """
         Enumeration items that have their C{hidden} flag set are not listed in
@@ -184,11 +152,11 @@
         or C{None} if there are no matches. Passing fewer or more than one
         query raises C{ValueError}.
         """
-        self.assertEquals(self.enum.find(quux=u'hello'), self.values[0])
-        self.assertEquals(self.enum.find(frob=u'world'), self.values[0])
-        self.assertEquals(self.enum.find(quux=u'goodbye'), self.values[1])
+        self.assertIdentical(self.enum.find(quux=u'hello'), self.values[0])
+        self.assertIdentical(self.enum.find(frob=u'world'), self.values[0])
+        self.assertIdentical(self.enum.find(quux=u'goodbye'), self.values[1])
 
-        self.assertEquals(self.enum.find(haha=u'nothanks'), None)
+        self.assertIdentical(self.enum.find(haha=u'nothanks'), None)
         self.assertRaises(ValueError, self.enum.find)
         self.assertRaises(ValueError, self.enum.find, foo=u'foo', bar=u'bar')
 
@@ -210,3 +178,217 @@
         self.assertRaises(ValueError, list, self.enum.findAll())
         self.assertRaises(ValueError, list, self.enum.findAll(foo=u'foo',
                                                               bar=u'bar'))
+
+
+    def test_iterator(self):
+        """
+        L{Enum} implements the iterator protocol and will iterate over
+        L{EnumItem}s in the order originally specified, omitting L{EnumItem}s
+        that are marked as hidden.
+        """
+        items = [enums.EnumItem(u'foo', u'Foo'),
+                 enums.EnumItem(u'bar', u'Bar'),
+                 enums.EnumItem(u'baz', u'Baz', hidden=True)]
+        enum = enums.Enum('Doc', items)
+
+        # The hidden Enum is omitted.
+        self.assertEquals(len(list(enum)), 2)
+
+        for expected, item in zip(items, enum):
+            self.assertIdentical(expected, item)
+
+
+
+class EnumTests(_EnumTestsMixin, unittest.TestCase):
+    """
+    Tests for L{methanal.enums.Enum}.
+    """
+    def setUp(self):
+        self.values = [
+            enums.EnumItem(u'foo', u'Foo', quux=u'hello', frob=u'world'),
+            enums.EnumItem(u'bar', u'Bar', quux=u'goodbye'),
+            enums.EnumItem(u'doh', u'Doh', frob=u'world')]
+        self.enum = enums.Enum('Doc', self.values)
+
+
+    def test_getExtra(self):
+        """
+        Getting an enumeration item extra value by enumeration value returns
+        the extra's value or a default value, defaulting to C{None}.
+        """
+        self.assertEquals(self.enum.getExtra(u'foo', 'quux'), u'hello')
+        self.assertEquals(self.enum.getExtra(u'foo', 'frob'), u'world')
+        self.assertEquals(self.enum.getExtra(u'bar', 'quux'), u'goodbye')
+
+        self.assertEquals(self.enum.getExtra(u'bar', 'nope'), None)
+        self.assertEquals(self.enum.getExtra(u'bar', 'nope', u''), u'')
+
+
+    def test_extra(self):
+        """
+        Extra parameters are retrieved by L{methanal.enums.EnumItem.get} if they
+        exist otherwise a default value is returned instead. Extra parameters
+        can also be accessed via attribute access but C{AttributeError} is
+        raised if no such extra parameter exists.
+        """
+        self.assertEquals(self.enum.get(u'foo').get('quux'), u'hello')
+        self.assertEquals(self.enum.get(u'foo').get('frob'), u'world')
+        self.assertEquals(self.enum.get(u'bar').get('quux'), u'goodbye')
+
+        self.assertEquals(self.enum.get(u'bar').get('boop'), None)
+        self.assertEquals(self.enum.get(u'bar').get('beep', 42), 42)
+
+        self.assertEquals(self.enum.get(u'foo').quux, u'hello')
+        self.assertEquals(self.enum.get(u'foo').frob, u'world')
+        self.assertEquals(self.enum.get(u'bar').quux, u'goodbye')
+
+        e = self.assertRaises(AttributeError,
+                              getattr, self.enum.get(u'bar'), 'boop')
+        self.assertIn('boop', str(e))
+        e = self.assertRaises(AttributeError,
+                          getattr, self.enum.get(u'bar'), 'beep')
+        self.assertIn('beep', str(e))
+
+
+    def test_reprEnum(self):
+        """
+        L{methanal.enums.Enum} has a useful representation that contains the
+        type name and the enumeration description.
+        """
+        self.assertEquals(
+            repr(enums.Enum('Foo bar', [])),
+            '<Enum """Foo bar""">')
+
+        lorem = """
+        Lorem ipsum dolor sit amet, consectetur adipiscing elit. In vitae sem
+        felis, sit amet tincidunt est. Cras convallis, odio nec accumsan
+        vestibulum, lectus dolor feugiat magna, sit amet tempus lorem diam ac
+        enim. Curabitur nisl nibh, bibendum ac tempus non, blandit ac turpis.
+        """
+
+        self.assertEquals(
+            repr(enums.Enum(lorem, [])),
+            '<Enum """Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+            ' In vitae sem...""">')
+
+
+    def test_reprEnumUndocumented(self):
+        """
+        L{methanal.enums.Enum} has a useful representation even when the
+        enumeration has no description.
+        """
+        self.assertEquals(
+            repr(enums.Enum('', [])),
+            '<Enum undocumented>')
+
+
+
+class EnumItemTests(unittest.TestCase):
+    """
+    Tests for L{methanal.enums.EnumItem}.
+    """
+    def test_reprEnumItem(self):
+        """
+        L{methanal.enums.EnumItem} has a useful representation that contains
+        the value, description and hidden state.
+        """
+        self.assertEquals(
+            repr(enums.EnumItem(u'foo', u'Foo')),
+            "<EnumItem value=u'foo' desc=u'Foo' hidden=False>")
+
+        self.assertEquals(
+            repr(enums.EnumItem(u'foo', u'Foo', hidden=True)),
+            "<EnumItem value=u'foo' desc=u'Foo' hidden=True>")
+
+
+
+class ObjectEnumTests(_EnumTestsMixin, unittest.TestCase):
+    """
+    Tests for L{methanal.enums.ObjectEnum}.
+    """
+    def setUp(self):
+        self.object1 = object()
+        self.object2 = object()
+        self.object3 = object()
+        self.values = [
+            enums.EnumItem(self.object1, u'Foo', quux=u'hello', frob=u'world'),
+            enums.EnumItem(self.object2, u'Bar', quux=u'goodbye'),
+            enums.EnumItem(self.object3, u'Doh', frob=u'world', id=u'chuck')]
+        self.enum = enums.ObjectEnum('Doc', self.values)
+
+
+    def test_idExtra(self):
+        """
+        L{methanal.enums.ObjectEnum} automatically creates an C{'id'} EnumItem
+        extra value, based on the result of C{id}, if one does not already
+        exist.
+        """
+        expected = [
+            unicode(id(self.object1)),
+            unicode(id(self.object2)),
+            u'chuck']
+
+        self.assertEquals(
+            expected,
+            [value.id for value in self.values])
+
+
+    def test_getExtra(self):
+        """
+        Getting an enumeration item extra value by enumeration value returns
+        the extra's value or a default value, defaulting to C{None}.
+        """
+        self.assertEquals(self.enum.getExtra(self.object1, 'quux'), u'hello')
+        self.assertEquals(self.enum.getExtra(self.object1, 'frob'), u'world')
+        self.assertEquals(self.enum.getExtra(self.object2, 'quux'), u'goodbye')
+
+        self.assertEquals(self.enum.getExtra(u'bar', 'nope'), None)
+        self.assertEquals(self.enum.getExtra(u'bar', 'nope', u''), u'')
+
+
+    def test_extra(self):
+        """
+        Extra parameters are retrieved by L{methanal.enums.EnumItem.get} if they
+        exist otherwise a default value is returned instead. Extra parameters
+        can also be accessed via attribute access but C{AttributeError} is
+        raised if no such extra parameter exists.
+        """
+        self.assertEquals(self.enum.get(self.object1).get('quux'), u'hello')
+        self.assertEquals(self.enum.get(self.object1).get('frob'), u'world')
+        self.assertEquals(self.enum.get(self.object2).get('quux'), u'goodbye')
+
+        self.assertEquals(self.enum.get(self.object2).get('boop'), None)
+        self.assertEquals(self.enum.get(self.object2).get('beep', 42), 42)
+
+        self.assertEquals(self.enum.get(self.object1).quux, u'hello')
+        self.assertEquals(self.enum.get(self.object1).frob, u'world')
+        self.assertEquals(self.enum.get(self.object2).quux, u'goodbye')
+
+        e = self.assertRaises(AttributeError,
+            getattr, self.enum.get(self.object2), 'boop')
+        self.assertIn('boop', str(e))
+        e = self.assertRaises(AttributeError,
+            getattr, self.enum.get(self.object2), 'beep')
+        self.assertIn('beep', str(e))
+
+
+    def test_reprEnum(self):
+        """
+        L{methanal.enums.ObjectEnum} has a useful representation that contains the
+        type name and the enumeration description.
+        """
+        self.assertEquals(
+            repr(enums.ObjectEnum('Foo bar', [])),
+            '<ObjectEnum """Foo bar""">')
+
+        lorem = """
+        Lorem ipsum dolor sit amet, consectetur adipiscing elit. In vitae sem
+        felis, sit amet tincidunt est. Cras convallis, odio nec accumsan
+        vestibulum, lectus dolor feugiat magna, sit amet tempus lorem diam ac
+        enim. Curabitur nisl nibh, bibendum ac tempus non, blandit ac turpis.
+        """
+
+        self.assertEquals(
+            repr(enums.ObjectEnum(lorem, [])),
+            '<ObjectEnum """Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+            ' In vitae sem...""">')

=== modified file 'methanal/test/test_view.py'
--- methanal/test/test_view.py	2010-03-12 15:21:05 +0000
+++ methanal/test/test_view.py	2010-07-13 11:45:57 +0000
@@ -19,9 +19,10 @@
 from nevow import athena, loaders
 from nevow.testutil import renderLivePage
 
+from methanal import view, errors
 from methanal.imethanal import IEnumeration
 from methanal.model import ItemModel, Value, DecimalValue, Model
-from methanal import view
+from methanal.enums import Enum, EnumItem, ObjectEnum
 
 
 
@@ -571,14 +572,15 @@
         (TypeError, dict())]
 
 
-    def createControl(self, args):
+    def createControl(self, args, checkExpectedValues=True):
         """
         Create a L{methanal.view.ChoiceInput} from C{values}, assert that
         L{methanal.view.ChoiceInput.value} provides L{IEnumeration} and
         calling C{asPairs} results in the same values as C{values}.
         """
         control = super(ChoiceInputTests, self).createControl(args)
-        self.assertEquals(control.values.asPairs(), list(args.get('values')))
+        if checkExpectedValues:
+            self.assertEquals(control.values.asPairs(), list(args.get('values')))
         return control
 
 
@@ -592,7 +594,284 @@
             (u'foo', u'Foo'),
             (u'bar', u'Bar')])
         self.createControl(dict(values=values))
-        self.assertEquals(len(self.flushWarnings()), 1)
+        self.assertEquals(len(self.flushWarnings()), 2)
+
+
+
+class SelectInputTests(ChoiceInputTests):
+    """
+    Tests for L{methanal.view.SelectInput}.
+    """
+    controlType = view.SelectInput
+
+    def test_renderGroupsOptions(self):
+        """
+        The options of a C{SelectInput} are rendered as groups if the enumeration
+        values specify a C{'group'} extra value.
+        """
+        values = Enum(
+            '',
+            [EnumItem(u'foo', u'Foo', group=u'Group'),
+             EnumItem(u'bar', u'Bar', group=u'Group')])
+
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
+
+        def verifyRendering(tree):
+            groupNodes = tree.findall('//select/optgroup')
+            groups = set(item.group for item in values)
+            self.assertEquals(len(groupNodes), len(groups))
+            for groupNode, item in zip(groupNodes, values):
+                self.assertEquals(groupNode.get('label'), item.group)
+
+                optionNodes = groupNode.findall('option')
+                self.assertEquals(len(optionNodes), len(list(values)))
+                for optionNode, innerItem in zip(optionNodes, values):
+                    self.assertEquals(optionNode.get('value'), innerItem.value)
+                    self.assertEquals(optionNode.text.strip(), innerItem.desc)
+
+        return renderWidget(control).addCallback(verifyRendering)
+
+
+    def test_renderObjectOptions(self):
+        """
+        If a C{SelectInput}'s values are an C{ObjectEnum} then the rendered
+        option values match the C{'id'} extra of the object enumeration.
+        """
+        object1 = object()
+        object2 = object()
+        values = ObjectEnum(
+            '',
+            [EnumItem(object1, u'Foo'),
+             EnumItem(object2, u'Bar', id=u'chuck')])
+
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
+
+        def verifyRendering(tree):
+            optionNodes = tree.findall('//option')
+            self.assertEquals(len(optionNodes), len(list(values)))
+            for optionNode, item in zip(optionNodes, values):
+                self.assertEquals(optionNode.get('value'), item.id)
+                self.assertEquals(optionNode.text.strip(), item.desc)
+
+        return renderWidget(control).addCallback(verifyRendering)
+
+
+    def test_getValueObjectEnum(self):
+        """
+        L{SelectInput.getValue} returns the C{'id'} extra value when backed by
+        an C{ObjectEnum}.
+        """
+        object1 = object()
+        object2 = object()
+        values = ObjectEnum(
+            '',
+            [EnumItem(object1, u'Foo'),
+             EnumItem(object2, u'Bar', id=u'chuck')])
+
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
+
+        param = control.parent.param
+
+        param.value = None
+        self.assertIdentical(control.getValue(), None)
+
+        for value in values:
+            param.value = value.value
+            self.assertEquals(control.getValue(), value.id)
+
+
+    def test_invokeObjectEnum(self):
+        """
+        When backed by an C{ObjectEnum}, L{SelectInput.invoke} sets the
+        parameter value to the Python object of L{EnumItem} with C{'id'} extra
+        matching the invocation data value and C{None} in the C{None} case.
+        """
+        object1 = object()
+        object2 = object()
+        values = ObjectEnum(
+            '',
+            [EnumItem(object1, u'Foo'),
+             EnumItem(object2, u'Bar', id=u'chuck')])
+
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
+
+        param = control.parent.param
+        data = {param.name: None}
+        control.invoke(data)
+        self.assertIdentical(param.value, None)
+
+        for value in values:
+            data = {param.name: value.id}
+            control.invoke(data)
+            self.assertIdentical(param.value, value.value)
+
+
+    def test_invokeObjectEnumTrickery(self):
+        """
+        L{SelectInput.invoke} falls back to locating enumeration items by value
+        when no C{'id'} extra value matches. However, this can lead to leaking
+        information about the enumeration values in the case of objects such as
+        strings and integers. In case we fallback to an item with a C{'id'}
+        extra, even if it doesn't match, C{InvalidEnumItem} is raised.
+        """
+        object1 = object()
+        values = ObjectEnum(
+            '',
+            [EnumItem(object1,     u'Foo'),
+             EnumItem(u'password', u'Bar', id=u'chuck')])
+
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
+
+        param = control.parent.param
+
+        data = {param.name: u'password'}
+        self.assertRaises(errors.InvalidEnumItem,
+            control.invoke, data)
+
+
+
+class MultiValueChoiceInputTestsMixin(object):
+    """
+    Tests mixin for L{methanal.view.ChoiceInput}s that support multiple values.
+    """
+    values = [
+        (u'foo', u'Foo'),
+        (u'bar', u'Bar'),
+        (u'baz', u'Baz')]
+
+    def test_getValueNoValues(self):
+        """
+        Multi-value L{ChoiceInput}s return an empty list from C{getValue} when
+        the parameter is C{None}, or empty.
+        """
+        control = self.createControl(dict(values=self.values))
+
+        control.parent.param.value = None
+        self.assertEquals(control.getValue(), [])
+
+        control.parent.param.value = []
+        self.assertEquals(control.getValue(), [])
+
+
+    def test_getValue(self):
+        """
+        Multi-value L{ChoiceInput}s return a C{list} of the selected values
+        from C{getValue}.
+        """
+        control = self.createControl(dict(values=self.values))
+        param = control.parent.param
+
+        for value, desc in self.values:
+            param.value = [value]
+            self.assertEquals(
+                control.getValue(),
+                [value])
+
+        v1, v2 = [self.values[0][0], self.values[1][0]]
+        param.value = [v1, v2]
+        self.assertEquals(
+            control.getValue(),
+            [v1, v2])
+
+
+    def test_invokeNoValues(self):
+        """
+        Multi-value L{ChoiceInput}s set their parameter value to an empty list
+        when invoked with C{None}, or empty.
+        """
+        control = self.createControl(dict(values=self.values))
+        param = control.parent.param
+        control.invoke({param.name: None})
+        self.assertEquals(param.value, [])
+
+        control = self.createControl(dict(values=self.values))
+        param = control.parent.param
+        control.invoke({param.name: []})
+        self.assertEquals(param.value, [])
+
+
+    def test_invoke(self):
+        """
+        Multi-value L{ChoiceInput}s set their parameter value to a C{list}
+        containing the values of the invoked data.
+        """
+        control = self.createControl(dict(values=self.values))
+        param = control.parent.param
+
+        data = {param.name: None}
+        control.invoke(data)
+        self.assertEquals(param.value, [])
+
+        data = {param.name: [None]}
+        control.invoke(data)
+        self.assertEquals(param.value, [None])
+
+        for value, desc in self.values:
+            data = {param.name: [value]}
+            control.invoke(data)
+            self.assertEquals(param.value, [value])
+
+        v1, v2 = self.values[0][0], self.values[1][0]
+        data = {param.name: [v1, v2]}
+        control.invoke(data)
+        self.assertEquals(param.value, [v1, v2])
+
+
+    def test_invokeObjectEnum(self):
+        """
+        Invoking a multi-value L{ChoiceInput}s backed by an L{ObjectEnum} sets
+        their parameter value to a C{list} of objects referenced by ID in the
+        invocation data.
+        """
+        object1 = object()
+        values = ObjectEnum(
+            '',
+            [EnumItem(object1, u'Foo'),
+             EnumItem(u'buzz', u'Buzz', id=u'quux')])
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
+        param = control.parent.param
+
+        for value in values:
+            data = {param.name: [value.id]}
+            control.invoke(data)
+            self.assertEquals(param.value, [value.value])
+
+        vs = [v.value for v in values]
+        vIDs = [v.id for v in values]
+        data = {param.name: vIDs}
+        control.invoke(data)
+        self.assertEquals(param.value, vs)
+
+        data = {param.name: [u'buzz']}
+        self.assertRaises(errors.InvalidEnumItem, control.invoke, data)
+
+
+    def test_render(self):
+        """
+        Rendering the control raises no exceptions.
+        """
+        control = self.createControl(dict(values=self.values))
+        ds = []
+
+        def _render(value):
+            control.parent.param.value = value
+            ds.append(renderWidget(control))
+
+        _render(None)
+        for obj, desc in self.values:
+            _render([obj])
+        return gatherResults(ds)
+
+
+
+class MultiSelectInputTests(ChoiceInputTests, MultiValueChoiceInputTestsMixin):
+    controlType = view.MultiSelectInput
 
 
 
@@ -602,6 +881,18 @@
     """
     controlType = view.GroupedSelectInput
 
+    def test_createDeprecated(self):
+        """
+        Passing values that are not adaptable to IEnumeration are converted
+        to a C{list}, adapted to L{IEnumeration} and a warning is emitted.
+        """
+        # Not a list.
+        values = tuple([
+            (u'foo', u'Foo'),
+            (u'bar', u'Bar')])
+        self.createControl(dict(values=values))
+        self.assertEquals(len(self.flushWarnings()), 3)
+
 
     def test_renderOptions(self):
         """
@@ -611,7 +902,8 @@
         values = [(u'Group', [(u'foo', u'Foo'),
                               (u'bar', u'Bar')])]
 
-        control = self.createControl(dict(values=values))
+        control = self.createControl(
+            dict(values=values), checkExpectedValues=False)
 
         def verifyRendering(tree):
             groupNodes = tree.findall('//select/optgroup')
@@ -753,6 +1045,12 @@
 
 
 
+class MultiCheckboxInputTests(ChoiceInputTests,
+                              MultiValueChoiceInputTestsMixin):
+    controlType = view.MultiCheckboxInput
+
+
+
 class TestItem(Item):
     """
     A test Item with some attributes.

=== modified file 'methanal/themes/methanal-base/methanal-multicheck-input.html'
--- methanal/themes/methanal-base/methanal-multicheck-input.html	2007-05-19 19:13:54 +0000
+++ methanal/themes/methanal-base/methanal-multicheck-input.html	2010-07-13 11:45:57 +0000
@@ -1,6 +1,9 @@
 <div class="methanal-input methanal-control-multicheck" xmlns:nevow="http://nevow.com/ns/nevow/0.1" xmlns:athena="http://divmod.org/ns/athena/0.7" nevow:render="liveElement">
     <div class="methanal-multi-input">
         <nevow:invisible nevow:render="options">
+            <div class="methanal-choice-group" nevow:pattern="optgroup">
+                <h4><nevow:slot name="label" /></h4>
+            </div>
             <div nevow:pattern="option">
                 <label>
                     <input type="checkbox">

=== modified file 'methanal/themes/methanal-base/methanal-multiselect-input.html'
--- methanal/themes/methanal-base/methanal-multiselect-input.html	2009-09-09 01:56:42 +0000
+++ methanal/themes/methanal-base/methanal-multiselect-input.html	2010-07-13 11:45:57 +0000
@@ -5,11 +5,7 @@
             <optgroup nevow:pattern="optgroup">
                 <nevow:attr name="label"><nevow:slot name="label" /></nevow:attr>
             </optgroup>
-
-            <option nevow:pattern="option">
-                <nevow:attr name="value"><nevow:slot name="value" /></nevow:attr>
-                <nevow:slot name="description" />
-            </option>
+            <option nevow:pattern="option"><nevow:attr name="value"><nevow:slot name="value" /></nevow:attr><nevow:slot name="description" /></option>
         </nevow:invisible>
     </select>
     <div class="methanal-multiselect-selection">

=== modified file 'methanal/themes/methanal-base/methanal-radio-input.html'
--- methanal/themes/methanal-base/methanal-radio-input.html	2010-03-04 10:19:46 +0000
+++ methanal/themes/methanal-base/methanal-radio-input.html	2010-07-13 11:45:57 +0000
@@ -1,13 +1,16 @@
 <div class="methanal-input methanal-control-radio" xmlns:nevow="http://nevow.com/ns/nevow/0.1" xmlns:athena="http://divmod.org/ns/athena/0.7" nevow:render="liveElement">
     <div class="methanal-multi-input">
         <nevow:invisible nevow:render="options">
-        <div nevow:pattern="option">
-            <label><input type="radio"
-                ><athena:handler event="onchange" handler="onChange"></athena:handler
-                ><nevow:attr name="name"><nevow:slot name="name" /></nevow:attr
-                ><nevow:attr name="value"><nevow:slot name="value" /></nevow:attr
-            ></input><nevow:slot name="description" /></label>
-        </div>
+            <div class="methanal-choice-group" nevow:pattern="optgroup">
+                <h4><nevow:slot name="label" /></h4>
+            </div>
+            <div nevow:pattern="option">
+                <label><input type="radio"
+                    ><athena:handler event="onchange" handler="onChange"></athena:handler
+                    ><nevow:attr name="name"><nevow:slot name="name" /></nevow:attr
+                    ><nevow:attr name="value"><nevow:slot name="value" /></nevow:attr
+                ></input><nevow:slot name="description" /></label>
+            </div>
         </nevow:invisible>
     </div>
     <span class="methanal-error" id="error" />

=== modified file 'methanal/themes/methanal-base/methanal-select-input.html'
--- methanal/themes/methanal-base/methanal-select-input.html	2009-09-28 23:51:41 +0000
+++ methanal/themes/methanal-base/methanal-select-input.html	2010-07-13 11:45:57 +0000
@@ -5,7 +5,6 @@
             <optgroup nevow:pattern="optgroup">
                 <nevow:attr name="label"><nevow:slot name="label" /></nevow:attr>
             </optgroup>
-
             <option nevow:pattern="option"><nevow:attr name="value"><nevow:slot name="value" /></nevow:attr><nevow:slot name="description" /></option>
         </nevow:invisible>
     </select>

=== modified file 'methanal/view.py'
--- methanal/view.py	2010-07-09 13:50:30 +0000
+++ methanal/view.py	2010-07-13 11:45:57 +0000
@@ -1,3 +1,4 @@
+import itertools
 from warnings import warn
 
 from decimal import Decimal
@@ -16,6 +17,7 @@
 from xmantissa.ixmantissa import IWebTranslator
 from xmantissa.webtheme import ThemedElement
 
+from methanal import errors
 from methanal.imethanal import IEnumeration
 from methanal.model import ItemModel, Model, paramFromAttribute
 from methanal.util import getArgsDict
@@ -732,7 +734,9 @@
     Abstract input with multiple options.
 
     @type values: L{IEnumeration}
-    @ivar values: An enumeration to be used for choice options
+    @ivar values: An enumeration to be used for choice options. C{ChoiceInput}
+        will group enumeration values by their C{'group'} extra value, if one
+        exists.
     """
     def __init__(self, values, **kw):
         super(ChoiceInput, self).__init__(**kw)
@@ -744,23 +748,94 @@
         self.values = _values
 
 
+    def _makeOptions(self, pattern, enums):
+        """
+        Create "option" elements, based on C{pattern}, from C{enums}.
+        """
+        for enum in enums:
+            o = pattern()
+            o.fillSlots('value', enum.get('id', enum.value))
+            o.fillSlots('description', enum.desc)
+            yield o
+
+
     @renderer
     def options(self, req, tag):
         """
         Render all available options.
         """
-        option = tag.patternGenerator('option')
-        for value, description in self.values.asPairs():
-            o = option()
-            o.fillSlots('value', value)
-            o.fillSlots('description', description)
-            yield o
+        optionPattern = tag.patternGenerator('option')
+        groupPattern = tag.patternGenerator('optgroup')
+
+        groups = itertools.groupby(self.values, lambda e: e.get('group'))
+        for group, enums in groups:
+            options = self._makeOptions(optionPattern, enums)
+            if group is not None:
+                g = groupPattern()
+                g.fillSlots('label', group)
+                yield g[options]
+            else:
+                yield options
+
+
+    def _invokeOne(self, value):
+        if value:
+            item = self.values.find(id=value)
+            if item is None:
+                item = self.values.get(value)
+                # We got tricked into fetching an enumeration item by value
+                # instead of id.
+                if item.get('id') is not None:
+                    raise errors.InvalidEnumItem(value)
+            value = item.value
+        return value
+
+
+    def invoke(self, data):
+        """
+        Set the model parameter's value from form data.
+        """
+        value = data[self.param.name]
+        self.param.value = self._invokeOne(value)
+
+
+    def _getOneValue(self, value):
+        if value is None:
+            return None
+        item = self.values.get(value)
+        return item.get('id', item.value)
+
+
+    def getValue(self):
+        """
+        Get the model parameter's value.
+        """
+        return self._getOneValue(self.param.value)
 
 
 registerAdapter(ListEnumeration, list, IEnumeration)
 
 
 
+class MultiChoiceInputMixin(object):
+    """
+    A mixin for supporting multiple values in a L{ChoiceInput}.
+    """
+    def invoke(self, data):
+        value = data[self.param.name]
+        if value is None:
+            value = []
+        self.param.value = map(self._invokeOne, value)
+
+
+    def getValue(self):
+        if self.param.value is None:
+            return []
+        return map(self._getOneValue, self.param.value)
+
+
+
+# XXX: All his friends are deprecated, remove this too.
 class _ObjectChoiceMixinBase(object):
     """
     Common base class for L{ObjectChoiceMixin} and L{ObjectMultiChoiceMixin}.
@@ -784,6 +859,20 @@
         super(_ObjectChoiceMixinBase, self).__init__(values=objectIDs, **kw)
 
 
+    def invoke(self, data):
+        """
+        Set the model parameter's value from form data.
+        """
+        self.param.value = data[self.param.name]
+
+
+    def getValue(self):
+        """
+        Get the model parameter's value.
+        """
+        return self.param.value
+
+
     def encodeValue(self, value):
         """
         Encode a Python object's identifier as text.
@@ -814,6 +903,7 @@
 
 
 
+# XXX: All his friends are deprecated, remove this too.
 class ObjectChoiceMixin(_ObjectChoiceMixinBase):
     """
     A mixin for supporting arbitrary Python objects in a L{ChoiceInput}.
@@ -828,6 +918,7 @@
 
 
 
+# XXX: All his friends are deprecated, remove this too.
 class ObjectMultiChoiceMixin(_ObjectChoiceMixinBase):
     """
     A mixin for supporting many arbitrary Python objects in a L{ChoiceInput}.
@@ -850,17 +941,10 @@
     fragmentName = 'methanal-radio-input'
     jsClass = u'Methanal.View.RadioGroupInput'
 
-    @renderer
-    def options(self, req, tag):
-        """
-        Render all available options.
-        """
-        option = tag.patternGenerator('option')
-        for value, description in self.values.asPairs():
-            o = option()
+    def _makeOptions(self, pattern, enums):
+        options = super(RadioGroupInput, self)._makeOptions(pattern, enums)
+        for o in options:
             o.fillSlots('name', self.name)
-            o.fillSlots('value', value)
-            o.fillSlots('description', description)
             yield o
 
 
@@ -868,11 +952,15 @@
 class ObjectRadioGroupInput(ObjectChoiceMixin, RadioGroupInput):
     """
     Variant of L{RadioGroupInput} for arbitrary Python objects.
+
+    Deprecated. Use L{RadioGroupInput} with L{methanal.enums.ObjectEnum}.
     """
-
-
-
-class MultiCheckboxInput(ChoiceInput):
+ObjectRadioGroupInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
+    ObjectRadioGroupInput.__init__)
+
+
+
+class MultiCheckboxInput(MultiChoiceInputMixin, ChoiceInput):
     """
     Multiple-checkboxes input.
     """
@@ -884,7 +972,11 @@
 class ObjectMultiCheckboxInput(ObjectMultiChoiceMixin, MultiCheckboxInput):
     """
     Variant of L{MultiCheckboxInput} for arbitrary Python objects.
+
+    Deprecated. Use L{MultiCheckboxInput} with L{methanal.enums.ObjectEnum}.
     """
+ObjectMultiCheckboxInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
+    ObjectMultiCheckboxInput.__init__)
 
 
 
@@ -900,7 +992,11 @@
 class ObjectSelectInput(ObjectChoiceMixin, SelectInput):
     """
     Variant of L{SelectInput} for arbitrary Python objects.
+
+    Deprecated. Use L{SelectInput} with L{methanal.enums.ObjectEnum}.
     """
+ObjectSelectInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
+    ObjectSelectInput.__init__)
 
 
 
@@ -913,7 +1009,7 @@
 
 
 
-class MultiSelectInput(ChoiceInput):
+class MultiSelectInput(MultiChoiceInputMixin, ChoiceInput):
     """
     Multiple-selection list box input.
     """
@@ -925,7 +1021,11 @@
 class ObjectMultiSelectInput(ObjectMultiChoiceMixin, MultiSelectInput):
     """
     Variant of L{MultiSelectInput} for arbitrary Python objects.
+
+    Deprecated. Use L{MultiSelectInput} with L{methanal.enums.ObjectEnum}.
     """
+ObjectMultiSelectInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
+    ObjectMultiSelectInput.__init__)
 
 
 
@@ -938,27 +1038,23 @@
         (u'Group name', [(u'value', u'Description'),
                          ...]),
          ...)
+
+    Deprecated. Use L{methanal.view.SelectInput} with L{methanal.enums.Enum}
+    values with a C{'group'} extra value instead.
     """
-    @renderer
-    def options(self, req, tag):
-        option = tag.patternGenerator('option')
-        optgroup = tag.patternGenerator('optgroup')
-
-        for groupName, values in self.values.asPairs():
-            g = optgroup().fillSlots('label', groupName)
-            for value, description in values:
-                o = option()
-                o.fillSlots('value', value)
-                o.fillSlots('description', description)
-                g[o]
-            yield g
+GroupedSelectInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
+    GroupedSelectInput.__init__)
 
 
 
 class ObjectGroupedSelectInput(ObjectChoiceMixin, SelectInput):
     """
     Variant of L{GroupedSelectInput} for arbitrary Python objects.
+
+    Deprecated. Use L{SelectInput} with L{methanal.enums.ObjectEnum}.
     """
+ObjectGroupedSelectInput.__init__ = deprecated(Version('methanal', 0, 2, 1))(
+    ObjectGroupedSelectInput.__init__)