[PATCH 2/3] Refactor usage of the "types" module out, per 2to3 -f types
"R. Tyler Ballance" <[email protected]> Mon, 9 Nov 2009 09:13:17 -0800
| Newsgroups | gmane.comp.python.cheetah |
|---|---|
| Message-ID | <[email protected]> |
Left out cheetah/Template.py which will need to be refactored
a bit more aggressively, particularly in Template.compile()
---
SetupTools.py | 12 +-
cheetah/DummyTransaction.py | 2 +-
cheetah/SettingsManager.py | 8 +-
cheetah/Templates/_SkeletonPage.py | 8 +-
cheetah/Tests/Misc.py | 20 +
cheetah/Tests/SyntaxAndOutput.py | 2 +-
cheetah/Tests/Test.py | 2 +
cheetah/Tests/VerifyType.py | 158 ------
cheetah/Tests/unittest_local_copy.py | 978 ----------------------------------
cheetah/Tools/MondoReport.py | 9 +-
cheetah/Utils/Misc.py | 22 +-
cheetah/Utils/VerifyType.py | 83 ---
cheetah/Utils/memcache.py | 11 +-
cheetah/c/_verifytype.c | 107 ----
14 files changed, 45 insertions(+), 1377 deletions(-)
create mode 100644 cheetah/Tests/Misc.py
delete mode 100644 cheetah/Tests/VerifyType.py
delete mode 100755 cheetah/Tests/unittest_local_copy.py
delete mode 100644 cheetah/Utils/VerifyType.py
delete mode 100644 cheetah/c/_verifytype.c
diff --git a/SetupTools.py b/SetupTools.py
index 096ee40..0f5377d 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 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/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 <[email protected]> (Sept 28th, 2001)
-
-- _TestTextResult.printErrorList(): print blank line after each traceback
-
--- Mike Orr <[email protected]> (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 <[email protected]>
-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 <[email protected]>"
-__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 <[email protected]>
-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 <[email protected]>"
-__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 <[email protected]>
- */
-#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
--
1.6.4.2
------------------------------------------------------------------------------
Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day
trial. Simplify your report design, integration and deployment - and focus on
what you do best, core application coding. Discover what's new with
Crystal Reports now. http://p.sf.net/sfu/bobj-july