PythonIota 1.3.0__tar.gz → 1.7.1__tar.gz

pythoniota-1.7.1/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include tests *.py

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

@@ -1,7 +1,7 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.2
 Name: PythonIota
-Version: 1.3.0
-Summary: Go-style iota enumerations and flexible sequence generators for Python
+Version: 1.7.1
+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,20 @@ pip install PythonIota
 
 Requires Python 3.10+.
 
+## 1.7.1 fixes
+
+- Full matching now considers complete alternatives instead of rejecting a
+  valid match after selecting a shorter branch.
+- Ordered enum members now hash consistently with equal numeric values and
+  equal members of other enums, preserving dictionary and set lookups.
+
+**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`)
+- **CLI** — a from-scratch `argparse`-style argument parser (`pythoniota.cli`)
+
 ---
 
 ## Enums
@@ -310,6 +325,100 @@ 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
+`(?=...)` / `(?!...)`, fixed-width lookbehind `(?<=...)` / `(?<!...)`, conditionals
+`(?(id/name)yes|no)`, character classes `[...]`, counted repeats `{m,n}`,
+shorthands `\d \w \s` (and `\D \W \S`), word boundaries `\b \B`, anchors
+`^ $ \A \Z`, and hex escapes `\xHH` / `\uHHHH`. Flags: `IGNORECASE`, `MULTILINE`,
+`DOTALL`, `VERBOSE` (also inline `(?imsx)`). API mirrors `re`: `compile`, `match`,
+`fullmatch`, `search`, `findall`, `finditer`, `sub`, `subn`, `split`, `escape`,
+with `Match.group` / `groups` / `span` / `groupdict` / `expand`.
+
+```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
+```
+
+---
+
+## CLI
+
+A faithful subset of the standard library's `argparse`, built from scratch:
+
+```python
+from pythoniota import cli
+
+p = cli.ArgumentParser(prog="greet", description="say hello")
+p.add_argument("name")
+p.add_argument("-n", "--times", type=int, default=1)
+p.add_argument("-v", "--verbose", action="store_true")
+
+args = p.parse_args(["world", "--times", "3", "-v"])
+args.name, args.times, args.verbose      # ('world', 3, True)
+```
+
+Supported:
+
+- positional & optional arguments, `nargs` (`N` / `?` / `*` / `+`)
+- `type` / `choices` / `default` / `required`
+- actions: `store`, `store_true`, `store_false`, `store_const`, `append`, `count`
+- `--opt=value`, clustered short flags (`-abc`), the `--` end-of-options marker
+- an auto-generated `-h/--help`, and sub-commands via `add_subparsers`
+
+Bad input prints a usage line and raises `SystemExit(2)` — the same contract as
+argparse, so it drops into scripts and tests unchanged. `parse_known_args`
+returns `(namespace, extras)` instead of erroring on unknown tokens.
+
+### Sub-commands
+
+```python
+p = cli.ArgumentParser(prog="git")
+sub = p.add_subparsers(dest="cmd")
+
+add = sub.add_parser("add", help="stage files")
+add.add_argument("path")
+add.add_argument("-f", "--force", action="store_true")
+
+rm = sub.add_parser("rm", help="remove files")
+rm.add_argument("path")
+
+args = p.parse_args(["add", "README.md", "-f"])
+args.cmd, args.path, args.force          # ('add', 'README.md', True)
+```
+
+---
+
 ## License
 
 MIT