Use descriptors.

Lib/test/test_datetime.py

@@ -446,9 +446,9 @@ class TestTimeDelta(HarmlessMixedComparison):
     def test_subclass_timedelta(self):
 
         class T(timedelta):
+            @staticmethod
             def from_td(td):
                 return T(td.days, td.seconds, td.microseconds)
-            from_td = staticmethod(from_td)
 
             def as_hours(self):
                 sum = (self.days * 24 +

Lib/test/test_descr.py

@@ -691,13 +691,13 @@ def metaclass():
     class _instance(object):
         pass
     class M2(object):
+        @staticmethod
         def __new__(cls, name, bases, dict):
             self = object.__new__(cls)
             self.name = name
             self.bases = bases
             self.dict = dict
             return self
-        __new__ = staticmethod(__new__)
         def __call__(self):
             it = _instance()
             # Early binding of methods
@@ -2071,9 +2071,9 @@ def supers():
         aProp = property(lambda self: "foo")
 
     class Sub(Base):
+        @classmethod
         def test(klass):
             return super(Sub,klass).aProp
-        test = classmethod(test)
 
     veris(Sub.test(), Base.aProp)
 

Lib/test/test_descrtut.py

@@ -246,9 +246,9 @@ static methods in C++ or Java. Here's an example:
 
     >>> class C:
     ...
+    ...     @staticmethod
     ...     def foo(x, y):
     ...         print "staticmethod", x, y
-    ...     foo = staticmethod(foo)
 
     >>> C.foo(1, 2)
     staticmethod 1 2
@@ -260,9 +260,9 @@ Class methods use a similar pattern to declare methods that receive an
 implicit first argument that is the *class* for which they are invoked.
 
     >>> class C:
+    ...     @classmethod
     ...     def foo(cls, y):
     ...         print "classmethod", cls, y
-    ...     foo = classmethod(foo)
 
     >>> C.foo(1)
     classmethod test.test_descrtut.C 1
@@ -286,10 +286,10 @@ call, not the class involved in the definition of foo().
 But notice this:
 
     >>> class E(C):
+    ...     @classmethod
     ...     def foo(cls, y): # override C.foo
     ...         print "E.foo() called"
     ...         C.foo(y)
-    ...     foo = classmethod(foo)
 
     >>> E.foo(1)
     E.foo() called

Lib/test/test_doctest2.py

@@ -80,6 +80,7 @@ class C(object):
         -12
         """)
 
+    @staticmethod
     def statm():
         """
         A static method.
@@ -91,8 +92,7 @@ class C(object):
         """
         return 666
 
-    statm = staticmethod(statm)
+    @classmethod
-
     def clsm(cls, val):
         """
         A class method.
@@ -104,8 +104,6 @@ class C(object):
         """
         return val
 
-    clsm = classmethod(clsm)
-
 def test_main():
     from test import test_doctest2
     EXPECTED = 19

Lib/test/test_userdict.py

@@ -191,12 +191,12 @@ class SeqDict(UserDict.DictMixin):
         for key, value in self.iteritems():
             d[key] = value
         return d
+    @classmethod
     def fromkeys(cls, keys, value=None):
         d = cls()
         for key in keys:
             d[key] = value
         return d
-    fromkeys = classmethod(fromkeys)
 
 class UserDictMixinTest(mapping_tests.TestMappingProtocol):
     type2test = SeqDict