PEP8 and import sort

Author: qwiglydee

Diff for: rest_framework_mongoengine/fields.py

@@ -1,23 +1,20 @@
 from collections import OrderedDict
 
+from bson import DBRef, ObjectId
+from bson.errors import InvalidId
 from django.utils import six
 from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
-
-from rest_framework import serializers
-from rest_framework.exceptions import ValidationError
-from rest_framework.fields import empty
-
-from bson import ObjectId, DBRef
-from bson.errors import InvalidId
-
+from mongoengine import fields as me_fields
+from mongoengine import Document, EmbeddedDocument
 from mongoengine.base import get_document
 from mongoengine.base.common import _document_registry
-from mongoengine.errors import ValidationError as MongoValidationError, NotRegistered
-
+from mongoengine.errors import ValidationError as MongoValidationError
+from mongoengine.errors import DoesNotExist, NotRegistered
 from mongoengine.queryset import QuerySet, QuerySetManager
-from mongoengine import EmbeddedDocument, Document, fields as me_fields
-from mongoengine.errors import DoesNotExist
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+from rest_framework.fields import empty
 
 
 class ObjectIdField(serializers.Field):
@@ -110,7 +107,7 @@ def to_internal_value(self, data):
     def to_representation(self, doc):
         if not isinstance(doc, EmbeddedDocument):
             self.fail('not_a_doc', input_type=type(doc).__name__)
-        data = { '_cls': doc.__class__.__name__}
+        data = {'_cls': doc.__class__.__name__}
         for field_name in doc._fields:
             if not hasattr(doc, field_name):
                 continue
@@ -219,13 +216,13 @@ def __init__(self, model=None, queryset=None, **kwargs):
             'Reference field must provide a `queryset` or `model` argument, '
             'or set read_only=`True`.'
         )
-        super(ReferenceField,self).__init__(**kwargs)
+        super(ReferenceField, self).__init__(**kwargs)
 
     def run_validation(self, data=empty):
         # We force empty strings to None values for relational fields.
         if data == '':
             data = None
-        return super(ReferenceField,self).run_validation(data)
+        return super(ReferenceField, self).run_validation(data)
 
     def get_queryset(self):
         queryset = self.queryset
@@ -256,7 +253,7 @@ def grouped_choices(self):
     def display_value(self, instance):
         return six.text_type(instance)
 
-    def parse_id(self,value):
+    def parse_id(self, value):
         try:
             return self.pk_field.to_internal_value(value)
         except:
@@ -306,9 +303,9 @@ class GenericReferenceField(serializers.Field):
 
     def __init__(self, **kwargs):
         self.pk_field = self.pk_field_class()
-        super(GenericReferenceField,self).__init__(**kwargs)
+        super(GenericReferenceField, self).__init__(**kwargs)
 
-    def parse_id(self,value):
+    def parse_id(self, value):
         try:
             return self.pk_field.to_internal_value(value)
         except:
@@ -325,7 +322,7 @@ def to_internal_value(self, value):
         try:
             doc_cls = get_document(doc_name)
         except NotRegistered:
-            self.fail('undefined_model', doc_cls = doc_name)
+            self.fail('undefined_model', doc_cls=doc_name)
 
         try:
             doc_id = self.pk_field.to_internal_value(doc_id)
@@ -337,20 +334,19 @@ def to_internal_value(self, value):
         except DoesNotExist:
             self.fail('not_found', pk_value=doc_id)
 
-
     def to_representation(self, value):
         assert isinstance(value, (Document, DBRef))
         if isinstance(value, Document):
             doc_id = value.id
             doc_cls = value.__class__.__name__
-        if isinstance(value, DBRef): # hard case
+        if isinstance(value, DBRef):  # hard case
             doc_id = value.id
             doc_collection = value.collection
-            class_match = [ k for k,v in _document_registry.items() if v._get_collection_name() == doc_collection ]
+            class_match = [k for k, v in _document_registry.items() if v._get_collection_name() == doc_collection]
             if len(class_match) != 1:
                 self.fail('unmapped_collection', collection=doc_collection)
             doc_cls = class_match[0]
-        return { '_cls': doc_cls, '_id': self.pk_field.to_representation(doc_id) }
+        return {'_cls': doc_cls, '_id': self.pk_field.to_representation(doc_id)}
 
 
 class MongoValidatingField(object):
@@ -386,7 +382,7 @@ def to_internal_value(self, value):
         if len(value) != 2:
             self.fail('not_2d', input_value=repr(value))
         try:
-            return [ float(value[0]), float(value[1]) ]
+            return [float(value[0]), float(value[1])]
         except ValueError:
             self.fail('not_float', input_value=repr(value))
 
@@ -434,4 +430,4 @@ def to_internal_value(self, value):
         return value['coordinates']
 
     def to_representation(self, value):
-        return { 'type': self.mongo_field._type, 'coordinates': value}
+        return {'type': self.mongo_field._type, 'coordinates': value}

Diff for: rest_framework_mongoengine/generics.py

@@ -1,8 +1,7 @@
-from rest_framework import mixins
-from rest_framework import generics as drf_generics
-
-from mongoengine.queryset.base import BaseQuerySet
 from mongoengine import ValidationError
+from mongoengine.queryset.base import BaseQuerySet
+from rest_framework import generics as drf_generics
+from rest_framework import mixins
 
 
 class GenericAPIView(drf_generics.GenericAPIView):

Diff for: rest_framework_mongoengine/repr.py

@@ -4,22 +4,22 @@
 """
 from __future__ import unicode_literals
 
-from django.utils import six
-from django.utils.encoding import force_str
-
 import re
 
+from django.utils import six
+from django.utils.encoding import force_str
+from mongoengine.base import BaseDocument
+from mongoengine.fields import BaseField
+from mongoengine.queryset import QuerySet
 from rest_framework.compat import unicode_repr
 from rest_framework.fields import Field
-from mongoengine.queryset import QuerySet
-from mongoengine.fields import BaseField
-from mongoengine.base import BaseDocument
 
 
 def manager_repr(value):
     model = value._document
     return '%s.objects' % (model.__name__,)
 
+
 def mongo_field_repr(value):
     # mimic django models.Field.__repr__
     path = '%s.%s' % (value.__class__.__module__, value.__class__.__name__)
@@ -28,6 +28,7 @@ def mongo_field_repr(value):
         return '<%s: %s>' % (path, name)
     return '<%s>' % path
 
+
 def mongo_doc_repr(value):
     # mimic django models.Model.__repr__
     try:
@@ -38,6 +39,7 @@ def mongo_doc_repr(value):
 
 uni_lit_re = re.compile("u'(.*?)'")
 
+
 def smart_repr(value):
     if isinstance(value, QuerySet):
         return manager_repr(value)

Diff for: rest_framework_mongoengine/routers.py

@@ -8,8 +8,8 @@ class MongoRouterMixin(object):
     """
     def get_default_base_name(self, viewset):
         queryset = getattr(viewset, 'queryset', None)
-        assert queryset is not None, ('`base_name` argument not specified, and could ' \
-                                      'not automatically determine the name from the viewset, as ' \
+        assert queryset is not None, ('`base_name` argument not specified, and could '
+                                      'not automatically determine the name from the viewset, as '
                                       'it does not have a `.queryset` attribute.')
         return queryset._document.__name__.lower()
 

Diff for: rest_framework_mongoengine/serializers.py

@@ -3,32 +3,19 @@
 
 from mongoengine import fields as me_fields
 from mongoengine.errors import ValidationError as me_ValidationError
-
-from rest_framework import serializers
 from rest_framework import fields as drf_fields
-from rest_framework.utils.field_mapping import ClassLookupDict
+from rest_framework import serializers
 from rest_framework.compat import unicode_to_repr
+from rest_framework.utils.field_mapping import ClassLookupDict
+from rest_framework_mongoengine.validators import (UniqueTogetherValidator,
+                                                   UniqueValidator)
 
-from rest_framework_mongoengine.validators import UniqueValidator, UniqueTogetherValidator
-
-
-from .fields import (ObjectIdField,
-                     DocumentField,
-                     GenericEmbeddedDocumentField,
-                     DynamicField,
-                     ReferenceField,
-                     GenericReferenceField,
-                     GeoPointField,
-                     GeoJSONField)
-
-from .utils import (is_abstract_model,
-                    get_field_info,
-                    get_field_kwargs,
-                    get_relation_kwargs,
-                    has_default,
-                    COMPOUND_FIELD_TYPES)
-
+from .fields import (DocumentField, DynamicField, GenericEmbeddedDocumentField,
+                     GenericReferenceField, GeoJSONField, GeoPointField,
+                     ObjectIdField, ReferenceField)
 from .repr import serializer_repr
+from .utils import (COMPOUND_FIELD_TYPES, get_field_info, get_field_kwargs,
+                    get_relation_kwargs, has_default, is_abstract_model)
 
 
 def raise_errors_on_nested_writes(method_name, serializer, validated_data):
@@ -239,7 +226,6 @@ def get_fields(self):
                 'Cannot use ModelSerializer with Abstract Models.'
             )
 
-
         # Retrieve metadata about fields & relationships on the model class.
         self.field_info = get_field_info(model)
         field_names = self.get_field_names(declared_fields, self.field_info)
@@ -277,7 +263,6 @@ def get_fields(self):
 
         return fields
 
-
     def get_default_field_names(self, declared_fields, model_info):
         return (
             [model_info.pk.name] +
@@ -291,7 +276,7 @@ def build_field(self, field_name, info, model_class, nested_depth):
         if field_name in info.fields_and_pk:
             model_field = info.fields_and_pk[field_name]
             if isinstance(model_field, COMPOUND_FIELD_TYPES):
-                child_name = field_name+'.child'
+                child_name = field_name + '.child'
                 if child_name in info.fields or child_name in info.embedded:
                     child_class, child_kwargs = self.build_field(child_name, info, model_class, nested_depth)
                     child_field = child_class(**child_kwargs)
@@ -314,7 +299,6 @@ def build_field(self, field_name, info, model_class, nested_depth):
 
         return self.build_unknown_field(field_name, model_class)
 
-
     def build_standard_field(self, field_name, model_field):
         field_mapping = ClassLookupDict(self.serializer_field_mapping)
 
@@ -380,7 +364,7 @@ class Meta:
                     depth = nested_depth - 1
 
             field_class = NestedSerializer
-            field_kwargs = { 'read_only': True }
+            field_kwargs = {'read_only': True}
         elif relation_info.related_model:
             field_class = ReferenceField
             field_kwargs = get_relation_kwargs(field_name, relation_info)
@@ -411,7 +395,6 @@ class Meta:
 
         return field_class, field_kwargs
 
-
     def get_uniqueness_extra_kwargs(self, field_names, extra_kwargs):
         # extra_kwargs contains 'default', 'required', 'validators=[UniqValidator]'
         # hidden_fields contains fields involved in constraints, but missing in serializer fields
@@ -427,7 +410,7 @@ def get_uniqueness_extra_kwargs(self, field_names, extra_kwargs):
 
         # include `unique_with` from model indexes
         # so long as all the field names are included on the serializer.
-        uniq_indexes = filter(lambda i: i.get('unique',False), model._meta.get('index_specs',[]))
+        uniq_indexes = filter(lambda i: i.get('unique', False), model._meta.get('index_specs', []))
         for idx in uniq_indexes:
             field_set = set(map(lambda e: e[0], idx['fields']))
             if field_names.issuperset(field_set):
@@ -445,9 +428,9 @@ def get_uniqueness_extra_kwargs(self, field_names, extra_kwargs):
         for field_name in unique_together_fields:
             fld = model._fields[field_name]
             if has_default(fld):
-                uniq_extra_kwargs[field_name] = { 'default': fld.default }
+                uniq_extra_kwargs[field_name] = {'default': fld.default}
             else:
-                uniq_extra_kwargs[field_name] = { 'required': True }
+                uniq_extra_kwargs[field_name] = {'required': True}
 
         # Update `extra_kwargs` with any new options.
         for key, value in uniq_extra_kwargs.items():
@@ -465,9 +448,9 @@ def get_unique_together_validators(self):
         validators = []
         field_names = set(self.get_field_names(self._declared_fields, self.field_info))
 
-        uniq_indexes = filter(lambda i: i.get('unique',False), model._meta.get('index_specs',[]))
+        uniq_indexes = filter(lambda i: i.get('unique', False), model._meta.get('index_specs', []))
         for idx in uniq_indexes:
-            if not idx.get('unique',False):
+            if not idx.get('unique', False):
                 continue
             field_set = tuple(map(lambda e: e[0], idx['fields']))
             if len(field_set) > 1 and field_names.issuperset(set(field_set)):
@@ -506,7 +489,7 @@ def get_unique_together_validators(self):
 
     def to_internal_value(self, data):
         # run nested validation and convert to document instance
-        data = super(EmbeddedDocumentSerializer,self).to_internal_value(data)
+        data = super(EmbeddedDocumentSerializer, self).to_internal_value(data)
         return self.Meta.model(**data)
 
 
@@ -516,7 +499,7 @@ class DynamicDocumentSerializer(DocumentSerializer):
     Maps all undefined fields to :class:`fields.DynamicField`.
     """
     def to_representation(self, instance):
-        ret = super(DynamicDocumentSerializer,self).to_representation(instance)
+        ret = super(DynamicDocumentSerializer, self).to_representation(instance)
 
         for field_name, field in self._map_dynamic_fields(instance).items():
             ret[field_name] = field.to_representation(field.get_attribute(instance))