Refactor usage of the "types" module out, per 2to3 -f types

Left out cheetah/Template.py which will need to be refactored
a bit more aggressively, particularly in Template.compile()

15 files changed, 49 insertions, 1379 deletions

diff --git a/SetupTools.py b/SetupTools.py
index 096ee40..788f81b 100644
--- a/SetupTools.py
+++ b/SetupTools.py
@@ -77,8 +77,8 @@ class mod_install_data(install_data):
         data_files = self.get_inputs()
         
         for entry in data_files:
-            if type(entry) != types.StringType:
-                raise ValueError, 'The entries in "data_files" must be strings'
+            if not isinstance(entry, basestring):
+                raise ValueError('The entries in "data_files" must be strings')
             
             entry = string.join(string.split(entry, '/'), os.sep)
             # entry is a filename or glob pattern
@@ -137,13 +137,7 @@ def run_setup(configurations):
     for configuration in configurations:
         kws.update(vars(configuration))
     for name, value in kws.items():
-        if name[:1] == '_' or \
-           type(value) not in (types.StringType,
-                               types.ListType,
-                               types.TupleType,
-                               types.DictType,
-                               types.IntType,
-                               ):
+        if name[:1] == '_' or not isinstance(value, (basestring, list, tuple, dict, int)):
             del kws[name]
 
     # Add setup extensions
diff --git a/cheetah/DummyTransaction.py b/cheetah/DummyTransaction.py
index f84ade4..72f8662 100644
--- a/cheetah/DummyTransaction.py
+++ b/cheetah/DummyTransaction.py
@@ -92,7 +92,7 @@ class TransformerResponse(DummyResponse):
         output = super(TransformerResponse, self).getvalue(**kwargs)
         if self._filter:
             _filter = self._filter
-            if isinstance(_filter, types.TypeType):
+            if isinstance(_filter, type):
                 _filter = _filter()
             return _filter.filter(output)
         return output
diff --git a/cheetah/SettingsManager.py b/cheetah/SettingsManager.py
index dfb396b..07c88a1 100644
--- a/cheetah/SettingsManager.py
+++ b/cheetah/SettingsManager.py
@@ -34,10 +34,8 @@ def mergeNestedDictionaries(dict1, dict2, copy=False, deepcopy=False):
     elif deepcopy:
         dict1 = copyModule.deepcopy(dict1)
         
-    for key,val in dict2.items():
-        if dict1.has_key(key) and type(val) == types.DictType and \
-           type(dict1[key]) == types.DictType:
-            
+    for key,val in dict2.iteritems():
+        if dict1.has_key(key) and isinstance(val, dict) and isinstance(dict1[key], dict):
             dict1[key] = mergeNestedDictionaries(dict1[key], val)
         else:
             dict1[key] = val
@@ -96,7 +94,7 @@ class _SettingsCollector(object):
         """
         S = {}
         attrs = vars(mod)
-        for k, v in attrs.items():
+        for k, v in attrs.iteritems():
             if (ignoreUnderscored and k.startswith('_')):
                 continue
             else:
diff --git a/cheetah/Templates/_SkeletonPage.py b/cheetah/Templates/_SkeletonPage.py
index 95a59a7..afb54b2 100644
--- a/cheetah/Templates/_SkeletonPage.py
+++ b/cheetah/Templates/_SkeletonPage.py
@@ -115,8 +115,8 @@ class _SkeletonPage(Template):
         SRC filename rather than a code string."""
         
         javascriptTagsTxt = []
-        for key, details in self._javascriptTags.items():
-            if type(details) not in (types.ListType, types.TupleType):
+        for key, details in self._javascriptTags.iteritems():
+            if not isinstance(details, (list, tuple)):
                 details = ['',details]
                 
             javascriptTagsTxt += ['<script language="JavaScript', str(details[0]),
@@ -124,8 +124,8 @@ class _SkeletonPage(Template):
                                   str(details[0]), '\n//--></script>\n']
 
 
-        for key, details in self._javascriptLibs.items():
-            if type(details) not in (types.ListType, types.TupleType):
+        for key, details in self._javascriptLibs.iteritems():
+            if not isinstance(details, (list, tuple)):
                 details = ['',details]
 
             javascriptTagsTxt += ['<script language="JavaScript', str(details[0]),
diff --git a/cheetah/Tests/Filters.py b/cheetah/Tests/Filters.py
index 9b3c7c2..65b3d93 100644
--- a/cheetah/Tests/Filters.py
+++ b/cheetah/Tests/Filters.py
@@ -1,12 +1,11 @@
 #!/usr/bin/env python
 
 import sys
+import unittest
 
 import Cheetah.Template
 import Cheetah.Filters
 
-import unittest_local_copy as unittest 
-
 majorVer, minorVer = sys.version_info[0], sys.version_info[1]
 versionTuple = (majorVer, minorVer)
 
@@ -29,6 +28,9 @@ Header
             template = Cheetah.Template.Template(template, searchList=[{'foo' : 'bar'}])
             template = str(template)
             assert template == expected
+        except ImportError, ex:
+            print('>>> We probably failed to import markdown, bummer %s' % ex)
+            return
         except Exception, ex:
             if ex.__class__.__name__ == 'MarkdownException' and majorVer == 2 and minorVer < 5:
                 print('>>> NOTE: Support for the Markdown filter will be broken for you. Markdown says: %s' % ex)
diff --git a/cheetah/Tests/Misc.py b/cheetah/Tests/Misc.py
new file mode 100644
index 0000000..9ea66f0
--- /dev/null
+++ b/cheetah/Tests/Misc.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+import unittest
+
+from Cheetah import SettingsManager
+
+
+class SettingsManagerTests(unittest.TestCase):
+    def test_mergeDictionaries(self):
+        left = {'foo' : 'bar', 'abc' : {'a' : 1, 'b' : 2, 'c' : (3,)}}
+        right = {'xyz' : (10, 9)}
+        expect = {'xyz': (10, 9), 'foo': 'bar', 'abc': {'a': 1, 'c': (3,), 'b': 2}}
+
+        result = SettingsManager.mergeNestedDictionaries(left, right)
+        self.assertEquals(result, expect)
+
+
+if __name__ == '__main__':
+    unittest.main()
+
diff --git a/cheetah/Tests/SyntaxAndOutput.py b/cheetah/Tests/SyntaxAndOutput.py
index 6bd6963..0702ded 100644
--- a/cheetah/Tests/SyntaxAndOutput.py
+++ b/cheetah/Tests/SyntaxAndOutput.py
@@ -3199,7 +3199,7 @@ else:
     
 
 def install_eols():
-    klasses = [v for v in globals().values() if isinstance(v, (types.ClassType, types.TypeType)) and issubclass(v, unittest.TestCase)]
+    klasses = [v for v in globals().values() if isinstance(v, type) and issubclass(v, unittest.TestCase)]
     for klass in klasses:
         name = klass.__name__        
         if hasattr(klass,'convertEOLs') and klass.convertEOLs:
diff --git a/cheetah/Tests/Test.py b/cheetah/Tests/Test.py
index 13b0171..872de8e 100755
--- a/cheetah/Tests/Test.py
+++ b/cheetah/Tests/Test.py
@@ -15,6 +15,7 @@ import unittest
 
 import SyntaxAndOutput
 import NameMapper
+import Misc
 import Filters
 import Template
 import Cheps
@@ -32,6 +33,7 @@ suites = [
    #unittest.findTestCases(Cheps),
    unittest.findTestCases(Regressions),
    unittest.findTestCases(Unicode),
+   unittest.findTestCases(Misc),
 ]
 
 if not sys.platform.startswith('java'):
diff --git a/cheetah/Tests/VerifyType.py b/cheetah/Tests/VerifyType.py
deleted file mode 100644
index a581d70..0000000
--- a/cheetah/Tests/VerifyType.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env python 
-import unittest
-
-from Cheetah.Utils import VerifyType
-from Cheetah import _verifytype
-
-class VerifyType_Test(unittest.TestCase):
-    def test_Verified(self):
-        arg = 'foo'
-        legalTypes = [str, unicode]
-        try:
-            rc = VerifyType.VerifyType(arg, 'arg', legalTypes, 'string') 
-            assert rc
-        except TypeError:
-            self.fail('Should not have raised a TypeError here')
-
-        try:
-            rc = _verifytype.verifyType(arg, 'arg', legalTypes, 'string')
-            assert rc
-        except TypeError:
-            self.fail('Should not have raised a TypeError here')
-
-    def test_Unverified(self):
-        arg = 'foo'
-        legalTypes = [list, dict]
-        self.failUnlessRaises(TypeError, VerifyType.VerifyType, arg,
-                    'arg', legalTypes, 'list or dict')
-        self.failUnlessRaises(TypeError, _verifytype.verifyType, arg,
-                    'arg', legalTypes, 'list or dict')
-
-    def test_IncorrectNumberOfArgs(self):
-        arg = 'foo'
-        legalTypes = [str, unicode]
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyType)
-        self.failUnlessRaises(TypeError, _verifytype.verifyType)
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyType, arg)
-        self.failUnlessRaises(TypeError, _verifytype.verifyType, arg)
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyType, arg,
-                    'arg')
-        self.failUnlessRaises(TypeError, _verifytype.verifyType, arg,
-                    'arg')
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyType, arg,
-                    'arg', legalTypes)
-        self.failUnlessRaises(TypeError, _verifytype.verifyType, arg,
-                    'arg', legalTypes)
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyType, arg,
-                    'arg', legalTypes, 'string', 'errmsgExtra', 'one more')
-        self.failUnlessRaises(TypeError, _verifytype.verifyType, arg,
-                    'arg', legalTypes, 'string', 'errmsgExtra', 'one more')
-
-    def test_LegalTypesNotIterable(self):
-        arg = 'foo'
-        legalTypes = 1
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyType, arg,
-                    'arg', legalTypes, 'string')
-        self.failUnlessRaises(TypeError, _verifytype.verifyType, arg,
-                    'arg', legalTypes, 'string')
-
-class FakeClass(dict):
-    pass
-
-class VerifyTypeClass_Test(unittest.TestCase):
-    def test_VerifiedClass(self):
-        arg = FakeClass
-        legalTypes = [type]
-        try:
-            rc = VerifyType.VerifyTypeClass(arg, 'arg', legalTypes, '', dict) 
-            assert rc
-        except TypeError:
-            self.fail('Should not have raised a TypeError here')
-
-        try:
-            rc = _verifytype.verifyTypeClass(arg, 'arg', legalTypes, 'foo', dict)
-            assert rc
-        except TypeError:
-            self.fail('Should not have raised a TypeError here')
-
-    def test_UnverifiedClass(self):
-        arg = FakeClass
-        legalTypes = [type]
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    legalTypes, 'subclass of list', list)
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    legalTypes, 'subclass of list', list)
-
-    def test_Verified(self):
-        arg = 'foo'
-        legalTypes = [str, unicode]
-        try:
-            rc = VerifyType.VerifyTypeClass(arg, 'arg', legalTypes, 'string', int) 
-            assert rc
-        except TypeError:
-            self.fail('Should not have raised a TypeError here')
-
-        try:
-            rc = _verifytype.verifyTypeClass(arg, 'arg', legalTypes, 'string', int)
-            assert rc
-        except TypeError:
-            self.fail('Should not have raised a TypeError here')
-
-    def test_Unverified(self):
-        arg = 'foo'
-        legalTypes = [list, dict]
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    'arg', legalTypes, 'list or dict', int)
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    'arg', legalTypes, 'list or dict', int)
-
-    def test_IncorrectNumberOfArgs(self):
-        arg = 'foo'
-        legalTypes = [str, unicode]
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass)
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass)
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg)
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg)
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    'arg')
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    'arg')
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    'arg', legalTypes)
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    'arg', legalTypes)
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    'arg', legalTypes, 'string')
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    'arg', legalTypes, 'string')
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    'arg', legalTypes, 'string', int, 'errmsgExtra', 'one more')
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    'arg', legalTypes, 'string', int, 'errmsgExtra', 'one more')
-
-    def test_LegalTypesNotIterable(self):
-        arg = 'foo'
-        legalTypes = 1
-
-        self.failUnlessRaises(TypeError,  VerifyType.VerifyTypeClass, arg,
-                    'arg', legalTypes, 'string', int)
-        self.failUnlessRaises(TypeError, _verifytype.verifyTypeClass, arg,
-                    'arg', legalTypes, 'string', int)
-
-
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/cheetah/Tests/unittest_local_copy.py b/cheetah/Tests/unittest_local_copy.py
deleted file mode 100755
index 11d2d2c..0000000
--- a/cheetah/Tests/unittest_local_copy.py
+++ /dev/null
@@ -1,978 +0,0 @@
-#!/usr/bin/env python
-""" This is a hacked version of PyUnit that extends its reporting capabilities
-with optional meta data on the test cases.  It also makes it possible to
-separate the standard and error output streams in TextTestRunner.
-
-It's a hack rather than a set of subclasses because a) Steve had used double
-underscore private attributes for some things I needed access to, and b) the
-changes affected so many classes that it was easier just to hack it.
-
-The changes are in the following places:
-TestCase:
-   - minor refactoring of  __init__ and __call__ internals
-   - added some attributes and methods for storing and retrieving meta data
-
-_TextTestResult
-   - refactored the stream handling
-   - incorporated all the output code from TextTestRunner
-   - made the output of FAIL and ERROR information more flexible and
-     incorporated the new meta data from TestCase
-   - added a flag called 'explain' to __init__ that controls whether the new '
-     explanation'   meta data from TestCase is printed along with tracebacks
-   
-TextTestRunner
-   - delegated all output to _TextTestResult
-   - added 'err' and 'explain' to the __init__ signature to match the changes
-     in _TextTestResult
-   
-TestProgram
-   - added -e and --explain as flags on the command line
-
--- Tavis Rudd <tavis@redonions.net> (Sept 28th, 2001)
-
-- _TestTextResult.printErrorList(): print blank line after each traceback
-
--- Mike Orr <mso@oz.net> (Nov 11, 2002)
-
-TestCase methods copied from unittest in Python 2.3:
-  - .assertAlmostEqual(first, second, places=7, msg=None): to N decimal places.
-  - .failIfAlmostEqual(first, second, places=7, msg=None)
-
--- Mike Orr (Jan 5, 2004)
-
-
-Below is the original docstring for unittest.
----------------------------------------------------------------------------
-Python unit testing framework, based on Erich Gamma's JUnit and Kent Beck's
-Smalltalk testing framework.
-
-This module contains the core framework classes that form the basis of
-specific test cases and suites (TestCase, TestSuite etc.), and also a
-text-based utility class for running the tests and reporting the results
-(TextTestRunner).
-
-Simple usage:
-
-    import unittest
-
-    class IntegerArithmenticTestCase(unittest.TestCase):
-        def testAdd(self):  ## test method names begin 'test*'
-            self.assertEquals((1 + 2), 3)
-            self.assertEquals(0 + 1, 1)
-        def testMultiply(self);
-            self.assertEquals((0 * 10), 0)
-            self.assertEquals((5 * 8), 40)
-
-    if __name__ == '__main__':
-        unittest.main()
-
-Further information is available in the bundled documentation, and from
-
-  http://pyunit.sourceforge.net/
-
-Copyright (c) 1999, 2000, 2001 Steve Purcell
-This module is free software, and you may redistribute it and/or modify
-it under the same terms as Python itself, so long as this copyright message
-and disclaimer are retained in their original form.
-
-IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
-SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
-THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
-THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
-AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
-SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-"""
-
-__author__ = "Steve Purcell"
-__email__ = "stephen_purcell at yahoo dot com"
-__revision__ = "$Revision: 1.11 $"[11:-2]
-
-
-##################################################
-## DEPENDENCIES ##
-
-import os
-import re
-import string
-import sys
-import time
-import traceback
-import types
-import pprint
-
-##################################################
-## CONSTANTS & GLOBALS
-
-try:
-    True,False
-except NameError:
-    True, False = (1==1),(1==0)
-
-##############################################################################
-# Test framework core
-##############################################################################
-
-
-class TestResult:
-    """Holder for test result information.
-
-    Test results are automatically managed by the TestCase and TestSuite
-    classes, and do not need to be explicitly manipulated by writers of tests.
-
-    Each instance holds the total number of tests run, and collections of
-    failures and errors that occurred among those test runs. The collections
-    contain tuples of (testcase, exceptioninfo), where exceptioninfo is a
-    tuple of values as returned by sys.exc_info().
-    """
-    def __init__(self):
-        self.failures = []
-        self.errors = []
-        self.testsRun = 0
-        self.shouldStop = 0
-
-    def startTest(self, test):
-        "Called when the given test is about to be run"
-        self.testsRun = self.testsRun + 1
-
-    def stopTest(self, test):
-        "Called when the given test has been run"
-        pass
-
-    def addError(self, test, err):
-        "Called when an error has occurred"
-        self.errors.append((test, err))
-
-    def addFailure(self, test, err):
-        "Called when a failure has occurred"
-        self.failures.append((test, err))
-
-    def addSuccess(self, test):
-        "Called when a test has completed successfully"
-        pass
-
-    def wasSuccessful(self):
-        "Tells whether or not this result was a success"
-        return len(self.failures) == len(self.errors) == 0
-
-    def stop(self):
-        "Indicates that the tests should be aborted"
-        self.shouldStop = 1
-
-    def __repr__(self):
-        return "<%s run=%i errors=%i failures=%i>" % \
-               (self.__class__, self.testsRun, len(self.errors),
-                len(self.failures))
-        
-class TestCase:
-    """A class whose instances are single test cases.
-
-    By default, the test code itself should be placed in a method named
-    'runTest'.
-
-    If the fixture may be used for many test cases, create as
-    many test methods as are needed. When instantiating such a TestCase
-    subclass, specify in the constructor arguments the name of the test method
-    that the instance is to execute.
-
-    Test authors should subclass TestCase for their own tests. Construction
-    and deconstruction of the test's environment ('fixture') can be
-    implemented by overriding the 'setUp' and 'tearDown' methods respectively.
-
-    If it is necessary to override the __init__ method, the base class
-    __init__ method must always be called. It is important that subclasses
-    should not change the signature of their __init__ method, since instances
-    of the classes are instantiated automatically by parts of the framework
-    in order to be run.
-    """
-
-    # This attribute determines which exception will be raised when
-    # the instance's assertion methods fail; test methods raising this
-    # exception will be deemed to have 'failed' rather than 'errored'
-
-    failureException = AssertionError
-
-    # the name of the fixture.  Used for displaying meta data about the test
-    name = None
-    
-    def __init__(self, methodName='runTest'):
-        """Create an instance of the class that will use the named test
-        method when executed. Raises a ValueError if the instance does
-        not have a method with the specified name.
-        """
-        self._testMethodName = methodName
-        self._setupTestMethod()
-        self._setupMetaData()
-
-    def _setupTestMethod(self):
-        try:
-            self._testMethod = getattr(self, self._testMethodName)
-        except AttributeError:
-            raise ValueError, "no such test method in %s: %s" % \
-                  (self.__class__, self._testMethodName)
-        
-    ## meta data methods
-        
-    def _setupMetaData(self):
-        """Setup the default meta data for the test case:
-
-        - id: self.__class__.__name__ + testMethodName OR self.name + testMethodName
-        - description: 1st line of Class docstring + 1st line of method docstring
-        - explanation: rest of Class docstring + rest of method docstring
-        
-        """
-
-        
-        testDoc = self._testMethod.__doc__ or '\n'
-        testDocLines = testDoc.splitlines()
-        
-        testDescription = testDocLines[0].strip() 
-        if len(testDocLines) > 1:
-            testExplanation = '\n'.join(
-                [ln.strip() for ln in testDocLines[1:]]
-                ).strip()
-        else:
-            testExplanation = ''
-            
-        fixtureDoc = self.__doc__ or '\n'
-        fixtureDocLines = fixtureDoc.splitlines()
-        fixtureDescription = fixtureDocLines[0].strip()
-        if len(fixtureDocLines) > 1:
-            fixtureExplanation = '\n'.join(
-                [ln.strip() for ln in fixtureDocLines[1:]]
-                ).strip()
-        else:
-            fixtureExplanation = ''
-        
-        if not self.name:
-            self.name = self.__class__
-        self._id = "%s.%s" % (self.name, self._testMethodName)
-        
-        if not fixtureDescription:
-            self._description = testDescription
-        else:
-            self._description = fixtureDescription + ', ' + testDescription
-
-        if not fixtureExplanation:
-            self._explanation = testExplanation
-        else:
-            self._explanation = ['Fixture Explanation:',
-                                 '--------------------',
-                                 fixtureExplanation,
-                                 '',
-                                 'Test Explanation:',
-                                 '-----------------',
-                                 testExplanation
-                                 ]
-            self._explanation = '\n'.join(self._explanation)
-
-    def id(self):
-        return self._id
-
-    def setId(self, id):
-        self._id = id
-
-    def describe(self):
-        """Returns a one-line description of the test, or None if no
-        description has been provided.
-
-        The default implementation of this method returns the first line of
-        the specified test method's docstring.
-        """
-        return self._description
-
-    shortDescription = describe
-    
-    def setDescription(self, descr):
-        self._description = descr
-    
-    def explain(self):
-        return self._explanation
-
-    def setExplanation(self, expln):
-        self._explanation = expln
-
-    ## core methods
-
-    def setUp(self):
-        "Hook method for setting up the test fixture before exercising it."
-        pass
-    
-    def run(self, result=None):
-        return self(result)
-        
-    def tearDown(self):
-        "Hook method for deconstructing the test fixture after testing it."
-        pass
-
-    def debug(self):
-        """Run the test without collecting errors in a TestResult"""
-        self.setUp()
-        self._testMethod()
-        self.tearDown()
-
-    ## internal methods
-
-    def defaultTestResult(self):
-        return TestResult()
-    
-    def __call__(self, result=None):
-        if result is None:
-            result = self.defaultTestResult()
-        
-        result.startTest(self)
-        try:
-            try:
-                self.setUp()
-            except:
-                result.addError(self, self.__exc_info())
-                return
-            
-            ok = 0
-            try:
-                self._testMethod()
-                ok = 1
-            except self.failureException, e:
-                result.addFailure(self, self.__exc_info())
-            except:
-                result.addError(self, self.__exc_info())
-            try:
-                self.tearDown()
-            except:
-                result.addError(self, self.__exc_info())
-                ok = 0
-            if ok:
-                result.addSuccess(self)
-        finally:
-            result.stopTest(self)
-            
-        return result
-        
-    def countTestCases(self):
-        return 1
-       
-    def __str__(self):
-        return "%s (%s)" % (self._testMethodName, self.__class__)
-
-    def __repr__(self):
-        return "<%s testMethod=%s>" % \
-               (self.__class__, self._testMethodName)
-
-    def __exc_info(self):
-        """Return a version of sys.exc_info() with the traceback frame
-           minimised; usually the top level of the traceback frame is not
-           needed.
-        """
-        exctype, excvalue, tb = sys.exc_info()
-        if sys.platform[:4] == 'java': ## tracebacks look different in Jython
-            return (exctype, excvalue, tb)
-        newtb = tb.tb_next
-        if newtb is None:
-            return (exctype, excvalue, tb)
-        return (exctype, excvalue, newtb)
-
-    ## methods for use by the test cases
-
-    def fail(self, msg=None):
-        """Fail immediately, with the given message."""
-        raise self.failureException, msg
-
-    def failIf(self, expr, msg=None):
-        "Fail the test if the expression is true."
-        if expr: raise self.failureException, msg
-
-    def failUnless(self, expr, msg=None):
-        """Fail the test unless the expression is true."""
-        if not expr: raise self.failureException, msg
-
-    def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):
-        """Fail unless an exception of class excClass is thrown
-           by callableObj when invoked with arguments args and keyword
-           arguments kwargs. If a different type of exception is
-           thrown, it will not be caught, and the test case will be
-           deemed to have suffered an error, exactly as for an
-           unexpected exception.
-        """
-        try:
-            apply(callableObj, args, kwargs)
-        except excClass:
-            return
-        else:
-            if hasattr(excClass,'__name__'): excName = excClass.__name__
-            else: excName = str(excClass)
-            raise self.failureException, excName
-
-    def failUnlessEqual(self, first, second, msg=None):
-        """Fail if the two objects are unequal as determined by the '!='
-           operator.
-        """
-        if first != second:
-            raise self.failureException, (msg or '%s != %s' % (first, second))
-
-    def failIfEqual(self, first, second, msg=None):
-        """Fail if the two objects are equal as determined by the '=='
-           operator.
-        """
-        if first == second:
-            raise self.failureException, (msg or '%s == %s' % (first, second))
-
-    def failUnlessAlmostEqual(self, first, second, places=7, msg=None):
-        """Fail if the two objects are unequal as determined by their
-           difference rounded to the given number of decimal places
-           (default 7) and comparing to zero.
-
-           Note that decimal places (from zero) is usually not the same
-           as significant digits (measured from the most signficant digit).
-        """
-        if round(second-first, places) != 0:
-            raise self.failureException, \
-                  (msg or '%s != %s within %s places' % (`first`, `second`, `places` ))
-
-    def failIfAlmostEqual(self, first, second, places=7, msg=None):
-        """Fail if the two objects are equal as determined by their
-           difference rounded to the given number of decimal places
-           (default 7) and comparing to zero.
-
-           Note that decimal places (from zero) is usually not the same
-           as significant digits (measured from the most signficant digit).
-        """
-        if round(second-first, places) == 0:
-            raise self.failureException, \
-                  (msg or '%s == %s within %s places' % (`first`, `second`, `places`))
-
-    ## aliases
-
-    assertEqual = assertEquals = failUnlessEqual
-
-    assertNotEqual = assertNotEquals = failIfEqual
-
-    assertAlmostEqual = assertAlmostEquals = failUnlessAlmostEqual
-
-    assertNotAlmostEqual = assertNotAlmostEquals = failIfAlmostEqual
-
-    assertRaises = failUnlessRaises
-
-    assert_ = failUnless
-
-
-class FunctionTestCase(TestCase):
-    """A test case that wraps a test function.
-
-    This is useful for slipping pre-existing test functions into the
-    PyUnit framework. Optionally, set-up and tidy-up functions can be
-    supplied. As with TestCase, the tidy-up ('tearDown') function will
-    always be called if the set-up ('setUp') function ran successfully.
-    """
-
-    def __init__(self, testFunc, setUp=None, tearDown=None,
-                 description=None):
-        TestCase.__init__(self)
-        self.__setUpFunc = setUp
-        self.__tearDownFunc = tearDown
-        self.__testFunc = testFunc
-        self.__description = description
-
-    def setUp(self):
-        if self.__setUpFunc is not None:
-            self.__setUpFunc()
-
-    def tearDown(self):
-        if self.__tearDownFunc is not None:
-            self.__tearDownFunc()
-
-    def runTest(self):
-        self.__testFunc()
-
-    def id(self):
-        return self.__testFunc.__name__
-
-    def __str__(self):
-        return "%s (%s)" % (self.__class__, self.__testFunc.__name__)
-
-    def __repr__(self):
-        return "<%s testFunc=%s>" % (self.__class__, self.__testFunc)
-
-
-    def describe(self):
-        if self.__description is not None: return self.__description
-        doc = self.__testFunc.__doc__
-        return doc and string.strip(string.split(doc, "\n")[0]) or None
-    
-    ## aliases
-    shortDescription = describe
-
-class TestSuite:
-    """A test suite is a composite test consisting of a number of TestCases.
-
-    For use, create an instance of TestSuite, then add test case instances.
-    When all tests have been added, the suite can be passed to a test
-    runner, such as TextTestRunner. It will run the individual test cases
-    in the order in which they were added, aggregating the results. When
-    subclassing, do not forget to call the base class constructor.
-    """
-    def __init__(self, tests=(), suiteName=None):
-        self._tests = []
-        self._testMap = {}
-        self.suiteName = suiteName
-        self.addTests(tests)
-
-    def __repr__(self):
-        return "<%s tests=%s>" % (self.__class__, pprint.pformat(self._tests))
-
-    __str__ = __repr__
-
-    def countTestCases(self):
-        cases = 0
-        for test in self._tests:
-            cases = cases + test.countTestCases()
-        return cases
-
-    def addTest(self, test):
-        self._tests.append(test)
-        if isinstance(test, TestSuite) and test.suiteName:
-            name = test.suiteName
-        elif isinstance(test, TestCase):
-            #print test, test._testMethodName
-            name = test._testMethodName
-        else:
-            name = test.__class__.__name__
-        self._testMap[name] = test
-        
-    def addTests(self, tests):
-        for test in tests:
-            self.addTest(test)
-
-    def getTestForName(self, name):
-        return self._testMap[name]
-
-    def run(self, result):
-        return self(result)
-
-    def __call__(self, result):
-        for test in self._tests:
-            if result.shouldStop:
-                break
-            test(result)
-        return result
-
-    def debug(self):
-        """Run the tests without collecting errors in a TestResult"""
-        for test in self._tests: test.debug()
-
-
-##############################################################################
-# Text UI
-##############################################################################
-
-class StreamWrapper:
-    def __init__(self, out=sys.stdout, err=sys.stderr):
-        self._streamOut = out
-        self._streamErr = err
-
-    def write(self, txt):
-        self._streamOut.write(txt)
-        self._streamOut.flush()
-    
-    def writeln(self, *lines):
-        for line in lines:
-            self.write(line + '\n')
-        if not lines:
-            self.write('\n')
-
-    def writeErr(self, txt):
-        self._streamErr.write(txt)
-    
-    def writelnErr(self, *lines):
-        for line in lines:
-            self.writeErr(line + '\n')
-        if not lines:
-            self.writeErr('\n')
-
-
-class _TextTestResult(TestResult, StreamWrapper):
-    _separatorWidth = 70
-    _sep1 = '='
-    _sep2 = '-'
-    _errorSep1 = '*'
-    _errorSep2 = '-'
-    _errorSep3 = ''
-    
-    def __init__(self,
-                 stream=sys.stdout,
-                 errStream=sys.stderr,
-                 verbosity=1,
-                 explain=False):
-        
-        TestResult.__init__(self)
-        StreamWrapper.__init__(self, out=stream, err=errStream)        
-
-        self._verbosity = verbosity
-        self._showAll = verbosity > 1
-        self._dots = (verbosity == 1)
-        self._explain = explain
-
-    ## startup and shutdown methods
-        
-    def beginTests(self):
-        self._startTime = time.time()
-
-    def endTests(self):
-        self._stopTime = time.time()
-        self._timeTaken = float(self._stopTime - self._startTime)
-
-    def stop(self):
-        self.shouldStop = 1
-        
-    ## methods called for each test
-        
-    def startTest(self, test):
-        TestResult.startTest(self, test)
-        if self._showAll:
-            self.write("%s (%s)" %( test.id(), test.describe() ) )
-            self.write(" ... ")
-
-    def addSuccess(self, test):
-        TestResult.addSuccess(self, test)
-        if self._showAll:
-            self.writeln("ok")
-        elif self._dots:
-            self.write('.')
-
-    def addError(self, test, err):
-        TestResult.addError(self, test, err)
-        if self._showAll:
-            self.writeln("ERROR")
-        elif self._dots:
-            self.write('E')
-        if err[0] is KeyboardInterrupt:
-            self.stop()
-
-    def addFailure(self, test, err):
-        TestResult.addFailure(self, test, err)
-        if self._showAll:
-            self.writeln("FAIL")
-        elif self._dots:
-            self.write('F')
-
-    ## display methods
-
-    def summarize(self):
-        self.printErrors()
-        self.writeSep2()
-        run = self.testsRun
-        self.writeln("Ran %d test%s in %.3fs" %
-                            (run, run == 1 and "" or "s", self._timeTaken))
-        self.writeln()
-        if not self.wasSuccessful():
-            self.writeErr("FAILED (")
-            failed, errored = map(len, (self.failures, self.errors))
-            if failed:
-                self.writeErr("failures=%d" % failed)
-            if errored:
-                if failed: self.writeErr(", ")
-                self.writeErr("errors=%d" % errored)
-            self.writelnErr(")")
-        else:
-            self.writelnErr("OK")
-
-    def writeSep1(self):
-        self.writeln(self._sep1 * self._separatorWidth)
-
-    def writeSep2(self):
-        self.writeln(self._sep2 * self._separatorWidth)
-
-    def writeErrSep1(self):
-        self.writeln(self._errorSep1 * self._separatorWidth)
-
-    def writeErrSep2(self):
-        self.writeln(self._errorSep2 * self._separatorWidth)
-
-    def printErrors(self):
-        if self._dots or self._showAll:
-            self.writeln()
-        self.printErrorList('ERROR', self.errors)
-        self.printErrorList('FAIL', self.failures)
-
-    def printErrorList(self, flavour, errors):
-        for test, err in errors:
-            self.writeErrSep1()
-            self.writelnErr("%s %s (%s)" % (flavour, test.id(), test.describe() ))
-            if self._explain:
-                expln = test.explain()
-                if expln:
-                    self.writeErrSep2()
-                    self.writeErr( expln )
-                    self.writelnErr()
-
-            self.writeErrSep2()
-            for line in apply(traceback.format_exception, err):
-                for l in line.split("\n")[:-1]:
-                    self.writelnErr(l)
-            self.writelnErr("")
-
-class TextTestRunner:
-    def __init__(self, 
-                 stream=sys.stdout,
-                 errStream=sys.stderr,
-                 verbosity=1,
-                 explain=False):
-
-        self._out = stream
-        self._err = errStream
-        self._verbosity = verbosity
-        self._explain = explain
-        
-    ## main methods
-
-    def run(self, test):
-        result = self._makeResult()
-        result.beginTests()
-        test( result )
-        result.endTests()       
-        result.summarize()
-        
-        return result
-    
-    ## internal methods
-
-    def _makeResult(self):
-        return _TextTestResult(stream=self._out,
-                               errStream=self._err,
-                               verbosity=self._verbosity,
-                               explain=self._explain,
-                               )
-
-##############################################################################
-# Locating and loading tests
-##############################################################################
-
-class TestLoader:
-    """This class is responsible for loading tests according to various
-    criteria and returning them wrapped in a Test
-    """
-    testMethodPrefix = 'test'
-    sortTestMethodsUsing = cmp
-    suiteClass = TestSuite
-
-    def loadTestsFromTestCase(self, testCaseClass):
-        """Return a suite of all tests cases contained in testCaseClass"""
-        return self.suiteClass(tests=map(testCaseClass,
-                                         self.getTestCaseNames(testCaseClass)),
-                               suiteName=testCaseClass.__name__)
-
-    def loadTestsFromModule(self, module):
-        """Return a suite of all tests cases contained in the given module"""
-        tests = []
-        for name in dir(module):
-            obj = getattr(module, name)
-            if type(obj) == types.ClassType and issubclass(obj, TestCase):
-                tests.append(self.loadTestsFromTestCase(obj))
-        return self.suiteClass(tests)
-
-    def loadTestsFromName(self, name, module=None):
-        """Return a suite of all tests cases given a string specifier.
-
-        The name may resolve either to a module, a test case class, a
-        test method within a test case class, or a callable object which
-        returns a TestCase or TestSuite instance.
-
-        The method optionally resolves the names relative to a given module.
-        """
-        parts = string.split(name, '.')
-        if module is None:
-            if not parts:
-                raise ValueError, "incomplete test name: %s" % name
-            else:
-                parts_copy = parts[:]
-                while parts_copy:
-                    try:
-                        module = __import__(string.join(parts_copy,'.'))
-                        break
-                    except ImportError:
-                        del parts_copy[-1]
-                        if not parts_copy: raise
-                parts = parts[1:]
-        obj = module
-        for part in parts:
-            if isinstance(obj, TestSuite):
-                obj = obj.getTestForName(part)
-            else:
-                obj = getattr(obj, part)
-
-        if type(obj) == types.ModuleType:
-            return self.loadTestsFromModule(obj)
-        elif type(obj) == types.ClassType and issubclass(obj, TestCase):
-            return self.loadTestsFromTestCase(obj)
-        elif type(obj) == types.UnboundMethodType:
-            return obj.im_class(obj.__name__)
-        elif isinstance(obj, TestSuite):
-            return obj
-        elif isinstance(obj, TestCase):
-            return obj
-        elif callable(obj):
-            test = obj()
-            if not isinstance(test, TestCase) and \
-               not isinstance(test, TestSuite):
-                raise ValueError, \
-                      "calling %s returned %s, not a test" %(obj,test)
-            return test
-        else:
-            raise ValueError, "don't know how to make test from: %s" % obj
-
-    def loadTestsFromNames(self, names, module=None):
-        """Return a suite of all tests cases found using the given sequence
-        of string specifiers. See 'loadTestsFromName()'.
-        """
-        suites = []
-        for name in names:
-            suites.append(self.loadTestsFromName(name, module))
-        return self.suiteClass(suites)
-
-    def getTestCaseNames(self, testCaseClass):
-        """Return a sorted sequence of method names found within testCaseClass.
-        """
-        testFnNames = [fn for fn in dir(testCaseClass) if fn.startswith(self.testMethodPrefix)]
-        if hasattr(testCaseClass, 'runTest'):
-            testFnNames.append('runTest')
-        for baseclass in testCaseClass.__bases__:
-            for testFnName in self.getTestCaseNames(baseclass):
-                if testFnName not in testFnNames:  # handle overridden methods
-                    testFnNames.append(testFnName)
-        if self.sortTestMethodsUsing:
-            testFnNames.sort(self.sortTestMethodsUsing)
-        return testFnNames
-
-
-
-defaultTestLoader = TestLoader()
-
-
-##############################################################################
-# Patches for old functions: these functions should be considered obsolete
-##############################################################################
-
-def _makeLoader(prefix, sortUsing, suiteClass=None):
-    loader = TestLoader()
-    loader.sortTestMethodsUsing = sortUsing
-    loader.testMethodPrefix = prefix
-    if suiteClass: loader.suiteClass = suiteClass
-    return loader
-
-def getTestCaseNames(testCaseClass, prefix, sortUsing=cmp):
-    return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass)
-
-def makeSuite(testCaseClass, prefix='test', sortUsing=cmp, suiteClass=TestSuite):
-    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass)
-
-def findTestCases(module, prefix='test', sortUsing=cmp, suiteClass=TestSuite):
-    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module)
-
-##############################################################################
-# Facilities for running tests from the command line
-##############################################################################
-
-class TestProgram:
-    """A command-line program that runs a set of tests; this is primarily
-       for making test modules conveniently executable.
-    """
-    USAGE = """\
-Usage: %(progName)s [options] [test] [...]
-
-Options:
-  -h, --help       Show this message
-  -v, --verbose    Verbose output
-  -q, --quiet      Minimal output
-  -e, --expain     Output extra test details if there is a failure or error
-  
-Examples:
-  %(progName)s                               - run default set of tests
-  %(progName)s MyTestSuite                   - run suite 'MyTestSuite'
-  %(progName)s MyTestSuite.MyTestCase        - run suite 'MyTestSuite'
-  %(progName)s MyTestCase.testSomething      - run MyTestCase.testSomething
-  %(progName)s MyTestCase                    - run all 'test*' test methods
-                                               in MyTestCase
-"""
-    def __init__(self, module='__main__', defaultTest=None,
-                 argv=None, testRunner=None, testLoader=defaultTestLoader,
-                 testSuite=None):
-        if type(module) == type(''):
-            self.module = __import__(module)
-            for part in string.split(module,'.')[1:]:
-                self.module = getattr(self.module, part)
-        else:
-            self.module = module
-        if argv is None:
-            argv = sys.argv
-        self.test = testSuite
-        self.verbosity = 1
-        self.explain = 0
-        self.defaultTest = defaultTest
-        self.testRunner = testRunner
-        self.testLoader = testLoader
-        self.progName = os.path.basename(argv[0])
-        self.parseArgs(argv)
-        self.runTests()
-
-    def usageExit(self, msg=None):
-        if msg: print(msg)
-        print(self.USAGE % self.__dict__)
-        sys.exit(2)
-
-    def parseArgs(self, argv):
-        import getopt
-        try:
-            options, args = getopt.getopt(argv[1:], 'hHvqer',
-                                  ['help','verbose','quiet','explain', 'raise'])
-            for opt, value in options:
-                if opt in ('-h','-H','--help'):
-                    self.usageExit()
-                if opt in ('-q','--quiet'):
-                    self.verbosity = 0
-                if opt in ('-v','--verbose'):
-                    self.verbosity = 2
-                if opt in ('-e','--explain'):
-                    self.explain = True
-            if len(args) == 0 and self.defaultTest is None and self.test is None:
-                self.test = self.testLoader.loadTestsFromModule(self.module)
-                return
-            if len(args) > 0:
-                self.testNames = args
-            else:
-                self.testNames = (self.defaultTest,)
-            self.createTests()
-        except getopt.error, msg:
-            self.usageExit(msg)
-
-    def createTests(self):
-        if self.test == None:
-            self.test = self.testLoader.loadTestsFromNames(self.testNames,
-                                                           self.module)
-
-    def runTests(self):
-        if self.testRunner is None:
-            self.testRunner = TextTestRunner(verbosity=self.verbosity,
-                                             explain=self.explain)
-        result = self.testRunner.run(self.test)
-        self._cleanupAfterRunningTests()
-        sys.exit(not result.wasSuccessful())
-
-    def _cleanupAfterRunningTests(self):
-        """A hook method that is called immediately prior to calling
-        sys.exit(not result.wasSuccessful()) in self.runTests().
-        """
-        pass
-
-main = TestProgram
-
-
-##############################################################################
-# Executing this module from the command line
-##############################################################################
-
-if __name__ == "__main__":
-    main(module=None)
-
-# vim: shiftwidth=4 tabstop=4 expandtab
diff --git a/cheetah/Tools/MondoReport.py b/cheetah/Tools/MondoReport.py
index d0fada2..e8d34a4 100644
--- a/cheetah/Tools/MondoReport.py
+++ b/cheetah/Tools/MondoReport.py
@@ -12,7 +12,7 @@ next.query.
 
 How about Report: .page(), .all(), .summary()?  Or PageBreaker.
 """
-import operator, types
+import operator
 try:
     from Cheetah.NameMapper import valueForKey as lookup_func
 except ImportError:
@@ -22,18 +22,13 @@ except ImportError:
         else:
             return obj[name] # Raises KeyError.
 
-########## CONSTANTS ##############################
-
-True, False = (1==1), (1==0)
-numericTypes = types.IntType, types.LongType, types.FloatType
-
 ########## PUBLIC GENERIC FUNCTIONS ##############################
 
 class NegativeError(ValueError):
     pass
 
 def isNumeric(v):
-    return type(v) in numericTypes
+    return isinstance(v, (int, float))
 
 def isNonNegative(v):
     ret = isNumeric(v)
diff --git a/cheetah/Utils/Misc.py b/cheetah/Utils/Misc.py
index 6ff5bb2..81949d1 100644
--- a/cheetah/Utils/Misc.py
+++ b/cheetah/Utils/Misc.py
@@ -1,20 +1,8 @@
-# $Id: Misc.py,v 1.8 2005/11/02 22:26:08 tavis_rudd Exp $
-"""Miscellaneous functions/objects used by Cheetah but also useful standalone.
-
-Meta-Data
-================================================================================
-Author: Mike Orr <iron@mso.oz.net>
-License: This software is released for unlimited distribution under the
-         terms of the MIT license.  See the LICENSE file.
-Version: $Revision: 1.8 $
-Start Date: 2001/11/07
-Last Revision Date: $Date: 2005/11/02 22:26:08 $
+#!/usr/bin/env python
+"""
+    Miscellaneous functions/objects used by Cheetah but also useful standalone.
 """ 
-__author__ = "Mike Orr <iron@mso.oz.net>"
-__revision__ = "$Revision: 1.8 $"[11:-2]
-
 import os          # Used in mkdirsWithPyInitFile.
-import types       # Used in useOrRaise.
 import sys         # Used in die.
 
 ##################################################
@@ -29,7 +17,7 @@ def useOrRaise(thing, errmsg=''):
 
     Called by: Cheetah.Servlet.cgiImport()
     """
-    if type(thing) == types.ClassType and issubclass(thing, Exception):
+    if isinstance(thing, type) and issubclass(thing, Exception):
         raise thing(errmsg)
     return thing
 
@@ -76,6 +64,4 @@ def mkdirsWithPyInitFiles(path):
         f = open(init, 'w') # Open and close to produce empty file.
         f.close()
 
-
-
 # vim: shiftwidth=4 tabstop=4 expandtab
diff --git a/cheetah/Utils/VerifyType.py b/cheetah/Utils/VerifyType.py
deleted file mode 100644
index 11a435d..0000000
--- a/cheetah/Utils/VerifyType.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# $Id: VerifyType.py,v 1.4 2005/11/02 22:26:08 tavis_rudd Exp $
-"""Functions to verify an argument's type
-
-Meta-Data
-================================================================================
-Author: Mike Orr <iron@mso.oz.net>
-License: This software is released for unlimited distribution under the
-         terms of the MIT license.  See the LICENSE file.
-Version: $Revision: 1.4 $
-Start Date: 2001/11/07
-Last Revision Date: $Date: 2005/11/02 22:26:08 $
-""" 
-__author__ = "Mike Orr <iron@mso.oz.net>"
-__revision__ = "$Revision: 1.4 $"[11:-2]
-
-##################################################
-## DEPENDENCIES
-
-import types       # Used in VerifyTypeClass.
-
-##################################################
-## PRIVATE FUNCTIONS
-
-def _errmsg(argname, ltd, errmsgExtra=''):
-    """Construct an error message.
-
-    argname, string, the argument name.
-    ltd, string, description of the legal types.
-    errmsgExtra, string, text to append to error mssage.
-    Returns: string, the error message.
-    """
-    if errmsgExtra:
-        errmsgExtra = '\n' + errmsgExtra
-    return "arg '%s' must be %s%s" % (argname, ltd, errmsgExtra)
-
-
-##################################################
-## TYPE VERIFICATION FUNCTIONS
-
-def VerifyType(arg, argname, legalTypes, ltd, errmsgExtra=''):
-    """Verify the type of an argument.
-    
-    arg, any, the argument.
-    argname, string, name of the argument.
-    legalTypes, list of type objects, the allowed types.
-    ltd, string, description of legal types (for error message).
-    errmsgExtra, string, text to append to error message.
-    Returns: None.
-    Exceptions: TypeError if 'arg' is the wrong type.
-    """
-    if type(arg) not in legalTypes:
-        m = _errmsg(argname, ltd, errmsgExtra)
-        raise TypeError(m)
-    return True
-
-
-def VerifyTypeClass(arg, argname, legalTypes, ltd, klass, errmsgExtra=''):
-    """Same, but if it's a class, verify it's a subclass of the right class.
-
-    arg, any, the argument.
-    argname, string, name of the argument.
-    legalTypes, list of type objects, the allowed types.
-    ltd, string, description of legal types (for error message).
-    klass, class, the parent class.
-    errmsgExtra, string, text to append to the error message.
-    Returns: None.
-    Exceptions: TypeError if 'arg' is the wrong type.
-    """
-    VerifyType(arg, argname, legalTypes, ltd, errmsgExtra)
-    # If no exception, the arg is a legal type.
-    if type(arg) == types.ClassType and not issubclass(arg, klass):
-        # Must test for "is class type" to avoid TypeError from issubclass().
-        m = _errmsg(argname, ltd, errmsgExtra)
-        raise TypeError(m)
-    return True
-
-# @@MO: Commented until we determine whether it's useful.
-#def VerifyClass(arg, argname, klass, ltd):
-#    """Same, but allow *only* a subclass of the right class.
-#    """
-#    VerifyTypeClass(arg, argname, [types.ClassType], ltd, klass)
-
-# vim: shiftwidth=4 tabstop=4 expandtab
diff --git a/cheetah/Utils/memcache.py b/cheetah/Utils/memcache.py
index 029f621..c535303 100644
--- a/cheetah/Utils/memcache.py
+++ b/cheetah/Utils/memcache.py
@@ -45,7 +45,6 @@ More detailed documentation is available in the L{Client} class.
 import sys
 import socket
 import time
-import types
 try:
     import cPickle as pickle
 except ImportError:
@@ -168,7 +167,7 @@ class Client:
                 self.buckets.append(server)
 
     def _get_server(self, key):
-        if type(key) == types.TupleType:
+        if isinstance(key, tuple):
             serverhash = key[0]
             key = key[1]
         else:
@@ -301,7 +300,7 @@ class Client:
         self._statlog(cmd)
 
         flags = 0
-        if isinstance(val, types.StringTypes):
+        if isinstance(val, str):
             pass
         elif isinstance(val, int):
             flags |= Client._FLAG_INTEGER
@@ -343,7 +342,7 @@ class Client:
             value = self._recv_value(server, flags, rlen)
             server.expect("END")
         except (_Error, socket.error), msg:
-            if type(msg) is types.TupleType:
+            if isinstance(msg, tuple):
                 msg = msg[1]
             server.mark_dead(msg)
             return None
@@ -451,7 +450,7 @@ class _Host:
     _DEAD_RETRY = 30  # number of seconds before retrying a dead server.
 
     def __init__(self, host, debugfunc=None):
-        if isinstance(host, types.TupleType):
+        if isinstance(host, tuple):
             host = host[0]
             self.weight = host[1]
         else:
@@ -562,7 +561,7 @@ if __name__ == "__main__":
     mc = Client(servers, debug=1)
 
     def to_s(val):
-        if not isinstance(val, types.StringTypes):
+        if not isinstance(val, str):
             return "%s (%s)" % (val, type(val))
         return "%s" % val
     def test_setget(key, val):
diff --git a/cheetah/c/_verifytype.c b/cheetah/c/_verifytype.c
deleted file mode 100644
index 6dadf22..0000000
--- a/cheetah/c/_verifytype.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * C-version of the src/Utils/VerifyType.py module.
- *
- * (c) 2009, R. Tyler Ballance <tyler@slide.com>
- */
-#include <Python.h>
-#if __STDC_VERSION__ >= 199901L
-#include <stdbool.h>
-#else
-typedef enum { false, true } bool;
-#endif
-
-#include "Cheetah.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static PyObject *_errorMessage(char *arg, char *legalTypes, char *extra)
-{
-    return PyString_FromFormat("Argument '%s' must be %s\n", arg, legalTypes);
-}
-
-static PyObject *py_verifytype(PyObject *self, PyObject *args, PyObject *kwargs)
-{
-    PyObject *argument, *legalTypes;
-    char *arg_string, *types_string, *extra;
-    PyObject *iterator, *item;
-    bool rc = false;
-    char *kwlist[] = {"argument", "argument_name", "legalType",
-                "types_string", "errmsgExtra", NULL};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsOs|s", kwlist, &argument, 
-                &arg_string, &legalTypes, &types_string, &extra))
-        return NULL;
-
-    iterator = PyObject_GetIter(legalTypes);
-    if (iterator == NULL) {
-        return NULL;
-    }
-
-    while (item = PyIter_Next(iterator)) {
-        if ((PyObject *)argument->ob_type == item) {
-            rc = true;
-            Py_DECREF(item);
-            break;
-        }
-        Py_DECREF(item);
-    }
-    Py_DECREF(iterator);
-
-    if (rc)
-        Py_RETURN_TRUE;
-
-    PyErr_SetObject(PyExc_TypeError, _errorMessage(arg_string,
-            types_string, extra));
-    return NULL;
-}
-
-static PyObject *py_verifytypeclass(PyObject *self, PyObject *args, PyObject *kwargs) 
-{
-    PyObject *argument, *legalTypes, *klass;
-    PyObject *verifyTypeArgs, *v;
-    char *arg_string, *types_string, *extra;
-    bool rc = false;
-
-    char *kwlist[] = {"argument", "argument_name", "legalTypes", 
-           "types_string", "klass", "errmsgExtra", NULL};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsOsO|s", kwlist, &argument,
-                &arg_string, &legalTypes, &types_string, &klass, &extra))
-        return NULL;
-
-    verifyTypeArgs = Py_BuildValue("OsOs", argument, arg_string, legalTypes, 
-            types_string);
-    v = py_verifytype(self, verifyTypeArgs, NULL);
-
-    if (v == NULL)
-        return NULL;
-    Py_DECREF(v);
-
-    if (PyClass_Check(argument) && (!PyClass_IsSubclass(argument, klass)) ) {
-        PyErr_SetObject(PyExc_TypeError, _errorMessage(arg_string,
-                types_string, extra));
-        return NULL;
-    }
-    Py_RETURN_TRUE;
-}
-
-static const char _verifytypedoc[] = "\
-\n\
-";
-static struct PyMethodDef _verifytype_methods[] = {
-    {"verifyType", (PyCFunction)py_verifytype, METH_VARARGS | METH_KEYWORDS, NULL},
-    {"verifyTypeClass", (PyCFunction)py_verifytypeclass, METH_VARARGS | METH_KEYWORDS, NULL},
-    {NULL}
-};
-
-PyMODINIT_FUNC init_verifytype()
-{
-    PyObject *module = Py_InitModule3("_verifytype", _verifytype_methods,
-            _verifytypedoc);
-}
-
-#ifdef __cplusplus
-}
-#endif