Ticket #15702: 24boilerplate.patch

django/contrib/admin/options.py

@@ +1 @@
+from functools import update_wrapper, partial
 from django import forms, template
 from django.forms.formsets import all_valid
 from django.forms.models import (modelform_factory, modelformset_factory,
@@ -17 +18 @@
 from django.shortcuts import get_object_or_404, render_to_response
 from django.utils.decorators import method_decorator
 from django.utils.datastructures import SortedDict
-from django.utils.functional import update_wrapper
 from django.utils.html import escape, escapejs
 from django.utils.safestring import mark_safe
-from django.utils.functional import curry
 from django.utils.text import capfirst, get_text_list
 from django.utils.translation import ugettext as _
 from django.utils.translation import ungettext
@@ -426 +425 @@
             "form": self.form,
             "fields": fields,
             "exclude": exclude,
-            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
         }
         defaults.update(kwargs)
         return modelform_factory(self.model, **defaults)
@@ -457 +456 @@
         Returns a Form class for use in the Formset on the changelist page.
         """
         defaults = {
-            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
         }
         defaults.update(kwargs)
         return modelform_factory(self.model, **defaults)
@@ -468 +467 @@
         is used.
         """
         defaults = {
-            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
         }
         defaults.update(kwargs)
         return modelformset_factory(self.model,
@@ -1327 +1326 @@
             "fk_name": self.fk_name,
             "fields": fields,
             "exclude": exclude,
-            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
             "extra": self.extra,
             "max_num": self.max_num,
             "can_delete": self.can_delete,

django/contrib/admin/sites.py

@@ -1 +1 @@
 import re
+from functools import update_wrapper
 from django import http, template
 from django.contrib.admin import ModelAdmin, actions
 from django.contrib.admin.forms import AdminAuthenticationForm
@@ -9 +10 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.core.urlresolvers import reverse
 from django.shortcuts import render_to_response
-from django.utils.functional import update_wrapper
 from django.utils.safestring import mark_safe
 from django.utils.text import capfirst
 from django.utils.translation import ugettext as _

django/contrib/admin/views/decorators.py

@@ -1 @@
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from django.utils.translation import ugettext as _
 from django.contrib.admin.forms import AdminAuthenticationForm

django/contrib/admin/widgets.py

@@ -2 +2 @@
 Form Widget classes specific to the Django admin site.
 """
 
-import django.utils.copycompat as copy
+import copy
 
 from django import forms
 from django.forms.widgets import RadioFieldRenderer

django/contrib/auth/decorators.py

@@ -1 +1 @@
 import urlparse
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from django.conf import settings
 from django.contrib.auth import REDIRECT_FIELD_NAME

django/contrib/auth/models.py

@@ -1 +1 @@
 import datetime
 import urllib
+from hashlib import sha1, md5
 
 from django.contrib import auth
 from django.contrib.auth.signals import user_logged_in
@@ -8 +9 @@
 from django.db.models.manager import EmptyManager
 from django.contrib.contenttypes.models import ContentType
 from django.utils.encoding import smart_str
-from django.utils.hashcompat import md5_constructor, sha_constructor
 from django.utils.translation import ugettext_lazy as _
 from django.utils.crypto import constant_time_compare
 
@@ -29 +29 @@
         return crypt.crypt(raw_password, salt)
 
     if algorithm == 'md5':
-        return md5_constructor(salt + raw_password).hexdigest()
+        return md5(salt + raw_password).hexdigest()
     elif algorithm == 'sha1':
-        return sha_constructor(salt + raw_password).hexdigest()
+        return sha1(salt + raw_password).hexdigest()
     raise ValueError("Got unknown password algorithm type in password.")
 
 def check_password(raw_password, enc_password):

django/contrib/auth/tests/tokens.py

@@ -58 +58 @@
         # Hard code in the Django 1.2 algorithm (not the result, as it is time
         # dependent)
         def _make_token(user):
-            from django.utils.hashcompat import sha_constructor
+            from hashlib import sha1
             from django.utils.http import int_to_base36
 
             timestamp = (date.today() - date(2001,1,1)).days
             ts_b36 = int_to_base36(timestamp)
-            hash = sha_constructor(settings.SECRET_KEY + unicode(user.id) +
-                                   user.password + user.last_login.strftime('%Y-%m-%d %H:%M:%S') +
-                                   unicode(timestamp)).hexdigest()[::2]
+            hash = sha1(settings.SECRET_KEY + unicode(user.id) +
+                        user.password + user.last_login.strftime('%Y-%m-%d %H:%M:%S') +
+                        unicode(timestamp)).hexdigest()[::2]
             return "%s-%s" % (ts_b36, hash)
 
         user = User.objects.create_user('tokentestuser', 'test2@example.com', 'testpw')

django/contrib/auth/tokens.py

@@ -1 +1 @@
 from datetime import date
+from hashlib import sha1
 
 from django.conf import settings
-from django.utils.hashcompat import sha_constructor
 from django.utils.http import int_to_base36, base36_to_int
 from django.utils.crypto import constant_time_compare, salted_hmac
 
@@ -67 +67 @@
     def _make_token_with_timestamp_old(self, user, timestamp):
         # The Django 1.2 method
         ts_b36 = int_to_base36(timestamp)
-        hash = sha_constructor(settings.SECRET_KEY + unicode(user.id) +
-                               user.password + user.last_login.strftime('%Y-%m-%d %H:%M:%S') +
-                               unicode(timestamp)).hexdigest()[::2]
+        hash = sha1(settings.SECRET_KEY + unicode(user.id) +
+                    user.password + user.last_login.strftime('%Y-%m-%d %H:%M:%S') +
+                    unicode(timestamp)).hexdigest()[::2]
         return "%s-%s" % (ts_b36, hash)
 
     def _num_days(self, dt):

django/contrib/comments/forms.py

@@ -1 +1 @@
 import time
 import datetime
+from hashlib import sha1
 
 from django import forms
 from django.forms.util import ErrorDict
@@ -8 +9 @@
 from models import Comment
 from django.utils.crypto import salted_hmac, constant_time_compare
 from django.utils.encoding import force_unicode
-from django.utils.hashcompat import sha_constructor
 from django.utils.text import get_text_list
 from django.utils.translation import ungettext, ugettext_lazy as _
 
@@ -100 +100 @@
         """Generate a (SHA1) security hash from the provided info."""
         # Django 1.2 compatibility
         info = (content_type, object_pk, timestamp, settings.SECRET_KEY)
-        return sha_constructor("".join(info)).hexdigest()
+        return sha1("".join(info)).hexdigest()
 
 class CommentDetailsForm(CommentSecurityForm):
     """

django/contrib/contenttypes/generic.py

@@ -2 +2 @@
 Classes allowing "generic" relations through ContentType and object-id fields.
 """
 
+from functools import partial
+
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import connection
 from django.db.models import signals
@@ -12 +14 @@
 from django.forms.models import BaseModelFormSet, modelformset_factory, save_instance
 from django.contrib.admin.options import InlineModelAdmin, flatten_fieldsets
 from django.utils.encoding import smart_unicode
-from django.utils.functional import curry
 
 from django.contrib.contenttypes.models import ContentType
 
@@ -414 +415 @@
             "ct_field": self.ct_field,
             "fk_field": self.ct_fk_field,
             "form": self.form,
-            "formfield_callback": curry(self.formfield_for_dbfield, request=request),
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
             "formset": self.formset,
             "extra": self.extra,
             "can_delete": self.can_delete,

django/contrib/formtools/preview.py

@@ -1 +1 @@
 """
 Formtools Preview application.
 """
-
-import cPickle as pickle
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
 
 from django.conf import settings
 from django.http import Http404
 from django.shortcuts import render_to_response
 from django.template.context import RequestContext
-from django.utils.hashcompat import md5_constructor
 from django.utils.crypto import constant_time_compare
 from django.contrib.formtools.utils import security_hash
 

django/contrib/formtools/utils.py

@@ +1 @@
+from hashlib import md5
 try:
     import cPickle as pickle
 except ImportError:
@@ -6 +7 @@
 from django.conf import settings
 from django.forms import BooleanField
 from django.utils.crypto import salted_hmac
-from django.utils.hashcompat import md5_constructor
 
 
 def security_hash(request, form, *args):
@@ -39 +39 @@
     # Python 2.3, but Django requires 2.4 anyway, so that's OK.
     pickled = pickle.dumps(data, pickle.HIGHEST_PROTOCOL)
 
-    return md5_constructor(pickled).hexdigest()
+    return md5(pickled).hexdigest()
 
 
 def form_hmac(form):

django/contrib/formtools/wizard.py

@@ -3 +3 @@
 step and storing the form's state as HTML hidden fields so that no state is
 stored on the server side.
 """
-
-import cPickle as pickle
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
 
 from django import forms
 from django.conf import settings
@@ -13 +15 @@
 from django.shortcuts import render_to_response
 from django.template.context import RequestContext
 from django.utils.crypto import constant_time_compare
-from django.utils.hashcompat import md5_constructor
 from django.utils.translation import ugettext_lazy as _
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect

django/contrib/gis/geos/tests/test_geos.py

@@ -820 +820 @@
 
     def test22_copy(self):
         "Testing use with the Python `copy` module."
-        import django.utils.copycompat as copy
+        import copy
         poly = GEOSGeometry('POLYGON((0 0, 0 23, 23 23, 23 0, 0 0), (5 5, 5 10, 10 10, 10 5, 5 5))')
         cpy1 = copy.copy(poly)
         cpy2 = copy.deepcopy(poly)

django/contrib/gis/geos/tests/test_geos_mutation.py

@@ -2 +2 @@
 # Modified from original contribution by Aryeh Leib Taurog, which was
 # released under the New BSD license.
 
-import django.utils.copycompat as copy
+import copy
 
 from django.contrib.gis.geos import *
 from django.contrib.gis.geos.error import GEOSIndexError

django/contrib/gis/tests/layermap/tests.py

@@ -1 +1 @@
 import os
+import copy
 from decimal import Decimal
 
-from django.utils.copycompat import copy
 from django.utils.unittest import TestCase
 
 from django.contrib.gis.gdal import DataSource, OGRException

django/contrib/sessions/backends/base.py

@@ -3 +3 @@
 import random
 import sys
 import time
+from hashlib import md5
 from datetime import datetime, timedelta
 try:
     import cPickle as pickle
@@ -11 +12 @@
 
 from django.conf import settings
 from django.core.exceptions import SuspiciousOperation
-from django.utils.hashcompat import md5_constructor
 from django.utils.crypto import constant_time_compare, salted_hmac
 
 # Use the system (hardware-based) random number generator if it exists.
@@ -119 +119 @@
     def _decode_old(self, session_data):
         encoded_data = base64.decodestring(session_data)
         pickled, tamper_check = encoded_data[:-32], encoded_data[-32:]
-        if not constant_time_compare(md5_constructor(pickled + settings.SECRET_KEY).hexdigest(),
+        if not constant_time_compare(md5(pickled + settings.SECRET_KEY).hexdigest(),
                                      tamper_check):
             raise SuspiciousOperation("User tampered with session cookie.")
         return pickle.loads(pickled)
@@ -161 +161 @@
             # No getpid() in Jython, for example
             pid = 1
         while 1:
-            session_key = md5_constructor("%s%s%s%s"
+            session_key = md5("%s%s%s%s"
                     % (randrange(0, MAX_SESSION_KEY), pid, time.time(),
                        settings.SECRET_KEY)).hexdigest()
             if not self.exists(session_key):

django/contrib/sessions/tests.py

@@ -1 +1 @@
 import base64
-from datetime import datetime, timedelta
 import pickle
 import shutil
 import tempfile
+from hashlib import md5
+from datetime import datetime, timedelta
 
 from django.conf import settings
 from django.contrib.sessions.backends.db import SessionStore as DatabaseSession
@@ -15 +16 @@
 from django.http import HttpResponse
 from django.test import TestCase, RequestFactory
 from django.utils import unittest
-from django.utils.hashcompat import md5_constructor
 
 
 class SessionTestsMixin(object):
@@ -257 +257 @@
         # Hard code the Django 1.2 method here:
         def encode(session_dict):
             pickled = pickle.dumps(session_dict, pickle.HIGHEST_PROTOCOL)
-            pickled_md5 = md5_constructor(pickled + settings.SECRET_KEY).hexdigest()
+            pickled_md5 = md5(pickled + settings.SECRET_KEY).hexdigest()
             return base64.encodestring(pickled + pickled_md5)
 
         data = {'a test key': 'a test value'}

django/core/cache/backends/filebased.py

@@ -3 +3 @@
 import os
 import time
 import shutil
+from hashlib import md5
 try:
     import cPickle as pickle
 except ImportError:
     import pickle
 
 from django.core.cache.backends.base import BaseCache
-from django.utils.hashcompat import md5_constructor
 
 class FileBasedCache(BaseCache):
     def __init__(self, dir, params):
@@ -145 +145 @@
         Thus, a cache key of "foo" gets turnned into a file named
         ``{cache-dir}ac/bd/18db4cc2f85cedef654fccc4a4d8``.
         """
-        path = md5_constructor(key).hexdigest()
+        path = md5(key).hexdigest()
         path = os.path.join(path[:2], path[2:4], path[4:])
         return os.path.join(self._dir, path)
 

django/core/cache/backends/locmem.py

@@ -77 +77 @@
         key = self.make_key(key, version=version)
         self.validate_key(key)
         self._lock.writer_enters()
-        # Python 2.4 doesn't allow combined try-except-finally blocks.
         try:
-            try:
-                self._set(key, pickle.dumps(value), timeout)
-            except pickle.PickleError:
-                pass
+            self._set(key, pickle.dumps(value), timeout)
+        except pickle.PickleError:
+            pass
         finally:
             self._lock.writer_leaves()
 

django/core/mail/backends/console.py

@@ -18 +18 @@
             return
         self._lock.acquire()
         try:
-            # The try-except is nested to allow for
-            # Python 2.4 support (Refs #12147)
-            try:
-                stream_created = self.open()
-                for message in email_messages:
-                    self.stream.write('%s\n' % message.message().as_string())
-                    self.stream.write('-'*79)
-                    self.stream.write('\n')
-                    self.stream.flush()  # flush after each message
-                if stream_created:
-                    self.close()
-            except:
-                if not self.fail_silently:
-                    raise
+            stream_created = self.open()
+            for message in email_messages:
+                self.stream.write('%s\n' % message.message().as_string())
+                self.stream.write('-'*79)
+                self.stream.write('\n')
+                self.stream.flush()  # flush after each message
+            if stream_created:
+                self.close()
+        except:
+            if not self.fail_silently:
+                raise
         finally:
             self._lock.release()
         return len(email_messages)

django/core/mail/message.py

@@ -3 +3 @@
 import random
 import time
 from email import Charset, Encoders
-try:
-    from email.generator import Generator
-except ImportError:
-    from email.Generator import Generator # TODO: Remove when remove Python 2.4 support
+from email.generator import Generator
 from email.MIMEText import MIMEText
 from email.MIMEMultipart import MIMEMultipart
 from email.MIMEBase import MIMEBase

django/core/management/validation.py

@@ -4 +4 @@
 from django.core.management.color import color_style
 from django.utils.itercompat import is_iterable
 
-try:
-    any
-except NameError:
-    from django.utils.itercompat import any
-
 class ModelErrorCollection:
     def __init__(self, outfile=sys.stdout):
         self.errors = []

django/db/__init__.py

@@ +1 @@
+from functools import partial
+
 from django.conf import settings
 from django.core import signals
 from django.core.exceptions import ImproperlyConfigured
 from django.db.utils import ConnectionHandler, ConnectionRouter, load_backend, DEFAULT_DB_ALIAS, \
                             DatabaseError, IntegrityError
-from django.utils.functional import curry
 
 __all__ = ('backend', 'connection', 'connections', 'router', 'DatabaseError',
     'IntegrityError', 'DEFAULT_DB_ALIAS')

django/db/backends/util.py

@@ -1 +1 @@
 import datetime
 import decimal
 from time import time
+from hashlib import md5
 
-from django.utils.hashcompat import md5_constructor
 from django.utils.log import getLogger
 
 
@@ -130 +130 @@
     if length is None or len(name) <= length:
         return name
 
-    hash = md5_constructor(name).hexdigest()[:hash_len]
+    hash = md5(name).hexdigest()[:hash_len]
 
     return '%s%s' % (name[:length-hash_len], hash)
 

django/db/models/base.py

@@ -1 +1 @@
 import types
 import sys
+import copy
 from itertools import izip
+from functools import update_wrapper
 
 import django.db.models.manager     # Imported to register signal handler.
 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned, FieldError, ValidationError, NON_FIELD_ERRORS
@@ -17 +19 @@
 from django.db.models import signals
 from django.db.models.loading import register_models, get_model
 from django.utils.translation import ugettext_lazy as _
-import django.utils.copycompat as copy
-from django.utils.functional import curry, update_wrapper
+from django.utils.functional import curry
 from django.utils.encoding import smart_str, force_unicode
 from django.utils.text import get_text_list, capfirst
 from django.conf import settings

django/db/models/deletion.py

@@ +1 @@
+from functools import wraps
 from operator import attrgetter
 
 from django.db import connections, transaction, IntegrityError
 from django.db.models import signals, sql
 from django.db.models.sql.constants import GET_ITERATOR_CHUNK_SIZE
 from django.utils.datastructures import SortedDict
-from django.utils.functional import wraps
 
 
 class ProtectedError(IntegrityError):
     def __init__(self, msg, protected_objects):
         self.protected_objects = protected_objects
-        # TODO change this to use super() when we drop Python 2.4
-        IntegrityError.__init__(self, msg, protected_objects)
+        super(ProtectedError, self).__init__(msg, protected_objects)
 
 
 def CASCADE(collector, field, sub_objs, using):

django/db/models/expressions.py

@@ -1 +1 @@
 import datetime
+from copy import deepcopy
 
 from django.utils import tree
-from django.utils.copycompat import deepcopy
 
 class ExpressionNode(tree.Node):
     """

django/db/models/fields/__init__.py

@@ -3 +3 @@
 import re
 import time
 import math
+import copy
 from itertools import tee
 
-import django.utils.copycompat as copy
-
 from django.db import connection
 from django.db.models.fields.subclassing import LegacyConnection
 from django.db.models.query_utils import QueryWrapper

django/db/models/fields/files.py

@@ -1 +1 @@
 import datetime
 import os
 
-import django.utils.copycompat as copy
-
 from django.conf import settings
 from django.db.models.fields import Field
 from django.core.files.base import File, ContentFile

django/db/models/fields/related.py

@@ +1 @@
+from django.utils import datetime_safe
 from django.conf import settings
 from django.db import connection, router, transaction
 from django.db.backends import util

django/db/models/manager.py

@@ -1 @@
-from django.utils import copycompat as copy
+import copy
 from django.conf import settings
 from django.db import router
 from django.db.models.query import QuerySet, EmptyQuerySet, insert_query, RawQuerySet

django/db/models/options.py

@@ -11 +11 @@
 from django.utils.encoding import force_unicode, smart_str
 from django.utils.datastructures import SortedDict
 
-try:
-    all
-except NameError:
-    from django.utils.itercompat import all
-
 # Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
 get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip()
 

django/db/models/query.py

@@ -3 +3 @@
 """
 
 from itertools import izip
+from copy import deepcopy
 
 from django.db import connections, router, transaction, IntegrityError
 from django.db.models.aggregates import Aggregate
@@ -11 +12 @@
     deferred_class_factory, InvalidQuery)
 from django.db.models.deletion import Collector
 from django.db.models import signals, sql
-from django.utils.copycompat import deepcopy
 
 # Used to control how many objects are worked with at once in some cases (e.g.
 # when deleting objects).

django/db/models/query_utils.py

@@ -7 +7 @@
 """
 
 import weakref
-from django.utils.copycompat import deepcopy
+from copy import deepcopy
 
 from django.db.backends import util
 from django.utils import tree

django/db/models/sql/query.py

@@ -7 +7 @@
 all about the internals of models in order to get the information it needs.
 """
 
-from django.utils.copycompat import deepcopy
+from copy import deepcopy
 from django.utils.tree import Node
 from django.utils.datastructures import SortedDict
 from django.utils.encoding import force_unicode

django/db/transaction.py

@@ -12 +12 @@
 or implicit commits or rollbacks.
 """
 import sys
-
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from django.conf import settings
 from django.db import connections, DEFAULT_DB_ALIAS
@@ -210 +206 @@
         @wraps(func)
         def inner(*args, **kwargs):
             # Once we drop support for Python 2.4 this block should become:
-            # with self:
-            #     func(*args, **kwargs)
-            self.__enter__()
-            try:
-                res = func(*args, **kwargs)
-            except:
-                self.__exit__(*sys.exc_info())
-                raise
-            else:
-                self.__exit__(None, None, None)
-                return res
+            with self:
+                return func(*args, **kwargs)
         return inner
 
 def _transaction_func(entering, exiting, using):

django/dispatch/saferef.py

@@ -230 +230 @@
         if target is not None:
             function = self.weakFunc()
             if function is not None:
-                # Using curry() would be another option, but it erases the
+                # Using partial() would be another option, but it erases the
                 # "signature" of the function. That is, after a function is
                 # curried, the inspect module can't be used to determine how
                 # many arguments the function expects, nor what keyword

django/forms/extras/widgets.py

@@ -68 +68 @@
                 if settings.USE_L10N:
                     try:
                         input_format = get_format('DATE_INPUT_FORMATS')[0]
-                        # Python 2.4 compatibility:
-                        #     v = datetime.datetime.strptime(value, input_format)
-                        # would be clearer, but datetime.strptime was added in
-                        # Python 2.5
-                        v = datetime.datetime(*(time.strptime(value, input_format)[0:6]))
+                        v = datetime.datetime.strptime(value, input_format)
                         year_val, month_val, day_val = v.year, v.month, v.day
                     except ValueError:
                         pass

django/forms/fields.py

@@ -5 +5 @@
 import datetime
 import os
 import re
+import copy
 import time
 import urlparse
 import warnings
@@ -16 +17 @@
 
 from django.core.exceptions import ValidationError
 from django.core import validators
-import django.utils.copycompat as copy
 from django.utils import formats
 from django.utils.translation import ugettext_lazy as _
 from django.utils.encoding import smart_unicode, smart_str

django/forms/forms.py

@@ -2 +2 @@
 Form classes
 """
 
+from copy import deepcopy
 from django.core.exceptions import ValidationError
-from django.utils.copycompat import deepcopy
 from django.utils.datastructures import SortedDict
 from django.utils.html import conditional_escape
 from django.utils.encoding import StrAndUnicode, smart_unicode, force_unicode

django/forms/widgets.py

@@ -2 +2 @@
 HTML Widget classes
 """
 import datetime
-from itertools import chain
 import time
+import copy
+from itertools import chain
 from urlparse import urljoin
 from util import flatatt
 
-import django.utils.copycompat as copy
 from django.conf import settings
 from django.utils.datastructures import MultiValueDict, MergeDict
 from django.utils.html import escape, conditional_escape

django/http/__init__.py

@@ -364 +364 @@
         return result
 
     def __deepcopy__(self, memo):
-        import django.utils.copycompat as copy
+        import copy
         result = self.__class__('', mutable=True, encoding=self.encoding)
         memo[id(self)] = result
         for key, value in dict.items(self):

django/middleware/common.py

@@ -1 +1 @@
 import re
+from hashlib import md5
 
 from django.conf import settings
 from django import http
 from django.core.mail import mail_managers
 from django.utils.http import urlquote
 from django.core import urlresolvers
-from django.utils.hashcompat import md5_constructor
 from django.utils.log import getLogger
 
 logger = getLogger('django.request')
@@ -113 +113 @@
             if response.has_header('ETag'):
                 etag = response['ETag']
             else:
-                etag = '"%s"' % md5_constructor(response.content).hexdigest()
+                etag = '"%s"' % md5(response.content).hexdigest()
             if response.status_code >= 200 and response.status_code < 300 and request.META.get('HTTP_IF_NONE_MATCH') == etag:
                 cookies = response.cookies
                 response = http.HttpResponseNotModified()

django/middleware/csrf.py

@@ -8 +8 @@
 import itertools
 import re
 import random
+from hashlib import md5
 
 from django.conf import settings
 from django.core.urlresolvers import get_callable
 from django.utils.cache import patch_vary_headers
-from django.utils.hashcompat import md5_constructor
 from django.utils.http import same_origin
 from django.utils.log import getLogger
 from django.utils.safestring import mark_safe
@@ -47 +47 @@
 
 
 def _get_new_csrf_key():
-    return md5_constructor("%s%s"
-                % (randrange(0, _MAX_CSRF_KEY), settings.SECRET_KEY)).hexdigest()
+    return md5("%s%s" % (randrange(0, _MAX_CSRF_KEY), settings.SECRET_KEY)).hexdigest()
 
 
 def _make_legacy_session_token(session_id):
-    return md5_constructor(settings.SECRET_KEY + session_id).hexdigest()
+    return md5(settings.SECRET_KEY + session_id).hexdigest()
 
 
 def get_token(request):

django/template/base.py

@@ -1 +1 @@
 import imp
 import re
 from inspect import getargspec
+from functools import partial
 
 from django.conf import settings
 from django.template.context import Context, RequestContext, ContextPopException
 from django.utils.importlib import import_module
 from django.utils.itercompat import is_iterable
-from django.utils.functional import curry, Promise
+from django.utils.functional import Promise
 from django.utils.text import smart_split, unescape_string_literal, get_text_list
 from django.utils.encoding import smart_unicode, force_unicode, smart_str
 from django.utils.translation import ugettext_lazy
@@ -884 +885 @@
                         func_args = resolved_vars
                     return func(*func_args)
 
-            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode)
+            compile_func = partial(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode)
             compile_func.__doc__ = func.__doc__
             self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
             return func
@@ -936 +937 @@
                         new_context['csrf_token'] = csrf_token
                     return self.nodelist.render(new_context)
 
-            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
+            compile_func = partial(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
             compile_func.__doc__ = func.__doc__
             self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
             return func

django/template/defaultfilters.py

@@ -3 +3 @@
 import re
 from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
 import random as random_module
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from django.template.base import Variable, Library
 from django.conf import settings

django/template/loaders/cached.py

@@ -2 +2 @@
 Wrapper class that takes a list of template loaders as an argument and attempts
 to load templates from them in order, caching the result.
 """
+from hashlib import sha1
 
 from django.core.exceptions import ImproperlyConfigured
 from django.template.base import TemplateDoesNotExist
 from django.template.loader import BaseLoader, get_template_from_string, find_template_loader, make_origin
-from django.utils.hashcompat import sha_constructor
 from django.utils.importlib import import_module
 
 class Loader(BaseLoader):
@@ -38 +38 @@
         key = template_name
         if template_dirs:
             # If template directories were specified, use a hash to differentiate
-            key = '-'.join([template_name, sha_constructor('|'.join(template_dirs)).hexdigest()])
+            key = '-'.join([template_name, sha1('|'.join(template_dirs)).hexdigest()])
 
         if key not in self.template_cache:
             template, origin = self.find_template(template_name, template_dirs)

django/templatetags/cache.py

@@ +1 @@
+from hashlib import md5
 from django.template import Library, Node, TemplateSyntaxError, Variable, VariableDoesNotExist
 from django.template import resolve_variable
 from django.core.cache import cache
 from django.utils.encoding import force_unicode
 from django.utils.http import urlquote
-from django.utils.hashcompat import md5_constructor
 
 register = Library()
 
@@ -24 +24 @@
         except (ValueError, TypeError):
             raise TemplateSyntaxError('"cache" tag got a non-integer timeout value: %r' % expire_time)
         # Build a unicode key for this fragment and all vary-on's.
-        args = md5_constructor(u':'.join([urlquote(resolve_variable(var, context)) for var in self.vary_on]))
+        args = md5(u':'.join([urlquote(resolve_variable(var, context)) for var in self.vary_on]))
         cache_key = 'template.cache.%s.%s' % (self.fragment_name, args.hexdigest())
         value = cache.get(cache_key)
         if value is None:

django/test/client.py

@@ -6 +6 @@
 import mimetypes
 import warnings
 from copy import copy
+from functools import partial
 try:
     from cStringIO import StringIO
 except ImportError:

django/test/simple.py

@@ -7 +7 @@
 from django.test.testcases import OutputChecker, DocTestRunner, TestCase
 from django.utils import unittest
 
-try:
-    all
-except NameError:
-    from django.utils.itercompat import all
-
-
 __all__ = ('DjangoTestRunner', 'DjangoTestSuiteRunner', 'run_tests')
 
 # The module name for tests outside models.py

django/test/testcases.py

@@ -1 +1 @@
 import re
 import sys
+from functools import wraps
 from urlparse import urlsplit, urlunsplit
 from xml.dom.minidom import parseString, Node
 
@@ -16 +17 @@
 from django.test.utils import get_warnings_state, restore_warnings_state
 from django.utils import simplejson, unittest as ut2
 from django.utils.encoding import smart_str
-from django.utils.functional import wraps
 
 __all__ = ('DocTestRunner', 'OutputChecker', 'TestCase', 'TransactionTestCase',
            'skipIfDBFeature', 'skipUnlessDBFeature')
 
 
-try:
-    all
-except NameError:
-    from django.utils.itercompat import all
-
 normalize_long_ints = lambda s: re.sub(r'(?<![\w])(\d+)L(?![\w])', '\\1', s)
 normalize_decimals = lambda s: re.sub(r"Decimal\('(\d+(\.\d*)?)'\)", lambda m: "Decimal(\"%s\")" % m.groups()[0], s)
 
@@ -550 +545 @@
 
 def connections_support_transactions():
     """
-    Returns True if all connections support transactions.  This is messy
-    because 2.4 doesn't support any or all.
+    Returns True if all connections support transactions.
     """
     return all(conn.features.supports_transactions
         for conn in connections.all())

django/utils/cache.py

@@ -19 +19 @@
 
 import re
 import time
+from hashlib import md5
 
 from django.conf import settings
 from django.core.cache import get_cache
 from django.utils.encoding import smart_str, iri_to_uri
 from django.utils.http import http_date
-from django.utils.hashcompat import md5_constructor
 from django.utils.translation import get_language
 from django.http import HttpRequest
 
@@ -102 +102 @@
     if cache_timeout < 0:
         cache_timeout = 0 # Can't have max-age negative
     if settings.USE_ETAGS and not response.has_header('ETag'):
-        response['ETag'] = '"%s"' % md5_constructor(response.content).hexdigest()
+        response['ETag'] = '"%s"' % md5(response.content).hexdigest()
     if not response.has_header('Last-Modified'):
         response['Last-Modified'] = http_date()
     if not response.has_header('Expires'):
@@ -155 +155 @@
 
 def _generate_cache_key(request, method, headerlist, key_prefix):
     """Returns a cache key from the headers given in the header list."""
-    ctx = md5_constructor()
+    ctx = md5()
     for header in headerlist:
         value = request.META.get(header, None)
         if value is not None:
             ctx.update(value)
-    path = md5_constructor(iri_to_uri(request.get_full_path()))
+    path = md5(iri_to_uri(request.get_full_path()))
     cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
         key_prefix, request.method, path.hexdigest(), ctx.hexdigest())
     return _i18n_cache_key_suffix(request, cache_key)
 
 def _generate_cache_header_key(key_prefix, request):
     """Returns a cache key for the header cache."""
-    path = md5_constructor(iri_to_uri(request.get_full_path()))
+    path = md5(iri_to_uri(request.get_full_path()))
     cache_key = 'views.decorators.cache.cache_header.%s.%s' % (
         key_prefix, path.hexdigest())
     return _i18n_cache_key_suffix(request, cache_key)

deleted file django/utils/copycompat.py

@@ -1 @@
-"""
-Fixes Python 2.4's failure to deepcopy unbound functions.
-"""
-
-import copy
-import types
-
-# Monkeypatch copy's deepcopy registry to handle functions correctly.
-if (hasattr(copy, '_deepcopy_dispatch') and types.FunctionType not in copy._deepcopy_dispatch):
-    copy._deepcopy_dispatch[types.FunctionType] = copy._deepcopy_atomic
-
-# Pose as the copy module now.
-del copy, types
-from copy import *

django/utils/crypto.py

@@ -2 +2 @@
 Django's standard crypto functions and utilities.
 """
 import hmac
+from hashlib import sha1
 
 from django.conf import settings
-from django.utils.hashcompat import sha_constructor, sha_hmac
 
 
 def salted_hmac(key_salt, value, secret=None):
@@ -21 +21 @@
     # passing the key_salt and our base key through a pseudo-random function and
     # SHA1 works nicely.
 
-    key = sha_constructor(key_salt + secret).digest()
+    key = sha1(key_salt + secret).digest()
 
     # If len(key_salt + secret) > sha_constructor().block_size, the above
     # line is redundant and could be replaced by key = key_salt + secret, since
     # the hmac module does the same thing for keys longer than the block size.
     # However, we need to ensure that we *always* do this.
 
-    return hmac.new(key, msg=value, digestmod=sha_hmac)
+    return hmac.new(key, msg=value, digestmod=sha1)
 
 
 def constant_time_compare(val1, val2):

django/utils/datastructures.py

@@ -1 +1 @@
 from types import GeneratorType
-
-from django.utils.copycompat import copy, deepcopy
+from copy import copy, deepcopy
 
 
 class MergeDict(object):
@@ -269 +268 @@
         ])
 
     def __deepcopy__(self, memo=None):
-        import django.utils.copycompat as copy
         if memo is None:
             memo = {}
         result = self.__class__()
         memo[id(self)] = result
         for key, value in dict.items(self):
-            dict.__setitem__(result, copy.deepcopy(key, memo),
-                             copy.deepcopy(value, memo))
+            dict.__setitem__(result, deepcopy(key, memo),
+                             deepcopy(value, memo))
         return result
 
     def __getstate__(self):

django/utils/decorators.py

@@ -1 +1 @@
 "Functions that help with dynamically creating decorators for views."
 
-try:
-    from functools import wraps, update_wrapper, WRAPPER_ASSIGNMENTS
-except ImportError:
-    from django.utils.functional import wraps, update_wrapper, WRAPPER_ASSIGNMENTS  # Python 2.4 fallback.
+from functools import wraps, update_wrapper, WRAPPER_ASSIGNMENTS
 
 class classonlymethod(classmethod):
     def __get__(self, instance, owner):

django/utils/functional.py

@@ -49 +49 @@
 # agrees to be bound by the terms and conditions of this License
 # Agreement.
 
+from functools import wraps
 
 def curry(_curried_func, *args, **kwargs):
     def _curried(*moreargs, **morekwargs):
         return _curried_func(*(args+moreargs), **dict(kwargs, **morekwargs))
     return _curried
 
-### Begin from Python 2.5 functools.py ########################################
-
-# Summary of changes made to the Python 2.5 code below:
-#   * swapped ``partial`` for ``curry`` to maintain backwards-compatibility
-#     in Django.
-
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Python Software Foundation.
-# All Rights Reserved.
-
-###############################################################################
-
-# update_wrapper() and wraps() are tools to help write
-# wrapper functions that can handle naive introspection
-
-WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__doc__')
-WRAPPER_UPDATES = ('__dict__',)
-def update_wrapper(wrapper,
-                   wrapped,
-                   assigned = WRAPPER_ASSIGNMENTS,
-                   updated = WRAPPER_UPDATES):
-    """Update a wrapper function to look like the wrapped function
-
-       wrapper is the function to be updated
-       wrapped is the original function
-       assigned is a tuple naming the attributes assigned directly
-       from the wrapped function to the wrapper function (defaults to
-       functools.WRAPPER_ASSIGNMENTS)
-       updated is a tuple naming the attributes off the wrapper that
-       are updated with the corresponding attribute from the wrapped
-       function (defaults to functools.WRAPPER_UPDATES)
-    """
-    for attr in assigned:
-        setattr(wrapper, attr, getattr(wrapped, attr))
-    for attr in updated:
-        getattr(wrapper, attr).update(getattr(wrapped, attr))
-    # Return the wrapper so this can be used as a decorator via curry()
-    return wrapper
-
-def wraps(wrapped,
-          assigned = WRAPPER_ASSIGNMENTS,
-          updated = WRAPPER_UPDATES):
-    """Decorator factory to apply update_wrapper() to a wrapper function
-
-       Returns a decorator that invokes update_wrapper() with the decorated
-       function as the wrapper argument and the arguments to wraps() as the
-       remaining arguments. Default arguments are as for update_wrapper().
-       This is a convenience function to simplify applying curry() to
-       update_wrapper().
-    """
-    return curry(update_wrapper, wrapped=wrapped,
-                 assigned=assigned, updated=updated)
-
-### End from Python 2.5 functools.py ##########################################
-
 def memoize(func, cache, num_args):
     """
     Wrap a function so that results for any argument tuple are stored in
@@ -343 +290 @@
             memo[id(self)] = result
             return result
         else:
-            # Changed to use deepcopy from copycompat, instead of copy
-            # For Python 2.4.
-            from django.utils.copycompat import deepcopy
+            from copy import deepcopy
             return deepcopy(self._wrapped, memo)
 
     # Need to pretend to be the wrapped class, for the sake of objects that care

deleted file django/utils/hashcompat.py

@@ -1 @@
-"""
-The md5 and sha modules are deprecated since Python 2.5, replaced by the
-hashlib module containing both hash algorithms. Here, we provide a common
-interface to the md5 and sha constructors, depending on system version.
-"""
-
-import sys
-if sys.version_info >= (2, 5):
-    import hashlib
-    md5_constructor = hashlib.md5
-    md5_hmac = md5_constructor
-    sha_constructor = hashlib.sha1
-    sha_hmac = sha_constructor
-else:
-    import md5
-    md5_constructor = md5.new
-    md5_hmac = md5
-    import sha
-    sha_constructor = sha.new
-    sha_hmac = sha

django/utils/itercompat.py

@@ -31 +31 @@
         return False
     else:
         return True
-
-def all(iterable):
-    for item in iterable:
-        if not item:
-            return False
-    return True
-
-def any(iterable):
-    for item in iterable:
-        if item:
-            return True
-    return False

django/utils/log.py

@@ -18 +18 @@
 except ImportError:
     from django.utils.dictconfig import dictConfig
 
-if sys.version_info < (2, 5):
-    class LoggerCompat(object):
-        def __init__(self, logger):
-            self._logger = logger
-
-        def __getattr__(self, name):
-            val = getattr(self._logger, name)
-            if callable(val):
-                def _wrapper(*args, **kwargs):
-                    # Python 2.4 logging module doesn't support 'extra' parameter to
-                    # methods of Logger
-                    kwargs.pop('extra', None)
-                    return val(*args, **kwargs)
-                return _wrapper
-            else:
-                return val
-
-    def getLogger(name=None):
-        return LoggerCompat(logging.getLogger(name=name))
-else:
-    getLogger = logging.getLogger
+getLogger = logging.getLogger
 
 # Ensure the creation of the Django logger
 # with a null handler. This ensures we don't get any
@@ -49 +29 @@
 
 class AdminEmailHandler(logging.Handler):
     def __init__(self, include_html=False):
-        logging.Handler.__init__(self)        
+        logging.Handler.__init__(self)
         self.include_html = include_html
 
     """An exception log handler that e-mails log entries to site admins.
@@ -63 +43 @@
         from django.views.debug import ExceptionReporter
 
         try:
-            if sys.version_info < (2,5):
-                # A nasty workaround required because Python 2.4's logging
-                # module doesn't support passing in extra context.
-                # For this handler, the only extra data we need is the
-                # request, and that's in the top stack frame.
-                request = record.exc_info[2].tb_frame.f_locals['request']
-            else:
-                request = record.request
-
+            request = record.request
             subject = '%s (%s IP): %s' % (
                 record.levelname,
                 (request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'),

django/utils/tree.py

@@ -3 +3 @@
 ORM.
 """
 
-from django.utils.copycompat import deepcopy
+from copy import deepcopy
 
 class Node(object):
     """

django/utils/unittest/case.py

@@ -36 +36 @@
     """
 
     def __init__(self, exc_info):
-        # can't use super because Python 2.4 exceptions are old style
-        Exception.__init__(self)
+        super(_ExpectedFailure, self).__init__()
         self.exc_info = exc_info
 
 class _UnexpectedSuccess(Exception):

django/utils/unittest/compatibility.py

@@ -1 +1 @@
 import os
 import sys
-
-try:
-    from functools import wraps
-except ImportError:
-    # only needed for Python 2.4
-    def wraps(_):
-        def _wraps(func):
-            return func
-        return _wraps
+from functools import wraps
 
 __unittest = True
 

django/views/decorators/cache.py

@@ -1 @@
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from django.utils.decorators import decorator_from_middleware_with_args, available_attrs
 from django.utils.cache import patch_cache_control, add_never_cache_headers

django/views/decorators/csrf.py

@@ +1 @@
+from functools import wraps
+
 from django.middleware.csrf import CsrfViewMiddleware
 from django.utils.decorators import decorator_from_middleware, available_attrs
 
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
-
 csrf_protect = decorator_from_middleware(CsrfViewMiddleware)
 csrf_protect.__name__ = "csrf_protect"
 csrf_protect.__doc__ = """

django/views/decorators/http.py

@@ -1 +1 @@
 """
 Decorators for views based on HTTP headers.
 """
-
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from calendar import timegm
 from datetime import timedelta

django/views/decorators/vary.py

@@ -1 @@
-try:
-    from functools import wraps
-except ImportError:
-    from django.utils.functional import wraps  # Python 2.4 fallback.
+from functools import wraps
 
 from django.utils.cache import patch_vary_headers
 from django.utils.decorators import available_attrs

django/views/generic/base.py

@@ +1 @@
+from functools import update_wrapper
 from django import http
 from django.core.exceptions import ImproperlyConfigured
 from django.template import RequestContext, loader
 from django.template.response import TemplateResponse
-from django.utils.functional import update_wrapper
 from django.utils.log import getLogger
 from django.utils.decorators import classonlymethod
 

tests/regressiontests/dispatch/tests/test_dispatcher.py

@@ -1 +1 @@
 import gc
 import sys
+import copy
 
 from django.dispatch import Signal
 from django.utils import unittest
-import django.utils.copycompat as copy
 
 if sys.platform.startswith('java'):
     def garbage_collect():

tests/regressiontests/extra_regress/models.py

@@ -1 +1 @@
 import datetime
-
-import django.utils.copycompat as copy
+import copy
 
 from django.contrib.auth.models import User
 from django.db import models

tests/regressiontests/forms/tests/widgets.py

@@ -1 +1 @@
 # -*- coding: utf-8 -*-
 import datetime
-from decimal import Decimal
 import re
 import time
+import copy
+from decimal import Decimal
+
 from django.conf import settings
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.forms import *
 from django.forms.widgets import RadioFieldRenderer
-from django.utils import copycompat as copy
 from django.utils import formats
 from django.utils.safestring import mark_safe
 from django.utils.translation import activate, deactivate

tests/regressiontests/introspection/tests.py

@@ +1 @@
+from functools import update_wrapper
+
 from django.conf import settings
 from django.db import connection, DEFAULT_DB_ALIAS
 from django.test import TestCase, skipUnlessDBFeature
-from django.utils import functional
 
 from models import Reporter, Article
 
@@ -23 +24 @@
             return func(*args, **kwargs)
         except NotImplementedError:
             return None
-    functional.update_wrapper(_inner, func)
+    update_wrapper(_inner, func)
     return _inner
 
 class IgnoreNotimplementedError(type):

tests/regressiontests/utils/datastructures.py

@@ -3 +3 @@
 """
 import pickle
 import unittest
+import copy
 
-from django.utils.copycompat import copy
 from django.utils.datastructures import *
 
 

tests/regressiontests/utils/simplelazyobject.py

@@ -1 +1 @@
 import unittest
+import copy
 
-import django.utils.copycompat as copy
 from django.utils.functional import SimpleLazyObject
 
 class _ComplexObject(object):