drop Python v2.6 support and use dict comprehensions

.travis.yml

@@ -1,7 +1,6 @@
 language: python
 
 python:
-- '2.6'
 - '2.7'
 - '3.3'
 - '3.4'

mongoengine/base/document.py

@@ -416,33 +416,26 @@ class BaseDocument(object):
         return cls._from_son(json_util.loads(json_data), created=created)
 
     def __expand_dynamic_values(self, name, value):
-        """expand any dynamic values to their correct types / values"""
+        """Expand any dynamic values to their correct types / values."""
         if not isinstance(value, (dict, list, tuple)):
             return value
 
-        EmbeddedDocumentListField = _import_class('EmbeddedDocumentListField')
+        # If the value is a dict with '_cls' in it, turn it into a document
-
+        is_dict = isinstance(value, dict)
-        is_list = False
+        if is_dict and '_cls' in value:
-        if not hasattr(value, 'items'):
-            is_list = True
-            value = dict([(k, v) for k, v in enumerate(value)])
-
-        if not is_list and '_cls' in value:
             cls = get_document(value['_cls'])
             return cls(**value)
 
-        data = {}
+        if is_dict:
-        for k, v in value.items():
+            value = {
-            key = name if is_list else k
+                k: self.__expand_dynamic_values(k, v)
-            data[k] = self.__expand_dynamic_values(key, v)
+                for k, v in value.items()
-
+            }
-        if is_list:  # Convert back to a list
-            data_items = sorted(data.items(), key=operator.itemgetter(0))
-            value = [v for k, v in data_items]
         else:
-            value = data
+            value = [self.__expand_dynamic_values(name, v) for v in value]
 
         # Convert lists / values so we can watch for any changes on them
+        EmbeddedDocumentListField = _import_class('EmbeddedDocumentListField')
         if (isinstance(value, (list, tuple)) and
                 not isinstance(value, BaseList)):
             if issubclass(type(self), EmbeddedDocumentListField):
@@ -682,7 +675,7 @@ class BaseDocument(object):
         # get the class name from the document, falling back to the given
         # class if unavailable
         class_name = son.get('_cls', cls._class_name)
-        data = dict(('%s' % key, value) for key, value in son.iteritems())
+        data = {key: value for key, value in son.iteritems()}
 
         # Return correct subclass for document type
         if class_name != cls._class_name:
@@ -714,9 +707,10 @@ class BaseDocument(object):
                    % (cls._class_name, errors))
             raise InvalidDocumentError(msg)
 
+        # In STRICT documents, remove any keys that aren't in cls._fields
         if cls.STRICT:
-            data = dict((k, v)
+            data = {k: v for k, v in data.iteritems() if k in cls._fields}
-                        for k, v in data.iteritems() if k in cls._fields)
+
         obj = cls(__auto_convert=False, _created=created, __only_fields=only_fields, **data)
         obj._changed_fields = changed_fields
         if not _auto_dereference:
@@ -738,9 +732,9 @@ class BaseDocument(object):
 
             # Create a map of index fields to index spec. We're converting
             # the fields from a list to a tuple so that it's hashable.
-            spec_fields = dict(
+            spec_fields = {
-                (tuple(index['fields']), index) for index in index_specs
+                tuple(index['fields']): index for index in index_specs
-            )
+            }
 
             # For each new index, if there's an existing index with the same
             # fields list, update the existing spec with all data from the

mongoengine/base/fields.py

@@ -297,14 +297,14 @@ class ComplexBaseField(BaseField):
         if not hasattr(value, 'items'):
             try:
                 is_list = True
-                value = dict([(k, v) for k, v in enumerate(value)])
+                value = {k: v for k, v in enumerate(value)}
             except TypeError:  # Not iterable return the value
                 return value
 
         if self.field:
             self.field._auto_dereference = self._auto_dereference
-            value_dict = dict([(key, self.field.to_python(item))
+            value_dict = {key: self.field.to_python(item)
-                               for key, item in value.items()])
+                          for key, item in value.items()}
         else:
             Document = _import_class('Document')
             value_dict = {}
@@ -349,13 +349,15 @@ class ComplexBaseField(BaseField):
         if not hasattr(value, 'items'):
             try:
                 is_list = True
-                value = dict([(k, v) for k, v in enumerate(value)])
+                value = {k: v for k, v in enumerate(value)}
             except TypeError:  # Not iterable return the value
                 return value
 
         if self.field:
-            value_dict = dict([(key, self.field._to_mongo_safe_call(item, use_db_field, fields))
+            value_dict = {
-                               for key, item in value.iteritems()])
+                key: self.field._to_mongo_safe_call(item, use_db_field, fields)
+                for key, item in value.iteritems()
+            }
         else:
             value_dict = {}
             for k, v in value.iteritems():

mongoengine/base/metaclasses.py

@@ -95,10 +95,11 @@ class DocumentMetaclass(type):
 
         # Set _fields and db_field maps
         attrs['_fields'] = doc_fields
-        attrs['_db_field_map'] = dict([(k, getattr(v, 'db_field', k))
+        attrs['_db_field_map'] = {k: getattr(v, 'db_field', k)
-                                       for k, v in doc_fields.iteritems()])
+                                  for k, v in doc_fields.items()}
-        attrs['_reverse_db_field_map'] = dict(
+        attrs['_reverse_db_field_map'] = {
-            (v, k) for k, v in attrs['_db_field_map'].iteritems())
+            v: k for k, v in attrs['_db_field_map'].items()
+        }
 
         attrs['_fields_ordered'] = tuple(i[1] for i in sorted(
                                          (v.creation_counter, v.name)

mongoengine/connection.py

@@ -148,10 +148,10 @@ def get_connection(alias=DEFAULT_CONNECTION_NAME, reconnect=False):
             'name', 'username', 'password', 'authentication_source',
             'authentication_mechanism'
         ])
-        return dict(
+        return {
-            (k, v) for k, v in settings_dict.items()
+            k: v for k, v in settings_dict.items()
             if k not in irrelevant_fields
-        )
+        }
 
     # Retrieve a copy of the connection settings associated with the requested
     # alias and remove the database name and authentication info (we don't

mongoengine/dereference.py

@@ -66,11 +66,11 @@ class DeReference(object):
 
                         items = _get_items(items)
                     else:
-                        items = dict([
+                        items = {
-                            (k, field.to_python(v))
+                            k: (v if isinstance(v, (DBRef, Document))
-                            if not isinstance(v, (DBRef, Document)) else (k, v)
+                                else field.to_python(v))
-                            for k, v in items.iteritems()]
+                            for k, v in items.iteritems()
-                        )
+                        }
 
         self.reference_map = self._find_references(items)
         self.object_map = self._fetch_objects(doc_type=doc_type)

mongoengine/fields.py

@@ -650,7 +650,7 @@ class DynamicField(BaseField):
         is_list = False
         if not hasattr(value, 'items'):
             is_list = True
-            value = dict([(k, v) for k, v in enumerate(value)])
+            value = {k: v for k, v in enumerate(value)}
 
         data = {}
         for k, v in value.iteritems():
@@ -844,9 +844,10 @@ class DictField(ComplexBaseField):
 
         if hasattr(self.field, 'field'):
             if op in ('set', 'unset') and isinstance(value, dict):
-                return dict(
+                return {
-                    (k, self.field.prepare_query_value(op, v))
+                    k: self.field.prepare_query_value(op, v)
-                    for k, v in value.items())
+                    for k, v in value.items()
+                }
             return self.field.prepare_query_value(op, value)
 
         return super(DictField, self).prepare_query_value(op, value)
@@ -1062,18 +1063,20 @@ class CachedReferenceField(BaseField):
                                   sender=self.document_type)
 
     def on_document_pre_save(self, sender, document, created, **kwargs):
-        if not created:
+        if created:
-            update_kwargs = dict(
+            return None
-                ('set__%s__%s' % (self.name, k), v)
-                for k, v in document._delta()[0].items()
-                if k in self.fields)
 
-            if update_kwargs:
+        update_kwargs = {
-                filter_kwargs = {}
+            'set__%s__%s' % (self.name, key): val
-                filter_kwargs[self.name] = document
+            for key, val in document._delta()[0].items()
+            if key in self.fields
+        }
+        if update_kwargs:
+            filter_kwargs = {}
+            filter_kwargs[self.name] = document
 
-                self.owner_document.objects(
+            self.owner_document.objects(
-                    **filter_kwargs).update(**update_kwargs)
+                **filter_kwargs).update(**update_kwargs)
 
     def to_python(self, value):
         if isinstance(value, dict):
@@ -1707,7 +1710,10 @@ class ImageField(FileField):
             raise ImproperlyConfigured('PIL library was not found')
 
         params_size = ('width', 'height', 'force')
-        extra_args = dict(size=size, thumbnail_size=thumbnail_size)
+        extra_args = {
+            'size': size,
+            'thumbnail_size': thumbnail_size
+        }
         for att_name, att in extra_args.items():
             value = None
             if isinstance(att, (tuple, list)):

mongoengine/python_support.py

@@ -1,5 +1,5 @@
 """
-Helper functions, constants, and types to aid with Python v2.6 - v3.x and
+Helper functions, constants, and types to aid with Python v2.7 - v3.x and
 PyMongo v2.7 - v3.x support.
 """
 import pymongo

mongoengine/queryset/base.py

@@ -876,7 +876,7 @@ class BaseQuerySet(object):
         .. versionadded:: 0.3
         .. versionchanged:: 0.5 - Added subfield support
         """
-        fields = dict([(f, QueryFieldList.ONLY) for f in fields])
+        fields = {f: QueryFieldList.ONLY for f in fields}
         self.only_fields = fields.keys()
         return self.fields(True, **fields)
 
@@ -897,7 +897,7 @@ class BaseQuerySet(object):
 
         .. versionadded:: 0.5
         """
-        fields = dict([(f, QueryFieldList.EXCLUDE) for f in fields])
+        fields = {f: QueryFieldList.EXCLUDE for f in fields}
         return self.fields(**fields)
 
     def fields(self, _only_called=False, **kwargs):
@@ -1553,7 +1553,7 @@ class BaseQuerySet(object):
                     emit(null, 1);
                 }
             }
-        """ % dict(field=field)
+        """ % {'field': field}
         reduce_func = """
             function(key, values) {
                 var total = 0;
@@ -1575,8 +1575,8 @@ class BaseQuerySet(object):
 
         if normalize:
             count = sum(frequencies.values())
-            frequencies = dict([(k, float(v) / count)
+            frequencies = {k: float(v) / count
-                                for k, v in frequencies.items()])
+                           for k, v in frequencies.items()}
 
         return frequencies
 
@@ -1628,10 +1628,10 @@ class BaseQuerySet(object):
             }
         """
         total, data, types = self.exec_js(freq_func, field)
-        values = dict([(types.get(k), int(v)) for k, v in data.iteritems()])
+        values = {types.get(k): int(v) for k, v in data.iteritems()}
 
         if normalize:
-            values = dict([(k, float(v) / total) for k, v in values.items()])
+            values = {k: float(v) / total for k, v in values.items()}
 
         frequencies = {}
         for k, v in values.iteritems():

mongoengine/queryset/field_list.py

@@ -67,7 +67,7 @@ class QueryFieldList(object):
         return bool(self.fields)
 
     def as_dict(self):
-        field_list = dict((field, self.value) for field in self.fields)
+        field_list = {field: self.value for field in self.fields}
         if self.slice:
             field_list.update(self.slice)
         if self._id is not None:

tests/__init__.py

@@ -2,4 +2,3 @@ from all_warnings import AllWarnings
 from document import *
 from queryset import *
 from fields import *
-from migration import *

tests/document/instance.py

@@ -805,7 +805,7 @@ class InstanceTest(unittest.TestCase):
 
         self.assertRaises(
             InvalidQueryError,
-            lambda: doc1.modify(dict(id=doc2.id), set__value=20))
+            lambda: doc1.modify({'id': doc2.id}, set__value=20))
 
         self.assertDbEqual(docs)
 
@@ -814,7 +814,7 @@ class InstanceTest(unittest.TestCase):
         doc2 = self.Person(name="jim", age=20).save()
         docs = [dict(doc1.to_mongo()), dict(doc2.to_mongo())]
 
-        assert not doc1.modify(dict(name=doc2.name), set__age=100)
+        assert not doc1.modify({'name': doc2.name}, set__age=100)
 
         self.assertDbEqual(docs)
 
@@ -823,7 +823,7 @@ class InstanceTest(unittest.TestCase):
         doc2 = self.Person(id=ObjectId(), name="jim", age=20)
         docs = [dict(doc1.to_mongo())]
 
-        assert not doc2.modify(dict(name=doc2.name), set__age=100)
+        assert not doc2.modify({'name': doc2.name}, set__age=100)
 
         self.assertDbEqual(docs)
 

tests/queryset/field_list.py

@@ -92,7 +92,7 @@ class OnlyExcludeAllTest(unittest.TestCase):
         exclude = ['d', 'e']
         only = ['b', 'c']
 
-        qs = MyDoc.objects.fields(**dict(((i, 1) for i in include)))
+        qs = MyDoc.objects.fields(**{i: 1 for i in include})
         self.assertEqual(qs._loaded_fields.as_dict(),
                          {'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1})
         qs = qs.only(*only)
@@ -100,14 +100,14 @@ class OnlyExcludeAllTest(unittest.TestCase):
         qs = qs.exclude(*exclude)
         self.assertEqual(qs._loaded_fields.as_dict(), {'b': 1, 'c': 1})
 
-        qs = MyDoc.objects.fields(**dict(((i, 1) for i in include)))
+        qs = MyDoc.objects.fields(**{i: 1 for i in include})
         qs = qs.exclude(*exclude)
         self.assertEqual(qs._loaded_fields.as_dict(), {'a': 1, 'b': 1, 'c': 1})
         qs = qs.only(*only)
         self.assertEqual(qs._loaded_fields.as_dict(), {'b': 1, 'c': 1})
 
         qs = MyDoc.objects.exclude(*exclude)
-        qs = qs.fields(**dict(((i, 1) for i in include)))
+        qs = qs.fields(**{i: 1 for i in include})
         self.assertEqual(qs._loaded_fields.as_dict(), {'a': 1, 'b': 1, 'c': 1})
         qs = qs.only(*only)
         self.assertEqual(qs._loaded_fields.as_dict(), {'b': 1, 'c': 1})
@@ -126,7 +126,7 @@ class OnlyExcludeAllTest(unittest.TestCase):
         exclude = ['d', 'e']
         only = ['b', 'c']
 
-        qs = MyDoc.objects.fields(**dict(((i, 1) for i in include)))
+        qs = MyDoc.objects.fields(**{i: 1 for i in include})
         qs = qs.exclude(*exclude)
         qs = qs.only(*only)
         qs = qs.fields(slice__b=5)

tests/queryset/queryset.py

@@ -617,11 +617,11 @@ class QuerySetTest(unittest.TestCase):
             members = DictField()
 
         club = Club()
-        club.members['John'] = dict(gender="M", age=13)
+        club.members['John'] = {'gender': 'M', 'age': 13}
         club.save()
 
         Club.objects().update(
-            set__members={"John": dict(gender="F", age=14)})
+            set__members={"John": {'gender': 'F', 'age': 14}})
 
         club = Club.objects().first()
         self.assertEqual(club.members['John']['gender'], "F")
@@ -2610,7 +2610,7 @@ class QuerySetTest(unittest.TestCase):
         BlogPost(hits=2, tags=['music', 'actors']).save()
 
         def test_assertions(f):
-            f = dict((key, int(val)) for key, val in f.items())
+            f = {key: int(val) for key, val in f.items()}
             self.assertEqual(
                 set(['music', 'film', 'actors', 'watch']), set(f.keys()))
             self.assertEqual(f['music'], 3)
@@ -2625,7 +2625,7 @@ class QuerySetTest(unittest.TestCase):
 
         # Ensure query is taken into account
         def test_assertions(f):
-            f = dict((key, int(val)) for key, val in f.items())
+            f = {key: int(val) for key, val in f.items()}
             self.assertEqual(set(['music', 'actors', 'watch']), set(f.keys()))
             self.assertEqual(f['music'], 2)
             self.assertEqual(f['actors'], 1)
@@ -2689,7 +2689,7 @@ class QuerySetTest(unittest.TestCase):
         doc.save()
 
         def test_assertions(f):
-            f = dict((key, int(val)) for key, val in f.items())
+            f = {key: int(val) for key, val in f.items()}
             self.assertEqual(
                 set(['62-3331-1656', '62-3332-1656']), set(f.keys()))
             self.assertEqual(f['62-3331-1656'], 2)
@@ -2703,7 +2703,7 @@ class QuerySetTest(unittest.TestCase):
 
         # Ensure query is taken into account
         def test_assertions(f):
-            f = dict((key, int(val)) for key, val in f.items())
+            f = {key: int(val) for key, val in f.items()}
             self.assertEqual(set(['62-3331-1656']), set(f.keys()))
             self.assertEqual(f['62-3331-1656'], 2)
 
@@ -4880,7 +4880,7 @@ class QuerySetTest(unittest.TestCase):
     def test_subclass_field_query(self):
         class Animal(Document):
             is_mamal = BooleanField()
-            meta = dict(allow_inheritance=True)
+            meta = {'allow_inheritance': True}
 
         class Cat(Animal):
             whiskers_length = FloatField()

tests/test_dereference.py

@@ -617,10 +617,10 @@ class FieldTest(unittest.TestCase):
             user.save()
             members.append(user)
 
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
 
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
 
         with query_counter() as q:
@@ -697,9 +697,9 @@ class FieldTest(unittest.TestCase):
 
             members += [a, b, c]
 
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
 
         with query_counter() as q:
@@ -787,10 +787,10 @@ class FieldTest(unittest.TestCase):
 
             members += [a]
 
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
 
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
 
         with query_counter() as q:
@@ -876,9 +876,9 @@ class FieldTest(unittest.TestCase):
 
             members += [a, b, c]
 
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
-        group = Group(members=dict([(str(u.id), u) for u in members]))
+        group = Group(members={str(u.id): u for u in members})
         group.save()
 
         with query_counter() as q: