PythonIota 1.1.0__tar.gz → 1.2.0__tar.gz

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

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

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

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

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

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

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

@@ -10,6 +10,7 @@ src/pythoniota/_safe_eval.py
 src/pythoniota/enum.py
 src/pythoniota/recipes.py
 src/pythoniota/sequence.py
+tests/test_advanced.py
 tests/test_bitflags.py
 tests/test_compat.py
 tests/test_enum.py

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

@@ -1,11 +1,14 @@
 from pythoniota._compat import Iota
 from pythoniota._bitflag import BitFlag
 from pythoniota._safe_eval import safe_eval
-from pythoniota.enum import IotaEnum, IotaBitFlags, IotaStringEnum
+from pythoniota.enum import (
+    IotaEnum, IotaBitFlags, IotaStringEnum,
+    FlagScope, iota_enum, _EnumMemberProxy,
+)
 from pythoniota.sequence import IotaSequence as iota
 from pythoniota import recipes
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 __all__ = [
     "Iota",
     "IotaEnum",
@@ -13,6 +16,8 @@ __all__ = [
     "IotaStringEnum",
     "iota",
     "BitFlag",
+    "FlagScope",
+    "iota_enum",
     "safe_eval",
     "recipes",
 ]

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

@@ -101,5 +101,19 @@ class BitFlag:
     def __str__(self) -> str:
         return self._name or str(self._value)
 
+    def __format__(self, format_spec: str) -> str:
+        if not format_spec:
+            return self._name or str(self._value)
+        if format_spec == "v":
+            return str(self._value)
+        if format_spec == "n":
+            return self._name
+        if format_spec == "b":
+            return bin(self._value)
+        return format(self._value, format_spec)
+
+    def __reduce__(self) -> tuple:
+        return (BitFlag, (self._value, self._name))
+
     def __iter__(self) -> Iterator[BitFlag]:
         return iter(self.decompose())

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

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import json
+import pickle
 from collections import OrderedDict
-from typing import Any, Iterator
+from contextlib import contextmanager
+from typing import Any, Callable, Iterator
 
 from pythoniota._bitflag import BitFlag
 
@@ -161,6 +163,10 @@ class IotaEnumMeta(type):
             hasattr(b, "_is_string_enum_base") for b in bases
         )
 
+        is_ordered = namespace.get("_ordered_", False) or any(
+            getattr(b, "_ordered_", False) for b in bases
+        )
+
         if is_string_enum:
             fmt = namespace.get("_format_", None)
             for mname, mval in list(members.items()):
@@ -175,6 +181,11 @@ class IotaEnumMeta(type):
                 flag = BitFlag(int(mval), mname)
                 members[mname] = flag
                 type.__setattr__(cls, mname, flag)
+        elif is_ordered:
+            for order, (mname, mval) in builtins_enumerate(members.items()):
+                proxy = _EnumMemberProxy(mname, mval, cls, order)
+                members[mname] = proxy
+                type.__setattr__(cls, mname, proxy)
         else:
             for mname, mval in members.items():
                 type.__setattr__(cls, mname, mval)
@@ -210,10 +221,148 @@ class IotaEnumMeta(type):
             raise AttributeError(f"Cannot delete enum member '{name}'")
         super().__delattr__(name)
 
+    def __call__(cls, value: Any) -> Any:
+        for name, val in cls._members_.items():  # type: ignore[attr-defined]
+            cmp_val = int(val) if isinstance(val, BitFlag) else val
+            if cmp_val == value:
+                return val
+        raise ValueError(f"{value!r} is not a valid value in {cls.__name__}")
+
     def __repr__(cls) -> str:
         items = ", ".join(f"{k}={v}" for k, v in cls._members_.items())  # type: ignore[attr-defined]
         return f"<{cls.__name__}: {items}>"
 
+    def __reduce__(cls) -> tuple[Any, ...]:
+        return (cls.__class__, (cls.__name__, cls.__bases__, dict(cls._members_)))  # type: ignore[attr-defined]
+
+
+class _EnumMemberProxy:
+    """Wraps an enum member value to support ordered comparison within the same enum."""
+
+    __slots__ = ("_name", "_value", "_enum_cls", "_order")
+
+    def __init__(self, name: str, value: Any, enum_cls: type, order: int) -> None:
+        object.__setattr__(self, "_name", name)
+        object.__setattr__(self, "_value", value)
+        object.__setattr__(self, "_enum_cls", enum_cls)
+        object.__setattr__(self, "_order", order)
+
+    def __int__(self) -> int:
+        return int(self._value)
+
+    def __index__(self) -> int:
+        return int(self._value)
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, _EnumMemberProxy):
+            return self._value == other._value
+        return self._value == other
+
+    def __ne__(self, other: Any) -> bool:
+        return not self.__eq__(other)
+
+    def __lt__(self, other: Any) -> bool:
+        if isinstance(other, _EnumMemberProxy):
+            if self._enum_cls is not other._enum_cls:
+                raise TypeError(f"'<' not supported between members of '{self._enum_cls.__name__}' and '{other._enum_cls.__name__}'")
+            return self._order < other._order
+        return NotImplemented
+
+    def __le__(self, other: Any) -> bool:
+        if isinstance(other, _EnumMemberProxy):
+            if self._enum_cls is not other._enum_cls:
+                raise TypeError(f"'<=' not supported between members of '{self._enum_cls.__name__}' and '{other._enum_cls.__name__}'")
+            return self._order <= other._order
+        return NotImplemented
+
+    def __gt__(self, other: Any) -> bool:
+        if isinstance(other, _EnumMemberProxy):
+            if self._enum_cls is not other._enum_cls:
+                raise TypeError(f"'>' not supported between members of '{self._enum_cls.__name__}' and '{other._enum_cls.__name__}'")
+            return self._order > other._order
+        return NotImplemented
+
+    def __ge__(self, other: Any) -> bool:
+        if isinstance(other, _EnumMemberProxy):
+            if self._enum_cls is not other._enum_cls:
+                raise TypeError(f"'>=' not supported between members of '{self._enum_cls.__name__}' and '{other._enum_cls.__name__}'")
+            return self._order >= other._order
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash((self._enum_cls, self._value))
+
+    def __repr__(self) -> str:
+        return f"{self._enum_cls.__name__}.{self._name}"
+
+    def __str__(self) -> str:
+        return self._name
+
+    def __format__(self, format_spec: str) -> str:
+        if not format_spec:
+            return self._name
+        if format_spec == "v":
+            return str(self._value)
+        if format_spec == "n":
+            return self._name
+        if format_spec == "r":
+            return repr(self)
+        if format_spec == "nv":
+            return f"{self._name}={self._value}"
+        return format(self._value, format_spec)
+
+    def __bool__(self) -> bool:
+        return True
+
+    def __add__(self, other: Any) -> Any:
+        return self._value + (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __radd__(self, other: Any) -> Any:
+        return other + self._value
+
+    def __sub__(self, other: Any) -> Any:
+        return self._value - (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __rsub__(self, other: Any) -> Any:
+        return other - self._value
+
+    def __mul__(self, other: Any) -> Any:
+        return self._value * (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __rmul__(self, other: Any) -> Any:
+        return other * self._value
+
+    def __or__(self, other: Any) -> Any:
+        return self._value | (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __ror__(self, other: Any) -> Any:
+        return other | self._value
+
+    def __and__(self, other: Any) -> Any:
+        return self._value & (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __rand__(self, other: Any) -> Any:
+        return other & self._value
+
+    def __lshift__(self, other: Any) -> Any:
+        return self._value << (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __rlshift__(self, other: Any) -> Any:
+        return other << self._value
+
+    def __rshift__(self, other: Any) -> Any:
+        return self._value >> (other._value if isinstance(other, _EnumMemberProxy) else other)
+
+    def __rrshift__(self, other: Any) -> Any:
+        return other >> self._value
+
+    def __reduce__(self) -> tuple[Any, ...]:
+        return (_restore_member, (self._enum_cls, self._name))
+
+
+def _restore_member(cls: type, name: str) -> Any:
+    return getattr(cls, name)
+
 
 class IotaEnum(metaclass=IotaEnumMeta):
 
@@ -319,3 +468,73 @@ class IotaBitFlags(metaclass=IotaEnumMeta):
 
 class IotaStringEnum(IotaEnum):
     _is_string_enum_base = True
+
+
+class FlagScope:
+    """Context manager for scoped bitflag operations."""
+
+    def __init__(self, initial: BitFlag | int = 0) -> None:
+        self._flags = initial if isinstance(initial, BitFlag) else BitFlag(initial)
+
+    @property
+    def flags(self) -> BitFlag:
+        return self._flags
+
+    def grant(self, *flags: BitFlag | int) -> None:
+        for f in flags:
+            self._flags = self._flags | f
+
+    def revoke(self, *flags: BitFlag | int) -> None:
+        for f in flags:
+            fv = int(f)
+            self._flags = BitFlag(int(self._flags) & ~fv)
+
+    def has(self, flag: BitFlag | int) -> bool:
+        return self._flags.has(flag)
+
+    def __enter__(self) -> FlagScope:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        pass
+
+    def __repr__(self) -> str:
+        return f"FlagScope({self._flags})"
+
+
+def iota_enum(cls: type | None = None, *, ordered: bool = False) -> Any:
+    """Decorator to convert a plain class into an IotaEnum.
+
+    Usage:
+        @iota_enum
+        class Color:
+            Red = 0
+            Green = 1
+            Blue = 2
+
+        @iota_enum(ordered=True)
+        class Priority:
+            Low = 0
+            Medium = 1
+            High = 2
+    """
+    def _wrap(klass: type) -> IotaEnumMeta:
+        ns = IotaNamespace()
+        if ordered:
+            ns["_ordered_"] = True
+        for key, val in vars(klass).items():
+            if key.startswith("_"):
+                continue
+            if callable(val) and not isinstance(val, (int, float, str)):
+                continue
+            ns[key] = val
+            ns._member_names.append(key)
+        return IotaEnumMeta(klass.__name__, (IotaEnum,), ns)
+
+    if cls is not None:
+        return _wrap(cls)
+    return _wrap
+
+
+import builtins
+builtins_enumerate = builtins.enumerate

{pythoniota-1.1.0 → pythoniota-1.2.0}/src/pythoniota/sequence.py

@@ -149,6 +149,25 @@ class IotaSequence:
             return _reduce(fn, iter(self), initial)
         return _reduce(fn, iter(self))
 
+    def __add__(self, other: IotaSequence) -> _ConcatSequence:
+        return _ConcatSequence(self, other)
+
+    def __mul__(self, n: int) -> _RepeatSequence:
+        return _RepeatSequence(self, n)
+
+    def __rmul__(self, n: int) -> _RepeatSequence:
+        return _RepeatSequence(self, n)
+
+    def __or__(self, other: IotaSequence) -> _InterleaveSequence:
+        return _InterleaveSequence(self, other)
+
+    def __matmul__(self, other: IotaSequence) -> _ZipMapSequence:
+        return _ZipMapSequence(self, other)
+
+    async def __aiter__(self):  # type: ignore[override]
+        for item in self:
+            yield item
+
     def __repr__(self) -> str:
         parts = []
         if self._start != 0:
@@ -164,6 +183,125 @@ class IotaSequence:
         return f"iota({', '.join(parts)})"
 
 
+class _ConcatSequence(IotaSequence):
+    def __init__(self, a: IotaSequence, b: IotaSequence) -> None:
+        self._a = a
+        self._b = b
+        self._start = 0
+        self._stop = None if (a.infinite or b.infinite) else (len(a) + len(b))
+        self._step = 1
+        self._map = None
+
+    @property
+    def infinite(self) -> bool:
+        return self._a.infinite or self._b.infinite
+
+    def __iter__(self) -> Iterator[Any]:
+        yield from self._a
+        yield from self._b
+
+    def __repr__(self) -> str:
+        return f"({self._a!r} + {self._b!r})"
+
+
+class _RepeatSequence(IotaSequence):
+    def __init__(self, seq: IotaSequence, n: int) -> None:
+        self._seq = seq
+        self._n = n
+        self._start = 0
+        self._stop = None if seq.infinite else len(seq) * n
+        self._step = 1
+        self._map = None
+
+    @property
+    def infinite(self) -> bool:
+        return self._seq.infinite
+
+    def __iter__(self) -> Iterator[Any]:
+        for _ in range(self._n):
+            yield from self._seq
+
+    def __repr__(self) -> str:
+        return f"({self._seq!r} * {self._n})"
+
+
+class _InterleaveSequence(IotaSequence):
+    def __init__(self, a: IotaSequence, b: IotaSequence) -> None:
+        self._a = a
+        self._b = b
+        self._start = 0
+        self._step = 1
+        self._map = None
+        if a.infinite or b.infinite:
+            self._stop = None
+        else:
+            self._stop = len(a) + len(b)
+
+    @property
+    def infinite(self) -> bool:
+        return self._a.infinite or self._b.infinite
+
+    def __iter__(self) -> Iterator[Any]:
+        it_a = iter(self._a)
+        it_b = iter(self._b)
+        while True:
+            exhausted = 0
+            try:
+                yield next(it_a)
+            except StopIteration:
+                exhausted += 1
+            try:
+                yield next(it_b)
+            except StopIteration:
+                exhausted += 1
+            if exhausted == 2:
+                break
+
+    def __len__(self) -> int:
+        if self.infinite:
+            raise TypeError("infinite sequence has no len()")
+        return len(self._a) + len(self._b)
+
+    def __repr__(self) -> str:
+        return f"({self._a!r} | {self._b!r})"
+
+
+class _ZipMapSequence(IotaSequence):
+    def __init__(self, a: IotaSequence, b: IotaSequence) -> None:
+        self._a = a
+        self._b = b
+        self._start = 0
+        self._step = 1
+        self._map = None
+        if a.infinite and b.infinite:
+            self._stop = None
+        elif a.infinite:
+            self._stop = len(b)
+        elif b.infinite:
+            self._stop = len(a)
+        else:
+            self._stop = min(len(a), len(b))
+
+    @property
+    def infinite(self) -> bool:
+        return self._a.infinite and self._b.infinite
+
+    def __iter__(self) -> Iterator[tuple[Any, Any]]:
+        yield from builtins_zip(self._a, self._b)
+
+    def __len__(self) -> int:
+        if self.infinite:
+            raise TypeError("infinite sequence has no len()")
+        if self._a.infinite:
+            return len(self._b)
+        if self._b.infinite:
+            return len(self._a)
+        return min(len(self._a), len(self._b))
+
+    def __repr__(self) -> str:
+        return f"({self._a!r} @ {self._b!r})"
+
+
 import builtins
 
 builtins_map = builtins.map

pythoniota-1.2.0/tests/test_advanced.py

@@ -0,0 +1,377 @@
+import asyncio
+import pickle
+import pytest
+from pythoniota import (
+    IotaEnum, IotaBitFlags, IotaStringEnum,
+    FlagScope, iota_enum, iota, BitFlag,
+)
+from pythoniota.enum import _EnumMemberProxy
+
+
+# ── Enum callable: Color(0) → member ──
+
+class TestEnumCallable:
+    def test_call_by_value(self):
+        class Color(IotaEnum):
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        assert Color(0) == 0
+        assert Color(1) == 1
+
+    def test_call_invalid(self):
+        class Color(IotaEnum):
+            Red = iota  # noqa: F821
+
+        with pytest.raises(ValueError, match="not a valid"):
+            Color(99)
+
+    def test_call_bitflags(self):
+        class Perm(IotaBitFlags):
+            R = 1 << iota  # noqa: F821
+            W = 1 << iota  # noqa: F821
+
+        result = Perm(1)
+        assert isinstance(result, BitFlag)
+        assert result.value == 1
+
+
+# ── Ordered comparison: < > <= >= with type safety ──
+
+class TestOrderedEnum:
+    def test_less_than(self):
+        class Priority(IotaEnum):
+            _ordered_ = True
+            Low = iota     # noqa: F821
+            Medium = iota  # noqa: F821
+            High = iota    # noqa: F821
+
+        assert Priority.Low < Priority.Medium
+        assert Priority.Medium < Priority.High
+        assert not (Priority.High < Priority.Low)
+
+    def test_greater_than(self):
+        class Priority(IotaEnum):
+            _ordered_ = True
+            Low = iota     # noqa: F821
+            Medium = iota  # noqa: F821
+            High = iota    # noqa: F821
+
+        assert Priority.High > Priority.Low
+        assert not (Priority.Low > Priority.High)
+
+    def test_le_ge(self):
+        class P(IotaEnum):
+            _ordered_ = True
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert P.A <= P.A
+        assert P.A <= P.B
+        assert P.B >= P.A
+        assert P.B >= P.B
+
+    def test_cross_enum_comparison_raises(self):
+        class A(IotaEnum):
+            _ordered_ = True
+            X = iota  # noqa: F821
+
+        class B(IotaEnum):
+            _ordered_ = True
+            X = iota  # noqa: F821
+
+        with pytest.raises(TypeError, match="not supported between"):
+            A.X < B.X  # noqa: B015
+
+    def test_ordered_equality(self):
+        class P(IotaEnum):
+            _ordered_ = True
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert P.A == P.A
+        assert P.A != P.B
+
+    def test_ordered_int_comparison(self):
+        class P(IotaEnum):
+            _ordered_ = True
+            A = iota  # noqa: F821
+
+        assert P.A == 0
+
+    def test_ordered_hash(self):
+        class P(IotaEnum):
+            _ordered_ = True
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        s = {P.A, P.B, P.A}
+        assert len(s) == 2
+
+    def test_ordered_repr(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert repr(Color.Red) == "Color.Red"
+
+    def test_ordered_str(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert str(Color.Red) == "Red"
+
+    def test_ordered_arithmetic(self):
+        class P(IotaEnum):
+            _ordered_ = True
+            A = iota  # noqa: F821
+            B = iota  # noqa: F821
+
+        assert P.A + P.B == 1
+        assert P.B - P.A == 1
+        assert P.B * 3 == 3
+        assert 10 + P.A == 10
+
+
+# ── __format__ protocol ──
+
+class TestFormat:
+    def test_format_default(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert f"{Color.Red}" == "Red"
+
+    def test_format_v(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert f"{Color.Red:v}" == "0"
+
+    def test_format_n(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert f"{Color.Red:n}" == "Red"
+
+    def test_format_r(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert f"{Color.Red:r}" == "Color.Red"
+
+    def test_format_nv(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota  # noqa: F821
+
+        assert f"{Color.Red:nv}" == "Red=0"
+
+    def test_format_numeric(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota   # noqa: F821
+            Blue = iota  # noqa: F821
+
+        assert f"{Color.Blue:03d}" == "001"
+
+    def test_bitflag_format(self):
+        f = BitFlag(4, "Exec")
+        assert f"{f}" == "Exec"
+        assert f"{f!r}" == "BitFlag(Exec=4)"
+
+
+# ── Pickle support ──
+
+class TestPickle:
+    def test_pickle_ordered_member(self):
+        class Color(IotaEnum):
+            _ordered_ = True
+            Red = iota    # noqa: F821
+            Green = iota  # noqa: F821
+
+        # _EnumMemberProxy.__reduce__ uses _restore_member which needs
+        # the class to be importable. For test purposes, verify __reduce__ returns valid tuple.
+        r = Color.Red.__reduce__()
+        assert len(r) == 2
+        fn, args = r
+        assert args[1] == "Red"
+
+    def test_pickle_bitflag(self):
+        f = BitFlag(4, "Exec")
+        data = pickle.dumps(f)
+        restored = pickle.loads(data)
+        assert restored.value == 4
+        assert restored.name == "Exec"
+
+
+# ── Decorator API ──
+
+class TestIotaEnumDecorator:
+    def test_basic_decorator(self):
+        @iota_enum
+        class Color:
+            Red = 0
+            Green = 1
+            Blue = 2
+
+        assert Color.Red == 0
+        assert Color.Green == 1
+        assert Color.Blue == 2
+        assert Color.names() == ["Red", "Green", "Blue"]
+
+    def test_decorator_with_ordered(self):
+        @iota_enum(ordered=True)
+        class Priority:
+            Low = 0
+            Medium = 1
+            High = 2
+
+        assert Priority.Low < Priority.Medium
+        assert Priority.High > Priority.Low
+
+    def test_decorator_iteration(self):
+        @iota_enum
+        class Dir:
+            N = 0
+            S = 1
+            E = 2
+            W = 3
+
+        assert len(Dir) == 4
+        assert list(Dir) == [("N", 0), ("S", 1), ("E", 2), ("W", 3)]
+
+    def test_decorator_to_dict(self):
+        @iota_enum
+        class X:
+            A = 10
+            B = 20
+
+        assert X.to_dict() == {"A": 10, "B": 20}
+
+
+# ── FlagScope context manager ──
+
+class TestFlagScope:
+    def test_basic_scope(self):
+        R = BitFlag(1, "R")
+        W = BitFlag(2, "W")
+        X = BitFlag(4, "X")
+
+        with FlagScope() as scope:
+            scope.grant(R, W)
+            assert scope.has(R)
+            assert scope.has(W)
+            assert not scope.has(X)
+
+    def test_revoke(self):
+        R = BitFlag(1, "R")
+        W = BitFlag(2, "W")
+
+        with FlagScope() as scope:
+            scope.grant(R, W)
+            scope.revoke(W)
+            assert scope.has(R)
+            assert not scope.has(W)
+
+    def test_initial_flags(self):
+        R = BitFlag(1, "R")
+        W = BitFlag(2, "W")
+
+        with FlagScope(R | W) as scope:
+            assert scope.has(R)
+            assert scope.has(W)
+
+    def test_repr(self):
+        with FlagScope() as scope:
+            assert "FlagScope" in repr(scope)
+
+    def test_with_bitflags_enum(self):
+        class Perm(IotaBitFlags):
+            R = 1 << iota  # noqa: F821
+            W = 1 << iota  # noqa: F821
+            X = 1 << iota  # noqa: F821
+
+        with FlagScope() as scope:
+            scope.grant(Perm.R, Perm.W)
+            assert scope.has(Perm.R)
+            assert not scope.has(Perm.X)
+            scope.grant(Perm.X)
+            assert scope.has(Perm.X)
+
+
+# ── Sequence algebra ──
+
+class TestSequenceAlgebra:
+    def test_concat(self):
+        a = iota(3)
+        b = iota(3, 6)
+        result = list(a + b)
+        assert result == [0, 1, 2, 3, 4, 5]
+
+    def test_concat_repr(self):
+        r = repr(iota(3) + iota(3))
+        assert "+" in r
+
+    def test_repeat(self):
+        result = list(iota(3) * 2)
+        assert result == [0, 1, 2, 0, 1, 2]
+
+    def test_rmul(self):
+        result = list(2 * iota(3))
+        assert result == [0, 1, 2, 0, 1, 2]
+
+    def test_interleave(self):
+        a = iota(3)
+        b = iota(10, 13)
+        result = list(a | b)
+        assert result == [0, 10, 1, 11, 2, 12]
+
+    def test_interleave_unequal(self):
+        a = iota(2)
+        b = iota(10, 14)
+        result = list(a | b)
+        assert result == [0, 10, 1, 11, 12, 13]
+
+    def test_zipmap(self):
+        a = iota(3)
+        b = iota(10, 13)
+        result = list(a @ b)
+        assert result == [(0, 10), (1, 11), (2, 12)]
+
+    def test_chain_algebra(self):
+        result = list((iota(2) + iota(2)) * 2)
+        assert result == [0, 1, 0, 1, 0, 1, 0, 1]
+
+    def test_concat_len(self):
+        s = iota(3) + iota(4)
+        assert len(s) == 7
+
+
+# ── Async iteration ──
+
+class TestAsyncIter:
+    def test_async_iter(self):
+        async def collect():
+            result = []
+            async for x in iota(5):
+                result.append(x)
+            return result
+
+        result = asyncio.run(collect())
+        assert result == [0, 1, 2, 3, 4]
+
+    def test_async_iter_mapped(self):
+        async def collect():
+            result = []
+            async for x in iota(4, map=lambda i: i * 10):
+                result.append(x)
+            return result
+
+        result = asyncio.run(collect())
+        assert result == [0, 10, 20, 30]

{pythoniota-1.1.0 → pythoniota-1.2.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.1.0"
+        assert pythoniota.__version__ == "1.2.0"