pare-cli 0.2.0__py3-none-macosx_11_0_arm64.whl

pare_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,405 @@
+Metadata-Version: 2.4
+Name: pare-cli
+Version: 0.2.0
+Classifier: Environment :: Console
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: Utilities
+License-File: LICENSE-MIT
+License-File: LICENSE-APACHE
+License-File: THIRD-PARTY-NOTICES
+Summary: Summarize noisy command output (test runs, builds, logs) to a token budget, for AI agents and humans
+Keywords: logs,summarization,token-budget,ai-agents,cli
+Home-Page: https://github.com/wspires/pare
+License-Expression: MIT OR Apache-2.0
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/wspires/pare
+
+<img src="assets/pare.svg" alt="pare" width="176" height="72">
+
+# pare
+
+A Unix filter that summarizes noisy command output (test runs, builds, logs)
+to fit a token budget, for AI agents and humans. Nothing is lost: the raw
+input is saved to a run file, and the summary ends with what was omitted and
+how to get it back.
+
+```
+pytest -v 2>&1 | pare --budget 2000
+```
+
+A 308-line, 9,523-token pytest run becomes this (1,763 tokens), exactly
+as printed; the last lines name the run file on the machine it ran on:
+
+```
+# pare: 308 lines, 19,046 B (~9,523 tok) → ~1,763 tok (budget 2,000) · 35 templates
+## head (L1–L5)
+1: ============================= test session starts ==============================
+2: platform linux -- Python 3.13.16, pytest-9.1.1, pluggy-1.6.0 -- /home/dev/proj/.venv/bin/python
+3: rootdir: /home/dev/proj
+4: collecting ... collected 170 items
+5: 
+## templates (by salience)
+T17  ×1 E L177: =================================== FAILURES ===================================
+T24  ×5 E <PATH>:<NUM>: <*>
+     e.g. L214: /usr/lib/python3.13/json/decoder.py:363: JSONDecodeError
+T13  ×1 W L171: tests/test_cart.py::test_skipped SKIPPED (flaky on CI)                   [ 97%]
+T14  ×1 W L172: tests/test_cart.py::test_xfail XFAIL (known bug #42)                     [ 98%]
+T19  ×4 S L183: tests/test_cart.py:14:
+T27  ×1 . L218: INFO     app.core:core.py:5 parsing 6 bytes
+T26  ×5 S L216: INFO     app.core:conftest.py:5 fixture setup for test
+T22  ×1 . L196: self = <json.decoder.JSONDecoder object at 0x7f7e97664590>, s = '{"a": '
+T23  ×1 (16 lines) E L197: idx = 0
+210:         except StopIteration as err:
+211: >           raise JSONDecodeError("Expecting value", s, err.value) from None
+212: E           json.decoder.JSONDecodeError: Expecting value: line 1 column 7 (char 6)
+  ┆ (+9 more lines)
+T18  ×5 (21 lines) S ___ <*> ___
+     e.g. L178: ________________________________ test_parse_bad ________________________________
+  ┆ (+2 more lines)
+T21  ×5 (15 lines) . <PATH>:<NUM>: in <*>
+     e.g. L185: app/core.py:6: in parse
+  ┆ (+2 more lines)
+T25  ×6 S --- Captured log <*> ---
+     e.g. L215: ------------------------------ Captured log setup ------------------------------
+## selected lines
+223: >       assert c.total() == 0.9
+224: E       assert 0.9000000000000001 == 0.9
+225: E        +  where 0.9000000000000001 = total()
+226: E        +    where total = <app.core.Cart object at 0x7f7e97197d40>.total
+  ┆ (1 line)
+228: tests/test_cart.py:18: AssertionError
+  ┆ (20 lines)
+249: E       ConnectionRefusedError: [Errno 111] Connection refused
+  ┆ (1 line)
+251: app/core.py:15: ConnectionRefusedError
+  ┆ (20 lines)
+272: E       TimeoutError: timed out
+  ┆ (1 line)
+274: app/core.py:15: TimeoutError
+  ┆ (12 lines)
+287: tests/test_net.py:9: in a
+  ┆ (7 lines)
+295: >   def c(): raise RuntimeError("deep failure at level 3")
+  ┆ (1 line)
+297: E   RuntimeError: deep failure at level 3
+## tail (L285–L308)
+285: tests/test_net.py:12:
+  ┆ (12 lines)
+298: 
+299: tests/test_net.py:11: RuntimeError
+  ┆ (2 lines)
+302: =========================== short test summary info ============================
+303: FAILED tests/test_cart.py::test_parse_bad - json.decoder.JSONDecodeError: Exp...
+304: FAILED tests/test_cart.py::test_total_wrong - assert 0.9000000000000001 == 0.9
+305: FAILED tests/test_net.py::test_connect[127.0.0.1] - ConnectionRefusedError: [...
+306: FAILED tests/test_net.py::test_connect[10.255.255.1] - TimeoutError: timed out
+307: FAILED tests/test_net.py::test_deep - RuntimeError: deep failure at level 3
+308: ============= 5 failed, 163 passed, 1 skipped, 1 xfailed in 0.51s ==============
+## omitted 266/308 lines (86.4%): T5 ×120, T28 ×24, T18 ×16, T21 ×13, T23 ×12, T6 ×10, T7 ×10, T8 ×10, T9 ×10, T20 ×8, T25 ×5, T26 ×4, T12 ×3, T15 ×2, T19 ×2, T10 ×1, T11 ×1, T16 ×1 · 23 templates not listed; 25 blank
+## raw: ~/.cache/pare/runs/d0ec7c06b92d.log
+   expand with: pare --only T<n> < raw   ·   drop noise: pare --except T<n>,T<m> < raw
+```
+
+`pare --only T5 < runfile` then prints the 120 omitted lines of one
+template; `--except`, `--min-severity error` and `--since L200` narrow it
+further.
+
+## Why pare
+
+An agent that runs a test suite or a build gets the whole output back,
+and the part it needs, one failing test with its traceback or the one
+compile error, is a few lines among thousands. The usual cuts lose
+exactly those lines:
+
+- `| tail -50` keeps the verdict and loses the failure above it; `| head`
+  keeps the start. Neither knows where the error is.
+- `| grep -i error` keeps the matching lines without their stack trace or
+  the verdict, and misses tools whose failures say `FAILED` or `panic:`.
+- A harness that truncates long tool output is head and tail applied
+  blindly, with nothing recoverable.
+- The tools' own quiet flags (`pytest -q`, `mvn -q`) cut at the source,
+  each tool in its own way, and a quiet run still prints every failure
+  in full.
+- Asking the model to summarise spends the tokens that were to be saved,
+  and what it leaves out is gone.
+
+pare keeps the lines that differ, counts the shapes that repeat, and
+fits the result to a budget. Three things make it safe to rely on:
+
+- **Nothing is lost.** The input is saved before anything else happens,
+  the ledger names each omitted template with its count, and the flags
+  above pull any of it back.
+- **It is deterministic.** The pipeline has no randomness, so the same
+  input gives the same summary and the same template ids, and a summary
+  can be quoted, diffed and expanded a day later.
+- **It is one filter for every tool.** The signals are structural (log
+  levels, HTTP statuses, exit codes, indentation, stack frames) with a
+  vocabulary on top, so Maven, pytest, Terraform and a JSON log get the
+  same treatment; the tool-specific rules add a few points on one
+  dataset and nothing on the other ([Results](#results)).
+
+Use it for anything whose output can be long and whose failures are the
+point: test suites, builds, linters, package installs, `terraform plan`,
+`kubectl logs`, CI runs. Do not use it for output you need exactly: a
+file you are reading, `git diff`, `grep`, anything you will edit from.
+Source code is not a log either; pare summarises it, pointlessly. A
+binary file (an executable, an image, an archive) gets one line saying
+so, not a summary. Output that already fits the budget passes through
+untouched, so wrapping a short command costs nothing but its run file.
+
+## Install
+
+pare is a single binary with no dependencies. Any of these installs the
+`pare` command (the package is `pare-cli` where `pare` was taken):
+
+```
+brew install wspires/tap/pare                    # macOS and Linux (Homebrew)
+curl -sSfL https://raw.githubusercontent.com/wspires/pare/main/install.sh | sh
+                                                 # macOS and Linux: to ~/.local/bin
+pipx install pare-cli                            # or: uv tool install pare-cli, uvx pare-cli
+cargo binstall pare-cli                          # the release binary, via cargo
+cargo install pare-cli                           # built from source (Rust 1.87+)
+```
+
+Or download an archive for Linux (x86-64 and ARM, statically linked),
+macOS (Apple Silicon and Intel) or Windows from the
+[releases](https://github.com/wspires/pare/releases) page; each has a
+`SHA256SUMS` entry.
+
+Building from a checkout is in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Use
+
+### The budget
+
+The budget is a hard ceiling in tokens on what pare prints. Tokens are
+estimated as bytes / 2.0, the rate measured on pare's output with the
+tokenizer of the current Claude models, through Anthropic's token-count
+API (`--bytes-per-token` changes it: 2.8 is the rate for OpenAI's cl100k
+and o200k tokenizers, and the default until October 2026).
+
+By default the size follows the log (`auto`): output under 4,000
+tokens is printed whole, since on the agent runs a summary of a log
+that size cost a round trip more often than it saved tokens; above
+that pare summarises, and stops once what is left is below error level,
+at most 2,000 tokens. On the latest held-out samples it keeps what a
+fixed 2,000 keeps ([Results](#results)).
+`--budget auto:4000` raises the ceiling (and the pass-through, which is
+twice it); `--budget N` is a fixed budget
+the summary fills (1,000 to 2,000 suits an agent loop; 600 is tight, see
+[Results](#results)). Without
+`--budget`, pare takes `$PARE_BUDGET`, else `auto`, so a harness can set
+it once for every call. `--ascii` writes pare's own marks (`→ · × ┆ …`)
+as ASCII; the log's text is never changed. Details:
+[docs/DESIGN.md](docs/DESIGN.md#tokens-and-the-budget) and
+[docs/USAGE.md](docs/USAGE.md).
+
+### Running the command
+
+`pare -- CMD ARGS` runs the command itself instead of reading a pipe:
+
+```
+pare -- ./gradlew build
+```
+
+The command's exit code survives (a pipe would report pare's), the
+summary ends with the exit status, stdout and stderr are merged in the
+order the command wrote them, and the command is recorded next to the run
+file. `pare stats` totals what commands printed against what pare
+printed, over every run so far.
+
+[integrations/README.md](integrations/README.md) has two ways to route an
+agent's noisy commands through pare: an instruction for `CLAUDE.md` or
+`AGENTS.md`, and a Claude Code hook that rewrites test, build and install
+commands automatically.
+
+### Following a stream
+
+`pare --follow` (or `-f`) summarises input as it arrives: a long build, a
+server log, a `tail -f`. Each window becomes one block in the usual
+format, budgeted on its own:
+
+```
+kubectl logs -f deploy/api | pare -f --budget 600
+```
+
+A window closes after `--every` lines, after `--interval` seconds (30 by
+default), or half a second after a line at `--flush-on` severity
+(default `error`) arrives. A stack trace is never split across windows,
+and template ids are the ones a batch run over the finished run file
+would assign, so every block can be expanded afterwards with `--only`
+and `--since`. Details: [docs/USAGE.md](docs/USAGE.md#follow-mode).
+
+### Run files
+
+Run files live in `~/.cache/pare/runs` (`$PARE_RUN_DIR`). pare prunes
+them itself: runs older than 14 days go, then the oldest until the rest
+fit in 500 MB (`$PARE_RUN_KEEP_DAYS`, `$PARE_RUN_MAX_MB`;
+`$PARE_RUN_PRUNE=off` stops it; `pare prune [--dry-run]` sweeps now). A
+file on standard input (`pare < build.log`) is not copied but read in
+place, and a piped input over the size limit is summarised but not
+kept. Details: [docs/USAGE.md](docs/USAGE.md#run-files).
+
+## Teaching pare your logs
+
+pare needs no configuration: it learns each input's kinds of lines as it
+reads them. What it knows in advance is a vocabulary (error, warning,
+summary and noise words, log-level tokens, the shapes of stack frames)
+which a file can extend for your tools or language:
+
+```
+pare vocab > my.vocab                 # every built-in entry, in file format
+pare --vocab my.vocab ...             # or: export PARE_VOCAB=my.vocab
+```
+
+In the file, `[error]` adds entries to a class and `[error replace]`
+replaces its built-in ones; a plain line is a word or phrase (matched
+whole, case-insensitively) and a `/.../` line a regular expression.
+[reference/vocab.example](reference/vocab.example) adds German.
+
+The `continuation` class says which lines continue the record above
+whatever their indentation, so a stack trace stays one record. pare knows
+Java, JavaScript, Python, rustc and pytest shapes; for others, add
+regexes. A Go panic prints its frames at column 0:
+
+```
+[continuation]
+/^goroutine \d+ \[/
+/^[\w./*()]+\(.*\)$/
+/^\t/
+```
+
+A `[mask NAME]` section turns what its regexes match into `<NAME>` before
+lines are clustered, for ids pare cannot recognize as variable. When a
+tenant name leads each line, every tenant gets a template of its own
+(`acme: nightly sync failed`, `globex: nightly sync failed`, ...); with
+
+```
+[mask TENANT]
+/^[a-z]+(?=:)/
+```
+
+they are one template. Masks run before the built-in ones (timestamps,
+numbers, ...), on the line as written. Template ids depend on the masks,
+so `--only T3` on a saved run file needs the same `--vocab`.
+
+A worked example, from a wrong reading to the entry that fixes it, is in
+[docs/USAGE.md](docs/USAGE.md#adapting-pare-to-a-new-log-format).
+
+Structured logs need nothing either. A JSON line (slog, pino, zap,
+bunyan, structlog) or a logfmt line (`level=error msg="..." err="..."`)
+is recognized on its own, and when it is longer than `--width` pare keeps
+its start and then the fields that say what went wrong (`err`,
+`exception`, `panic`, `stack`, `msg`, ...) instead of cutting them off.
+An escaped stack trace inside a field is shown decoded, as its message
+and the frame nearest it; pino's and bunyan's numeric levels
+(`"level":50`) count as levels. `pare --only T7` prints the whole line.
+
+## How it works
+
+1. **Tee** stdin to a content-hashed run file, in one pass with the steps
+   below: pare keeps a few dozen bytes per line in memory, not the
+   lines, so time is linear in the input and spent as it arrives, and
+   memory stays small ([docs/DESIGN.md](docs/DESIGN.md#performance)).
+2. **Segment** lines into records: indented continuations, stack frames and
+   compiler gutters join the line above.
+3. **Mask** timestamps, IPs, hashes, paths and numbers, then **cluster** the
+   masked head lines into templates with Drain (built in, from
+   [drain3](https://github.com/logpai/Drain3)).
+4. **Score** each line by its structural severity (log level, HTTP status,
+   exit code) and vocabulary (error, warning, summary, frame, pass, noise),
+   and each template by its head line plus its rarity.
+5. **Allocate** the budget: head and tail windows, then one priority queue
+   in which template entries and raw lines compete on the same scale, with
+   diminishing returns for repeats and a hard limit on size.
+6. **End** with a ledger of what was omitted and the run-file path.
+
+Every scoring term survived an ablation; nine that did not were removed.
+The details are in [docs/DESIGN.md](docs/DESIGN.md); the experiments
+behind each rule, in order, in [docs/HISTORY.md](docs/HISTORY.md).
+
+## Results
+
+Recall is the share of must-survive lines (the failing tests, the error
+messages, the verdict) that a tool's output keeps; `bench/run.py`
+measures it. Two kinds of number, reported apart:
+
+**The development corpus** (`corpus/dev/`, nine logs, 1.6 MB: real
+pytest, go test, cargo, make and npm runs, three seeded synthetic logs
+and a synthetic Android logcat), against two other filters written for
+agents: [sqz](https://github.com/ojuschugh1/sqz), which compresses
+output before it reaches the model and deduplicates across a session's
+calls, and [tidyout](https://github.com/sathish-2000/tidyout), which
+wraps a command and strips its output with rules keyed on the command's
+name, passing unknown commands through. Neither takes a budget. The
+misses here were fixed by looking at these cases, so pare's rows are
+training scores.
+
+| tool | output tokens | share of input | lines kept |
+|---|---|---|---|
+| pare 0.2.0, `--budget 2000` | 12,812 | 1.6 % | 99 % |
+| pare 0.2.0, `--budget auto` | 12,388 | 1.5 % | 98 % |
+| pare 0.2.0, `--budget 600` | 5,017 | 0.6 % | 53 % |
+| sqz 1.9.0 | 375,276 | 55 % | 55 % |
+| tidyout 0.2.0 | 411,114 | 60 % | 89 % |
+
+Tokens here are bytes / 2.0, the Claude rate, for every tool. A budget
+is a smaller summary than it was at the old rate (2.8 bytes per token:
+a 2,000 budget was 5,600 bytes and is 4,000), so 600 now keeps about half
+of the must-survive lines where it kept 78 %; 1,000 to 2,000 is the
+working range. (The sqz and tidyout rows were measured in October 2026
+on the eight logs the corpus then had, 683k tokens at this rate, with
+pare 0.1.0 at 100 % and 79.5 % for budgets 2,000 and 600 at the old
+rate; their token counts are restated at 2.0.)
+
+**Held-out samples**, labelled by datasets rather than by anyone working
+on pare: Defects4J bugs (real Java builds, labelled with the failing tests
+and their exceptions) and SWE-bench Verified tasks (real Python test
+runs, labelled with the tests the fix makes pass). Each sample is drawn
+fresh with earlier ones excluded and measured before anyone reads it;
+once a miss has been fixed by looking at it, the sample counts as
+training data and a new one is drawn. The latest, measured blind:
+
+| sample | cases | pare 0.2.0 (600 / 1,000 / 2,000) | `auto` |
+|---|---:|---|---|
+| Defects4J, seed 7 | 16 | 86 / 92 / 100 % | 100 % at 125 % of the tokens of 2,000 |
+| SWE-bench Verified, seed 5 | 17 | 56 / 70 / 100 % | 100 % at 96 % |
+
+`auto` prints more than a fixed 2,000 on the Defects4J sample because
+most of those builds are under 8 KB and pass through whole, which the
+agent runs showed to be cheaper than a summary the agent then expands
+([docs/DESIGN.md](docs/DESIGN.md#automatic-budget)).
+
+Measured at the Claude rate of 2.0 bytes per token, the default since
+29 October 2026; the same samples at the old rate, and the numbers
+before each held-out fix, are in the record. Seven Defects4J and six
+SWE-bench samples so far; the full record, with every miss and what was
+done about it, is in
+[corpus/heldout/README.md](corpus/heldout/README.md). The tool-specific
+rules (pytest markers, rustc gutters, logcat levels) earn several points
+at 600 on SWE-bench and nothing on Defects4J
+([docs/DESIGN.md](docs/DESIGN.md#tool-specific-rules)).
+
+## Contributing
+
+pare is written in Rust. `bench/check.sh` runs what CI runs: the Rust
+tests and lints, the tests of the Python prototype pare began as, kept
+in [reference/](reference/pare.py), the parity check that holds the
+binary to it byte for byte over every log in the repository, and
+packaging; `bench/run.py` is the benchmark. Setting up, the checks, the
+benchmark tools and the repository layout are in
+[CONTRIBUTING.md](CONTRIBUTING.md); what comes next is in
+[ROADMAP.md](ROADMAP.md).
+
+## License
+
+Licensed under either of [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE),
+at your option. The built-in Drain is adapted from
+[drain3](https://github.com/logpai/Drain3) (MIT; see
+[THIRD-PARTY-NOTICES](THIRD-PARTY-NOTICES)). Unless you say otherwise, a
+contribution you submit for inclusion is dual-licensed as above, without
+additional terms.
+

pare_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pare_cli-0.2.0.data/scripts/pare,sha256=cAurT7x0lSmpQAF0CUbCYouN7btaQSfzKWqUoRZWeZg,2886912
+pare_cli-0.2.0.dist-info/METADATA,sha256=2c47NXvTME52iPzYJhxRLdEjpcdb1FQ10VwV23JsYZE,18945
+pare_cli-0.2.0.dist-info/WHEEL,sha256=Fvrs5zUKO4nQbE5Fttn9y8loVOWxn3I3-bRdoW2U0nw,102
+pare_cli-0.2.0.dist-info/licenses/LICENSE-APACHE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pare_cli-0.2.0.dist-info/licenses/LICENSE-MIT,sha256=fWFACeiiIaARKW44nT2jWyuZR9Sw6U4v4Y_ShqDi2LU,1068
+pare_cli-0.2.0.dist-info/licenses/THIRD-PARTY-NOTICES,sha256=fWuhESMcNlGXX7q0nsyRr_IebGfLvr8Chi0q3euSXUI,1325
+pare_cli-0.2.0.dist-info/sboms/pare-cli.cyclonedx.json,sha256=yaKCGv8IqKZ-gHreAGpMX-bpkI0Wjsvq5cscJFU7LeQ,55994
+pare_cli-0.2.0.dist-info/RECORD,,

pare_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.16.0)
+Root-Is-Purelib: false
+Tag: py3-none-macosx_11_0_arm64

pare_cli-0.2.0.dist-info/licenses/LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pare_cli-0.2.0.dist-info/licenses/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wade Spires
+
+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.

pare_cli-0.2.0.dist-info/licenses/THIRD-PARTY-NOTICES

@@ -0,0 +1,28 @@
+Third-party notices
+===================
+
+src/drain.rs (and the Drain class in reference/pare.py) is adapted from the
+core of Drain3 0.9.11, https://github.com/logpai/Drain3, under this license:
+
+MIT License
+
+Copyright (c) 2020-2022 International Business Machines
+and the Drain3 project contributors.
+
+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.