enumplus 1.0.0__tar.gz → 1.1.0__tar.gz

{enumplus-1.0.0 → enumplus-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: enumplus
-Version: 1.0.0
+Version: 1.1.0
 Summary: Enhanced Python enums with metadata, serialization, and choices
 Author-email: Mathias Paulenko <mathias.paulenko@outlook.com>
 License-Expression: MIT

{enumplus-1.0.0 → enumplus-1.1.0}/enumplus/__init__.py

@@ -1,6 +1,6 @@
 from enumplus.enum import Enum, OrderedEnum
 from enumplus.serialize import SerializableEncoder
 
-__version__ = "0.1.0"
+__version__ = "1.1.0"
 
 __all__ = ["Enum", "OrderedEnum", "SerializableEncoder", "__version__"]

{enumplus-1.0.0 → enumplus-1.1.0}/enumplus/enum.py

@@ -27,6 +27,21 @@ class EnumMeta(enum.EnumMeta):
         member_names: list[str] = list(getattr(namespace, "_member_names", []))
         last_values: list[Any] = getattr(namespace, "_last_values", [])
 
+        class_config: dict[str, Any] = {}
+        _config_keys = {"serialize_by_name"}
+
+        ns_member_names = getattr(namespace, "_member_names", None)
+
+        for key in _config_keys:
+            if key in namespace:
+                class_config[key] = namespace[key]
+                dict.__delitem__(namespace, key)
+                if ns_member_names is not None and key in ns_member_names:
+                    if isinstance(ns_member_names, dict):
+                        del ns_member_names[key]
+                    else:
+                        ns_member_names.remove(key)
+
         for key, value in list(namespace.items()):
             if isinstance(value, tuple) and len(value) == 2 and isinstance(value[1], dict):
                 actual_value, metadata = value
@@ -38,6 +53,12 @@ class EnumMeta(enum.EnumMeta):
 
         new_cls = super().__new__(cls, name, bases, namespace, **kwargs)
 
+        for key, value in class_config.items():
+            setattr(new_cls, key, value)
+
+        if not hasattr(new_cls, "serialize_by_name"):
+            new_cls.serialize_by_name = False
+
         members: list[Any] = list(new_cls)
         for index, member in enumerate(members):
             metadata = member_metadata.get(member.name, {})
@@ -53,6 +74,8 @@ class EnumMeta(enum.EnumMeta):
 
         return new_cls
 
+    serialize_by_name: bool = False
+
     def __contains__(cls, item: Any) -> bool:
         if isinstance(item, cls):
             return True
@@ -72,7 +95,10 @@ class Enum(enum.Enum, metaclass=EnumMeta):
 
     @property
     def label(self) -> str:
-        return self._label_
+        label = self._label_
+        if callable(label):
+            return str(label())
+        return str(label)
 
     @property
     def metadata(self) -> dict[str, Any]:
@@ -89,7 +115,7 @@ class Enum(enum.Enum, metaclass=EnumMeta):
             ) from None
 
     def __str__(self) -> str:
-        return self._label_
+        return self.label
 
     def __repr__(self) -> str:
         return f"<{type(self).__name__}.{self.name}: {self.value!r}>"
@@ -107,20 +133,36 @@ class Enum(enum.Enum, metaclass=EnumMeta):
         return [(member.value, member.label) for member in cls]
 
     @classmethod
-    def from_value(cls, value: Any, default: Any = _SENTINEL) -> Enum:
+    def from_value(
+        cls, value: Any, default: Any = _SENTINEL, *, case_insensitive: bool = False
+    ) -> Enum:
         member: Any
-        for member in cls:
-            if member.value == value:
-                return cast(Enum, member)
+        if case_insensitive and isinstance(value, str):
+            lowered = value.lower()
+            for member in cls:
+                if isinstance(member.value, str) and member.value.lower() == lowered:
+                    return cast(Enum, member)
+        else:
+            for member in cls:
+                if member.value == value:
+                    return cast(Enum, member)
         if default is not _SENTINEL:
             return cast(Enum, default)
         raise ValueError(f"{value!r} is not a valid {cls.__name__} value")
 
     @classmethod
-    def from_name(cls, name: str, default: Any = _SENTINEL) -> Enum:
-        member = cls.__members__.get(name)
-        if member is not None:
-            return member
+    def from_name(
+        cls, name: str, default: Any = _SENTINEL, *, case_insensitive: bool = False
+    ) -> Enum:
+        if case_insensitive:
+            upper = name.upper()
+            for member in cls:
+                if member.name.upper() == upper:
+                    return member
+        else:
+            found = cls.__members__.get(name)
+            if found is not None:
+                return found
         if default is not _SENTINEL:
             return cast(Enum, default)
         raise KeyError(f"{name!r} is not a valid {cls.__name__} name")
@@ -149,6 +191,49 @@ class Enum(enum.Enum, metaclass=EnumMeta):
     def labels(cls) -> list[str]:
         return [member.label for member in cls]
 
+    @classmethod
+    def keys(cls) -> list[str]:
+        return [member.name for member in cls]
+
+    @classmethod
+    def get(cls, value: Any, default: Any = None) -> Enum | None:
+        return cls.from_value(value, default=default)
+
+    @classmethod
+    def get_initial(cls) -> Enum:
+        members = list(cls)
+        if not members:
+            raise ValueError(f"{cls.__name__} has no members")
+        return members[0]
+
+    @classmethod
+    def get_final(cls) -> Enum:
+        members = list(cls)
+        if not members:
+            raise ValueError(f"{cls.__name__} has no members")
+        return members[-1]
+
+    @classmethod
+    def map(cls, mapping: dict[Enum, Any]) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        for member in cls:
+            result[member.name] = mapping.get(member, None)
+        return result
+
+    @classmethod
+    def to_dict(cls) -> dict[str, dict[str, Any]]:
+        result: dict[str, dict[str, Any]] = {}
+        for member in cls:
+            result[member.name] = {
+                "value": member.value,
+                "label": member.label,
+                "metadata": {
+                    k: (v() if callable(v) else v)
+                    for k, v in member._metadata_.items()
+                },
+            }
+        return result
+
     @classmethod
     def filter(cls, **kwargs: Any) -> list[Enum]:
         if not kwargs:

{enumplus-1.0.0 → enumplus-1.1.0}/enumplus/pydantic.py

@@ -14,16 +14,28 @@ def get_pydantic_core_schema(
 ) -> CoreSchema:
     from pydantic_core import core_schema
 
+    serialize_by_name = getattr(cls, "serialize_by_name", False)
+
     def validate(value: Any) -> Any:
         if isinstance(value, cls):
             return value
+        if serialize_by_name and isinstance(value, str):
+            try:
+                return cls.from_name(value)
+            except KeyError:
+                raise ValueError(f"{value!r} is not a valid {cls.__name__} name") from None
         return cls.from_value(value)
 
+    if serialize_by_name:
+        serializer = lambda v: v.name
+    else:
+        serializer = lambda v: v.value
+
     return core_schema.no_info_after_validator_function(
         validate,
         core_schema.any_schema(),
         serialization=core_schema.plain_serializer_function_ser_schema(
-            lambda v: v.value,
+            serializer,
             return_schema=core_schema.any_schema(),
         ),
     )

{enumplus-1.0.0 → enumplus-1.1.0}/enumplus/serialize.py

@@ -6,6 +6,12 @@ from typing import Any, cast
 from enumplus.enum import Enum
 
 
+def _serialize_value(value: Any) -> Any:
+    if callable(value):
+        return value()
+    return value
+
+
 def to_json(cls: type[Enum]) -> str:
     data: dict[str, Any] = {
         "name": cls.__name__,
@@ -14,7 +20,9 @@ def to_json(cls: type[Enum]) -> str:
                 "name": member.name,
                 "value": member.value,
                 "label": member.label,
-                "metadata": member._metadata_,
+                "metadata": {
+                    k: _serialize_value(v) for k, v in member._metadata_.items()
+                },
             }
             for member in cls
         ],

{enumplus-1.0.0 → enumplus-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "enumplus"
-version = "1.0.0"
+version = "1.1.0"
 description = "Enhanced Python enums with metadata, serialization, and choices"
 readme = "README.md"
 requires-python = ">=3.11"

enumplus-1.1.0/tests/test_new_features.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+from enumplus import Enum
+
+
+class TestCaseInsensitive:
+    def test_from_value_case_insensitive(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        assert Color.from_value("Red", case_insensitive=True) is Color.RED
+        assert Color.from_value("GREEN", case_insensitive=True) is Color.GREEN
+        assert Color.from_value("rEd", case_insensitive=True) is Color.RED
+
+    def test_from_value_case_insensitive_not_found(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        try:
+            Color.from_value("blue", case_insensitive=True)
+            raise AssertionError("Should have raised ValueError")
+        except ValueError:
+            pass
+
+    def test_from_value_case_insensitive_with_default(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        assert Color.from_value("Blue", case_insensitive=True, default=None) is None
+
+    def test_from_name_case_insensitive(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        assert Color.from_name("red", case_insensitive=True) is Color.RED
+        assert Color.from_name("green", case_insensitive=True) is Color.GREEN
+        assert Color.from_name("ReD", case_insensitive=True) is Color.RED
+
+    def test_from_name_case_insensitive_not_found(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        try:
+            Color.from_name("blue", case_insensitive=True)
+            raise AssertionError("Should have raised KeyError")
+        except KeyError:
+            pass
+
+    def test_from_value_case_insensitive_non_string(self) -> None:
+        class Number(Enum):
+            ONE = 1
+            TWO = 2
+
+        assert Number.from_value(1, case_insensitive=True) is Number.ONE
+        assert Number.from_value(2, case_insensitive=True) is Number.TWO
+
+
+class TestToDict:
+    def test_to_dict_basic(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        d = Color.to_dict()
+        assert "RED" in d
+        assert d["RED"]["value"] == "red"
+        assert d["RED"]["label"] == "Red"
+        assert d["RED"]["metadata"] == {}
+        assert d["GREEN"]["value"] == "green"
+        assert d["GREEN"]["label"] == "Green"
+
+    def test_to_dict_with_metadata(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"hex": "#FF0000"})
+            GREEN = "green"
+
+        d = Color.to_dict()
+        assert d["RED"]["metadata"] == {"hex": "#FF0000"}
+        assert d["RED"]["label"] == "Red"
+        assert d["GREEN"]["metadata"] == {}
+
+    def test_to_dict_with_custom_label(self) -> None:
+        class Status(Enum):
+            IN_PROGRESS = ("in_progress", {"label": "In Progress"})
+
+        d = Status.to_dict()
+        assert d["IN_PROGRESS"]["label"] == "In Progress"
+
+
+class TestGet:
+    def test_get_returns_member(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        assert Color.get("red") is Color.RED
+
+    def test_get_returns_default(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        assert Color.get("blue", default=None) is None
+        assert Color.get("blue", default=Color.RED) is Color.RED
+
+    def test_get_default_is_none(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        assert Color.get("blue") is None
+
+
+class TestGetInitial:
+    def test_get_initial(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+            BLUE = "blue"
+
+        assert Color.get_initial() is Color.RED
+
+    def test_get_initial_single_member(self) -> None:
+        class Single(Enum):
+            ONLY = 1
+
+        assert Single.get_initial() is Single.ONLY
+
+    def test_get_initial_empty_raises(self) -> None:
+        class Empty(Enum):
+            pass
+
+        try:
+            Empty.get_initial()
+            raise AssertionError("Should have raised ValueError")
+        except ValueError:
+            pass
+
+
+class TestGetFinal:
+    def test_get_final(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+            BLUE = "blue"
+
+        assert Color.get_final() is Color.BLUE
+
+    def test_get_final_single_member(self) -> None:
+        class Single(Enum):
+            ONLY = 1
+
+        assert Single.get_final() is Single.ONLY
+
+    def test_get_final_empty_raises(self) -> None:
+        class Empty(Enum):
+            pass
+
+        try:
+            Empty.get_final()
+            raise AssertionError("Should have raised ValueError")
+        except ValueError:
+            pass
+
+
+class TestKeys:
+    def test_keys_returns_names(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        assert Color.keys() == ["RED", "GREEN"]
+
+    def test_keys_empty(self) -> None:
+        class Empty(Enum):
+            pass
+
+        assert Empty.keys() == []
+
+    def test_keys_equals_names(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        assert Color.keys() == Color.names()
+
+
+class TestMap:
+    def test_map_basic(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        result = Color.map({Color.RED: "#FF0000", Color.GREEN: "#00FF00"})
+        assert result == {"RED": "#FF0000", "GREEN": "#00FF00"}
+
+    def test_map_partial(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        result = Color.map({Color.RED: "#FF0000"})
+        assert result == {"RED": "#FF0000", "GREEN": None}
+
+    def test_map_empty(self) -> None:
+        class Color(Enum):
+            RED = "red"
+
+        result = Color.map({})
+        assert result == {"RED": None}
+
+
+class TestI18nLabels:
+    def test_callable_label(self) -> None:
+        translations = {"RED": "Rojo", "GREEN": "Verde"}
+
+        def translate(key: str) -> str:
+            return translations.get(key, key)
+
+        class Color(Enum):
+            RED = ("red", {"label": lambda: translate("RED")})
+            GREEN = ("green", {"label": lambda: translate("GREEN")})
+
+        assert Color.RED.label == "Rojo"
+        assert Color.GREEN.label == "Verde"
+
+    def test_callable_label_changes_with_locale(self) -> None:
+        current_locale: dict[str, str] = {"lang": "en"}
+        en = {"RED": "Red", "GREEN": "Green"}
+        es = {"RED": "Rojo", "GREEN": "Verde"}
+
+        def translate(key: str) -> str:
+            lang = current_locale["lang"]
+            table = es if lang == "es" else en
+            return table.get(key, key)
+
+        class Color(Enum):
+            RED = ("red", {"label": lambda: translate("RED")})
+            GREEN = ("green", {"label": lambda: translate("GREEN")})
+
+        assert Color.RED.label == "Red"
+        current_locale["lang"] = "es"
+        assert Color.RED.label == "Rojo"
+        assert Color.GREEN.label == "Verde"
+        current_locale["lang"] = "en"
+        assert Color.RED.label == "Red"
+
+    def test_non_callable_label_unchanged(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"label": "Red"})
+
+        assert Color.RED.label == "Red"
+
+    def test_callable_label_in_choices(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"label": lambda: "Rojo"})
+
+        assert Color.choices() == [("red", "Rojo")]
+
+    def test_callable_label_in_to_dict(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"label": lambda: "Rojo"})
+
+        d = Color.to_dict()
+        assert d["RED"]["label"] == "Rojo"
+
+    def test_callable_label_in_str(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"label": lambda: "Rojo"})
+
+        assert str(Color.RED) == "Rojo"
+
+    def test_callable_label_in_labels(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"label": lambda: "Rojo"})
+            GREEN = ("green", {"label": lambda: "Verde"})
+
+        assert Color.labels() == ["Rojo", "Verde"]
+
+    def test_callable_label_in_to_json(self) -> None:
+        class Color(Enum):
+            RED = ("red", {"label": lambda: "Rojo"})
+
+        import json
+
+        data = json.loads(Color.to_json())
+        assert data["members"][0]["label"] == "Rojo"
+
+
+class TestSerializeByName:
+    def test_flag_default_false(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+        assert Color.serialize_by_name is False
+
+    def test_flag_set_true(self) -> None:
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+
+            serialize_by_name = True
+
+        assert Color.serialize_by_name is True

{enumplus-1.0.0 → enumplus-1.1.0}/tests/test_public_api.py

@@ -15,4 +15,4 @@ def test_all_exports() -> None:
 
 
 def test_version() -> None:
-    assert enumplus.__version__ == "0.1.0"
+    assert enumplus.__version__ == "1.1.0"

enumplus-1.1.0/tests/test_pydantic.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("pydantic")
+
+from pydantic import BaseModel, ValidationError
+
+from enumplus import Enum
+
+
+class Color(Enum):
+    RED = "red"
+    GREEN = "green"
+
+
+class MyModel(BaseModel):
+    color: Color
+
+
+def test_pydantic_validate_string() -> None:
+    model = MyModel(color="red")  # type: ignore[arg-type]
+    assert model.color is Color.RED
+
+
+def test_pydantic_validate_member() -> None:
+    model = MyModel(color=Color.RED)
+    assert model.color is Color.RED
+
+
+def test_pydantic_invalid() -> None:
+    with pytest.raises(ValidationError):
+        MyModel(color="blue")  # type: ignore[arg-type]
+
+
+def test_pydantic_dump() -> None:
+    model = MyModel(color=Color.RED)
+    assert model.model_dump() == {"color": "red"}
+
+
+def test_pydantic_dump_json() -> None:
+    model = MyModel(color=Color.RED)
+    assert model.model_dump_json() == '{"color":"red"}'
+
+
+class ColorByName(Enum):
+    RED = "red"
+    GREEN = "green"
+
+    serialize_by_name = True
+
+
+class MyModelByName(BaseModel):
+    color: ColorByName
+
+
+def test_pydantic_serialize_by_name_validate() -> None:
+    model = MyModelByName(color="RED")  # type: ignore[arg-type]
+    assert model.color is ColorByName.RED
+
+
+def test_pydantic_serialize_by_name_validate_member() -> None:
+    model = MyModelByName(color=ColorByName.RED)
+    assert model.color is ColorByName.RED
+
+
+def test_pydantic_serialize_by_name_invalid() -> None:
+    with pytest.raises(ValidationError):
+        MyModelByName(color="blue")  # type: ignore[arg-type]
+
+
+def test_pydantic_serialize_by_name_dump() -> None:
+    model = MyModelByName(color=ColorByName.RED)
+    assert model.model_dump() == {"color": "RED"}
+
+
+def test_pydantic_serialize_by_name_dump_json() -> None:
+    model = MyModelByName(color=ColorByName.RED)
+    assert model.model_dump_json() == '{"color":"RED"}'

enumplus-1.0.0/tests/test_pydantic.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-pytest.importorskip("pydantic")
-
-from pydantic import BaseModel, ValidationError
-
-from enumplus import Enum
-
-
-class Color(Enum):
-    RED = "red"
-    GREEN = "green"
-
-
-class MyModel(BaseModel):
-    color: Color
-
-
-def test_pydantic_validate_string() -> None:
-    model = MyModel(color="red")  # type: ignore[arg-type]
-    assert model.color is Color.RED
-
-
-def test_pydantic_validate_member() -> None:
-    model = MyModel(color=Color.RED)
-    assert model.color is Color.RED
-
-
-def test_pydantic_invalid() -> None:
-    with pytest.raises(ValidationError):
-        MyModel(color="blue")  # type: ignore[arg-type]
-
-
-def test_pydantic_dump() -> None:
-    model = MyModel(color=Color.RED)
-    assert model.model_dump() == {"color": "red"}
-
-
-def test_pydantic_dump_json() -> None:
-    model = MyModel(color=Color.RED)
-    assert model.model_dump_json() == '{"color":"red"}'