PythonIota 1.3.0__tar.gz → 1.7.0__tar.gz

{pythoniota-1.3.0/src/PythonIota.egg-info → pythoniota-1.7.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: PythonIota
-Version: 1.3.0
-Summary: Go-style iota enumerations and flexible sequence generators for Python
+Version: 1.7.0
+Summary: A zero-dependency Python toolkit: Go-style iota enums, sequence generators, a from-scratch regex engine, and an argparse-style CLI parser
 Author: Equinox
 License: MIT
 Classifier: Programming Language :: Python :: 3
@@ -17,7 +17,8 @@ Description-Content-Type: text/markdown
 
 # PythonIota
 
-Go-style `iota` enumerations and flexible, lazy sequence generators for Python — zero dependencies, fully typed.
+A **zero-dependency Python toolkit** of from-scratch building blocks — Go-style
+`iota` enumerations, lazy sequence generators, and a linear-time regex engine.
 
 ```bash
 pip install PythonIota
@@ -25,6 +26,12 @@ pip install PythonIota
 
 Requires Python 3.10+.
 
+**What's inside**
+
+- **Enums** — Go-style `iota`, bit flags, string enums (`pythoniota.IotaEnum`, ...)
+- **Sequences** — lazy, chainable generators (`pythoniota.iota`)
+- **Regex** — a from-scratch NFA (Pike VM) engine, no catastrophic backtracking (`pythoniota.regex`)
+
 ---
 
 ## Enums
@@ -310,6 +317,52 @@ safe_eval("a * b + 1", {"a": 3, "b": 4})  # 13
 
 ---
 
+## Regex
+
+A from-scratch regular-expression engine. Unlike Python's backtracking `re`, it
+compiles the pattern to a tiny bytecode and runs it with a **Pike VM** (a
+thread-list NFA simulation), so matching is linear in `len(text) × len(program)`
+— pathological patterns like `(a+)+$` finish instantly instead of hanging.
+
+```python
+from pythoniota import regex
+
+m = regex.match(r"(\d{4})-(\d{2})-(\d{2})", "2026-08-02")
+m.groups()                                   # ('2026', '08', '02')
+
+regex.findall(r"\w+", "hello world")          # ['hello', 'world']
+regex.sub(r"\s+", "_", "a  b   c")            # 'a_b_c'
+regex.split(r"[,;]\s*", "a, b; c,d")          # ['a', 'b', 'c', 'd']
+
+named = regex.search(r"(?P<user>\w+)@(?P<host>\w+)", "user@host")
+named.groupdict()                             # {'user': 'user', 'host': 'host'}
+```
+
+Supported: literals, `.`, `* + ?` and their lazy forms `*? +? ??`, alternation
+`|`, groups `(...)` / non-capturing `(?:...)` / named `(?P<name>...)`, lookahead
+`(?=...)` / `(?!...)`, character classes `[...]`, counted repeats `{m,n}`,
+shorthands `\d \w \s` (and `\D \W \S`), word boundaries `\b \B`, and anchors
+`^ $ \A \Z`. Flags: `IGNORECASE`, `MULTILINE`, `DOTALL`, `VERBOSE` (also inline
+`(?imsx)`). API mirrors `re`: `compile`, `match`, `fullmatch`, `search`,
+`findall`, `finditer`, `sub`, `split`, `escape`, with `Match.group` / `groups` /
+`span` / `groupdict`.
+
+```python
+regex.findall(r"[a-z]+", "AbCdEf", regex.IGNORECASE)   # ['AbCdEf']
+regex.findall(r"\d+(?=px)", "10px 20em 30px")           # ['10', '30']  (lookahead)
+```
+
+Backreferences (`\1`) are intentionally *not* supported: they can't be matched
+by a finite automaton in linear time — that's the price of the no-backtracking
+guarantee (the same trade-off Go's `regexp` and RE2 make).
+
+```python
+# no ReDoS: this returns in microseconds, where re takes ~13s at length 28
+regex.search(r"(a+)+$", "a" * 40 + "!")       # None, instantly
+```
+
+---
+
 ## License
 
 MIT