--- a/genshi/core.py
+++ b/genshi/core.py
@@ -644,6 +644,9 @@
         return QName(self.uri + u'}' + name)
     __getattr__ = __getitem__
 
+    def __hash__(self):
+        return hash(self.uri)
+
     def __repr__(self):
         return '<Namespace "%s">' % self.uri
 

--- a/genshi/filters/transform.py
+++ b/genshi/filters/transform.py
@@ -1037,7 +1037,7 @@
 
     def _inject(self):
         content = self.content
-        if callable(content):
+        if hasattr(content, '__call__'):
             content = content()
         for event in _ensure(content):
             yield None, event
@@ -1170,7 +1170,7 @@
 
         :param stream: The marked event stream to filter
         """
-        callable_value = callable(self.value)
+        callable_value = hasattr(self.value, '__call__')
         for mark, (kind, data, pos) in stream:
             if mark is ENTER:
                 if callable_value:

--- a/genshi/template/eval.py
+++ b/genshi/template/eval.py
@@ -18,6 +18,7 @@
 from compiler.pycodegen import ExpressionCodeGenerator, ModuleCodeGenerator
 import new
 from textwrap import dedent
+from types import CodeType
 
 from genshi.core import Markup
 from genshi.template.base import TemplateRuntimeError
@@ -446,7 +447,7 @@
 
     # We'd like to just set co_firstlineno, but it's readonly. So we need to
     # clone the code object while adjusting the line number
-    return new.code(0, code.co_nlocals, code.co_stacksize,
+    return CodeType(0, code.co_nlocals, code.co_stacksize,
                     code.co_flags | 0x0040, code.co_code, code.co_consts,
                     code.co_names, code.co_varnames, filename, name, lineno,
                     code.co_lnotab, (), ())

--- a/genshi/template/interpolation.py
+++ b/genshi/template/interpolation.py
@@ -44,7 +44,7 @@
     string.
     
     >>> for kind, data, pos in interpolate("hey ${foo}bar"):
-    ...     print kind, `data`
+    ...     print kind, repr(data)
     TEXT u'hey '
     EXPR Expression('foo')
     TEXT u'bar'

--- a/genshi/template/loader.py
+++ b/genshi/template/loader.py
@@ -124,7 +124,7 @@
         self.default_class = default_class or MarkupTemplate
         self.variable_lookup = variable_lookup
         self.allow_exec = allow_exec
-        if callback is not None and not callable(callback):
+        if callback is not None and not hasattr(callback, '__call__'):
             raise TypeError('The "callback" parameter needs to be callable')
         self.callback = callback
         self._cache = LRUCache(max_cache_size)

--- a/genshi/template/plugin.py
+++ b/genshi/template/plugin.py
@@ -57,7 +57,7 @@
                                      options.get('genshi.max_cache_size'))
 
         loader_callback = options.get('genshi.loader_callback', None)
-        if loader_callback and not callable(loader_callback):
+        if loader_callback and not hasattr(loader_callback, '__call__'):
             raise ConfigurationError('loader callback must be a function')
 
         lookup_errors = options.get('genshi.lookup_errors', 'strict')

--- a/genshi/template/tests/eval.py
+++ b/genshi/template/tests/eval.py
@@ -195,8 +195,9 @@
     def test_compare_ne(self):
         self.assertEqual(False, Expression("1 != 1").evaluate({}))
         self.assertEqual(False, Expression("x != y").evaluate({'x': 1, 'y': 1}))
-        self.assertEqual(False, Expression("1 <> 1").evaluate({}))
-        self.assertEqual(False, Expression("x <> y").evaluate({'x': 1, 'y': 1}))
+        if sys.version < '3':
+            self.assertEqual(False, Expression("1 <> 1").evaluate({}))
+            self.assertEqual(False, Expression("x <> y").evaluate({'x': 1, 'y': 1}))
 
     def test_compare_lt(self):
         self.assertEqual(True, Expression("1 < 2").evaluate({}))
@@ -241,11 +242,9 @@
         self.assertEqual(42, expr.evaluate({'foo': foo, 'bar': {"x": 42}}))
 
     def test_lambda(self):
-        data = {'items': [{'name': 'b', 'value': 0}, {'name': 'a', 'value': 1}],
-                'sorted': sorted}
-        expr = Expression("sorted(items, lambda a, b: cmp(a.name, b.name))")
-        self.assertEqual([{'name': 'a', 'value': 1}, {'name': 'b', 'value': 0}],
-                         expr.evaluate(data))
+        data = {'items': range(5)}
+        expr = Expression("filter(lambda x: x > 2, items)")
+        self.assertEqual([3, 4], expr.evaluate(data))
 
     def test_list_comprehension(self):
         expr = Expression("[n for n in numbers if n < 2]")
@@ -695,7 +694,7 @@
     def test_delitem(self):
         d = {'k': 'foo'}
         Suite("del d['k']").execute({'d': d})
-        self.failIf('k' in d, `d`)
+        self.failIf('k' in d, repr(d))
 
 
 def suite():