initial swath of yapf formatting changes

src/bitfield/admin.py

@@ -21,8 +21,8 @@ class BitFieldListFilter(FieldListFilter):
         self.lookup_val = int(request.GET.get(self.lookup_kwarg, 0))
         self.flags = field.flags
         self.labels = field.labels
-        super(BitFieldListFilter, self).__init__(
-            field, request, params, model, model_admin, field_path)
+        super(BitFieldListFilter,
+              self).__init__(field, request, params, model, model_admin, field_path)
 
     def queryset(self, request, queryset):
         filter = dict((p, bitor(F(p), v)) for p, v in six.iteritems(self.used_parameters))
@@ -44,6 +44,8 @@ class BitFieldListFilter(FieldListFilter):
             bit_mask = Bit(number).mask
             yield {
                 'selected': self.lookup_val == bit_mask,
-                'query_string': cl.get_query_string({self.lookup_kwarg: bit_mask}),
+                'query_string': cl.get_query_string({
+                    self.lookup_kwarg: bit_mask
+                }),
                 'display': self.labels[number],
             }

src/bitfield/forms.py

@@ -25,8 +25,7 @@ class BitFieldCheckboxSelectMultiple(CheckboxSelectMultiple):
                     value -= (value % div)
                 div *= 2
             value = real_value
-        return super(BitFieldCheckboxSelectMultiple, self).render(
-            name, value, attrs=attrs)
+        return super(BitFieldCheckboxSelectMultiple, self).render(name, value, attrs=attrs)
 
     def _has_changed(self, initial, data):
         if initial is None:
@@ -41,8 +40,7 @@ class BitFieldCheckboxSelectMultiple(CheckboxSelectMultiple):
 
 
 class BitFormField(IntegerField):
-    def __init__(self, choices=(), widget=BitFieldCheckboxSelectMultiple, *args,
-                 **kwargs):
+    def __init__(self, choices=(), widget=BitFieldCheckboxSelectMultiple, *args, **kwargs):
         if isinstance(kwargs['initial'], int):
             iv = kwargs['initial']
             l = []
@@ -64,5 +62,5 @@ class BitFormField(IntegerField):
             try:
                 setattr(result, six.text_type(k), True)
             except AttributeError:
-                raise ValidationError('Unknown choice: %r' % (k,))
+                raise ValidationError('Unknown choice: %r' % (k, ))
         return int(result)

src/bitfield/models.py

@@ -80,7 +80,6 @@ class BitFieldCreator(object):
 
 
 class BitField(BigIntegerField):
-
     def contribute_to_class(self, cls, name, **kwargs):
         super(BitField, self).contribute_to_class(cls, name, **kwargs)
         setattr(cls, self.name, BitFieldCreator(self))
@@ -89,9 +88,8 @@ class BitField(BigIntegerField):
         if isinstance(flags, dict):
             # Get only integer keys in correct range
             valid_keys = (
-                k for k in flags.keys() if isinstance(
-                    k, int) and (
-                    0 <= k < MAX_FLAG_COUNT))
+                k for k in flags.keys() if isinstance(k, int) and (0 <= k < MAX_FLAG_COUNT)
+            )
             if not valid_keys:
                 raise ValueError('Wrong keys or empty dictionary')
             # Fill list with values from dict or with empty values
@@ -156,15 +154,17 @@ class BitField(BigIntegerField):
                 return [value.mask]
             else:
                 return BitQueryLookupWrapper(
-                    self.model._meta.db_table, self.db_column or self.name, value)
-        return BigIntegerField.get_db_prep_lookup(self, lookup_type=lookup_type, value=value,
-                                                  connection=connection, prepared=prepared)
+                    self.model._meta.db_table, self.db_column or self.name, value
+                )
+        return BigIntegerField.get_db_prep_lookup(
+            self, lookup_type=lookup_type, value=value, connection=connection, prepared=prepared
+        )
 
     def get_prep_lookup(self, lookup_type, value):
         if isinstance(getattr(value, 'expression', None), Bit):
             value = value.expression
         if isinstance(value, Bit):
-            if lookup_type in ('exact',):
+            if lookup_type in ('exact', ):
                 return value
             raise TypeError('Lookup type %r not supported with `Bit` type.' % lookup_type)
         return BigIntegerField.get_prep_lookup(self, lookup_type, value)
@@ -179,7 +179,7 @@ class BitField(BigIntegerField):
             if isinstance(value, six.integer_types) and value < 0:
                 new_value = 0
                 for bit_number, _ in enumerate(self.flags):
-                    new_value |= (value & (2 ** bit_number))
+                    new_value |= (value & (2**bit_number))
                 value = new_value
 
             value = BitHandler(value, self.flags, self.labels)
@@ -253,8 +253,7 @@ class CompositeBitField(object):
 
     def validate_fields(self, sender, **kwargs):
         cls = sender
-        model_fields = dict([
-            (f.name, f) for f in cls._meta.fields if f.name in self.fields])
+        model_fields = dict([(f.name, f) for f in cls._meta.fields if f.name in self.fields])
         all_flags = sum([model_fields[f].flags for f in self.fields], [])
         if len(all_flags) != len(set(all_flags)):
             raise ValueError('BitField flags must be unique.')

src/bitfield/query.py

@@ -17,10 +17,8 @@ class BitQueryLookupWrapper(object):
         This will be called by Where.as_sql()
         """
         if self.bit:
-            return ("(%s.%s | %d)" % (qn(self.table_alias), qn(self.column), self.bit.mask),
-                    [])
-        return ("(%s.%s & %d)" % (qn(self.table_alias), qn(self.column), self.bit.mask),
-                [])
+            return ("(%s.%s | %d)" % (qn(self.table_alias), qn(self.column), self.bit.mask), [])
+        return ("(%s.%s & %d)" % (qn(self.table_alias), qn(self.column), self.bit.mask), [])
 
 
 try:
@@ -29,8 +27,7 @@ try:
 
     class BitQueryLookupWrapper(Exact):  # NOQA
         def process_lhs(self, qn, connection, lhs=None):
-            lhs_sql, params = super(BitQueryLookupWrapper, self).process_lhs(
-                qn, connection, lhs)
+            lhs_sql, params = super(BitQueryLookupWrapper, self).process_lhs(qn, connection, lhs)
             if self.rhs:
                 lhs_sql = lhs_sql + ' & %s'
             else:
@@ -66,7 +63,7 @@ class BitQuerySaveWrapper(BitQueryLookupWrapper):
             XOR_OPERATOR = '^'
 
         if self.bit:
-            return ("%s.%s | %d" % (qn(self.table_alias), qn(self.column), self.bit.mask),
-                    [])
-        return ("%s.%s %s %d" % (qn(self.table_alias), qn(
-            self.column), XOR_OPERATOR, self.bit.mask), [])
+            return ("%s.%s | %d" % (qn(self.table_alias), qn(self.column), self.bit.mask), [])
+        return (
+            "%s.%s %s %d" % (qn(self.table_alias), qn(self.column), XOR_OPERATOR, self.bit.mask), []
+        )

src/bitfield/types.py

@@ -19,7 +19,7 @@ class Bit(object):
     def __init__(self, number, is_set=True):
         self.number = number
         self.is_set = bool(is_set)
-        self.mask = 2 ** int(number)
+        self.mask = 2**int(number)
         self.children = []
         if not self.is_set:
             self.mask = ~self.mask
@@ -154,8 +154,10 @@ class BitHandler(object):
         return cmp(self._value, other)
 
     def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, ', '.join('%s=%s' %
-                                                                (k, self.get_bit(n).is_set) for n, k in enumerate(self._keys)),)
+        return '<%s: %s>' % (
+            self.__class__.__name__,
+            ', '.join('%s=%s' % (k, self.get_bit(n).is_set) for n, k in enumerate(self._keys)),
+        )
 
     def __str__(self):
         return six.text_type(self._value)
@@ -215,17 +217,18 @@ class BitHandler(object):
 
     def _get_mask(self):
         return self._value
+
     mask = property(_get_mask)
 
     def evaluate(self, evaluator, qn, connection):
         return self.mask, []
 
     def get_bit(self, bit_number):
-        mask = 2 ** int(bit_number)
+        mask = 2**int(bit_number)
         return Bit(bit_number, self._value & mask != 0)
 
     def set_bit(self, bit_number, true_or_false):
-        mask = 2 ** int(bit_number)
+        mask = 2**int(bit_number)
         if true_or_false:
             self._value |= mask
         else:
@@ -268,7 +271,6 @@ if django.VERSION[:2] >= (1, 8):
     try:
         from django.db.backends.postgresql_psycopg2.base import Database
         Database.extensions.register_adapter(Bit, lambda x: Database.extensions.AsIs(int(x)))
-        Database.extensions.register_adapter(
-            BitHandler, lambda x: Database.extensions.AsIs(int(x)))
+        Database.extensions.register_adapter(BitHandler, lambda x: Database.extensions.AsIs(int(x)))
     except ImproperlyConfigured:
         pass

src/debug_toolbar/__init__.py

@@ -1,20 +1,16 @@
 from __future__ import absolute_import, unicode_literals
 
-
 __all__ = ['VERSION']
 
-
 try:
     import pkg_resources
     VERSION = pkg_resources.get_distribution('django-debug-toolbar').version
 except Exception:
     VERSION = 'unknown'
 
-
 # Code that discovers files or modules in INSTALLED_APPS imports this module.
 # Reference URLpatterns with a string to avoid the risk of circular imports.
 
 urls = 'debug_toolbar.toolbar', 'djdt', 'djdt'
 
-
 default_app_config = 'debug_toolbar.apps.DebugToolbarConfig'

src/debug_toolbar/compat.py

@@ -34,11 +34,11 @@ except ImportError:  # python < 2.7
     from django.utils.datastructures import SortedDict as OrderedDict  # NOQA
 
 try:
-    from django.contrib.staticfiles.testing import (
-        StaticLiveServerTestCase)
+    from django.contrib.staticfiles.testing import (StaticLiveServerTestCase)
 except ImportError:  # Django < 1.7
     from django.test import (  # NOQA
-        LiveServerTestCase as StaticLiveServerTestCase)
+        LiveServerTestCase as StaticLiveServerTestCase
+    )
 
 try:
     from django.db.backends import utils as db_backends_util
@@ -76,9 +76,7 @@ def get_template_loaders():
         else:
             loaders = engine.template_loaders
     else:  # Django < 1.8
-        loaders = [
-            find_template_loader(loader_name)
-            for loader_name in settings.TEMPLATE_LOADERS]
+        loaders = [find_template_loader(loader_name) for loader_name in settings.TEMPLATE_LOADERS]
     return loaders
 
 
@@ -95,6 +93,7 @@ def get_template_context_processors():
         context_processors = get_standard_processors()
     return context_processors
 
+
 if django.VERSION[:2] < (1, 5):
     # If the user is using Django < 1.5, then load up the url tag
     # from future. Otherwise use the normal one. The purpose of this

src/debug_toolbar/management/commands/debugsqlshell.py

@@ -3,7 +3,7 @@ from __future__ import absolute_import, print_function, unicode_literals
 from time import time
 
 # 'debugsqlshell' is the same as the 'shell'.
-from django.core.management.commands.shell import Command               # noqa
+from django.core.management.commands.shell import Command  # noqa
 
 import sqlparse
 

src/debug_toolbar/middleware.py

@@ -104,9 +104,12 @@ class DebugToolbarMiddleware(object):
         # Check for responses where the toolbar can't be inserted.
         content_encoding = response.get('Content-Encoding', '')
         content_type = response.get('Content-Type', '').split(';')[0]
-        if any((getattr(response, 'streaming', False),
-                'gzip' in content_encoding,
-                content_type not in _HTML_TYPES)):
+        if any(
+            (
+                getattr(response, 'streaming', False), 'gzip' in content_encoding,
+                content_type not in _HTML_TYPES
+            )
+        ):
             return response
 
         # Collapse the toolbar by default if SHOW_COLLAPSED is set.
@@ -116,10 +119,10 @@ class DebugToolbarMiddleware(object):
         # Insert the toolbar in the response.
         content = force_text(response.content, encoding=settings.DEFAULT_CHARSET)
         insert_before = dt_settings.CONFIG['INSERT_BEFORE']
-        try:                    # Python >= 2.7
+        try:  # Python >= 2.7
             pattern = re.escape(insert_before)
             bits = re.split(pattern, content, flags=re.IGNORECASE)
-        except TypeError:       # Python < 2.7
+        except TypeError:  # Python < 2.7
             pattern = '(.+?)(%s|$)' % re.escape(insert_before)
             matches = re.findall(pattern, content, flags=re.DOTALL | re.IGNORECASE)
             bits = [m[0] for m in matches if m[1] == insert_before]

src/debug_toolbar/models.py

@@ -4,6 +4,5 @@ import django
 
 from debug_toolbar import settings as dt_settings
 
-
 if dt_settings.PATCH_SETTINGS and django.VERSION[:2] < (1, 7):
     dt_settings.patch_all()