PythonIota 1.0.0__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonIota
-Version: 1.0.0
+Version: 1.1.0
 Summary: Go-style iota enumerations and flexible sequence generators for Python
 Author: Equinox
 License: MIT

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PythonIota"
-version = "1.0.0"
+version = "1.1.0"
 description = "Go-style iota enumerations and flexible sequence generators for Python"
 readme = "README.md"
 license = {text = "MIT"}

{pythoniota-1.0.0 → pythoniota-1.1.0}/src/PythonIota.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonIota
-Version: 1.0.0
+Version: 1.1.0
 Summary: Go-style iota enumerations and flexible sequence generators for Python
 Author: Equinox
 License: MIT

{pythoniota-1.0.0 → pythoniota-1.1.0}/src/PythonIota.egg-info/SOURCES.txt

@@ -8,10 +8,15 @@ src/pythoniota/_bitflag.py
 src/pythoniota/_compat.py
 src/pythoniota/_safe_eval.py
 src/pythoniota/enum.py
+src/pythoniota/recipes.py
 src/pythoniota/sequence.py
 tests/test_bitflags.py
 tests/test_compat.py
 tests/test_enum.py
+tests/test_enum_enhanced.py
 tests/test_integration.py
+tests/test_recipes.py
 tests/test_safe_eval.py
-tests/test_sequence.py
+tests/test_sequence.py
+tests/test_serialization.py
+tests/test_string_enum.py

{pythoniota-1.0.0 → pythoniota-1.1.0}/src/pythoniota/__init__.py

@@ -1,15 +1,18 @@
 from pythoniota._compat import Iota
 from pythoniota._bitflag import BitFlag
 from pythoniota._safe_eval import safe_eval
-from pythoniota.enum import IotaEnum, IotaBitFlags
+from pythoniota.enum import IotaEnum, IotaBitFlags, IotaStringEnum
 from pythoniota.sequence import IotaSequence as iota
+from pythoniota import recipes
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 __all__ = [
     "Iota",
     "IotaEnum",
     "IotaBitFlags",
+    "IotaStringEnum",
     "iota",
     "BitFlag",
     "safe_eval",
+    "recipes",
 ]

{pythoniota-1.0.0 → pythoniota-1.1.0}/src/pythoniota/_bitflag.py

@@ -69,6 +69,20 @@ class BitFlag:
     def has(self, flag: BitFlag | int) -> bool:
         return flag in self
 
+    def has_any(self, *flags: BitFlag | int) -> bool:
+        for f in flags:
+            fv = f._value if isinstance(f, BitFlag) else int(f)
+            if self._value & fv:
+                return True
+        return False
+
+    def has_all(self, *flags: BitFlag | int) -> bool:
+        for f in flags:
+            fv = f._value if isinstance(f, BitFlag) else int(f)
+            if (self._value & fv) != fv:
+                return False
+        return True
+
     def decompose(self) -> list[BitFlag]:
         result = []
         v = self._value

{pythoniota-1.0.0 → pythoniota-1.1.0}/src/pythoniota/enum.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from collections import OrderedDict
 from typing import Any, Iterator
 
@@ -124,7 +125,7 @@ class IotaNamespace(dict):  # type: ignore[type-arg]
         if (
             not key.startswith("_")
             and key != "iota"
-            and isinstance(value, (int, float, _IotaCounter))
+            and isinstance(value, (int, float, str, _IotaCounter))
         ):
             if key not in self._member_names:
                 self._member_names.append(key)
@@ -144,25 +145,45 @@ class IotaEnumMeta(type):
         **kwargs: Any,
     ) -> IotaEnumMeta:
         member_names = namespace._member_names if isinstance(namespace, IotaNamespace) else []
-        members: OrderedDict[str, int | float] = OrderedDict()
+        members: OrderedDict[str, Any] = OrderedDict()
         for mname in member_names:
             val = namespace[mname] if mname in namespace else 0
             members[mname] = int(val) if isinstance(val, _IotaCounter) else val
 
         cls = super().__new__(mcs, name, bases, dict(namespace))
         cls._members_ = members  # type: ignore[attr-defined]
+        cls._aliases_: dict[str, str] = {}  # type: ignore[attr-defined]
 
         is_bitflag = any(
             hasattr(b, "_is_bitflag_base") for b in bases
         )
-        for mname, mval in members.items():
-            if is_bitflag:
+        is_string_enum = any(
+            hasattr(b, "_is_string_enum_base") for b in bases
+        )
+
+        if is_string_enum:
+            fmt = namespace.get("_format_", None)
+            for mname, mval in list(members.items()):
+                if isinstance(mval, _IotaCounter) or isinstance(mval, int):
+                    if fmt:
+                        members[mname] = fmt.format(name=mname, index=mval if isinstance(mval, int) else int(mval))
+                    else:
+                        members[mname] = mname
+                type.__setattr__(cls, mname, members[mname])
+        elif is_bitflag:
+            for mname, mval in members.items():
                 flag = BitFlag(int(mval), mname)
                 members[mname] = flag
                 type.__setattr__(cls, mname, flag)
-            else:
+        else:
+            for mname, mval in members.items():
                 type.__setattr__(cls, mname, mval)
 
+        doc_lines = [f"{name} enum members:"]
+        for mname, mval in members.items():
+            doc_lines.append(f"  {mname} = {mval}")
+        cls.__doc__ = "\n".join(doc_lines)
+
         return cls
 
     def __iter__(cls) -> Iterator[tuple[str, int | float]]:
@@ -201,20 +222,55 @@ class IotaEnum(metaclass=IotaEnumMeta):
         return list(cls._members_.keys())  # type: ignore[attr-defined]
 
     @classmethod
-    def values(cls) -> list[int | float]:
+    def values(cls) -> list[Any]:
         return list(cls._members_.values())  # type: ignore[attr-defined]
 
     @classmethod
-    def items(cls) -> list[tuple[str, int | float]]:
+    def items(cls) -> list[tuple[str, Any]]:
         return list(cls._members_.items())  # type: ignore[attr-defined]
 
     @classmethod
-    def from_value(cls, value: int | float) -> str | None:
+    def from_value(cls, value: Any) -> str | None:
         for name, val in cls._members_.items():  # type: ignore[attr-defined]
             if val == value:
                 return name
+        for alias, target in cls._aliases_.items():  # type: ignore[attr-defined]
+            if cls._members_[target] == value:  # type: ignore[attr-defined]
+                return alias
         return None
 
+    @classmethod
+    def alias(cls, alias_name: str, target_name: str) -> None:
+        if target_name not in cls._members_:  # type: ignore[attr-defined]
+            raise KeyError(f"'{target_name}' is not a member of {cls.__name__}")
+        cls._aliases_[alias_name] = target_name  # type: ignore[attr-defined]
+        type.__setattr__(cls, alias_name, cls._members_[target_name])  # type: ignore[attr-defined]
+
+    @classmethod
+    def to_dict(cls) -> dict[str, Any]:
+        return dict(cls._members_)  # type: ignore[attr-defined]
+
+    @classmethod
+    def to_json(cls, **kwargs: Any) -> str:
+        d = {}
+        for k, v in cls._members_.items():  # type: ignore[attr-defined]
+            d[k] = int(v) if isinstance(v, (BitFlag, float)) and not isinstance(v, str) else v
+        return json.dumps(d, **kwargs)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
+        result = {}
+        for name, value in data.items():
+            if name in cls._members_:  # type: ignore[attr-defined]
+                result[name] = cls._members_[name]  # type: ignore[attr-defined]
+            else:
+                raise KeyError(f"'{name}' is not a member of {cls.__name__}")
+        return result
+
+    @classmethod
+    def from_json(cls, s: str) -> dict[str, Any]:
+        return cls.from_dict(json.loads(s))
+
 
 class IotaBitFlags(metaclass=IotaEnumMeta):
     _is_bitflag_base = True
@@ -237,3 +293,29 @@ class IotaBitFlags(metaclass=IotaEnumMeta):
             if int(flag) == value:
                 return name
         return None
+
+    @classmethod
+    def to_dict(cls) -> dict[str, int]:
+        return {k: int(v) for k, v in cls._members_.items()}  # type: ignore[attr-defined]
+
+    @classmethod
+    def to_json(cls, **kwargs: Any) -> str:
+        return json.dumps(cls.to_dict(), **kwargs)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> dict[str, BitFlag]:
+        result = {}
+        for name in data:
+            if name in cls._members_:  # type: ignore[attr-defined]
+                result[name] = cls._members_[name]  # type: ignore[attr-defined]
+            else:
+                raise KeyError(f"'{name}' is not a member of {cls.__name__}")
+        return result
+
+    @classmethod
+    def from_json(cls, s: str) -> dict[str, BitFlag]:
+        return cls.from_dict(json.loads(s))
+
+
+class IotaStringEnum(IotaEnum):
+    _is_string_enum_base = True

pythoniota-1.1.0/src/pythoniota/recipes.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import itertools
+import math
+from typing import Any, Callable, Iterator
+
+from pythoniota.sequence import IotaSequence
+
+
+def fibonacci(n: int | None = None) -> IotaSequence:
+    def _fib_map(_: int) -> int:
+        return 0  # placeholder, overridden below
+
+    class FibSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int]:
+            a, b = 0, 1
+            if self._stop is None:
+                while True:
+                    yield a
+                    a, b = b, a + b
+            else:
+                count = 0
+                while count < self._stop:
+                    yield a
+                    a, b = b, a + b
+                    count += 1
+
+        def __repr__(self) -> str:
+            if self._stop is None:
+                return "fibonacci(infinite)"
+            return f"fibonacci({self._stop})"
+
+    seq = FibSequence.__new__(FibSequence)
+    seq._start = 0
+    seq._stop = n
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def geometric(start: int | float, ratio: int | float, n: int | None = None) -> IotaSequence:
+    class GeomSequence(IotaSequence):
+        def __init__(self, start_val: int | float, ratio_val: int | float, count: int | None) -> None:
+            self._start = 0
+            self._stop = count
+            self._step = 1
+            self._map = None
+            self._geo_start = start_val
+            self._geo_ratio = ratio_val
+
+        def __iter__(self) -> Iterator[int | float]:
+            val = self._geo_start
+            if self._stop is None:
+                while True:
+                    yield val
+                    val *= self._geo_ratio
+            else:
+                for _ in range(self._stop):
+                    yield val
+                    val *= self._geo_ratio
+
+        def __repr__(self) -> str:
+            if self._stop is None:
+                return f"geometric(start={self._geo_start}, ratio={self._geo_ratio}, infinite)"
+            return f"geometric(start={self._geo_start}, ratio={self._geo_ratio}, n={self._stop})"
+
+    return GeomSequence(start, ratio, n)
+
+
+def primes(n: int | None = None) -> IotaSequence:
+    class PrimeSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int]:
+            count = 0
+            candidate = 2
+            while n is None or count < n:
+                if _is_prime(candidate):
+                    yield candidate
+                    count += 1
+                candidate += 1
+
+        def __repr__(self) -> str:
+            if self._stop is None:
+                return "primes(infinite)"
+            return f"primes({self._stop})"
+
+    seq = PrimeSequence.__new__(PrimeSequence)
+    seq._start = 0
+    seq._stop = n
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def _is_prime(num: int) -> bool:
+    if num < 2:
+        return False
+    if num < 4:
+        return True
+    if num % 2 == 0 or num % 3 == 0:
+        return False
+    i = 5
+    while i * i <= num:
+        if num % i == 0 or num % (i + 2) == 0:
+            return False
+        i += 6
+    return True
+
+
+def repeat(value: Any, n: int | None = None) -> IotaSequence:
+    class RepeatSequence(IotaSequence):
+        def __init__(self, val: Any, count: int | None) -> None:
+            self._start = 0
+            self._stop = count
+            self._step = 1
+            self._map = None
+            self._repeat_val = val
+
+        def __iter__(self) -> Iterator[Any]:
+            if self._stop is None:
+                while True:
+                    yield self._repeat_val
+            else:
+                for _ in range(self._stop):
+                    yield self._repeat_val
+
+        def __repr__(self) -> str:
+            if self._stop is None:
+                return f"repeat({self._repeat_val!r}, infinite)"
+            return f"repeat({self._repeat_val!r}, {self._stop})"
+
+    return RepeatSequence(value, n)
+
+
+def cycle(iterable: Any, n: int | None = None) -> IotaSequence:
+    class CycleSequence(IotaSequence):
+        def __init__(self, items: Any, count: int | None) -> None:
+            self._start = 0
+            self._stop = count
+            self._step = 1
+            self._map = None
+            self._cycle_items = list(items)
+
+        def __iter__(self) -> Iterator[Any]:
+            if not self._cycle_items:
+                return
+            if self._stop is None:
+                while True:
+                    yield from self._cycle_items
+            else:
+                emitted = 0
+                while emitted < self._stop:
+                    for item in self._cycle_items:
+                        if emitted >= self._stop:
+                            return
+                        yield item
+                        emitted += 1
+
+        def __repr__(self) -> str:
+            if self._stop is None:
+                return f"cycle({self._cycle_items!r}, infinite)"
+            return f"cycle({self._cycle_items!r}, {self._stop})"
+
+    return CycleSequence(iterable, n)
+
+
+def collatz(start: int) -> IotaSequence:
+    class CollatzSequence(IotaSequence):
+        def __init__(self, start_val: int) -> None:
+            self._start = 0
+            self._stop = None
+            self._step = 1
+            self._map = None
+            self._collatz_start = start_val
+
+        @property
+        def infinite(self) -> bool:
+            return False
+
+        def __iter__(self) -> Iterator[int]:
+            n = self._collatz_start
+            yield n
+            while n != 1:
+                n = n // 2 if n % 2 == 0 else 3 * n + 1
+                yield n
+
+        def __len__(self) -> int:
+            return sum(1 for _ in self)
+
+        def __repr__(self) -> str:
+            return f"collatz({self._collatz_start})"
+
+    return CollatzSequence(start)
+
+
+def triangle(n: int | None = None) -> IotaSequence:
+    if n is not None:
+        return IotaSequence(n, map=lambda i: i * (i + 1) // 2)
+
+    class TriSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int]:
+            i = 0
+            while True:
+                yield i * (i + 1) // 2
+                i += 1
+
+        def __repr__(self) -> str:
+            return "triangle(infinite)"
+
+    seq = TriSequence.__new__(TriSequence)
+    seq._start = 0
+    seq._stop = None
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def powers(base: int | float, n: int | None = None) -> IotaSequence:
+    if n is not None:
+        return IotaSequence(n, map=lambda i: base ** i)
+
+    class PowerSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int | float]:
+            i = 0
+            while True:
+                yield base ** i
+                i += 1
+
+        def __repr__(self) -> str:
+            return f"powers({base}, infinite)"
+
+    seq = PowerSequence.__new__(PowerSequence)
+    seq._start = 0
+    seq._stop = None
+    seq._step = 1
+    seq._map = None
+    return seq

pythoniota-1.1.0/tests/test_enum_enhanced.py

@@ -0,0 +1,89 @@
+import pytest
+from pythoniota._bitflag import BitFlag
+from pythoniota.enum import IotaEnum, IotaBitFlags
+
+
+class TestBitFlagHasAnyAll:
+    def test_has_any_true(self):
+        combined = BitFlag(7)
+        assert combined.has_any(BitFlag(1), BitFlag(8))
+
+    def test_has_any_false(self):
+        combined = BitFlag(6)
+        assert not combined.has_any(BitFlag(1), BitFlag(8))
+
+    def test_has_all_true(self):
+        combined = BitFlag(7)
+        assert combined.has_all(BitFlag(1), BitFlag(2), BitFlag(4))
+
+    def test_has_all_false(self):
+        combined = BitFlag(3)
+        assert not combined.has_all(BitFlag(1), BitFlag(4))
+
+    def test_has_any_with_int(self):
+        combined = BitFlag(7)
+        assert combined.has_any(1, 8)
+
+    def test_has_all_with_int(self):
+        combined = BitFlag(7)
+        assert combined.has_all(1, 2, 4)
+
+    def test_has_any_with_bitflags_enum(self):
+        class Perm(IotaBitFlags):
+            R = 1 << iota  # noqa: F821
+            W = 1 << iota  # noqa: F821
+            X = 1 << iota  # noqa: F821
+
+        rw = Perm.R | Perm.W
+        assert rw.has_any(Perm.R, Perm.X)
+        assert not rw.has_any(Perm.X)
+
+    def test_has_all_with_bitflags_enum(self):
+        class Perm(IotaBitFlags):
+            R = 1 << iota  # noqa: F821
+            W = 1 << iota  # noqa: F821
+            X = 1 << iota  # noqa: F821
+
+        rwx = Perm.R | Perm.W | Perm.X
+        assert rwx.has_all(Perm.R, Perm.W)
+        assert rwx.has_all(Perm.R, Perm.W, Perm.X)
+
+
+class TestEnumAlias:
+    def test_alias(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+            Blue = iota   # noqa: F821
+
+        Color.alias("R", "Red")
+        Color.alias("G", "Green")
+        assert Color.R == 0
+        assert Color.G == 1
+
+    def test_alias_invalid_target(self):
+        class Color(IotaEnum):
+            Red = iota  # noqa: F821
+
+        with pytest.raises(KeyError, match="not a member"):
+            Color.alias("X", "Purple")
+
+
+class TestAutoDocstring:
+    def test_enum_has_docstring(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        assert Color.__doc__ is not None
+        assert "Red" in Color.__doc__
+        assert "Green" in Color.__doc__
+
+    def test_bitflags_has_docstring(self):
+        class Perm(IotaBitFlags):
+            Read = 1 << iota   # noqa: F821
+            Write = 1 << iota  # noqa: F821
+
+        assert Perm.__doc__ is not None
+        assert "Read" in Perm.__doc__
+        assert "Write" in Perm.__doc__

{pythoniota-1.0.0 → pythoniota-1.1.0}/tests/test_integration.py

@@ -63,4 +63,4 @@ class TestIntegration:
     def test_version_exists(self):
         import pythoniota
         assert hasattr(pythoniota, "__version__")
-        assert pythoniota.__version__ == "1.0.0"
+        assert pythoniota.__version__ == "1.1.0"

pythoniota-1.1.0/tests/test_recipes.py

@@ -0,0 +1,130 @@
+import pytest
+from pythoniota.recipes import (
+    fibonacci, geometric, primes, repeat, cycle, collatz, triangle, powers
+)
+
+
+class TestFibonacci:
+    def test_first_10(self):
+        assert fibonacci(10).take(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+    def test_first_1(self):
+        assert list(fibonacci(1)) == [0]
+
+    def test_empty(self):
+        assert list(fibonacci(0)) == []
+
+    def test_infinite_take(self):
+        assert fibonacci().take(7) == [0, 1, 1, 2, 3, 5, 8]
+
+    def test_repr(self):
+        assert "fibonacci" in repr(fibonacci(5))
+        assert "infinite" in repr(fibonacci())
+
+
+class TestGeometric:
+    def test_basic(self):
+        assert list(geometric(1, 2, 5)) == [1, 2, 4, 8, 16]
+
+    def test_fraction(self):
+        result = list(geometric(100, 0.5, 4))
+        assert result == [100, 50.0, 25.0, 12.5]
+
+    def test_infinite_take(self):
+        assert geometric(1, 3).take(4) == [1, 3, 9, 27]
+
+    def test_repr(self):
+        assert "geometric" in repr(geometric(1, 2, 5))
+
+
+class TestPrimes:
+    def test_first_10(self):
+        assert primes(10).take(10) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
+    def test_first_1(self):
+        assert list(primes(1)) == [2]
+
+    def test_infinite_take(self):
+        assert primes().take(5) == [2, 3, 5, 7, 11]
+
+    def test_repr(self):
+        assert "primes" in repr(primes(5))
+
+
+class TestRepeat:
+    def test_finite(self):
+        assert list(repeat("x", 3)) == ["x", "x", "x"]
+
+    def test_infinite_take(self):
+        assert repeat(42).take(4) == [42, 42, 42, 42]
+
+    def test_empty(self):
+        assert list(repeat("x", 0)) == []
+
+    def test_repr(self):
+        assert "repeat" in repr(repeat(1, 3))
+
+
+class TestCycle:
+    def test_finite(self):
+        assert list(cycle([1, 2, 3], 7)) == [1, 2, 3, 1, 2, 3, 1]
+
+    def test_infinite_take(self):
+        assert cycle(["a", "b"]).take(5) == ["a", "b", "a", "b", "a"]
+
+    def test_empty_iterable(self):
+        assert list(cycle([], 5)) == []
+
+    def test_exact_multiple(self):
+        assert list(cycle([1, 2], 4)) == [1, 2, 1, 2]
+
+    def test_repr(self):
+        assert "cycle" in repr(cycle([1], 3))
+
+
+class TestCollatz:
+    def test_from_6(self):
+        assert list(collatz(6)) == [6, 3, 10, 5, 16, 8, 4, 2, 1]
+
+    def test_from_1(self):
+        assert list(collatz(1)) == [1]
+
+    def test_from_27(self):
+        result = list(collatz(27))
+        assert result[0] == 27
+        assert result[-1] == 1
+        assert len(result) == 112
+
+    def test_len(self):
+        assert len(collatz(6)) == 9
+
+    def test_repr(self):
+        assert "collatz" in repr(collatz(6))
+
+    def test_not_infinite(self):
+        assert collatz(6).infinite is False
+
+
+class TestTriangle:
+    def test_first_6(self):
+        assert list(triangle(6)) == [0, 1, 3, 6, 10, 15]
+
+    def test_infinite_take(self):
+        assert triangle().take(5) == [0, 1, 3, 6, 10]
+
+    def test_repr(self):
+        assert "triangle" in repr(triangle())
+
+
+class TestPowers:
+    def test_powers_of_2(self):
+        assert list(powers(2, 5)) == [1, 2, 4, 8, 16]
+
+    def test_powers_of_3(self):
+        assert list(powers(3, 4)) == [1, 3, 9, 27]
+
+    def test_infinite_take(self):
+        assert powers(2).take(4) == [1, 2, 4, 8]
+
+    def test_repr(self):
+        assert "powers" in repr(powers(2))

pythoniota-1.1.0/tests/test_serialization.py

@@ -0,0 +1,86 @@
+import json
+import pytest
+from pythoniota.enum import IotaEnum, IotaBitFlags
+
+
+class TestEnumSerialization:
+    def test_to_dict(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+            Blue = iota   # noqa: F821
+
+        assert Color.to_dict() == {"Red": 0, "Green": 1, "Blue": 2}
+
+    def test_to_json(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        j = Color.to_json()
+        assert json.loads(j) == {"Red": 0, "Green": 1}
+
+    def test_to_json_indent(self):
+        class X(IotaEnum):
+            A = iota  # noqa: F821
+
+        j = X.to_json(indent=2)
+        assert "\n" in j
+
+    def test_from_dict(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        result = Color.from_dict({"Red": 0})
+        assert result == {"Red": 0}
+
+    def test_from_dict_invalid_key(self):
+        class Color(IotaEnum):
+            Red = iota  # noqa: F821
+
+        with pytest.raises(KeyError, match="not a member"):
+            Color.from_dict({"Purple": 99})
+
+    def test_from_json(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        result = Color.from_json('{"Red": 0, "Green": 1}')
+        assert result == {"Red": 0, "Green": 1}
+
+    def test_roundtrip(self):
+        class Status(IotaEnum):
+            OK = iota       # noqa: F821
+            Error = iota    # noqa: F821
+            Pending = iota  # noqa: F821
+
+        j = Status.to_json()
+        restored = Status.from_json(j)
+        assert restored == Status.to_dict()
+
+
+class TestBitFlagsSerialization:
+    def test_to_dict(self):
+        class Perm(IotaBitFlags):
+            Read = 1 << iota   # noqa: F821
+            Write = 1 << iota  # noqa: F821
+
+        assert Perm.to_dict() == {"Read": 1, "Write": 2}
+
+    def test_to_json(self):
+        class Perm(IotaBitFlags):
+            Read = 1 << iota   # noqa: F821
+            Write = 1 << iota  # noqa: F821
+
+        j = Perm.to_json()
+        assert json.loads(j) == {"Read": 1, "Write": 2}
+
+    def test_from_json(self):
+        class Perm(IotaBitFlags):
+            Read = 1 << iota   # noqa: F821
+            Write = 1 << iota  # noqa: F821
+
+        result = Perm.from_json('{"Read": 1}')
+        assert "Read" in result

pythoniota-1.1.0/tests/test_string_enum.py

@@ -0,0 +1,114 @@
+import pytest
+from pythoniota.enum import IotaStringEnum
+
+
+class TestIotaStringEnum:
+    def test_basic_string_enum(self):
+        class Color(IotaStringEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+            Blue = iota   # noqa: F821
+
+        assert Color.Red == "Red"
+        assert Color.Green == "Green"
+        assert Color.Blue == "Blue"
+
+    def test_custom_format(self):
+        class Color(IotaStringEnum):
+            _format_ = "color_{name}"
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        assert Color.Red == "color_Red"
+        assert Color.Green == "color_Green"
+
+    def test_format_with_index(self):
+        class Code(IotaStringEnum):
+            _format_ = "{name}_{index:03d}"
+            OK = iota       # noqa: F821
+            Error = iota    # noqa: F821
+            Warn = iota     # noqa: F821
+
+        assert Code.OK == "OK_000"
+        assert Code.Error == "Error_001"
+        assert Code.Warn == "Warn_002"
+
+    def test_explicit_string_value(self):
+        class Lang(IotaStringEnum):
+            Python = "py"
+            Rust = "rs"
+
+        assert Lang.Python == "py"
+        assert Lang.Rust == "rs"
+
+    def test_mixed_iota_and_explicit(self):
+        class Mix(IotaStringEnum):
+            Auto = iota    # noqa: F821
+            Manual = "custom_value"
+
+        assert Mix.Auto == "Auto"
+        assert Mix.Manual == "custom_value"
+
+    def test_iteration(self):
+        class Dir(IotaStringEnum):
+            North = iota  # noqa: F821
+            South = iota  # noqa: F821
+
+        items = list(Dir)
+        assert items == [("North", "North"), ("South", "South")]
+
+    def test_names(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert X.names() == ["A", "B"]
+
+    def test_values(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert X.values() == ["A", "B"]
+
+    def test_to_dict(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert X.to_dict() == {"A": "A", "B": "B"}
+
+    def test_to_json(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+
+        import json
+        assert json.loads(X.to_json()) == {"A": "A"}
+
+    def test_from_value(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert X.from_value("A") == "A"
+        assert X.from_value("Z") is None
+
+    def test_immutable(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+
+        with pytest.raises(AttributeError):
+            X.A = "changed"
+
+    def test_contains(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+
+        assert "A" in X
+
+    def test_auto_docstring(self):
+        class X(IotaStringEnum):
+            A = iota  # noqa: F821
+
+        assert X.__doc__ is not None
+        assert "A" in X.__doc__