Flake8 all the things

stdqs/__init__.py

@@ -1,2 +1,5 @@
-from stdqs.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
-from stdqs.queryset import get_queryset as qs, QuerySet
+from stdqs.exceptions import (  # noqa: F401
+    ObjectDoesNotExist,
+    MultipleObjectsReturned,
+)
+from stdqs.queryset import get_queryset as qs, QuerySet  # noqa: F401

stdqs/parsing/__init__.py

@@ -1,15 +1,11 @@
-from stdqs.parsing.lookups import (
+from stdqs.parsing.lookups import (  # noqa: F401
     Lookup,
     registry as lookup_registry,
-    register as register_lookup,
-    unregister as unregister_lookup,
 )
-from stdqs.parsing.transforms import (
+from stdqs.parsing.transforms import (  # noqa: F401
     Transform,
     GetterTransform,
     registry as transform_registry,
-    register as register_transform,
-    unregister as unregister_transform,
 )
 
 
@@ -19,13 +15,11 @@ class QueryParser(object):
         """
         Parses a list of fields and returns a list of Transforms to apply.
         """
-        print(fields)
         return [
             transform_registry.get(field, GetterTransform)(field)
             for field in fields
         ]
 
-
     def parse_filter(self, key, value):
         """
         Parses a key/value combination for a filter and returns a list of

stdqs/parsing/lookups.py

@@ -30,7 +30,11 @@ class Lookup(metaclass=LookupMetaclass):
         """
 
     def __repr__(self):
-        return '{}({},{})'.format(self.__class__.__name__, repr(self.lhs), repr(self.rhs))
+        return '{}({!r},{!r})'.format(
+            self.__class__.__name__,
+            self.lhs,
+            self.rhs,
+        )
 
 
 def func_lookup(func, name=None):
@@ -70,7 +74,8 @@ class LookupRegistry(Registry):
         """
         Register a lookup.
         May be used as register(lookup_class) if the lookup has a defined name,
-        or as register(name, lookup_class) or register(lookup_class, name) to set a custom name.
+        or as register(name, lookup_class) or register(lookup_class, name)
+        to set a custom name.
         Can be used as a decorator on a Lookup if it has a defined name.
         """
         if value:
@@ -85,8 +90,10 @@ class LookupRegistry(Registry):
                 raise
 
         if not getattr(key, 'lookup_name', None):
-            raise KeyError('Lookup is missing a lookup name.'
-                           'Set the lookup_name attribute or use register(name, lookup).')
+            raise KeyError(
+                'Lookup is missing a lookup name.'
+                'Set the lookup_name attribute or use register(name, lookup).'
+            )
 
         super().register(key.lookup_name, key)
 

stdqs/queryset.py

@@ -26,11 +26,9 @@ class QuerySet(Sequence):
         return self.exists()
 
     def __repr__(self):
-        #data = list(self[:REPR_OUTPUT_SIZE+1])
-        #if len(data) > REPR_OUTPUT_SIZE:
-        #    data[-1] = '...(remaining elements truncated)...'
-        data = list(self)
-        return '<{} {!r}>'.format(self.__class__.__name__, data)
+        data = list(self[:REPR_OUTPUT_SIZE+1])
+        if len(data) > REPR_OUTPUT_SIZE:
+            data[-1] = '...(remaining elements truncated)...'
 
     def __getitem__(self, item):
         raise NotImplementedError
@@ -49,7 +47,8 @@ class QuerySet(Sequence):
             result = transform.transform_obj(obj)
             if result is NotImplemented:
                 raise NotImplementedError(
-                    '{!r} does not implement transformation for {!r}'.format(transform, obj),
+                    '{!r} does not implement transformation for {!r}'.format(
+                        transform, obj),
                 )
             if isinstance(result, Iterator):
                 result = list(result)
@@ -106,8 +105,15 @@ class QuerySet(Sequence):
     def filter(self, **filters):
         # TODO: QuerySet._clone()
         new_filters = self._filters.copy()
-        new_filters.extend(map(self.query_parser.parse_filter, *zip(*filters.items())))
-        return self.__class__(self.collection, filters=new_filters, values=self._values)
+        new_filters.extend(map(
+            self.query_parser.parse_filter,
+            *zip(*filters.items())
+        ))
+        return self.__class__(
+            self.collection,
+            filters=new_filters,
+            values=self._values,
+        )
 
     def exclude(self, **filters):
         raise NotImplementedError
@@ -165,7 +171,8 @@ class QuerySetRegistry(Registry):
         assert isinstance(key, type), \
             '{!r} should be a class'.format(key)
         assert issubclass(key, Collection), \
-            '{} should implement all methods of collections.abc.Collection'.format(key.__name__)
+            '{} should implement all methods of ' \
+            'collections.abc.Collection'.format(key.__name__)
 
     def check_value(self, value):
         assert isinstance(value, type) and issubclass(value, QuerySet), \

stdqs/utils.py

@@ -36,15 +36,16 @@ class Registry(dict):
 
 def flatten(data):
     """
-    Turns data structured in nested iterables into data suitable for filtering with QuerySets.
+    Turns data structured in nested iterables into data suitable for filtering
+    with QuerySets.
     """
-    if isinstance(data, Mapping): 
-        for k, v in data.items(): 
-            for r in flatten(v): 
-                yield {k: r} 
+    if isinstance(data, Mapping):
+        for k, v in data.items():
+            for r in flatten(v):
+                yield {k: r}
 
     elif isinstance(data, Iterable):
         yield from map(flatten, data)
 
-    else: 
-        yield data 
+    else:
+        yield data