PythonIota 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

pythoniota/__init__.py

@@ -1,15 +1,23 @@
 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,
+    FlagScope, iota_enum, _EnumMemberProxy,
+)
 from pythoniota.sequence import IotaSequence as iota
+from pythoniota import recipes
 
-__version__ = "1.0.0"
+__version__ = "1.2.0"
 __all__ = [
     "Iota",
     "IotaEnum",
     "IotaBitFlags",
+    "IotaStringEnum",
     "iota",
     "BitFlag",
+    "FlagScope",
+    "iota_enum",
     "safe_eval",
+    "recipes",
 ]

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
@@ -87,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/enum.py

@@ -1,7 +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
 
@@ -124,7 +127,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 +147,54 @@ 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
+        )
+
+        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()):
+                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:
+        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)
 
+        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]]:
@@ -189,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):
 
@@ -201,20 +371,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 +442,99 @@ 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
+
+
+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/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/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.0.0.dist-info → pythoniota-1.2.0.dist-info}/METADATA

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

pythoniota-1.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pythoniota/__init__.py,sha256=nQiMvhfaPQPcl6UyUmxv3aA39vqle0ARK4BwYMBhwlg,524
+pythoniota/_bitflag.py,sha256=EOOwudYcOECBN665TSFMtWIT9l5bT-hrdN0Gr_x_RQk,3692
+pythoniota/_compat.py,sha256=kscV09rl3-1ccU5hm_dGj7EocKSLj0qUmRVUNOTmBwU,2075
+pythoniota/_safe_eval.py,sha256=FJgZxLp5eBDUg1MchVjkHSqnDOM9Jo6mmiupKZ2CvR4,2051
+pythoniota/enum.py,sha256=Spwp_EosBA_ltMdHn3sRjJ-djF5_C8PJ-uKKbzTfd_4,18102
+pythoniota/recipes.py,sha256=5L4iAiUL2tRi6YG7XUQYTl2cUFY20gMP72BoEbf-Leo,6847
+pythoniota/sequence.py,sha256=Ov76UtMuhiVULdfYwb645eSeGuZZN-qEYhUGNFPiYe4,9559
+pythoniota-1.2.0.dist-info/METADATA,sha256=O87uw7fQS2qThEhLYbcipk1VgGffNoNtPlasV_iLYIw,621
+pythoniota-1.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pythoniota-1.2.0.dist-info/top_level.txt,sha256=LoZ35nXIBPHY71-dvmTXyI_g9PBRt8hui5ubG4Huu8c,11
+pythoniota-1.2.0.dist-info/RECORD,,

pythoniota-1.0.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-pythoniota/__init__.py,sha256=fO2WT2un6fpIg3h5qdB0fck4wP2zg48D3ej1dzyi1_0,353
-pythoniota/_bitflag.py,sha256=9gHyG-yFD-Z5Va9GclBaqKZzELfGx5m5aX5MUtpPQWk,2773
-pythoniota/_compat.py,sha256=kscV09rl3-1ccU5hm_dGj7EocKSLj0qUmRVUNOTmBwU,2075
-pythoniota/_safe_eval.py,sha256=FJgZxLp5eBDUg1MchVjkHSqnDOM9Jo6mmiupKZ2CvR4,2051
-pythoniota/enum.py,sha256=PzIJGNMDDoY1mxEhHIC8b8Nca_0_DJ0X7wV_l-3aLlE,7396
-pythoniota/sequence.py,sha256=7PtxrOcBAOAFtTwwSJwtI_h0vYROZyd3JNKfuF20PSA,5686
-pythoniota-1.0.0.dist-info/METADATA,sha256=ykPzwek9rW-7wL4V5JHMFpHntuPojw6nFGyWL5MXXF4,621
-pythoniota-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pythoniota-1.0.0.dist-info/top_level.txt,sha256=LoZ35nXIBPHY71-dvmTXyI_g9PBRt8hui5ubG4Huu8c,11
-pythoniota-1.0.0.dist-info/RECORD,,