diff -r 61ca4732399b Lib/enum.py
--- a/Lib/enum.py	Wed Sep 04 14:30:16 2013 +0300
+++ b/Lib/enum.py	Wed Sep 04 06:34:14 2013 -0700
@@ -153,20 +153,21 @@ class EnumMeta(type):
             if not use_args:
                 enum_member = __new__(enum_class)
                 if not hasattr(enum_member, '_value_'):
                     enum_member._value_ = value
             else:
                 enum_member = __new__(enum_class, *args)
                 if not hasattr(enum_member, '_value_'):
                     enum_member._value_ = member_type(*args)
             value = enum_member._value_
             enum_member._name_ = member_name
+            enum_member.__objclass__ = enum_class
             enum_member.__init__(*args)
             # If another member with the same value was already defined, the
             # new member becomes an alias to the existing one.
             for name, canonical_member in enum_class._member_map_.items():
                 if canonical_member.value == enum_member._value_:
                     enum_member = canonical_member
                     break
             else:
                 # Aliases don't appear in member names (only in __members__).
                 enum_class._member_names_.append(member_name)
@@ -216,21 +217,21 @@ class EnumMeta(type):
         """
         if names is None:  # simple value lookup
             return cls.__new__(cls, value)
         # otherwise, functional API: we're creating a new Enum type
         return cls._create_(value, names, module=module, type=type)
 
     def __contains__(cls, member):
         return isinstance(member, cls) and member.name in cls._member_map_
 
     def __dir__(self):
-        return ['__class__', '__doc__', '__members__'] + self._member_names_
+        return ['__class__', '__doc__', '__members__', '__module__'] + self._member_names_
 
     @property
     def __members__(cls):
         """Returns a mapping of member name->value.
 
         This mapping lists all enum members, including aliases. Note that this
         is a read-only view of the internal mapping.
 
         """
         return MappingProxyType(cls._member_map_)
@@ -426,21 +427,22 @@ class Enum(metaclass=EnumMeta):
         raise ValueError("%s is not a valid %s" % (value, cls.__name__))
 
     def __repr__(self):
         return "<%s.%s: %r>" % (
                 self.__class__.__name__, self._name_, self._value_)
 
     def __str__(self):
         return "%s.%s" % (self.__class__.__name__, self._name_)
 
     def __dir__(self):
-        return (['__class__', '__doc__', 'name', 'value'])
+        added_behavior = [m for m in self.__class__.__dict__ if m[0] != '_']
+        return ['__class__', '__doc__', 'name', 'value'] + added_behavior
 
     def __eq__(self, other):
         if type(other) is self.__class__:
             return self is other
         return NotImplemented
 
     def __format__(self, format_spec):
         # mixed-in Enums should use the mixed-in type's __format__, otherwise
         # we can get strange results with the Enum name showing up instead of
         # the value
diff -r 61ca4732399b Lib/inspect.py
--- a/Lib/inspect.py	Wed Sep 04 14:30:16 2013 +0300
+++ b/Lib/inspect.py	Wed Sep 04 06:34:14 2013 -0700
@@ -314,21 +314,21 @@ def classify_class_attrs(cls):
     names = dir(cls)
     result = []
     for name in names:
         # Get the object associated with the name, and where it was defined.
         # Getting an obj from the __dict__ sometimes reveals more than
         # using getattr.  Static and class methods are dramatic examples.
         # Furthermore, some objects may raise an Exception when fetched with
         # getattr(). This is the case with some descriptors (bug #1785).
         # Thus, we only use getattr() as a last resort.
         homecls = None
-        for base in (cls,) + mro:
+        for base in (cls,) + mro + (type(cls),):
             if name in base.__dict__:
                 obj = base.__dict__[name]
                 homecls = base
                 break
         else:
             obj = getattr(cls, name)
             homecls = getattr(obj, "__objclass__", homecls)
 
         # Classify the object.
         if isinstance(obj, staticmethod):
diff -r 61ca4732399b Lib/test/test_enum.py
--- a/Lib/test/test_enum.py	Wed Sep 04 14:30:16 2013 +0300
+++ b/Lib/test/test_enum.py	Wed Sep 04 06:34:14 2013 -0700
@@ -91,31 +91,46 @@ class TestEnum(unittest.TestCase):
         from datetime import date
         class Holiday(date, Enum):
             NEW_YEAR = 2013, 1, 1
             IDES_OF_MARCH = 2013, 3, 15
         self.Holiday = Holiday
 
     def test_dir_on_class(self):
         Season = self.Season
         self.assertEqual(
             set(dir(Season)),
-            set(['__class__', '__doc__', '__members__',
+            set(['__class__', '__doc__', '__members__', '__module__',
                 'SPRING', 'SUMMER', 'AUTUMN', 'WINTER']),
             )
 
     def test_dir_on_item(self):
         Season = self.Season
         self.assertEqual(
             set(dir(Season.WINTER)),
             set(['__class__', '__doc__', 'name', 'value']),
             )
 
+    def test_dir_with_added_behavior(self):
+        class Test(Enum):
+            this = 'that'
+            these = 'those'
+            def wowser(self):
+                return ("Wowser! I'm %s!" % self.name)
+        self.assertEqual(
+                set(dir(Test)),
+                set(['__class__', '__doc__', '__members__', '__module__', 'this', 'these']),
+                )
+        self.assertEqual(
+                set(dir(Test.this)),
+                set(['__class__', '__doc__', 'name', 'value', 'wowser']),
+                )
+
     def test_enum_in_enum_out(self):
         Season = self.Season
         self.assertIs(Season(Season.WINTER), Season.WINTER)
 
     def test_enum_value(self):
         Season = self.Season
         self.assertEqual(Season.SPRING.value, 1)
 
     def test_intenum_value(self):
         self.assertEqual(IntStooges.CURLY.value, 2)