Add black code linter

Author: codingjoe

.github/workflows/ci.yml

@@ -27,6 +27,14 @@ jobs:
       - run: python -m pip install pydocstyle
       - run: pydocstyle .
 
+  black:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@v1
+      - uses: actions/checkout@v2
+      - run: python -m pip install black
+      - run: black --check --diff .
+
   docs:
     runs-on: ubuntu-latest
     steps:
@@ -51,6 +59,7 @@ jobs:
       - isort
       - pydocstyle
       - flake8
+      - black
     strategy:
       matrix:
         os:

django_measurement/conf.py

@@ -2,16 +2,16 @@
 from appconf import AppConf
 from django.conf import settings
 
-__all__ = ('settings',)
+__all__ = ("settings",)
 
 
 class DjangoMeasurementConf(AppConf):
     """Settings for django-measurement."""
 
-    BIDIMENSIONAL_SEPARATOR = '/'
+    BIDIMENSIONAL_SEPARATOR = "/"
     """
     For measurement classes subclassing a BidimensionalMeasure, this .
     """
 
     class Meta:
-        prefix = 'measurement'
+        prefix = "measurement"

django_measurement/forms.py

@@ -9,29 +9,30 @@
 
 
 class MeasurementWidget(forms.MultiWidget):
-    def __init__(self, attrs=None, float_widget=None,
-                 unit_choices_widget=None, unit_choices=None, *args, **kwargs):
+    def __init__(
+        self,
+        attrs=None,
+        float_widget=None,
+        unit_choices_widget=None,
+        unit_choices=None,
+        *args,
+        **kwargs
+    ):
 
         self.unit_choices = unit_choices
 
         if not float_widget:
             float_widget = forms.TextInput(attrs=attrs)
 
         if not unit_choices_widget:
-            unit_choices_widget = forms.Select(
-                attrs=attrs,
-                choices=unit_choices
-            )
+            unit_choices_widget = forms.Select(attrs=attrs, choices=unit_choices)
 
         widgets = (float_widget, unit_choices_widget)
         super(MeasurementWidget, self).__init__(widgets, attrs)
 
     def decompress(self, value):
         if value:
-            choice_units = set([
-                u
-                for u, n in self.unit_choices
-            ])
+            choice_units = set([u for u, n in self.unit_choices])
 
             unit = value.STANDARD_UNIT
             if unit not in choice_units:
@@ -44,42 +45,56 @@ def decompress(self, value):
 
 
 class MeasurementField(forms.MultiValueField):
-    def __init__(self, measurement, max_value=None, min_value=None,
-                 unit_choices=None, validators=None,
-                 bidimensional_separator=settings.MEASUREMENT_BIDIMENSIONAL_SEPARATOR,
-                 *args, **kwargs):
+    def __init__(
+        self,
+        measurement,
+        max_value=None,
+        min_value=None,
+        unit_choices=None,
+        validators=None,
+        bidimensional_separator=settings.MEASUREMENT_BIDIMENSIONAL_SEPARATOR,
+        *args,
+        **kwargs
+    ):
 
         if not issubclass(measurement, (MeasureBase, BidimensionalMeasure)):
-            raise ValueError(
-                "%s must be a subclass of MeasureBase" % measurement
-            )
+            raise ValueError("%s must be a subclass of MeasureBase" % measurement)
 
         self.measurement_class = measurement
         if not unit_choices:
             if issubclass(measurement, BidimensionalMeasure):
-                assert isinstance(bidimensional_separator, str), \
-                    "Supplied bidimensional_separator for %s must be of string/unicode type;" \
-                    " Instead got type %s" % (measurement, str(type(bidimensional_separator)),)
-                unit_choices = tuple((
+                assert isinstance(bidimensional_separator, str), (
+                    "Supplied bidimensional_separator for %s must be of string/unicode type;"
+                    " Instead got type %s"
+                    % (measurement, str(type(bidimensional_separator)),)
+                )
+                unit_choices = tuple(
                     (
-                        '{0}__{1}'.format(primary, reference),
-                        '{0}{1}{2}'.format(
-                            getattr(measurement.PRIMARY_DIMENSION, 'LABELS', {}).get(
-                                primary, primary),
-                            bidimensional_separator,
-                            getattr(measurement.REFERENCE_DIMENSION, 'LABELS', {}).get(
-                                reference, reference)),
+                        (
+                            "{0}__{1}".format(primary, reference),
+                            "{0}{1}{2}".format(
+                                getattr(
+                                    measurement.PRIMARY_DIMENSION, "LABELS", {}
+                                ).get(primary, primary),
+                                bidimensional_separator,
+                                getattr(
+                                    measurement.REFERENCE_DIMENSION, "LABELS", {}
+                                ).get(reference, reference),
+                            ),
+                        )
+                        for primary, reference in product(
+                            measurement.PRIMARY_DIMENSION.get_units(),
+                            measurement.REFERENCE_DIMENSION.get_units(),
+                        )
                     )
-                    for primary, reference in product(
-                        measurement.PRIMARY_DIMENSION.get_units(),
-                        measurement.REFERENCE_DIMENSION.get_units(),
-                    )
-                ))
+                )
             else:
-                unit_choices = tuple((
-                    (u, getattr(measurement, 'LABELS', {}).get(u, u))
-                    for u in measurement.get_units()
-                ))
+                unit_choices = tuple(
+                    (
+                        (u, getattr(measurement, "LABELS", {}).get(u, u))
+                        for u in measurement.get_units()
+                    )
+                )
 
         if validators is None:
             validators = []
@@ -99,16 +114,17 @@ def __init__(self, measurement, max_value=None, min_value=None,
         float_field = forms.FloatField(*args, **kwargs)
         choice_field = forms.ChoiceField(choices=unit_choices)
         defaults = {
-            'widget': MeasurementWidget(
+            "widget": MeasurementWidget(
                 float_widget=float_field.widget,
                 unit_choices_widget=choice_field.widget,
-                unit_choices=unit_choices
+                unit_choices=unit_choices,
             ),
         }
         defaults.update(kwargs)
         fields = (float_field, choice_field)
-        super(MeasurementField, self).__init__(fields, validators=validators,
-                                               *args, **defaults)
+        super(MeasurementField, self).__init__(
+            fields, validators=validators, *args, **defaults
+        )
 
     def compress(self, data_list):
         if not data_list:
@@ -118,8 +134,4 @@ def compress(self, data_list):
         if value in self.empty_values:
             return None
 
-        return utils.get_measurement(
-            self.measurement_class,
-            value,
-            unit
-        )
+        return utils.get_measurement(self.measurement_class, value, unit)

django_measurement/models.py

@@ -9,7 +9,7 @@
 from . import forms
 from .utils import get_measurement
 
-logger = logging.getLogger('django_measurement')
+logger = logging.getLogger("django_measurement")
 
 
 class MeasurementField(FloatField):
@@ -20,44 +20,51 @@ class MeasurementField(FloatField):
         MeasureBase,
     )
     default_error_messages = {
-        'invalid_type': _(
-            "'%(value)s' (%(type_given)s) value"
-            " must be of type %(type_wanted)s."
+        "invalid_type": _(
+            "'%(value)s' (%(type_given)s) value" " must be of type %(type_wanted)s."
         ),
     }
 
-    def __init__(self, verbose_name=None, name=None, measurement=None,
-                 measurement_class=None, unit_choices=None, *args, **kwargs):
+    def __init__(
+        self,
+        verbose_name=None,
+        name=None,
+        measurement=None,
+        measurement_class=None,
+        unit_choices=None,
+        *args,
+        **kwargs
+    ):
 
         if not measurement and measurement_class is not None:
             warnings.warn(
-                "\"measurement_class\" will be removed in version 4.0",
-                DeprecationWarning
+                '"measurement_class" will be removed in version 4.0', DeprecationWarning
             )
             measurement = getattr(measures, measurement_class)
 
         if not measurement:
-            raise TypeError('MeasurementField() takes a measurement'
-                            ' keyword argument. None given.')
+            raise TypeError(
+                "MeasurementField() takes a measurement"
+                " keyword argument. None given."
+            )
 
         if not issubclass(measurement, self.MEASURE_BASES):
             raise TypeError(
-                'MeasurementField() takes a measurement keyword argument.'
-                ' It has to be a valid MeasureBase subclass.'
+                "MeasurementField() takes a measurement keyword argument."
+                " It has to be a valid MeasureBase subclass."
             )
 
         self.measurement = measurement
         self.widget_args = {
-            'measurement': measurement,
-            'unit_choices': unit_choices,
+            "measurement": measurement,
+            "unit_choices": unit_choices,
         }
 
-        super(MeasurementField, self).__init__(verbose_name, name,
-                                               *args, **kwargs)
+        super(MeasurementField, self).__init__(verbose_name, name, *args, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(MeasurementField, self).deconstruct()
-        kwargs['measurement'] = self.measurement
+        kwargs["measurement"] = self.measurement
         return name, path, args, kwargs
 
     def get_prep_value(self, value):
@@ -75,7 +82,7 @@ def get_prep_value(self, value):
             return super(MeasurementField, self).get_prep_value(value)
 
     def get_default_unit(self):
-        unit_choices = self.widget_args['unit_choices']
+        unit_choices = self.widget_args["unit_choices"]
         if unit_choices:
             return unit_choices[0][0]
         return self.measurement.STANDARD_UNIT
@@ -94,10 +101,10 @@ def value_to_string(self, obj):
         value = self.value_from_object(obj)
         if not isinstance(value, self.MEASURE_BASES):
             return value
-        return '%s:%s' % (value.value, value.unit)
+        return "%s:%s" % (value.value, value.unit)
 
     def deserialize_value_from_string(self, s: str):
-        parts = s.split(':', 1)
+        parts = s.split(":", 1)
         if len(parts) != 2:
             return None
         value, unit = float(parts[0]), parts[1]
@@ -118,23 +125,22 @@ def to_python(self, value):
 
         return_unit = self.get_default_unit()
 
-        msg = "You assigned a %s instead of %s to %s.%s.%s, unit was guessed to be \"%s\"." % (
-            type(value).__name__,
-            str(self.measurement.__name__),
-            self.model.__module__,
-            self.model.__name__,
-            self.name,
-            return_unit,
+        msg = (
+            'You assigned a %s instead of %s to %s.%s.%s, unit was guessed to be "%s".'
+            % (
+                type(value).__name__,
+                str(self.measurement.__name__),
+                self.model.__module__,
+                self.model.__name__,
+                self.name,
+                return_unit,
+            )
         )
         logger.warning(msg)
-        return get_measurement(
-            measure=self.measurement,
-            value=value,
-            unit=return_unit,
-        )
+        return get_measurement(measure=self.measurement, value=value, unit=return_unit,)
 
     def formfield(self, **kwargs):
-        defaults = {'form_class': forms.MeasurementField}
+        defaults = {"form_class": forms.MeasurementField}
         defaults.update(kwargs)
         defaults.update(self.widget_args)
         return super(MeasurementField, self).formfield(**defaults)

django_measurement/utils.py

@@ -4,9 +4,7 @@
 def get_measurement(measure, value, unit=None, original_unit=None):
     unit = unit or measure.STANDARD_UNIT
 
-    m = measure(
-        **{unit: value}
-    )
+    m = measure(**{unit: value})
     if original_unit:
         m.unit = original_unit
     if isinstance(m, BidimensionalMeasure):

setup.cfg

@@ -78,19 +78,18 @@ addopts =
 show_missing = True
 
 [flake8]
-max-line-length = 99
-max-complexity = 10
-statistics = true
-show-source = true
-exclude = */migrations/*,docs/*,env/*,.tox/*,.eggs/*
+max-line-length=88
+select = C,E,F,W,B,B950
+ignore = E203, E501, W503
+exclude = venv,.tox,.eggs
 
 [pydocstyle]
-add_ignore = D1
+add-ignore = D1
 
 [isort]
 atomic = true
-line_length = 79
-multi_line_output=5
+line_length = 88
+multi_line_output=3
 include_trailing_comma=True
 force_grid_wrap=0
 use_parentheses=True

setup.py

@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 from setuptools import setup
 
-setup(name='django-measurement', use_scm_version=True)
+setup(name="django-measurement", use_scm_version=True)