diff -pruN 3.1.0-1/debian/changelog 3.1.1-1/debian/changelog --- 3.1.0-1/debian/changelog 2025-10-05 04:41:45.000000000 +0000 +++ 3.1.1-1/debian/changelog 2025-12-02 15:07:12.000000000 +0000 @@ -1,3 +1,9 @@ +django-choices-field (3.1.1-1) unstable; urgency=medium + + * [aaa5981] New upstream version 3.1.1 + + -- Carsten Schoenert Tue, 02 Dec 2025 17:07:12 +0200 + django-choices-field (3.1.0-1) unstable; urgency=medium * [91fd85f] d/watch: Convert to version 5 diff -pruN 3.1.0-1/django_choices_field/fields.py 3.1.1-1/django_choices_field/fields.py --- 3.1.0-1/django_choices_field/fields.py 2025-09-27 10:05:14.000000000 +0000 +++ 3.1.1-1/django_choices_field/fields.py 2025-10-24 15:39:33.000000000 +0000 @@ -9,6 +9,7 @@ from typing import ( Sequence, Tuple, Type, + Union, cast, ) @@ -22,8 +23,12 @@ def _get_flag_description(descs: Sequenc return "|".join(str(desc) for desc in descs) -def _get_integer_enum_members(choices: List[Tuple[int, str]]) -> Dict[str, int]: - return {desc.replace(" ", "_").upper(): value for value, desc in choices} +def _get_integer_enum_members(choices: List[Tuple[Union[int, None], str]]) -> Dict[str, int]: + # choices can contain the `None` key which can't be mapped to an enum. See + # Django Model Field docs about Enumeration Types for more info about + # labelling empty states with `__empty__`. + filtered_choices = [(k, v) for (k, v) in choices if k is not None] + return {desc.replace(" ", "_").upper(): value for value, desc in filtered_choices} try: @@ -53,15 +58,23 @@ class TextChoicesField(models.CharField) ): if choices_enum is not None: self.choices_enum = choices_enum - kwargs["choices"] = [(x.value, x.label) for x in choices_enum] + if getattr(self, "null", False) or kwargs.get("null"): + kwargs["choices"] = choices_enum.choices + else: + kwargs["choices"] = [ + (k, v) for (k, v) in choices_enum.choices if cast(object, k) is not None + ] elif "choices" in kwargs: self.choices_enum = models.TextChoices( "ChoicesEnum", - [(k, (k, v)) for k, v in kwargs["choices"]], + [(k, (k, v)) for k, v in kwargs["choices"] if k is not None], ) else: raise TypeError("either of choices_enum or choices must be provided") - kwargs.setdefault("max_length", max(len(c[0]) for c in kwargs["choices"])) + kwargs.setdefault( + "max_length", + max(len(c[0]) for c in kwargs["choices"] if c[0] is not None), + ) super().__init__(verbose_name=verbose_name, name=name, **kwargs) def to_python(self, value): @@ -100,7 +113,12 @@ class IntegerChoicesField(models.Integer ): if choices_enum is not None: self.choices_enum = choices_enum - kwargs["choices"] = [(x.value, x.label) for x in choices_enum] + if getattr(self, "null", False) or kwargs.get("null"): + kwargs["choices"] = choices_enum.choices + else: + kwargs["choices"] = [ + (k, v) for (k, v) in choices_enum.choices if cast(object, k) is not None + ] elif "choices" in kwargs: enum_members = _get_integer_enum_members(kwargs["choices"]) self.choices_enum = models.IntegerChoices("ChoicesEnum", enum_members) @@ -153,8 +171,13 @@ class IntegerChoicesFlagField(models.Int if choices_enum is not None: self.choices_enum = choices_enum + if getattr(self, "null", False) or kwargs.get("null"): + kwargs["choices"] = choices_enum.choices + else: + kwargs["choices"] = [ + (k, v) for (k, v) in choices_enum.choices if cast(object, k) is not None + ] default_choices = [(x.value, x.label) for x in choices_enum] - kwargs["choices"] = default_choices[:] for i in range(1, len(default_choices)): for combination in itertools.combinations(default_choices, i + 1): value = functools.reduce(lambda a, b: a | b[0], combination, 0) diff -pruN 3.1.0-1/pyproject.toml 3.1.1-1/pyproject.toml --- 3.1.0-1/pyproject.toml 2025-09-27 10:05:14.000000000 +0000 +++ 3.1.1-1/pyproject.toml 2025-10-24 15:39:33.000000000 +0000 @@ -1,6 +1,6 @@ [tool.poetry] name = "django-choices-field" -version = "3.1.0" +version = "3.1.1" description = "Django field that set/get django's new TextChoices/IntegerChoices enum." authors = ["Thiago Bellini Ribeiro "] license = "MIT" diff -pruN 3.1.0-1/tests/models.py 3.1.1-1/tests/models.py --- 3.1.0-1/tests/models.py 2025-09-27 10:05:14.000000000 +0000 +++ 3.1.1-1/tests/models.py 2025-10-24 15:39:33.000000000 +0000 @@ -14,10 +14,20 @@ class MyModel(models.Model): C_FOO = "foo", "T Foo Description" C_BAR = "bar", "T Bar Description" + class TextEnumWithEmptyStateLabel(models.TextChoices): + __empty__ = "This is the label for the text empty value" + C_FOO = "foo", "T Foo Description" + C_BAR = "bar", "T Bar Description" + class IntegerEnum(models.IntegerChoices): I_FOO = 1, "I Foo Description" I_BAR = 2, "I Bar Description" + class IntegerEnumWithEmptyStateLabel(models.IntegerChoices): + __empty__ = "This is the label for the int empty value" + I_FOO = 1, "I Foo Description" + I_BAR = 2, "I Bar Description" + class IntegerFlagEnum(IntegerChoicesFlag): IF_FOO = ( enum.auto() if sys.version_info >= (3, 11) else 1, @@ -33,8 +43,6 @@ class MyModel(models.Model): ) class IntegerFlagEnumTranslated(IntegerChoicesFlag): - __empty__ = _("this is the label for the empty value") - IF_FOO = ( enum.auto() if sys.version_info >= (3, 11) else 1, _("IF Foo Description"), # type: ignore @@ -48,6 +56,21 @@ class MyModel(models.Model): _("IF Bin Description"), # type: ignore ) + class IntegerFlagEnumWithEmptyStateLabel(IntegerChoicesFlag): + __empty__ = "This is the label for the flag empty value" + IF_FOO = ( + enum.auto() if sys.version_info >= (3, 11) else 1, + "IF Foo Description", # type: ignore + ) + IF_BAR = ( + enum.auto() if sys.version_info >= (3, 11) else 2, + "IF Bar Description", # type: ignore + ) + IF_BIN = ( + enum.auto() if sys.version_info >= (3, 11) else 4, + "IF Bin Description", # type: ignore + ) + objects = models.Manager["MyModel"]() # type: ignore c_field = TextChoicesField( @@ -58,6 +81,14 @@ class MyModel(models.Model): choices_enum=TextEnum, null=True, ) + c_field_with_empty_state = TextChoicesField( + choices_enum=TextEnumWithEmptyStateLabel, + default=TextEnumWithEmptyStateLabel.C_FOO, + ) + c_field_with_empty_state_nullable = TextChoicesField( + choices_enum=TextEnumWithEmptyStateLabel, + null=True, + ) i_field = IntegerChoicesField( choices_enum=IntegerEnum, default=IntegerEnum.I_FOO, @@ -66,6 +97,14 @@ class MyModel(models.Model): choices_enum=IntegerEnum, null=True, ) + i_field_with_empty_state = IntegerChoicesField( + choices_enum=IntegerEnumWithEmptyStateLabel, + default=IntegerEnumWithEmptyStateLabel.I_FOO, + ) + i_field_with_empty_state_nullable = IntegerChoicesField( + choices_enum=IntegerEnumWithEmptyStateLabel, + null=True, + ) if_field = IntegerChoicesFlagField( choices_enum=IntegerFlagEnum, default=IntegerFlagEnum.IF_FOO, @@ -82,3 +121,11 @@ class MyModel(models.Model): choices_enum=IntegerFlagEnumTranslated, null=True, ) + if_field_with_empty_state = IntegerChoicesFlagField( + choices_enum=IntegerFlagEnumWithEmptyStateLabel, + default=IntegerFlagEnumWithEmptyStateLabel.IF_FOO, + ) + if_field_with_empty_state_nullable = IntegerChoicesFlagField( + choices_enum=IntegerFlagEnumWithEmptyStateLabel, + null=True, + ) diff -pruN 3.1.0-1/tests/test_fields.py 3.1.1-1/tests/test_fields.py --- 3.1.0-1/tests/test_fields.py 2025-09-27 10:05:14.000000000 +0000 +++ 3.1.1-1/tests/test_fields.py 2025-10-24 15:39:33.000000000 +0000 @@ -15,6 +15,19 @@ def test_field_choices_text(fname: str): ] +def test_field_choices_text_with_labelled_empty_state(): + assert MyModel._meta.get_field("c_field_with_empty_state").choices == [ + ("foo", "T Foo Description"), + ("bar", "T Bar Description"), + ] + + assert MyModel._meta.get_field("c_field_with_empty_state_nullable").choices == [ + (None, "This is the label for the text empty value"), + ("foo", "T Foo Description"), + ("bar", "T Bar Description"), + ] + + @pytest.mark.parametrize("fname", ["i_field", "i_field_nullable"]) def test_field_choices_integer(fname: str): f = MyModel._meta.get_field(fname) @@ -24,6 +37,19 @@ def test_field_choices_integer(fname: st ] +def test_field_choices_integer_with_labelled_empty_state(): + assert MyModel._meta.get_field("i_field_with_empty_state").choices == [ + (1, "I Foo Description"), + (2, "I Bar Description"), + ] + + assert MyModel._meta.get_field("i_field_with_empty_state_nullable").choices == [ + (None, "This is the label for the int empty value"), + (1, "I Foo Description"), + (2, "I Bar Description"), + ] + + @pytest.mark.parametrize( "fname", ["if_field", "if_field_nullable", "ift_field", "ift_field_nullable"], @@ -41,6 +67,24 @@ def test_field_choices_integer_flags(fna ] +def test_field_choices_integer_flags_with_empty_state_label(): + expected_choices = [ + (None, "This is the label for the flag empty value"), + (1, "IF Foo Description"), + (2, "IF Bar Description"), + (4, "IF Bin Description"), + (3, "IF Foo Description|IF Bar Description"), + (5, "IF Foo Description|IF Bin Description"), + (6, "IF Bar Description|IF Bin Description"), + (7, "IF Foo Description|IF Bar Description|IF Bin Description"), + ] + + assert MyModel._meta.get_field("if_field_with_empty_state").choices == [ + x for x in expected_choices if x[0] + ] + assert MyModel._meta.get_field("if_field_with_empty_state_nullable").choices == expected_choices + + def test_default_value_text(): m = MyModel() assert isinstance(m.c_field, MyModel.TextEnum) @@ -229,3 +273,51 @@ def test_set_wrong_value_integer_flag(v, m.save() assert str(exc.value) == f"Field 'if_field' expected a number but got '{v}'." + + +def test_text_field_get_display(db): + m = MyModel() + assert isinstance(m.c_field, MyModel.TextEnum) + assert m.c_field == MyModel.TextEnum.C_FOO + assert m.get_c_field_display() == "T Foo Description" + + assert m.c_field_nullable is None + assert m.get_c_field_nullable_display() is None + + assert m.c_field_with_empty_state_nullable is None + assert ( + m.get_c_field_with_empty_state_nullable_display() + == MyModel.TextEnumWithEmptyStateLabel.__empty__ + ) + + +def test_int_field_get_display(db): + m = MyModel() + assert isinstance(m.i_field, MyModel.IntegerEnum) + assert m.i_field == MyModel.IntegerEnum.I_FOO + assert m.get_i_field_display() == "I Foo Description" + + assert m.i_field_nullable is None + assert m.get_i_field_nullable_display() is None + + assert m.i_field_with_empty_state_nullable is None + assert ( + m.get_i_field_with_empty_state_nullable_display() + == MyModel.IntegerEnumWithEmptyStateLabel.__empty__ + ) + + +def test_int_flag_field_get_display(db): + m = MyModel() + assert isinstance(m.if_field, MyModel.IntegerFlagEnum) + assert m.if_field == MyModel.IntegerFlagEnum.IF_FOO + assert m.get_if_field_display() == "IF Foo Description" + + assert m.if_field_nullable is None + assert m.get_if_field_nullable_display() is None + + assert m.if_field_with_empty_state_nullable is None + assert ( + m.get_if_field_with_empty_state_nullable_display() + == MyModel.IntegerFlagEnumWithEmptyStateLabel.__empty__ + )