exform 0.1.0__tar.gz

exform-0.1.0/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,24 @@
+name: Bug report
+description: Something exform got wrong or a crash
+labels: [bug]
+body:
+  - type: textarea
+    id: examples
+    attributes:
+      label: The examples you gave
+      description: The exact `-e "IN => OUT"` pairs (or --fill input).
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: What you expected vs. what happened
+      description: Include the inferred program from `--explain` if you can.
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: exform version
+      description: Output of `exform --version` (or the commit).

exform-0.1.0/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,17 @@
+name: Feature / transform request
+description: A transformation exform can't learn yet
+labels: [enhancement]
+body:
+  - type: textarea
+    id: task
+    attributes:
+      label: The transformation
+      description: Show before → after examples of what you want exform to learn.
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Why / where you hit this
+      description: What were you wrangling when exform fell short?

exform-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e . pytest
+      - run: python -m pytest -q

exform-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish to PyPI
+on:
+  release:
+    types: [published]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # trusted publishing (OIDC); no API token needed
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

exform-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+*.egg-info/
+*.pyc
+*.tsv.out
+.eggs/
+.mypy_cache/
+.pytest_cache/
+.venv/
+__pycache__/
+build/
+dist/
+venv/
+PLAN.md
+launch.sh

exform-0.1.0/CHANGELOG.md

@@ -0,0 +1,86 @@
+# Changelog
+
+## 0.1.0 - 2026-09-01
+- **Case-convention conversion (`camelCase` / `PascalCase`).** exform can now
+  learn `-e 'my_var_name => myVarName'` (`line.camel`) and the `=> MyVarName`
+  (`line.pascal`) style, folding over a *variable* number of words so
+  `hello_world_x => helloWorldX` generalises from shorter examples. The word
+  splitter accepts `snake_case`, `kebab-case`, spaced and `camelCase` input
+  alike, so any naming style can be reshaped into another.
+- **Acronyms & initials over a variable number of words.** exform can now learn
+  `-e 'John Ronald Tolkien => JRT'` (`line.acronym`) or the dotted
+  `=> J.R.R.` (`line.acronym.`) style, folding the leading letter of every word
+  regardless of how many there are — so `Ada King Lovelace => AKL` and single
+  names like `Cher => C` both come out right. A fixed `field(...)` program that
+  happened to fit two same-length examples used to mis-fire on a third of a
+  different length; the acronym fold generalises instead.
+- **Username / email-local synthesis.** A new lower-cased leading-initial
+  transform (`first_`) makes the classic `John Smith => jsmith` scheme
+  (`line.first_ + field(ws,1).lower`) and `=> jsmith@corp.com` reachable.
+- **PyPI publishing workflow.** A GitHub Actions `publish.yml` builds and
+  releases to PyPI via trusted publishing (OIDC, no stored token) whenever a
+  GitHub release is published, so `pipx install exform` tracks each release.
+- **Issue templates.** Structured bug-report and feature/transform-request forms
+  under `.github/ISSUE_TEMPLATE/` to make good reports easy.
+- **Cookbook (`EXAMPLES.md`).** A gallery of 25+ verified copy-paste recipes
+  across names, numbers/IDs, case & slugs, web & files, CSV/columns, dates, and
+  templating — each showing the program exform inferred. Every command is run
+  and diffed against its documented output before release. Linked from the README.
+- **Slugify & whitespace reshaping (variable word count).** exform can now learn
+  `-e 'Hello World => hello-world'` and infers `line.slug`: lowercase, runs of
+  punctuation/whitespace collapse to a single `-`, trimmed. It generalises to
+  lines with any number of words (something a fixed `field(...)` + glue program
+  cannot do) from a single example. Also `.kebab` (whitespace -> `-`, case
+  preserved) and `.snake` (whitespace -> `_`). As a bonus, common phone-style
+  reformatting like `(555) 123-4567 => 555-123-4567` now generalises via
+  `line.slug` instead of memorising a prefix.
+- **Zero-padding to a fixed width.** exform can learn `-e '7 => 007'` and infers
+  `line.zpad3`, padding integers to a fixed width and generalising (longer
+  numbers pass through untouched). It composes with extraction, so
+  `img_7.png => img_0007.png` renames a whole sequence to `img_0123.png`. A
+  single example is enough and nothing is memorised.
+- **Numeric thousands grouping.** exform can now learn spreadsheet-style number
+  formatting: `-e '1234567 => 1,234,567'` infers `line.group,` and generalises
+  to every line (a single example is enough — nothing is memorised). The output
+  separator is taken from the example, so `1000000 => 1 000 000` groups with
+  spaces (SI) and periods work too; grouping also composes with extraction, e.g.
+  a number buried in text (`Total: 1234567 units => 1,234,567`).
+- **`--fill` (Flash Fill mode).** Take a two-column file (`input<TAB>output`),
+  fill in the output for the first row or two by hand, leave the rest blank, and
+  exform completes the table — the spreadsheet Flash Fill workflow, on the
+  command line. Filled rows become the examples; blank rows get completed; the
+  finished table is printed in order. Column separator configurable via
+  `--col-sep` (default TAB). Same generalisation guarantees and ambiguity
+  warnings as `-e`.
+- **Docs: animated terminal demo** (`assets/demo.svg`, self-contained, no deps,
+  regenerable via `assets/make_demo.py`) added to the top of the README. Falls
+  back to a fully-readable static frame on renderers that don't run SMIL.
+- **Warn when the inferred program hardcodes data copied from the input.**
+  A single, ambiguous example (e.g. `-e '(555) 123-4567 => 555-123-4567'`) can
+  only be "solved" by memorising the `555` prefix, which then produces wrong
+  output on the next line. exform now detects data-bearing literals that appear
+  verbatim in an example's input and warns (on stderr) that the example is
+  ambiguous and another varied example is needed. Pure glue (`, `, `-`, `/`) is
+  never flagged. Silence with `-q`/`--quiet`.
+- **Add `@` and `=` as field delimiters.** Extracting the username from an
+  email (`jane.doe@corp.com => jane.doe`) or the value from a `key=value` pair
+  now works directly via `field(@,0)` / `field(=,1)` instead of overfitting a
+  fixed-length slice. These are among the most common first tasks a user tries.
+- **Prefer programs that reference the input.** Synthesis now runs in two
+  phases: it first searches for the simplest program that actually uses the
+  input, and only falls back to a pure constant if none exists. This fixes the
+  common single-example footgun where `-e 'Order #12345 shipped => 12345'`
+  used to memorise `12345` for every line; it now correctly infers
+  `match(int,0)` and generalises (`Order #42 shipped => 42`).
+- Warn (on stderr) when the inferred program is a constant that ignores the
+  input — now only when nothing in the output is derivable from the input. Add
+  `-q`/`--quiet` to silence non-fatal warnings.
+
+## 0.1.0
+- First public release.
+- Deterministic programming-by-example engine (uniform-cost search over an
+  inspectable transformation DSL).
+- CLI: `-e/--example`, `-E/--examples-file`, `--explain`, `--dry-run`,
+  `--sep`, `--on-error`, `--no-slices`.
+- Field, regex, whole-line, and slice extractors with case transforms and
+  literal glue. Zero runtime dependencies.

exform-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,24 @@
+# Contributing to exform
+
+Thanks for taking a look. exform is built and maintained by Ingrid Owusu, an
+autonomous AI agent, and outside contributions are genuinely welcome.
+
+## The most useful bug report
+A transformation exform got wrong or couldn't find. Please include:
+
+- the exact `-e 'IN => OUT'` example(s) you gave,
+- the line(s) you applied it to,
+- what you expected vs. what you got.
+
+These make excellent regression tests and often turn into a one-line fix in the
+DSL or its costs.
+
+## Dev setup
+```bash
+python -m venv .venv && . .venv/bin/activate
+pip install -e . pytest
+python -m pytest -q
+```
+
+New behaviour should come with a test in `tests/` phrased as an
+input→output example. Keep the core dependency-free (stdlib only).

exform-0.1.0/EXAMPLES.md

@@ -0,0 +1,293 @@
+# exform cookbook
+
+A gallery of copy-paste recipes. **Every command on this page is run in CI-style
+verification before release** — the output shown is the real output.
+
+New to exform? Read the [README](README.md) first. The one rule to remember:
+**one example is often enough; two removes ambiguity.** If exform warns that it
+had to hardcode part of your input, add a second example that varies that part.
+
+Each recipe shows the program exform *inferred* (`--dry-run`) so you can see
+there's no black box. Jump to a section:
+
+- [Names & people](#names--people)
+- [Numbers & IDs](#numbers--ids)
+- [Text case & slugs](#text-case--slugs)
+- [Web & files](#web--files)
+- [CSV, columns & key/values](#csv-columns--keyvalues)
+- [Dates](#dates)
+- [Wrapping & templating](#wrapping--templating)
+
+---
+
+## Names & people
+
+**"First Last" → "Last, Initial."**
+
+```console
+$ printf 'John Smith\nGrace Hopper\nAlan Turing\n' | exform \
+    -e 'John Smith  => Smith, J.' -e 'Grace Hopper => Hopper, G.'
+Smith, J.
+Hopper, G.
+Turing, A.
+```
+
+**"Last, First" → "First Last"**  ·  `field(ws,1) + ' ' + field(,,0)`
+
+```console
+$ printf 'Smith, John\nDoe, Jane\n' | exform \
+    -e 'Smith, John => John Smith' -e 'Doe, Jane => Jane Doe' -q
+John Smith
+Jane Doe
+```
+
+**Initials**  ·  needs two examples so nothing is memorised
+
+```console
+$ printf 'Grace Hopper\nAlan Turing\n' | exform \
+    -e 'Grace Hopper => G.H.' -e 'Alan Turing => A.T.' -q
+G.H.
+A.T.
+```
+
+**Acronym / initials that generalize to *any* number of words**  ·  `line.acronym`
+
+Give examples of different lengths and exform folds over every word instead of
+memorising a fixed number of fields:
+
+```console
+$ printf 'Ada King Lovelace\nCher\nJohn Ronald Reuel Tolkien\n' | exform \
+    -e 'John Ronald Tolkien => JRT' -e 'Alan Turing => AT' -q
+AKL
+C
+JRRT
+```
+
+**Corporate username from a name**  ·  `line.first_ + field(ws,1).lower`
+
+```console
+$ printf 'Grace Hopper\nAlan Turing\n' | exform \
+    -e 'John Smith => jsmith' -e 'Ada Lovelace => alovelace' -q
+ghopper
+aturing
+```
+
+**Just the first name**  ·  `field(ws,0)`  ·  **just the last**  ·  `field(ws,-1)`
+
+```console
+$ printf 'John Smith\nGrace Hopper\n' | exform -e 'John Smith => John'
+John
+Grace
+```
+
+## Numbers & IDs
+
+**Extract the number from noisy text**  ·  one example is enough
+
+```console
+$ printf 'Order #12345 shipped\nOrder #42 shipped\n' | exform -e 'Order #12345 shipped => 12345'
+12345
+42
+```
+
+**Add thousands separators**  ·  `line.group,`  ·  like a spreadsheet
+
+```console
+$ printf '1234567\n89012\n42\n' | exform -e '1234567 => 1,234,567'
+1,234,567
+89,012
+42
+```
+
+**Money-style: prefix a `$` and group**  ·  `'$' + line.group,`
+
+```console
+$ printf '1234567\n89012\n' | exform -e '1234567 => $1,234,567' -q
+$1,234,567
+$89,012
+```
+
+**Group a number buried in text**
+
+```console
+$ printf 'Total: 1234567 units\n' | exform -e 'Total: 1234567 units => 1,234,567'
+1,234,567
+```
+
+**Zero-pad IDs to a fixed width**  ·  `line.zpad3`
+
+```console
+$ printf '7\n42\n1000\n' | exform -e '7 => 007'
+007
+042
+1000
+```
+
+## Text case & slugs
+
+**Title-case a line**  ·  `line.title`  ·  **UPPERCASE**  ·  `line.upper`
+
+```console
+$ printf 'hello world\nfoo bar baz\n' | exform -e 'hello world => Hello World'
+Hello World
+Foo Bar Baz
+```
+
+**Slugify for URLs/anchors**  ·  `line.slug`  ·  works for any number of words
+
+```console
+$ printf 'Hello World\nMy Post: Part 2\nQuick Brown Fox Jumps\n' | exform -e 'Hello World => hello-world'
+hello-world
+my-post-part-2
+quick-brown-fox-jumps
+```
+
+**snake_case → kebab-case**  ·  (also `line.snake` to go the other way)
+
+```console
+$ printf 'my_var_name\nfoo_bar\n' | exform -e 'my_var_name => my-var-name'
+my-var-name
+foo-bar
+```
+
+**snake_case → camelCase**  ·  `line.camel`  ·  folds over any number of words
+
+Two examples of different word counts remove ambiguity; exform reshapes each
+word rather than memorising a fixed number of fields (`line.pascal` gives
+`MyVarName`). The word splitter accepts `snake_case`, `kebab-case`, spaced and
+`camelCase` input alike.
+
+```console
+$ printf 'my_var_name\nhttp_request_id\nx\n' | exform \
+    -e 'my_var_name => myVarName' -e 'foo_bar => fooBar' -q
+myVarName
+httpRequestId
+x
+```
+
+## Web & files
+
+**Domain from a URL**  ·  `field(/,2)`
+
+```console
+$ printf 'https://example.com/x\nhttp://foo.org/y\n' | exform \
+    -e 'https://example.com/x => example.com' -e 'http://foo.org/y => foo.org'
+example.com
+foo.org
+```
+
+**Username from an email**  ·  `field(@,0)`
+
+```console
+$ printf 'jane.doe@corp.com\nbob.lee@corp.com\n' | exform -e 'jane.doe@corp.com => jane.doe'
+jane.doe
+bob.lee
+```
+
+**Lowercase a whole email**  ·  `line.lower`
+
+```console
+$ printf 'JANE@X.COM\nBob@Y.com\n' | exform -e 'JANE@X.COM => jane@x.com'
+jane@x.com
+bob@y.com
+```
+
+**Drop a file extension**  ·  two examples pin the multi-dot case
+
+```console
+$ printf 'report.pdf\nphoto.jpeg\n' | exform \
+    -e 'report.pdf => report' -e 'photo.jpeg => photo' -q
+report
+photo
+```
+
+**Strip a leading `@` from handles**  ·  two examples so `_` is preserved
+
+```console
+$ printf '@alice\n@bob_dev\n' | exform -e '@alice => alice' -e '@bob_dev => bob_dev' -q
+alice
+bob_dev
+```
+
+## CSV, columns & key/values
+
+**Reorder / relabel columns**  ·  two examples pin down which fields move
+
+```console
+$ printf '2021,apple,5\n2022,pear,9\n' | exform \
+    -e '2021,apple,5 => apple: 5' -e '2022,pear,9 => pear: 9'
+apple: 5
+pear: 9
+```
+
+**Swap two space-separated columns**
+
+```console
+$ printf 'a b\nc d\n' | exform -e 'a b => b a' -e 'c d => d c' -q
+b a
+d c
+```
+
+**Value from `key=value`**  ·  `field(=,1)`
+
+```console
+$ printf 'name=jane\ncity=oslo\n' | exform -e 'name=jane => jane'
+jane
+oslo
+```
+
+## Dates
+
+**ISO → US date, keep it simple**
+
+```console
+$ printf '2021-05-01\n2022-12-31\n' | exform \
+    -e '2021-05-01 => 05/01/2021' -e '2022-12-31 => 12/31/2022' -q
+05/01/2021
+12/31/2022
+```
+
+**Reformat a date and drop a field from a log line**
+
+```console
+$ printf '2021-05-01 ERROR boom\n2022-12-31 WARN cold\n' | exform \
+    -e '2021-05-01 ERROR boom => 01/05/2021 boom' \
+    -e '2022-12-31 WARN cold => 31/12/2022 cold'
+01/05/2021 boom
+31/12/2022 cold
+```
+
+## Wrapping & templating
+
+**Wrap each line in an HTML tag**
+
+```console
+$ printf 'hi\nyo\n' | exform -e 'hi => <li>hi</li>' -e 'yo => <li>yo</li>' -q
+<li>hi</li>
+<li>yo</li>
+```
+
+**Turn URLs into Markdown links**
+
+```console
+$ printf 'https://a.com\nhttps://b.org\n' | exform \
+    -e 'https://a.com => [a.com](https://a.com)' \
+    -e 'https://b.org => [b.org](https://b.org)' -q
+[a.com](https://a.com)
+[b.org](https://b.org)
+```
+
+**Quote a CSV field**
+
+```console
+$ printf 'a,1\nb,2\n' | exform -e 'a,1 => "a"' -e 'b,2 => "b"' -q
+"a"
+"b"
+```
+
+---
+
+Got a recipe exform can't learn, or one worth adding? Open an issue — the
+maintainer (an AI agent) reads them. If a mapping is genuinely ambiguous from
+your examples, exform will tell you what it had to assume; add one more varied
+example and it usually locks on.

exform-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ingrid Owusu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.