try fix CI

Author: bckohan

.github/workflows/lint.yml

@@ -44,22 +44,12 @@ jobs:
         run: |
           poetry config virtualenvs.in-project true
           poetry run pip install --upgrade pip
-          poetry install -E all
-          poetry run pip install -U "Django~=${{ matrix.django-version }}"
-      - name: Conditionally Install django-filter
-        run: |
-          if [ $(echo "${{ matrix.django-version }}" | awk '{print ($1 < 4.2)}') -eq 1 ]; then
-            poetry run pip install -U "django-filter~=23.5"
-          fi
+          sed -i 's/^python = .*/python = "^${{ matrix.python-version }}"/' pyproject.toml
+          poetry add django@^${{ matrix.django-version }}
+          poetry install --no-interaction -E all
+
       - name: Run Static Analysis
         run: |
-          poetry run isort django_enum --check
-          poetry run black django_enum --check
-          poetry run pylint django_enum
-          poetry run mypy django_enum
-          poetry check
-          poetry run pip check
-          poetry run safety check --full-report
-          poetry run python -m readme_renderer ./README.rst -o /tmp/README.html
-          cd ./doc
-          poetry run doc8 --ignore-path build --max-line-length 100
+          source .venv/bin/activate
+          ./check.sh --no-fix
+          echo "$(poetry env info --path)/bin" >> $GITHUB_PATH

check.sh

@@ -13,7 +13,6 @@ else
 fi
 
 poetry run mypy django_enum
-poetry run pyright
 poetry check
 poetry run pip check
 cd ./doc

django_enum/choices.py

@@ -35,20 +35,20 @@ class DjangoEnumPropertiesMeta(EnumPropertiesMeta, ChoicesType):  # type: ignore
         """
 
         @property
-        def names(cls):
+        def names(self):
             """
             For some eccentric enums list(Enum) is empty, so we override names
             if empty
             """
-            return super().names or names(cls, override=True)
+            return super().names or names(self, override=True)
 
         @property
-        def choices(cls):
+        def choices(self):
             """
             For some eccentric enums list(Enum) is empty, so we override
             choices if empty
             """
-            return super().choices or choices(cls, override=True)
+            return super().choices or choices(self, override=True)
 
     class DjangoSymmetricMixin(SymmetricMixin):
         """
@@ -58,7 +58,7 @@ class DjangoSymmetricMixin(SymmetricMixin):
 
         _symmetric_builtins_ = ["name", "label"]
 
-    class TextChoices(  # pylint: disable=too-many-ancestors
+    class TextChoices(
         DjangoSymmetricMixin, DjangoTextChoices, metaclass=DjangoEnumPropertiesMeta
     ):
         """
@@ -69,7 +69,7 @@ class TextChoices(  # pylint: disable=too-many-ancestors
         def __hash__(self):
             return DjangoTextChoices.__hash__(self)
 
-    class IntegerChoices(  # pylint: disable=too-many-ancestors
+    class IntegerChoices(
         DjangoSymmetricMixin, DjangoIntegerChoices, metaclass=DjangoEnumPropertiesMeta
     ):
         """
@@ -118,7 +118,7 @@ def __hash__(self):
     class MissingEnumProperties(enum.Enum):
         """Throw error if choice types are used without enum-properties"""
 
-        def __init__(self, *args, **kwargs):  # pylint: disable=W0231
+        def __init__(self, *args, **kwargs):
             raise ImportError(
                 f"{self.__class__.__name__} requires enum-properties to be "
                 f"installed."
@@ -134,7 +134,7 @@ class DjangoEnumPropertiesMeta(ChoicesType):  # type: ignore
         the ImportError.
         """
 
-        def __init__(cls, *args, **kwargs):  # pylint: disable=W0231
+        def __init__(cls, *args, **kwargs):
             raise ImportError(
                 f"{cls.__class__.__name__} requires enum-properties to be "
                 f"installed."

django_enum/fields.py

@@ -1,4 +1,3 @@
-# pylint: disable=C0302
 """
 Support for Django model fields built from enumeration types.
 """
@@ -85,7 +84,6 @@ class _DatabaseDefault:
 
 PrimitiveT = TypeVar("PrimitiveT", bound=Type[SupportedPrimitive])
 
-
 condition = "check" if django_version[0:2] < (5, 1) else "condition"
 
 
@@ -143,7 +141,7 @@ class EnumFieldFactory(type):
     based on their python Enum class types.
     """
 
-    def __call__(  # pylint: disable=C0103, R0912, R0911
+    def __call__(
         cls,
         enum: Optional[Type[Enum]] = None,
         primitive: Optional[Type[SupportedPrimitive]] = None,
@@ -225,7 +223,7 @@ class EnumTypeChar(TextChoices):
         # make sure all enumeration values are symmetrically coercible to
         # the primitive, if they are not this could cause some strange behavior
         for value in values(enum):
-            if value is None or type(value) is primitive:  # pylint: disable=C0123
+            if value is None or type(value) is primitive:
                 continue
             try:
                 assert type(value)(primitive(value)) == value  # type: ignore
@@ -418,7 +416,7 @@ def _coerce_to_value_type(self, value: Any) -> Any:
             and self.primitive
             and not isinstance(value, self.primitive)
         ):
-            return self.primitive(value)  # pylint: disable=E1102
+            return self.primitive(value)
         return value
 
     def __init__(
@@ -474,23 +472,21 @@ def _try_coerce(self, value: Any, force: bool = False) -> Union[Enum, Any]:
 
         if (self.coerce or force) and not isinstance(value, self.enum):
             try:
-                value = self.enum(value)  # pylint: disable=E1102
+                value = self.enum(value)
             except (TypeError, ValueError):
                 try:
                     # value = self.primitive(value)
                     value = self._coerce_to_value_type(value)
-                    value = self.enum(value)  # pylint: disable=E1102
+                    value = self.enum(value)
                 except (TypeError, ValueError, DecimalException):
                     try:
                         value = self.enum[value]
                     except KeyError as err:
                         if len(self._value_primitives_) > 1:
                             for primitive in self._value_primitives_:
                                 try:
-                                    return self.enum(  # pylint: disable=E1102
-                                        primitive(value)
-                                    )
-                                except Exception:  # pylint: disable=W0703
+                                    return self.enum(primitive(value))
+                                except Exception:
                                     pass
                         value = self._fallback(value)
                         if not isinstance(value, self.enum) and (
@@ -578,8 +574,8 @@ def get_db_prep_value(self, value, connection, prepared=False) -> Any:
     def from_db_value(
         self,
         value: Any,
-        expression,  # pylint: disable=W0613
-        connection,  # pylint: disable=W0613
+        expression,
+        connection,
     ) -> Any:
         """
         Convert the database field value into the Enum type.
@@ -663,7 +659,7 @@ def formfield(self, form_class=None, choices_form_class=None, **kwargs):
 
         is_multi = self.enum and issubclass(self.enum, Flag)
         if is_multi and self.enum:
-            kwargs["empty_value"] = self.enum(0)  # pylint: disable=E1102
+            kwargs["empty_value"] = self.enum(0)
             # why fail? - does this fail for single select too?
             # kwargs['show_hidden_initial'] = True
 
@@ -694,9 +690,9 @@ def get_choices(
         blank_choice=tuple(BLANK_CHOICE_DASH),
         limit_choices_to=None,
         ordering=(),
-    ):  # pylint: disable=W0221
+    ):
         if self.enum and issubclass(self.enum, Flag):
-            blank_choice = [(self.enum(0), "---------")]  # pylint: disable=E1102
+            blank_choice = [(self.enum(0), "---------")]
         return [
             (getattr(choice, "value", choice), label)
             for choice, label in super().get_choices(
@@ -722,7 +718,7 @@ def constraint_name(
         :param enum: The enumeration type of the EnumField
         """
         name = (
-            f"{model_class._meta.app_label}_"  # pylint: disable=W0212
+            f"{model_class._meta.app_label}_"
             f"{model_class.__name__}_{field_name}_"
             f"{enum.__name__}"
         )
@@ -732,7 +728,7 @@ def constraint_name(
 
     def contribute_to_class(
         self, cls: Type[Model], name: str, private_only: bool = False
-    ):  # pylint: disable=W0221
+    ):
         super().contribute_to_class(cls, name, private_only=private_only)
         if self.constrained and self.enum and issubclass(self.enum, IntFlag):
             # It's possible to declare an IntFlag field with negative values -
@@ -751,20 +747,20 @@ def contribute_to_class(
             )
             if self.null:
                 constraint |= Q(**{f"{name}__isnull": True})
-            cls._meta.constraints = [  # pylint: disable=W0212
-                *cls._meta.constraints,  # pylint: disable=W0212
+            cls._meta.constraints = [
+                *cls._meta.constraints,
                 CheckConstraint(
-                    **{
+                    **{  # type: ignore[arg-type]
                         condition: constraint,
                         "name": self.constraint_name(cls, name, self.enum),
                     }
                 ),
-            ]  # pylint: disable=protected-access
+            ]
             # this dictionary is used to serialize the model, so if constraints
             # is not present - they will not be added to migrations
-            cls._meta.original_attrs.setdefault(  # pylint: disable=W0212
+            cls._meta.original_attrs.setdefault(
                 "constraints",
-                cls._meta.constraints,  # pylint: disable=W0212
+                cls._meta.constraints,
             )
 
 
@@ -1173,16 +1169,16 @@ def contribute_to_class(
             ]
 
             if is_strict or is_conform or (is_eject and self.strict) and flags:
-                constraint = (  # pylint: disable=E1131
+                constraint = (
                     Q(**{f"{name}__gte": min(*flags)})
                     & Q(**{f"{name}__lte": reduce(or_, flags)})
                 ) | Q(**{name: 0})
 
                 if self.null:
                     constraint |= Q(**{f"{name}__isnull": True})
 
-                cls._meta.constraints = [  # pylint: disable=W0212
-                    *cls._meta.constraints,  # pylint: disable=W0212
+                cls._meta.constraints = [
+                    *cls._meta.constraints,
                     CheckConstraint(
                         **{
                             condition: constraint,
@@ -1193,9 +1189,9 @@ def contribute_to_class(
                 # this dictionary is used to serialize the model, so if
                 # constraints is not present - they will not be added to
                 # migrations
-                cls._meta.original_attrs.setdefault(  # pylint: disable=W0212
+                cls._meta.original_attrs.setdefault(
                     "constraints",
-                    cls._meta.constraints,  # pylint: disable=W0212
+                    cls._meta.constraints,
                 )
         if isinstance(self, FlagField):
             # this may have been called by a normal EnumField to bring in flag-like constraints
@@ -1283,8 +1279,8 @@ def get_db_prep_value(self, value: Any, connection, prepared=False):
     def from_db_value(
         self,
         value: Any,
-        expression,  # pylint: disable=W0613
-        connection,  # pylint: disable=W0613
+        expression,
+        connection,
     ) -> Any:
         """
         Convert the database field value into the Enum type.

django_enum/forms.py

@@ -7,7 +7,11 @@
 
 from django.core.exceptions import ValidationError
 from django.db.models import Choices
-from django.forms.fields import Field, TypedChoiceField, TypedMultipleChoiceField
+from django.forms.fields import (
+    Field,
+    TypedChoiceField,
+    TypedMultipleChoiceField,
+)
 from django.forms.widgets import Select, SelectMultiple
 
 from django_enum.utils import choices as get_choices
@@ -91,7 +95,7 @@ class NonStrictSelectMultiple(NonStrictMixin, SelectMultiple):
 
 class ChoiceFieldMixin(
     with_typehint(TypedChoiceField)  # type: ignore
-):  # pylint: disable=R0902
+):
     """
     Mixin to adapt base model form ChoiceFields to use on EnumFields.
 
@@ -119,7 +123,7 @@ class ChoiceFieldMixin(
     _empty_value_overridden_: bool = False
     _empty_values_overridden_: bool = False
 
-    # choices: _ChoicesProperty
+    choices: _ChoicesParameter
 
     def __init__(
         self,
@@ -193,7 +197,7 @@ def enum(self):
     def enum(self, enum):
         self._enum_ = enum
         self._primitive_ = self._primitive_ or determine_primitive(enum)
-        self.choices = self.choices or get_choices(self.enum)  # type: ignore[has-type]
+        self.choices = self.choices or get_choices(self.enum)
         # remove any of our valid enumeration values or symmetric properties
         # from our empty value list if there exists an equivalency
         if not self._empty_values_overridden_:
@@ -215,7 +219,7 @@ def enum(self, enum):
 
     def _coerce_to_value_type(self, value: Any) -> Any:
         """Coerce the value to the enumerations value type"""
-        return self.primitive(value)  # pylint: disable=E1102
+        return self.primitive(value)
 
     def prepare_value(self, value: Any) -> Any:
         """Must return the raw enumeration value type"""
@@ -236,7 +240,7 @@ def valid_value(self, value: Any) -> bool:
         except ValidationError:
             return False
 
-    def default_coerce(self, value: Any) -> Any:  # pylint: disable=E0202
+    def default_coerce(self, value: Any) -> Any:
         """
         Attempt conversion of value to an enumeration value and return it
         if successful.
@@ -252,7 +256,7 @@ def default_coerce(self, value: Any) -> Any:  # pylint: disable=E0202
             one of our empty_values, or the value itself if this is a
             non-strict field and the value is of a matching primitive type
         """
-        if self.enum is not None and not isinstance(value, self.enum):  # pylint: disable=R0801
+        if self.enum is not None and not isinstance(value, self.enum):
             try:
                 value = self.enum(value)
             except (TypeError, ValueError):
@@ -263,6 +267,7 @@ def default_coerce(self, value: Any) -> Any:  # pylint: disable=E0202
                     try:
                         value = self.enum[value]
                     except KeyError as err:
+                        assert self.primitive
                         if self.strict or not isinstance(value, self.primitive):
                             raise ValidationError(
                                 f"{value} is not a valid {self.enum}.",
@@ -284,15 +289,15 @@ def validate(self, value):
             )
 
 
-class EnumChoiceField(ChoiceFieldMixin, TypedChoiceField):
+class EnumChoiceField(ChoiceFieldMixin, TypedChoiceField):  # type: ignore
     """
     The default ``ChoiceField`` will only accept the base enumeration values.
     Use this field on forms to accept any value mappable to an enumeration
     including any labels or symmetric properties.
     """
 
 
-class EnumFlagField(ChoiceFieldMixin, TypedMultipleChoiceField):
+class EnumFlagField(ChoiceFieldMixin, TypedMultipleChoiceField):  # type: ignore
     """
     The default ``TypedMultipleChoiceField`` will only accept the base
     enumeration values. Use this field on forms to accept any value mappable