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

pythoniota/__init__.py

@@ -3,12 +3,12 @@ from pythoniota._bitflag import BitFlag
 from pythoniota._safe_eval import safe_eval
 from pythoniota.enum import (
     IotaEnum, IotaBitFlags, IotaStringEnum,
-    FlagScope, iota_enum, _EnumMemberProxy,
+    FlagScope, iota_enum, unique, _EnumMemberProxy,
 )
 from pythoniota.sequence import IotaSequence as iota
 from pythoniota import recipes
 
-__version__ = "1.2.0"
+__version__ = "1.3.0"
 __all__ = [
     "Iota",
     "IotaEnum",
@@ -18,6 +18,7 @@ __all__ = [
     "BitFlag",
     "FlagScope",
     "iota_enum",
+    "unique",
     "safe_eval",
     "recipes",
 ]

pythoniota/enum.py

@@ -113,20 +113,32 @@ class IotaNamespace(dict):  # type: ignore[type-arg]
     def __init__(self) -> None:
         super().__init__()
         self._counter = 0
+        self._step = 1
         self._member_names: list[str] = []
 
+    def _skip(self, n: int = 1) -> None:
+        """Advance the iota counter by `n` steps without defining a member (Go's blank `_`)."""
+        self._counter += n * self._step
+        return None
+
     def __getitem__(self, key: str) -> Any:
         if key == "iota":
             val = _IotaCounter(self._counter)
-            self._counter += 1
+            self._counter += self._step
             return val
+        if key == "skip":
+            return self._skip
         return super().__getitem__(key)
 
     def __setitem__(self, key: str, value: Any) -> None:
+        if key == "_iota_start_":
+            self._counter = int(value)
+        elif key == "_iota_step_":
+            self._step = int(value)
         super().__setitem__(key, value)
         if (
             not key.startswith("_")
-            and key != "iota"
+            and key not in ("iota", "skip")
             and isinstance(value, (int, float, str, _IotaCounter))
         ):
             if key not in self._member_names:
@@ -182,7 +194,7 @@ class IotaEnumMeta(type):
                 members[mname] = flag
                 type.__setattr__(cls, mname, flag)
         elif is_ordered:
-            for order, (mname, mval) in builtins_enumerate(members.items()):
+            for order, (mname, mval) in enumerate(members.items()):
                 proxy = _EnumMemberProxy(mname, mval, cls, order)
                 members[mname] = proxy
                 type.__setattr__(cls, mname, proxy)
@@ -388,6 +400,14 @@ class IotaEnum(metaclass=IotaEnumMeta):
                 return alias
         return None
 
+    @classmethod
+    def has(cls, name: str) -> bool:
+        return name in cls._members_  # type: ignore[attr-defined]
+
+    @classmethod
+    def get(cls, name: str, default: Any = None) -> Any:
+        return cls._members_.get(name, default)  # type: ignore[attr-defined]
+
     @classmethod
     def alias(cls, alias_name: str, target_name: str) -> None:
         if target_name not in cls._members_:  # type: ignore[attr-defined]
@@ -397,13 +417,21 @@ class IotaEnum(metaclass=IotaEnumMeta):
 
     @classmethod
     def to_dict(cls) -> dict[str, Any]:
-        return dict(cls._members_)  # type: ignore[attr-defined]
+        d = {}
+        for k, v in cls._members_.items():  # type: ignore[attr-defined]
+            d[k] = v._value if isinstance(v, _EnumMemberProxy) else v
+        return d
 
     @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
+            if isinstance(v, _EnumMemberProxy):
+                d[k] = v._value
+            elif isinstance(v, BitFlag):
+                d[k] = int(v)
+            else:
+                d[k] = v
         return json.dumps(d, **kwargs)
 
     @classmethod
@@ -443,6 +471,14 @@ class IotaBitFlags(metaclass=IotaEnumMeta):
                 return name
         return None
 
+    @classmethod
+    def has(cls, name: str) -> bool:
+        return name in cls._members_  # type: ignore[attr-defined]
+
+    @classmethod
+    def get(cls, name: str, default: Any = None) -> Any:
+        return cls._members_.get(name, default)  # type: ignore[attr-defined]
+
     @classmethod
     def to_dict(cls) -> dict[str, int]:
         return {k: int(v) for k, v in cls._members_.items()}  # type: ignore[attr-defined]
@@ -536,5 +572,22 @@ def iota_enum(cls: type | None = None, *, ordered: bool = False) -> Any:
     return _wrap
 
 
-import builtins
-builtins_enumerate = builtins.enumerate
+def _member_value(val: Any) -> Any:
+    if isinstance(val, _EnumMemberProxy):
+        return val._value
+    if isinstance(val, BitFlag):
+        return int(val)
+    return val
+
+
+def unique(cls: type) -> type:
+    """Class decorator that rejects an enum with duplicate member values."""
+    seen: dict[Any, str] = {}
+    for name, val in cls._members_.items():  # type: ignore[attr-defined]
+        v = _member_value(val)
+        if v in seen:
+            raise ValueError(
+                f"duplicate value {v!r} in {cls.__name__}: {seen[v]} and {name}"
+            )
+        seen[v] = name
+    return cls

pythoniota/recipes.py

@@ -234,3 +234,140 @@ def powers(base: int | float, n: int | None = None) -> IotaSequence:
     seq._step = 1
     seq._map = None
     return seq
+
+
+def factorial(n: int | None = None) -> IotaSequence:
+    class FactorialSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int]:
+            f = 1
+            i = 0
+            while self._stop is None or i < self._stop:
+                yield f
+                i += 1
+                f *= i
+
+        def __repr__(self) -> str:
+            return "factorial(infinite)" if self._stop is None else f"factorial({self._stop})"
+
+    seq = FactorialSequence.__new__(FactorialSequence)
+    seq._start = 0
+    seq._stop = n
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def catalan(n: int | None = None) -> IotaSequence:
+    class CatalanSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int]:
+            c = 1
+            k = 0
+            while self._stop is None or k < self._stop:
+                yield c
+                c = c * 2 * (2 * k + 1) // (k + 2)
+                k += 1
+
+        def __repr__(self) -> str:
+            return "catalan(infinite)" if self._stop is None else f"catalan({self._stop})"
+
+    seq = CatalanSequence.__new__(CatalanSequence)
+    seq._start = 0
+    seq._stop = n
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def lucas(n: int | None = None) -> IotaSequence:
+    class LucasSequence(IotaSequence):
+        def __iter__(self) -> Iterator[int]:
+            a, b = 2, 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:
+            return "lucas(infinite)" if self._stop is None else f"lucas({self._stop})"
+
+    seq = LucasSequence.__new__(LucasSequence)
+    seq._start = 0
+    seq._stop = n
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def harmonic(n: int | None = None) -> IotaSequence:
+    """Harmonic numbers H_k = sum(1/i for i in 1..k), yielded as floats starting at H_1."""
+
+    class HarmonicSequence(IotaSequence):
+        def __iter__(self) -> Iterator[float]:
+            total = 0.0
+            k = 1
+            while self._stop is None or k <= self._stop:
+                total += 1.0 / k
+                yield total
+                k += 1
+
+        def __repr__(self) -> str:
+            return "harmonic(infinite)" if self._stop is None else f"harmonic({self._stop})"
+
+    seq = HarmonicSequence.__new__(HarmonicSequence)
+    seq._start = 0
+    seq._stop = n
+    seq._step = 1
+    seq._map = None
+    return seq
+
+
+def pascal_row(row: int) -> IotaSequence:
+    """The `row`-th row of Pascal's triangle: C(row, 0), C(row, 1), ..., C(row, row)."""
+    if row < 0:
+        raise ValueError("row must be non-negative")
+    return IotaSequence(row + 1, map=lambda k: math.comb(row, k))
+
+
+def primes_sieve(limit: int) -> IotaSequence:
+    """All primes strictly less than `limit`, via the Sieve of Eratosthenes."""
+
+    class PrimesSieveSequence(IotaSequence):
+        def __init__(self, lim: int) -> None:
+            self._start = 0
+            self._stop = None
+            self._step = 1
+            self._map = None
+            self._limit = lim
+
+        @property
+        def infinite(self) -> bool:
+            return False
+
+        def __iter__(self) -> Iterator[int]:
+            lim = self._limit
+            if lim < 3:
+                return
+            sieve = bytearray([1]) * lim
+            sieve[0] = sieve[1] = 0
+            p = 2
+            while p * p < lim:
+                if sieve[p]:
+                    sieve[p * p : lim : p] = bytearray(len(range(p * p, lim, p)))
+                p += 1
+            for i in range(2, lim):
+                if sieve[i]:
+                    yield i
+
+        def __len__(self) -> int:
+            return sum(1 for _ in self)
+
+        def __repr__(self) -> str:
+            return f"primes_sieve({self._limit})"
+
+    return PrimesSieveSequence(limit)

pythoniota/sequence.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import itertools
-import math
 from collections import deque
 from functools import reduce as _reduce
 from typing import Any, Callable, Iterator, TypeVar, overload
 
 T = TypeVar("T")
 
+_MISSING: Any = object()
+
 
 class IotaSequence:
 
@@ -66,14 +67,15 @@ class IotaSequence:
     def __iter__(self) -> Iterator[Any]:
         it = self._raw_iter()
         if self._map is not None:
-            return builtins_map(self._map, it)
+            return map(self._map, it)
         return it
 
     def __len__(self) -> int:
         if self.infinite:
             raise TypeError("infinite sequence has no len()")
         assert self._stop is not None
-        n = math.ceil((self._stop - self._start) / self._step)
+        adjust = 1 if self._step > 0 else -1
+        n = (self._stop - self._start + self._step - adjust) // self._step
         return max(0, n)
 
     def __getitem__(self, index: int | slice) -> Any:
@@ -84,18 +86,42 @@ class IotaSequence:
             if self.infinite:
                 raise IndexError("negative indexing not supported on infinite sequences")
             index = len(self) + index
+        if type(self) is IotaSequence:
+            if index < 0 or (not self.infinite and index >= self.__len__()):
+                raise IndexError("iota index out of range")
+            raw = self._start + index * self._step
+            return self._map(raw) if self._map is not None else raw
         return next(itertools.islice(iter(self), index, index + 1))
 
     def __contains__(self, value: Any) -> bool:
         if self.infinite:
             raise TypeError("cannot check membership on infinite sequence")
+        if (
+            type(self) is IotaSequence
+            and self._map is None
+            and isinstance(value, int)
+            and not isinstance(value, bool)
+        ):
+            assert self._stop is not None
+            if self._step > 0:
+                in_range = self._start <= value < self._stop
+            else:
+                in_range = self._stop < value <= self._start
+            return in_range and (value - self._start) % self._step == 0
         return value in iter(self)
 
     def __reversed__(self) -> Iterator[Any]:
         if self.infinite:
             raise TypeError("cannot reverse infinite sequence")
+        if type(self) is IotaSequence:
+            return self._reversed_arith()
         return reversed(list(self))
 
+    def _reversed_arith(self) -> Iterator[Any]:
+        for i in range(self.__len__() - 1, -1, -1):
+            raw = self._start + i * self._step
+            yield self._map(raw) if self._map is not None else raw
+
     def take(self, n: int) -> list[Any]:
         return list(itertools.islice(iter(self), n))
 
@@ -113,16 +139,16 @@ class IotaSequence:
         return seq
 
     def filter(self, fn: Callable[[Any], bool]) -> Iterator[Any]:
-        return builtins_filter(fn, iter(self))
+        return filter(fn, iter(self))
 
     def accumulate(self, fn: Callable[[Any, Any], Any] | None = None) -> Iterator[Any]:
         return itertools.accumulate(iter(self), fn)
 
     def enumerate(self, start: int = 0) -> Iterator[tuple[int, Any]]:
-        return builtins_enumerate(iter(self), start)
+        return enumerate(iter(self), start)
 
     def zip(self, *others: Any) -> Iterator[tuple[Any, ...]]:
-        return builtins_zip(iter(self), *others)
+        return zip(iter(self), *others)
 
     def chunk(self, n: int) -> Iterator[list[Any]]:
         it = iter(self)
@@ -142,12 +168,145 @@ class IotaSequence:
             win.append(item)
             yield tuple(win)
 
-    def reduce(self, fn: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+    def reduce(self, fn: Callable[[Any, Any], Any], initial: Any = _MISSING) -> Any:
         if self.infinite:
             raise TypeError("cannot reduce infinite sequence")
-        if initial is not None:
-            return _reduce(fn, iter(self), initial)
-        return _reduce(fn, iter(self))
+        if initial is _MISSING:
+            return _reduce(fn, iter(self))
+        return _reduce(fn, iter(self), initial)
+
+    # --- lazy combinators (return iterators) ---
+
+    def takewhile(self, pred: Callable[[Any], bool]) -> Iterator[Any]:
+        return itertools.takewhile(pred, iter(self))
+
+    def dropwhile(self, pred: Callable[[Any], bool]) -> Iterator[Any]:
+        return itertools.dropwhile(pred, iter(self))
+
+    def pairwise(self) -> Iterator[tuple[Any, Any]]:
+        return itertools.pairwise(iter(self))
+
+    def flatten(self) -> Iterator[Any]:
+        for item in self:
+            if isinstance(item, (str, bytes)):
+                yield item
+            else:
+                try:
+                    inner = iter(item)
+                except TypeError:
+                    yield item
+                else:
+                    yield from inner
+
+    def distinct(self, key: Callable[[Any], Any] | None = None) -> Iterator[Any]:
+        seen: set[Any] = set()
+        for item in self:
+            k = key(item) if key is not None else item
+            if k not in seen:
+                seen.add(k)
+                yield item
+
+    # --- terminal operations (consume the sequence) ---
+
+    def _reject_infinite(self, op: str) -> None:
+        if self.infinite:
+            raise TypeError(f"cannot {op} an infinite sequence")
+
+    def to_list(self) -> list[Any]:
+        self._reject_infinite("materialize")
+        return list(self)
+
+    def to_tuple(self) -> tuple[Any, ...]:
+        self._reject_infinite("materialize")
+        return tuple(self)
+
+    def to_set(self) -> set[Any]:
+        self._reject_infinite("materialize")
+        return set(self)
+
+    def to_dict(
+        self,
+        key: Callable[[Any], Any] | None = None,
+        value: Callable[[Any], Any] | None = None,
+    ) -> dict[Any, Any]:
+        self._reject_infinite("materialize")
+        return {
+            (key(x) if key is not None else x): (value(x) if value is not None else x)
+            for x in self
+        }
+
+    def sum(self, start: Any = 0) -> Any:
+        self._reject_infinite("sum")
+        if type(self) is IotaSequence and self._map is None:
+            n = self.__len__()
+            if n == 0:
+                return start
+            last = self._start + (n - 1) * self._step
+            return start + n * (self._start + last) // 2
+        return sum(self, start)
+
+    def min(self, default: Any = _MISSING) -> Any:
+        self._reject_infinite("take min of")
+        if type(self) is IotaSequence and self._map is None:
+            n = self.__len__()
+            if n == 0:
+                if default is _MISSING:
+                    raise ValueError("min() of an empty sequence")
+                return default
+            last = self._start + (n - 1) * self._step
+            return self._start if self._step > 0 else last
+        return min(self) if default is _MISSING else min(self, default=default)
+
+    def max(self, default: Any = _MISSING) -> Any:
+        self._reject_infinite("take max of")
+        if type(self) is IotaSequence and self._map is None:
+            n = self.__len__()
+            if n == 0:
+                if default is _MISSING:
+                    raise ValueError("max() of an empty sequence")
+                return default
+            last = self._start + (n - 1) * self._step
+            return last if self._step > 0 else self._start
+        return max(self) if default is _MISSING else max(self, default=default)
+
+    def count(self) -> int:
+        self._reject_infinite("count")
+        if type(self) is IotaSequence:
+            return self.__len__()
+        return sum(1 for _ in self)
+
+    def first(self, default: Any = None) -> Any:
+        return next(iter(self), default)
+
+    def last(self, default: Any = None) -> Any:
+        self._reject_infinite("take last of")
+        if type(self) is IotaSequence:
+            n = self.__len__()
+            if n == 0:
+                return default
+            raw = self._start + (n - 1) * self._step
+            return self._map(raw) if self._map is not None else raw
+        result = default
+        for item in self:
+            result = item
+        return result
+
+    def nth(self, n: int, default: Any = None) -> Any:
+        if type(self) is IotaSequence and n >= 0:
+            if self.infinite or n < self.__len__():
+                raw = self._start + n * self._step
+                return self._map(raw) if self._map is not None else raw
+            return default
+        return next(itertools.islice(iter(self), n, n + 1), default)
+
+    def find(self, pred: Callable[[Any], bool], default: Any = None) -> Any:
+        return next((x for x in self if pred(x)), default)
+
+    def any(self, pred: Callable[[Any], bool] | None = None) -> bool:
+        return any(pred(x) if pred is not None else x for x in self)
+
+    def all(self, pred: Callable[[Any], bool] | None = None) -> bool:
+        return all(pred(x) if pred is not None else x for x in self)
 
     def __add__(self, other: IotaSequence) -> _ConcatSequence:
         return _ConcatSequence(self, other)
@@ -287,7 +446,7 @@ class _ZipMapSequence(IotaSequence):
         return self._a.infinite and self._b.infinite
 
     def __iter__(self) -> Iterator[tuple[Any, Any]]:
-        yield from builtins_zip(self._a, self._b)
+        yield from zip(self._a, self._b)
 
     def __len__(self) -> int:
         if self.infinite:
@@ -300,11 +459,3 @@ class _ZipMapSequence(IotaSequence):
 
     def __repr__(self) -> str:
         return f"({self._a!r} @ {self._b!r})"
-
-
-import builtins
-
-builtins_map = builtins.map
-builtins_filter = builtins.filter
-builtins_enumerate = builtins.enumerate
-builtins_zip = builtins.zip

pythoniota-1.3.0.dist-info/METADATA

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: PythonIota
+Version: 1.3.0
+Summary: Go-style iota enumerations and flexible sequence generators for Python
+Author: Equinox
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# PythonIota
+
+Go-style `iota` enumerations and flexible, lazy sequence generators for Python — zero dependencies, fully typed.
+
+```bash
+pip install PythonIota
+```
+
+Requires Python 3.10+.
+
+---
+
+## Enums
+
+### Go-style `iota`
+
+`iota` starts at `0` and auto-increments each time it is read. Literal assignments do **not** consume it.
+
+```python
+from pythoniota import IotaEnum
+
+class Color(IotaEnum):
+    Red   = iota   # 0
+    Green = iota   # 1
+    Blue  = iota   # 2
+
+Color.Green          # 1
+Color.names()        # ['Red', 'Green', 'Blue']
+Color.values()       # [0, 1, 2]
+list(Color)          # [('Red', 0), ('Green', 1), ('Blue', 2)]
+0 in Color           # True (by value)
+'Red' in Color       # True (by name)
+Color.from_value(2)  # 'Blue'
+```
+
+`iota` works inside expressions — the value is the current counter:
+
+```python
+class Perm(IotaEnum):
+    Read  = 1 << iota          # 1
+    Write = 1 << iota          # 2
+    Exec  = 1 << iota          # 4
+    All   = Read | Write | Exec # 7
+
+class Size(IotaEnum):
+    KB = 1 << (iota + 10)      # 1024
+    MB = 1 << (iota + 10)      # 2048
+    GB = 1 << (iota + 10)      # 4096
+```
+
+### Skipping values & custom start/step
+
+```python
+class Errno(IotaEnum):
+    EPERM = iota   # 0
+    skip(2)        # skip 1, 2
+    EBADF = iota   # 3
+
+class Port(IotaEnum):
+    _iota_start_ = 8000
+    _iota_step_  = 10
+    HTTP  = iota   # 8000
+    HTTPS = iota   # 8010
+```
+
+`_ = iota` also skips a single value (Go's blank identifier).
+
+### Immutability, aliases, serialization
+
+```python
+Color.Red = 99          # AttributeError: cannot modify enum member
+Color.alias('R', 'Red') # Color.R == 0
+Color.to_dict()         # {'Red': 0, 'Green': 1, 'Blue': 2}
+Color.to_json()         # '{"Red": 0, "Green": 1, "Blue": 2}'
+Color.from_json(s)      # -> dict of members
+Color.has('Red')        # True
+Color.get('Nope', -1)   # -1
+```
+
+### `@unique` — reject duplicate values
+
+```python
+from pythoniota import unique
+
+@unique
+class Status(IotaEnum):
+    Active   = iota
+    Inactive = iota
+# raises ValueError if two members share a value
+```
+
+### Ordered enums
+
+Add `_ordered_ = True` to make members comparable by declaration order:
+
+```python
+class Priority(IotaEnum):
+    _ordered_ = True
+    Low    = iota
+    Medium = iota
+    High   = iota
+
+Priority.Low < Priority.High   # True
+```
+
+### Bit flags
+
+```python
+from pythoniota import IotaBitFlags, FlagScope
+
+class Access(IotaBitFlags):
+    Read  = 1 << iota   # 1
+    Write = 1 << iota   # 2
+    Exec  = 1 << iota   # 4
+
+flags = Access.Read | Access.Write
+flags.has(Access.Read)              # True
+flags.has_all(Access.Read, Access.Exec)  # False
+flags.has_any(Access.Read, Access.Exec)  # True
+list(flags.decompose())             # [BitFlag(1), BitFlag(2)]
+
+with FlagScope() as scope:
+    scope.grant(Access.Read, Access.Write)
+    scope.revoke(Access.Write)
+    scope.has(Access.Read)          # True
+```
+
+### String enums
+
+Members resolve to their own name, or a custom format:
+
+```python
+from pythoniota import IotaStringEnum
+
+class Color(IotaStringEnum):
+    Red  = iota   # 'Red'
+    Blue = iota   # 'Blue'
+
+class Code(IotaStringEnum):
+    _format_ = "{name}_{index:03d}"
+    OK    = iota  # 'OK_000'
+    Error = iota  # 'Error_001'
+```
+
+### `@iota_enum` decorator
+
+Turn a plain class into an enum:
+
+```python
+from pythoniota import iota_enum
+
+@iota_enum
+class Color:
+    Red = 0
+    Green = 1
+    Blue = 2
+
+@iota_enum(ordered=True)
+class Priority:
+    Low = 0
+    High = 1
+```
+
+### `match` / `case`
+
+Enum members match by value:
+
+```python
+match color:
+    case Color.Red:   ...
+    case Color.Blue:  ...
+    case _:           ...
+```
+
+---
+
+## Sequences
+
+`iota(...)` is a lazy, composable sequence. Construction mirrors `range`, plus an optional `map`:
+
+```python
+from pythoniota import iota
+
+iota()                       # 0, 1, 2, ...        (infinite)
+iota(5)                      # 0, 1, 2, 3, 4
+iota(2, 10, 2)               # 2, 4, 6, 8
+iota(5, map=lambda i: i*i)   # 0, 1, 4, 9, 16
+
+s = iota(10)
+len(s)          # 10        (O(1))
+s[7]            # 7         (O(1) arithmetic indexing)
+s[2:5]          # [2, 3, 4]
+list(reversed(s))   # 9, 8, ... 0   (lazy)
+5 in s          # True      (O(1))
+s.take(3)       # [0, 1, 2]
+```
+
+### Operators
+
+```python
+iota(3) + iota(3, 6)   # concat: 0,1,2,3,4,5
+iota(3) * 2            # repeat: 0,1,2,0,1,2
+iota(3) | iota(3, 6)   # interleave: 0,3,1,4,2,5
+iota(3) @ iota(3, 6)   # zip: (0,3),(1,4),(2,5)
+```
+
+### Lazy combinators
+
+```python
+iota(10).filter(lambda x: x % 2 == 0)   # 0,2,4,6,8
+iota().map(lambda x: x*x)               # 0,1,4,9,...
+iota().takewhile(lambda x: x < 5)       # 0,1,2,3,4
+iota(10).dropwhile(lambda x: x < 7)     # 7,8,9
+iota(4).pairwise()                      # (0,1),(1,2),(2,3)
+iota(5).window(3)                       # (0,1,2),(1,2,3),(2,3,4)
+iota(7).chunk(3)                        # [0,1,2],[3,4,5],[6]
+iota(6).map(lambda x: x % 3).distinct() # 0,1,2
+seq.flatten()                           # flatten one level
+iota().enumerate()  .accumulate()  .zip(other)
+```
+
+### Terminal operations
+
+Reductions on plain arithmetic sequences are O(1); infinite sequences raise where they would not terminate.
+
+```python
+iota(1, 101).sum()      # 5050   (closed-form, O(1))
+iota(3, 10).min()       # 3
+iota(3, 10).max()       # 9
+iota(0, 10, 2).count()  # 5
+iota(5).last()          # 4
+iota(10).nth(3)         # 3
+iota().first()          # 0
+iota().find(lambda x: x > 100)   # 101
+iota(1, 5).all(lambda x: x > 0)  # True
+iota(5).any(lambda x: x == 3)    # True
+iota(3).reduce(lambda a, b: a + b)  # 3
+
+iota(3).to_list()                     # [0, 1, 2]
+iota(3).to_tuple()                    # (0, 1, 2)
+iota(3).to_set()                      # {0, 1, 2}
+iota(3).to_dict(value=lambda x: x*x)  # {0: 0, 1: 1, 2: 4}
+```
+
+### Async iteration
+
+```python
+async for x in iota(5):
+    ...
+```
+
+---
+
+## Recipes
+
+```python
+from pythoniota.recipes import (
+    fibonacci, lucas, factorial, catalan, harmonic,
+    triangle, powers, geometric, primes, primes_sieve,
+    pascal_row, collatz, repeat, cycle,
+)
+
+fibonacci(10).to_list()   # 0,1,1,2,3,5,8,13,21,34
+lucas(7).to_list()        # 2,1,3,4,7,11,18
+factorial(6).to_list()    # 1,1,2,6,24,120
+catalan(6).to_list()      # 1,1,2,5,14,42
+harmonic(4).to_list()     # 1.0, 1.5, 1.833..., 2.083...
+triangle(5).to_list()     # 0,1,3,6,10
+powers(2, 8).to_list()    # 1,2,4,...,128
+geometric(3, 2, 4).to_list()  # 3,6,12,24
+primes(5).to_list()       # 2,3,5,7,11        (first n primes)
+primes_sieve(20).to_list()# 2,3,5,7,11,13,17,19  (< limit, Eratosthenes)
+pascal_row(4).to_list()   # 1,4,6,4,1
+collatz(6).to_list()      # 6,3,10,5,16,8,4,2,1
+repeat('x', 3).to_list()  # ['x','x','x']
+cycle([1,2], 5).to_list() # 1,2,1,2,1
+```
+
+Recipes without a count argument produce infinite sequences: `fibonacci().take(20)`, `primes().takewhile(lambda p: p < 100)`.
+
+---
+
+## Safe expression evaluation
+
+`safe_eval` evaluates arithmetic expressions over a whitelisted AST (no `eval`, no names/calls beyond provided variables):
+
+```python
+from pythoniota import safe_eval
+
+safe_eval("2 ** 10")                 # 1024
+safe_eval("a * b + 1", {"a": 3, "b": 4})  # 13
+```
+
+---
+
+## License
+
+MIT

pythoniota-1.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pythoniota/__init__.py,sha256=kSSASpZFdDUTmw7TfRNvppXWpp_nVTxd88Jn8SV1bIk,546
+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=PQNk3rbY93C7AwNoD5LmdDNlr3gvppFMt15QedsTBUo,19846
+pythoniota/recipes.py,sha256=W005nhwH4rqLfSXIsuFjl6ZjZvzHFEC9nrJH2_VibIA,10835
+pythoniota/sequence.py,sha256=XMtbBIP-elaXkBiYOpSt0qPIYQOz_lGo2lHDh5z3V-A,15344
+pythoniota-1.3.0.dist-info/METADATA,sha256=22aDmgyCECjd4KSDllYc1HK1NVTRkd3up-zaPyKFdo0,8084
+pythoniota-1.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pythoniota-1.3.0.dist-info/top_level.txt,sha256=LoZ35nXIBPHY71-dvmTXyI_g9PBRt8hui5ubG4Huu8c,11
+pythoniota-1.3.0.dist-info/RECORD,,

{pythoniota-1.2.0.dist-info → pythoniota-1.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pythoniota-1.2.0.dist-info/METADATA

@@ -1,16 +0,0 @@
-Metadata-Version: 2.4
-Name: PythonIota
-Version: 1.2.0
-Summary: Go-style iota enumerations and flexible sequence generators for Python
-Author: Equinox
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown

pythoniota-1.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-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,,