PythonIota 0.0.2__tar.gz → 1.1.0__tar.gz

pythoniota-1.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: PythonIota
+Version: 1.1.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.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PythonIota"
+version = "1.1.0"
+description = "Go-style iota enumerations and flexible sequence generators for Python"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Equinox"}]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pythoniota-1.1.0/src/PythonIota.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: PythonIota
+Version: 1.1.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.1.0/src/PythonIota.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+pyproject.toml
+src/PythonIota.egg-info/PKG-INFO
+src/PythonIota.egg-info/SOURCES.txt
+src/PythonIota.egg-info/dependency_links.txt
+src/PythonIota.egg-info/top_level.txt
+src/pythoniota/__init__.py
+src/pythoniota/_bitflag.py
+src/pythoniota/_compat.py
+src/pythoniota/_safe_eval.py
+src/pythoniota/enum.py
+src/pythoniota/recipes.py
+src/pythoniota/sequence.py
+tests/test_bitflags.py
+tests/test_compat.py
+tests/test_enum.py
+tests/test_enum_enhanced.py
+tests/test_integration.py
+tests/test_recipes.py
+tests/test_safe_eval.py
+tests/test_sequence.py
+tests/test_serialization.py
+tests/test_string_enum.py

pythoniota-1.1.0/src/PythonIota.egg-info/top_level.txt

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

pythoniota-1.1.0/src/pythoniota/__init__.py

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

pythoniota-1.1.0/src/pythoniota/_bitflag.py

@@ -0,0 +1,105 @@
+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 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
+        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-1.1.0/src/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-1.1.0/src/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-1.1.0/src/pythoniota/enum.py

@@ -0,0 +1,321 @@
+from __future__ import annotations
+
+import json
+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, str, _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, 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
+        )
+        is_string_enum = any(
+            hasattr(b, "_is_string_enum_base") for b in bases
+        )
+
+        if is_string_enum:
+            fmt = namespace.get("_format_", None)
+            for mname, mval in list(members.items()):
+                if isinstance(mval, _IotaCounter) or isinstance(mval, int):
+                    if fmt:
+                        members[mname] = fmt.format(name=mname, index=mval if isinstance(mval, int) else int(mval))
+                    else:
+                        members[mname] = mname
+                type.__setattr__(cls, mname, members[mname])
+        elif is_bitflag:
+            for mname, mval in members.items():
+                flag = BitFlag(int(mval), mname)
+                members[mname] = flag
+                type.__setattr__(cls, mname, flag)
+        else:
+            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]]:
+        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[Any]:
+        return list(cls._members_.values())  # type: ignore[attr-defined]
+
+    @classmethod
+    def items(cls) -> list[tuple[str, Any]]:
+        return list(cls._members_.items())  # type: ignore[attr-defined]
+
+    @classmethod
+    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
+
+    @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
+
+    @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