lint

Author: saxix

pyproject.toml

@@ -40,15 +40,24 @@ dev = [
 ]
 
 [tool.isort]
-combine_as_imports = true
-default_section = "THIRDPARTY"
-include_trailing_comma = true
-known_tests = "pytest,unittest,factory"
-known_demo = "demo"
-known_django = "django"
-sections = "FUTURE,STDLIB,DJANGO,THIRDPARTY,TESTS,FIRSTPARTY,DEMO,LOCALFOLDER"
-known_first_party = "etools_validator"
-multi_line_output = 3
-line_length = 120
-balanced_wrapping = true
-order_by_type = false
+profile = "black"
+
+[tool.black]
+line-length = 120
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | venv
+  | _build
+  | buck-out
+  | build
+  | dist
+  | migrations
+  | snapshots
+)/
+'''

setup.cfg

@@ -12,16 +12,17 @@
 from django.forms import CheckboxInput
 from django.forms.formsets import (
     INITIAL_FORM_COUNT,
-    ManagementForm,
     MAX_NUM_FORM_COUNT,
     TOTAL_FORM_COUNT,
+    ManagementForm,
 )
 from django.forms.models import BaseModelFormSet
 from django.http import HttpResponse, HttpResponseRedirect
 from django.utils.encoding import force_str
 from django.utils.html import format_html
 from django.utils.safestring import mark_safe
-from django.utils.translation import gettext_lazy as _, ngettext
+from django.utils.translation import gettext_lazy as _
+from django.utils.translation import ngettext
 
 from concurrency import core, forms
 from concurrency.api import get_revision_of_object
@@ -44,9 +45,7 @@ def action_checkbox(self, obj):
         if self.check_concurrent_action:
             attrs = {
                 "class": "action-select",
-                "aria-label": format_html(
-                    _("Select this object for an action - {}"), obj
-                ),
+                "aria-label": format_html(_("Select this object for an action - {}"), obj),
             }
             checkbox = CheckboxInput(attrs, lambda value: False)
             pk = force_str("%s,%s" % (obj.pk, get_revision_of_object(obj)))
@@ -57,9 +56,7 @@ def action_checkbox(self, obj):
         else:  # pragma: no cover
             return super().action_checkbox(obj)
 
-    action_checkbox.short_description = mark_safe(
-        '<input type="checkbox" id="action-toggle" />'
-    )
+    action_checkbox.short_description = mark_safe('<input type="checkbox" id="action-toggle" />')
     action_checkbox.allow_tags = True
 
     def get_confirmation_template(self):
@@ -114,9 +111,7 @@ def response_action(self, request, queryset):  # noqa
             revision_field = self.model._concurrencymeta.field
 
             if self.check_concurrent_action:
-                self.delete_selected_confirmation_template = (
-                    self.get_confirmation_template()
-                )
+                self.delete_selected_confirmation_template = self.get_confirmation_template()
 
                 # If select_across we have to avoid the use of concurrency
                 if selected is not ALL:
@@ -166,9 +161,7 @@ def __init__(self, *args, **kwargs):
     def _get_concurrency_fields(self):
         v = []
         for pk, version in self._versions:
-            v.append(
-                f'<input type="hidden" name="{concurrency_param_name}_{pk}" value="{version}">'
-            )
+            v.append(f'<input type="hidden" name="{concurrency_param_name}_{pk}" value="{version}">')
         return mark_safe("".join(v))
 
     def render(self, template_name=None, context=None, renderer=None):
@@ -183,26 +176,18 @@ def __str__(self):
 
     __html__ = __str__
 
-    def _html_output(
-        self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row
-    ):
-        ret = super()._html_output(
-            normal_row, error_row, row_ender, help_text_html, errors_on_separate_row
-        )
+    def _html_output(self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):
+        ret = super()._html_output(normal_row, error_row, row_ender, help_text_html, errors_on_separate_row)
         return mark_safe("{0}{1}".format(ret, self._get_concurrency_fields()))
 
 
 class ConcurrentBaseModelFormSet(BaseModelFormSet):
     def _management_form(self):
         """Returns the ManagementForm instance for this FormSet."""
         if self.is_bound:
-            form = ConcurrentManagementForm(
-                self.data, auto_id=self.auto_id, prefix=self.prefix
-            )
+            form = ConcurrentManagementForm(self.data, auto_id=self.auto_id, prefix=self.prefix)
             if not form.is_valid():
-                raise ValidationError(
-                    "ManagementForm data is missing or has been tampered with"
-                )
+                raise ValidationError("ManagementForm data is missing or has been tampered with")
         else:
             form = ConcurrentManagementForm(
                 auto_id=self.auto_id,
@@ -212,10 +197,7 @@ def _management_form(self):
                     INITIAL_FORM_COUNT: self.initial_form_count(),
                     MAX_NUM_FORM_COUNT: self.max_num,
                 },
-                versions=[
-                    (form.instance.pk, get_revision_of_object(form.instance))
-                    for form in self.initial_forms
-                ],
+                versions=[(form.instance.pk, get_revision_of_object(form.instance)) for form in self.initial_forms],
             )
         return form
 
@@ -308,9 +290,7 @@ def message_user(self, request, message, *args, **kwargs):
         return super().message_user(request, message, *args, **kwargs)
 
 
-class ConcurrentModelAdmin(
-    ConcurrencyActionMixin, ConcurrencyListEditableMixin, admin.ModelAdmin
-):
+class ConcurrentModelAdmin(ConcurrencyActionMixin, ConcurrencyListEditableMixin, admin.ModelAdmin):
     form = ConcurrentForm
     formfield_overrides = {forms.VersionField: {"widget": VersionWidget}}
 
@@ -322,9 +302,7 @@ def check(self, **kwargs):
                 errors.append(
                     Error(
                         "Missed version field in {} fields definition".format(self),
-                        hint="Please add '{}' to the 'fields' attribute".format(
-                            version_field.name
-                        ),
+                        hint="Please add '{}' to the 'fields' attribute".format(version_field.name),
                         obj=None,
                         id="concurrency.A001",
                     )
@@ -337,9 +315,7 @@ def check(self, **kwargs):
                 errors.append(
                     Error(
                         "Missed version field in {} fieldsets definition".format(self),
-                        hint="Please add '{}' to the 'fieldsets' attribute".format(
-                            version_field.name
-                        ),
+                        hint="Please add '{}' to the 'fieldsets' attribute".format(version_field.name),
                         obj=None,
                         id="concurrency.A002",
                     )

src/concurrency/admin.py

@@ -39,9 +39,7 @@ def is_changed(obj):
     """
     revision_field = get_version_fieldname(obj)
     version = get_revision_of_object(obj)
-    return not obj.__class__.objects.filter(
-        **{obj._meta.pk.name: obj.pk, revision_field: version}
-    ).exists()
+    return not obj.__class__.objects.filter(**{obj._meta.pk.name: obj.pk, revision_field: version}).exists()
 
 
 def get_version(model_instance, version):

src/concurrency/api.py

@@ -48,18 +48,15 @@ def __init__(self, prefix):
             value = getattr(settings, prefix_name, default)
             self._set_attr(prefix_name, value)
             setattr(settings, prefix_name, value)
-            setting_changed.send(
-                self.__class__, setting=prefix_name, value=value, enter=True
-            )
+            setting_changed.send(self.__class__, setting=prefix_name, value=value, enter=True)
 
         setting_changed.connect(self._handler)
 
     def _set_attr(self, prefix_name, value):
-        name = prefix_name[len(self.prefix) + 1:]
+        name = prefix_name[1 + len(self.prefix):]
         if name == "IGNORE_DEFAULT":
             raise ImproperlyConfigured(
-                "IGNORE_DEFAULT has been removed in django-concurrency 1.5. "
-                "Use VERSION_FIELD_REQUIRED instead"
+                "IGNORE_DEFAULT has been removed in django-concurrency 1.5. " "Use VERSION_FIELD_REQUIRED instead"
             )
         elif name == "CALLBACK":
             if isinstance(value, str):
@@ -79,9 +76,7 @@ def _set_attr(self, prefix_name, value):
                 try:
                     value[k] = import_string(v)
                 except ImportError as e:
-                    raise ImproperlyConfigured(
-                        f"Unable to load {k} TriggerFactory. Invalid fqn '{v}': {e}"
-                    )
+                    raise ImproperlyConfigured(f"Unable to load {k} TriggerFactory. Invalid fqn '{v}': {e}")
 
         setattr(self, name, value)
 

src/concurrency/config.py

@@ -38,8 +38,7 @@ def _select_lock(model_instance, version_value=None):
 
         if not entry:
             logger.debug(
-                "Conflict detected on `{0}` pk:`{0.pk}`, "
-                "version `{1}` not found".format(model_instance, value)
+                "Conflict detected on `{0}` pk:`{0.pk}`, " "version `{1}` not found".format(model_instance, value)
             )
             conf._callback(model_instance)
         else:  # pragma: no cover

src/concurrency/core.py

@@ -16,6 +16,4 @@ def __init__(self, *args, **kwargs):
 class VersionError(SuspiciousOperation):
 
     def __init__(self, message=None, code=None, params=None, *args, **kwargs):
-        self.message = message or _(
-            "Version number is missing or has been tampered with"
-        )
+        self.message = message or _("Version number is missing or has been tampered with")

src/concurrency/exceptions.py

@@ -34,19 +34,15 @@ def class_prepared_concurrency_handler(sender, **kwargs):
             setattr(sender, "_concurrencymeta", local)
 
         if hasattr(sender, "ConcurrencyMeta"):
-            sender._concurrencymeta.enabled = getattr(
-                sender.ConcurrencyMeta, "enabled", True
-            )
+            sender._concurrencymeta.enabled = getattr(sender.ConcurrencyMeta, "enabled", True)
             check_fields = getattr(sender.ConcurrencyMeta, "check_fields", None)
             ignore_fields = getattr(sender.ConcurrencyMeta, "ignore_fields", None)
             if check_fields and ignore_fields:
                 raise ValueError("Cannot set both 'check_fields' and 'ignore_fields'")
 
             sender._concurrencymeta.check_fields = check_fields
             sender._concurrencymeta.ignore_fields = ignore_fields
-            sender._concurrencymeta.increment = getattr(
-                sender.ConcurrencyMeta, "increment", True
-            )
+            sender._concurrencymeta.increment = getattr(sender.ConcurrencyMeta, "increment", True)
             sender._concurrencymeta.skip = False
 
         if not (sender._concurrencymeta.manually):
@@ -71,9 +67,7 @@ def post_syncdb_concurrency_handler(sender, **kwargs):
 
 
 if conf.AUTO_CREATE_TRIGGERS:
-    post_migrate.connect(
-        post_syncdb_concurrency_handler, dispatch_uid="post_syncdb_concurrency_handler"
-    )
+    post_migrate.connect(post_syncdb_concurrency_handler, dispatch_uid="post_syncdb_concurrency_handler")
 
 
 class VersionField(Field):
@@ -145,9 +139,7 @@ def _wrap_model_methods(model):
 
     def _wrap_do_update(self, func):
 
-        def _do_update(
-            model_instance, base_qs, using, pk_val, values, update_fields, forced_update
-        ):
+        def _do_update(model_instance, base_qs, using, pk_val, values, update_fields, forced_update):
             version_field = model_instance._concurrencymeta.field
             old_version = get_revision_of_object(model_instance)
             if not version_field.model._meta.abstract:
@@ -354,16 +346,10 @@ def _get_hash(self, instance):
 
         filter_ = functools.partial(filter_fields, instance)
         if check_fields is None and ignore_fields is None:
-            fields = sorted(
-                [f.name for f in filter(filter_, instance._meta.get_fields())]
-            )
+            fields = sorted([f.name for f in filter(filter_, instance._meta.get_fields())])
         elif check_fields is None:
             fields = sorted(
-                [
-                    f.name
-                    for f in filter(filter_, instance._meta.get_fields())
-                    if f.name not in ignore_fields
-                ]
+                [f.name for f in filter(filter_, instance._meta.get_fields()) if f.name not in ignore_fields]
             )
         else:
             fields = instance._concurrencymeta.check_fields
@@ -372,9 +358,7 @@ def _get_hash(self, instance):
             # FK. the raw value of the FK is enough
             field = opts.get_field(field_name)
             if isinstance(field, models.ManyToManyField):
-                values[field_name] = getattr(instance, field_name).values_list(
-                    "pk", flat=True
-                )
+                values[field_name] = getattr(instance, field_name).values_list("pk", flat=True)
             else:
                 values[field_name] = field.value_from_object(instance)
         return hashlib.sha1(force_str(values).encode("utf-8")).hexdigest()

src/concurrency/fields.py

@@ -2,8 +2,8 @@
 
 from django import forms
 from django.core.exceptions import (
-    ImproperlyConfigured,
     NON_FIELD_ERRORS,
+    ImproperlyConfigured,
     ValidationError,
 )
 from django.core.signing import BadSignature, Signer
@@ -32,11 +32,7 @@ def clean(self):
                 )
 
         except RecordModifiedError:
-            self._update_errors(
-                ValidationError(
-                    {NON_FIELD_ERRORS: self.error_class([_("Record Modified")])}
-                )
-            )
+            self._update_errors(ValidationError({NON_FIELD_ERRORS: self.error_class([_("Record Modified")])}))
 
         return super().clean()
 
@@ -78,19 +74,15 @@ def sign(self, value):
 def get_signer():
     path = conf.FIELD_SIGNER
     i = path.rfind(".")
-    module, attr = path[:i], path[i + 1 :]
+    module, attr = path[:i], path[i + 1:]
     try:
         mod = import_module(module)
     except ImportError as e:
-        raise ImproperlyConfigured(
-            'Error loading concurrency signer %s: "%s"' % (module, e)
-        )
+        raise ImproperlyConfigured('Error loading concurrency signer %s: "%s"' % (module, e))
     try:
         signer_class = getattr(mod, attr)
     except AttributeError:  # pragma: no cover
-        raise ImproperlyConfigured(
-            'Module "%s" does not define a valid signer named "%s"' % (module, attr)
-        )
+        raise ImproperlyConfigured('Module "%s" does not define a valid signer named "%s"' % (module, attr))
     return signer_class()
 
 
@@ -107,9 +99,7 @@ def __repr__(self):
 
 class VersionField(forms.IntegerField):
     widget = HiddenInput  # Default widget to use when rendering this type of Field.
-    hidden_widget = (
-        HiddenInput  # Default widget to use when rendering this as "hidden".
-    )
+    hidden_widget = HiddenInput  # Default widget to use when rendering this as "hidden".
 
     def __init__(self, *args, **kwargs):
         self._signer = kwargs.pop("signer", get_signer())