PythonIota 1.0.0__py3-none-any.whl

pythoniota/__init__.py

@@ -0,0 +1,15 @@
+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.sequence import IotaSequence as iota
+
+__version__ = "1.0.0"
+__all__ = [
+    "Iota",
+    "IotaEnum",
+    "IotaBitFlags",
+    "iota",
+    "BitFlag",
+    "safe_eval",
+]

pythoniota/_bitflag.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+
+class BitFlag:
+    __slots__ = ("_value", "_name")
+
+    def __init__(self, value: int, name: str = "") -> None:
+        object.__setattr__(self, "_value", value)
+        object.__setattr__(self, "_name", name)
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def __int__(self) -> int:
+        return self._value
+
+    def __index__(self) -> int:
+        return self._value
+
+    def __bool__(self) -> bool:
+        return self._value != 0
+
+    def __hash__(self) -> int:
+        return hash(self._value)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, BitFlag):
+            return self._value == other._value
+        if isinstance(other, int):
+            return self._value == other
+        return NotImplemented
+
+    def __or__(self, other: BitFlag | int) -> BitFlag:
+        other_val = other._value if isinstance(other, BitFlag) else int(other)
+        name = f"{self._name}|{other._name if isinstance(other, BitFlag) else other_val}"
+        return BitFlag(self._value | other_val, name)
+
+    def __ror__(self, other: int) -> BitFlag:
+        return BitFlag(other | self._value, f"{other}|{self._name}")
+
+    def __and__(self, other: BitFlag | int) -> BitFlag:
+        other_val = other._value if isinstance(other, BitFlag) else int(other)
+        return BitFlag(self._value & other_val)
+
+    def __rand__(self, other: int) -> BitFlag:
+        return BitFlag(other & self._value)
+
+    def __xor__(self, other: BitFlag | int) -> BitFlag:
+        other_val = other._value if isinstance(other, BitFlag) else int(other)
+        return BitFlag(self._value ^ other_val)
+
+    def __rxor__(self, other: int) -> BitFlag:
+        return BitFlag(other ^ self._value)
+
+    def __invert__(self) -> BitFlag:
+        return BitFlag(~self._value, f"~{self._name}")
+
+    def __contains__(self, item: BitFlag | int) -> bool:
+        item_val = item._value if isinstance(item, BitFlag) else int(item)
+        return (self._value & item_val) == item_val and item_val != 0
+
+    def has(self, flag: BitFlag | int) -> bool:
+        return flag in self
+
+    def decompose(self) -> list[BitFlag]:
+        result = []
+        v = self._value
+        bit = 1
+        while bit <= v:
+            if v & bit:
+                result.append(BitFlag(bit))
+            bit <<= 1
+        return result
+
+    def __repr__(self) -> str:
+        if self._name:
+            return f"BitFlag({self._name}={self._value})"
+        return f"BitFlag({self._value})"
+
+    def __str__(self) -> str:
+        return self._name or str(self._value)
+
+    def __iter__(self) -> Iterator[BitFlag]:
+        return iter(self.decompose())

pythoniota/_compat.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any
+
+from pythoniota._safe_eval import safe_eval
+
+
+class Iota:
+    """Legacy Iota class for backward compatibility. Prefer IotaEnum or iota()."""
+
+    def __init__(self, initial: int = 0) -> None:
+        warnings.warn(
+            "Iota is deprecated. Use IotaEnum for enumerations or iota() for sequences.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.current: int = initial
+        self.values: dict[str, Any] = {}
+
+    def __call__(self, **kwargs: str) -> None:
+        keys = list(kwargs.keys())
+        for i, (key, value) in enumerate(kwargs.items()):
+            if value == "iota":
+                self.values[key] = 0
+                self.current = 1
+            elif value == "":
+                self.values[key] = self.current
+                self.current += 1
+            elif value == "_":
+                self.current += 1
+                continue
+            elif value.isdigit():
+                self.values[key] = int(value)
+                self.current = self.values[key] + 1
+            else:
+                variables = {"iota": self.current}
+                variables.update({k: v for k, v in self.values.items() if isinstance(v, (int, float))})
+                result = safe_eval(value, variables)
+                self.values[key] = result
+                self.current = int(result) + 1
+
+            if key != "_":
+                setattr(self, key, self.values[key])
+
+    def parse_input(self, input_str: str) -> None:
+        lines = input_str.strip().split("\n")
+        args: dict[str, str] = {}
+        for line in lines:
+            if "=" in line:
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+            else:
+                key = line.strip()
+                value = ""
+            args[key] = value
+        self(**args)
+
+    # Backward-compatible alias
+    __parseInput__ = parse_input
+
+    def get_values(self) -> dict[str, Any]:
+        return self.values

pythoniota/_safe_eval.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import ast
+import operator
+from typing import Any
+
+_BIN_OPS: dict[type, Any] = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+    ast.LShift: operator.lshift,
+    ast.RShift: operator.rshift,
+    ast.BitOr: operator.or_,
+    ast.BitAnd: operator.and_,
+    ast.BitXor: operator.xor,
+}
+
+_UNARY_OPS: dict[type, Any] = {
+    ast.USub: operator.neg,
+    ast.UAdd: operator.pos,
+    ast.Invert: operator.invert,
+}
+
+
+def _eval_node(node: ast.expr, variables: dict[str, int | float]) -> int | float:
+    if isinstance(node, ast.Constant):
+        if not isinstance(node.value, (int, float)):
+            raise ValueError(f"Unsupported constant type: {type(node.value).__name__}")
+        return node.value
+
+    if isinstance(node, ast.Name):
+        if node.id not in variables:
+            raise ValueError(f"Undefined variable: {node.id}")
+        return variables[node.id]
+
+    if isinstance(node, ast.BinOp):
+        op_fn = _BIN_OPS.get(type(node.op))
+        if op_fn is None:
+            raise ValueError(f"Unsupported operator: {type(node.op).__name__}")
+        return op_fn(_eval_node(node.left, variables), _eval_node(node.right, variables))
+
+    if isinstance(node, ast.UnaryOp):
+        op_fn = _UNARY_OPS.get(type(node.op))
+        if op_fn is None:
+            raise ValueError(f"Unsupported unary operator: {type(node.op).__name__}")
+        return op_fn(_eval_node(node.operand, variables))
+
+    raise ValueError(f"Unsupported node: {type(node).__name__}")
+
+
+def safe_eval(expr: str, variables: dict[str, int | float] | None = None) -> int | float:
+    if variables is None:
+        variables = {}
+    tree = ast.parse(expr.strip(), mode="eval")
+    return _eval_node(tree.body, variables)
+
+
+def is_safe_expression(expr: str) -> bool:
+    try:
+        safe_eval(expr)
+        return True
+    except (ValueError, SyntaxError):
+        return False

pythoniota/enum.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Any, Iterator
+
+from pythoniota._bitflag import BitFlag
+
+
+class _IotaCounter:
+    """Sentinel returned by IotaNamespace when 'iota' is read. Holds the current counter value."""
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: int) -> None:
+        self.value = value
+
+    def __int__(self) -> int:
+        return self.value
+
+    def __index__(self) -> int:
+        return self.value
+
+    def __lshift__(self, other: Any) -> int:
+        return self.value << int(other)
+
+    def __rlshift__(self, other: Any) -> int:
+        return int(other) << self.value
+
+    def __rshift__(self, other: Any) -> int:
+        return self.value >> int(other)
+
+    def __rrshift__(self, other: Any) -> int:
+        return int(other) >> self.value
+
+    def __add__(self, other: Any) -> int:
+        return self.value + int(other)
+
+    def __radd__(self, other: Any) -> int:
+        return int(other) + self.value
+
+    def __sub__(self, other: Any) -> int:
+        return self.value - int(other)
+
+    def __rsub__(self, other: Any) -> int:
+        return int(other) - self.value
+
+    def __mul__(self, other: Any) -> int:
+        return self.value * int(other)
+
+    def __rmul__(self, other: Any) -> int:
+        return int(other) * self.value
+
+    def __floordiv__(self, other: Any) -> int:
+        return self.value // int(other)
+
+    def __rfloordiv__(self, other: Any) -> int:
+        return int(other) // self.value
+
+    def __mod__(self, other: Any) -> int:
+        return self.value % int(other)
+
+    def __rmod__(self, other: Any) -> int:
+        return int(other) % self.value
+
+    def __pow__(self, other: Any) -> int:
+        return self.value ** int(other)
+
+    def __rpow__(self, other: Any) -> int:
+        return int(other) ** self.value
+
+    def __or__(self, other: Any) -> int:
+        return self.value | int(other)
+
+    def __ror__(self, other: Any) -> int:
+        return int(other) | self.value
+
+    def __and__(self, other: Any) -> int:
+        return self.value & int(other)
+
+    def __rand__(self, other: Any) -> int:
+        return int(other) & self.value
+
+    def __xor__(self, other: Any) -> int:
+        return self.value ^ int(other)
+
+    def __rxor__(self, other: Any) -> int:
+        return int(other) ^ self.value
+
+    def __neg__(self) -> int:
+        return -self.value
+
+    def __pos__(self) -> int:
+        return +self.value
+
+    def __invert__(self) -> int:
+        return ~self.value
+
+    def __eq__(self, other: Any) -> bool:
+        return self.value == int(other) if isinstance(other, (int, _IotaCounter)) else NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __repr__(self) -> str:
+        return f"iota({self.value})"
+
+
+class IotaNamespace(dict):  # type: ignore[type-arg]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._counter = 0
+        self._member_names: list[str] = []
+
+    def __getitem__(self, key: str) -> Any:
+        if key == "iota":
+            val = _IotaCounter(self._counter)
+            self._counter += 1
+            return val
+        return super().__getitem__(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        super().__setitem__(key, value)
+        if (
+            not key.startswith("_")
+            and key != "iota"
+            and isinstance(value, (int, float, _IotaCounter))
+        ):
+            if key not in self._member_names:
+                self._member_names.append(key)
+
+
+class IotaEnumMeta(type):
+
+    @classmethod
+    def __prepare__(mcs, name: str, bases: tuple[type, ...], **kwargs: Any) -> IotaNamespace:  # type: ignore[override]
+        return IotaNamespace()
+
+    def __new__(
+        mcs,
+        name: str,
+        bases: tuple[type, ...],
+        namespace: IotaNamespace,  # type: ignore[override]
+        **kwargs: Any,
+    ) -> IotaEnumMeta:
+        member_names = namespace._member_names if isinstance(namespace, IotaNamespace) else []
+        members: OrderedDict[str, int | float] = 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]
+
+        is_bitflag = any(
+            hasattr(b, "_is_bitflag_base") for b in bases
+        )
+        for mname, mval in members.items():
+            if is_bitflag:
+                flag = BitFlag(int(mval), mname)
+                members[mname] = flag
+                type.__setattr__(cls, mname, flag)
+            else:
+                type.__setattr__(cls, mname, mval)
+
+        return cls
+
+    def __iter__(cls) -> Iterator[tuple[str, int | float]]:
+        return iter(cls._members_.items())  # type: ignore[attr-defined]
+
+    def __contains__(cls, item: Any) -> bool:
+        if isinstance(item, str):
+            return item in cls._members_  # type: ignore[attr-defined]
+        return item in cls._members_.values()  # type: ignore[attr-defined]
+
+    def __len__(cls) -> int:
+        return len(cls._members_)  # type: ignore[attr-defined]
+
+    def __getitem__(cls, key: str) -> int | float:
+        return cls._members_[key]  # type: ignore[attr-defined]
+
+    def __setattr__(cls, name: str, value: Any) -> None:
+        if hasattr(cls, "_members_") and name in cls._members_:  # type: ignore[attr-defined]
+            raise AttributeError(f"Cannot modify enum member '{name}'")
+        super().__setattr__(name, value)
+
+    def __delattr__(cls, name: str) -> None:
+        if hasattr(cls, "_members_") and name in cls._members_:  # type: ignore[attr-defined]
+            raise AttributeError(f"Cannot delete enum member '{name}'")
+        super().__delattr__(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}>"
+
+
+class IotaEnum(metaclass=IotaEnumMeta):
+
+    @classmethod
+    def names(cls) -> list[str]:
+        return list(cls._members_.keys())  # type: ignore[attr-defined]
+
+    @classmethod
+    def values(cls) -> list[int | float]:
+        return list(cls._members_.values())  # type: ignore[attr-defined]
+
+    @classmethod
+    def items(cls) -> list[tuple[str, int | float]]:
+        return list(cls._members_.items())  # type: ignore[attr-defined]
+
+    @classmethod
+    def from_value(cls, value: int | float) -> str | None:
+        for name, val in cls._members_.items():  # type: ignore[attr-defined]
+            if val == value:
+                return name
+        return None
+
+
+class IotaBitFlags(metaclass=IotaEnumMeta):
+    _is_bitflag_base = True
+
+    @classmethod
+    def names(cls) -> list[str]:
+        return list(cls._members_.keys())  # type: ignore[attr-defined]
+
+    @classmethod
+    def values(cls) -> list[BitFlag]:
+        return list(cls._members_.values())  # type: ignore[attr-defined]
+
+    @classmethod
+    def items(cls) -> list[tuple[str, BitFlag]]:
+        return list(cls._members_.items())  # type: ignore[attr-defined]
+
+    @classmethod
+    def from_value(cls, value: int) -> str | None:
+        for name, flag in cls._members_.items():  # type: ignore[attr-defined]
+            if int(flag) == value:
+                return name
+        return None

pythoniota/sequence.py

@@ -0,0 +1,172 @@
+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")
+
+
+class IotaSequence:
+
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, stop: int, /, *, map: Callable[[int], Any] | None = None) -> None: ...
+    @overload
+    def __init__(self, start: int, stop: int, step: int = 1, *, map: Callable[[int], Any] | None = None) -> None: ...
+
+    def __init__(self, *args: int, map: Callable[[int], Any] | None = None, step: int | None = None) -> None:
+        if len(args) == 0:
+            self._start = 0
+            self._stop: int | None = None
+            self._step = step if step is not None else 1
+        elif len(args) == 1:
+            self._start = 0
+            self._stop = args[0]
+            self._step = step if step is not None else 1
+        elif len(args) == 2:
+            self._start = args[0]
+            self._stop = args[1]
+            self._step = step if step is not None else 1
+        elif len(args) == 3:
+            self._start = args[0]
+            self._stop = args[1]
+            self._step = args[2]
+        else:
+            raise TypeError(f"iota expected at most 3 positional arguments, got {len(args)}")
+
+        if self._step == 0:
+            raise ValueError("step must not be zero")
+
+        self._map = map
+
+    @property
+    def infinite(self) -> bool:
+        return self._stop is None
+
+    def _raw_iter(self) -> Iterator[int]:
+        i = self._start
+        if self._stop is None:
+            while True:
+                yield i
+                i += self._step
+        else:
+            if self._step > 0:
+                while i < self._stop:
+                    yield i
+                    i += self._step
+            else:
+                while i > self._stop:
+                    yield i
+                    i += self._step
+
+    def __iter__(self) -> Iterator[Any]:
+        it = self._raw_iter()
+        if self._map is not None:
+            return builtins_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)
+        return max(0, n)
+
+    def __getitem__(self, index: int | slice) -> Any:
+        if isinstance(index, slice):
+            start, stop, step = index.indices(len(self) if not self.infinite else 2**31)
+            return list(itertools.islice(iter(self), start, stop, step))
+        if index < 0:
+            if self.infinite:
+                raise IndexError("negative indexing not supported on infinite sequences")
+            index = len(self) + index
+        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")
+        return value in iter(self)
+
+    def __reversed__(self) -> Iterator[Any]:
+        if self.infinite:
+            raise TypeError("cannot reverse infinite sequence")
+        return reversed(list(self))
+
+    def take(self, n: int) -> list[Any]:
+        return list(itertools.islice(iter(self), n))
+
+    def map(self, fn: Callable[[Any], Any]) -> IotaSequence:
+        outer_map = self._map
+        if outer_map is not None:
+            combined: Callable[[int], Any] = lambda x, _om=outer_map, _fn=fn: _fn(_om(x))
+        else:
+            combined = fn
+        seq = IotaSequence.__new__(IotaSequence)
+        seq._start = self._start
+        seq._stop = self._stop
+        seq._step = self._step
+        seq._map = combined
+        return seq
+
+    def filter(self, fn: Callable[[Any], bool]) -> Iterator[Any]:
+        return builtins_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)
+
+    def zip(self, *others: Any) -> Iterator[tuple[Any, ...]]:
+        return builtins_zip(iter(self), *others)
+
+    def chunk(self, n: int) -> Iterator[list[Any]]:
+        it = iter(self)
+        while True:
+            batch = list(itertools.islice(it, n))
+            if not batch:
+                break
+            yield batch
+
+    def window(self, n: int) -> Iterator[tuple[Any, ...]]:
+        it = iter(self)
+        win: deque[Any] = deque(itertools.islice(it, n), maxlen=n)
+        if len(win) < n:
+            return
+        yield tuple(win)
+        for item in it:
+            win.append(item)
+            yield tuple(win)
+
+    def reduce(self, fn: Callable[[Any, Any], Any], initial: Any = None) -> 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))
+
+    def __repr__(self) -> str:
+        parts = []
+        if self._start != 0:
+            parts.append(f"start={self._start}")
+        if self._stop is not None:
+            parts.append(f"stop={self._stop}")
+        else:
+            parts.append("infinite")
+        if self._step != 1:
+            parts.append(f"step={self._step}")
+        if self._map is not None:
+            parts.append("mapped")
+        return f"iota({', '.join(parts)})"
+
+
+import builtins
+
+builtins_map = builtins.map
+builtins_filter = builtins.filter
+builtins_enumerate = builtins.enumerate
+builtins_zip = builtins.zip

pythoniota-1.0.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: PythonIota
+Version: 1.0.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.0.0.dist-info/RECORD

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

pythoniota-1.0.0.dist-info/WHEEL

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

pythoniota-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pythoniota