From c115d824801c7e660be852b28b813fa9ce51abf3 Mon Sep 17 00:00:00 2001 From: David Burke Date: Thu, 13 Apr 2023 11:41:28 -0400 Subject: [PATCH] lint --- bitfield/__init__.py | 4 ++-- bitfield/admin.py | 21 +++++++++++---------- bitfield/apps.py | 2 +- bitfield/forms.py | 21 +++++++++++---------- bitfield/models.py | 44 ++++++++++++++++++++++++-------------------- bitfield/query.py | 31 +++++++++++++++++++------------ bitfield/types.py | 27 +++++++++++++++++++-------- 7 files changed, 87 insertions(+), 63 deletions(-) diff --git a/bitfield/__init__.py b/bitfield/__init__.py index 93fb403a..852eb0e3 100644 --- a/bitfield/__init__.py +++ b/bitfield/__init__.py @@ -4,8 +4,8 @@ django-bitfield """ from __future__ import absolute_import -from bitfield.models import Bit, BitHandler, CompositeBitField, BitField # NOQA +from bitfield.models import Bit, BitField, BitHandler, CompositeBitField # NOQA -default_app_config = 'bitfield.apps.BitFieldAppConfig' +default_app_config = "bitfield.apps.BitFieldAppConfig" VERSION = "2.2.0" diff --git a/bitfield/admin.py b/bitfield/admin.py index 8d790e30..c19bf41f 100644 --- a/bitfield/admin.py +++ b/bitfield/admin.py @@ -1,12 +1,13 @@ import django import six - from django.core.exceptions import ValidationError + if django.VERSION < (2, 0): from django.utils.translation import ugettext_lazy as _ else: # Aliased since Django 2.0 https://github.com/django/django/blob/2.0/django/utils/translation/__init__.py#L80-L81 from django.utils.translation import gettext_lazy as _ + from django.contrib.admin import FieldListFilter from django.contrib.admin.options import IncorrectLookupParameters @@ -24,12 +25,12 @@ class BitFieldListFilter(FieldListFilter): self.flags = field.flags self.labels = field.labels super(BitFieldListFilter, self).__init__( - field, request, params, model, model_admin, field_path) + field, request, params, model, model_admin, field_path + ) def queryset(self, request, queryset): filter_kwargs = dict( - (p, BitHandler(v, ())) - for p, v in six.iteritems(self.used_parameters) + (p, BitHandler(v, ())) for p, v in six.iteritems(self.used_parameters) ) if not filter_kwargs: return queryset @@ -43,14 +44,14 @@ class BitFieldListFilter(FieldListFilter): def choices(self, cl): yield { - 'selected': self.lookup_val == 0, - 'query_string': cl.get_query_string({}, [self.lookup_kwarg]), - 'display': _('All'), + "selected": self.lookup_val == 0, + "query_string": cl.get_query_string({}, [self.lookup_kwarg]), + "display": _("All"), } for number, flag in enumerate(self.flags): bit_mask = Bit(number).mask yield { - 'selected': self.lookup_val == bit_mask, - 'query_string': cl.get_query_string({self.lookup_kwarg: bit_mask}), - 'display': self.labels[number], + "selected": self.lookup_val == bit_mask, + "query_string": cl.get_query_string({self.lookup_kwarg: bit_mask}), + "display": self.labels[number], } diff --git a/bitfield/apps.py b/bitfield/apps.py index dabe0cec..093112a9 100644 --- a/bitfield/apps.py +++ b/bitfield/apps.py @@ -2,5 +2,5 @@ from django.apps import AppConfig class BitFieldAppConfig(AppConfig): - name = 'bitfield' + name = "bitfield" verbose_name = "Bit Field" diff --git a/bitfield/forms.py b/bitfield/forms.py index 7c8b8939..6a92d05f 100644 --- a/bitfield/forms.py +++ b/bitfield/forms.py @@ -1,7 +1,6 @@ from __future__ import absolute_import from django.forms import CheckboxSelectMultiple, IntegerField, ValidationError - from django.utils.encoding import force_str from bitfield.types import BitHandler @@ -14,14 +13,15 @@ class BitFieldCheckboxSelectMultiple(CheckboxSelectMultiple): elif isinstance(value, int): real_value = [] div = 2 - for (k, v) in self.choices: + for k, v in self.choices: if value % div != 0: real_value.append(k) - value -= (value % div) + value -= value % div div *= 2 value = real_value return super(BitFieldCheckboxSelectMultiple, self).render( - name, value, attrs=attrs) + name, value, attrs=attrs + ) def has_changed(self, initial, data): if initial is None: @@ -36,15 +36,16 @@ class BitFieldCheckboxSelectMultiple(CheckboxSelectMultiple): class BitFormField(IntegerField): - def __init__(self, choices=(), widget=BitFieldCheckboxSelectMultiple, *args, **kwargs): - - if isinstance(kwargs['initial'], int): - iv = kwargs['initial'] + def __init__( + self, choices=(), widget=BitFieldCheckboxSelectMultiple, *args, **kwargs + ): + if isinstance(kwargs["initial"], int): + iv = kwargs["initial"] iv_list = [] for i in range(0, min(len(choices), 63)): if (1 << i) & iv > 0: iv_list += [choices[i][0]] - kwargs['initial'] = iv_list + kwargs["initial"] = iv_list self.widget = widget super(BitFormField, self).__init__(widget=widget, *args, **kwargs) self.choices = self.widget.choices = choices @@ -59,5 +60,5 @@ class BitFormField(IntegerField): try: setattr(result, str(k), True) except AttributeError: - raise ValidationError('Unknown choice: %r' % (k,)) + raise ValidationError("Unknown choice: %r" % (k,)) return int(result) diff --git a/bitfield/models.py b/bitfield/models.py index 5fe3e780..e2c26470 100644 --- a/bitfield/models.py +++ b/bitfield/models.py @@ -1,13 +1,12 @@ from __future__ import absolute_import import six - from django.db.models import signals -from django.db.models.fields import Field, BigIntegerField +from django.db.models.fields import BigIntegerField, Field from bitfield.forms import BitFormField from bitfield.query import BitQueryLookupWrapper -from bitfield.types import BitHandler, Bit +from bitfield.types import Bit, BitHandler # Count binary capacity. Truncate "0b" prefix from binary form. # Twice faster than bin(i)[2:] or math.floor(math.log(i)) @@ -17,7 +16,7 @@ MAX_FLAG_COUNT = int(len(bin(BigIntegerField.MAX_BIGINT)) - 2) class BitFieldFlags(object): def __init__(self, flags): if len(flags) > MAX_FLAG_COUNT: - raise ValueError('Too many flags') + raise ValueError("Too many flags") self._flags = flags def __repr__(self): @@ -28,7 +27,7 @@ class BitFieldFlags(object): yield flag def __getattr__(self, key): - if key == '_flags': + if key == "_flags": # Since __getattr__ is for fallback, reaching here from Python # means that there's no '_flags' attribute in this object, # which may be caused by intermediate state while copying etc. @@ -77,6 +76,7 @@ class BitFieldCreator(object): an older version of the instance and a newer version of the class is available (usually during deploys). """ + def __init__(self, field): self.field = field @@ -94,7 +94,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)) @@ -102,14 +101,18 @@ class BitField(BigIntegerField): def __init__(self, flags, default=None, *args, **kwargs): 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)) + valid_keys = ( + 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') + raise ValueError("Wrong keys or empty dictionary") # Fill list with values from dict or with empty values - flags = [flags.get(i, '') for i in range(max(valid_keys) + 1)] + flags = [flags.get(i, "") for i in range(max(valid_keys) + 1)] if len(flags) > MAX_FLAG_COUNT: - raise ValueError('Too many flags') + raise ValueError("Too many flags") self._arg_flags = flags flags = list(flags) @@ -157,7 +160,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) @@ -180,16 +183,16 @@ class CompositeBitFieldWrapper(object): self.fields = fields def __getattr__(self, attr): - if attr == 'fields': + if attr == "fields": return super(CompositeBitFieldWrapper, self).__getattr__(attr) for field in self.fields: if hasattr(field, attr): return getattr(field, attr) - raise AttributeError('%s is not a valid flag' % attr) + raise AttributeError("%s is not a valid flag" % attr) def __hasattr__(self, attr): - if attr == 'fields': + if attr == "fields": return super(CompositeBitFieldWrapper, self).__hasattr__(attr) for field in self.fields: @@ -198,7 +201,7 @@ class CompositeBitFieldWrapper(object): return False def __setattr__(self, attr, value): - if attr == 'fields': + if attr == "fields": super(CompositeBitFieldWrapper, self).__setattr__(attr, value) return @@ -206,7 +209,7 @@ class CompositeBitFieldWrapper(object): if hasattr(field, attr): setattr(field, attr, value) return - raise AttributeError('%s is not a valid flag' % attr) + raise AttributeError("%s is not a valid flag" % attr) class CompositeBitField(object): @@ -228,15 +231,16 @@ 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.') + raise ValueError("BitField flags must be unique.") def __get__(self, instance, instance_type=None): fields = [getattr(instance, f) for f in self.fields] return CompositeBitFieldWrapper(fields) def __set__(self, *args, **kwargs): - raise NotImplementedError('CompositeBitField cannot be set.') + raise NotImplementedError("CompositeBitField cannot be set.") diff --git a/bitfield/query.py b/bitfield/query.py index 0e97b174..440f06f8 100644 --- a/bitfield/query.py +++ b/bitfield/query.py @@ -1,18 +1,20 @@ from __future__ import absolute_import -from bitfield.types import Bit, BitHandler from django.db.models.lookups import Exact +from bitfield.types import Bit, BitHandler + class BitQueryLookupWrapper(Exact): # NOQA def process_lhs(self, compiler, connection, lhs=None): lhs_sql, lhs_params = super(BitQueryLookupWrapper, self).process_lhs( - compiler, connection, lhs) + compiler, connection, lhs + ) if not isinstance(self.rhs, (BitHandler, Bit)): return lhs_sql, lhs_params - op = ' & ' if self.rhs else ' | ' + op = " & " if self.rhs else " | " rhs_sql, rhs_params = self.process_rhs(compiler, connection) params = list(lhs_params) params.extend(rhs_params) @@ -37,16 +39,21 @@ class BitQuerySaveWrapper(BitQueryLookupWrapper): This will be called by Where.as_sql() """ - engine = connection.settings_dict['ENGINE'].rsplit('.', -1)[-1] - if engine.startswith('postgres'): - XOR_OPERATOR = '#' - elif engine.startswith('sqlite'): + engine = connection.settings_dict["ENGINE"].rsplit(".", -1)[-1] + if engine.startswith("postgres"): + XOR_OPERATOR = "#" + elif engine.startswith("sqlite"): raise NotImplementedError else: - XOR_OPERATOR = '^' + 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), + [], + ) diff --git a/bitfield/types.py b/bitfield/types.py index b28abc98..da0d319c 100644 --- a/bitfield/types.py +++ b/bitfield/types.py @@ -11,6 +11,7 @@ class Bit(object): """ Represents a single Bit. """ + def __init__(self, number, is_set=True): self.number = number self.is_set = bool(is_set) @@ -20,7 +21,11 @@ class Bit(object): self.mask = ~self.mask def __repr__(self): - return '<%s: number=%d, is_set=%s>' % (self.__class__.__name__, self.number, self.is_set) + return "<%s: number=%d, is_set=%s>" % ( + self.__class__.__name__, + self.number, + self.is_set, + ) # def __str__(self): # if self.is_set: @@ -117,6 +122,7 @@ class BitHandler(object): """ Represents an array of bits, each as a ``Bit`` object. """ + def __init__(self, value, keys, labels=None): # TODO: change to bitarray? if value: @@ -147,7 +153,12 @@ 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 str(self._value) @@ -186,17 +197,17 @@ class BitHandler(object): return bool(self.get_bit(bit_number)) def __getattr__(self, key): - if key.startswith('_'): + if key.startswith("_"): return object.__getattribute__(self, key) if key not in self._keys: - raise AttributeError('%s is not a valid flag' % key) + raise AttributeError("%s is not a valid flag" % key) return self.get_bit(self._keys.index(key)) def __setattr__(self, key, value): - if key.startswith('_'): + if key.startswith("_"): return object.__setattr__(self, key, value) if key not in self._keys: - raise AttributeError('%s is not a valid flag' % key) + raise AttributeError("%s is not a valid flag" % key) self.set_bit(self._keys.index(key), value) def __iter__(self): @@ -207,6 +218,7 @@ class BitHandler(object): def _get_mask(self): return self._value + mask = property(_get_mask) def evaluate(self, evaluator, qn, connection): @@ -221,7 +233,7 @@ class BitHandler(object): if true_or_false: self._value |= mask else: - self._value &= (~mask) + self._value &= ~mask return Bit(bit_number, self._value & mask != 0) def keys(self): @@ -243,4 +255,3 @@ class BitHandler(object): if isinstance(flag, Bit): flag = flag.number return self._labels[flag] -