Merge branch 'rel_0_9'

Conflicts:
	lib/sqlalchemy/dialects/postgresql/hstore.py
	lib/sqlalchemy/util/__init__.py
	lib/sqlalchemy/util/compat.py

5 files changed, 258 insertions, 183 deletions

diff --git a/lib/sqlalchemy/util/__init__.py b/lib/sqlalchemy/util/__init__.py
index efeca6f1b..687abb39a 100644
--- a/lib/sqlalchemy/util/__init__.py
+++ b/lib/sqlalchemy/util/__init__.py
@@ -5,9 +5,12 @@
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 from .compat import callable, cmp, reduce,  \
-    threading, py3k, py2k, py3k_warning, jython, pypy, cpython, win32, set_types, \
+    threading, py3k, py2k, jython, pypy, cpython, win32, \
     pickle, dottedgetter, parse_qsl, namedtuple, next, WeakSet, reraise, \
-    raise_from_cause
+    raise_from_cause, text_type, string_types, int_types, binary_type, \
+    quote_plus, with_metaclass, print_, itertools_filterfalse, u, ue, b,\
+    unquote_plus, b64decode, b64encode, byte_buffer, itertools_filter,\
+    StringIO
 
 from ._collections import KeyedTuple, ImmutableContainer, immutabledict, \
     Properties, OrderedProperties, ImmutableProperties, OrderedDict, \
diff --git a/lib/sqlalchemy/util/_collections.py b/lib/sqlalchemy/util/_collections.py
index 8e61275e7..86a90828a 100644
--- a/lib/sqlalchemy/util/_collections.py
+++ b/lib/sqlalchemy/util/_collections.py
@@ -9,7 +9,8 @@
 import itertools
 import weakref
 import operator
-from .compat import threading
+from .compat import threading, itertools_filterfalse
+from . import py2k
 
 EMPTY_SET = frozenset()
 
@@ -142,7 +143,7 @@ class Properties(object):
         return len(self._data)
 
     def __iter__(self):
-        return self._data.itervalues()
+        return iter(list(self._data.values()))
 
     def __add__(self, other):
         return list(self) + list(other)
@@ -189,13 +190,13 @@ class Properties(object):
             return default
 
     def keys(self):
-        return self._data.keys()
+        return list(self._data)
 
     def values(self):
-        return self._data.values()
+        return list(self._data.values())
 
     def items(self):
-        return self._data.items()
+        return list(self._data.items())
 
     def has_key(self, key):
         return key in self._data
@@ -260,23 +261,55 @@ class OrderedDict(dict):
     def __iter__(self):
         return iter(self._list)
 
-    def values(self):
-        return [self[key] for key in self._list]
 
-    def itervalues(self):
-        return iter([self[key] for key in self._list])
+    if py2k:
+        def values(self):
+            return [self[key] for key in self._list]
 
-    def keys(self):
-        return list(self._list)
+        def keys(self):
+            return self._list
 
-    def iterkeys(self):
-        return iter(self.keys())
+        def itervalues(self):
+            return iter([self[key] for key in self._list])
 
-    def items(self):
-        return [(key, self[key]) for key in self.keys()]
+        def iterkeys(self):
+            return iter(self)
+
+        def iteritems(self):
+            return iter(self.items())
+
+        def items(self):
+            return [(key, self[key]) for key in self._list]
+    else:
+        def values(self):
+            #return (self[key] for key in self)
+            return (self[key] for key in self._list)
+
+        def keys(self):
+            #return iter(self)
+            return iter(self._list)
+
+        def items(self):
+            #return ((key, self[key]) for key in self)
+            return ((key, self[key]) for key in self._list)
+
+    _debug_iter = False
+    if _debug_iter:
+        # normally disabled to reduce function call
+        # overhead
+        def __iter__(self):
+            len_ = len(self._list)
+            for item in self._list:
+                yield item
+                assert len_ == len(self._list), \
+                   "Dictionary changed size during iteration"
+        def values(self):
+            return (self[key] for key in self)
+        def keys(self):
+            return iter(self)
+        def items(self):
+            return ((key, self[key]) for key in self)
 
-    def iteritems(self):
-        return iter(self.items())
 
     def __setitem__(self, key, object):
         if key not in self:
@@ -470,8 +503,8 @@ class IdentitySet(object):
 
         if len(self) > len(other):
             return False
-        for m in itertools.ifilterfalse(other._members.__contains__,
-                                        self._members.iterkeys()):
+        for m in itertools_filterfalse(other._members.__contains__,
+                                        iter(self._members.keys())):
             return False
         return True
 
@@ -491,8 +524,8 @@ class IdentitySet(object):
         if len(self) < len(other):
             return False
 
-        for m in itertools.ifilterfalse(self._members.__contains__,
-                                        other._members.iterkeys()):
+        for m in itertools_filterfalse(self._members.__contains__,
+                                        iter(other._members.keys())):
             return False
         return True
 
@@ -582,7 +615,7 @@ class IdentitySet(object):
         return result
 
     def _member_id_tuples(self):
-        return ((id(v), v) for v in self._members.itervalues())
+        return ((id(v), v) for v in self._members.values())
 
     def __xor__(self, other):
         if not isinstance(other, IdentitySet):
@@ -599,7 +632,7 @@ class IdentitySet(object):
         return self
 
     def copy(self):
-        return type(self)(self._members.itervalues())
+        return type(self)(iter(self._members.values()))
 
     __copy__ = copy
 
@@ -607,13 +640,13 @@ class IdentitySet(object):
         return len(self._members)
 
     def __iter__(self):
-        return self._members.itervalues()
+        return iter(self._members.values())
 
     def __hash__(self):
         raise TypeError('set objects are unhashable')
 
     def __repr__(self):
-        return '%s(%r)' % (type(self).__name__, self._members.values())
+        return '%s(%r)' % (type(self).__name__, list(self._members.values()))
 
 
 class WeakSequence(object):
@@ -623,7 +656,7 @@ class WeakSequence(object):
         )
 
     def __iter__(self):
-        return self._storage.itervalues()
+        return iter(self._storage.values())
 
     def __getitem__(self, index):
         try:
@@ -754,7 +787,7 @@ def flatten_iterator(x):
 
     """
     for elem in x:
-        if not isinstance(elem, basestring) and hasattr(elem, '__iter__'):
+        if not isinstance(elem, str) and hasattr(elem, '__iter__'):
             for y in flatten_iterator(elem):
                 yield y
         else:
diff --git a/lib/sqlalchemy/util/compat.py b/lib/sqlalchemy/util/compat.py
index 6905d6347..3bbce5dde 100644
--- a/lib/sqlalchemy/util/compat.py
+++ b/lib/sqlalchemy/util/compat.py
@@ -14,7 +14,6 @@ except ImportError:
     import dummy_threading as threading
 
 py32 = sys.version_info >= (3, 2)
-py3k_warning = getattr(sys, 'py3kwarning', False) or sys.version_info >= (3, 0)
 py3k = sys.version_info >= (3, 0)
 py2k = sys.version_info < (3, 0)
 jython = sys.platform.startswith('java')
@@ -22,32 +21,10 @@ pypy = hasattr(sys, 'pypy_version_info')
 win32 = sys.platform.startswith('win')
 cpython = not pypy and not jython  # TODO: something better for this ?
 
-if py3k_warning:
-    set_types = set
-elif sys.version_info < (2, 6):
-    import sets
-    set_types = set, sets.Set
-else:
-    # 2.6 deprecates sets.Set, but we still need to be able to detect them
-    # in user code and as return values from DB-APIs
-    ignore = ('ignore', None, DeprecationWarning, None, 0)
-    import warnings
-    try:
-        warnings.filters.insert(0, ignore)
-    except Exception:
-        import sets
-    else:
-        import sets
-        warnings.filters.remove(ignore)
 
-    set_types = set, sets.Set
+next = next
 
-if sys.version_info < (2, 6):
-    def next(iter):
-        return iter.next()
-else:
-    next = next
-if py3k_warning:
+if py3k:
     import pickle
 else:
     try:
@@ -55,44 +32,114 @@ else:
     except ImportError:
         import pickle
 
-if sys.version_info < (2, 6):
-    # emits a nasty deprecation warning
-    # in newer pythons
-    from cgi import parse_qsl
-else:
-    from urlparse import parse_qsl
+if py3k:
+    import builtins
+
+    from inspect import getfullargspec as inspect_getfullargspec
+    from urllib.parse import quote_plus, unquote_plus, parse_qsl
+    import configparser
+    from io import StringIO
 
-# Py3K
-#from inspect import getfullargspec as inspect_getfullargspec
-# Py2K
-from inspect import getargspec as inspect_getfullargspec
-# end Py2K
+    from io import BytesIO as byte_buffer
 
-if py3k_warning:
-    # they're bringing it back in 3.2.  brilliant !
-    def callable(fn):
-        return hasattr(fn, '__call__')
+
+    string_types = str,
+    binary_type = bytes
+    text_type = str
+    int_types = int,
+    iterbytes = iter
+
+    def u(s):
+        return s
+
+    def ue(s):
+        return s
+
+    def b(s):
+        return s.encode("latin-1")
+
+    if py32:
+        callable = callable
+    else:
+        def callable(fn):
+            return hasattr(fn, '__call__')
 
     def cmp(a, b):
         return (a > b) - (a < b)
 
     from functools import reduce
+
+    print_ = getattr(builtins, "print")
+
+    import_ = getattr(builtins, '__import__')
+
+    import itertools
+    itertools_filterfalse = itertools.filterfalse
+    itertools_filter = filter
+    itertools_imap = map
+
+    import base64
+    def b64encode(x):
+        return base64.b64encode(x).decode('ascii')
+    def b64decode(x):
+        return base64.b64decode(x.encode('ascii'))
+
 else:
+    from inspect import getargspec as inspect_getfullargspec
+    from urllib import quote_plus, unquote_plus
+    from urlparse import parse_qsl
+    import ConfigParser as configparser
+    from StringIO import StringIO
+    from cStringIO import StringIO as byte_buffer
+
+    string_types = basestring,
+    binary_type = str
+    text_type = unicode
+    int_types = int, long
+    def iterbytes(buf):
+        return (ord(byte) for byte in buf)
+
+    def u(s):
+        # this differs from what six does, which doesn't support non-ASCII
+        # strings - we only use u() with
+        # literal source strings, and all our source files with non-ascii
+        # in them (all are tests) are utf-8 encoded.
+        return unicode(s, "utf-8")
+
+    def ue(s):
+        return unicode(s, "unicode_escape")
+
+    def b(s):
+        return s
+
+    def import_(*args):
+        if len(args) == 4:
+            args = args[0:3] + ([str(arg) for arg in args[3]],)
+        return __import__(*args)
+
     callable = callable
     cmp = cmp
     reduce = reduce
 
-try:
-    from collections import namedtuple
-except ImportError:
-    def namedtuple(typename, fieldnames):
-        def __new__(cls, *values):
-            tup = tuple.__new__(cls, values)
-            for i, fname in enumerate(fieldnames):
-                setattr(tup, fname, tup[i])
-            return tup
-        tuptype = type(typename, (tuple, ), {'__new__': __new__})
-        return tuptype
+    import base64
+    b64encode = base64.b64encode
+    b64decode = base64.b64decode
+
+    def print_(*args, **kwargs):
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+        for arg in enumerate(args):
+            if not isinstance(arg, basestring):
+                arg = str(arg)
+            fp.write(arg)
+
+    import itertools
+    itertools_filterfalse = itertools.ifilterfalse
+    itertools_filter = itertools.ifilter
+    itertools_imap = itertools.imap
+
+
 
 try:
     from weakref import WeakSet
@@ -122,24 +169,8 @@ if win32 or jython:
 else:
     time_func = time.time
 
-
-if sys.version_info >= (2, 6):
-    from operator import attrgetter as dottedgetter
-else:
-    def dottedgetter(attr):
-        def g(obj):
-            for name in attr.split("."):
-                obj = getattr(obj, name)
-            return obj
-        return g
-
-# Adapted from six.py
-if py3k:
-    def b(s):
-        return s.encode("latin-1")
-else:
-    def b(s):
-        return s
+from collections import namedtuple
+from operator import attrgetter as dottedgetter
 
 
 if py3k:
@@ -150,19 +181,34 @@ if py3k:
             raise value.with_traceback(tb)
         raise value
 
-    def raise_from_cause(exception, exc_info):
+    def raise_from_cause(exception, exc_info=None):
+        if exc_info is None:
+            exc_info = sys.exc_info()
         exc_type, exc_value, exc_tb = exc_info
         reraise(type(exception), exception, tb=exc_tb, cause=exc_value)
 else:
     exec("def reraise(tp, value, tb=None, cause=None):\n"
             "    raise tp, value, tb\n")
 
-    def raise_from_cause(exception, exc_info):
+    def raise_from_cause(exception, exc_info=None):
         # not as nice as that of Py3K, but at least preserves
         # the code line where the issue occurred
+        if exc_info is None:
+            exc_info = sys.exc_info()
         exc_type, exc_value, exc_tb = exc_info
         reraise(type(exception), exception, tb=exc_tb)
 
+if py3k:
+    exec_ = getattr(builtins, 'exec')
+else:
+    def exec_(func_text, globals_, lcl=None):
+        if lcl is None:
+            exec('exec func_text in globals_')
+        else:
+            exec('exec func_text in globals_, lcl')
 
 
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
 
+    return meta("MetaBase", bases, {})
diff --git a/lib/sqlalchemy/util/deprecations.py b/lib/sqlalchemy/util/deprecations.py
index 34be4fbf8..e0dc168db 100644
--- a/lib/sqlalchemy/util/deprecations.py
+++ b/lib/sqlalchemy/util/deprecations.py
@@ -10,7 +10,7 @@ functionality."""
 from .. import exc
 import warnings
 import re
-from langhelpers import decorator
+from .langhelpers import decorator
 
 
 def warn_deprecated(msg, stacklevel=3):
diff --git a/lib/sqlalchemy/util/langhelpers.py b/lib/sqlalchemy/util/langhelpers.py
index d82aefdea..b0ff5b073 100644
--- a/lib/sqlalchemy/util/langhelpers.py
+++ b/lib/sqlalchemy/util/langhelpers.py
@@ -15,16 +15,14 @@ import re
 import sys
 import types
 import warnings
-from .compat import set_types, threading, \
-    callable, inspect_getfullargspec
 from functools import update_wrapper
 from .. import exc
 import hashlib
 from . import compat
 
 def md5_hex(x):
-    # Py3K
-    #x = x.encode('utf-8')
+    if compat.py3k:
+        x = x.encode('utf-8')
     m = hashlib.md5()
     m.update(x)
     return m.hexdigest()
@@ -77,8 +75,8 @@ def _unique_symbols(used, *bases):
     used = set(used)
     for base in bases:
         pool = itertools.chain((base,),
-                               itertools.imap(lambda i: base + str(i),
-                                              xrange(1000)))
+                               compat.itertools_imap(lambda i: base + str(i),
+                                              range(1000)))
         for sym in pool:
             if sym not in used:
                 used.add(sym)
@@ -94,8 +92,8 @@ def decorator(target):
     def decorate(fn):
         if not inspect.isfunction(fn):
             raise Exception("not a decoratable function")
-        spec = inspect_getfullargspec(fn)
-        names = tuple(spec[0]) + spec[1:3] + (fn.func_name,)
+        spec = compat.inspect_getfullargspec(fn)
+        names = tuple(spec[0]) + spec[1:3] + (fn.__name__,)
         targ_name, fn_name = _unique_symbols(names, 'target', 'fn')
 
         metadata = dict(target=targ_name, fn=fn_name)
@@ -104,7 +102,7 @@ def decorator(target):
         code = 'lambda %(args)s: %(target)s(%(fn)s, %(apply_kw)s)' % (
                 metadata)
         decorated = eval(code, {targ_name: target, fn_name: fn})
-        decorated.func_defaults = getattr(fn, 'im_func', fn).func_defaults
+        decorated.__defaults__ = getattr(fn, 'im_func', fn).__defaults__
         return update_wrapper(decorated, fn)
     return update_wrapper(decorate, target)
 
@@ -143,7 +141,7 @@ class PluginLoader(object):
 
     def register(self, name, modulepath, objname):
         def load():
-            mod = __import__(modulepath)
+            mod = compat.import_(modulepath)
             for token in modulepath.split(".")[1:]:
                 mod = getattr(mod, token)
             return getattr(mod, objname)
@@ -169,7 +167,7 @@ def get_cls_kwargs(cls, _set=None):
     ctr = cls.__dict__.get('__init__', False)
 
     has_init = ctr and isinstance(ctr, types.FunctionType) and \
-        isinstance(ctr.func_code, types.CodeType)
+        isinstance(ctr.__code__, types.CodeType)
 
     if has_init:
         names, has_kw = inspect_func_args(ctr)
@@ -192,7 +190,7 @@ try:
     from inspect import CO_VARKEYWORDS
 
     def inspect_func_args(fn):
-        co = fn.func_code
+        co = fn.__code__
         nargs = co.co_argcount
         names = co.co_varnames
         args = list(names[:nargs])
@@ -248,8 +246,8 @@ def format_argspec_plus(fn, grouped=True):
        'apply_pos': '(self, a, b, c, **d)'}
 
     """
-    if callable(fn):
-        spec = inspect_getfullargspec(fn)
+    if compat.callable(fn):
+        spec = compat.inspect_getfullargspec(fn)
     else:
         # we accept an existing argspec...
         spec = fn
@@ -261,22 +259,21 @@ def format_argspec_plus(fn, grouped=True):
     else:
         self_arg = None
 
-    # Py3K
-    #apply_pos = inspect.formatargspec(spec[0], spec[1],
-    #    spec[2], None, spec[4])
-    #num_defaults = 0
-    #if spec[3]:
-    #    num_defaults += len(spec[3])
-    #if spec[4]:
-    #    num_defaults += len(spec[4])
-    #name_args = spec[0] + spec[4]
-    # Py2K
-    apply_pos = inspect.formatargspec(spec[0], spec[1], spec[2])
-    num_defaults = 0
-    if spec[3]:
-        num_defaults += len(spec[3])
-    name_args = spec[0]
-    # end Py2K
+    if compat.py3k:
+        apply_pos = inspect.formatargspec(spec[0], spec[1],
+            spec[2], None, spec[4])
+        num_defaults = 0
+        if spec[3]:
+            num_defaults += len(spec[3])
+        if spec[4]:
+            num_defaults += len(spec[4])
+        name_args = spec[0] + spec[4]
+    else:
+        apply_pos = inspect.formatargspec(spec[0], spec[1], spec[2])
+        num_defaults = 0
+        if spec[3]:
+            num_defaults += len(spec[3])
+        name_args = spec[0]
 
     if num_defaults:
         defaulted_vals = name_args[0 - num_defaults:]
@@ -339,8 +336,8 @@ def unbound_method_to_callable(func_or_cls):
 
     """
 
-    if isinstance(func_or_cls, types.MethodType) and not func_or_cls.im_self:
-        return func_or_cls.im_func
+    if isinstance(func_or_cls, types.MethodType) and not func_or_cls.__self__:
+        return func_or_cls.__func__
     else:
         return func_or_cls
 
@@ -397,7 +394,7 @@ class portable_instancemethod(object):
 
     """
     def __init__(self, meth):
-        self.target = meth.im_self
+        self.target = meth.__self__
         self.name = meth.__name__
 
     def __call__(self, *arg, **kw):
@@ -417,32 +414,33 @@ def class_hierarchy(cls):
     will not be descended.
 
     """
-    # Py2K
-    if isinstance(cls, types.ClassType):
-        return list()
-    # end Py2K
+    if compat.py2k:
+        if isinstance(cls, types.ClassType):
+            return list()
+
     hier = set([cls])
     process = list(cls.__mro__)
     while process:
         c = process.pop()
-        # Py2K
-        if isinstance(c, types.ClassType):
-            continue
-        for b in (_ for _ in c.__bases__
-                  if _ not in hier and not isinstance(_, types.ClassType)):
-        # end Py2K
-        # Py3K
-        #for b in (_ for _ in c.__bases__
-        #          if _ not in hier):
+        if compat.py2k:
+            if isinstance(c, types.ClassType):
+                continue
+            bases = (_ for _ in c.__bases__
+                  if _ not in hier and not isinstance(_, types.ClassType))
+        else:
+            bases = (_ for _ in c.__bases__ if _ not in hier)
+
+        for b in bases:
             process.append(b)
             hier.add(b)
-        # Py3K
-        #if c.__module__ == 'builtins' or not hasattr(c, '__subclasses__'):
-        #    continue
-        # Py2K
-        if c.__module__ == '__builtin__' or not hasattr(c, '__subclasses__'):
-            continue
-        # end Py2K
+
+        if compat.py3k:
+            if c.__module__ == 'builtins' or not hasattr(c, '__subclasses__'):
+                continue
+        else:
+            if c.__module__ == '__builtin__' or not hasattr(c, '__subclasses__'):
+                continue
+
         for s in [_ for _ in c.__subclasses__() if _ not in hier]:
             process.append(s)
             hier.add(s)
@@ -499,9 +497,9 @@ def monkeypatch_proxied_specials(into_cls, from_cls, skip=None, only=None,
               "return %(name)s.%(method)s%(d_args)s" % locals())
 
         env = from_instance is not None and {name: from_instance} or {}
-        exec py in env
+        compat.exec_(py, env)
         try:
-            env[method].func_defaults = fn.func_defaults
+            env[method].__defaults__ = fn.__defaults__
         except AttributeError:
             pass
         setattr(into_cls, method, env[method])
@@ -510,11 +508,7 @@ def monkeypatch_proxied_specials(into_cls, from_cls, skip=None, only=None,
 def methods_equivalent(meth1, meth2):
     """Return True if the two methods are the same implementation."""
 
-    # Py3K
-    #return getattr(meth1, '__func__', meth1) is getattr(meth2, '__func__', meth2)
-    # Py2K
-    return getattr(meth1, 'im_func', meth1) is getattr(meth2, 'im_func', meth2)
-    # end Py2K
+    return getattr(meth1, '__func__', meth1) is getattr(meth2, '__func__', meth2)
 
 
 def as_interface(obj, cls=None, methods=None, required=None):
@@ -587,7 +581,7 @@ def as_interface(obj, cls=None, methods=None, required=None):
     for method, impl in dictlike_iteritems(obj):
         if method not in interface:
             raise TypeError("%r: unknown in this interface" % method)
-        if not callable(impl):
+        if not compat.callable(impl):
             raise TypeError("%r=%r is not callable" % (method, impl))
         setattr(AnonymousInterface, method, staticmethod(impl))
         found.add(method)
@@ -728,11 +722,11 @@ class importlater(object):
     def _resolve(self):
         importlater._unresolved.discard(self)
         if self._il_addtl:
-            self._initial_import = __import__(
+            self._initial_import = compat.import_(
                                 self._il_path, globals(), locals(),
                                 [self._il_addtl])
         else:
-            self._initial_import = __import__(self._il_path)
+            self._initial_import = compat.import_(self._il_path)
 
     def __getattr__(self, key):
         if key == 'module':
@@ -751,7 +745,7 @@ class importlater(object):
 
 # from paste.deploy.converters
 def asbool(obj):
-    if isinstance(obj, (str, unicode)):
+    if isinstance(obj, compat.string_types):
         obj = obj.strip().lower()
         if obj in ['true', 'yes', 'on', 'y', 't', '1']:
             return True
@@ -811,14 +805,14 @@ def constructor_copy(obj, cls, **kw):
 def counter():
     """Return a threadsafe counter function."""
 
-    lock = threading.Lock()
-    counter = itertools.count(1L)
+    lock = compat.threading.Lock()
+    counter = itertools.count(1)
 
     # avoid the 2to3 "next" transformation...
     def _next():
         lock.acquire()
         try:
-            return counter.next()
+            return next(counter)
         finally:
             lock.release()
 
@@ -834,7 +828,7 @@ def duck_type_collection(specimen, default=None):
     if hasattr(specimen, '__emulates__'):
         # canonicalize set vs sets.Set to a standard: the builtin set
         if (specimen.__emulates__ is not None and
-                issubclass(specimen.__emulates__, set_types)):
+                issubclass(specimen.__emulates__, set)):
             return set
         else:
             return specimen.__emulates__
@@ -842,7 +836,7 @@ def duck_type_collection(specimen, default=None):
     isa = isinstance(specimen, type) and issubclass or isinstance
     if isa(specimen, list):
         return list
-    elif isa(specimen, set_types):
+    elif isa(specimen, set):
         return set
     elif isa(specimen, dict):
         return dict
@@ -874,15 +868,14 @@ def assert_arg_type(arg, argtype, name):
 def dictlike_iteritems(dictlike):
     """Return a (key, value) iterator for almost any dict-like object."""
 
-    # Py3K
-    #if hasattr(dictlike, 'items'):
-    #    return dictlike.items()
-    # Py2K
-    if hasattr(dictlike, 'iteritems'):
-        return dictlike.iteritems()
-    elif hasattr(dictlike, 'items'):
-        return iter(dictlike.items())
-    # end Py2K
+    if compat.py3k:
+        if hasattr(dictlike, 'items'):
+            return list(dictlike.items())
+    else:
+        if hasattr(dictlike, 'iteritems'):
+            return dictlike.iteritems()
+        elif hasattr(dictlike, 'items'):
+            return iter(dictlike.items())
 
     getter = getattr(dictlike, '__getitem__', getattr(dictlike, 'get', None))
     if getter is None:
@@ -891,7 +884,7 @@ def dictlike_iteritems(dictlike):
 
     if hasattr(dictlike, 'iterkeys'):
         def iterator():
-            for key in dictlike.iterkeys():
+            for key in dictlike.keys():
                 yield key, getter(key)
         return iterator()
     elif hasattr(dictlike, 'keys'):
@@ -935,7 +928,7 @@ class hybridmethod(object):
 class _symbol(int):
     def __new__(self, name, doc=None, canonical=None):
         """Construct a new named symbol."""
-        assert isinstance(name, str)
+        assert isinstance(name, compat.string_types)
         if canonical is None:
             canonical = hash(name)
         v = int.__new__(_symbol, canonical)
@@ -978,7 +971,7 @@ class symbol(object):
 
     """
     symbols = {}
-    _lock = threading.Lock()
+    _lock = compat.threading.Lock()
 
     def __new__(cls, name, doc=None, canonical=None):
         cls._lock.acquire()
@@ -1032,7 +1025,7 @@ def warn(msg, stacklevel=3):
        be controlled.
 
     """
-    if isinstance(msg, basestring):
+    if isinstance(msg, compat.string_types):
         warnings.warn(msg, exc.SAWarning, stacklevel=stacklevel)
     else:
         warnings.warn(msg, stacklevel=stacklevel)