had about all i can take for a while

11 files changed, 66 insertions, 35 deletions

diff --git a/pyramid/compat.py b/pyramid/compat.py
index 3a73b7e8f..a03fc893d 100644
--- a/pyramid/compat.py
+++ b/pyramid/compat.py
@@ -187,3 +187,12 @@ try:
 except:
     __pypy__ = None
 
+if PY3: # pragma: no cover
+    def is_nonstr_iter(v):
+        if isinstance(v, str):
+            return False
+        return hasattr(v, '__iter__')
+else:
+    def is_nonstr_iter(v):
+        return hasattr(v, '__iter__')
+    
diff --git a/pyramid/config/tweens.py b/pyramid/config/tweens.py
index 0cdc55e65..c7d50248f 100644
--- a/pyramid/config/tweens.py
+++ b/pyramid/config/tweens.py
@@ -2,6 +2,8 @@ from zope.interface import implementer
 
 from pyramid.interfaces import ITweens
 
+from pyramid.compat import string_types
+from pyramid.compat import is_nonstr_iter
 from pyramid.exceptions import ConfigurationError
 from pyramid.tweens import excview_tween_factory
 from pyramid.tweens import MAIN, INGRESS, EXCVIEW
@@ -110,7 +112,7 @@ class TweensConfiguratorMixin(object):
         tween_factory = self.maybe_dotted(tween_factory)
 
         def is_string_or_iterable(v):
-            if isinstance(v, basestring):
+            if isinstance(v, string_types):
                 return True
             if hasattr(v, '__iter__'):
                 return True
@@ -121,10 +123,10 @@ class TweensConfiguratorMixin(object):
                     raise ConfigurationError(
                         '"%s" must be a string or iterable, not %s' % (t, p))
 
-        if over is INGRESS or hasattr(over, '__iter__') and INGRESS in over:
+        if over is INGRESS or is_nonstr_iter(over) and INGRESS in over:
             raise ConfigurationError('%s cannot be over INGRESS' % name)
 
-        if under is MAIN or hasattr(under, '__iter__') and MAIN in under:
+        if under is MAIN or is_nonstr_iter(under) and MAIN in under:
             raise ConfigurationError('%s cannot be under MAIN' % name)
 
         registry = self.registry
@@ -176,12 +178,12 @@ class Tweens(object):
         if under is None and over is None:
             under = INGRESS
         if under is not None:
-            if not hasattr(under, '__iter__'):
+            if not is_nonstr_iter(under):
                 under = (under,)
             self.order += [(u, name) for u in under]
             self.req_under.add(name)
         if over is not None:
-            if not hasattr(over, '__iter__'):
+            if not is_nonstr_iter(over): #hasattr(over, '__iter__'):
                 over = (over,)
             self.order += [(name, o) for o in over]
             self.req_over.add(name)
diff --git a/pyramid/config/views.py b/pyramid/config/views.py
index d89431bda..51f13f69f 100644
--- a/pyramid/config/views.py
+++ b/pyramid/config/views.py
@@ -26,6 +26,7 @@ from pyramid.interfaces import IViewMapperFactory
 from pyramid.interfaces import PHASE1_CONFIG
 
 from pyramid import renderers
+from pyramid.compat import string_types
 from pyramid.compat import urlparse
 from pyramid.exceptions import ConfigurationError
 from pyramid.exceptions import PredicateMismatch
@@ -913,7 +914,7 @@ class ViewsConfiguratorMixin(object):
         if not IInterface.providedBy(r_context):
             r_context = implementedBy(r_context)
 
-        if isinstance(renderer, basestring):
+        if isinstance(renderer, string_types):
             renderer = renderers.RendererHelper(
                 name=renderer, package=self.package,
                 registry = self.registry)
diff --git a/pyramid/interfaces.py b/pyramid/interfaces.py
index a2b7990aa..5f7108e89 100644
--- a/pyramid/interfaces.py
+++ b/pyramid/interfaces.py
@@ -1,6 +1,8 @@
 from zope.interface import Attribute
 from zope.interface import Interface
 
+from pyramid.compat import PY3
+
 # public API interfaces
 
 class IContextFound(Interface):
@@ -292,25 +294,27 @@ class IDict(Interface):
         """ Return the value for key ``k`` from the renderer dictionary, or
         the default if no such value exists."""
 
-    has_key = __contains__
-
     def items():
         """ Return a list of [(k,v)] pairs from the dictionary """
 
-    def iteritems():
-        """ Return an iterator of (k,v) pairs from the dictionary """
-
     def keys():
         """ Return a list of keys from the dictionary """
 
-    def iterkeys():
-        """ Return an iterator of keys from the dictionary """
-
     def values():
         """ Return a list of values from the dictionary """
 
-    def itervalues():
-        """ Return an iterator of values from the dictionary """
+    if not PY3:
+
+        def iterkeys():
+            """ Return an iterator of keys from the dictionary """
+
+        def iteritems():
+            """ Return an iterator of (k,v) pairs from the dictionary """
+
+        def itervalues():
+            """ Return an iterator of values from the dictionary """
+
+        has_key = __contains__
 
     def pop(k, default=None):
         """ Pop the key k from the dictionary and return its value.  If k
diff --git a/pyramid/scaffolds/__init__.py b/pyramid/scaffolds/__init__.py
index a49bbd9f6..ef93a53c7 100644
--- a/pyramid/scaffolds/__init__.py
+++ b/pyramid/scaffolds/__init__.py
@@ -1,7 +1,16 @@
 import os
 
-from paste.script.templates import Template
-from paste.util.template import paste_script_template_renderer
+try:
+    from paste.script.templates import Template
+except ImportError:
+    class Template(object):
+        pass
+
+try:
+    from paste.util.template import paste_script_template_renderer
+except ImportError:
+    def paste_script_template_renderer(self):
+        pass
 
 class PyramidTemplate(Template):
     def pre(self, command, output_dir, vars):
diff --git a/pyramid/security.py b/pyramid/security.py
index a001f7073..4355737b7 100644
--- a/pyramid/security.py
+++ b/pyramid/security.py
@@ -5,6 +5,7 @@ from pyramid.interfaces import IAuthorizationPolicy
 from pyramid.interfaces import ISecuredView
 from pyramid.interfaces import IViewClassifier
 
+from pyramid.compat import map_
 from pyramid.threadlocal import get_current_registry
 
 Everyone = 'system.Everyone'
@@ -132,7 +133,7 @@ def view_execution_permitted(context, request, name=''):
         reg = request.registry
     except AttributeError:
         reg = get_current_registry() # b/c
-    provides = [IViewClassifier] + map(providedBy, (request, context))
+    provides = [IViewClassifier] + map_(providedBy, (request, context))
     view = reg.adapters.lookup(provides, ISecuredView, name=name)
     if view is None:
         return Allowed(
diff --git a/pyramid/session.py b/pyramid/session.py
index b5e40c65d..7d7edab1b 100644
--- a/pyramid/session.py
+++ b/pyramid/session.py
@@ -9,6 +9,7 @@ import os
 from zope.interface import implementer
 
 from pyramid.compat import pickle
+from pyramid.compat import PY3
 from pyramid.interfaces import ISession
 
 def manage_accessed(wrapped):
@@ -140,16 +141,18 @@ def UnencryptedCookieSessionFactoryConfig(
         get = manage_accessed(dict.get)
         __getitem__ = manage_accessed(dict.__getitem__)
         items = manage_accessed(dict.items)
-        iteritems = manage_accessed(dict.iteritems)
         values = manage_accessed(dict.values)
-        itervalues = manage_accessed(dict.itervalues)
         keys = manage_accessed(dict.keys)
-        iterkeys = manage_accessed(dict.iterkeys)
         __contains__ = manage_accessed(dict.__contains__)
-        has_key = manage_accessed(dict.has_key)
         __len__ = manage_accessed(dict.__len__)
         __iter__ = manage_accessed(dict.__iter__)
 
+        if not PY3:
+            iteritems = manage_accessed(dict.iteritems)
+            itervalues = manage_accessed(dict.itervalues)
+            iterkeys = manage_accessed(dict.iterkeys)
+            has_key = manage_accessed(dict.has_key)
+
         # modifying dictionary methods
         clear = manage_accessed(dict.clear)
         update = manage_accessed(dict.update)
diff --git a/pyramid/tests/test_httpexceptions.py b/pyramid/tests/test_httpexceptions.py
index fe3a79593..6a3ea7367 100644
--- a/pyramid/tests/test_httpexceptions.py
+++ b/pyramid/tests/test_httpexceptions.py
@@ -126,15 +126,15 @@ class TestWSGIHTTPException(unittest.TestCase):
 
     def test_ctor_with_body_doesnt_set_default_app_iter(self):
         exc = self._makeOne(body='123')
-        self.assertEqual(exc.app_iter, ['123'])
+        self.assertEqual(exc.app_iter, [b'123'])
 
     def test_ctor_with_unicode_body_doesnt_set_default_app_iter(self):
         exc = self._makeOne(unicode_body=text_('123'))
-        self.assertEqual(exc.app_iter, ['123'])
+        self.assertEqual(exc.app_iter, [b'123'])
 
     def test_ctor_with_app_iter_doesnt_set_default_app_iter(self):
-        exc = self._makeOne(app_iter=['123'])
-        self.assertEqual(exc.app_iter, ['123'])
+        exc = self._makeOne(app_iter=[b'123'])
+        self.assertEqual(exc.app_iter, [b'123'])
 
     def test_ctor_with_body_sets_default_app_iter_html(self):
         cls = self._getTargetSubclass()
diff --git a/pyramid/tests/test_request.py b/pyramid/tests/test_request.py
index 572f14f0b..f1338e331 100644
--- a/pyramid/tests/test_request.py
+++ b/pyramid/tests/test_request.py
@@ -372,8 +372,8 @@ class TestRequestDeprecatedMethods(unittest.TestCase):
     def test_values(self):
         environ = {'zooma':1}
         inst = self._makeOne(environ)
-        result = inst.values()
-        self.assertEqual(result, environ.values())
+        result = list(inst.values())
+        self.assertEqual(result, list(environ.values()))
 
     def test_response_content_type(self):
         inst = self._makeOne()
diff --git a/pyramid/tests/test_testing.py b/pyramid/tests/test_testing.py
index 919546a73..f428fa40a 100644
--- a/pyramid/tests/test_testing.py
+++ b/pyramid/tests/test_testing.py
@@ -132,7 +132,7 @@ class Test_registerView(TestBase):
         request = DummyRequest()
         request.registry = self.registry
         response = render_view_to_response(None, request, 'moo.html')
-        self.assertEqual(response.body, 'yo')
+        self.assertEqual(response.body, b'yo')
 
     def test_registerView_custom(self):
         from pyramid import testing
@@ -146,7 +146,7 @@ class Test_registerView(TestBase):
         request = DummyRequest()
         request.registry = self.registry
         response = render_view_to_response(None, request, 'moo.html')
-        self.assertEqual(response.body, '123')
+        self.assertEqual(response.body, b'123')
 
     def test_registerView_with_permission_denying(self):
         from pyramid import testing
@@ -188,7 +188,7 @@ class Test_registerView(TestBase):
         request = DummyRequest()
         request.registry = self.registry
         result = render_view_to_response(None, request, 'moo.html')
-        self.assertEqual(result.app_iter, ['123'])
+        self.assertEqual(result.app_iter, [b'123'])
 
 
 class Test_registerAdapter(TestBase):
@@ -380,9 +380,10 @@ class TestDummyResource(unittest.TestCase):
         resource = self._makeOne()
         resource['abc'] = Dummy()
         resource['def'] = Dummy()
-        self.assertEqual(resource.values(), resource.subs.values())
-        self.assertEqual(resource.items(), resource.subs.items())
-        self.assertEqual(resource.keys(), resource.subs.keys())
+        L = list
+        self.assertEqual(L(resource.values()), L(resource.subs.values()))
+        self.assertEqual(L(resource.items()), L(resource.subs.items()))
+        self.assertEqual(L(resource.keys()), L(resource.subs.keys()))
         self.assertEqual(len(resource), 2)
 
     def test_nonzero(self):
diff --git a/pyramid/tests/test_traversal.py b/pyramid/tests/test_traversal.py
index 6231c516b..6abaf403d 100644
--- a/pyramid/tests/test_traversal.py
+++ b/pyramid/tests/test_traversal.py
@@ -770,6 +770,7 @@ class QuotePathSegmentTests(unittest.TestCase):
         self.assertEqual(result, '12345')
         
     def test_long(self):
+        from pyramid.compat import long
         import sys
         s = long(sys.maxint + 1)
         result = self._callFUT(s)