- remove all compat items that are pre-2.5 (hooray)

- other cleanup
- don't need compat.decimal, that approach never panned out. hopefully
outside libs aren't pulling it in, they shouldn't be

16 files changed, 65 insertions, 206 deletions

diff --git a/lib/sqlalchemy/dialects/firebird/kinterbasdb.py b/lib/sqlalchemy/dialects/firebird/kinterbasdb.py
index 206dbf38b..d581f799a 100644
--- a/lib/sqlalchemy/dialects/firebird/kinterbasdb.py
+++ b/lib/sqlalchemy/dialects/firebird/kinterbasdb.py
@@ -50,8 +50,8 @@ __ http://kinterbasdb.sourceforge.net/dist_docs/usage.html#special_issue_concurr
 
 from .base import FBDialect, FBExecutionContext
 from ... import util, types as sqltypes
-from ...util.compat import decimal
 from re import match
+import decimal
 
 
 class _FBNumeric_kinterbasdb(sqltypes.Numeric):
diff --git a/lib/sqlalchemy/dialects/mssql/pyodbc.py b/lib/sqlalchemy/dialects/mssql/pyodbc.py
index 8854d1caa..beb6066f5 100644
--- a/lib/sqlalchemy/dialects/mssql/pyodbc.py
+++ b/lib/sqlalchemy/dialects/mssql/pyodbc.py
@@ -114,7 +114,7 @@ for unix + PyODBC.
 from .base import MSExecutionContext, MSDialect
 from ...connectors.pyodbc import PyODBCConnector
 from ... import types as sqltypes, util
-from ...util.compat import decimal
+import decimal
 
 
 class _MSNumeric_pyodbc(sqltypes.Numeric):
diff --git a/lib/sqlalchemy/dialects/oracle/cx_oracle.py b/lib/sqlalchemy/dialects/oracle/cx_oracle.py
index fd9fea878..b8f7439f5 100644
--- a/lib/sqlalchemy/dialects/oracle/cx_oracle.py
+++ b/lib/sqlalchemy/dialects/oracle/cx_oracle.py
@@ -190,7 +190,7 @@ from ...engine import result as _result
 from sqlalchemy import types as sqltypes, util, exc, processors
 import random
 import collections
-from sqlalchemy.util.compat import decimal
+import decimal
 import re
 
 
diff --git a/lib/sqlalchemy/dialects/postgresql/pg8000.py b/lib/sqlalchemy/dialects/postgresql/pg8000.py
index 214db348c..0e503746c 100644
--- a/lib/sqlalchemy/dialects/postgresql/pg8000.py
+++ b/lib/sqlalchemy/dialects/postgresql/pg8000.py
@@ -27,7 +27,7 @@ yet.
 
 """
 from ... import util, exc
-from ...util.compat import decimal
+import decimal
 from ... import processors
 from ... import types as sqltypes
 from .base import PGDialect, \
diff --git a/lib/sqlalchemy/dialects/postgresql/psycopg2.py b/lib/sqlalchemy/dialects/postgresql/psycopg2.py
index 649a95ee6..1f118067f 100644
--- a/lib/sqlalchemy/dialects/postgresql/psycopg2.py
+++ b/lib/sqlalchemy/dialects/postgresql/psycopg2.py
@@ -147,7 +147,7 @@ import re
 import logging
 
 from ... import util, exc
-from ...util.compat import decimal
+import decimal
 from ... import processors
 from ...engine import result as _result
 from ...sql import expression
diff --git a/lib/sqlalchemy/dialects/sybase/pyodbc.py b/lib/sqlalchemy/dialects/sybase/pyodbc.py
index 644f4edb1..283c60da3 100644
--- a/lib/sqlalchemy/dialects/sybase/pyodbc.py
+++ b/lib/sqlalchemy/dialects/sybase/pyodbc.py
@@ -36,7 +36,7 @@ from sqlalchemy.dialects.sybase.base import SybaseDialect,\
                                             SybaseExecutionContext
 from sqlalchemy.connectors.pyodbc import PyODBCConnector
 from sqlalchemy import types as sqltypes, processors
-from sqlalchemy.util.compat import decimal
+import decimal
 
 
 class _SybNumeric_pyodbc(sqltypes.Numeric):
diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py
index 4e7b4d272..2d7f62153 100644
--- a/lib/sqlalchemy/orm/mapper.py
+++ b/lib/sqlalchemy/orm/mapper.py
@@ -2224,7 +2224,7 @@ def _event_on_resurrect(state):
                                             state, state.dict, col, val)
 
 
-class _ColumnMapping(util.py25_dict):
+class _ColumnMapping(dict):
     """Error reporting helper for mapper._columntoproperty."""
 
     def __init__(self, mapper):
diff --git a/lib/sqlalchemy/pool.py b/lib/sqlalchemy/pool.py
index f72082ceb..501b6d2a0 100644
--- a/lib/sqlalchemy/pool.py
+++ b/lib/sqlalchemy/pool.py
@@ -736,8 +736,8 @@ class QueuePool(Pool):
         self._overflow = 0 - pool_size
         self._max_overflow = max_overflow
         self._timeout = timeout
-        self._overflow_lock = self._max_overflow > -1 and \
-                                    threading.Lock() or DummyLock()
+        self._overflow_lock = threading.Lock() if self._max_overflow > -1 \
+                                    else DummyLock()
 
     def _do_return_conn(self, conn):
         try:
diff --git a/lib/sqlalchemy/testing/profiling.py b/lib/sqlalchemy/testing/profiling.py
index ae9d176b7..19a9731be 100644
--- a/lib/sqlalchemy/testing/profiling.py
+++ b/lib/sqlalchemy/testing/profiling.py
@@ -14,11 +14,12 @@ import pstats
 import time
 import collections
 from .. import util
+
 try:
     import cProfile
 except ImportError:
     cProfile = None
-from ..util.compat import jython, pypy, win32
+from ..util import jython, pypy, win32, update_wrapper
 
 _current_test = None
 
@@ -210,7 +211,6 @@ class ProfileStatsFile(object):
                 profile_f.write("%s %s %s\n" % (test_key, platform_key, c))
         profile_f.close()
 
-from sqlalchemy.util.compat import update_wrapper
 
 
 def function_call_count(variance=0.05):
diff --git a/lib/sqlalchemy/testing/util.py b/lib/sqlalchemy/testing/util.py
index 2592c341e..d9ff14eaf 100644
--- a/lib/sqlalchemy/testing/util.py
+++ b/lib/sqlalchemy/testing/util.py
@@ -1,6 +1,5 @@
 from ..util import jython, pypy, defaultdict, decorator
-from ..util.compat import decimal
-
+import decimal
 import gc
 import time
 import random
diff --git a/lib/sqlalchemy/types.py b/lib/sqlalchemy/types.py
index b9f7b9444..08aba4b56 100644
--- a/lib/sqlalchemy/types.py
+++ b/lib/sqlalchemy/types.py
@@ -25,10 +25,10 @@ import codecs
 
 from . import exc, schema, util, processors, events, event
 from .sql import operators
-from .sql.expression import _DefaultColumnComparator, column, bindparam
+from .sql.expression import _DefaultColumnComparator
 from .util import pickle
-from .util.compat import decimal
 from .sql.visitors import Visitable
+import decimal
 default = util.importlater("sqlalchemy.engine", "default")
 
 NoneType = type(None)
@@ -1372,8 +1372,7 @@ class Numeric(_DateAffinity, TypeEngine):
        implementations however, most of which contain an import for plain
        ``decimal`` in their source code, even though some such as psycopg2
        provide hooks for alternate adapters. SQLAlchemy imports ``decimal``
-       globally as well. While the alternate ``Decimal`` class can be patched
-       into SQLA's ``decimal`` module, overall the most straightforward and
+       globally as well.  The most straightforward and
        foolproof way to use "cdecimal" given current DBAPI and Python support
        is to patch it directly into sys.modules before anything else is
        imported::
diff --git a/lib/sqlalchemy/util/__init__.py b/lib/sqlalchemy/util/__init__.py
index 249c46ead..57bbdca85 100644
--- a/lib/sqlalchemy/util/__init__.py
+++ b/lib/sqlalchemy/util/__init__.py
@@ -4,10 +4,9 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-from .compat import callable, cmp, reduce, defaultdict, py25_dict, \
+from .compat import callable, cmp, reduce,  \
     threading, py3k, py3k_warning, jython, pypy, cpython, win32, set_types, \
-    buffer, pickle, update_wrapper, partial, md5_hex, decode_slice, \
-    dottedgetter, parse_qsl, any, contextmanager, namedtuple, next, WeakSet
+    pickle, dottedgetter, parse_qsl, namedtuple, next, WeakSet
 
 from ._collections import KeyedTuple, ImmutableContainer, immutabledict, \
     Properties, OrderedProperties, ImmutableProperties, OrderedDict, \
@@ -21,8 +20,8 @@ from .langhelpers import iterate_attributes, class_hierarchy, \
     portable_instancemethod, unbound_method_to_callable, \
     getargspec_init, format_argspec_init, format_argspec_plus, \
     get_func_kwargs, get_cls_kwargs, decorator, as_interface, \
-    memoized_property, memoized_instancemethod, \
-    group_expirable_memoized_property, importlater, \
+    memoized_property, memoized_instancemethod, md5_hex, \
+    group_expirable_memoized_property, importlater, decode_slice, \
     monkeypatch_proxied_specials, asbool, bool_or_str, coerce_kw_type,\
     duck_type_collection, assert_arg_type, symbol, dictlike_iteritems,\
     classproperty, set_creation_order, warn_exception, warn, NoneType,\
@@ -31,3 +30,10 @@ from .langhelpers import iterate_attributes, class_hierarchy, \
 
 from .deprecations import warn_deprecated, warn_pending_deprecation, \
     deprecated, pending_deprecation
+
+# things that used to be not always available,
+# but are now as of current support Python versions
+from collections import defaultdict
+from functools import partial
+from functools import update_wrapper
+from contextlib import contextmanager
diff --git a/lib/sqlalchemy/util/_collections.py b/lib/sqlalchemy/util/_collections.py
index ca77103b2..2c9c982fb 100644
--- a/lib/sqlalchemy/util/_collections.py
+++ b/lib/sqlalchemy/util/_collections.py
@@ -6,7 +6,6 @@
 
 """Collection classes and helpers."""
 
-import sys
 import itertools
 import weakref
 import operator
@@ -649,37 +648,25 @@ class OrderedIdentitySet(IdentitySet):
                 self.add(o)
 
 
-if sys.version_info >= (2, 5):
-    class PopulateDict(dict):
-        """A dict which populates missing values via a creation function.
+class PopulateDict(dict):
+    """A dict which populates missing values via a creation function.
 
-        Note the creation function takes a key, unlike
-        collections.defaultdict.
+    Note the creation function takes a key, unlike
+    collections.defaultdict.
 
-        """
-
-        def __init__(self, creator):
-            self.creator = creator
-
-        def __missing__(self, key):
-            self[key] = val = self.creator(key)
-            return val
-else:
-    class PopulateDict(dict):
-        """A dict which populates missing values via a creation function."""
+    """
 
-        def __init__(self, creator):
-            self.creator = creator
+    def __init__(self, creator):
+        self.creator = creator
 
-        def __getitem__(self, key):
-            try:
-                return dict.__getitem__(self, key)
-            except KeyError:
-                self[key] = value = self.creator(key)
-                return value
+    def __missing__(self, key):
+        self[key] = val = self.creator(key)
+        return val
 
-# define collections that are capable of storing
+# Define collections that are capable of storing
 # ColumnElement objects as hashable keys/elements.
+# At this point, these are mostly historical, things
+# used to be more complicated.
 column_set = set
 column_dict = dict
 ordered_column_set = OrderedSet
diff --git a/lib/sqlalchemy/util/compat.py b/lib/sqlalchemy/util/compat.py
index 3725a8491..12d349a5b 100644
--- a/lib/sqlalchemy/util/compat.py
+++ b/lib/sqlalchemy/util/compat.py
@@ -54,44 +54,6 @@ else:
     except ImportError:
         import pickle
 
-
-# a controversial feature, required by MySQLdb currently
-def buffer(x):
-    return x
-
-# Py2K
-buffer = buffer
-# end Py2K
-
-try:
-    from contextlib import contextmanager
-except ImportError:
-    def contextmanager(fn):
-        return fn
-
-try:
-    from functools import update_wrapper
-except ImportError:
-    def update_wrapper(wrapper, wrapped,
-                       assigned=('__doc__', '__module__', '__name__'),
-                       updated=('__dict__',)):
-        for attr in assigned:
-            setattr(wrapper, attr, getattr(wrapped, attr))
-        for attr in updated:
-            getattr(wrapper, attr).update(getattr(wrapped, attr, ()))
-        return wrapper
-
-try:
-    from functools import partial
-except ImportError:
-    def partial(func, *args, **keywords):
-        def newfunc(*fargs, **fkeywords):
-            newkeywords = keywords.copy()
-            newkeywords.update(fkeywords)
-            return func(*(args + fargs), **newkeywords)
-        return newfunc
-
-
 if sys.version_info < (2, 6):
     # emits a nasty deprecation warning
     # in newer pythons
@@ -132,52 +94,6 @@ except ImportError:
         return tuptype
 
 try:
-    from collections import defaultdict
-except ImportError:
-    class defaultdict(dict):
-
-        def __init__(self, default_factory=None, *a, **kw):
-            if (default_factory is not None and
-                not hasattr(default_factory, '__call__')):
-                raise TypeError('first argument must be callable')
-            dict.__init__(self, *a, **kw)
-            self.default_factory = default_factory
-
-        def __getitem__(self, key):
-            try:
-                return dict.__getitem__(self, key)
-            except KeyError:
-                return self.__missing__(key)
-
-        def __missing__(self, key):
-            if self.default_factory is None:
-                raise KeyError(key)
-            self[key] = value = self.default_factory()
-            return value
-
-        def __reduce__(self):
-            if self.default_factory is None:
-                args = tuple()
-            else:
-                args = self.default_factory,
-            return type(self), args, None, None, self.iteritems()
-
-        def copy(self):
-            return self.__copy__()
-
-        def __copy__(self):
-            return type(self)(self.default_factory, self)
-
-        def __deepcopy__(self, memo):
-            import copy
-            return type(self)(self.default_factory,
-                              copy.deepcopy(self.items()))
-
-        def __repr__(self):
-            return 'defaultdict(%s, %s)' % (self.default_factory,
-                                            dict.__repr__(self))
-
-try:
     from weakref import WeakSet
 except:
     import weakref
@@ -199,79 +115,12 @@ except:
         def add(self, other):
             self._storage[other] = True
 
-
-# find or create a dict implementation that supports __missing__
-class _probe(dict):
-    def __missing__(self, key):
-        return 1
-
-try:
-    try:
-        _probe()['missing']
-        py25_dict = dict
-    except KeyError:
-        class py25_dict(dict):
-            def __getitem__(self, key):
-                try:
-                    return dict.__getitem__(self, key)
-                except KeyError:
-                    try:
-                        missing = self.__missing__
-                    except AttributeError:
-                        raise KeyError(key)
-                    else:
-                        return missing(key)
-finally:
-    del _probe
-
-
-try:
-    import hashlib
-    _md5 = hashlib.md5
-except ImportError:
-    import md5
-    _md5 = md5.new
-
-
-def md5_hex(x):
-    # Py3K
-    #x = x.encode('utf-8')
-    m = _md5()
-    m.update(x)
-    return m.hexdigest()
-
 import time
 if win32 or jython:
     time_func = time.clock
 else:
     time_func = time.time
 
-if sys.version_info >= (2, 5):
-    any = any
-else:
-    def any(iterator):
-        for item in iterator:
-            if bool(item):
-                return True
-        else:
-            return False
-
-if sys.version_info >= (2, 5):
-    def decode_slice(slc):
-        """decode a slice object as sent to __getitem__.
-
-        takes into account the 2.5 __index__() method, basically.
-
-        """
-        ret = []
-        for x in slc.start, slc.stop, slc.step:
-            if hasattr(x, '__index__'):
-                x = x.__index__()
-            ret.append(x)
-        return tuple(ret)
-else:
-    def decode_slice(slc):
-        return (slc.start, slc.stop, slc.step)
 
 if sys.version_info >= (2, 6):
     from operator import attrgetter as dottedgetter
@@ -283,5 +132,3 @@ else:
             return obj
         return g
 
-
-import decimal
diff --git a/lib/sqlalchemy/util/langhelpers.py b/lib/sqlalchemy/util/langhelpers.py
index a9b791234..e3aed24d8 100644
--- a/lib/sqlalchemy/util/langhelpers.py
+++ b/lib/sqlalchemy/util/langhelpers.py
@@ -15,10 +15,31 @@ import re
 import sys
 import types
 import warnings
-from .compat import update_wrapper, set_types, threading, \
+from .compat import set_types, threading, \
     callable, inspect_getfullargspec
+from functools import update_wrapper
 from .. import exc
+import hashlib
 
+def md5_hex(x):
+    # Py3K
+    #x = x.encode('utf-8')
+    m = hashlib.md5()
+    m.update(x)
+    return m.hexdigest()
+
+def decode_slice(slc):
+    """decode a slice object as sent to __getitem__.
+
+    takes into account the 2.5 __index__() method, basically.
+
+    """
+    ret = []
+    for x in slc.start, slc.stop, slc.step:
+        if hasattr(x, '__index__'):
+            x = x.__index__()
+        ret.append(x)
+    return tuple(ret)
 
 def _unique_symbols(used, *bases):
     used = set(used)
@@ -123,7 +144,7 @@ def get_cls_kwargs(cls):
         ctr = class_.__dict__.get('__init__', False)
         if (not ctr or
             not isinstance(ctr, types.FunctionType) or
-            not isinstance(ctr.func_code, types.CodeType)):
+                not isinstance(ctr.func_code, types.CodeType)):
             stack.update(class_.__bases__)
             continue
 
@@ -256,7 +277,6 @@ def format_argspec_init(method, grouped=True):
     try:
         return format_argspec_plus(method, grouped=grouped)
     except TypeError:
-        self_arg = 'self'
         if method is object.__init__:
             args = grouped and '(self)' or 'self'
         else:
@@ -784,7 +804,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_types)):
             return set
         else:
             return specimen.__emulates__
diff --git a/lib/sqlalchemy/util/topological.py b/lib/sqlalchemy/util/topological.py
index 6f895e7b7..de3dfd0ae 100644
--- a/lib/sqlalchemy/util/topological.py
+++ b/lib/sqlalchemy/util/topological.py
@@ -49,7 +49,8 @@ def sort(tuples, allitems):
 
 
 def find_cycles(tuples, allitems):
-    # straight from gvr with some mods
+    # adapted from:
+    # http://neopythonic.blogspot.com/2009/01/detecting-cycles-in-directed-graph.html
 
     edges = util.defaultdict(set)
     for parent, child in tuples: