Python 3 compatibility

djangotoolbox/db/base.py

@@ -1,5 +1,5 @@
-from django.utils.six.moves import cPickle as pickle
 import datetime
+import six
 
 from django.conf import settings
 from django.db.backends import (
@@ -11,8 +11,16 @@
     BaseDatabaseIntrospection)
 from django.db.utils import DatabaseError
 from django.utils.functional import Promise
-from django.utils.safestring import EscapeString, EscapeUnicode, SafeString, \
-    SafeUnicode
+from django.utils.safestring import EscapeString, SafeString
+
+if six.PY3:
+    import pickle
+    EscapeUnicode = EscapeString
+    SafeUnicode = SafeString
+    StandardError = Exception
+else:
+    import cPickle as pickle
+    from django.utils.safestring import EscapeUnicode, SafeUnicode
 from django.utils import timezone
 
 from .creation import NonrelDatabaseCreation
@@ -435,7 +443,7 @@ def _value_for_db_collection(self, value, field, field_kind, db_type,
                 value = (
                     (key, self._value_for_db(subvalue, subfield,
                                              subkind, db_subtype, lookup))
-                    for key, subvalue in value.iteritems())
+                    for key, subvalue in six.iteritems(value))
 
                 # Return just a dict, a once-flattened list;
                 if db_type == 'dict':
@@ -492,7 +500,7 @@ def _value_from_db_collection(self, value, field, field_kind, db_type):
             if db_type == 'list':
                 value = zip(value[::2], value[1::2])
             else:
-                value = value.iteritems()
+                value = six.iteritems(value)
 
             # DictField needs to hold a dict.
             return dict(
@@ -551,7 +559,7 @@ def _value_for_db_model(self, value, field, field_kind, db_type, lookup):
         value = (
             (subfield.column, self._value_for_db(
                 subvalue, lookup=lookup, *self._convert_as(subfield, lookup)))
-            for subfield, subvalue in value.iteritems())
+            for subfield, subvalue in six.iteritems(value))
 
         # Cast to a dict, interleave columns with values on a list,
         # serialize, or return a generator.

djangotoolbox/db/basecompiler.py

@@ -10,6 +10,7 @@
 from django.db.models.sql.where import AND, OR
 from django.db.utils import DatabaseError, IntegrityError
 from django.utils.tree import Node
+from django.utils import six
 from django.db import connections
 
 try:
@@ -209,7 +210,7 @@ def _decode_child(self, child):
                 raise DatabaseError("This database doesn't support filtering "
                                     "on non-primary key ForeignKey fields.")
 
-            field = (f for f in opts.fields if f.column == column).next()
+            field = six.next(f for f in opts.fields if f.column == column)
             assert field.rel is not None
 
         value = self._normalize_lookup_value(
@@ -388,7 +389,7 @@ def execute_sql(self, result_type=MULTI):
         Handles SQL-like aggregate queries. This class only emulates COUNT
         by using abstract NonrelQuery.count method.
         """
-        aggregates = self.query.aggregate_select.values()
+        aggregates = list(self.query.aggregate_select.values())
 
         # Simulate a count().
         if aggregates:
@@ -503,7 +504,7 @@ def get_fields(self):
             db_table = self.query.model._meta.db_table
             only_load = dict((k, v) for k, v in only_load.items()
                              if v or k == db_table)
-            if len(only_load.keys()) > 1:
+            if len(only_load) > 1:
                 raise DatabaseError("Multi-table inheritance is not "
                                     "supported by non-relational DBs %s." %
                                     repr(only_load))

djangotoolbox/fields.py

@@ -6,6 +6,7 @@
 from django.db.models.fields.subclassing import Creator
 from django.db.utils import IntegrityError
 from django.db.models.fields.related import add_lazy_relation
+from django.utils import six
 
 
 __all__ = ('RawField', 'ListField', 'SetField', 'DictField',
@@ -81,11 +82,11 @@ def contribute_to_class(self, cls, name):
         super(AbstractIterableField, self).contribute_to_class(cls, name)
 
         # If items' field uses SubfieldBase we also need to.
-        item_metaclass = getattr(self.item_field, '__metaclass__', None)
-        if item_metaclass and issubclass(item_metaclass, models.SubfieldBase):
+        item_metaclass = type(self.item_field)
+        if issubclass(item_metaclass, models.SubfieldBase):
             setattr(cls, self.name, Creator(self))
 
-        if isinstance(self.item_field, models.ForeignKey) and isinstance(self.item_field.rel.to, basestring):
+        if isinstance(self.item_field, models.ForeignKey) and isinstance(self.item_field.rel.to, six.string_types):
             """
             If rel.to is a string because the actual class is not yet defined, look up the
             actual class later.  Refer to django.models.fields.related.RelatedField.contribute_to_class.
@@ -225,15 +226,15 @@ def get_internal_type(self):
 
     def _map(self, function, iterable, *args, **kwargs):
         return self._type((key, function(value, *args, **kwargs))
-                          for key, value in iterable.iteritems())
+                          for key, value in six.iteritems(iterable))
 
     def validate(self, values, model_instance):
         if not isinstance(values, dict):
             raise ValidationError("Value is of type %r. Should be a dict." %
                                   type(values))
 
 
-class EmbeddedModelField(models.Field):
+class EmbeddedModelField(six.with_metaclass(models.SubfieldBase, models.Field)):
     """
     Field that allows you to embed a model instance.
 
@@ -245,8 +246,6 @@ class EmbeddedModelField(models.Field):
           the embedded instance (not just pre_save, get_db_prep_* and
           to_python).
     """
-    __metaclass__ = models.SubfieldBase
-
     def __init__(self, embedded_model=None, *args, **kwargs):
         self.embedded_model = embedded_model
         kwargs.setdefault('default', None)
@@ -271,7 +270,7 @@ def _set_model(self, model):
         our "model" attribute in its contribute_to_class method).
         """
         self._model = model
-        if model is not None and isinstance(self.embedded_model, basestring):
+        if model is not None and isinstance(self.embedded_model, six.string_types):
 
             def _resolve_lookup(self_, resolved_model, model):
                 self.embedded_model = resolved_model

djangotoolbox/test.py

@@ -42,14 +42,14 @@ def validate_state(self, columns, *state_table):
         current_state = object_list_to_table(
             columns, self.model.all())[1:]
         if not equal_lists(current_state, state_table):
-            print "DB state not valid:"
-            print "Current state:"
-            print columns
+            print("DB state not valid:")
+            print("Current state:")
+            print(columns)
             for state in current_state:
-                print state
-            print "Should be:"
+                print(state)
+            print("Should be:")
             for state in state_table:
-                print state
+                print(state)
             self.fail("DB state not valid.")
 
 

djangotoolbox/tests.py

@@ -10,6 +10,7 @@
 from django.dispatch.dispatcher import receiver
 from django.test import TestCase
 from django.utils.unittest import expectedFailure, skip
+from django.utils import six
 
 from .fields import ListField, SetField, DictField, EmbeddedModelField
 
@@ -217,7 +218,7 @@ def test_chained_filter(self):
     def test_setfield(self):
         setdata = [1, 2, 3, 2, 1]
         # At the same time test value conversion.
-        SetModel(setfield=map(str, setdata)).save()
+        SetModel(setfield=list(map(str, setdata))).save()
         item = SetModel.objects.filter(setfield=3)[0]
         self.assertEqual(item.setfield, set(setdata))
         # This shouldn't raise an error because the default value is
@@ -392,29 +393,29 @@ def test_error_messages(self):
 
     def test_typed_listfield(self):
         EmbeddedModelFieldModel.objects.create(
-            typed_list=[SetModel(setfield=range(3)),
-                        SetModel(setfield=range(9))],
-            ordered_list=[Target(index=i) for i in xrange(5, 0, -1)])
+            typed_list=[SetModel(setfield=list(range(3))),
+                        SetModel(setfield=list(range(9)))],
+            ordered_list=[Target(index=i) for i in six.moves.xrange(5, 0, -1)])
         obj = EmbeddedModelFieldModel.objects.get()
         self.assertIn(5, obj.typed_list[1].setfield)
         self.assertEqual([target.index for target in obj.ordered_list],
-                         range(1, 6))
+                         list(range(1, 6)))
 
     def test_untyped_listfield(self):
         EmbeddedModelFieldModel.objects.create(untyped_list=[
             EmbeddedModel(someint=7),
-            OrderedListModel(ordered_ints=range(5, 0, -1)),
+            OrderedListModel(ordered_ints=list(range(5, 0, -1))),
             SetModel(setfield=[1, 2, 2, 3])])
         instances = EmbeddedModelFieldModel.objects.get().untyped_list
         for instance, cls in zip(instances,
                                  [EmbeddedModel, OrderedListModel, SetModel]):
             self.assertIsInstance(instance, cls)
         self.assertNotEqual(instances[0].auto_now, None)
-        self.assertEqual(instances[1].ordered_ints, range(1, 6))
+        self.assertEqual(instances[1].ordered_ints, list(range(1, 6)))
 
     def test_untyped_dict(self):
         EmbeddedModelFieldModel.objects.create(untyped_dict={
-            'a': SetModel(setfield=range(3)),
+            'a': SetModel(setfield=list(range(3))),
             'b': DictModel(dictfield={'a': 1, 'b': 2}),
             'c': DictModel(dictfield={}, auto_now={'y': 1})})
         data = EmbeddedModelFieldModel.objects.get().untyped_dict